libMesh: libMesh::FE< Dim, T > Class Template Reference

Definition: enum_fe_family.h:75

◆ get_continuity() [2/54]

template<>

FEContinuity libMesh::FE< 1, SCALAR >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 108 of file fe_scalar.C.

108 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [3/54]

template<>

FEContinuity libMesh::FE< 2, SCALAR >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 109 of file fe_scalar.C.

109 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [4/54]

template<>

FEContinuity libMesh::FE< 3, SCALAR >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 110 of file fe_scalar.C.

110 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [5/54]

template<>

FEContinuity libMesh::FE< 0, L2_HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 193 of file fe_l2_hierarchic.C.

193 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [6/54]

template<>

FEContinuity libMesh::FE< 1, L2_HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 194 of file fe_l2_hierarchic.C.

194 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [7/54]

template<>

FEContinuity libMesh::FE< 2, L2_HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 195 of file fe_l2_hierarchic.C.

195 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [8/54]

template<>

FEContinuity libMesh::FE< 3, L2_HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 196 of file fe_l2_hierarchic.C.

196 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [9/54]

template<unsigned int Dim, FEFamily T>

virtual FEContinuity libMesh::FE< Dim, T >::get_continuity ( ) const

overridevirtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

◆ get_continuity() [10/54]

template<>

FEContinuity libMesh::FE< 0, CLOUGH >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 290 of file fe_clough.C.

290 { return C_ONE; }

Definition: enum_fe_family.h:77

◆ get_continuity() [11/54]

template<>

FEContinuity libMesh::FE< 1, CLOUGH >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 291 of file fe_clough.C.

291 { return C_ONE; }

Definition: enum_fe_family.h:77

◆ get_continuity() [12/54]

template<>

FEContinuity libMesh::FE< 2, CLOUGH >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 292 of file fe_clough.C.

292 { return C_ONE; }

Definition: enum_fe_family.h:77

◆ get_continuity() [13/54]

template<>

FEContinuity libMesh::FE< 3, CLOUGH >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 293 of file fe_clough.C.

293 { return C_ONE; }

Definition: enum_fe_family.h:77

◆ get_continuity() [14/54]

template<>

FEContinuity libMesh::FE< 0, HERMITE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 340 of file fe_hermite.C.

340 { return C_ONE; }

Definition: enum_fe_family.h:77

◆ get_continuity() [15/54]

template<>

FEContinuity libMesh::FE< 1, HERMITE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 341 of file fe_hermite.C.

341 { return C_ONE; }

Definition: enum_fe_family.h:77

◆ get_continuity() [16/54]

template<>

FEContinuity libMesh::FE< 2, HERMITE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 342 of file fe_hermite.C.

342 { return C_ONE; }

Definition: enum_fe_family.h:77

◆ get_continuity() [17/54]

template<>

FEContinuity libMesh::FE< 3, HERMITE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 343 of file fe_hermite.C.

343 { return C_ONE; }

Definition: enum_fe_family.h:77

◆ get_continuity() [18/54]

template<>

FEContinuity libMesh::FE< 0, HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 369 of file fe_hierarchic.C.

369 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [19/54]

template<>

FEContinuity libMesh::FE< 1, HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 370 of file fe_hierarchic.C.

370 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [20/54]

template<>

FEContinuity libMesh::FE< 2, HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 371 of file fe_hierarchic.C.

371 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [21/54]

template<>

FEContinuity libMesh::FE< 3, HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 372 of file fe_hierarchic.C.

372 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [22/54]

template<>

FEContinuity libMesh::FE< 0, MONOMIAL >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 402 of file fe_monomial.C.

402 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [23/54]

template<>

FEContinuity libMesh::FE< 1, MONOMIAL >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 403 of file fe_monomial.C.

403 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [24/54]

template<>

FEContinuity libMesh::FE< 2, MONOMIAL >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 404 of file fe_monomial.C.

404 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [25/54]

template<>

FEContinuity libMesh::FE< 3, MONOMIAL >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 405 of file fe_monomial.C.

405 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [26/54]

template<>

FEContinuity libMesh::FE< 0, BERNSTEIN >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 436 of file fe_bernstein.C.

436 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [27/54]

template<>

FEContinuity libMesh::FE< 1, BERNSTEIN >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 437 of file fe_bernstein.C.

437 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [28/54]

template<>

FEContinuity libMesh::FE< 2, BERNSTEIN >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 438 of file fe_bernstein.C.

438 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [29/54]

template<>

FEContinuity libMesh::FE< 3, BERNSTEIN >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 439 of file fe_bernstein.C.

439 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [30/54]

template<>

FEContinuity libMesh::FE< 0, L2_LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 474 of file fe_l2_lagrange.C.

474 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [31/54]

template<>

FEContinuity libMesh::FE< 1, L2_LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 475 of file fe_l2_lagrange.C.

475 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [32/54]

template<>

FEContinuity libMesh::FE< 2, L2_LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 476 of file fe_l2_lagrange.C.

476 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [33/54]

template<>

FEContinuity libMesh::FE< 3, L2_LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 477 of file fe_l2_lagrange.C.

477 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [34/54]

template<>

FEContinuity libMesh::FE< 0, NEDELEC_ONE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 544 of file fe_nedelec_one.C.

544 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ get_continuity() [35/54]

template<>

FEContinuity libMesh::FE< 1, NEDELEC_ONE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 545 of file fe_nedelec_one.C.

545 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ get_continuity() [36/54]

template<>

FEContinuity libMesh::FE< 2, NEDELEC_ONE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 546 of file fe_nedelec_one.C.

546 { return H_CURL; }

libMesh::H_CURL

Definition: enum_fe_family.h:78

◆ get_continuity() [37/54]

template<>

FEContinuity libMesh::FE< 3, NEDELEC_ONE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 547 of file fe_nedelec_one.C.

547 { return H_CURL; }

libMesh::H_CURL

Definition: enum_fe_family.h:78

◆ get_continuity() [38/54]

template<>

FEContinuity libMesh::FE< 0, LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 877 of file fe_lagrange.C.

877 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [39/54]

template<>

FEContinuity libMesh::FE< 1, LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 878 of file fe_lagrange.C.

878 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [40/54]

template<>

FEContinuity libMesh::FE< 2, LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 879 of file fe_lagrange.C.

879 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [41/54]

template<>

FEContinuity libMesh::FE< 3, LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 880 of file fe_lagrange.C.

880 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [42/54]

template<>

FEContinuity libMesh::FE< 2, SUBDIVISION >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 910 of file fe_subdivision_2D.C.

910 { return C_ONE; }

Definition: enum_fe_family.h:77

◆ get_continuity() [43/54]

template<>

FEContinuity libMesh::FE< 0, XYZ >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 925 of file fe_xyz.C.

925 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [44/54]

template<>

FEContinuity libMesh::FE< 1, XYZ >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 926 of file fe_xyz.C.

926 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [45/54]

template<>

FEContinuity libMesh::FE< 2, XYZ >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 927 of file fe_xyz.C.

927 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [46/54]

template<>

FEContinuity libMesh::FE< 0, LAGRANGE_VEC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 927 of file fe_lagrange_vec.C.

927 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [47/54]

template<>

FEContinuity libMesh::FE< 3, XYZ >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 928 of file fe_xyz.C.

928 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:75

◆ get_continuity() [48/54]

template<>

FEContinuity libMesh::FE< 1, LAGRANGE_VEC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 928 of file fe_lagrange_vec.C.

928 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [49/54]

template<>

FEContinuity libMesh::FE< 2, LAGRANGE_VEC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 929 of file fe_lagrange_vec.C.

929 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [50/54]

template<>

FEContinuity libMesh::FE< 3, LAGRANGE_VEC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 930 of file fe_lagrange_vec.C.

930 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [51/54]

template<>

FEContinuity libMesh::FE< 0, SZABAB >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 1273 of file fe_szabab.C.

1273 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [52/54]

template<>

FEContinuity libMesh::FE< 1, SZABAB >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 1274 of file fe_szabab.C.

1274 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [53/54]

template<>

FEContinuity libMesh::FE< 2, SZABAB >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 1275 of file fe_szabab.C.

1275 { return C_ZERO; }

Definition: enum_fe_family.h:76

◆ get_continuity() [54/54]

template<>

FEContinuity libMesh::FE< 3, SZABAB >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 1276 of file fe_szabab.C.

1276 { return C_ZERO; }

libMesh::FEAbstract::calculate_curl_phi

Definition: enum_fe_family.h:76

◆ get_curl_phi()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_curl_phi ( ) const

inlineinherited

Returns: The curl of the shape function at the quadrature points.

Definition at line 223 of file fe_base.h.

References libMesh::FEAbstract::calculate_curl_phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::curl_phi.

224 { libmesh_assert(!calculations_started || calculate_curl_phi);

225 calculate_curl_phi = calculate_dphiref = true; return curl_phi; }

bool calculate_curl_phi

Definition: fe_abstract.h:557

libMesh::FEGenericBase< FEOutputType< T >::type >::curl_phi

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > curl_phi

Definition: fe_base.h:508

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_curvatures()

const std::vector<Real>& libMesh::FEAbstract::get_curvatures ( ) const

inlineinherited

Returns: The curvatures for use in face integration.

Definition at line 391 of file fe_abstract.h.

392 { return this->_fe_map->get_curvatures();}

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_d2phi()

const std::vector<std::vector<OutputTensor> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 289 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phi.

290 { libmesh_assert(!calculations_started || calculate_d2phi);

291 calculate_d2phi = calculate_dphiref = true; return d2phi; }

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phi

bool calculate_d2phi

Definition: fe_abstract.h:552

std::vector< std::vector< OutputTensor > > d2phi

Definition: fe_base.h:551

bool calculations_started

Definition: fe_abstract.h:537

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phideta2()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 369 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phideta2.

370 { libmesh_assert(!calculations_started || calculate_d2phi);

371 calculate_d2phi = calculate_dphiref = true; return d2phideta2; }

bool calculate_d2phi

Definition: fe_abstract.h:552

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phideta2

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > d2phideta2

Definition: fe_base.h:571

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phidetadzeta()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 377 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidetadzeta.

378 { libmesh_assert(!calculations_started || calculate_d2phi);

379 calculate_d2phi = calculate_dphiref = true; return d2phidetadzeta; }

bool calculate_d2phi

Definition: fe_abstract.h:552

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidetadzeta

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > d2phidetadzeta

Definition: fe_base.h:576

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phidx2()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 297 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidx2.

298 { libmesh_assert(!calculations_started || calculate_d2phi);

299 calculate_d2phi = calculate_dphiref = true; return d2phidx2; }

bool calculate_d2phi

Definition: fe_abstract.h:552

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidx2

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > d2phidx2

Definition: fe_base.h:586

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phidxdy()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 305 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidxdy.

306 { libmesh_assert(!calculations_started || calculate_d2phi);

307 calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }

bool calculate_d2phi

Definition: fe_abstract.h:552

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdy

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > d2phidxdy

Definition: fe_base.h:591

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phidxdz()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 313 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidxdz.

314 { libmesh_assert(!calculations_started || calculate_d2phi);

315 calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdz

bool calculate_d2phi

Definition: fe_abstract.h:552

std::vector< std::vector< OutputShape > > d2phidxdz

Definition: fe_base.h:596

bool calculations_started

Definition: fe_abstract.h:537

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phidxi2()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 345 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidxi2.

346 { libmesh_assert(!calculations_started || calculate_d2phi);

347 calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }

bool calculate_d2phi

Definition: fe_abstract.h:552

bool calculations_started

Definition: fe_abstract.h:537

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxi2

bool calculate_dphiref

Definition: fe_abstract.h:567

std::vector< std::vector< OutputShape > > d2phidxi2

Definition: fe_base.h:556

◆ get_d2phidxideta()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 353 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidxideta.

354 { libmesh_assert(!calculations_started || calculate_d2phi);

355 calculate_d2phi = calculate_dphiref = true; return d2phidxideta; }

bool calculate_d2phi

Definition: fe_abstract.h:552

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxideta

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > d2phidxideta

Definition: fe_base.h:561

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phidxidzeta()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 361 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidxidzeta.

362 { libmesh_assert(!calculations_started || calculate_d2phi);

363 calculate_d2phi = calculate_dphiref = true; return d2phidxidzeta; }

bool calculate_d2phi

Definition: fe_abstract.h:552

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxidzeta

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > d2phidxidzeta

Definition: fe_base.h:566

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phidy2()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 321 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidy2.

322 { libmesh_assert(!calculations_started || calculate_d2phi);

323 calculate_d2phi = calculate_dphiref = true; return d2phidy2; }

bool calculate_d2phi

Definition: fe_abstract.h:552

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidy2

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > d2phidy2

Definition: fe_base.h:601

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phidydz()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 329 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidydz.

330 { libmesh_assert(!calculations_started || calculate_d2phi);

331 calculate_d2phi = calculate_dphiref = true; return d2phidydz; }

bool calculate_d2phi

Definition: fe_abstract.h:552

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidydz

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > d2phidydz

Definition: fe_base.h:606

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_d2phidz2()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 337 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidz2.

338 { libmesh_assert(!calculations_started || calculate_d2phi);

339 calculate_d2phi = calculate_dphiref = true; return d2phidz2; }

bool calculate_d2phi

Definition: fe_abstract.h:552

bool calculations_started

Definition: fe_abstract.h:537

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidz2

bool calculate_dphiref

Definition: fe_abstract.h:567

std::vector< std::vector< OutputShape > > d2phidz2

Definition: fe_base.h:611

◆ get_d2phidzeta2()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 385 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::d2phidzeta2.

386 { libmesh_assert(!calculations_started || calculate_d2phi);

387 calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }

bool calculate_d2phi

Definition: fe_abstract.h:552

bool calculations_started

Definition: fe_abstract.h:537

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidzeta2

bool calculate_dphiref

Definition: fe_abstract.h:567

std::vector< std::vector< OutputShape > > d2phidzeta2

Definition: fe_base.h:581

◆ get_d2xyzdeta2()

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdeta2 ( ) const

inlineinherited

Returns: The second partial derivatives in eta.

Definition at line 278 of file fe_abstract.h.

279 { return this->_fe_map->get_d2xyzdeta2(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_d2xyzdetadzeta()

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdetadzeta ( ) const

inlineinherited

Returns: The second partial derivatives in eta-zeta.

Definition at line 308 of file fe_abstract.h.

309 { return this->_fe_map->get_d2xyzdetadzeta(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_d2xyzdxi2()

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxi2 ( ) const

inlineinherited

Returns: The second partial derivatives in xi.

Definition at line 272 of file fe_abstract.h.

273 { return this->_fe_map->get_d2xyzdxi2(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_d2xyzdxideta()

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxideta ( ) const

inlineinherited

Returns: The second partial derivatives in xi-eta.

Definition at line 294 of file fe_abstract.h.

295 { return this->_fe_map->get_d2xyzdxideta(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_d2xyzdxidzeta()

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxidzeta ( ) const

inlineinherited

Returns: The second partial derivatives in xi-zeta.

Definition at line 302 of file fe_abstract.h.

303 { return this->_fe_map->get_d2xyzdxidzeta(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_d2xyzdzeta2()

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdzeta2 ( ) const

inlineinherited

Returns: The second partial derivatives in zeta.

Definition at line 286 of file fe_abstract.h.

287 { return this->_fe_map->get_d2xyzdzeta2(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_detadx()

const std::vector<Real>& libMesh::FEAbstract::get_detadx ( ) const

inlineinherited

Returns: The deta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 338 of file fe_abstract.h.

339 { return this->_fe_map->get_detadx(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_detady()

const std::vector<Real>& libMesh::FEAbstract::get_detady ( ) const

inlineinherited

Returns: The deta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 345 of file fe_abstract.h.

346 { return this->_fe_map->get_detady(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_detadz()

const std::vector<Real>& libMesh::FEAbstract::get_detadz ( ) const

inlineinherited

Returns: The deta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 352 of file fe_abstract.h.

353 { return this->_fe_map->get_detadz(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_dim()

unsigned int libMesh::FEAbstract::get_dim ( ) const

inlineinherited

Returns: the dimension of this FE

Definition at line 231 of file fe_abstract.h.

References libMesh::FEAbstract::dim.

232 { return dim; }

libMesh::FEAbstract::dim

const unsigned int dim

Definition: fe_abstract.h:531

◆ get_div_phi()

const std::vector<std::vector<OutputDivergence> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_div_phi ( ) const

inlineinherited

Returns: The divergence of the shape function at the quadrature points.

Definition at line 231 of file fe_base.h.

References libMesh::FEAbstract::calculate_div_phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::div_phi.

232 { libmesh_assert(!calculations_started || calculate_div_phi);

233 calculate_div_phi = calculate_dphiref = true; return div_phi; }

libMesh::FEAbstract::calculate_div_phi

bool calculations_started

Definition: fe_abstract.h:537

bool calculate_div_phi

Definition: fe_abstract.h:562

libMesh::FEGenericBase< FEOutputType< T >::type >::div_phi

std::vector< std::vector< OutputDivergence > > div_phi

Definition: fe_base.h:513

libMesh::FEGenericBase< FEOutputType< T >::type >::dphase

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_dphase()

const std::vector<OutputGradient>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphase ( ) const

inlineinherited

Returns: The global first derivative of the phase term which is used in infinite elements, evaluated at the quadrature points.

In case of the general finite element class FE this field is initialized to all zero, so that the variational formulation for an infinite element produces correct element matrices for a mesh using both finite and infinite elements.

Definition at line 403 of file fe_base.h.

References libMesh::FEGenericBase< OutputType >::dphase.

404 { return dphase; }

std::vector< OutputGradient > dphase

Definition: fe_base.h:629

◆ get_dphi()

const std::vector<std::vector<OutputGradient> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi ( ) const

inlineinherited

Returns: The shape function derivatives at the quadrature points.

Definition at line 215 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::dphi.

216 { libmesh_assert(!calculations_started || calculate_dphi);

217 calculate_dphi = calculate_dphiref = true; return dphi; }

bool calculations_started

Definition: fe_abstract.h:537

libMesh::FEGenericBase< FEOutputType< T >::type >::dphi

bool calculate_dphiref

Definition: fe_abstract.h:567

std::vector< std::vector< OutputGradient > > dphi

Definition: fe_base.h:503

bool calculate_dphi

Definition: fe_abstract.h:547

◆ get_dphideta()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphideta ( ) const

inlineinherited

Returns: The shape function eta-derivative at the quadrature points.

Definition at line 271 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::dphideta.

272 { libmesh_assert(!calculations_started || calculate_dphiref);

273 calculate_dphiref = true; return dphideta; }

bool calculations_started

Definition: fe_abstract.h:537

libMesh::FEGenericBase< FEOutputType< T >::type >::dphideta

bool calculate_dphiref

Definition: fe_abstract.h:567

std::vector< std::vector< OutputShape > > dphideta

Definition: fe_base.h:523

◆ get_dphidx()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx ( ) const

inlineinherited

Returns: The shape function x-derivative at the quadrature points.

Definition at line 239 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::dphidx.

240 { libmesh_assert(!calculations_started || calculate_dphi);

241 calculate_dphi = calculate_dphiref = true; return dphidx; }

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidx

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > dphidx

Definition: fe_base.h:533

bool calculate_dphiref

Definition: fe_abstract.h:567

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidxi

bool calculate_dphi

Definition: fe_abstract.h:547

◆ get_dphidxi()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi ( ) const

inlineinherited

Returns: The shape function xi-derivative at the quadrature points.

Definition at line 263 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::dphidxi.

264 { libmesh_assert(!calculations_started || calculate_dphiref);

265 calculate_dphiref = true; return dphidxi; }

std::vector< std::vector< OutputShape > > dphidxi

Definition: fe_base.h:518

bool calculations_started

Definition: fe_abstract.h:537

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_dphidy()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy ( ) const

inlineinherited

Returns: The shape function y-derivative at the quadrature points.

Definition at line 247 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::dphidy.

248 { libmesh_assert(!calculations_started || calculate_dphi);

249 calculate_dphi = calculate_dphiref = true; return dphidy; }

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidy

bool calculations_started

Definition: fe_abstract.h:537

std::vector< std::vector< OutputShape > > dphidy

Definition: fe_base.h:538

bool calculate_dphiref

Definition: fe_abstract.h:567

bool calculate_dphi

Definition: fe_abstract.h:547

◆ get_dphidz()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz ( ) const

inlineinherited

Returns: The shape function z-derivative at the quadrature points.

Definition at line 255 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::dphidz.

256 { libmesh_assert(!calculations_started || calculate_dphi);

257 calculate_dphi = calculate_dphiref = true; return dphidz; }

bool calculations_started

Definition: fe_abstract.h:537

bool calculate_dphiref

Definition: fe_abstract.h:567

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidz

bool calculate_dphi

Definition: fe_abstract.h:547

std::vector< std::vector< OutputShape > > dphidz

Definition: fe_base.h:543

◆ get_dphidzeta()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta ( ) const

inlineinherited

Returns: The shape function zeta-derivative at the quadrature points.

Definition at line 279 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::dphidzeta.

280 { libmesh_assert(!calculations_started || calculate_dphiref);

281 calculate_dphiref = true; return dphidzeta; }

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidzeta

std::vector< std::vector< OutputShape > > dphidzeta

Definition: fe_base.h:528

bool calculations_started

Definition: fe_abstract.h:537

bool calculate_dphiref

Definition: fe_abstract.h:567

◆ get_dxidx()

const std::vector<Real>& libMesh::FEAbstract::get_dxidx ( ) const

inlineinherited

Returns: The dxi/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 317 of file fe_abstract.h.

318 { return this->_fe_map->get_dxidx(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_dxidy()

const std::vector<Real>& libMesh::FEAbstract::get_dxidy ( ) const

inlineinherited

Returns: The dxi/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 324 of file fe_abstract.h.

325 { return this->_fe_map->get_dxidy(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_dxidz()

const std::vector<Real>& libMesh::FEAbstract::get_dxidz ( ) const

inlineinherited

Returns: The dxi/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 331 of file fe_abstract.h.

332 { return this->_fe_map->get_dxidz(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_dxyzdeta()

const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdeta ( ) const

inlineinherited

Returns: The element tangents in eta-direction at the quadrature points.

Definition at line 259 of file fe_abstract.h.

260 { return this->_fe_map->get_dxyzdeta(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_dxyzdxi()

const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdxi ( ) const

inlineinherited

Returns: The element tangents in xi-direction at the quadrature points.

Definition at line 252 of file fe_abstract.h.

253 { return this->_fe_map->get_dxyzdxi(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_dxyzdzeta()

const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdzeta ( ) const

inlineinherited

Returns: The element tangents in zeta-direction at the quadrature points.

Definition at line 266 of file fe_abstract.h.

267 { return _fe_map->get_dxyzdzeta(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_dzetadx()

const std::vector<Real>& libMesh::FEAbstract::get_dzetadx ( ) const

inlineinherited

Returns: The dzeta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 359 of file fe_abstract.h.

360 { return this->_fe_map->get_dzetadx(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_dzetady()

const std::vector<Real>& libMesh::FEAbstract::get_dzetady ( ) const

inlineinherited

Returns: The dzeta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 366 of file fe_abstract.h.

367 { return this->_fe_map->get_dzetady(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_dzetadz()

const std::vector<Real>& libMesh::FEAbstract::get_dzetadz ( ) const

inlineinherited

Returns: The dzeta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 373 of file fe_abstract.h.

374 { return this->_fe_map->get_dzetadz(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_family()

FEFamily libMesh::FEAbstract::get_family ( ) const

inlineinherited

Returns: The finite element family of this element.

Definition at line 455 of file fe_abstract.h.

References libMesh::FEType::family, and libMesh::FEAbstract::fe_type.

455 { return fe_type.family; }

libMesh::FEType::family

FEFamily family

Definition: fe_type.h:204

FEType fe_type

Definition: fe_abstract.h:575

◆ get_fe_map()

const FEMap& libMesh::FEAbstract::get_fe_map ( ) const

inlineinherited

Returns: The mapping object

Definition at line 460 of file fe_abstract.h.

460 { return *_fe_map.get(); }

Referenced by libMesh::FEMContext::build_new_fe(), libMesh::HCurlFETransformation< OutputShape >::map_phi(), libMesh::H1FETransformation< OutputShape >::map_phi(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), and libMesh::JumpErrorEstimator::reinit_sides().

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_fe_type()

FEType libMesh::FEAbstract::get_fe_type ( ) const

inlineinherited

Returns: The FE Type (approximation order and family) of the finite element.

Definition at line 429 of file fe_abstract.h.

References libMesh::FEAbstract::fe_type.

429 { return fe_type; }

FEType fe_type

Definition: fe_abstract.h:575

◆ get_info()

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
   std::ostringstream oss;
 
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
 
   for (const auto & pr : _counts)
     {
       const std::string name(pr.first);
       const unsigned int creations    = pr.second.first;
       const unsigned int destructions = pr.second.second;
 
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

◆ get_JxW()

const std::vector<Real>& libMesh::FEAbstract::get_JxW ( ) const

inlineinherited

Returns: The element Jacobian times the quadrature weight for each quadrature point.

Definition at line 245 of file fe_abstract.h.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::System::calculate_norm(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMSystem::init_context(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()().

246 { return this->_fe_map->get_JxW(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_normals()

const std::vector<Point>& libMesh::FEAbstract::get_normals ( ) const

inlineinherited

Returns: The outward pointing normal vectors for face integration.

Definition at line 385 of file fe_abstract.h.

Referenced by libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::ParsedFEMFunction< T >::eval_args(), libMesh::ParsedFEMFunction< T >::init_context(), libMesh::KellyErrorEstimator::init_context(), and libMesh::KellyErrorEstimator::internal_side_integration().

386 { return this->_fe_map->get_normals(); }

libMesh::FEAbstract::_p_level

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_order()

Order libMesh::FEAbstract::get_order ( ) const

inlineinherited

Returns: The approximation order of the finite element.

Definition at line 434 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level, libMesh::FEAbstract::fe_type, and libMesh::FEType::order.

434 { return static_cast<Order>(fe_type.order + _p_level); }

libMesh::Order

Order

Definition: enum_order.h:40

unsigned int _p_level

Definition: fe_abstract.h:587

libMesh::FEType::order

OrderWrapper order

Definition: fe_type.h:198

libMesh::FEAbstract::_p_level

FEType fe_type

Definition: fe_abstract.h:575

◆ get_p_level()

unsigned int libMesh::FEAbstract::get_p_level ( ) const

inlineinherited

Returns: The p refinement level that the current shape functions have been calculated for.

Definition at line 424 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level.

424 { return _p_level; }

unsigned int _p_level

Definition: fe_abstract.h:587

◆ get_phi()

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi ( ) const

inlineinherited

Returns: The shape function values at the quadrature points on the element.

Definition at line 207 of file fe_base.h.

References libMesh::FEAbstract::calculate_phi, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::phi.

208 { libmesh_assert(!calculations_started || calculate_phi);

209 calculate_phi = true; return phi; }

libMesh::FEAbstract::calculate_phi

bool calculations_started

Definition: fe_abstract.h:537

bool calculate_phi

Definition: fe_abstract.h:542

libMesh::FEGenericBase< FEOutputType< T >::type >::phi

std::vector< std::vector< OutputShape > > phi

Definition: fe_base.h:498

◆ get_refspace_nodes()

void libMesh::FEAbstract::get_refspace_nodes	(	const ElemType	t,
		std::vector< Point > &	nodes
	)

staticinherited

Returns: The reference space coordinates of nodes based on the element type.

Definition at line 283 of file fe_abstract.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and libMesh::TRISHELL3.

 {
   switch(itemType)
     {
     case EDGE2:
       {
         nodes.resize(2);
         nodes[0] = Point (-1.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         return;
       }
     case EDGE3:
       {
         nodes.resize(3);
         nodes[0] = Point (-1.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,0.,0.);
         return;
       }
     case TRI3:
     case TRISHELL3:
       {
         nodes.resize(3);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         return;
       }
     case TRI6:
       {
         nodes.resize(6);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         nodes[3] = Point (.5,0.,0.);
         nodes[4] = Point (.5,.5,0.);
         nodes[5] = Point (0.,.5,0.);
         return;
       }
     case QUAD4:
     case QUADSHELL4:
       {
         nodes.resize(4);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         return;
       }
     case QUAD8:
     case QUADSHELL8:
       {
         nodes.resize(8);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         nodes[4] = Point (0.,-1.,0.);
         nodes[5] = Point (1.,0.,0.);
         nodes[6] = Point (0.,1.,0.);
         nodes[7] = Point (-1.,0.,0.);
         return;
       }
     case QUAD9:
       {
         nodes.resize(9);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         nodes[4] = Point (0.,-1.,0.);
         nodes[5] = Point (1.,0.,0.);
         nodes[6] = Point (0.,1.,0.);
         nodes[7] = Point (-1.,0.,0.);
         nodes[8] = Point (0.,0.,0.);
         return;
       }
     case TET4:
       {
         nodes.resize(4);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         nodes[3] = Point (0.,0.,1.);
         return;
       }
     case TET10:
       {
         nodes.resize(10);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         nodes[3] = Point (0.,0.,1.);
         nodes[4] = Point (.5,0.,0.);
         nodes[5] = Point (.5,.5,0.);
         nodes[6] = Point (0.,.5,0.);
         nodes[7] = Point (0.,0.,.5);
         nodes[8] = Point (.5,0.,.5);
         nodes[9] = Point (0.,.5,.5);
         return;
       }
     case HEX8:
       {
         nodes.resize(8);
         nodes[0] = Point (-1.,-1.,-1.);
         nodes[1] = Point (1.,-1.,-1.);
         nodes[2] = Point (1.,1.,-1.);
         nodes[3] = Point (-1.,1.,-1.);
         nodes[4] = Point (-1.,-1.,1.);
         nodes[5] = Point (1.,-1.,1.);
         nodes[6] = Point (1.,1.,1.);
         nodes[7] = Point (-1.,1.,1.);
         return;
       }
     case HEX20:
       {
         nodes.resize(20);
         nodes[0] = Point (-1.,-1.,-1.);
         nodes[1] = Point (1.,-1.,-1.);
         nodes[2] = Point (1.,1.,-1.);
         nodes[3] = Point (-1.,1.,-1.);
         nodes[4] = Point (-1.,-1.,1.);
         nodes[5] = Point (1.,-1.,1.);
         nodes[6] = Point (1.,1.,1.);
         nodes[7] = Point (-1.,1.,1.);
         nodes[8] = Point (0.,-1.,-1.);
         nodes[9] = Point (1.,0.,-1.);
         nodes[10] = Point (0.,1.,-1.);
         nodes[11] = Point (-1.,0.,-1.);
         nodes[12] = Point (-1.,-1.,0.);
         nodes[13] = Point (1.,-1.,0.);
         nodes[14] = Point (1.,1.,0.);
         nodes[15] = Point (-1.,1.,0.);
         nodes[16] = Point (0.,-1.,1.);
         nodes[17] = Point (1.,0.,1.);
         nodes[18] = Point (0.,1.,1.);
         nodes[19] = Point (-1.,0.,1.);
         return;
       }
     case HEX27:
       {
         nodes.resize(27);
         nodes[0] = Point (-1.,-1.,-1.);
         nodes[1] = Point (1.,-1.,-1.);
         nodes[2] = Point (1.,1.,-1.);
         nodes[3] = Point (-1.,1.,-1.);
         nodes[4] = Point (-1.,-1.,1.);
         nodes[5] = Point (1.,-1.,1.);
         nodes[6] = Point (1.,1.,1.);
         nodes[7] = Point (-1.,1.,1.);
         nodes[8] = Point (0.,-1.,-1.);
         nodes[9] = Point (1.,0.,-1.);
         nodes[10] = Point (0.,1.,-1.);
         nodes[11] = Point (-1.,0.,-1.);
         nodes[12] = Point (-1.,-1.,0.);
         nodes[13] = Point (1.,-1.,0.);
         nodes[14] = Point (1.,1.,0.);
         nodes[15] = Point (-1.,1.,0.);
         nodes[16] = Point (0.,-1.,1.);
         nodes[17] = Point (1.,0.,1.);
         nodes[18] = Point (0.,1.,1.);
         nodes[19] = Point (-1.,0.,1.);
         nodes[20] = Point (0.,0.,-1.);
         nodes[21] = Point (0.,-1.,0.);
         nodes[22] = Point (1.,0.,0.);
         nodes[23] = Point (0.,1.,0.);
         nodes[24] = Point (-1.,0.,0.);
         nodes[25] = Point (0.,0.,1.);
         nodes[26] = Point (0.,0.,0.);
         return;
       }
     case PRISM6:
       {
         nodes.resize(6);
         nodes[0] = Point (0.,0.,-1.);
         nodes[1] = Point (1.,0.,-1.);
         nodes[2] = Point (0.,1.,-1.);
         nodes[3] = Point (0.,0.,1.);
         nodes[4] = Point (1.,0.,1.);
         nodes[5] = Point (0.,1.,1.);
         return;
       }
     case PRISM15:
       {
         nodes.resize(15);
         nodes[0] = Point (0.,0.,-1.);
         nodes[1] = Point (1.,0.,-1.);
         nodes[2] = Point (0.,1.,-1.);
         nodes[3] = Point (0.,0.,1.);
         nodes[4] = Point (1.,0.,1.);
         nodes[5] = Point (0.,1.,1.);
         nodes[6] = Point (.5,0.,-1.);
         nodes[7] = Point (.5,.5,-1.);
         nodes[8] = Point (0.,.5,-1.);
         nodes[9] = Point (0.,0.,0.);
         nodes[10] = Point (1.,0.,0.);
         nodes[11] = Point (0.,1.,0.);
         nodes[12] = Point (.5,0.,1.);
         nodes[13] = Point (.5,.5,1.);
         nodes[14] = Point (0.,.5,1.);
         return;
       }
     case PRISM18:
       {
         nodes.resize(18);
         nodes[0] = Point (0.,0.,-1.);
         nodes[1] = Point (1.,0.,-1.);
         nodes[2] = Point (0.,1.,-1.);
         nodes[3] = Point (0.,0.,1.);
         nodes[4] = Point (1.,0.,1.);
         nodes[5] = Point (0.,1.,1.);
         nodes[6] = Point (.5,0.,-1.);
         nodes[7] = Point (.5,.5,-1.);
         nodes[8] = Point (0.,.5,-1.);
         nodes[9] = Point (0.,0.,0.);
         nodes[10] = Point (1.,0.,0.);
         nodes[11] = Point (0.,1.,0.);
         nodes[12] = Point (.5,0.,1.);
         nodes[13] = Point (.5,.5,1.);
         nodes[14] = Point (0.,.5,1.);
         nodes[15] = Point (.5,0.,0.);
         nodes[16] = Point (.5,.5,0.);
         nodes[17] = Point (0.,.5,0.);
         return;
       }
     case PYRAMID5:
       {
         nodes.resize(5);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         nodes[4] = Point (0.,0.,1.);
         return;
       }
     case PYRAMID13:
       {
         nodes.resize(13);
 
         // base corners
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
 
         // apex
         nodes[4] = Point (0.,0.,1.);
 
         // base midedge
         nodes[5] = Point (0.,-1.,0.);
         nodes[6] = Point (1.,0.,0.);
         nodes[7] = Point (0.,1.,0.);
         nodes[8] = Point (-1,0.,0.);
 
         // lateral midedge
         nodes[9] = Point (-.5,-.5,.5);
         nodes[10] = Point (.5,-.5,.5);
         nodes[11] = Point (.5,.5,.5);
         nodes[12] = Point (-.5,.5,.5);
 
         return;
       }
     case PYRAMID14:
       {
         nodes.resize(14);
 
         // base corners
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
 
         // apex
         nodes[4] = Point (0.,0.,1.);
 
         // base midedge
         nodes[5] = Point (0.,-1.,0.);
         nodes[6] = Point (1.,0.,0.);
         nodes[7] = Point (0.,1.,0.);
         nodes[8] = Point (-1,0.,0.);
 
         // lateral midedge
         nodes[9] = Point (-.5,-.5,.5);
         nodes[10] = Point (.5,-.5,.5);
         nodes[11] = Point (.5,.5,.5);
         nodes[12] = Point (-.5,.5,.5);
 
         // base center
         nodes[13] = Point (0.,0.,0.);
 
         return;
       }
 
     default:
       libmesh_error_msg("ERROR: Unknown element type " << itemType);
     }
 }

◆ get_Sobolev_dweight()

const std::vector<RealGradient>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_dweight ( ) const

inlineinherited

Returns: The first global derivative of the multiplicative weight at each quadrature point. See get_Sobolev_weight() for details. In case of FE initialized to all zero.

Definition at line 427 of file fe_base.h.

References libMesh::FEGenericBase< OutputType >::dweight.

428 { return dweight; }

libMesh::FEGenericBase< FEOutputType< T >::type >::dweight

std::vector< RealGradient > dweight

Definition: fe_base.h:636

◆ get_Sobolev_weight()

const std::vector<Real>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_weight ( ) const

inlineinherited

Returns: The multiplicative weight at each quadrature point. This weight is used for certain infinite element weak formulations, so that weighted Sobolev spaces are used for the trial function space. This renders the variational form easily computable.

In case of the general finite element class FE this field is initialized to all ones, so that the variational formulation for an infinite element produces correct element matrices for a mesh using both finite and infinite elements.

Definition at line 419 of file fe_base.h.

References libMesh::FEGenericBase< OutputType >::weight.

420 { return weight; }

libMesh::FEGenericBase< FEOutputType< T >::type >::weight

std::vector< Real > weight

Definition: fe_base.h:643

◆ get_tangents()

const std::vector<std::vector<Point> >& libMesh::FEAbstract::get_tangents ( ) const

inlineinherited

Returns: The tangent vectors for face integration.

Definition at line 379 of file fe_abstract.h.

380 { return this->_fe_map->get_tangents(); }

libMesh::FEAbstract::elem_type

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ get_type()

ElemType libMesh::FEAbstract::get_type ( ) const

inlineinherited

Returns: The element type that the current shape functions have been calculated for. Useful in determining when shape functions must be recomputed.

Definition at line 418 of file fe_abstract.h.

References libMesh::FEAbstract::elem_type.

418 { return elem_type; }

ElemType elem_type

Definition: fe_abstract.h:581

◆ get_xyz()

const std::vector<Point>& libMesh::FEAbstract::get_xyz ( ) const

inlineinherited

Returns: The xyz spatial locations of the quadrature points on the element.

Definition at line 238 of file fe_abstract.h.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ParsedFEMFunction< T >::eval_args(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::ParsedFEMFunction< T >::init_context(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()().

239 { return this->_fe_map->get_xyz(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:525

◆ increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name )

inlineprotectedinherited

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 181 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.first++;
 }

◆ increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name )

inlineprotectedinherited

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 194 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.second++;
 }

◆ init_base_shape_functions()

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::init_base_shape_functions	(	const std::vector< Point > &	qp,
		const Elem *	e
	)

overrideprotectedvirtual

Initialize the data fields for the base of an an infinite element.

Implements libMesh::FEGenericBase< FEOutputType< T >::type >.

Definition at line 550 of file fe.C.

 {
   this->elem_type = e->type();
   this->_fe_map->template init_reference_to_physical_map<Dim>(qp, e);
   init_shape_functions(qp, e);
 }

◆ init_shape_functions()

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::init_shape_functions	(	const std::vector< Point > &	qp,
		const Elem *	e
	)

protectedvirtual

Update the various member data fields phi, dphidxi, dphideta, dphidzeta, etc. for the current element. These data will be computed at the points qp, which are generally (but need not be) the quadrature points.

Reimplemented in libMesh::FEXYZ< Dim >, and libMesh::FESubdivision.

Definition at line 294 of file fe.C.

 {
   // Start logging the shape function initialization
   LOG_SCOPE("init_shape_functions()", "FE");
 
   // The number of quadrature points.
   const unsigned int n_qp = cast_int<unsigned int>(qp.size());
 
   // Number of shape functions in the finite element approximation
   // space.
   const unsigned int n_approx_shape_functions =
     this->n_shape_functions(this->get_type(),
                             this->get_order());
 
   // resize the vectors to hold current data
   // Phi are the shape functions used for the FE approximation
   // Phi_map are the shape functions used for the FE mapping
   if (this->calculate_phi)
     this->phi.resize     (n_approx_shape_functions);
 
   if (this->calculate_dphi)
     {
       this->dphi.resize    (n_approx_shape_functions);
       this->dphidx.resize  (n_approx_shape_functions);
       this->dphidy.resize  (n_approx_shape_functions);
       this->dphidz.resize  (n_approx_shape_functions);
     }
 
   if (this->calculate_dphiref)
     {
       if (Dim > 0)
         this->dphidxi.resize (n_approx_shape_functions);
 
       if (Dim > 1)
         this->dphideta.resize      (n_approx_shape_functions);
 
       if (Dim > 2)
         this->dphidzeta.resize     (n_approx_shape_functions);
     }
 
   if (this->calculate_curl_phi && (FEInterface::field_type(T) == TYPE_VECTOR))
     this->curl_phi.resize(n_approx_shape_functions);
 
   if (this->calculate_div_phi && (FEInterface::field_type(T) == TYPE_VECTOR))
     this->div_phi.resize(n_approx_shape_functions);
 
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
   if (this->calculate_d2phi)
     {
       this->d2phi.resize     (n_approx_shape_functions);
       this->d2phidx2.resize  (n_approx_shape_functions);
       this->d2phidxdy.resize (n_approx_shape_functions);
       this->d2phidxdz.resize (n_approx_shape_functions);
       this->d2phidy2.resize  (n_approx_shape_functions);
       this->d2phidydz.resize (n_approx_shape_functions);
       this->d2phidz2.resize  (n_approx_shape_functions);
 
       if (Dim > 0)
         this->d2phidxi2.resize (n_approx_shape_functions);
 
       if (Dim > 1)
         {
           this->d2phidxideta.resize (n_approx_shape_functions);
           this->d2phideta2.resize   (n_approx_shape_functions);
         }
       if (Dim > 2)
         {
           this->d2phidxidzeta.resize  (n_approx_shape_functions);
           this->d2phidetadzeta.resize (n_approx_shape_functions);
           this->d2phidzeta2.resize    (n_approx_shape_functions);
         }
     }
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
 
   for (unsigned int i=0; i<n_approx_shape_functions; i++)
     {
       if (this->calculate_phi)
         this->phi[i].resize         (n_qp);
       if (this->calculate_dphi)
         {
           this->dphi[i].resize        (n_qp);
           this->dphidx[i].resize      (n_qp);
           this->dphidy[i].resize      (n_qp);
           this->dphidz[i].resize      (n_qp);
         }
 
       if (this->calculate_dphiref)
         {
           if (Dim > 0)
             this->dphidxi[i].resize(n_qp);
 
           if (Dim > 1)
             this->dphideta[i].resize(n_qp);
 
           if (Dim > 2)
             this->dphidzeta[i].resize(n_qp);
         }
 
       if (this->calculate_curl_phi && (FEInterface::field_type(T) == TYPE_VECTOR))
         this->curl_phi[i].resize(n_qp);
 
       if (this->calculate_div_phi && (FEInterface::field_type(T) == TYPE_VECTOR))
         this->div_phi[i].resize(n_qp);
 
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
       if (this->calculate_d2phi)
         {
           this->d2phi[i].resize     (n_qp);
           this->d2phidx2[i].resize  (n_qp);
           this->d2phidxdy[i].resize (n_qp);
           this->d2phidxdz[i].resize (n_qp);
           this->d2phidy2[i].resize  (n_qp);
           this->d2phidydz[i].resize (n_qp);
           this->d2phidz2[i].resize  (n_qp);
           if (Dim > 0)
             this->d2phidxi2[i].resize (n_qp);
           if (Dim > 1)
             {
               this->d2phidxideta[i].resize (n_qp);
               this->d2phideta2[i].resize   (n_qp);
             }
           if (Dim > 2)
             {
               this->d2phidxidzeta[i].resize  (n_qp);
               this->d2phidetadzeta[i].resize (n_qp);
               this->d2phidzeta2[i].resize    (n_qp);
             }
         }
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     }
 
 
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
   //------------------------------------------------------------
   // Initialize the data fields, which should only be used for infinite
   // elements, to some sensible values, so that using a FE with the
   // variational formulation of an InfFE, correct element matrices are
   // returned
 
   {
     this->weight.resize  (n_qp);
     this->dweight.resize (n_qp);
     this->dphase.resize  (n_qp);
 
     for (unsigned int p=0; p<n_qp; p++)
       {
         this->weight[p] = 1.;
         this->dweight[p].zero();
         this->dphase[p].zero();
       }
 
   }
 #endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
 
   switch (Dim)
     {
 
       //------------------------------------------------------------
       // 0D
     case 0:
       {
         break;
       }
 
       //------------------------------------------------------------
       // 1D
     case 1:
       {
         // Compute the value of the approximation shape function i at quadrature point p
         if (this->calculate_dphiref)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               this->dphidxi[i][p]  = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 0, qp[p]);
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
         if (this->calculate_d2phi)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               this->d2phidxi2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 0, qp[p]);
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
 
         break;
       }
 
 
 
       //------------------------------------------------------------
       // 2D
     case 2:
       {
         // Compute the value of the approximation shape function i at quadrature point p
         if (this->calculate_dphiref)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               {
                 this->dphidxi[i][p]  = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 0, qp[p]);
                 this->dphideta[i][p] = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 1, qp[p]);
               }
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
         if (this->calculate_d2phi)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               {
                 this->d2phidxi2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 0, qp[p]);
                 this->d2phidxideta[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 1, qp[p]);
                 this->d2phideta2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 2, qp[p]);
               }
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
 
 
         break;
       }
 
 
 
       //------------------------------------------------------------
       // 3D
     case 3:
       {
         // Compute the value of the approximation shape function i at quadrature point p
         if (this->calculate_dphiref)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               {
                 this->dphidxi[i][p]   = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 0, qp[p]);
                 this->dphideta[i][p]  = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 1, qp[p]);
                 this->dphidzeta[i][p] = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 2, qp[p]);
               }
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
         if (this->calculate_d2phi)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               {
                 this->d2phidxi2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 0, qp[p]);
                 this->d2phidxideta[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 1, qp[p]);
                 this->d2phideta2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 2, qp[p]);
                 this->d2phidxidzeta[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 3, qp[p]);
                 this->d2phidetadzeta[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 4, qp[p]);
                 this->d2phidzeta2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 5, qp[p]);
               }
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
 
         break;
       }
 
 
     default:
       libmesh_error_msg("Invalid dimension Dim = " << Dim);
     }
 }

◆ inverse_map() [1/4]

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::inverse_map	(	const Elem *	elem,
		const Point &	p,
		const Real	tolerance = `TOLERANCE`,
		const bool	secure = `true`
	)

static

Returns: The location (on the reference element) of the point p located in physical space. This function requires inverting the (possibly nonlinear) transformation map, so it is not trivial. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence $\{ p_n \}$ , and the iteration is terminated when $\|p - p_n\| < \mbox{\texttt{tolerance}}$

Definition at line 1576 of file fe_map.C.

Referenced by libMesh::FEMap::compute_face_map(), and libMesh::InfFE< Dim, T_radial, T_map >::inverse_map().

 {
   libmesh_assert(elem);
   libmesh_assert_greater_equal (tolerance, 0.);
 
 
   // Start logging the map inversion.
   LOG_SCOPE("inverse_map()", "FE");
 
   // How much did the point on the reference
   // element change by in this Newton step?
   Real inverse_map_error = 0.;
 
   //  The point on the reference element.  This is
   //  the "initial guess" for Newton's method.  The
   //  centroid seems like a good idea, but computing
   //  it is a little more intensive than, say taking
   //  the zero point.
   //
   //  Convergence should be insensitive of this choice
   //  for "good" elements.
   Point p; // the zero point.  No computation required
 
   //  The number of iterations in the map inversion process.
   unsigned int cnt = 0;
 
   //  The number of iterations after which we give up and declare
   //  divergence
   const unsigned int max_cnt = 10;
 
   //  The distance (in master element space) beyond which we give up
   //  and declare divergence.  This is no longer used...
   // Real max_step_length = 4.;
 
 
 
   //  Newton iteration loop.
   do
     {
       //  Where our current iterate \p p maps to.
       const Point physical_guess = FE<Dim,T>::map (elem, p);
 
       //  How far our current iterate is from the actual point.
       const Point delta = physical_point - physical_guess;
 
       //  Increment in current iterate \p p, will be computed.
       Point dp;
 
 
       //  The form of the map and how we invert it depends
       //  on the dimension that we are in.
       switch (Dim)
         {
           // ------------------------------------------------------------------
           //  0D map inversion is trivial
         case 0:
           {
             break;
           }
 
           // ------------------------------------------------------------------
           //  1D map inversion
           //
           //  Here we find the point on a 1D reference element that maps to
           //  the point \p physical_point in the domain.  This is a bit tricky
           //  since we do not want to assume that the point \p physical_point
           //  is also in a 1D domain.  In particular, this method might get
           //  called on the edge of a 3D element, in which case
           //  \p physical_point actually lives in 3D.
         case 1:
           {
             const Point dxi = FE<Dim,T>::map_xi (elem, p);
 
             //  Newton's method in this case looks like
             //
             //  {X} - {X_n} = [J]*dp
             //
             //  Where {X}, {X_n} are 3x1 vectors, [J] is a 3x1 matrix
             //  d(x,y,z)/dxi, and we seek dp, a scalar.  Since the above
             //  system is either overdetermined or rank-deficient, we will
             //  solve the normal equations for this system
             //
             //  [J]^T ({X} - {X_n}) = [J]^T [J] {dp}
             //
             //  which involves the trivial inversion of the scalar
             //  G = [J]^T [J]
             const Real G = dxi*dxi;
 
             if (secure)
               libmesh_assert_greater (G, 0.);
 
             const Real Ginv = 1./G;
 
             const Real  dxidelta = dxi*delta;
 
             dp(0) = Ginv*dxidelta;
 
             // No master elements have radius > 4, but sometimes we
             // can take a step that big while still converging
             // if (secure)
             // libmesh_assert_less (dp.size(), max_step_length);
 
             break;
           }
 
 
 
           // ------------------------------------------------------------------
           //  2D map inversion
           //
           //  Here we find the point on a 2D reference element that maps to
           //  the point \p physical_point in the domain.  This is a bit tricky
           //  since we do not want to assume that the point \p physical_point
           //  is also in a 2D domain.  In particular, this method might get
           //  called on the face of a 3D element, in which case
           //  \p physical_point actually lives in 3D.
         case 2:
           {
             const Point dxi  = FE<Dim,T>::map_xi  (elem, p);
             const Point deta = FE<Dim,T>::map_eta (elem, p);
 
             //  Newton's method in this case looks like
             //
             //  {X} - {X_n} = [J]*{dp}
             //
             //  Where {X}, {X_n} are 3x1 vectors, [J] is a 3x2 matrix
             //  d(x,y,z)/d(xi,eta), and we seek {dp}, a 2x1 vector.  Since
             //  the above system is either over-determined or rank-deficient,
             //  we will solve the normal equations for this system
             //
             //  [J]^T ({X} - {X_n}) = [J]^T [J] {dp}
             //
             //  which involves the inversion of the 2x2 matrix
             //  [G] = [J]^T [J]
             const Real
               G11 = dxi*dxi,  G12 = dxi*deta,
               G21 = dxi*deta, G22 = deta*deta;
 
 
             const Real det = (G11*G22 - G12*G21);
 
             if (secure)
               libmesh_assert_not_equal_to (det, 0.);
 
             const Real inv_det = 1./det;
 
             const Real
               Ginv11 =  G22*inv_det,
               Ginv12 = -G12*inv_det,
 
               Ginv21 = -G21*inv_det,
               Ginv22 =  G11*inv_det;
 
 
             const Real  dxidelta  = dxi*delta;
             const Real  detadelta = deta*delta;
 
             dp(0) = (Ginv11*dxidelta + Ginv12*detadelta);
             dp(1) = (Ginv21*dxidelta + Ginv22*detadelta);
 
             // No master elements have radius > 4, but sometimes we
             // can take a step that big while still converging
             // if (secure)
             // libmesh_assert_less (dp.size(), max_step_length);
 
             break;
           }
 
 
 
           // ------------------------------------------------------------------
           //  3D map inversion
           //
           //  Here we find the point in a 3D reference element that maps to
           //  the point \p physical_point in a 3D domain. Nothing special
           //  has to happen here, since (unless the map is singular because
           //  you have a BAD element) the map will be invertible and we can
           //  apply Newton's method directly.
         case 3:
           {
             const Point dxi   = FE<Dim,T>::map_xi   (elem, p);
             const Point deta  = FE<Dim,T>::map_eta  (elem, p);
             const Point dzeta = FE<Dim,T>::map_zeta (elem, p);
 
             //  Newton's method in this case looks like
             //
             //  {X} = {X_n} + [J]*{dp}
             //
             //  Where {X}, {X_n} are 3x1 vectors, [J] is a 3x3 matrix
             //  d(x,y,z)/d(xi,eta,zeta), and we seek {dp}, a 3x1 vector.
             //  Since the above system is nonsingular for invertible maps
             //  we will solve
             //
             //  {dp} = [J]^-1 ({X} - {X_n})
             //
             //  which involves the inversion of the 3x3 matrix [J]
             libmesh_try
               {
                 RealTensorValue(dxi(0), deta(0), dzeta(0),
                                 dxi(1), deta(1), dzeta(1),
                                 dxi(2), deta(2), dzeta(2)).solve(delta, dp);
               }
             libmesh_catch (ConvergenceFailure &)
               {
                 // We encountered a singular Jacobian.  The value of
                 // dp is zero, since it was never changed during the
                 // call to RealTensorValue::solve().  We don't want to
                 // continue iterating until max_cnt since there is no
                 // update to the Newton iterate, and we don't want to
                 // print the inverse_map_error value since it will
                 // confusingly be 0.  Therefore, in the secure case we
                 // need to throw an error message while in the !secure
                 // case we can just return a far away point.
                 if (secure)
                   {
                     libMesh::err << "ERROR: Newton scheme encountered a singular Jacobian in element: "
                                  << elem->id()
                                  << std::endl;
 
                     elem->print_info(libMesh::err);
 
                     libmesh_error_msg("Exiting...");
                   }
                 else
                   {
                     for (unsigned int i=0; i != Dim; ++i)
                       p(i) = 1e6;
                     return p;
                   }
               }
 
             // No master elements have radius > 4, but sometimes we
             // can take a step that big while still converging
             // if (secure)
             // libmesh_assert_less (dp.size(), max_step_length);
 
             break;
           }
 
 
           //  Some other dimension?
         default:
           libmesh_error_msg("Invalid Dim = " << Dim);
         } // end switch(Dim), dp now computed
 
 
 
       //  ||P_n+1 - P_n||
       inverse_map_error = dp.norm();
 
       //  P_n+1 = P_n + dp
       p.add (dp);
 
       //  Increment the iteration count.
       cnt++;
 
       //  Watch for divergence of Newton's
       //  method.  Here's how it goes:
       //  (1) For good elements, we expect convergence in 10
       //      iterations, with no too-large steps.
       //      - If called with (secure == true) and we have not yet converged
       //        print out a warning message.
       //      - If called with (secure == true) and we have not converged in
       //        20 iterations abort
       //  (2) This method may be called in cases when the target point is not
       //      inside the element and we have no business expecting convergence.
       //      For these cases if we have not converged in 10 iterations forget
       //      about it.
       if (cnt > max_cnt)
         {
           //  Warn about divergence when secure is true - this
           //  shouldn't happen
           if (secure)
             {
               // Print every time in devel/dbg modes
 #ifndef NDEBUG
               libmesh_here();
               libMesh::err << "WARNING: Newton scheme has not converged in "
                            << cnt << " iterations:" << std::endl
                            << "   physical_point="
                            << physical_point
                            << "   physical_guess="
                            << physical_guess
                            << "   dp="
                            << dp
                            << "   p="
                            << p
                            << "   error=" << inverse_map_error
                            << "   in element " << elem->id()
                            << std::endl;
 
               elem->print_info(libMesh::err);
 #else
               // In optimized mode, just print once that an inverse_map() call
               // had trouble converging its Newton iteration.
               libmesh_do_once(libMesh::err << "WARNING: At least one element took more than "
                               << max_cnt
                               << " iterations to converge in inverse_map()...\n"
                               << "Rerun in devel/dbg mode for more details."
                               << std::endl;);
 
 #endif // NDEBUG
 
               if (cnt > 2*max_cnt)
                 {
                   libMesh::err << "ERROR: Newton scheme FAILED to converge in "
                                << cnt
                                << " iterations in element "
                                << elem->id()
                                << " for physical point = "
                                << physical_point
                                << std::endl;
 
                   elem->print_info(libMesh::err);
 
                   libmesh_error_msg("Exiting...");
                 }
             }
           //  Return a far off point when secure is false - this
           //  should only happen when we're trying to map a point
           //  that's outside the element
           else
             {
               for (unsigned int i=0; i != Dim; ++i)
                 p(i) = 1e6;
 
               return p;
             }
         }
     }
   while (inverse_map_error > tolerance);
 
 
 
   //  If we are in debug mode do two sanity checks.
 #ifdef DEBUG
 
   if (secure)
     {
       // Make sure the point \p p on the reference element actually
       // does map to the point \p physical_point within a tolerance.
 
       const Point check = FE<Dim,T>::map (elem, p);
       const Point diff  = physical_point - check;
 
       if (diff.norm() > tolerance)
         {
           libmesh_here();
           libMesh::err << "WARNING:  diff is "
                        << diff.norm()
                        << std::endl
                        << " point="
                        << physical_point;
           libMesh::err << " local=" << check;
           libMesh::err << " lref= " << p;
 
           elem->print_info(libMesh::err);
         }
 
       // Make sure the point \p p on the reference element actually
       // is
 
       if (!FEAbstract::on_reference_element(p, elem->type(), 2*tolerance))
         {
           libmesh_here();
           libMesh::err << "WARNING:  inverse_map of physical point "
                        << physical_point
                        << " is not on element." << '\n';
           elem->print_info(libMesh::err);
         }
     }
 
 #endif
 
   return p;
 }

◆ inverse_map() [2/4]

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::inverse_map	(	const Elem *	elem,
		const std::vector< Point > &	physical_points,
		std::vector< Point > &	reference_points,
		const Real	tolerance = `TOLERANCE`,
		const bool	secure = `true`
	)

static

Takes a number points in physical space (in the physical_points vector) and finds their location on the reference element for the input element elem. The values on the reference element are returned in the vector reference_points. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence $\{ p_n \}$ , and the iteration is terminated when $\|p - p_n\| < \mbox{\texttt{tolerance}}$

Definition at line 1960 of file fe_map.C.

 {
   // The number of points to find the
   // inverse map of
   const std::size_t n_points = physical_points.size();
 
   // Resize the vector to hold the points
   // on the reference element
   reference_points.resize(n_points);
 
   // Find the coordinates on the reference
   // element of each point in physical space
   for (std::size_t p=0; p<n_points; p++)
     reference_points[p] =
       FE<Dim,T>::inverse_map (elem, physical_points[p], tolerance, secure);
 }

◆ inverse_map() [3/4]

template<>

Point libMesh::FE< 2, SUBDIVISION >::inverse_map	(	const Elem *	,
		const Point &	,
		const Real	,
		const bool
	)

Definition at line 876 of file fe_subdivision_2D.C.

 {
   libmesh_not_implemented();
 }

◆ inverse_map() [4/4]

template<>

void libMesh::FE< 2, SUBDIVISION >::inverse_map	(	const Elem *	,
		const std::vector< Point > &	,
		std::vector< Point > &	,
		Real	,
		bool
	)

Definition at line 885 of file fe_subdivision_2D.C.

 {
   libmesh_not_implemented();
 }

◆ is_hierarchic() [1/54]

template<>

bool libMesh::FE< 0, SCALAR >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 113 of file fe_scalar.C.

113 { return false; }

◆ is_hierarchic() [2/54]

template<>

bool libMesh::FE< 1, SCALAR >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 114 of file fe_scalar.C.

114 { return false; }

◆ is_hierarchic() [3/54]

template<>

bool libMesh::FE< 2, SCALAR >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 115 of file fe_scalar.C.

115 { return false; }

◆ is_hierarchic() [4/54]

template<>

bool libMesh::FE< 3, SCALAR >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 116 of file fe_scalar.C.

116 { return false; }

◆ is_hierarchic() [5/54]

template<>

bool libMesh::FE< 0, L2_HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 199 of file fe_l2_hierarchic.C.

199 { return true; }

◆ is_hierarchic() [6/54]

template<>

bool libMesh::FE< 1, L2_HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 200 of file fe_l2_hierarchic.C.

200 { return true; }

◆ is_hierarchic() [7/54]

template<>

bool libMesh::FE< 2, L2_HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 201 of file fe_l2_hierarchic.C.

201 { return true; }

◆ is_hierarchic() [8/54]

template<>

bool libMesh::FE< 3, L2_HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 202 of file fe_l2_hierarchic.C.

202 { return true; }

◆ is_hierarchic() [9/54]

template<unsigned int Dim, FEFamily T>

virtual bool libMesh::FE< Dim, T >::is_hierarchic ( ) const

overridevirtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

◆ is_hierarchic() [10/54]

template<>

bool libMesh::FE< 0, CLOUGH >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 296 of file fe_clough.C.

296 { return false; } // FIXME - this will be changed

◆ is_hierarchic() [11/54]

template<>

bool libMesh::FE< 1, CLOUGH >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 297 of file fe_clough.C.

297 { return false; } // FIXME - this will be changed

◆ is_hierarchic() [12/54]

template<>

bool libMesh::FE< 2, CLOUGH >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 298 of file fe_clough.C.

298 { return false; } // FIXME - this will be changed

◆ is_hierarchic() [13/54]

template<>

bool libMesh::FE< 3, CLOUGH >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 299 of file fe_clough.C.

299 { return false; } // FIXME - this will be changed

◆ is_hierarchic() [14/54]

template<>

bool libMesh::FE< 0, HERMITE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 346 of file fe_hermite.C.

346 { return true; }

◆ is_hierarchic() [15/54]

template<>

bool libMesh::FE< 1, HERMITE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 347 of file fe_hermite.C.

347 { return true; }

◆ is_hierarchic() [16/54]

template<>

bool libMesh::FE< 2, HERMITE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 348 of file fe_hermite.C.

348 { return true; }

◆ is_hierarchic() [17/54]

template<>

bool libMesh::FE< 3, HERMITE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 349 of file fe_hermite.C.

349 { return true; }

◆ is_hierarchic() [18/54]

template<>

bool libMesh::FE< 0, HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 375 of file fe_hierarchic.C.

375 { return true; }

◆ is_hierarchic() [19/54]

template<>

bool libMesh::FE< 1, HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 376 of file fe_hierarchic.C.

376 { return true; }

◆ is_hierarchic() [20/54]

template<>

bool libMesh::FE< 2, HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 377 of file fe_hierarchic.C.

377 { return true; }

◆ is_hierarchic() [21/54]

template<>

bool libMesh::FE< 3, HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 378 of file fe_hierarchic.C.

378 { return true; }

◆ is_hierarchic() [22/54]

template<>

bool libMesh::FE< 0, MONOMIAL >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 409 of file fe_monomial.C.

409 { return true; }

◆ is_hierarchic() [23/54]

template<>

bool libMesh::FE< 1, MONOMIAL >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 410 of file fe_monomial.C.

410 { return true; }

◆ is_hierarchic() [24/54]

template<>

bool libMesh::FE< 2, MONOMIAL >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 411 of file fe_monomial.C.

411 { return true; }

◆ is_hierarchic() [25/54]

template<>

bool libMesh::FE< 3, MONOMIAL >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 412 of file fe_monomial.C.

412 { return true; }

◆ is_hierarchic() [26/54]

template<>

bool libMesh::FE< 0, BERNSTEIN >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 442 of file fe_bernstein.C.

442 { return false; }

◆ is_hierarchic() [27/54]

template<>

bool libMesh::FE< 1, BERNSTEIN >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 443 of file fe_bernstein.C.

443 { return false; }

◆ is_hierarchic() [28/54]

template<>

bool libMesh::FE< 2, BERNSTEIN >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 444 of file fe_bernstein.C.

444 { return false; }

◆ is_hierarchic() [29/54]

template<>

bool libMesh::FE< 3, BERNSTEIN >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 445 of file fe_bernstein.C.

445 { return false; }

◆ is_hierarchic() [30/54]

template<>

bool libMesh::FE< 0, L2_LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 480 of file fe_l2_lagrange.C.

480 { return false; }

◆ is_hierarchic() [31/54]

template<>

bool libMesh::FE< 1, L2_LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 481 of file fe_l2_lagrange.C.

481 { return false; }

◆ is_hierarchic() [32/54]

template<>

bool libMesh::FE< 2, L2_LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 482 of file fe_l2_lagrange.C.

482 { return false; }

◆ is_hierarchic() [33/54]

template<>

bool libMesh::FE< 3, L2_LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 483 of file fe_l2_lagrange.C.

483 { return false; }

◆ is_hierarchic() [34/54]

template<>

bool libMesh::FE< 0, NEDELEC_ONE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 550 of file fe_nedelec_one.C.

550 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ is_hierarchic() [35/54]

template<>

bool libMesh::FE< 1, NEDELEC_ONE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 551 of file fe_nedelec_one.C.

551 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ is_hierarchic() [36/54]

template<>

bool libMesh::FE< 2, NEDELEC_ONE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 552 of file fe_nedelec_one.C.

552 { return false; }

◆ is_hierarchic() [37/54]

template<>

bool libMesh::FE< 3, NEDELEC_ONE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 553 of file fe_nedelec_one.C.

553 { return false; }

◆ is_hierarchic() [38/54]

template<>

bool libMesh::FE< 0, LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 883 of file fe_lagrange.C.

883 { return false; }

◆ is_hierarchic() [39/54]

template<>

bool libMesh::FE< 1, LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 884 of file fe_lagrange.C.

884 { return false; }

◆ is_hierarchic() [40/54]

template<>

bool libMesh::FE< 2, LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 885 of file fe_lagrange.C.

885 { return false; }

◆ is_hierarchic() [41/54]

template<>

bool libMesh::FE< 3, LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 886 of file fe_lagrange.C.

886 { return false; }

◆ is_hierarchic() [42/54]

template<>

bool libMesh::FE< 2, SUBDIVISION >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 913 of file fe_subdivision_2D.C.

913 { return false; }

◆ is_hierarchic() [43/54]

template<>

bool libMesh::FE< 0, XYZ >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 932 of file fe_xyz.C.

932 { return true; }

◆ is_hierarchic() [44/54]

template<>

bool libMesh::FE< 1, XYZ >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 933 of file fe_xyz.C.

933 { return true; }

◆ is_hierarchic() [45/54]

template<>

bool libMesh::FE< 0, LAGRANGE_VEC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 933 of file fe_lagrange_vec.C.

933 { return false; }

◆ is_hierarchic() [46/54]

template<>

bool libMesh::FE< 2, XYZ >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 934 of file fe_xyz.C.

934 { return true; }

◆ is_hierarchic() [47/54]

template<>

bool libMesh::FE< 1, LAGRANGE_VEC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 934 of file fe_lagrange_vec.C.

934 { return false; }

◆ is_hierarchic() [48/54]

template<>

bool libMesh::FE< 3, XYZ >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 935 of file fe_xyz.C.

935 { return true; }

◆ is_hierarchic() [49/54]

template<>

bool libMesh::FE< 2, LAGRANGE_VEC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 935 of file fe_lagrange_vec.C.

935 { return false; }

◆ is_hierarchic() [50/54]

template<>

bool libMesh::FE< 3, LAGRANGE_VEC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 936 of file fe_lagrange_vec.C.

936 { return false; }

◆ is_hierarchic() [51/54]

template<>

bool libMesh::FE< 0, SZABAB >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 1279 of file fe_szabab.C.

1279 { return true; }

◆ is_hierarchic() [52/54]

template<>

bool libMesh::FE< 1, SZABAB >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 1280 of file fe_szabab.C.

1280 { return true; }

◆ is_hierarchic() [53/54]

template<>

bool libMesh::FE< 2, SZABAB >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 1281 of file fe_szabab.C.

1281 { return true; }

◆ is_hierarchic() [54/54]

template<>

bool libMesh::FE< 3, SZABAB >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 1282 of file fe_szabab.C.

1282 { return true; }

◆ map()

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::map	(	const Elem *	elem,
		const Point &	reference_point
	)

static

Returns: The location (in physical space) of the point p located on the reference element.

Definition at line 1985 of file fe_map.C.

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::inverse_map(), and libMesh::InfFE< Dim, T_radial, T_map >::map().

 {
   libmesh_assert(elem);
 
   Point p;
 
   const ElemType type     = elem->type();
   const Order order       = elem->default_order();
   const unsigned int n_sf = FE<Dim,LAGRANGE>::n_shape_functions(type, order);
 
   // Lagrange basis functions are used for mapping
   for (unsigned int i=0; i<n_sf; i++)
     p.add_scaled (elem->point(i),
                   FE<Dim,LAGRANGE>::shape(type,
                                           order,
                                           i,
                                           reference_point)
                   );
 
   return p;
 }

◆ map_eta()

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::map_eta	(	const Elem *	elem,
		const Point &	reference_point
	)

static

Returns: d(xyz)/deta (in physical space) of the point p located on the reference element.

Definition at line 2040 of file fe_map.C.

Referenced by libMesh::FEMap::compute_face_map(), and libMesh::FE< Dim, LAGRANGE_VEC >::inverse_map().

 {
   libmesh_assert(elem);
 
   Point p;
 
   const ElemType type     = elem->type();
   const Order order       = elem->default_order();
   const unsigned int n_sf = FE<Dim,LAGRANGE>::n_shape_functions(type, order);
 
   // Lagrange basis functions are used for mapping
   for (unsigned int i=0; i<n_sf; i++)
     p.add_scaled (elem->point(i),
                   FE<Dim,LAGRANGE>::shape_deriv(type,
                                                 order,
                                                 i,
                                                 1,
                                                 reference_point)
                   );
 
   return p;
 }

◆ map_xi()

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::map_xi	(	const Elem *	elem,
		const Point &	reference_point
	)

static

Returns: d(xyz)/dxi (in physical space) of the point p located on the reference element.

Definition at line 2012 of file fe_map.C.

Referenced by libMesh::FEMap::compute_face_map(), and libMesh::FE< Dim, LAGRANGE_VEC >::inverse_map().

 {
   libmesh_assert(elem);
 
   Point p;
 
   const ElemType type     = elem->type();
   const Order order       = elem->default_order();
   const unsigned int n_sf = FE<Dim,LAGRANGE>::n_shape_functions(type, order);
 
   // Lagrange basis functions are used for mapping
   for (unsigned int i=0; i<n_sf; i++)
     p.add_scaled (elem->point(i),
                   FE<Dim,LAGRANGE>::shape_deriv(type,
                                                 order,
                                                 i,
                                                 0,
                                                 reference_point)
                   );
 
   return p;
 }

◆ map_zeta()

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::map_zeta	(	const Elem *	elem,
		const Point &	reference_point
	)

static

Returns: d(xyz)/dzeta (in physical space) of the point p located on the reference element.

Definition at line 2068 of file fe_map.C.

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::inverse_map().

 {
   libmesh_assert(elem);
 
   Point p;
 
   const ElemType type     = elem->type();
   const Order order       = elem->default_order();
   const unsigned int n_sf = FE<Dim,LAGRANGE>::n_shape_functions(type, order);
 
   // Lagrange basis functions are used for mapping
   for (unsigned int i=0; i<n_sf; i++)
     p.add_scaled (elem->point(i),
                   FE<Dim,LAGRANGE>::shape_deriv(type,
                                                 order,
                                                 i,
                                                 2,
                                                 reference_point)
                   );
 
   return p;
 }

◆ n_dofs() [1/54]

template<>

unsigned int libMesh::FE< 0, SCALAR >::n_dofs	(	const ElemType	,
		const Order	o
	)

Definition at line 87 of file fe_scalar.C.

87 { return o; }

◆ n_dofs() [2/54]

template<>

unsigned int libMesh::FE< 1, SCALAR >::n_dofs	(	const ElemType	,
		const Order	o
	)

Definition at line 88 of file fe_scalar.C.

88 { return o; }

◆ n_dofs() [3/54]

template<>

unsigned int libMesh::FE< 2, SCALAR >::n_dofs	(	const ElemType	,
		const Order	o
	)

Definition at line 89 of file fe_scalar.C.

89 { return o; }

◆ n_dofs() [4/54]

template<>

unsigned int libMesh::FE< 3, SCALAR >::n_dofs	(	const ElemType	,
		const Order	o
	)

Definition at line 90 of file fe_scalar.C.

90 { return o; }

◆ n_dofs() [5/54]

template<>

unsigned int libMesh::FE< 0, L2_HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 174 of file fe_l2_hierarchic.C.

174 { return l2_hierarchic_n_dofs(t, o); }

◆ n_dofs() [6/54]

template<>

unsigned int libMesh::FE< 1, L2_HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 175 of file fe_l2_hierarchic.C.

175 { return l2_hierarchic_n_dofs(t, o); }

◆ n_dofs() [7/54]

template<>

unsigned int libMesh::FE< 2, L2_HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 176 of file fe_l2_hierarchic.C.

176 { return l2_hierarchic_n_dofs(t, o); }

◆ n_dofs() [8/54]

template<>

unsigned int libMesh::FE< 3, L2_HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 177 of file fe_l2_hierarchic.C.

177 { return l2_hierarchic_n_dofs(t, o); }

◆ n_dofs() [9/54]

template<unsigned int Dim, FEFamily T>

static unsigned int libMesh::FE< Dim, T >::n_dofs	(	const ElemType	t,
		const Order	o
	)

static

Returns: The number of shape functions associated with this finite element.

On a p-refined element, o should be the total order of the element.

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::n_dofs(), and libMesh::FE< Dim, LAGRANGE_VEC >::n_shape_functions().

◆ n_dofs() [10/54]

template<>

unsigned int libMesh::FE< 0, CLOUGH >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 271 of file fe_clough.C.

271 { return clough_n_dofs(t, o); }

◆ n_dofs() [11/54]

template<>

unsigned int libMesh::FE< 1, CLOUGH >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 272 of file fe_clough.C.

272 { return clough_n_dofs(t, o); }

◆ n_dofs() [12/54]

template<>

unsigned int libMesh::FE< 2, CLOUGH >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 273 of file fe_clough.C.

273 { return clough_n_dofs(t, o); }

◆ n_dofs() [13/54]

template<>

unsigned int libMesh::FE< 3, CLOUGH >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 274 of file fe_clough.C.

274 { return clough_n_dofs(t, o); }

◆ n_dofs() [14/54]

template<>

unsigned int libMesh::FE< 0, HERMITE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 321 of file fe_hermite.C.

321 { return hermite_n_dofs(t, o); }

◆ n_dofs() [15/54]

template<>

unsigned int libMesh::FE< 1, HERMITE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 322 of file fe_hermite.C.

322 { return hermite_n_dofs(t, o); }

◆ n_dofs() [16/54]

template<>

unsigned int libMesh::FE< 2, HERMITE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 323 of file fe_hermite.C.

323 { return hermite_n_dofs(t, o); }

◆ n_dofs() [17/54]

template<>

unsigned int libMesh::FE< 3, HERMITE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 324 of file fe_hermite.C.

324 { return hermite_n_dofs(t, o); }

◆ n_dofs() [18/54]

template<>

unsigned int libMesh::FE< 0, HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 351 of file fe_hierarchic.C.

351 { return hierarchic_n_dofs(t, o); }

◆ n_dofs() [19/54]

template<>

unsigned int libMesh::FE< 1, HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 352 of file fe_hierarchic.C.

352 { return hierarchic_n_dofs(t, o); }

◆ n_dofs() [20/54]

template<>

unsigned int libMesh::FE< 2, HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 353 of file fe_hierarchic.C.

353 { return hierarchic_n_dofs(t, o); }

◆ n_dofs() [21/54]

template<>

unsigned int libMesh::FE< 3, HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 354 of file fe_hierarchic.C.

354 { return hierarchic_n_dofs(t, o); }

◆ n_dofs() [22/54]

template<>

unsigned int libMesh::FE< 0, MONOMIAL >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 382 of file fe_monomial.C.

382 { return monomial_n_dofs(t, o); }

◆ n_dofs() [23/54]

template<>

unsigned int libMesh::FE< 1, MONOMIAL >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 383 of file fe_monomial.C.

383 { return monomial_n_dofs(t, o); }

◆ n_dofs() [24/54]

template<>

unsigned int libMesh::FE< 2, MONOMIAL >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 384 of file fe_monomial.C.

384 { return monomial_n_dofs(t, o); }

◆ n_dofs() [25/54]

template<>

unsigned int libMesh::FE< 3, MONOMIAL >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 385 of file fe_monomial.C.

385 { return monomial_n_dofs(t, o); }

◆ n_dofs() [26/54]

template<>

unsigned int libMesh::FE< 0, BERNSTEIN >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 418 of file fe_bernstein.C.

418 { return bernstein_n_dofs(t, o); }

◆ n_dofs() [27/54]

template<>

unsigned int libMesh::FE< 1, BERNSTEIN >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 419 of file fe_bernstein.C.

419 { return bernstein_n_dofs(t, o); }

◆ n_dofs() [28/54]

template<>

unsigned int libMesh::FE< 2, BERNSTEIN >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 420 of file fe_bernstein.C.

420 { return bernstein_n_dofs(t, o); }

◆ n_dofs() [29/54]

template<>

unsigned int libMesh::FE< 3, BERNSTEIN >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 421 of file fe_bernstein.C.

421 { return bernstein_n_dofs(t, o); }

◆ n_dofs() [30/54]

template<>

unsigned int libMesh::FE< 0, L2_LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 454 of file fe_l2_lagrange.C.

454 { return l2_lagrange_n_dofs(t, o); }

◆ n_dofs() [31/54]

template<>

unsigned int libMesh::FE< 1, L2_LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 455 of file fe_l2_lagrange.C.

455 { return l2_lagrange_n_dofs(t, o); }

◆ n_dofs() [32/54]

template<>

unsigned int libMesh::FE< 2, L2_LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 456 of file fe_l2_lagrange.C.

456 { return l2_lagrange_n_dofs(t, o); }

◆ n_dofs() [33/54]

template<>

unsigned int libMesh::FE< 3, L2_LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 457 of file fe_l2_lagrange.C.

457 { return l2_lagrange_n_dofs(t, o); }

◆ n_dofs() [34/54]

template<>

unsigned int libMesh::FE< 0, NEDELEC_ONE >::n_dofs	(	const ElemType	,
		const Order
	)

Definition at line 522 of file fe_nedelec_one.C.

522 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ n_dofs() [35/54]

template<>

unsigned int libMesh::FE< 1, NEDELEC_ONE >::n_dofs	(	const ElemType	,
		const Order
	)

Definition at line 523 of file fe_nedelec_one.C.

523 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ n_dofs() [36/54]

template<>

unsigned int libMesh::FE< 2, NEDELEC_ONE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 524 of file fe_nedelec_one.C.

524 { return nedelec_one_n_dofs(t, o); }

◆ n_dofs() [37/54]

template<>

unsigned int libMesh::FE< 3, NEDELEC_ONE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 525 of file fe_nedelec_one.C.

525 { return nedelec_one_n_dofs(t, o); }

◆ n_dofs() [38/54]

template<>

unsigned int libMesh::FE< 0, LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 855 of file fe_lagrange.C.

855 { return lagrange_n_dofs(t, o); }

◆ n_dofs() [39/54]

template<>

unsigned int libMesh::FE< 1, LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 856 of file fe_lagrange.C.

856 { return lagrange_n_dofs(t, o); }

◆ n_dofs() [40/54]

template<>

unsigned int libMesh::FE< 2, LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 857 of file fe_lagrange.C.

857 { return lagrange_n_dofs(t, o); }

◆ n_dofs() [41/54]

template<>

unsigned int libMesh::FE< 3, LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 858 of file fe_lagrange.C.

858 { return lagrange_n_dofs(t, o); }

◆ n_dofs() [42/54]

template<>

unsigned int libMesh::FE< 2, SUBDIVISION >::n_dofs	(	const ElemType	,
		const Order
	)

Definition at line 897 of file fe_subdivision_2D.C.

897 { libmesh_not_implemented(); return 0; }

◆ n_dofs() [43/54]

template<>

unsigned int libMesh::FE< 0, LAGRANGE_VEC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 905 of file fe_lagrange_vec.C.

905 { return FE<0,LAGRANGE>::n_dofs(t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

◆ n_dofs() [44/54]

template<>

unsigned int libMesh::FE< 0, XYZ >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 906 of file fe_xyz.C.

906 { return xyz_n_dofs(t, o); }

◆ n_dofs() [45/54]

template<>

unsigned int libMesh::FE< 1, LAGRANGE_VEC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 906 of file fe_lagrange_vec.C.

906 { return FE<1,LAGRANGE>::n_dofs(t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

◆ n_dofs() [46/54]

template<>

unsigned int libMesh::FE< 1, XYZ >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 907 of file fe_xyz.C.

907 { return xyz_n_dofs(t, o); }

◆ n_dofs() [47/54]

template<>

unsigned int libMesh::FE< 2, LAGRANGE_VEC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 907 of file fe_lagrange_vec.C.

907 { return 2*FE<2,LAGRANGE>::n_dofs(t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

◆ n_dofs() [48/54]

template<>

unsigned int libMesh::FE< 2, XYZ >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 908 of file fe_xyz.C.

908 { return xyz_n_dofs(t, o); }

◆ n_dofs() [49/54]

template<>

unsigned int libMesh::FE< 3, LAGRANGE_VEC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 908 of file fe_lagrange_vec.C.

908 { return 3*FE<3,LAGRANGE>::n_dofs(t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

◆ n_dofs() [50/54]

template<>

unsigned int libMesh::FE< 3, XYZ >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 909 of file fe_xyz.C.

909 { return xyz_n_dofs(t, o); }

◆ n_dofs() [51/54]

template<>

unsigned int libMesh::FE< 0, SZABAB >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 1255 of file fe_szabab.C.

1255 { return szabab_n_dofs(t, o); }

◆ n_dofs() [52/54]

template<>

unsigned int libMesh::FE< 1, SZABAB >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 1256 of file fe_szabab.C.

1256 { return szabab_n_dofs(t, o); }

◆ n_dofs() [53/54]

template<>

unsigned int libMesh::FE< 2, SZABAB >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 1257 of file fe_szabab.C.

1257 { return szabab_n_dofs(t, o); }

◆ n_dofs() [54/54]

template<>

unsigned int libMesh::FE< 3, SZABAB >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 1258 of file fe_szabab.C.

1258 { return szabab_n_dofs(t, o); }

◆ n_dofs_at_node() [1/54]

template<>

unsigned int libMesh::FE< 0, SCALAR >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 94 of file fe_scalar.C.

94 { return 0; }

◆ n_dofs_at_node() [2/54]

template<>

unsigned int libMesh::FE< 1, SCALAR >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 95 of file fe_scalar.C.

95 { return 0; }

◆ n_dofs_at_node() [3/54]

template<>

unsigned int libMesh::FE< 2, SCALAR >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 96 of file fe_scalar.C.

96 { return 0; }

◆ n_dofs_at_node() [4/54]

template<>

unsigned int libMesh::FE< 3, SCALAR >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 97 of file fe_scalar.C.

97 { return 0; }

◆ n_dofs_at_node() [5/54]

template<>

unsigned int libMesh::FE< 0, L2_HIERARCHIC >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 181 of file fe_l2_hierarchic.C.

181 { return 0; }

◆ n_dofs_at_node() [6/54]

template<>

unsigned int libMesh::FE< 1, L2_HIERARCHIC >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 182 of file fe_l2_hierarchic.C.

182 { return 0; }

◆ n_dofs_at_node() [7/54]

template<>

unsigned int libMesh::FE< 2, L2_HIERARCHIC >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 183 of file fe_l2_hierarchic.C.

183 { return 0; }

◆ n_dofs_at_node() [8/54]

template<>

unsigned int libMesh::FE< 3, L2_HIERARCHIC >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 184 of file fe_l2_hierarchic.C.

184 { return 0; }

◆ n_dofs_at_node() [9/54]

template<unsigned int Dim, FEFamily T>

static unsigned int libMesh::FE< Dim, T >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

static

Returns: The number of dofs at node n for a finite element of type t and order o.

On a p-refined element, o should be the total order of the element.

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::n_dofs_at_node().

◆ n_dofs_at_node() [10/54]

template<>

unsigned int libMesh::FE< 0, CLOUGH >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 278 of file fe_clough.C.

278 { return clough_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [11/54]

template<>

unsigned int libMesh::FE< 1, CLOUGH >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 279 of file fe_clough.C.

279 { return clough_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [12/54]

template<>

unsigned int libMesh::FE< 2, CLOUGH >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 280 of file fe_clough.C.

280 { return clough_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [13/54]

template<>

unsigned int libMesh::FE< 3, CLOUGH >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 281 of file fe_clough.C.

281 { return clough_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [14/54]

template<>

unsigned int libMesh::FE< 0, HERMITE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 328 of file fe_hermite.C.

328 { return hermite_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [15/54]

template<>

unsigned int libMesh::FE< 1, HERMITE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 329 of file fe_hermite.C.

329 { return hermite_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [16/54]

template<>

unsigned int libMesh::FE< 2, HERMITE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 330 of file fe_hermite.C.

330 { return hermite_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [17/54]

template<>

unsigned int libMesh::FE< 3, HERMITE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 331 of file fe_hermite.C.

331 { return hermite_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [18/54]

template<>

unsigned int libMesh::FE< 0, HIERARCHIC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 357 of file fe_hierarchic.C.

357 { return hierarchic_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [19/54]

template<>

unsigned int libMesh::FE< 1, HIERARCHIC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 358 of file fe_hierarchic.C.

358 { return hierarchic_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [20/54]

template<>

unsigned int libMesh::FE< 2, HIERARCHIC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 359 of file fe_hierarchic.C.

359 { return hierarchic_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [21/54]

template<>

unsigned int libMesh::FE< 3, HIERARCHIC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 360 of file fe_hierarchic.C.

360 { return hierarchic_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [22/54]

template<>

unsigned int libMesh::FE< 0, MONOMIAL >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 389 of file fe_monomial.C.

389 { return 0; }

◆ n_dofs_at_node() [23/54]

template<>

unsigned int libMesh::FE< 1, MONOMIAL >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 390 of file fe_monomial.C.

390 { return 0; }

◆ n_dofs_at_node() [24/54]

template<>

unsigned int libMesh::FE< 2, MONOMIAL >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 391 of file fe_monomial.C.

391 { return 0; }

◆ n_dofs_at_node() [25/54]

template<>

unsigned int libMesh::FE< 3, MONOMIAL >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 392 of file fe_monomial.C.

392 { return 0; }

◆ n_dofs_at_node() [26/54]

template<>

unsigned int libMesh::FE< 0, BERNSTEIN >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 424 of file fe_bernstein.C.

424 { return bernstein_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [27/54]

template<>

unsigned int libMesh::FE< 1, BERNSTEIN >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 425 of file fe_bernstein.C.

425 { return bernstein_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [28/54]

template<>

unsigned int libMesh::FE< 2, BERNSTEIN >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 426 of file fe_bernstein.C.

426 { return bernstein_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [29/54]

template<>

unsigned int libMesh::FE< 3, BERNSTEIN >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 427 of file fe_bernstein.C.

427 { return bernstein_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [30/54]

template<>

unsigned int libMesh::FE< 0, L2_LAGRANGE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 461 of file fe_l2_lagrange.C.

461 { return 0; }

◆ n_dofs_at_node() [31/54]

template<>

unsigned int libMesh::FE< 1, L2_LAGRANGE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 462 of file fe_l2_lagrange.C.

462 { return 0; }

◆ n_dofs_at_node() [32/54]

template<>

unsigned int libMesh::FE< 2, L2_LAGRANGE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 463 of file fe_l2_lagrange.C.

463 { return 0; }

◆ n_dofs_at_node() [33/54]

template<>

unsigned int libMesh::FE< 3, L2_LAGRANGE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 464 of file fe_l2_lagrange.C.

464 { return 0; }

◆ n_dofs_at_node() [34/54]

template<>

unsigned int libMesh::FE< 0, NEDELEC_ONE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 530 of file fe_nedelec_one.C.

530 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ n_dofs_at_node() [35/54]

template<>

unsigned int libMesh::FE< 1, NEDELEC_ONE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 531 of file fe_nedelec_one.C.

531 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ n_dofs_at_node() [36/54]

template<>

unsigned int libMesh::FE< 2, NEDELEC_ONE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 532 of file fe_nedelec_one.C.

532 { return nedelec_one_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [37/54]

template<>

unsigned int libMesh::FE< 3, NEDELEC_ONE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 533 of file fe_nedelec_one.C.

533 { return nedelec_one_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [38/54]

template<>

unsigned int libMesh::FE< 0, LAGRANGE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 863 of file fe_lagrange.C.

863 { return lagrange_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [39/54]

template<>

unsigned int libMesh::FE< 1, LAGRANGE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 864 of file fe_lagrange.C.

864 { return lagrange_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [40/54]

template<>

unsigned int libMesh::FE< 2, LAGRANGE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 865 of file fe_lagrange.C.

865 { return lagrange_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [41/54]

template<>

unsigned int libMesh::FE< 3, LAGRANGE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 866 of file fe_lagrange.C.

866 { return lagrange_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [42/54]

template<>

unsigned int libMesh::FE< 2, SUBDIVISION >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 900 of file fe_subdivision_2D.C.

900 { return 1; }

◆ n_dofs_at_node() [43/54]

template<>

unsigned int libMesh::FE< 0, XYZ >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 913 of file fe_xyz.C.

913 { return 0; }

◆ n_dofs_at_node() [44/54]

template<>

unsigned int libMesh::FE< 0, LAGRANGE_VEC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 913 of file fe_lagrange_vec.C.

913 { return FE<0,LAGRANGE>::n_dofs_at_node(t,o,n); }

static unsigned int n_dofs_at_node(const ElemType t, const Order o, const unsigned int n)

◆ n_dofs_at_node() [45/54]

template<>

unsigned int libMesh::FE< 1, XYZ >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 914 of file fe_xyz.C.

914 { return 0; }

◆ n_dofs_at_node() [46/54]

template<>

unsigned int libMesh::FE< 1, LAGRANGE_VEC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 914 of file fe_lagrange_vec.C.

914 { return FE<1,LAGRANGE>::n_dofs_at_node(t,o,n); }

static unsigned int n_dofs_at_node(const ElemType t, const Order o, const unsigned int n)

◆ n_dofs_at_node() [47/54]

template<>

unsigned int libMesh::FE< 2, XYZ >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 915 of file fe_xyz.C.

915 { return 0; }

◆ n_dofs_at_node() [48/54]

template<>

unsigned int libMesh::FE< 2, LAGRANGE_VEC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 915 of file fe_lagrange_vec.C.

915 { return 2*FE<2,LAGRANGE>::n_dofs_at_node(t,o,n); }

static unsigned int n_dofs_at_node(const ElemType t, const Order o, const unsigned int n)

◆ n_dofs_at_node() [49/54]

template<>

unsigned int libMesh::FE< 3, XYZ >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 916 of file fe_xyz.C.

916 { return 0; }

◆ n_dofs_at_node() [50/54]

template<>

unsigned int libMesh::FE< 3, LAGRANGE_VEC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 916 of file fe_lagrange_vec.C.

916 { return 3*FE<2,LAGRANGE>::n_dofs_at_node(t,o,n); }

libMesh::ReferenceCounter::_n_objects

static unsigned int n_dofs_at_node(const ElemType t, const Order o, const unsigned int n)

◆ n_dofs_at_node() [51/54]

template<>

unsigned int libMesh::FE< 0, SZABAB >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 1261 of file fe_szabab.C.

1261 { return szabab_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [52/54]

template<>

unsigned int libMesh::FE< 1, SZABAB >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 1262 of file fe_szabab.C.

1262 { return szabab_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [53/54]

template<>

unsigned int libMesh::FE< 2, SZABAB >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 1263 of file fe_szabab.C.

1263 { return szabab_n_dofs_at_node(t, o, n); }

◆ n_dofs_at_node() [54/54]

template<>

unsigned int libMesh::FE< 3, SZABAB >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 1264 of file fe_szabab.C.

1264 { return szabab_n_dofs_at_node(t, o, n); }

◆ n_dofs_per_elem() [1/54]

template<>

unsigned int libMesh::FE< 0, SCALAR >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 101 of file fe_scalar.C.

101 { return 0; }

◆ n_dofs_per_elem() [2/54]

template<>

unsigned int libMesh::FE< 1, SCALAR >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 102 of file fe_scalar.C.

102 { return 0; }

◆ n_dofs_per_elem() [3/54]

template<>

unsigned int libMesh::FE< 2, SCALAR >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 103 of file fe_scalar.C.

103 { return 0; }

◆ n_dofs_per_elem() [4/54]

template<>

unsigned int libMesh::FE< 3, SCALAR >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 104 of file fe_scalar.C.

104 { return 0; }

◆ n_dofs_per_elem() [5/54]

template<>

unsigned int libMesh::FE< 0, L2_HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 187 of file fe_l2_hierarchic.C.

187 { return l2_hierarchic_n_dofs(t, o); }

◆ n_dofs_per_elem() [6/54]

template<>

unsigned int libMesh::FE< 1, L2_HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 188 of file fe_l2_hierarchic.C.

188 { return l2_hierarchic_n_dofs(t, o); }

◆ n_dofs_per_elem() [7/54]

template<>

unsigned int libMesh::FE< 2, L2_HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 189 of file fe_l2_hierarchic.C.

189 { return l2_hierarchic_n_dofs(t, o); }

◆ n_dofs_per_elem() [8/54]

template<>

unsigned int libMesh::FE< 3, L2_HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 190 of file fe_l2_hierarchic.C.

190 { return l2_hierarchic_n_dofs(t, o); }

◆ n_dofs_per_elem() [9/54]

template<unsigned int Dim, FEFamily T>

static unsigned int libMesh::FE< Dim, T >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

static

Returns: The number of dofs interior to the element, not associated with any interior nodes.

On a p-refined element, o should be the total order of the element.

◆ n_dofs_per_elem() [10/54]

template<>

unsigned int libMesh::FE< 0, CLOUGH >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 284 of file fe_clough.C.

284 { return clough_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [11/54]

template<>

unsigned int libMesh::FE< 1, CLOUGH >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 285 of file fe_clough.C.

285 { return clough_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [12/54]

template<>

unsigned int libMesh::FE< 2, CLOUGH >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 286 of file fe_clough.C.

286 { return clough_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [13/54]

template<>

unsigned int libMesh::FE< 3, CLOUGH >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 287 of file fe_clough.C.

287 { return clough_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [14/54]

template<>

unsigned int libMesh::FE< 0, HERMITE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 334 of file fe_hermite.C.

334 { return hermite_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [15/54]

template<>

unsigned int libMesh::FE< 1, HERMITE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 335 of file fe_hermite.C.

335 { return hermite_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [16/54]

template<>

unsigned int libMesh::FE< 2, HERMITE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 336 of file fe_hermite.C.

336 { return hermite_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [17/54]

template<>

unsigned int libMesh::FE< 3, HERMITE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 337 of file fe_hermite.C.

337 { return hermite_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [18/54]

template<>

unsigned int libMesh::FE< 0, HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 363 of file fe_hierarchic.C.

363 { return hierarchic_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [19/54]

template<>

unsigned int libMesh::FE< 1, HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 364 of file fe_hierarchic.C.

364 { return hierarchic_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [20/54]

template<>

unsigned int libMesh::FE< 2, HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 365 of file fe_hierarchic.C.

365 { return hierarchic_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [21/54]

template<>

unsigned int libMesh::FE< 3, HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 366 of file fe_hierarchic.C.

366 { return hierarchic_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [22/54]

template<>

unsigned int libMesh::FE< 0, MONOMIAL >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 395 of file fe_monomial.C.

395 { return monomial_n_dofs(t, o); }

◆ n_dofs_per_elem() [23/54]

template<>

unsigned int libMesh::FE< 1, MONOMIAL >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 396 of file fe_monomial.C.

396 { return monomial_n_dofs(t, o); }

◆ n_dofs_per_elem() [24/54]

template<>

unsigned int libMesh::FE< 2, MONOMIAL >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 397 of file fe_monomial.C.

397 { return monomial_n_dofs(t, o); }

◆ n_dofs_per_elem() [25/54]

template<>

unsigned int libMesh::FE< 3, MONOMIAL >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 398 of file fe_monomial.C.

398 { return monomial_n_dofs(t, o); }

◆ n_dofs_per_elem() [26/54]

template<>

unsigned int libMesh::FE< 0, BERNSTEIN >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 430 of file fe_bernstein.C.

430 { return bernstein_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [27/54]

template<>

unsigned int libMesh::FE< 1, BERNSTEIN >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 431 of file fe_bernstein.C.

431 { return bernstein_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [28/54]

template<>

unsigned int libMesh::FE< 2, BERNSTEIN >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 432 of file fe_bernstein.C.

432 { return bernstein_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [29/54]

template<>

unsigned int libMesh::FE< 3, BERNSTEIN >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 433 of file fe_bernstein.C.

433 { return bernstein_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [30/54]

template<>

unsigned int libMesh::FE< 0, L2_LAGRANGE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 468 of file fe_l2_lagrange.C.

468 { return l2_lagrange_n_dofs(t, o); }

◆ n_dofs_per_elem() [31/54]

template<>

unsigned int libMesh::FE< 1, L2_LAGRANGE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 469 of file fe_l2_lagrange.C.

469 { return l2_lagrange_n_dofs(t, o); }

◆ n_dofs_per_elem() [32/54]

template<>

unsigned int libMesh::FE< 2, L2_LAGRANGE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 470 of file fe_l2_lagrange.C.

470 { return l2_lagrange_n_dofs(t, o); }

◆ n_dofs_per_elem() [33/54]

template<>

unsigned int libMesh::FE< 3, L2_LAGRANGE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 471 of file fe_l2_lagrange.C.

471 { return l2_lagrange_n_dofs(t, o); }

◆ n_dofs_per_elem() [34/54]

template<>

unsigned int libMesh::FE< 0, NEDELEC_ONE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 538 of file fe_nedelec_one.C.

538 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ n_dofs_per_elem() [35/54]

template<>

unsigned int libMesh::FE< 1, NEDELEC_ONE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 539 of file fe_nedelec_one.C.

539 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ n_dofs_per_elem() [36/54]

template<>

unsigned int libMesh::FE< 2, NEDELEC_ONE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 540 of file fe_nedelec_one.C.

540 { return 0; }

◆ n_dofs_per_elem() [37/54]

template<>

unsigned int libMesh::FE< 3, NEDELEC_ONE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 541 of file fe_nedelec_one.C.

541 { return 0; }

◆ n_dofs_per_elem() [38/54]

template<>

unsigned int libMesh::FE< 0, LAGRANGE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 871 of file fe_lagrange.C.

871 { return 0; }

◆ n_dofs_per_elem() [39/54]

template<>

unsigned int libMesh::FE< 1, LAGRANGE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 872 of file fe_lagrange.C.

872 { return 0; }

◆ n_dofs_per_elem() [40/54]

template<>

unsigned int libMesh::FE< 2, LAGRANGE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 873 of file fe_lagrange.C.

873 { return 0; }

◆ n_dofs_per_elem() [41/54]

template<>

unsigned int libMesh::FE< 3, LAGRANGE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 874 of file fe_lagrange.C.

874 { return 0; }

◆ n_dofs_per_elem() [42/54]

template<>

unsigned int libMesh::FE< 2, SUBDIVISION >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 903 of file fe_subdivision_2D.C.

903 { return 0; }

◆ n_dofs_per_elem() [43/54]

template<>

unsigned int libMesh::FE< 0, XYZ >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 919 of file fe_xyz.C.

919 { return xyz_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [44/54]

template<>

unsigned int libMesh::FE< 1, XYZ >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 920 of file fe_xyz.C.

920 { return xyz_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [45/54]

template<>

unsigned int libMesh::FE< 2, XYZ >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 921 of file fe_xyz.C.

921 { return xyz_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [46/54]

template<>

unsigned int libMesh::FE< 0, LAGRANGE_VEC >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 921 of file fe_lagrange_vec.C.

921 { return 0; }

◆ n_dofs_per_elem() [47/54]

template<>

unsigned int libMesh::FE< 3, XYZ >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 922 of file fe_xyz.C.

922 { return xyz_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [48/54]

template<>

unsigned int libMesh::FE< 1, LAGRANGE_VEC >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 922 of file fe_lagrange_vec.C.

922 { return 0; }

◆ n_dofs_per_elem() [49/54]

template<>

unsigned int libMesh::FE< 2, LAGRANGE_VEC >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 923 of file fe_lagrange_vec.C.

923 { return 0; }

◆ n_dofs_per_elem() [50/54]

template<>

unsigned int libMesh::FE< 3, LAGRANGE_VEC >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 924 of file fe_lagrange_vec.C.

924 { return 0; }

◆ n_dofs_per_elem() [51/54]

template<>

unsigned int libMesh::FE< 0, SZABAB >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 1267 of file fe_szabab.C.

1267 { return szabab_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [52/54]

template<>

unsigned int libMesh::FE< 1, SZABAB >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 1268 of file fe_szabab.C.

1268 { return szabab_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [53/54]

template<>

unsigned int libMesh::FE< 2, SZABAB >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 1269 of file fe_szabab.C.

1269 { return szabab_n_dofs_per_elem(t, o); }

◆ n_dofs_per_elem() [54/54]

template<>

unsigned int libMesh::FE< 3, SZABAB >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 1270 of file fe_szabab.C.

1270 { return szabab_n_dofs_per_elem(t, o); }

◆ n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 83 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

84 { return _n_objects; }

static Threads::atomic< unsigned int > _n_objects

Definition: reference_counter.h:130

◆ n_quadrature_points()

template<unsigned int Dim, FEFamily T>

unsigned int libMesh::FE< Dim, T >::n_quadrature_points ( ) const

overridevirtual

Returns: The total number of quadrature points. Call this to get an upper bound for the for loop in your simulation for matrix assembly of the current element.

Implements libMesh::FEAbstract.

Definition at line 69 of file fe.C.

 {
   libmesh_assert(this->qrule);
   return this->qrule->n_points();
 }

◆ n_shape_functions() [1/2]

template<unsigned int Dim, FEFamily T>

unsigned int libMesh::FE< Dim, T >::n_shape_functions ( ) const

overridevirtual

Returns: The number of shape functions associated with this finite element.

Implements libMesh::FEAbstract.

Definition at line 50 of file fe.C.

Referenced by libMesh::FEMap::compute_face_map(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), libMesh::FE< Dim, LAGRANGE_VEC >::map(), libMesh::FE< Dim, LAGRANGE_VEC >::map_eta(), libMesh::FE< Dim, LAGRANGE_VEC >::map_xi(), libMesh::FE< Dim, LAGRANGE_VEC >::map_zeta(), and libMesh::InfFE< Dim, T_radial, T_map >::Base::n_base_mapping_sf().

 {
   return FE<Dim,T>::n_dofs (this->elem_type,
                             static_cast<Order>(this->fe_type.order + this->_p_level));
 }

◆ n_shape_functions() [2/2]

template<unsigned int Dim, FEFamily T>

static unsigned int libMesh::FE< Dim, T >::n_shape_functions	(	const ElemType	t,
		const Order	o
	)

inlinestatic

Returns: The number of shape functions associated with a finite element of type t and approximation order o.

On a p-refined element, o should be the total order of the element.

Definition at line 228 of file fe.h.

230 { return FE<Dim,T>::n_dofs (t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

◆ nodal_soln() [1/54]

template<>

void libMesh::FE< 0, SCALAR >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 58 of file fe_scalar.C.

62 { scalar_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [2/54]

template<>

void libMesh::FE< 1, SCALAR >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 65 of file fe_scalar.C.

69 { scalar_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [3/54]

template<>

void libMesh::FE< 2, SCALAR >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 72 of file fe_scalar.C.

76 { scalar_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [4/54]

template<>

void libMesh::FE< 3, SCALAR >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 79 of file fe_scalar.C.

83 { scalar_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [5/54]

template<>

void libMesh::FE< 0, L2_HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 146 of file fe_l2_hierarchic.C.

150 { l2_hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [6/54]

template<>

void libMesh::FE< 1, L2_HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 153 of file fe_l2_hierarchic.C.

157 { l2_hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [7/54]

template<>

void libMesh::FE< 2, L2_HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 160 of file fe_l2_hierarchic.C.

164 { l2_hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [8/54]

template<>

void libMesh::FE< 3, L2_HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 167 of file fe_l2_hierarchic.C.

171 { l2_hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [9/54]

template<unsigned int Dim, FEFamily T>

static void libMesh::FE< Dim, T >::nodal_soln	(	const Elem *	elem,
		const Order	o,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

static

Build the nodal soln from the element soln. This is the solution that will be plotted.

On a p-refined element, o should be the base order of the element.

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::nodal_soln().

◆ nodal_soln() [10/54]

template<>

void libMesh::FE< 0, CLOUGH >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 242 of file fe_clough.C.

246 { clough_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [11/54]

template<>

void libMesh::FE< 1, CLOUGH >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 249 of file fe_clough.C.

253 { clough_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [12/54]

template<>

void libMesh::FE< 2, CLOUGH >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 256 of file fe_clough.C.

260 { clough_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [13/54]

template<>

void libMesh::FE< 3, CLOUGH >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 263 of file fe_clough.C.

267 { clough_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [14/54]

template<>

void libMesh::FE< 0, HERMITE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 288 of file fe_hermite.C.

292 { hermite_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [15/54]

template<>

void libMesh::FE< 1, HERMITE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 295 of file fe_hermite.C.

299 { hermite_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [16/54]

template<>

void libMesh::FE< 2, HERMITE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 302 of file fe_hermite.C.

306 { hermite_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [17/54]

template<>

void libMesh::FE< 3, HERMITE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 309 of file fe_hermite.C.

313 { hermite_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [18/54]

template<>

void libMesh::FE< 0, HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 322 of file fe_hierarchic.C.

326 { hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [19/54]

template<>

void libMesh::FE< 1, HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 329 of file fe_hierarchic.C.

333 { hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [20/54]

template<>

void libMesh::FE< 2, HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 336 of file fe_hierarchic.C.

340 { hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [21/54]

template<>

void libMesh::FE< 3, HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 343 of file fe_hierarchic.C.

347 { hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [22/54]

template<>

void libMesh::FE< 0, MONOMIAL >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 353 of file fe_monomial.C.

357 { monomial_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [23/54]

template<>

void libMesh::FE< 1, MONOMIAL >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 360 of file fe_monomial.C.

364 { monomial_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [24/54]

template<>

void libMesh::FE< 2, MONOMIAL >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 367 of file fe_monomial.C.

371 { monomial_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [25/54]

template<>

void libMesh::FE< 3, MONOMIAL >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 374 of file fe_monomial.C.

378 { monomial_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [26/54]

template<>

void libMesh::FE< 0, BERNSTEIN >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 389 of file fe_bernstein.C.

393 { bernstein_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [27/54]

template<>

void libMesh::FE< 1, BERNSTEIN >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 396 of file fe_bernstein.C.

400 { bernstein_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [28/54]

template<>

void libMesh::FE< 2, BERNSTEIN >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 403 of file fe_bernstein.C.

407 { bernstein_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [29/54]

template<>

void libMesh::FE< 3, BERNSTEIN >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 410 of file fe_bernstein.C.

414 { bernstein_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [30/54]

template<>

void libMesh::FE< 0, L2_LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 423 of file fe_l2_lagrange.C.

427 { l2_lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [31/54]

template<>

void libMesh::FE< 1, L2_LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 430 of file fe_l2_lagrange.C.

434 { l2_lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [32/54]

template<>

void libMesh::FE< 2, L2_LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 437 of file fe_l2_lagrange.C.

441 { l2_lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [33/54]

template<>

void libMesh::FE< 3, L2_LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 444 of file fe_l2_lagrange.C.

448 { l2_lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [34/54]

template<>

void libMesh::FE< 0, NEDELEC_ONE >::nodal_soln	(	const Elem *	,
		const Order	,
		const std::vector< Number > &	,
		std::vector< Number > &
	)

Definition at line 491 of file fe_nedelec_one.C.

495 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ nodal_soln() [35/54]

template<>

void libMesh::FE< 1, NEDELEC_ONE >::nodal_soln	(	const Elem *	,
		const Order	,
		const std::vector< Number > &	,
		std::vector< Number > &
	)

Definition at line 498 of file fe_nedelec_one.C.

502 { NEDELEC_LOW_D_ERROR_MESSAGE }

◆ nodal_soln() [36/54]

template<>

void libMesh::FE< 2, NEDELEC_ONE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 505 of file fe_nedelec_one.C.

509 { nedelec_one_nodal_soln(elem, order, elem_soln, 2 /*dim*/, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [37/54]

template<>

void libMesh::FE< 0, LAGRANGE_VEC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 507 of file fe_lagrange_vec.C.

511 { FE<0,LAGRANGE>::nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [38/54]

template<>

void libMesh::FE< 3, NEDELEC_ONE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 512 of file fe_nedelec_one.C.

516 { nedelec_one_nodal_soln(elem, order, elem_soln, 3 /*dim*/, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [39/54]

template<>

void libMesh::FE< 1, LAGRANGE_VEC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 514 of file fe_lagrange_vec.C.

518 { FE<1,LAGRANGE>::nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [40/54]

template<>

void libMesh::FE< 2, LAGRANGE_VEC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 521 of file fe_lagrange_vec.C.

525 { lagrange_vec_nodal_soln(elem, order, elem_soln, 2 /*dimension*/, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [41/54]

template<>

void libMesh::FE< 3, LAGRANGE_VEC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 528 of file fe_lagrange_vec.C.

532 { lagrange_vec_nodal_soln(elem, order, elem_soln, 3 /*dimension*/, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [42/54]

template<>

void libMesh::FE< 2, SUBDIVISION >::nodal_soln	(	const Elem *	elem,
		const Order	,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 818 of file fe_subdivision_2D.C.

 {
   libmesh_assert(elem);
   libmesh_assert_equal_to(elem->type(), TRI3SUBDIVISION);
   const Tri3Subdivision * sd_elem = static_cast<const Tri3Subdivision *>(elem);
 
   nodal_soln.resize(3); // three nodes per element
 
   // Ghost nodes are auxiliary.
   if (sd_elem->is_ghost())
     {
       nodal_soln[0] = 0;
       nodal_soln[1] = 0;
       nodal_soln[2] = 0;
       return;
     }
 
   // First node (node 0 in the element patch):
   unsigned int j = sd_elem->local_node_number(sd_elem->get_ordered_node(0)->id());
   nodal_soln[j] = elem_soln[0];
 
   // Second node (node 1 in the element patch):
   j = sd_elem->local_node_number(sd_elem->get_ordered_node(1)->id());
   nodal_soln[j] = elem_soln[1];
 
   // Third node (node 'valence' in the element patch):
   j = sd_elem->local_node_number(sd_elem->get_ordered_node(2)->id());
   nodal_soln[j] = elem_soln[sd_elem->get_ordered_valence(0)];
 }

◆ nodal_soln() [43/54]

template<>

void libMesh::FE< 0, LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 824 of file fe_lagrange.C.

828 { lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [44/54]

template<>

void libMesh::FE< 1, LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 831 of file fe_lagrange.C.

835 { lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [45/54]

template<>

void libMesh::FE< 2, LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 838 of file fe_lagrange.C.

842 { lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [46/54]

template<>

void libMesh::FE< 3, LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 845 of file fe_lagrange.C.

849 { lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [47/54]

template<>

void libMesh::FE< 0, XYZ >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 876 of file fe_xyz.C.

880 { xyz_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [48/54]

template<>

void libMesh::FE< 1, XYZ >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 883 of file fe_xyz.C.

887 { xyz_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [49/54]

template<>

void libMesh::FE< 2, XYZ >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 890 of file fe_xyz.C.

894 { xyz_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [50/54]

template<>

void libMesh::FE< 3, XYZ >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 897 of file fe_xyz.C.

901 { xyz_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [51/54]

template<>

void libMesh::FE< 0, SZABAB >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 1226 of file fe_szabab.C.

1230 { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [52/54]

template<>

void libMesh::FE< 1, SZABAB >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 1233 of file fe_szabab.C.

1237 { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [53/54]

template<>

void libMesh::FE< 2, SZABAB >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 1240 of file fe_szabab.C.

1244 { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ nodal_soln() [54/54]

template<>

void libMesh::FE< 3, SZABAB >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 1247 of file fe_szabab.C.

1251 { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

◆ on_reference_element()

bool libMesh::FEAbstract::on_reference_element	(	const Point &	p,
		const ElemType	t,
		const Real	eps = `TOLERANCE`
	)

staticinherited

Returns: true if the point p is located on the reference element for element type t, false otherwise. Since we are doing floating point comparisons here the parameter eps can be specified to indicate a tolerance. For example, $x \le 1$ becomes $x \le 1 + \epsilon$ .

Definition at line 581 of file fe_abstract.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::Real, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and libMesh::TRISHELL3.

Referenced by libMesh::FEInterface::ifem_on_reference_element(), libMesh::FE< Dim, LAGRANGE_VEC >::inverse_map(), and libMesh::FEInterface::on_reference_element().

 {
   libmesh_assert_greater_equal (eps, 0.);
 
   const Real xi   = p(0);
 #if LIBMESH_DIM > 1
   const Real eta  = p(1);
 #else
   const Real eta  = 0.;
 #endif
 #if LIBMESH_DIM > 2
   const Real zeta = p(2);
 #else
   const Real zeta  = 0.;
 #endif
 
   switch (t)
     {
     case NODEELEM:
       {
         return (!xi && !eta && !zeta);
       }
     case EDGE2:
     case EDGE3:
     case EDGE4:
       {
         // The reference 1D element is [-1,1].
         if ((xi >= -1.-eps) &&
             (xi <=  1.+eps))
           return true;
 
         return false;
       }
 
 
     case TRI3:
     case TRISHELL3:
     case TRI6:
       {
         // The reference triangle is isosceles
         // and is bound by xi=0, eta=0, and xi+eta=1.
         if ((xi  >= 0.-eps) &&
             (eta >= 0.-eps) &&
             ((xi + eta) <= 1.+eps))
           return true;
 
         return false;
       }
 
 
     case QUAD4:
     case QUADSHELL4:
     case QUAD8:
     case QUADSHELL8:
     case QUAD9:
       {
         // The reference quadrilateral element is [-1,1]^2.
         if ((xi  >= -1.-eps) &&
             (xi  <=  1.+eps) &&
             (eta >= -1.-eps) &&
             (eta <=  1.+eps))
           return true;
 
         return false;
       }
 
 
     case TET4:
     case TET10:
       {
         // The reference tetrahedral is isosceles
         // and is bound by xi=0, eta=0, zeta=0,
         // and xi+eta+zeta=1.
         if ((xi   >= 0.-eps) &&
             (eta  >= 0.-eps) &&
             (zeta >= 0.-eps) &&
             ((xi + eta + zeta) <= 1.+eps))
           return true;
 
         return false;
       }
 
 
     case HEX8:
     case HEX20:
     case HEX27:
       {
         /*
           if ((xi   >= -1.) &&
           (xi   <=  1.) &&
           (eta  >= -1.) &&
           (eta  <=  1.) &&
           (zeta >= -1.) &&
           (zeta <=  1.))
           return true;
         */
 
         // The reference hexahedral element is [-1,1]^3.
         if ((xi   >= -1.-eps) &&
             (xi   <=  1.+eps) &&
             (eta  >= -1.-eps) &&
             (eta  <=  1.+eps) &&
             (zeta >= -1.-eps) &&
             (zeta <=  1.+eps))
           {
             //    libMesh::out << "Strange Point:\n";
             //    p.print();
             return true;
           }
 
         return false;
       }
 
     case PRISM6:
     case PRISM15:
     case PRISM18:
       {
         // Figure this one out...
         // inside the reference triangle with zeta in [-1,1]
         if ((xi   >=  0.-eps) &&
             (eta  >=  0.-eps) &&
             (zeta >= -1.-eps) &&
             (zeta <=  1.+eps) &&
             ((xi + eta) <= 1.+eps))
           return true;
 
         return false;
       }
 
 
     case PYRAMID5:
     case PYRAMID13:
     case PYRAMID14:
       {
         // Check that the point is on the same side of all the faces
         // by testing whether:
         //
         // n_i.(x - x_i) <= 0
         //
         // for each i, where:
         //   n_i is the outward normal of face i,
         //   x_i is a point on face i.
         if ((-eta - 1. + zeta <= 0.+eps) &&
             (  xi - 1. + zeta <= 0.+eps) &&
             ( eta - 1. + zeta <= 0.+eps) &&
             ( -xi - 1. + zeta <= 0.+eps) &&
             (            zeta >= 0.-eps))
           return true;
 
         return false;
       }
 
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
     case INFHEX8:
     case INFHEX16:
     case INFHEX18:
       {
         // The reference infhex8 is a [-1,1]^3.
         if ((xi   >= -1.-eps) &&
             (xi   <=  1.+eps) &&
             (eta  >= -1.-eps) &&
             (eta  <=  1.+eps) &&
             (zeta >= -1.-eps) &&
             (zeta <=  1.+eps))
           {
             return true;
           }
         return false;
       }
 
     case INFPRISM6:
     case INFPRISM12:
       {
         // inside the reference triangle with zeta in [-1,1]
         if ((xi   >=  0.-eps) &&
             (eta  >=  0.-eps) &&
             (zeta >= -1.-eps) &&
             (zeta <=  1.+eps) &&
             ((xi + eta) <= 1.+eps))
           {
             return true;
           }
 
         return false;
       }
 #endif
 
     default:
       libmesh_error_msg("ERROR: Unknown element type " << t);
     }
 
   // If we get here then the point is _not_ in the
   // reference element.   Better return false.
 
   return false;
 }

◆ print_d2phi()

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_d2phi ( std::ostream & os ) const

virtualinherited

Prints the value of each shape function's second derivatives at each quadrature point.

Implements libMesh::FEAbstract.

Definition at line 776 of file fe_base.C.

References libMesh::index_range().

 {
   for (auto i : index_range(dphi))
     for (auto j : index_range(dphi[i]))
       os << " d2phi[" << i << "][" << j << "]=" << d2phi[i][j];
 }

◆ print_dphi()

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_dphi ( std::ostream & os ) const

virtualinherited

Prints the value of each shape function's derivative at each quadrature point.

Implements libMesh::FEAbstract.

Definition at line 718 of file fe_base.C.

References libMesh::index_range().

 {
   for (auto i : index_range(dphi))
     for (auto j : index_range(dphi[i]))
       os << " dphi[" << i << "][" << j << "]=" << dphi[i][j];
 }

◆ print_info() [1/2]

void libMesh::ReferenceCounter::print_info ( std::ostream & out = libMesh::out )

staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 87 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

 {
   if (_enable_print_counter)
     out_stream << ReferenceCounter::get_info();
 }

◆ print_info() [2/2]

void libMesh::FEAbstract::print_info ( std::ostream & os ) const

inherited

Prints all the relevant information about the current element.

Definition at line 793 of file fe_abstract.C.

References libMesh::FEAbstract::print_dphi(), libMesh::FEAbstract::print_JxW(), libMesh::FEAbstract::print_phi(), and libMesh::FEAbstract::print_xyz().

Referenced by libMesh::operator<<().

 {
   os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
   this->print_phi(os);
 
   os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
   this->print_dphi(os);
 
   os << "XYZ locations of the quadrature pts." << std::endl;
   this->print_xyz(os);
 
   os << "Values of JxW at the quadrature pts." << std::endl;
   this->print_JxW(os);
 }

◆ print_JxW()

void libMesh::FEAbstract::print_JxW ( std::ostream & os ) const

inherited

Prints the Jacobian times the weight for each quadrature point.

Definition at line 780 of file fe_abstract.C.

Referenced by libMesh::FEAbstract::print_info().

 {
   this->_fe_map->print_JxW(os);
 }

◆ print_phi()

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_phi ( std::ostream & os ) const

virtualinherited

Prints the value of each shape function at each quadrature point.

Implements libMesh::FEAbstract.

Definition at line 707 of file fe_base.C.

References libMesh::index_range().

 {
   for (auto i : index_range(phi))
     for (auto j : index_range(phi[i]))
       os << " phi[" << i << "][" << j << "]=" << phi[i][j] << std::endl;
 }

◆ print_xyz()

void libMesh::FEAbstract::print_xyz ( std::ostream & os ) const

inherited

Prints the spatial location of each quadrature point (on the physical element).

Definition at line 787 of file fe_abstract.C.

Referenced by libMesh::FEAbstract::print_info().

 {
   this->_fe_map->print_xyz(os);
 }

◆ reinit() [1/2]

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::reinit	(	const Elem *	elem,
		const std::vector< Point > *const	pts = `nullptr`,
		const std::vector< Real > *const	weights = `nullptr`
	)

overridevirtual

This is at the core of this class. Use this for each new element in the mesh. Reinitializes all the physical element-dependent data based on the current element elem. By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference element specified in the optional argument pts.

Implements libMesh::FEAbstract.

Reimplemented in libMesh::FEXYZ< Dim >, and libMesh::FESubdivision.

Definition at line 129 of file fe.C.

Referenced by libMesh::FEXYZ< Dim >::reinit().

 {
   // We can be called with no element.  If we're evaluating SCALAR
   // dofs we'll still have work to do.
   // libmesh_assert(elem);
 
   // We're calculating now!  Time to determine what.
   this->determine_calculations();
 
   // Try to avoid calling init_shape_functions
   // even when shapes_need_reinit
   bool cached_nodes_still_fit = false;
 
   // Most of the hard work happens when we have an actual element
   if (elem)
     {
       // Initialize the shape functions at the user-specified
       // points
       if (pts != nullptr)
         {
           // Set the type and p level for this element
           this->elem_type = elem->type();
           this->_p_level = elem->p_level();
 
           // Initialize the shape functions
           this->_fe_map->template init_reference_to_physical_map<Dim>
             (*pts, elem);
           this->init_shape_functions (*pts, elem);
 
           // The shape functions do not correspond to the qrule
           this->shapes_on_quadrature = false;
         }
 
       // If there are no user specified points, we use the
       // quadrature rule
 
       // update the type in accordance to the current cell
       // and reinit if the cell type has changed or (as in
       // the case of the hierarchics) the shape functions need
       // reinit, since they depend on the particular element shape
       else
         {
           libmesh_assert(this->qrule);
           this->qrule->init(elem->type(), elem->p_level());
 
           if (this->qrule->shapes_need_reinit())
             this->shapes_on_quadrature = false;
 
           if (this->elem_type != elem->type() ||
               this->_p_level != elem->p_level() ||
               !this->shapes_on_quadrature)
             {
               // Set the type and p level for this element
               this->elem_type = elem->type();
               this->_p_level = elem->p_level();
               // Initialize the shape functions
               this->_fe_map->template init_reference_to_physical_map<Dim>
                 (this->qrule->get_points(), elem);
               this->init_shape_functions (this->qrule->get_points(), elem);
 
               if (this->shapes_need_reinit())
                 {
                   cached_nodes.resize(elem->n_nodes());
                   for (unsigned int n = 0; n != elem->n_nodes(); ++n)
                     {
                       cached_nodes[n] = elem->point(n);
                     }
                 }
             }
           else
             {
               // libmesh_assert_greater (elem->n_nodes(), 1);
 
               cached_nodes_still_fit = true;
               if (cached_nodes.size() != elem->n_nodes())
                 cached_nodes_still_fit = false;
               else
                 for (unsigned int n = 1; n < elem->n_nodes(); ++n)
                   {
                     if (!(elem->point(n) - elem->point(0)).relative_fuzzy_equals
                         ((cached_nodes[n] - cached_nodes[0]), 1e-13))
                       {
                         cached_nodes_still_fit = false;
                         break;
                       }
                   }
 
               if (this->shapes_need_reinit() && !cached_nodes_still_fit)
                 {
                   this->_fe_map->template init_reference_to_physical_map<Dim>
                     (this->qrule->get_points(), elem);
                   this->init_shape_functions (this->qrule->get_points(), elem);
                   cached_nodes.resize(elem->n_nodes());
                   for (unsigned int n = 0; n != elem->n_nodes(); ++n)
                     cached_nodes[n] = elem->point(n);
                 }
             }
 
           // The shape functions correspond to the qrule
           this->shapes_on_quadrature = true;
         }
     }
   else // With no defined elem, so mapping or caching to
        // be done, and our "quadrature rule" is one point for nonlocal
        // (SCALAR) variables and zero points for local variables.
     {
       this->elem_type = INVALID_ELEM;
       this->_p_level = 0;
 
       if (!pts)
         {
           if (T == SCALAR)
             {
               this->qrule->get_points() =
                 std::vector<Point>(1,Point(0));
 
               this->qrule->get_weights() =
                 std::vector<Real>(1,1);
             }
           else
             {
               this->qrule->get_points().clear();
               this->qrule->get_weights().clear();
             }
 
           this->init_shape_functions (this->qrule->get_points(), elem);
         }
       else
         this->init_shape_functions (*pts, elem);
     }
 
   // Compute the map for this element.
   if (pts != nullptr)
     {
       if (weights != nullptr)
         {
           this->_fe_map->compute_map (this->dim, *weights, elem, this->calculate_d2phi);
         }
       else
         {
           std::vector<Real> dummy_weights (pts->size(), 1.);
           this->_fe_map->compute_map (this->dim, dummy_weights, elem, this->calculate_d2phi);
         }
     }
   else
     {
       this->_fe_map->compute_map (this->dim, this->qrule->get_weights(), elem, this->calculate_d2phi);
     }
 
   // Compute the shape functions and the derivatives at all of the
   // quadrature points.
   if (!cached_nodes_still_fit)
     {
       if (pts != nullptr)
         this->compute_shape_functions (elem,*pts);
       else
         this->compute_shape_functions(elem,this->qrule->get_points());
     }
 }

◆ reinit() [2/2]

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::reinit	(	const Elem *	elem,
		const unsigned int	side,
		const Real	tolerance = `TOLERANCE`,
		const std::vector< Point > *const	pts = `nullptr`,
		const std::vector< Real > *const	weights = `nullptr`
	)

overridevirtual

Reinitializes all the physical element-dependent data based on the side of face. The tolerance parameter is passed to the involved call to inverse_map(). By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference side element specified in the optional argument pts.

Implements libMesh::FEAbstract.

Reimplemented in libMesh::FEXYZ< Dim >, libMesh::FESubdivision, libMesh::FEXYZ< Dim >, and libMesh::FEXYZ< Dim >.

Definition at line 142 of file fe_boundary.C.

 {
   libmesh_assert(elem);
   libmesh_assert (this->qrule != nullptr || pts != nullptr);
   // We now do this for 1D elements!
   // libmesh_assert_not_equal_to (Dim, 1);
 
   // We're (possibly re-) calculating now!  FIXME - we currently
   // expect to be able to use side_map and JxW later, but we could
   // optimize further here.
   this->_fe_map->calculations_started = false;
   this->_fe_map->get_JxW();
   this->_fe_map->get_xyz();
   this->determine_calculations();
 
   // Build the side of interest
   const std::unique_ptr<const Elem> side(elem->build_side_ptr(s));
 
   // Find the max p_level to select
   // the right quadrature rule for side integration
   unsigned int side_p_level = elem->p_level();
   if (elem->neighbor_ptr(s) != nullptr)
     side_p_level = std::max(side_p_level, elem->neighbor_ptr(s)->p_level());
 
   // Initialize the shape functions at the user-specified
   // points
   if (pts != nullptr)
     {
       // The shape functions do not correspond to the qrule
       this->shapes_on_quadrature = false;
 
       // Initialize the face shape functions
       this->_fe_map->template init_face_shape_functions<Dim>(*pts, side.get());
 
       // Compute the Jacobian*Weight on the face for integration
       if (weights != nullptr)
         {
           this->_fe_map->compute_face_map (Dim, *weights, side.get());
         }
       else
         {
           std::vector<Real> dummy_weights (pts->size(), 1.);
           this->_fe_map->compute_face_map (Dim, dummy_weights, side.get());
         }
     }
   // If there are no user specified points, we use the
   // quadrature rule
   else
     {
       // initialize quadrature rule
       this->qrule->init(side->type(), side_p_level);
 
       if (this->qrule->shapes_need_reinit())
         this->shapes_on_quadrature = false;
 
       // FIXME - could this break if the same FE object was used
       // for both volume and face integrals? - RHS
       // We might not need to reinitialize the shape functions
       if ((this->get_type() != elem->type())    ||
           (side->type() != last_side)           ||
           (this->get_p_level() != side_p_level) ||
           this->shapes_need_reinit()            ||
           !this->shapes_on_quadrature)
         {
           // Set the element type and p_level
           this->elem_type = elem->type();
 
           // Set the last_side
           last_side = side->type();
 
           // Set the last p level
           this->_p_level = side_p_level;
 
           // Initialize the face shape functions
           this->_fe_map->template init_face_shape_functions<Dim>(this->qrule->get_points(),  side.get());
         }
 
       // Compute the Jacobian*Weight on the face for integration
       this->_fe_map->compute_face_map (Dim, this->qrule->get_weights(), side.get());
 
       // The shape functions correspond to the qrule
       this->shapes_on_quadrature = true;
     }
 
   // make a copy of the Jacobian for integration
   const std::vector<Real> JxW_int(this->_fe_map->get_JxW());
 
   // make a copy of shape on quadrature info
   bool shapes_on_quadrature_side = this->shapes_on_quadrature;
 
   // Find where the integration points are located on the
   // full element.
   const std::vector<Point> * ref_qp;
   if (pts != nullptr)
     ref_qp = pts;
   else
     ref_qp = &this->qrule->get_points();
 
   std::vector<Point> qp;
   this->side_map(elem, side.get(), s, *ref_qp, qp);
 
   // compute the shape function and derivative values
   // at the points qp
   this->reinit  (elem, &qp);
 
   this->shapes_on_quadrature = shapes_on_quadrature_side;
 
   // copy back old data
   this->_fe_map->get_JxW() = JxW_int;
 }

◆ set_fe_order()

void libMesh::FEAbstract::set_fe_order ( int new_order )

inlineinherited

Sets the base FE order of the finite element.

Definition at line 439 of file fe_abstract.h.

References libMesh::FEAbstract::fe_type, and libMesh::FEType::order.

439 { fe_type.order = new_order; }

libMesh::FEType::order

OrderWrapper order

Definition: fe_type.h:198