LCOV - code coverage report
Current view: top level - src/fe - fe_lagrange_gll.C (source / functions) Hit Total Coverage
Test: libMesh/libmesh: #4573 (924896) with base 3f0912 Lines: 70 122 57.4 %
Date: 2026-11-18 21:52:26 Functions: 25 60 41.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // The libMesh Finite Element Library.
       2             : // Copyright (C) 2002-2026 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/elem.h"
      22             : #include "libmesh/enum_to_string.h"
      23             : #include "libmesh/fe.h"
      24             : #include "libmesh/fe_interface.h"
      25             : #include "libmesh/fe_lagrange_gll_shape_1D.h"
      26             : #include "libmesh/fe_macro.h"
      27             : 
      28             : 
      29             : namespace libMesh
      30             : {
      31             : 
      32             : /**
      33             :  * \returns The number of degrees of freedom that the LAGRANGE_GLL basis of order \p o carries
      34             :  * on an element of type \p t.
      35             :  *
      36             :  * The basis is a tensor product, so it applies only to tensor product element types. On
      37             :  * these types it has \f$(p+1)^d\f$ degrees of freedom.
      38             :  *
      39             :  * Each entity that owns degrees of freedom needs a node, and this limits the order on some
      40             :  * types. A vertex owns one degree of freedom and an edge owns p-1. Thus a type without mid-edge
      41             :  * nodes supports only order one. A face owns \f$(p-1)^2\f$, so in three dimensions a type
      42             :  * without face nodes supports only order one as well. The element owns the interior degrees of
      43             :  * freedom, so no type needs an interior node. HIERARCHIC has the same limits for the same
      44             :  * reason.
      45             :  */
      46       90536 : unsigned int lagrange_gll_n_dofs(const ElemType t, const Order o)
      47             : {
      48       30889 :   libmesh_assert_greater (o, 0);
      49             : 
      50       90536 :   const unsigned int n = static_cast<unsigned int>(o) + 1;
      51             : 
      52       90536 :   libmesh_error_msg_if(n > fe_lagrange_gll_max_points_1D,
      53             :                        "The LAGRANGE_GLL basis of order " << o << " needs " << n
      54             :                        << " Gauss-Lobatto points. The table has at most "
      55             :                        << fe_lagrange_gll_max_points_1D << ".");
      56             : 
      57       90536 :   switch (t)
      58             :     {
      59           0 :     case NODEELEM:
      60           0 :       return 1;
      61             : 
      62             :       // An edge element has only vertices and an interior, so it needs no other nodes at any
      63             :       // order
      64        2098 :     case EDGE2:
      65             :     case EDGE3:
      66             :     case EDGE4:
      67        2098 :       return n;
      68             : 
      69             :       // Above order one, the edge degrees of freedom need mid-edge nodes
      70        2078 :     case QUAD4:
      71             :     case QUADSHELL4:
      72        2078 :       libmesh_error_msg_if(o > FIRST,
      73             :                            "The LAGRANGE_GLL basis of order " << o << " puts " << o - 1
      74             :                            << " degrees of freedom on each edge. "
      75             :                            << Utility::enum_to_string(t) << " has no mid-edge nodes. "
      76             :                            "Use QUAD8 or QUAD9.");
      77             :       libmesh_fallthrough();
      78             :     case QUAD8:
      79             :     case QUADSHELL8:
      80             :     case QUAD9:
      81             :     case QUADSHELL9:
      82       14481 :       return n*n;
      83             : 
      84             :       // In three dimensions, the face degrees of freedom also need face nodes
      85       14910 :     case HEX8:
      86       14910 :       libmesh_error_msg_if(o > FIRST,
      87             :                            "The LAGRANGE_GLL basis of order " << o
      88             :                            << " puts degrees of freedom on the edges and faces of a hexahedron. "
      89             :                            "HEX8 has no edge or face nodes. Use HEX27.");
      90             :       libmesh_fallthrough();
      91             :     case HEX20:
      92        7582 :       libmesh_error_msg_if(o > FIRST,
      93             :                            "The LAGRANGE_GLL basis of order " << o << " puts " << (o - 1)*(o - 1)
      94             :                            << " degrees of freedom on each face. HEX20 has no face nodes. "
      95             :                            "Use HEX27.");
      96             :       libmesh_fallthrough();
      97             :     case HEX27:
      98       73957 :       return n*n*n;
      99             : 
     100           0 :     case INVALID_ELEM:
     101           0 :       return 0;
     102             : 
     103           0 :     default:
     104           0 :       libmesh_error_msg("The LAGRANGE_GLL basis is a tensor product. It does not support "
     105             :                         << Utility::enum_to_string(t) << ".");
     106             :     }
     107             : }
     108             : 
     109             : 
     110       90536 : unsigned int lagrange_gll_n_dofs(const Elem * e, const Order o)
     111             : {
     112       30889 :   libmesh_assert(e);
     113       90536 :   return lagrange_gll_n_dofs(e->type(), o);
     114             : }
     115             : 
     116             : /**
     117             :  * \returns The number of degrees of freedom that node \p n of an element of type \p t owns.
     118             :  *
     119             :  * A vertex owns the degree of freedom at its own interpolation point. A mid-edge node owns
     120             :  * the p-1 points inside its edge. A mid-face node owns the \f$(p-1)^2\f$ points inside its face.
     121             :  * An interior node owns none. The element owns the interior points. This lets static
     122             :  * condensation eliminate them, and it lets types without an interior node use the basis.
     123             :  */
     124     1172167 : unsigned int lagrange_gll_n_dofs_at_node(const ElemType t,
     125             :                                          const Order o,
     126             :                                          const unsigned int n)
     127             : {
     128      306832 :   libmesh_assert_greater (o, 0);
     129             : 
     130     1172167 :   const unsigned int per_edge = static_cast<unsigned int>(o) - 1;
     131             : 
     132     1172167 :   switch (t)
     133             :     {
     134           0 :     case NODEELEM:
     135           0 :       return 1;
     136             : 
     137        8120 :     case EDGE2:
     138             :     case EDGE3:
     139             :     case EDGE4:
     140        8120 :       return (n < 2) ? 1 : 0;
     141             : 
     142       67827 :     case QUAD4:
     143             :     case QUADSHELL4:
     144         798 :       libmesh_assert_less (n, 4);
     145             :       libmesh_fallthrough();
     146             :     case QUAD8:
     147             :     case QUADSHELL8:
     148             :     case QUAD9:
     149             :     case QUADSHELL9:
     150       92639 :       if (n < 4)
     151       12378 :         return 1;
     152       47782 :       if (n < 8)
     153       39435 :         return per_edge;
     154        2338 :       return 0;
     155             : 
     156      794820 :     case HEX8:
     157        2478 :       libmesh_assert_less (n, 8);
     158             :       libmesh_fallthrough();
     159             :     case HEX20:
     160             :     case HEX27:
     161     1071408 :       if (n < 8)
     162       85932 :         return 1;
     163      741954 :       if (n < 20)
     164      121962 :         return per_edge;
     165      273432 :       if (n < 26)
     166      234441 :         return per_edge * per_edge;
     167       10149 :       return 0;
     168             : 
     169           0 :     case INVALID_ELEM:
     170           0 :       return 0;
     171             : 
     172           0 :     default:
     173           0 :       libmesh_error_msg("The LAGRANGE_GLL basis is a tensor product. It does not support "
     174             :                         << Utility::enum_to_string(t) << ".");
     175             :     }
     176             : }
     177             : 
     178             : /**
     179             :  * \returns The number of degrees of freedom that the element itself owns. These are the
     180             :  * \f$(p-1)^d\f$ interpolation points in its interior.
     181             :  */
     182       46842 : unsigned int lagrange_gll_n_dofs_per_elem(const ElemType t, const Order o)
     183             : {
     184       12395 :   libmesh_assert_greater (o, 0);
     185             : 
     186       46842 :   const unsigned int per_edge = static_cast<unsigned int>(o) - 1;
     187             : 
     188       46842 :   switch (t)
     189             :     {
     190           0 :     case NODEELEM:
     191             :     case INVALID_ELEM:
     192           0 :       return 0;
     193             : 
     194        2828 :     case EDGE2:
     195             :     case EDGE3:
     196             :     case EDGE4:
     197        2828 :       return per_edge;
     198             : 
     199        9596 :     case QUAD4:
     200             :     case QUADSHELL4:
     201             :     case QUAD8:
     202             :     case QUADSHELL8:
     203             :     case QUAD9:
     204             :     case QUADSHELL9:
     205        9596 :       return per_edge * per_edge;
     206             : 
     207       34418 :     case HEX8:
     208             :     case HEX20:
     209             :     case HEX27:
     210       34418 :       return per_edge * per_edge * per_edge;
     211             : 
     212           0 :     default:
     213           0 :       libmesh_error_msg("The LAGRANGE_GLL basis is a tensor product. It does not support "
     214             :                         << Utility::enum_to_string(t) << ".");
     215             :     }
     216             : }
     217             : 
     218             : 
     219             : /**
     220             :  * Evaluates a solution at the nodes of \p elem. Output writers use these nodal values.
     221             :  *
     222             :  * Each vertex coefficient is the value at its node. Above order two, the other interpolation
     223             :  * points are not nodes. Thus this function evaluates the basis at each node.
     224             :  */
     225           0 : void lagrange_gll_nodal_soln(const Elem * elem,
     226             :                              const Order order,
     227             :                              const std::vector<Number> & elem_soln,
     228             :                              std::vector<Number> & nodal_soln,
     229             :                              const bool add_p_level)
     230             : {
     231           0 :   const unsigned int n_nodes = elem->n_nodes();
     232             : 
     233           0 :   nodal_soln.resize(n_nodes);
     234             : 
     235           0 :   const FEType fe_type(order, LAGRANGE_GLL);
     236             : 
     237             :   const unsigned int n_sf =
     238           0 :     FEInterface::n_shape_functions(fe_type, elem, add_p_level);
     239             : 
     240           0 :   std::vector<Point> refspace_nodes;
     241           0 :   FEBase::get_refspace_nodes(elem->type(), refspace_nodes);
     242           0 :   libmesh_assert_equal_to (refspace_nodes.size(), n_nodes);
     243           0 :   libmesh_assert_equal_to (elem_soln.size(), n_sf);
     244             : 
     245           0 :   std::fill(nodal_soln.begin(), nodal_soln.end(), 0);
     246             : 
     247           0 :   for (const auto n : make_range(n_nodes))
     248           0 :     for (const auto i : make_range(n_sf))
     249           0 :       nodal_soln[n] += elem_soln[i] *
     250           0 :         FEInterface::shape(fe_type, elem, i, refspace_nodes[n], add_p_level);
     251           0 : }
     252             : 
     253           0 : LIBMESH_FE_NODAL_SOLN(LAGRANGE_GLL, lagrange_gll_nodal_soln)
     254           0 : LIBMESH_FE_SIDE_NODAL_SOLN(LAGRANGE_GLL)
     255             : 
     256             : 
     257           0 : template <> unsigned int FE<0,LAGRANGE_GLL>::n_dofs(const ElemType t, const Order o) { return lagrange_gll_n_dofs(t, o); }
     258           0 : template <> unsigned int FE<1,LAGRANGE_GLL>::n_dofs(const ElemType t, const Order o) { return lagrange_gll_n_dofs(t, o); }
     259           0 : template <> unsigned int FE<2,LAGRANGE_GLL>::n_dofs(const ElemType t, const Order o) { return lagrange_gll_n_dofs(t, o); }
     260           0 : template <> unsigned int FE<3,LAGRANGE_GLL>::n_dofs(const ElemType t, const Order o) { return lagrange_gll_n_dofs(t, o); }
     261             : 
     262           0 : template <> unsigned int FE<0,LAGRANGE_GLL>::n_dofs(const Elem * e, const Order o) { return lagrange_gll_n_dofs(e, o); }
     263        2098 : template <> unsigned int FE<1,LAGRANGE_GLL>::n_dofs(const Elem * e, const Order o) { return lagrange_gll_n_dofs(e, o); }
     264       14481 : template <> unsigned int FE<2,LAGRANGE_GLL>::n_dofs(const Elem * e, const Order o) { return lagrange_gll_n_dofs(e, o); }
     265       73957 : template <> unsigned int FE<3,LAGRANGE_GLL>::n_dofs(const Elem * e, const Order o) { return lagrange_gll_n_dofs(e, o); }
     266             : 
     267           0 : template <> unsigned int FE<0,LAGRANGE_GLL>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return lagrange_gll_n_dofs_at_node(t, o, n); }
     268        5418 : template <> unsigned int FE<1,LAGRANGE_GLL>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return lagrange_gll_n_dofs_at_node(t, o, n); }
     269       71863 : template <> unsigned int FE<2,LAGRANGE_GLL>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return lagrange_gll_n_dofs_at_node(t, o, n); }
     270      807422 : template <> unsigned int FE<3,LAGRANGE_GLL>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return lagrange_gll_n_dofs_at_node(t, o, n); }
     271             : 
     272           0 : template <> unsigned int FE<0,LAGRANGE_GLL>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return lagrange_gll_n_dofs_at_node(e.type(), o, n); }
     273        2702 : template <> unsigned int FE<1,LAGRANGE_GLL>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return lagrange_gll_n_dofs_at_node(e.type(), o, n); }
     274       20776 : template <> unsigned int FE<2,LAGRANGE_GLL>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return lagrange_gll_n_dofs_at_node(e.type(), o, n); }
     275      263986 : template <> unsigned int FE<3,LAGRANGE_GLL>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return lagrange_gll_n_dofs_at_node(e.type(), o, n); }
     276             : 
     277           0 : template <> unsigned int FE<0,LAGRANGE_GLL>::n_dofs_per_elem(const ElemType t, const Order o) { return lagrange_gll_n_dofs_per_elem(t, o); }
     278           0 : template <> unsigned int FE<1,LAGRANGE_GLL>::n_dofs_per_elem(const ElemType t, const Order o) { return lagrange_gll_n_dofs_per_elem(t, o); }
     279           0 : template <> unsigned int FE<2,LAGRANGE_GLL>::n_dofs_per_elem(const ElemType t, const Order o) { return lagrange_gll_n_dofs_per_elem(t, o); }
     280           0 : template <> unsigned int FE<3,LAGRANGE_GLL>::n_dofs_per_elem(const ElemType t, const Order o) { return lagrange_gll_n_dofs_per_elem(t, o); }
     281             : 
     282           0 : template <> unsigned int FE<0,LAGRANGE_GLL>::n_dofs_per_elem(const Elem & e, const Order o) { return lagrange_gll_n_dofs_per_elem(e.type(), o); }
     283        2828 : template <> unsigned int FE<1,LAGRANGE_GLL>::n_dofs_per_elem(const Elem & e, const Order o) { return lagrange_gll_n_dofs_per_elem(e.type(), o); }
     284        9596 : template <> unsigned int FE<2,LAGRANGE_GLL>::n_dofs_per_elem(const Elem & e, const Order o) { return lagrange_gll_n_dofs_per_elem(e.type(), o); }
     285       34418 : template <> unsigned int FE<3,LAGRANGE_GLL>::n_dofs_per_elem(const Elem & e, const Order o) { return lagrange_gll_n_dofs_per_elem(e.type(), o); }
     286             : 
     287             : // The basis is continuous across a shared entity, because the two elements put each
     288             : // shared degree of freedom at the same point
     289           0 : template <> FEContinuity FE<0,LAGRANGE_GLL>::get_continuity() const { return C_ZERO; }
     290        2694 : template <> FEContinuity FE<1,LAGRANGE_GLL>::get_continuity() const { return C_ZERO; }
     291        4070 : template <> FEContinuity FE<2,LAGRANGE_GLL>::get_continuity() const { return C_ZERO; }
     292        8666 : template <> FEContinuity FE<3,LAGRANGE_GLL>::get_continuity() const { return C_ZERO; }
     293             : 
     294             : // A nodal basis is not hierarchic
     295           0 : template <> bool FE<0,LAGRANGE_GLL>::is_hierarchic() const { return false; }
     296          20 : template <> bool FE<1,LAGRANGE_GLL>::is_hierarchic() const { return false; }
     297          20 : template <> bool FE<2,LAGRANGE_GLL>::is_hierarchic() const { return false; }
     298          16 : template <> bool FE<3,LAGRANGE_GLL>::is_hierarchic() const { return false; }
     299             : 
     300             : // Each shape function depends on the orientation of the entity that owns it. Elements
     301             : // with different orientations thus need new shape values.
     302           0 : template <> bool FE<0,LAGRANGE_GLL>::shapes_need_reinit() const { return true; }
     303         338 : template <> bool FE<1,LAGRANGE_GLL>::shapes_need_reinit() const { return true; }
     304        1573 : template <> bool FE<2,LAGRANGE_GLL>::shapes_need_reinit() const { return true; }
     305        6840 : template <> bool FE<3,LAGRANGE_GLL>::shapes_need_reinit() const { return true; }
     306             : 
     307             : #ifdef LIBMESH_ENABLE_AMR
     308             : template <>
     309           0 : void FE<2,LAGRANGE_GLL>::compute_constraints (DofConstraints & constraints,
     310             :                                           DofMap & dof_map,
     311             :                                           const unsigned int variable_number,
     312             :                                           const Elem * elem)
     313           0 : { compute_proj_constraints(constraints, dof_map, variable_number, elem); }
     314             : 
     315             : template <>
     316           0 : void FE<3,LAGRANGE_GLL>::compute_constraints (DofConstraints & constraints,
     317             :                                           DofMap & dof_map,
     318             :                                           const unsigned int variable_number,
     319             :                                           const Elem * elem)
     320           0 : { compute_proj_constraints(constraints, dof_map, variable_number, elem); }
     321             : #endif // LIBMESH_ENABLE_AMR
     322             : 
     323             : 
     324             : } // namespace libMesh

Generated by: LCOV version 1.14