fe_szabab.C
Go to the documentation of this file.
1 // The libMesh Finite Element Library.
2 // Copyright (C) 2002-2014 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
3 
4 // This library is free software; you can redistribute it and/or
5 // modify it under the terms of the GNU Lesser General Public
6 // License as published by the Free Software Foundation; either
7 // version 2.1 of the License, or (at your option) any later version.
8 
9 // This library is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 // Lesser General Public License for more details.
13 
14 // You should have received a copy of the GNU Lesser General Public
15 // License along with this library; if not, write to the Free Software
16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 
18 
19 
20 // Local includes
21 #include "libmesh/libmesh_config.h"
22 #ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
23 
24 #include "libmesh/fe.h"
25 #include "libmesh/elem.h"
26 #include "libmesh/fe_interface.h"
27 
28 namespace libMesh
29 {
30 
31  // ------------------------------------------------------------
32  // Szabo-Babuska-specific implementations, Steffen Petersen 2004
33 
34  // Anonymous namespace for local helper functions
35  namespace {
36 
37  void szabab_nodal_soln(const Elem* elem,
38  const Order order,
39  const std::vector<Number>& elem_soln,
40  std::vector<Number>& nodal_soln,
41  unsigned Dim)
42  {
43  const unsigned int n_nodes = elem->n_nodes();
44 
45  const ElemType elem_type = elem->type();
46 
47  nodal_soln.resize(n_nodes);
48 
49  const Order totalorder = static_cast<Order>(order+elem->p_level());
50 
51  // FEType object to be passed to various FEInterface functions below.
52  FEType fe_type(totalorder, SZABAB);
53 
54  switch (totalorder)
55  {
56  // Constant shape functions
57  case CONSTANT:
58  {
59  libmesh_assert_equal_to (elem_soln.size(), 1);
60 
61  const Number val = elem_soln[0];
62 
63  for (unsigned int n=0; n<n_nodes; n++)
64  nodal_soln[n] = val;
65 
66  return;
67  }
68 
69 
70  // For other bases do interpolation at the nodes
71  // explicitly.
72  case FIRST:
73  case SECOND:
74  case THIRD:
75  case FOURTH:
76  case FIFTH:
77  case SIXTH:
78  case SEVENTH:
79  {
80 
81  const unsigned int n_sf =
82  // FE<Dim,T>::n_shape_functions(elem_type, totalorder);
83  FEInterface::n_shape_functions(Dim, fe_type, elem_type);
84 
85  std::vector<Point> refspace_nodes;
86  FEBase::get_refspace_nodes(elem_type,refspace_nodes);
87  libmesh_assert_equal_to (refspace_nodes.size(), n_nodes);
88 
89  for (unsigned int n=0; n<n_nodes; n++)
90  {
91  libmesh_assert_equal_to (elem_soln.size(), n_sf);
92 
93  // Zero before summation
94  nodal_soln[n] = 0;
95 
96  // u_i = Sum (alpha_i phi_i)
97  for (unsigned int i=0; i<n_sf; i++)
98  nodal_soln[n] += elem_soln[i] *
99  // FE<Dim,T>::shape(elem, order, i, mapped_point);
100  FEInterface::shape(Dim, fe_type, elem, i, refspace_nodes[n]);
101  }
102 
103  return;
104  }
105 
106  default:
107  {
108  libmesh_error();
109  return;
110  }
111  }
112 
113 
114  // We should never get here?
115  libmesh_error();
116  return;
117  } // szabab_nodal_soln()
118 
119 
120 
121 
122  unsigned int szabab_n_dofs(const ElemType t, const Order o)
123  {
124  switch (o)
125  {
126  // Szabo-Babuska 1st-order polynomials.
127  case FIRST:
128  {
129  switch (t)
130  {
131  case NODEELEM:
132  return 1;
133 
134  case EDGE2:
135  case EDGE3:
136  return 2;
137 
138  case TRI6:
139  return 3;
140 
141  case QUAD8:
142  case QUAD9:
143  return 4;
144 
145  default:
146  libmesh_error();
147  }
148  }
149 
150 
151  // Szabo-Babuska 2nd-order polynomials.
152  case SECOND:
153  {
154  switch (t)
155  {
156  case NODEELEM:
157  return 1;
158 
159  case EDGE2:
160  case EDGE3:
161  return 3;
162 
163  case TRI6:
164  return 6;
165 
166  case QUAD8:
167  return 8;
168  case QUAD9:
169  return 9;
170 
171  default:
172  libmesh_error();
173  }
174  }
175 
176 
177  // Szabo-Babuska 3rd-order polynomials.
178  case THIRD:
179  {
180  switch (t)
181  {
182  case NODEELEM:
183  return 1;
184 
185  case EDGE2:
186  case EDGE3:
187  return 4;
188 
189  case TRI6:
190  return 10;
191 
192  case QUAD8:
193  case QUAD9:
194  return 16;
195 
196  default:
197  libmesh_error();
198  }
199  }
200 
201 
202  // Szabo-Babuska 4th-order polynomials.
203  case FOURTH:
204  {
205  switch (t)
206  {
207  case NODEELEM:
208  return 1;
209 
210  case EDGE2:
211  case EDGE3:
212  return 5;
213 
214  case TRI6:
215  return 15;
216 
217  case QUAD8:
218  case QUAD9:
219  return 25;
220 
221  default:
222  libmesh_error();
223  }
224  }
225 
226 
227  // Szabo-Babuska 5th-order polynomials.
228  case FIFTH:
229  {
230  switch (t)
231  {
232  case NODEELEM:
233  return 1;
234 
235  case EDGE2:
236  case EDGE3:
237  return 6;
238 
239  case TRI6:
240  return 21;
241 
242  case QUAD8:
243  case QUAD9:
244  return 36;
245 
246  default:
247  libmesh_error();
248  }
249  }
250 
251 
252  // Szabo-Babuska 6th-order polynomials.
253  case SIXTH:
254  {
255  switch (t)
256  {
257  case NODEELEM:
258  return 1;
259 
260  case EDGE2:
261  case EDGE3:
262  return 7;
263 
264  case TRI6:
265  return 28;
266 
267  case QUAD8:
268  case QUAD9:
269  return 49;
270 
271  default:
272  libmesh_error();
273  }
274  }
275 
276  // Szabo-Babuska 7th-order polynomials.
277  case SEVENTH:
278  {
279  switch (t)
280  {
281  case NODEELEM:
282  return 1;
283 
284  case EDGE2:
285  case EDGE3:
286  return 8;
287 
288  case TRI6:
289  return 36;
290 
291  case QUAD8:
292  case QUAD9:
293  return 64;
294 
295  default:
296  libmesh_error();
297  }
298  }
299 
300 
301  default:
302  {
303  libmesh_error();
304  }
305  }
306 
307  libmesh_error();
308  return 0;
309  } // szabab_n_dofs()
310 
311 
312 
313 
314 
315  unsigned int szabab_n_dofs_at_node(const ElemType t,
316  const Order o,
317  const unsigned int n)
318  {
319  switch (o)
320  {
321  // The first-order Szabo-Babuska shape functions
322  case FIRST:
323  {
324  switch (t)
325  {
326  case NODEELEM:
327  return 1;
328 
329  // The 1D Szabo-Babuska defined on a three-noded edge
330  case EDGE2:
331  case EDGE3:
332  {
333  switch (n)
334  {
335  case 0:
336  case 1:
337  return 1;
338 
339  case 2:
340  return 0;
341 
342  default:
343  libmesh_error();
344  }
345  }
346 
347 
348  // The 2D Szabo-Babuska defined on a 6-noded triangle
349  case TRI6:
350  {
351  switch (n)
352  {
353  case 0:
354  case 1:
355  case 2:
356  return 1;
357 
358  case 3:
359  case 4:
360  case 5:
361  return 0;
362 
363  default:
364  libmesh_error();
365  }
366  }
367 
368 
369  // The 2D tensor-product Szabo-Babuska defined on a
370  // nine-noded quadrilateral.
371  case QUAD8:
372  case QUAD9:
373  {
374  switch (n)
375  {
376  case 0:
377  case 1:
378  case 2:
379  case 3:
380  return 1;
381 
382  case 4:
383  case 5:
384  case 6:
385  case 7:
386  return 0;
387 
388  case 8:
389  return 0;
390 
391  default:
392  libmesh_error();
393  }
394  }
395 
396 
397  default:
398  libmesh_error();
399 
400  }
401  }
402 
403 
404 
405  // The second-order Szabo-Babuska shape functions
406  case SECOND:
407  {
408  switch (t)
409  {
410  case NODEELEM:
411  return 1;
412 
413  // The 1D Szabo-Babuska defined on a three-noded edge
414  case EDGE2:
415  case EDGE3:
416  {
417  switch (n)
418  {
419  case 0:
420  case 1:
421  return 1;
422 
423  case 2:
424  return 1;
425 
426  default:
427  libmesh_error();
428  }
429  }
430 
431 
432  // The 2D Szabo-Babuska defined on a 6-noded triangle
433  case TRI6:
434  {
435  switch (n)
436  {
437  case 0:
438  case 1:
439  case 2:
440  return 1;
441 
442  case 3:
443  case 4:
444  case 5:
445  return 1;
446 
447  default:
448  libmesh_error();
449  }
450  }
451 
452 
453  // The 2D tensor-product Szabo-Babuska defined on a
454  // nine-noded quadrilateral.
455  case QUAD8:
456  case QUAD9:
457  {
458  switch (n)
459  {
460  case 0:
461  case 1:
462  case 2:
463  case 3:
464  return 1;
465 
466  case 4:
467  case 5:
468  case 6:
469  case 7:
470  return 1;
471 
472  case 8:
473  return 1;
474 
475  default:
476  libmesh_error();
477  }
478  }
479 
480 
481  default:
482  libmesh_error();
483 
484  }
485  }
486 
487 
488 
489  // The third-order Szabo-Babuska shape functions
490  case THIRD:
491  {
492  switch (t)
493  {
494  case NODEELEM:
495  return 1;
496 
497  // The 1D Szabo-Babuska defined on a three-noded edge
498  case EDGE2:
499  case EDGE3:
500  {
501  switch (n)
502  {
503  case 0:
504  case 1:
505  return 1;
506 
507  case 2:
508  return 2;
509 
510  default:
511  libmesh_error();
512  }
513  }
514 
515 
516  // The 2D Szabo-Babuska defined on a 6-noded triangle
517  case TRI6:
518  {
519  switch (n)
520  {
521  case 0:
522  case 1:
523  case 2:
524  return 1;
525 
526  case 3:
527  case 4:
528  case 5:
529  return 2;
530 
531  default:
532  libmesh_error();
533  }
534  }
535 
536 
537  // The 2D tensor-product Szabo-Babuska defined on a
538  // nine-noded quadrilateral.
539  case QUAD8:
540  case QUAD9:
541  {
542  switch (n)
543  {
544  case 0:
545  case 1:
546  case 2:
547  case 3:
548  return 1;
549 
550  case 4:
551  case 5:
552  case 6:
553  case 7:
554  return 2;
555 
556  case 8:
557  return 4;
558 
559  default:
560  libmesh_error();
561  }
562  }
563 
564 
565  default:
566  libmesh_error();
567 
568  }
569  }
570 
571 
572 
573  // The fourth-order Szabo-Babuska shape functions
574  case FOURTH:
575  {
576  switch (t)
577  {
578  case NODEELEM:
579  return 1;
580 
581  // The 1D Szabo-Babuska defined on a three-noded edge
582  case EDGE2:
583  case EDGE3:
584  {
585  switch (n)
586  {
587  case 0:
588  case 1:
589  return 1;
590 
591  case 2:
592  return 3;
593 
594  default:
595  libmesh_error();
596  }
597  }
598 
599 
600  // The 2D Szabo-Babuska defined on a 6-noded triangle
601  case TRI6:
602  {
603  switch (n)
604  {
605  case 0:
606  case 1:
607  case 2:
608  return 1;
609 
610  case 3:
611  case 4:
612  case 5:
613  return 3;
614 
615  default:
616  libmesh_error();
617  }
618  }
619 
620 
621  // The 2D tensor-product Szabo-Babuska defined on a
622  // nine-noded quadrilateral.
623  case QUAD8:
624  case QUAD9:
625  {
626  switch (n)
627  {
628  case 0:
629  case 1:
630  case 2:
631  case 3:
632  return 1;
633 
634  case 4:
635  case 5:
636  case 6:
637  case 7:
638  return 3;
639 
640  case 8:
641  return 9;
642 
643  default:
644  libmesh_error();
645  }
646  }
647 
648 
649  default:
650  libmesh_error();
651 
652  }
653  }
654 
655 
656 
657  // The fifth-order Szabo-Babuska shape functions
658  case FIFTH:
659  {
660  switch (t)
661  {
662  case NODEELEM:
663  return 1;
664 
665  // The 1D Szabo-Babuska defined on a three-noded edge
666  case EDGE2:
667  case EDGE3:
668  {
669  switch (n)
670  {
671  case 0:
672  case 1:
673  return 1;
674 
675  case 2:
676  return 4;
677 
678  default:
679  libmesh_error();
680  }
681  }
682 
683 
684  // The 2D Szabo-Babuska defined on a 6-noded triangle
685  case TRI6:
686  {
687  switch (n)
688  {
689  case 0:
690  case 1:
691  case 2:
692  return 1;
693 
694  case 3:
695  case 4:
696  case 5:
697  return 4;
698 
699  default:
700  libmesh_error();
701  }
702  }
703 
704 
705  // The 2D tensor-product Szabo-Babuska defined on a
706  // nine-noded quadrilateral.
707  case QUAD8:
708  case QUAD9:
709  {
710  switch (n)
711  {
712  case 0:
713  case 1:
714  case 2:
715  case 3:
716  return 1;
717 
718  case 4:
719  case 5:
720  case 6:
721  case 7:
722  return 4;
723 
724  case 8:
725  return 16;
726 
727  default:
728  libmesh_error();
729  }
730  }
731 
732 
733  default:
734  libmesh_error();
735 
736  }
737  }
738 
739 
740 
741  // The sixth-order Szabo-Babuska shape functions
742  case SIXTH:
743  {
744  switch (t)
745  {
746  case NODEELEM:
747  return 1;
748 
749  // The 1D Szabo-Babuska defined on a three-noded edge
750  case EDGE2:
751  case EDGE3:
752  {
753  switch (n)
754  {
755  case 0:
756  case 1:
757  return 1;
758 
759  case 2:
760  return 5;
761 
762  default:
763  libmesh_error();
764  }
765  }
766 
767 
768  // The 2D Szabo-Babuska defined on a 6-noded triangle
769  case TRI6:
770  {
771  switch (n)
772  {
773  case 0:
774  case 1:
775  case 2:
776  return 1;
777 
778  case 3:
779  case 4:
780  case 5:
781  return 5;
782 
783  default:
784  libmesh_error();
785  }
786  }
787 
788 
789  // The 2D tensor-product Szabo-Babuska defined on a
790  // nine-noded quadrilateral.
791  case QUAD8:
792  case QUAD9:
793  {
794  switch (n)
795  {
796  case 0:
797  case 1:
798  case 2:
799  case 3:
800  return 1;
801 
802  case 4:
803  case 5:
804  case 6:
805  case 7:
806  return 5;
807 
808  case 8:
809  return 25;
810 
811  default:
812  libmesh_error();
813  }
814  }
815 
816 
817  default:
818  libmesh_error();
819 
820  }
821  }
822 
823 
824  // The seventh-order Szabo-Babuska shape functions
825  case SEVENTH:
826  {
827  switch (t)
828  {
829  case NODEELEM:
830  return 1;
831 
832  // The 1D Szabo-Babuska defined on a three-noded edge
833  case EDGE2:
834  case EDGE3:
835  {
836  switch (n)
837  {
838  case 0:
839  case 1:
840  return 1;
841 
842  case 2:
843  return 6;
844 
845  default:
846  libmesh_error();
847  }
848  }
849 
850 
851  // The 2D Szabo-Babuska defined on a 6-noded triangle
852  case TRI6:
853  {
854  switch (n)
855  {
856  case 0:
857  case 1:
858  case 2:
859  return 1;
860 
861  case 3:
862  case 4:
863  case 5:
864  return 6;
865 
866  default:
867  libmesh_error();
868  }
869  }
870 
871 
872  // The 2D tensor-product Szabo-Babuska defined on a
873  // nine-noded quadrilateral.
874  case QUAD8:
875  case QUAD9:
876  {
877  switch (n)
878  {
879  case 0:
880  case 1:
881  case 2:
882  case 3:
883  return 1;
884 
885  case 4:
886  case 5:
887  case 6:
888  case 7:
889  return 6;
890 
891  case 8:
892  return 36;
893 
894  default:
895  libmesh_error();
896  }
897  }
898 
899 
900  default:
901  libmesh_error();
902 
903  }
904  }
905 
906 
907  default:
908  {
909  libmesh_error();
910  }
911  }
912 
913  libmesh_error();
914 
915  return 0;
916  } // szabab_n_dofs_at_node()
917 
918 
919 
920  unsigned int szabab_n_dofs_per_elem(const ElemType t, const Order o)
921  {
922  switch (o)
923  {
924  // The first-order Szabo-Babuska shape functions
925  case FIRST:
926  {
927  switch (t)
928  {
929  case NODEELEM:
930  return 0;
931 
932  // The 1D Szabo-Babuska defined on a two-noded edge
933  case EDGE2:
934  return 0;
935 
936  // The 1D Szabo-Babuska defined on a three-noded edge
937  case EDGE3:
938  return 0;
939 
940  // The 2D Szabo-Babuska defined on a 6-noded triangle
941  case TRI6:
942  return 0;
943 
944  // The 2D tensor-product Szabo-Babuska defined on a
945  // nine-noded quadrilateral.
946  case QUAD8:
947  return 0;
948 
949  // The 2D tensor-product Szabo-Babuska defined on a
950  // nine-noded quadrilateral.
951 
952  case QUAD9:
953  return 0;
954 
955 
956  default:
957  libmesh_error();
958 
959  }
960  }
961 
962 
963 
964  // The second-order Szabo-Babuska shape functions
965  case SECOND:
966  {
967  switch (t)
968  {
969  case NODEELEM:
970  return 0;
971 
972  // The 1D Szabo-Babuska defined on a two-noded edge
973  case EDGE2:
974  return 1;
975 
976  // The 1D Szabo-Babuska defined on a three-noded edge
977  case EDGE3:
978  return 0;
979 
980  // The 2D Szabo-Babuska defined on a 6-noded triangle
981  case TRI6:
982  return 0;
983 
984  // The 2D tensor-product Szabo-Babuska defined on a
985  // eight-noded quadrilateral.
986  case QUAD8:
987  return 0;
988 
989  // The 2D tensor-product Szabo-Babuska defined on a
990  // nine-noded quadrilateral.
991  case QUAD9:
992  return 0;
993 
994 
995  default:
996  libmesh_error();
997 
998  }
999  }
1000 
1001 
1002 
1003  // The third-order Szabo-Babuska shape functions
1004  case THIRD:
1005  {
1006  switch (t)
1007  {
1008  case NODEELEM:
1009  return 0;
1010 
1011  // The 1D Szabo-Babuska defined on a two-noded edge
1012  case EDGE2:
1013  return 2;
1014 
1015  // The 1D Szabo-Babuska defined on a three-noded edge
1016  case EDGE3:
1017  return 0;
1018 
1019  // The 2D Szabo-Babuska defined on a 6-noded triangle
1020  case TRI6:
1021  return 1;
1022 
1023  // The 2D tensor-product Szabo-Babuska defined on a
1024  // eight-noded quadrilateral.
1025  case QUAD8:
1026  return 4;
1027 
1028  // The 2D tensor-product Szabo-Babuska defined on a
1029  // nine-noded quadrilateral.
1030  case QUAD9:
1031  return 0;
1032 
1033 
1034  default:
1035  libmesh_error();
1036 
1037  }
1038  }
1039 
1040 
1041 
1042  // The fourth-order Szabo-Babuska shape functions
1043  case FOURTH:
1044  {
1045  switch (t)
1046  {
1047  case NODEELEM:
1048  return 0;
1049 
1050  // The 1D Szabo-Babuska defined on a two-noded edge
1051  case EDGE2:
1052  return 3;
1053 
1054  // The 1D Szabo-Babuska defined on a three-noded edge
1055  case EDGE3:
1056  return 0;
1057 
1058  // The 2D Szabo-Babuska defined on a 6-noded triangle
1059  case TRI6:
1060  return 3;
1061 
1062  // The 2D tensor-product Szabo-Babuska defined on a
1063  // eight-noded quadrilateral.
1064  case QUAD8:
1065  return 9;
1066 
1067  // The 2D tensor-product Szabo-Babuska defined on a
1068  // nine-noded quadrilateral.
1069  case QUAD9:
1070  return 0;
1071 
1072 
1073  default:
1074  libmesh_error();
1075 
1076  }
1077  }
1078 
1079 
1080 
1081  // The fifth-order Szabo-Babuska shape functions
1082  case FIFTH:
1083  {
1084  switch (t)
1085  {
1086  case NODEELEM:
1087  return 0;
1088 
1089  // The 1D Szabo-Babuska defined on a two-noded edge
1090  case EDGE2:
1091  return 4;
1092 
1093  // The 1D Szabo-Babuska defined on a three-noded edge
1094  case EDGE3:
1095  return 0;
1096 
1097  // The 2D Szabo-Babuska defined on a 6-noded triangle
1098  case TRI6:
1099  return 6;
1100 
1101  // The 2D tensor-product Szabo-Babuska defined on a
1102  // eight-noded quadrilateral.
1103  case QUAD8:
1104  return 16;
1105 
1106  // The 2D tensor-product Szabo-Babuska defined on a
1107  // nine-noded quadrilateral.
1108  case QUAD9:
1109  return 0;
1110 
1111 
1112  default:
1113  libmesh_error();
1114 
1115  }
1116  }
1117 
1118 
1119  // The sixth-order Szabo-Babuska shape functions
1120  case SIXTH:
1121  {
1122  switch (t)
1123  {
1124  case NODEELEM:
1125  return 0;
1126 
1127  // The 1D Szabo-Babuska defined on a two-noded edge
1128  case EDGE2:
1129  return 5;
1130 
1131  // The 1D Szabo-Babuska defined on a three-noded edge
1132  case EDGE3:
1133  return 0;
1134 
1135  // The 2D Szabo-Babuska defined on a 6-noded triangle
1136  case TRI6:
1137  return 10;
1138 
1139  // The 2D tensor-product Szabo-Babuska defined on a
1140  // eight-noded quadrilateral.
1141  case QUAD8:
1142  return 25;
1143 
1144  // The 2D tensor-product Szabo-Babuska defined on a
1145  // nine-noded quadrilateral.
1146  case QUAD9:
1147  return 0;
1148 
1149 
1150  default:
1151  libmesh_error();
1152 
1153  }
1154  }
1155 
1156 
1157  // The seventh-order Szabo-Babuska shape functions
1158  case SEVENTH:
1159  {
1160  switch (t)
1161  {
1162  case NODEELEM:
1163  return 0;
1164 
1165  // The 1D Szabo-Babuska defined on a two-noded edge
1166  case EDGE2:
1167  return 6;
1168 
1169  // The 1D Szabo-Babuska defined on a three-noded edge
1170  case EDGE3:
1171  return 0;
1172 
1173  // The 2D Szabo-Babuska defined on a 6-noded triangle
1174  case TRI6:
1175  return 15;
1176 
1177  // The 2D tensor-product Szabo-Babuska defined on a
1178  // eight-noded quadrilateral.
1179  case QUAD8:
1180  return 36;
1181 
1182  // The 2D tensor-product Szabo-Babuska defined on a
1183  // nine-noded quadrilateral.
1184  case QUAD9:
1185  return 0;
1186 
1187 
1188  default:
1189  libmesh_error();
1190 
1191  }
1192  }
1193 
1194 
1195  // Otherwise no DOFS per element
1196  default:
1197  return 0;
1198  }
1199  } // szabab_n_dofs_per_elem
1200 
1201  } // anonymous namespace
1202 
1203 
1204 
1205 
1206  // Do full-specialization of nodal_soln() function for every
1207  // dimension, instead of explicit instantiation at the end of this
1208  // file.
1209  // This could be macro-ified so that it fits on one line...
1210  template <>
1211  void FE<0,SZABAB>::nodal_soln(const Elem* elem,
1212  const Order order,
1213  const std::vector<Number>& elem_soln,
1214  std::vector<Number>& nodal_soln)
1215  { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }
1216 
1217  template <>
1218  void FE<1,SZABAB>::nodal_soln(const Elem* elem,
1219  const Order order,
1220  const std::vector<Number>& elem_soln,
1221  std::vector<Number>& nodal_soln)
1222  { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }
1223 
1224  template <>
1225  void FE<2,SZABAB>::nodal_soln(const Elem* elem,
1226  const Order order,
1227  const std::vector<Number>& elem_soln,
1228  std::vector<Number>& nodal_soln)
1229  { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }
1230 
1231  template <>
1232  void FE<3,SZABAB>::nodal_soln(const Elem* elem,
1233  const Order order,
1234  const std::vector<Number>& elem_soln,
1235  std::vector<Number>& nodal_soln)
1236  { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }
1237 
1238 
1239  // Full specialization of n_dofs() function for every dimension
1240  template <> unsigned int FE<0,SZABAB>::n_dofs(const ElemType t, const Order o) { return szabab_n_dofs(t, o); }
1241  template <> unsigned int FE<1,SZABAB>::n_dofs(const ElemType t, const Order o) { return szabab_n_dofs(t, o); }
1242  template <> unsigned int FE<2,SZABAB>::n_dofs(const ElemType t, const Order o) { return szabab_n_dofs(t, o); }
1243  template <> unsigned int FE<3,SZABAB>::n_dofs(const ElemType t, const Order o) { return szabab_n_dofs(t, o); }
1244 
1245  // Full specialization of n_dofs_at_node() function for every dimension.
1246  template <> unsigned int FE<0,SZABAB>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return szabab_n_dofs_at_node(t, o, n); }
1247  template <> unsigned int FE<1,SZABAB>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return szabab_n_dofs_at_node(t, o, n); }
1248  template <> unsigned int FE<2,SZABAB>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return szabab_n_dofs_at_node(t, o, n); }
1249  template <> unsigned int FE<3,SZABAB>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return szabab_n_dofs_at_node(t, o, n); }
1250 
1251  // Full specialization of n_dofs_per_elem() function for every dimension.
1252  template <> unsigned int FE<0,SZABAB>::n_dofs_per_elem(const ElemType t, const Order o) { return szabab_n_dofs_per_elem(t, o); }
1253  template <> unsigned int FE<1,SZABAB>::n_dofs_per_elem(const ElemType t, const Order o) { return szabab_n_dofs_per_elem(t, o); }
1254  template <> unsigned int FE<2,SZABAB>::n_dofs_per_elem(const ElemType t, const Order o) { return szabab_n_dofs_per_elem(t, o); }
1255  template <> unsigned int FE<3,SZABAB>::n_dofs_per_elem(const ElemType t, const Order o) { return szabab_n_dofs_per_elem(t, o); }
1256 
1257  // Szabab FEMs are C^0 continuous
1258  template <> FEContinuity FE<0,SZABAB>::get_continuity() const { return C_ZERO; }
1259  template <> FEContinuity FE<1,SZABAB>::get_continuity() const { return C_ZERO; }
1260  template <> FEContinuity FE<2,SZABAB>::get_continuity() const { return C_ZERO; }
1261  template <> FEContinuity FE<3,SZABAB>::get_continuity() const { return C_ZERO; }
1262 
1263  // Szabab FEMs are hierarchic
1264  template <> bool FE<0,SZABAB>::is_hierarchic() const { return true; }
1265  template <> bool FE<1,SZABAB>::is_hierarchic() const { return true; }
1266  template <> bool FE<2,SZABAB>::is_hierarchic() const { return true; }
1267  template <> bool FE<3,SZABAB>::is_hierarchic() const { return true; }
1268 
1269 #ifdef LIBMESH_ENABLE_AMR
1270  // compute_constraints() specializations are only needed for 2 and 3D
1271  template <>
1273  DofMap &dof_map,
1274  const unsigned int variable_number,
1275  const Elem* elem)
1276  { compute_proj_constraints(constraints, dof_map, variable_number, elem); }
1277 
1278  template <>
1280  DofMap &dof_map,
1281  const unsigned int variable_number,
1282  const Elem* elem)
1283  { compute_proj_constraints(constraints, dof_map, variable_number, elem); }
1284 #endif // #ifdef LIBMESH_ENABLE_AMR
1285 
1286  // Szabab shapes need reinit only for approximation orders >= 3,
1287  // but we might reach that with p refinement
1288  template <> bool FE<0,SZABAB>::shapes_need_reinit() const { return true; }
1289  template <> bool FE<1,SZABAB>::shapes_need_reinit() const { return true; }
1290  template <> bool FE<2,SZABAB>::shapes_need_reinit() const { return true; }
1291  template <> bool FE<3,SZABAB>::shapes_need_reinit() const { return true; }
1292 
1293 } // namespace libMesh
1294 
1295 #endif //LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

Site Created By: libMesh Developers
Last modified: February 07 2014 16:57:05 UTC

Hosted By:
SourceForge.net Logo