fe_interface_inf_fe.C
Go to the documentation of this file.00001 // The libMesh Finite Element Library. 00002 // Copyright (C) 2002-2012 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner 00003 00004 // This library is free software; you can redistribute it and/or 00005 // modify it under the terms of the GNU Lesser General Public 00006 // License as published by the Free Software Foundation; either 00007 // version 2.1 of the License, or (at your option) any later version. 00008 00009 // This library is distributed in the hope that it will be useful, 00010 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00011 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00012 // Lesser General Public License for more details. 00013 00014 // You should have received a copy of the GNU Lesser General Public 00015 // License along with this library; if not, write to the Free Software 00016 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00017 00018 00019 00020 // Local includes 00021 #include "libmesh/libmesh_config.h" 00022 00023 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS 00024 00025 #include "libmesh/fe_interface.h" 00026 #include "libmesh/inf_fe.h" 00027 00028 namespace libMesh 00029 { 00030 00031 00032 00033 00034 //------------------------------------------------------------ 00035 //FEInterface class members handling calls to InfFE 00036 00037 00038 00039 unsigned int FEInterface::ifem_n_shape_functions(const unsigned int dim, 00040 const FEType& fe_t, 00041 const ElemType t) 00042 { 00043 switch (dim) 00044 { 00045 // 1D 00046 case 1: 00047 /* 00048 * Since InfFE<Dim,T_radial,T_map>::n_shape_functions(...) 00049 * is actually independent of T_radial and T_map, we can use 00050 * just any T_radial and T_map 00051 */ 00052 return InfFE<1,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t); 00053 00054 // 2D 00055 case 2: 00056 return InfFE<2,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t); 00057 00058 // 3D 00059 case 3: 00060 return InfFE<3,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t); 00061 00062 default: 00063 libmesh_error(); 00064 } 00065 00066 00067 libmesh_error(); 00068 return 0; 00069 } 00070 00071 00072 00073 00074 00075 unsigned int FEInterface::ifem_n_dofs(const unsigned int dim, 00076 const FEType& fe_t, 00077 const ElemType t) 00078 { 00079 switch (dim) 00080 { 00081 // 1D 00082 case 1: 00083 /* 00084 * Since InfFE<Dim,T_radial,T_map>::n_dofs(...) 00085 * is actually independent of T_radial and T_map, we can use 00086 * just any T_radial and T_map 00087 */ 00088 return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t); 00089 00090 // 2D 00091 case 2: 00092 return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t); 00093 00094 // 3D 00095 case 3: 00096 return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t); 00097 00098 default: 00099 libmesh_error(); 00100 } 00101 00102 00103 libmesh_error(); 00104 return 0; 00105 } 00106 00107 00108 00109 00110 unsigned int FEInterface::ifem_n_dofs_at_node(const unsigned int dim, 00111 const FEType& fe_t, 00112 const ElemType t, 00113 const unsigned int n) 00114 { 00115 switch (dim) 00116 { 00117 // 1D 00118 case 1: 00119 /* 00120 * Since InfFE<Dim,T_radial,T_map>::n_dofs_at_node(...) 00121 * is actually independent of T_radial and T_map, we can use 00122 * just any T_radial and T_map 00123 */ 00124 return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n); 00125 00126 // 2D 00127 case 2: 00128 return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n); 00129 00130 // 3D 00131 case 3: 00132 return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n); 00133 00134 default: 00135 libmesh_error(); 00136 } 00137 00138 00139 libmesh_error(); 00140 return 0; 00141 } 00142 00143 00144 00145 00146 00147 unsigned int FEInterface::ifem_n_dofs_per_elem(const unsigned int dim, 00148 const FEType& fe_t, 00149 const ElemType t) 00150 { 00151 switch (dim) 00152 { 00153 // 1D 00154 case 1: 00155 /* 00156 * Since InfFE<Dim,T_radial,T_map>::n_dofs(...) 00157 * is actually independent of T_radial and T_map, we can use 00158 * just any T_radial and T_map 00159 */ 00160 return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t); 00161 00162 // 2D 00163 case 2: 00164 return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t); 00165 00166 // 3D 00167 case 3: 00168 return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t); 00169 00170 default: 00171 libmesh_error(); 00172 } 00173 00174 00175 libmesh_error(); 00176 return 0; 00177 } 00178 00179 00180 00181 00182 void FEInterface::ifem_nodal_soln(const unsigned int dim, 00183 const FEType& fe_t, 00184 const Elem* elem, 00185 const std::vector<Number>& elem_soln, 00186 std::vector<Number>& nodal_soln) 00187 { 00188 switch (dim) 00189 { 00190 00191 // 1D 00192 case 1: 00193 { 00194 switch (fe_t.radial_family) 00195 { 00196 case INFINITE_MAP: 00197 { 00198 libMesh::err << "ERROR: INFINTE_MAP is not a valid shape family for radial approximation." << std::endl; 00199 libmesh_error(); 00200 break; 00201 } 00202 00203 case JACOBI_20_00: 00204 { 00205 switch (fe_t.inf_map) 00206 { 00207 case CARTESIAN: 00208 { 00209 InfFE<1,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00210 break; 00211 } 00212 default: 00213 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00214 libmesh_error(); 00215 } 00216 break; 00217 } 00218 00219 case JACOBI_30_00: 00220 { 00221 switch (fe_t.inf_map) 00222 { 00223 case CARTESIAN: 00224 { 00225 InfFE<1,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00226 break; 00227 } 00228 default: 00229 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00230 libmesh_error(); 00231 } 00232 break; 00233 } 00234 00235 case LEGENDRE: 00236 { 00237 switch (fe_t.inf_map) 00238 { 00239 case CARTESIAN: 00240 { 00241 InfFE<1,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00242 break; 00243 } 00244 default: 00245 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00246 libmesh_error(); 00247 } 00248 break; 00249 } 00250 00251 case LAGRANGE: 00252 { 00253 switch (fe_t.inf_map) 00254 { 00255 case CARTESIAN: 00256 { 00257 InfFE<1,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00258 break; 00259 } 00260 default: 00261 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00262 libmesh_error(); 00263 } 00264 break; 00265 } 00266 00267 00268 00269 default: 00270 libMesh::err << "ERROR: Bad FEType.radial_family= " << fe_t.radial_family << std::endl; 00271 libmesh_error(); 00272 break; 00273 } 00274 00275 break; 00276 } 00277 00278 00279 00280 00281 // 2D 00282 case 2: 00283 { 00284 switch (fe_t.radial_family) 00285 { 00286 case INFINITE_MAP: 00287 { 00288 libMesh::err << "ERROR: INFINTE_MAP is not a valid shape family for radial approximation." << std::endl; 00289 libmesh_error(); 00290 break; 00291 } 00292 00293 case JACOBI_20_00: 00294 { 00295 switch (fe_t.inf_map) 00296 { 00297 case CARTESIAN: 00298 { 00299 InfFE<2,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00300 break; 00301 } 00302 default: 00303 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00304 libmesh_error(); 00305 } 00306 break; 00307 } 00308 00309 case JACOBI_30_00: 00310 { 00311 switch (fe_t.inf_map) 00312 { 00313 case CARTESIAN: 00314 { 00315 InfFE<2,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00316 break; 00317 } 00318 default: 00319 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00320 libmesh_error(); 00321 } 00322 break; 00323 } 00324 00325 case LEGENDRE: 00326 { 00327 switch (fe_t.inf_map) 00328 { 00329 case CARTESIAN: 00330 { 00331 InfFE<2,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00332 break; 00333 } 00334 default: 00335 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00336 libmesh_error(); 00337 } 00338 break; 00339 } 00340 00341 case LAGRANGE: 00342 { 00343 switch (fe_t.inf_map) 00344 { 00345 case CARTESIAN: 00346 { 00347 InfFE<2,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00348 break; 00349 } 00350 default: 00351 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00352 libmesh_error(); 00353 } 00354 break; 00355 } 00356 00357 00358 00359 default: 00360 libMesh::err << "ERROR: Bad FEType.radial_family= " << fe_t.radial_family << std::endl; 00361 libmesh_error(); 00362 break; 00363 } 00364 00365 break; 00366 } 00367 00368 00369 00370 00371 // 3D 00372 case 3: 00373 { 00374 switch (fe_t.radial_family) 00375 { 00376 case INFINITE_MAP: 00377 { 00378 libMesh::err << "ERROR: INFINTE_MAP is not a valid shape family for radial approximation." << std::endl; 00379 libmesh_error(); 00380 break; 00381 } 00382 00383 case JACOBI_20_00: 00384 { 00385 switch (fe_t.inf_map) 00386 { 00387 case CARTESIAN: 00388 { 00389 InfFE<3,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00390 break; 00391 } 00392 default: 00393 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00394 libmesh_error(); 00395 } 00396 break; 00397 } 00398 00399 case JACOBI_30_00: 00400 { 00401 switch (fe_t.inf_map) 00402 { 00403 case CARTESIAN: 00404 { 00405 InfFE<3,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00406 break; 00407 } 00408 default: 00409 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00410 libmesh_error(); 00411 } 00412 break; 00413 } 00414 00415 case LEGENDRE: 00416 { 00417 switch (fe_t.inf_map) 00418 { 00419 case CARTESIAN: 00420 { 00421 InfFE<3,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00422 break; 00423 } 00424 default: 00425 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00426 libmesh_error(); 00427 } 00428 break; 00429 } 00430 00431 case LAGRANGE: 00432 { 00433 switch (fe_t.inf_map) 00434 { 00435 case CARTESIAN: 00436 { 00437 InfFE<3,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln); 00438 break; 00439 } 00440 default: 00441 libMesh::err << "ERROR: Spherical & Ellipsoidal IFEMs not implemented." << std::endl; 00442 libmesh_error(); 00443 } 00444 break; 00445 } 00446 00447 00448 00449 default: 00450 libMesh::err << "ERROR: Bad FEType.radial_family= " << fe_t.radial_family << std::endl; 00451 libmesh_error(); 00452 break; 00453 } 00454 00455 break; 00456 } 00457 00458 default: 00459 libmesh_error(); 00460 } 00461 return; 00462 } 00463 00464 00465 00466 00467 00468 00469 00470 Point FEInterface::ifem_inverse_map (const unsigned int dim, 00471 const FEType& fe_t, 00472 const Elem* elem, 00473 const Point& p, 00474 const Real tolerance, 00475 const bool secure) 00476 { 00477 switch (dim) 00478 { 00479 // 1D 00480 case 1: 00481 { 00482 switch (fe_t.inf_map) 00483 { 00484 case CARTESIAN: 00485 return InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure); 00486 00487 case SPHERICAL: 00488 case ELLIPSOIDAL: 00489 { 00490 libMesh::err << "ERROR: Spherical and Ellipsoidal IFEMs not (yet) " << std::endl 00491 << "implemented." << std::endl; 00492 libmesh_error(); 00493 } 00494 00495 /* 00496 case SPHERICAL: 00497 return InfFE<1,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance); 00498 00499 case ELLIPSOIDAL: 00500 return InfFE<1,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance); 00501 */ 00502 00503 default: 00504 libmesh_error(); 00505 } 00506 } 00507 00508 00509 // 2D 00510 case 2: 00511 { 00512 switch (fe_t.inf_map) 00513 { 00514 case CARTESIAN: 00515 return InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure); 00516 00517 case SPHERICAL: 00518 case ELLIPSOIDAL: 00519 { 00520 libMesh::err << "ERROR: Spherical and Ellipsoidal IFEMs not (yet) " << std::endl 00521 << "implemented." << std::endl; 00522 libmesh_error(); 00523 } 00524 00525 /* 00526 case SPHERICAL: 00527 return InfFE<2,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance); 00528 00529 case ELLIPSOIDAL: 00530 return InfFE<2,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance); 00531 */ 00532 00533 default: 00534 libmesh_error(); 00535 } 00536 00537 } 00538 00539 00540 // 3D 00541 case 3: 00542 { 00543 switch (fe_t.inf_map) 00544 { 00545 case CARTESIAN: 00546 return InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure); 00547 00548 case SPHERICAL: 00549 case ELLIPSOIDAL: 00550 { 00551 libMesh::err << "ERROR: Spherical and Ellipsoidal IFEMs not (yet) " << std::endl 00552 << "implemented." << std::endl; 00553 libmesh_error(); 00554 } 00555 00556 /* 00557 case SPHERICAL: 00558 return InfFE<3,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance); 00559 00560 case ELLIPSOIDAL: 00561 return InfFE<3,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance); 00562 */ 00563 00564 default: 00565 libmesh_error(); 00566 } 00567 00568 } 00569 00570 00571 default: 00572 libmesh_error(); 00573 } 00574 00575 00576 libmesh_error(); 00577 Point pt; 00578 return pt; 00579 } 00580 00581 00582 00583 void FEInterface::ifem_inverse_map (const unsigned int dim, 00584 const FEType& fe_t, 00585 const Elem* elem, 00586 const std::vector<Point>& physical_points, 00587 std::vector<Point>& reference_points, 00588 const Real tolerance, 00589 const bool secure) 00590 { 00591 switch (dim) 00592 { 00593 // 1D 00594 case 1: 00595 { 00596 switch (fe_t.inf_map) 00597 { 00598 case CARTESIAN: 00599 InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure); 00600 return; 00601 00602 default: 00603 libmesh_error(); 00604 } 00605 } 00606 00607 00608 // 2D 00609 case 2: 00610 { 00611 switch (fe_t.inf_map) 00612 { 00613 case CARTESIAN: 00614 InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure); 00615 return; 00616 00617 default: 00618 libmesh_error(); 00619 } 00620 00621 } 00622 00623 00624 // 3D 00625 case 3: 00626 { 00627 switch (fe_t.inf_map) 00628 { 00629 case CARTESIAN: 00630 InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure); 00631 return; 00632 00633 default: 00634 libmesh_error(); 00635 } 00636 00637 } 00638 00639 00640 default: 00641 libmesh_error(); 00642 } 00643 00644 libmesh_error(); 00645 return; 00646 } 00647 00648 00649 00650 00651 bool FEInterface::ifem_on_reference_element(const Point& p, 00652 const ElemType t, 00653 const Real eps) 00654 { 00655 return FEBase::on_reference_element(p,t,eps); 00656 } 00657 00658 00659 00660 00661 Real FEInterface::ifem_shape(const unsigned int dim, 00662 const FEType& fe_t, 00663 const ElemType t, 00664 const unsigned int i, 00665 const Point& p) 00666 { 00667 switch (dim) 00668 { 00669 // 1D 00670 case 1: 00671 { 00672 switch (fe_t.radial_family) 00673 { 00674 /* 00675 * For no derivatives (and local coordinates, as 00676 * given in \p p) the infinite element shapes 00677 * are independent of mapping type 00678 */ 00679 case INFINITE_MAP: 00680 return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p); 00681 00682 case JACOBI_20_00: 00683 return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p); 00684 00685 case JACOBI_30_00: 00686 return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p); 00687 00688 case LEGENDRE: 00689 return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p); 00690 00691 case LAGRANGE: 00692 return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p); 00693 00694 default: 00695 libmesh_error(); 00696 } 00697 } 00698 00699 00700 // 2D 00701 case 2: 00702 { 00703 switch (fe_t.radial_family) 00704 { 00705 case INFINITE_MAP: 00706 return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p); 00707 00708 case JACOBI_20_00: 00709 return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p); 00710 00711 case JACOBI_30_00: 00712 return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p); 00713 00714 case LEGENDRE: 00715 return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p); 00716 00717 case LAGRANGE: 00718 return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p); 00719 00720 default: 00721 libmesh_error(); 00722 } 00723 00724 } 00725 00726 00727 // 3D 00728 case 3: 00729 { 00730 switch (fe_t.radial_family) 00731 { 00732 case INFINITE_MAP: 00733 return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p); 00734 00735 case JACOBI_20_00: 00736 return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p); 00737 00738 case JACOBI_30_00: 00739 return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p); 00740 00741 case LEGENDRE: 00742 return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p); 00743 00744 case LAGRANGE: 00745 return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p); 00746 00747 default: 00748 libmesh_error(); 00749 } 00750 00751 } 00752 00753 00754 default: 00755 libmesh_error(); 00756 } 00757 00758 00759 libmesh_error(); 00760 return 0.; 00761 } 00762 00763 00764 00765 00766 Real FEInterface::ifem_shape(const unsigned int dim, 00767 const FEType& fe_t, 00768 const Elem* elem, 00769 const unsigned int i, 00770 const Point& p) 00771 { 00772 switch (dim) 00773 { 00774 // 1D 00775 case 1: 00776 { 00777 switch (fe_t.radial_family) 00778 { 00779 /* 00780 * For no derivatives (and local coordinates, as 00781 * given in \p p) the infinite element shapes 00782 * are independent of mapping type 00783 */ 00784 case INFINITE_MAP: 00785 return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p); 00786 00787 case JACOBI_20_00: 00788 return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p); 00789 00790 case JACOBI_30_00: 00791 return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p); 00792 00793 case LEGENDRE: 00794 return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p); 00795 00796 case LAGRANGE: 00797 return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p); 00798 00799 default: 00800 libmesh_error(); 00801 } 00802 } 00803 00804 00805 // 2D 00806 case 2: 00807 { 00808 switch (fe_t.radial_family) 00809 { 00810 case INFINITE_MAP: 00811 return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p); 00812 00813 case JACOBI_20_00: 00814 return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p); 00815 00816 case JACOBI_30_00: 00817 return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p); 00818 00819 case LEGENDRE: 00820 return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p); 00821 00822 case LAGRANGE: 00823 return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p); 00824 00825 default: 00826 libmesh_error(); 00827 } 00828 00829 } 00830 00831 00832 // 3D 00833 case 3: 00834 { 00835 switch (fe_t.radial_family) 00836 { 00837 case INFINITE_MAP: 00838 return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p); 00839 00840 case JACOBI_20_00: 00841 return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p); 00842 00843 case JACOBI_30_00: 00844 return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p); 00845 00846 case LEGENDRE: 00847 return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p); 00848 00849 case LAGRANGE: 00850 return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p); 00851 00852 default: 00853 libmesh_error(); 00854 } 00855 00856 } 00857 00858 00859 default: 00860 libmesh_error(); 00861 } 00862 00863 00864 libmesh_error(); 00865 return 0.; 00866 } 00867 00868 00869 00870 00871 void FEInterface::ifem_compute_data(const unsigned int dim, 00872 const FEType& fe_t, 00873 const Elem* elem, 00874 FEComputeData& data) 00875 { 00876 switch (dim) 00877 { 00878 // 1D 00879 case 1: 00880 { 00881 switch (fe_t.radial_family) 00882 { 00883 /* 00884 * For no derivatives (and local coordinates, as 00885 * given in \p p) the infinite element shapes 00886 * are independent of mapping type 00887 */ 00888 case INFINITE_MAP: 00889 InfFE<1,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data); 00890 break; 00891 00892 case JACOBI_20_00: 00893 InfFE<1,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data); 00894 break; 00895 00896 case JACOBI_30_00: 00897 InfFE<1,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data); 00898 break; 00899 00900 case LEGENDRE: 00901 InfFE<1,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data); 00902 break; 00903 00904 case LAGRANGE: 00905 InfFE<1,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data); 00906 break; 00907 00908 default: 00909 libmesh_error(); 00910 } 00911 00912 break; 00913 } 00914 00915 00916 // 2D 00917 case 2: 00918 { 00919 switch (fe_t.radial_family) 00920 { 00921 case INFINITE_MAP: 00922 InfFE<2,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data); 00923 break; 00924 00925 case JACOBI_20_00: 00926 InfFE<2,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data); 00927 break; 00928 00929 case JACOBI_30_00: 00930 InfFE<2,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data); 00931 break; 00932 00933 case LEGENDRE: 00934 InfFE<2,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data); 00935 break; 00936 00937 case LAGRANGE: 00938 InfFE<2,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data); 00939 break; 00940 00941 default: 00942 libmesh_error(); 00943 } 00944 00945 break; 00946 } 00947 00948 00949 // 3D 00950 case 3: 00951 { 00952 switch (fe_t.radial_family) 00953 { 00954 case INFINITE_MAP: 00955 InfFE<3,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data); 00956 break; 00957 00958 case JACOBI_20_00: 00959 InfFE<3,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data); 00960 break; 00961 00962 case JACOBI_30_00: 00963 InfFE<3,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data); 00964 break; 00965 00966 case LEGENDRE: 00967 InfFE<3,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data); 00968 break; 00969 00970 case LAGRANGE: 00971 InfFE<3,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data); 00972 break; 00973 00974 default: 00975 libmesh_error(); 00976 } 00977 00978 break; 00979 } 00980 00981 00982 default: 00983 libmesh_error(); 00984 break; 00985 } 00986 00987 return; 00988 } 00989 00990 } // namespace libMesh 00991 00992 #endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS 00993
Site Created By: libMesh Developers
Last modified: February 05 2013 19:54:46 UTC
Hosted By: