libMesh: libMesh::FEGenericBase< OutputType

libMesh::FEGenericBase::curl_phi

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function curl values.

Definition: fe_base.h:631

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_curvatures()

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

inlineinherited

Returns: The curvatures for use in face integration.

Definition at line 467 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

468 { calculate_map = true; return this->_fe_map->get_curvatures();}

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::FEMContext::build_new_fe(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::LaplacianErrorEstimator::init_context(), libMesh::ParsedFEMFunction< T >::init_context(), libMesh::FEMContext::interior_hessians(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::FEMContext::side_hessians(), and libMesh::FEMContext::some_hessian().

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_d2phi()

template<typename OutputType>

const std::vector<std::vector<OutputTensor> >& libMesh::FEGenericBase< OutputType >::get_d2phi ( ) const

inline

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

Definition at line 319 of file fe_base.h.

320 { libmesh_assert(!calculations_started || calculate_d2phi);

321 calculate_d2phi = calculate_dphiref = true; return d2phi; }

libMesh::FEGenericBase::d2phi

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

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

Shape function second derivative values.

Definition: fe_base.h:674

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phideta2()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phideta2 ( ) const

inline

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

Definition at line 403 of file fe_base.h.

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

404 { libmesh_assert(!calculations_started || calculate_d2phi);

405 calculate_d2phi = calculate_dphiref = true; return d2phideta2; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

libMesh::FEGenericBase::d2phideta2

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function second derivatives in the eta direction.

Definition: fe_base.h:695

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phidetadzeta()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidetadzeta ( ) const

inline

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

Definition at line 411 of file fe_base.h.

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

412 { libmesh_assert(!calculations_started || calculate_d2phi);

413 calculate_d2phi = calculate_dphiref = true; return d2phidetadzeta; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

libMesh::FEGenericBase::d2phidetadzeta

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function second derivatives in the eta-zeta direction.

Definition: fe_base.h:700

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phidx2()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidx2 ( ) const

inline

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

Definition at line 331 of file fe_base.h.

332 { libmesh_assert(!calculations_started || calculate_d2phi);

333 calculate_d2phi = calculate_dphiref = true; return d2phidx2; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

libMesh::FEGenericBase::d2phidx2

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function second derivatives in the x direction.

Definition: fe_base.h:710

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phidxdy()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidxdy ( ) const

inline

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

Definition at line 339 of file fe_base.h.

340 { libmesh_assert(!calculations_started || calculate_d2phi);

341 calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

libMesh::FEGenericBase::d2phidxdy

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function second derivatives in the x-y direction.

Definition: fe_base.h:715

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phidxdz()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidxdz ( ) const

inline

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

Definition at line 347 of file fe_base.h.

348 { libmesh_assert(!calculations_started || calculate_d2phi);

349 calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }

libMesh::FEGenericBase::d2phidxdz

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

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

Shape function second derivatives in the x-z direction.

Definition: fe_base.h:720

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phidxi2()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidxi2 ( ) const

inline

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

Definition at line 379 of file fe_base.h.

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

380 { libmesh_assert(!calculations_started || calculate_d2phi);

381 calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

libMesh::FEGenericBase::d2phidxi2

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

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

Shape function second derivatives in the xi direction.

Definition: fe_base.h:680

◆ get_d2phidxideta()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidxideta ( ) const

inline

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

Definition at line 387 of file fe_base.h.

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

388 { libmesh_assert(!calculations_started || calculate_d2phi);

389 calculate_d2phi = calculate_dphiref = true; return d2phidxideta; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

libMesh::FEGenericBase::d2phidxideta

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function second derivatives in the xi-eta direction.

Definition: fe_base.h:685

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phidxidzeta()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidxidzeta ( ) const

inline

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

Definition at line 395 of file fe_base.h.

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

396 { libmesh_assert(!calculations_started || calculate_d2phi);

397 calculate_d2phi = calculate_dphiref = true; return d2phidxidzeta; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

libMesh::FEGenericBase::d2phidxidzeta

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function second derivatives in the xi-zeta direction.

Definition: fe_base.h:690

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phidy2()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidy2 ( ) const

inline

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

Definition at line 355 of file fe_base.h.

356 { libmesh_assert(!calculations_started || calculate_d2phi);

357 calculate_d2phi = calculate_dphiref = true; return d2phidy2; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

libMesh::FEGenericBase::d2phidy2

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function second derivatives in the y direction.

Definition: fe_base.h:725

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phidydz()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidydz ( ) const

inline

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

Definition at line 363 of file fe_base.h.

364 { libmesh_assert(!calculations_started || calculate_d2phi);

365 calculate_d2phi = calculate_dphiref = true; return d2phidydz; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

libMesh::FEGenericBase::d2phidydz

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function second derivatives in the y-z direction.

Definition: fe_base.h:730

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_d2phidz2()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidz2 ( ) const

inline

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

Definition at line 371 of file fe_base.h.

372 { libmesh_assert(!calculations_started || calculate_d2phi);

373 calculate_d2phi = calculate_dphiref = true; return d2phidz2; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

libMesh::FEGenericBase::d2phidz2

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

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

Shape function second derivatives in the z direction.

Definition: fe_base.h:735

◆ get_d2phidzeta2()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_d2phidzeta2 ( ) const

inline

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

Definition at line 419 of file fe_base.h.

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

420 { libmesh_assert(!calculations_started || calculate_d2phi);

421 calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

libMesh::FEGenericBase::d2phidzeta2

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

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

Shape function second derivatives in the zeta direction.

Definition: fe_base.h:705

◆ get_d2xyzdeta2()

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

inlineinherited

Returns: The second partial derivatives in eta.

Definition at line 343 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

344 { calculate_map = true; return this->_fe_map->get_d2xyzdeta2(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_d2xyzdetadzeta()

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

inlineinherited

Returns: The second partial derivatives in eta-zeta.

Definition at line 371 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

372 { calculate_map = true; return this->_fe_map->get_d2xyzdetadzeta(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_d2xyzdxi2()

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

inlineinherited

Returns: The second partial derivatives in xi.

Definition at line 336 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

337 { calculate_map = true; return this->_fe_map->get_d2xyzdxi2(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_d2xyzdxideta()

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

inlineinherited

Returns: The second partial derivatives in xi-eta.

Definition at line 357 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

358 { calculate_map = true; return this->_fe_map->get_d2xyzdxideta(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_d2xyzdxidzeta()

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

inlineinherited

Returns: The second partial derivatives in xi-zeta.

Definition at line 364 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

365 { calculate_map = true; return this->_fe_map->get_d2xyzdxidzeta(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_d2xyzdzeta2()

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

inlineinherited

Returns: The second partial derivatives in zeta.

Definition at line 350 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

351 { calculate_map = true; return this->_fe_map->get_d2xyzdzeta2(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_detadx()

virtual_for_inffe 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 405 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

406 { calculate_map = true; return this->_fe_map->get_detadx(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_detady()

virtual_for_inffe 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 413 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

414 { calculate_map = true; return this->_fe_map->get_detady(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_detadz()

virtual_for_inffe 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 421 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

422 { calculate_map = true; return this->_fe_map->get_detadz(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_dim()

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

inlineinherited

Returns: the dimension of this FE

Definition at line 258 of file fe_abstract.h.

References libMesh::FEAbstract::dim.

259 { return dim; }

libMesh::FEAbstract::dim

const unsigned int dim

The dimensionality of the object.

Definition: fe_abstract.h:660

◆ get_div_phi()

template<typename OutputType>

virtual_for_inffe const std::vector<std::vector<OutputDivergence> >& libMesh::FEGenericBase< OutputType >::get_div_phi ( ) const

inline

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

Definition at line 261 of file fe_base.h.

Referenced by libMesh::ExactSolution::_compute_error(), and libMesh::FEMContext::interior_div().

262 { libmesh_assert(!calculations_started || calculate_div_phi);

263 calculate_div_phi = calculate_dphiref = true; return div_phi; }

libMesh::FEAbstract::calculate_div_phi

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

bool calculate_div_phi

Should we calculate shape function divergences?

Definition: fe_abstract.h:717

libMesh::FEGenericBase::div_phi

libmesh_assert(ctx)

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

Shape function divergence values.

Definition: fe_base.h:636

libMesh::FEGenericBase::dphase

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_dphase()

template<typename OutputType>

const std::vector<OutputGradient>& libMesh::FEGenericBase< OutputType >::get_dphase ( ) const

inline

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 437 of file fe_base.h.

Referenced by assemble_SchroedingerEquation().

438 { return dphase; }

std::vector< OutputGradient > dphase

Used for certain infinite element families: the first derivatives of the phase term in global coordin...

Definition: fe_base.h:753

◆ get_dphi()

template<typename OutputType>

const std::vector<std::vector<OutputGradient> >& libMesh::FEGenericBase< OutputType >::get_dphi ( ) const

inline

Returns: The shape function derivatives at the quadrature points.

Definition at line 230 of file fe_base.h.

Referenced by libMesh::ExactSolution::_compute_error(), assembly_with_dg_fem_context(), libMesh::FEMContext::build_new_fe(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), ElasticitySystem::element_time_derivative(), HeatSystem::element_time_derivative(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_point(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi_over_decay(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi_over_decayxR(), PoissonSystem::init_context(), LaplaceSystem::init_context(), ElasticitySystem::init_context(), libMesh::ParsedFEMFunction< T >::init_context(), HeatSystem::init_context(), libMesh::KellyErrorEstimator::init_context(), ElasticityRBConstruction::init_context(), libMesh::FEMContext::interior_gradients(), libMesh::FEGenericBase< FEOutputType< T >::type >::request_dphi(), libMesh::FEMContext::side_gradient(), libMesh::FEMContext::side_gradients(), and libMesh::FEMContext::some_gradient().

231 { libmesh_assert(!calculations_started || calculate_dphi);

232 calculate_dphi = calculate_dphiref = true; return dphi; }

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

libMesh::FEGenericBase::dphi

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

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

Shape function derivative values.

Definition: fe_base.h:620

libMesh::FEGenericBase::get_dphi

bool calculate_dphi

Should we calculate shape function gradients?

Definition: fe_abstract.h:696

◆ get_dphi_over_decay()

template<typename OutputType>

virtual const std::vector<std::vector<OutputGradient> >& libMesh::FEGenericBase< OutputType >::get_dphi_over_decay ( ) const

inlinevirtual

Returns: the gradient of the shape function (see get_dphi()), but in case of InfFE, weighted with 1/decay.

In contrast to the shape function, its gradient stays finite when divided by the decay function.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 511 of file fe_base.h.

512 { return get_dphi();}

const std::vector< std::vector< OutputGradient > > & get_dphi() const

Definition: fe_base.h:230

◆ get_dphi_over_decayxR()

template<typename OutputType>

virtual const std::vector<std::vector<OutputGradient> >& libMesh::FEGenericBase< OutputType >::get_dphi_over_decayxR ( ) const

inlinevirtual

Returns: the gradient of the shape function (see get_dphi()), but in case of InfFE, weighted with r/decay. See get_phi_over_decayxR() for details.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 501 of file fe_base.h.

Referenced by assemble_func(), and assemble_SchroedingerEquation().

502 { return get_dphi();}

libMesh::FEGenericBase::get_dphi

const std::vector< std::vector< OutputGradient > > & get_dphi() const

Definition: fe_base.h:230

◆ get_dphideta()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_dphideta ( ) const

inline

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

Definition at line 301 of file fe_base.h.

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::HDivFETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_div(), and libMesh::H1FETransformation< OutputShape >::map_dphi().

302 { libmesh_assert(!calculations_started || calculate_dphiref);

303 calculate_dphiref = true; return dphideta; }

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

libMesh::FEGenericBase::dphideta

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

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

Shape function derivatives in the eta direction.

Definition: fe_base.h:646

◆ get_dphidx()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_dphidx ( ) const

inline

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

Definition at line 269 of file fe_base.h.

270 { libmesh_assert(!calculations_started || calculate_dphi);

271 calculate_dphi = calculate_dphiref = true; return dphidx; }

libMesh::FEGenericBase::dphidx

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function derivatives in the x direction.

Definition: fe_base.h:656

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::HDivFETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_div(), and libMesh::H1FETransformation< OutputShape >::map_dphi().

bool calculate_dphi

Should we calculate shape function gradients?

Definition: fe_abstract.h:696

◆ get_dphidxi()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_dphidxi ( ) const

inline

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

Definition at line 293 of file fe_base.h.

294 { libmesh_assert(!calculations_started || calculate_dphiref);

295 calculate_dphiref = true; return dphidxi; }

libMesh::FEGenericBase::dphidxi

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

Shape function derivatives in the xi direction.

Definition: fe_base.h:641

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_dphidy()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_dphidy ( ) const

inline

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

Definition at line 277 of file fe_base.h.

278 { libmesh_assert(!calculations_started || calculate_dphi);

279 calculate_dphi = calculate_dphiref = true; return dphidy; }

libMesh::FEGenericBase::dphidy

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

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

Shape function derivatives in the y direction.

Definition: fe_base.h:661

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

bool calculate_dphi

Should we calculate shape function gradients?

Definition: fe_abstract.h:696

◆ get_dphidz()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_dphidz ( ) const

inline

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

Definition at line 285 of file fe_base.h.

286 { libmesh_assert(!calculations_started || calculate_dphi);

287 calculate_dphi = calculate_dphiref = true; return dphidz; }

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

libMesh::FEGenericBase::dphidz

bool calculate_dphi

Should we calculate shape function gradients?

Definition: fe_abstract.h:696

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

Shape function derivatives in the z direction.

Definition: fe_base.h:666

◆ get_dphidzeta()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_dphidzeta ( ) const

inline

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

Definition at line 309 of file fe_base.h.

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::HDivFETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_div(), and libMesh::H1FETransformation< OutputShape >::map_dphi().

310 { libmesh_assert(!calculations_started || calculate_dphiref);

311 calculate_dphiref = true; return dphidzeta; }

libMesh::FEGenericBase::dphidzeta

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

Shape function derivatives in the zeta direction.

Definition: fe_base.h:651

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

libmesh_assert(ctx)

libMesh::FEGenericBase::dual_coeff

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

◆ get_dual_coeff()

template<typename OutputType>

const DenseMatrix<Real>& libMesh::FEGenericBase< OutputType >::get_dual_coeff ( ) const

inline

Definition at line 244 of file fe_base.h.

245 { return dual_coeff; }

DenseMatrix< Real > dual_coeff

Coefficient matrix for the dual basis.

Definition: fe_base.h:626

◆ get_dual_d2phi()

template<typename OutputType>

const std::vector<std::vector<OutputTensor> >& libMesh::FEGenericBase< OutputType >::get_dual_d2phi ( ) const

inline

Definition at line 323 of file fe_base.h.

324 { libmesh_assert(!calculations_started || calculate_d2phi);

325 calculate_d2phi = calculate_dual = calculate_dphiref = true; return dual_d2phi; }

bool calculate_d2phi

Should we calculate shape function hessians?

Definition: fe_abstract.h:702

libMesh::FEGenericBase::dual_d2phi

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

std::vector< std::vector< OutputTensor > > dual_d2phi

Definition: fe_base.h:675

libmesh_assert(ctx)

libMesh::FEAbstract::calculate_dual

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

bool calculate_dual

Are we calculating dual basis?

Definition: fe_abstract.h:671

◆ get_dual_dphi()

template<typename OutputType>

const std::vector<std::vector<OutputGradient> >& libMesh::FEGenericBase< OutputType >::get_dual_dphi ( ) const

inline

Definition at line 234 of file fe_base.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::request_dual_dphi().

235 { libmesh_assert(!calculations_started || calculate_dphi);

236 calculate_dphi = calculate_dual = calculate_dphiref = true; return dual_dphi; }

libMesh::FEGenericBase::dual_dphi

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

std::vector< std::vector< OutputGradient > > dual_dphi

Definition: fe_base.h:621

libmesh_assert(ctx)

bool calculate_dphiref

Should we calculate reference shape function gradients?

Definition: fe_abstract.h:722

libMesh::FEAbstract::calculate_dual

bool calculate_dphi

Should we calculate shape function gradients?

Definition: fe_abstract.h:696

bool calculate_dual

Are we calculating dual basis?

Definition: fe_abstract.h:671

◆ get_dual_phi()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_dual_phi ( ) const

inline

Definition at line 211 of file fe_base.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::request_dual_phi().

   {
     libmesh_assert(!calculations_started || calculate_dual);
     calculate_dual = true;
     // Dual phi computation relies on primal phi computation
     this->request_phi();
     return dual_phi;
   }

◆ get_dxidx()

virtual_for_inffe 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 381 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

382 { calculate_map = true; return this->_fe_map->get_dxidx(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_dxidy()

virtual_for_inffe 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 389 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

390 { calculate_map = true; return this->_fe_map->get_dxidy(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_dxidz()

virtual_for_inffe 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 397 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

398 { calculate_map = true; return this->_fe_map->get_dxidz(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_dxyzdeta()

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

inlineinherited

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

Definition at line 319 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

320 { calculate_map = true; return this->_fe_map->get_dxyzdeta(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_dxyzdxi()

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

inlineinherited

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

Definition at line 311 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

312 { calculate_map = true; return this->_fe_map->get_dxyzdxi(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_dxyzdzeta()

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

inlineinherited

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

Definition at line 327 of file fe_abstract.h.

328 { return _fe_map->get_dxyzdzeta(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_dzetadx()

virtual_for_inffe 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 429 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

430 { calculate_map = true; return this->_fe_map->get_dzetadx(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_dzetady()

virtual_for_inffe 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 437 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

438 { calculate_map = true; return this->_fe_map->get_dzetady(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_dzetadz()

virtual_for_inffe 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 445 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

446 { calculate_map = true; return this->_fe_map->get_dzetadz(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

libMesh::FEAbstract::_elem

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_elem()

const Elem* libMesh::FEAbstract::get_elem ( ) const

inlineinherited

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

Definition at line 496 of file fe_abstract.h.

References libMesh::FEAbstract::_elem.

496 { return _elem; }

const Elem * _elem

The element the current data structures were set up for.

Definition: fe_abstract.h:740

◆ get_family()

FEFamily libMesh::FEAbstract::get_family ( ) const

inlineinherited

Returns: The finite element family of this element.

Definition at line 547 of file fe_abstract.h.

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

547 { return fe_type.family; }

libMesh::FEType::family

FEFamily family

The type of finite element.

Definition: fe_type.h:228

FEType fe_type

The finite element type for this object.

Definition: fe_abstract.h:730

◆ get_fe_map() [1/2]

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

inlineinherited

Returns: The mapping object

Note: for InfFE, this gives a useless object.

Definition at line 554 of file fe_abstract.h.

554 { return *_fe_map.get(); }

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_fe_map() [2/2]

FEMap& libMesh::FEAbstract::get_fe_map ( )

inlineinherited

Definition at line 555 of file fe_abstract.h.

555 { return *_fe_map.get(); }

Referenced by libMesh::RBConstruction::add_scaled_matrix_and_vector(), assemble_func(), assemble_SchroedingerEquation(), libMesh::FEMContext::build_new_fe(), libMesh::HCurlFETransformation< OutputShape >::map_phi(), libMesh::HDivFETransformation< OutputShape >::map_phi(), libMesh::H1FETransformation< OutputShape >::map_phi(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ 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 520 of file fe_abstract.h.

References libMesh::FEAbstract::fe_type.

520 { return fe_type; }

Referenced by libMesh::ExactSolution::_compute_error(), assembly_with_dg_fem_context(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), compute_enriched_soln(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), ElasticitySystem::element_time_derivative(), HeatSystem::element_time_derivative(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEAbstract::get_JxWxdecay_sq(), CoupledSystemQoI::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), PoissonSystem::init_context(), LaplaceSystem::init_context(), CurlCurlSystem::init_context(), ElasticitySystem::init_context(), CoupledSystem::init_context(), libMesh::DiscontinuityMeasure::init_context(), HeatSystem::init_context(), ElasticityRBConstruction::init_context(), libMesh::FEMSystem::init_context(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), ElasticitySystem::mass_residual(), libMesh::FEMPhysics::mass_residual(), Integrate::operator()(), SolidSystem::side_time_derivative(), ElasticitySystem::side_time_derivative(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

FEType fe_type

The finite element type for this object.

Definition: fe_abstract.h:730

◆ 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 & [name, cd] : _counts)
     oss << "| " << name << " reference count information:\n"
         << "|  Creations:    " << cd.first    << '\n'
         << "|  Destructions: " << cd.second << '\n';
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

◆ get_JxW()

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

inlineinherited

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

For InfFE, use get_JxWxdecay_sq() instead.

Definition at line 303 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

304 { calculate_map = true; return this->_fe_map->get_JxW(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

libMesh::FEAbstract::get_JxW

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_JxWxdecay_sq()

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

inlinevirtualinherited

This function is the variant of get_JxW() for InfFE.

Since J diverges there, a respectize decay-function must be applied to obtain well-defined quantities.

For FE, it is equivalent to the common get_JxW().

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 292 of file fe_abstract.h.

References libMesh::FEAbstract::get_JxW().

Referenced by assemble_func(), and assemble_SchroedingerEquation().

293 { return get_JxW();}

virtual_for_inffe const std::vector< Real > & get_JxW() const

Definition: fe_abstract.h:303

◆ get_normals()

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

inlineinherited

Returns: The outward pointing normal vectors for face integration.

Definition at line 459 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

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

460 { calculate_map = true; return this->_fe_map->get_normals(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

libMesh::FEAbstract::calculate_nothing

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_nothing()

void libMesh::FEAbstract::get_nothing ( ) const

inlineinherited

Returns: nothing, but lets the FE know you're explicitly prerequesting calculations. This is useful when you only want the FE for n_quadrature_points, n_dofs_on_side, or other methods that don't require shape function calculations, but you don't want libMesh "backwards compatibility" mode to assume you've made no prerequests and need to calculate everything.

Definition at line 269 of file fe_abstract.h.

References libMesh::FEAbstract::calculate_nothing.

Referenced by libMesh::ExactSolution::_compute_error(), CoupledSystemQoI::init_context(), NavierSystem::init_context(), ElasticitySystem::init_context(), CoupledSystem::init_context(), libMesh::ParsedFEMFunction< T >::init_context(), libMesh::WrappedFunctor< Output >::init_context(), HeatSystem::init_context(), and Integrate::operator()().

270 { calculate_nothing = true; }

bool calculate_nothing

Are we potentially deliberately calculating nothing?

Definition: fe_abstract.h:681

◆ get_order()

Order libMesh::FEAbstract::get_order ( ) const

inlineinherited

Returns: The approximation order of the finite element.

Definition at line 525 of file fe_abstract.h.

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

526 { return fe_type.order + _p_level; }

libMesh::FEAbstract::_p_level

unsigned int _p_level

The p refinement level the current data structures are set up for.

Definition: fe_abstract.h:757

libMesh::FEType::order

OrderWrapper order

The approximation order of the element (at 0 p-refinement level).

Definition: fe_type.h:203

libMesh::FEAbstract::_p_level

FEType fe_type

The finite element type for this object.

Definition: fe_abstract.h:730

◆ 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 515 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level.

515 { return _p_level; }

unsigned int _p_level

The p refinement level the current data structures are set up for.

Definition: fe_abstract.h:757

◆ get_phi()

template<typename OutputType>

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_phi ( ) const

inline

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

Definition at line 207 of file fe_base.h.

208 { libmesh_assert(!calculations_started || calculate_phi);

209 calculate_phi = true; return phi; }

libMesh::FEAbstract::calculate_phi

bool calculations_started

Have calculations with this object already been started? Then all get_* functions should already have...

Definition: fe_abstract.h:666

bool calculate_phi

Should we calculate shape functions?

Definition: fe_abstract.h:691

libMesh::FEGenericBase::phi

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

Shape function values.

Definition: fe_base.h:614

libMesh::FEGenericBase::get_phi

libmesh_assert(ctx)

◆ get_phi_over_decayxR()

template<typename OutputType>

virtual const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< OutputType >::get_phi_over_decayxR ( ) const

inlinevirtual

Returns: The shape function phi (for FE) and phi weighted by r/decay for InfFE.

To compensate for the decay function applied to the Jacobian (see get_JxWxdecay_sq), the wave function phi should be divided by this function.

The factor r must be compensated for by the Sobolev weight. (i.e. by using get_Sobolev_weightxR_sq())

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 493 of file fe_base.h.

Referenced by assemble_func(), and assemble_SchroedingerEquation().

494 { return get_phi();}

const std::vector< std::vector< OutputShape > > & get_phi() const

Definition: fe_base.h:207

◆ 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 400 of file fe_abstract.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::invalid_uint, n_nodes, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::Real, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, libMesh::TRISHELL3, and libMesh::Elem::type_to_n_nodes_map.

Referenced by libMesh::LIBMESH_DEFAULT_VECTORIZED_FE().

 {
   const unsigned int n_nodes = Elem::type_to_n_nodes_map[itemType];
   if (n_nodes == invalid_uint)
     libmesh_error_msg("Number of nodes is not well-defined for " <<
                       Utility::enum_to_string(itemType));
 
   nodes.resize(n_nodes);
   switch(itemType)
     {
     case NODEELEM:
       {
         nodes[0] = Point (0.,0.,0.);
         return;
       }
     case EDGE3:
       {
         nodes[2] = Point (0.,0.,0.);
         libmesh_fallthrough();
       }
     case EDGE2:
       {
         nodes[0] = Point (-1.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         return;
       }
     case EDGE4: // not nested with EDGE3
       {
         nodes[0] = Point (-1.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (-1./3.,0.,0.);
         nodes[3] - Point (1./3.,0.,0.);
         return;
       }
     case TRI7:
       {
         nodes[6] = Point (1./3.,1./3.,0.);
         libmesh_fallthrough();
       }
     case TRI6:
       {
         nodes[3] = Point (.5,0.,0.);
         nodes[4] = Point (.5,.5,0.);
         nodes[5] = Point (0.,.5,0.);
         libmesh_fallthrough();
       }
     case TRI3:
     case TRISHELL3:
       {
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         return;
       }
     case QUAD9:
     case QUADSHELL9:
       {
         nodes[8] = Point (0.,0.,0.);
         libmesh_fallthrough();
       }
     case QUAD8:
     case QUADSHELL8:
       {
         nodes[4] = Point (0.,-1.,0.);
         nodes[5] = Point (1.,0.,0.);
         nodes[6] = Point (0.,1.,0.);
         nodes[7] = Point (-1.,0.,0.);
         libmesh_fallthrough();
       }
     case QUAD4:
     case QUADSHELL4:
       {
         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 TET14:
       {
         nodes[10] = Point (1/Real(3),1/Real(3),0.);
         nodes[11] = Point (1/Real(3),0.,1/Real(3));
         nodes[12] = Point (1/Real(3),1/Real(3),1/Real(3));
         nodes[13] = Point (0.,1/Real(3),1/Real(3));
         libmesh_fallthrough();
       }
     case TET10:
       {
         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);
         libmesh_fallthrough();
       }
     case TET4:
       {
         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 HEX27:
       {
         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.);
         libmesh_fallthrough();
       }
     case HEX20:
       {
         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.);
         libmesh_fallthrough();
       }
     case HEX8:
       {
         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 PRISM21:
       {
         nodes[20] = Point (1/Real(3),1/Real(3),0);
         libmesh_fallthrough();
       }
     case PRISM20:
       {
         nodes[18] = Point (1/Real(3),1/Real(3),-1);
         nodes[19] = Point (1/Real(3),1/Real(3),1);
         libmesh_fallthrough();
       }
     case PRISM18:
       {
         nodes[15] = Point (.5,0.,0.);
         nodes[16] = Point (.5,.5,0.);
         nodes[17] = Point (0.,.5,0.);
         libmesh_fallthrough();
       }
     case PRISM15:
       {
         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.);
         libmesh_fallthrough();
       }
     case PRISM6:
       {
         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 PYRAMID18:
       {
         // triangle centers
         nodes[14] = Point (-2/Real(3),0.,1/Real(3));
         nodes[15] = Point (0.,2/Real(3),1/Real(3));
         nodes[16] = Point (2/Real(3),0.,1/Real(3));
         nodes[17] = Point (0.,-2/Real(3),1/Real(3));
 
         libmesh_fallthrough();
       }
     case PYRAMID14:
       {
         // base center
         nodes[13] = Point (0.,0.,0.);
 
         libmesh_fallthrough();
       }
     case PYRAMID13:
       {
         // 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);
 
         libmesh_fallthrough();
       }
     case PYRAMID5:
       {
         // 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.);
         return;
       }
 
     default:
       libmesh_error_msg("ERROR: Unknown element type " << Utility::enum_to_string(itemType));
     }
 }

◆ get_Sobolev_dweight()

template<typename OutputType>

virtual const std::vector<RealGradient>& libMesh::FEGenericBase< OutputType >::get_Sobolev_dweight ( ) const

inlinevirtual

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.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 461 of file fe_base.h.

462 { return dweight; }

libMesh::FEGenericBase::dweight

std::vector< RealGradient > dweight

Used for certain infinite element families: the global derivative of the additional radial weight ...

Definition: fe_base.h:760

◆ get_Sobolev_dweightxR_sq()

template<typename OutputType>

virtual const std::vector<RealGradient>& libMesh::FEGenericBase< OutputType >::get_Sobolev_dweightxR_sq ( ) const

inlinevirtual

Returns: The first global derivative of the multiplicative weight (see dget_Sobolev_weight) but weighted with the square of the radial coordinate.

In finite elements, this is 0.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 480 of file fe_base.h.

Referenced by assemble_func(), and assemble_SchroedingerEquation().

481 { return dweight; }

libMesh::FEGenericBase::dweight

std::vector< RealGradient > dweight

Used for certain infinite element families: the global derivative of the additional radial weight ...

Definition: fe_base.h:760

◆ get_Sobolev_weight()

template<typename OutputType>

virtual const std::vector<Real>& libMesh::FEGenericBase< OutputType >::get_Sobolev_weight ( ) const

inlinevirtual

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.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 453 of file fe_base.h.

454 { return weight; }

libMesh::FEGenericBase::weight

std::vector< Real > weight

Used for certain infinite element families: the additional radial weight in local coordinates...

Definition: fe_base.h:767

◆ get_Sobolev_weightxR_sq()

template<typename OutputType>

virtual const std::vector<Real>& libMesh::FEGenericBase< OutputType >::get_Sobolev_weightxR_sq ( ) const

inlinevirtual

Returns: The multiplicative weight (see get_Sobolev_weight) but weighted with the radial coordinate square.

In finite elements, this gives just 1, similar to get_Sobolev_Weight()

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 470 of file fe_base.h.

Referenced by assemble_func(), and assemble_SchroedingerEquation().

471 { return weight; }

libMesh::FEGenericBase::weight

std::vector< Real > weight

Used for certain infinite element families: the additional radial weight in local coordinates...

Definition: fe_base.h:767

◆ get_tangents()

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

inlineinherited

Returns: The tangent vectors for face integration.

Definition at line 452 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

453 { calculate_map = true; return this->_fe_map->get_tangents(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

libMesh::FEAbstract::_elem_type

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ get_type()

ElemType libMesh::FEAbstract::get_type ( ) const

inlineinherited

Returns: The element type that the current shape functions have been calculated for, or INVALID_ELEM if no such element exists. Useful in determining when shape functions must be recomputed.

This is generally redundant with _elem->type(), but must be cached separately for cases (such as internal FE use in QComposite) where _elem might be a dangling pointer to a temporary.

Definition at line 509 of file fe_abstract.h.

References libMesh::FEAbstract::_elem_type.

509 { return _elem_type; }

ElemType _elem_type

The element type the current data structures were set up for.

Definition: fe_abstract.h:735

◆ get_xyz()

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

inlineinherited

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

It is overwritten by infinite elements since there FEMap cannot be used to compute xyz.

Definition at line 280 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

Referenced by libMesh::ExactSolution::_compute_error(), assemble_SchroedingerEquation(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), compute_enriched_soln(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), HeatSystem::element_time_derivative(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ParsedFEMFunction< T >::eval_args(), libMesh::ExactErrorEstimator::find_squared_element_error(), CoupledSystemQoI::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), PoissonSystem::init_context(), CurlCurlSystem::init_context(), CoupledSystem::init_context(), libMesh::ParsedFEMFunction< T >::init_context(), HeatSystem::init_context(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), Integrate::operator()(), SolidSystem::side_time_derivative(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor(), SlitMeshRefinedSystemTest::testRestart(), and SlitMeshRefinedSystemTest::testSystem().

281 { calculate_map = true; return this->_fe_map->get_xyz(); }

bool calculate_map

Are we calculating mapping functions?

Definition: fe_abstract.h:686

libMesh::ReferenceCounter::_n_objects

std::unique_ptr< FEMap > _fe_map

Definition: fe_abstract.h:654

◆ increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

 {
   libmesh_try
   {
     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     std::pair<unsigned int, unsigned int> & p = _counts[name];
     p.first++;
   }
   libmesh_catch (...)
   {
     auto stream = libMesh::err.get();
     stream->exceptions(stream->goodbit); // stream must not throw
     libMesh::err << "Encountered unrecoverable error while calling "
                  << "ReferenceCounter::increment_constructor_count() "
                  << "for a(n) " << name << " object." << std::endl;
     std::terminate();
   }
 }

◆ increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

 {
   libmesh_try
   {
     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     std::pair<unsigned int, unsigned int> & p = _counts[name];
     p.second++;
   }
   libmesh_catch (...)
   {
     auto stream = libMesh::err.get();
     stream->exceptions(stream->goodbit); // stream must not throw
     libMesh::err << "Encountered unrecoverable error while calling "
                  << "ReferenceCounter::increment_destructor_count() "
                  << "for a(n) " << name << " object." << std::endl;
     std::terminate();
   }
 }

◆ init_base_shape_functions()

template<typename OutputType>

virtual void libMesh::FEGenericBase< OutputType >::init_base_shape_functions	(	const std::vector< Point > &	qp,
		const Elem *	e
	)

protectedpure virtual

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

Implement this in the derived class FE<Dim,T>.

◆ is_hierarchic()

virtual bool libMesh::FEAbstract::is_hierarchic ( ) const

pure virtualinherited

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

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

86 { return _n_objects; }

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition: reference_counter.h:132

◆ n_quadrature_points()

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

virtualinherited

Returns: The total number of quadrature points with which this was last reinitialized. Useful during matrix assembly.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 1279 of file fe_abstract.C.

References libMesh::FEAbstract::_n_total_qp, libMesh::libmesh_assert(), libMesh::QBase::n_points(), libMesh::FEAbstract::qrule, and libMesh::FEAbstract::shapes_on_quadrature.

Referenced by assemble_func(), assemble_SchroedingerEquation(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), and libMesh::KellyErrorEstimator::internal_side_integration().

 {
   if (this->shapes_on_quadrature)
     {
       libmesh_assert(this->qrule);
       libmesh_assert_equal_to(this->qrule->n_points(),
                               this->_n_total_qp);
     }
   return this->_n_total_qp;
 }

◆ n_shape_functions()

virtual unsigned int libMesh::FEAbstract::n_shape_functions ( ) const

pure virtualinherited

Returns: The total number of approximation shape functions for the current element. Useful during matrix assembly. Implement this in derived classes.

◆ 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 \).

Deprecated:: This method overload does not support all finite element types; e.g. the reference element for an arbitrary polygon or polyhedron type may differ from element to element. Use Elem::on_reference_element() instead.

Definition at line 637 of file fe_abstract.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::Real, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::TRISHELL3.

Referenced by libMesh::FEInterface::ifem_on_reference_element(), and libMesh::FEInterface::on_reference_element().

 {
   // Use Elem::on_reference_element() instead
   libmesh_deprecated();
 
   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:
     case TRI7:
       {
         // 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:
     case QUADSHELL9:
       {
         // 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:
     case TET14:
       {
         // 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:
     case PRISM20:
     case PRISM21:
       {
         // 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:
     case PYRAMID18:
       {
         // 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 " << Utility::enum_to_string(t));
     }
 
   // If we get here then the point is _not_ in the
   // reference element.   Better return false.
 
   return false;
 }

◆ print_d2phi()

template<typename OutputType >

void libMesh::FEGenericBase< OutputType >::print_d2phi ( std::ostream & os ) const

overridevirtual

Prints the value of each shape function's second derivatives at each quadrature point.

Implements libMesh::FEAbstract.

Definition at line 953 of file fe_base.C.

 {
   for (auto i : index_range(dphi))
     for (auto j : index_range(dphi[i]))
       os << " d2phi[" << i << "][" << j << "]=" << d2phi[i][j];
 }

◆ print_dphi()

template<typename OutputType >

void libMesh::FEGenericBase< OutputType >::print_dphi ( std::ostream & os ) const

overridevirtual

Prints the value of each shape function's derivative at each quadrature point.

Implements libMesh::FEAbstract.

Definition at line 895 of file fe_base.C.

 {
   for (auto i : index_range(dphi))
     for (auto j : index_range(dphi[i]))
       os << " dphi[" << i << "][" << j << "]=" << dphi[i][j];
 }

◆ print_dual_d2phi()

template<typename OutputType >

void libMesh::FEGenericBase< OutputType >::print_dual_d2phi ( std::ostream & os ) const

overridevirtual

Implements libMesh::FEAbstract.

Definition at line 961 of file fe_base.C.

 {
   for (auto i : index_range(dual_d2phi))
     for (auto j : index_range(dual_d2phi[i]))
       os << " dual_d2phi[" << i << "][" << j << "]=" << dual_d2phi[i][j];
 }

◆ print_dual_dphi()

template<typename OutputType >

void libMesh::FEGenericBase< OutputType >::print_dual_dphi ( std::ostream & os ) const

overridevirtual

Implements libMesh::FEAbstract.

Definition at line 903 of file fe_base.C.

 {
   for (auto i : index_range(dphi))
     for (auto j : index_range(dphi[i]))
       os << " dual_dphi[" << i << "][" << j << "]=" << dual_dphi[i][j];
 }

◆ print_dual_phi()

template<typename OutputType >

void libMesh::FEGenericBase< OutputType >::print_dual_phi ( std::ostream & os ) const

overridevirtual

Implements libMesh::FEAbstract.

Definition at line 884 of file fe_base.C.

 {
   for (auto i : index_range(dual_phi))
     for (auto j : index_range(dual_phi[i]))
       os << " dual_phi[" << i << "][" << j << "]=" << dual_phi[i][j] << std::endl;
 }

◆ print_info() [1/2]

void libMesh::ReferenceCounter::print_info ( std::ostream & out_stream = libMesh::out )

staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 81 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

 {
   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 859 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 846 of file fe_abstract.C.

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

 {
   this->_fe_map->print_JxW(os);
 }

◆ print_phi()

template<typename OutputType >

void libMesh::FEGenericBase< OutputType >::print_phi ( std::ostream & os ) const

overridevirtual

Prints the value of each shape function at each quadrature point.

Implements libMesh::FEAbstract.

Definition at line 876 of file fe_base.C.

 {
   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 853 of file fe_abstract.C.

Referenced by libMesh::ExactSolution::_compute_error(), assemble_func(), assemble_SchroedingerEquation(), libMesh::FEMContext::build_new_fe(), compute_enriched_soln(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::JumpErrorEstimator::reinit_sides(), and InfFERadialTest::testRefinement().

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

 {
   this->_fe_map->print_xyz(os);
 }

◆ reinit() [1/2]

virtual void libMesh::FEAbstract::reinit	(	const Elem *	elem,
		const std::vector< Point > *const	pts = `nullptr`,
		const std::vector< Real > *const	weights = `nullptr`
	)

pure virtualinherited

This is at the core of this class.

Use this for each new element in the mesh. Reinitializes the requested physical element-dependent data based on the current element elem. By default the element data are computed at the quadrature points specified by the quadrature rule qrule, but any set of points on the reference element may be specified in the optional argument pts.

Note: The FE classes decide which data to initialize based on which accessor functions such as get_phi() or get_d2phi() have been called, so all such accessors should be called before the first reinit().

◆ reinit() [2/2]

virtual void libMesh::FEAbstract::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`
	)

pure virtualinherited

Reinitializes all the physical element-dependent data based on the side of the element elem.

The tolerance parameter is passed to the involved call to inverse_map(). By default the element data are computed at the quadrature points specified by the quadrature rule qrule, but any set of points on the reference side element may be specified in the optional argument pts.

◆ reinit_default_dual_shape_coeffs()

virtual void libMesh::FEAbstract::reinit_default_dual_shape_coeffs ( const Elem * )

inlinevirtualinherited

This re-computes the dual shape function coefficients using DEFAULT qrule.

This has not been implemented for InfFE

Definition at line 161 of file fe_abstract.h.

   {
     libmesh_error_msg("Default dual shape coefficient calculation has not been implemented for this FE type.");
   }

◆ reinit_dual_shape_coeffs()

virtual void libMesh::FEAbstract::reinit_dual_shape_coeffs	(	const Elem *	,
		const std::vector< Point > &	,
		const std::vector< Real > &
	)

inlinevirtualinherited

This re-computes the dual shape function coefficients using CUSTOMIZED qrule.

The dual shape coefficients are utilized when calculating dual shape functions. This has not been implemented for InfFE

Definition at line 150 of file fe_abstract.h.

   {
     libmesh_error_msg("Customized dual shape coefficient calculation has not been implemented for this FE type.");
   }

◆ request_dphi()

template<typename OutputType>

virtual void libMesh::FEGenericBase< OutputType >::request_dphi ( ) const

inlineoverridevirtual

request dphi calculations

Implements libMesh::FEAbstract.

Definition at line 238 of file fe_base.h.

239 { get_dphi(); }

libMesh::FEGenericBase::get_dphi

const std::vector< std::vector< OutputGradient > > & get_dphi() const

Definition: fe_base.h:230

◆ request_dual_dphi()

template<typename OutputType>

virtual void libMesh::FEGenericBase< OutputType >::request_dual_dphi ( ) const

inlineoverridevirtual

Implements libMesh::FEAbstract.

Definition at line 241 of file fe_base.h.

242 { get_dual_dphi(); }

libMesh::FEGenericBase::get_dual_dphi

const std::vector< std::vector< OutputGradient > > & get_dual_dphi() const

Definition: fe_base.h:234

◆ request_dual_phi()

template<typename OutputType>

virtual void libMesh::FEGenericBase< OutputType >::request_dual_phi ( ) const

inlineoverridevirtual

Implements libMesh::FEAbstract.

Definition at line 223 of file fe_base.h.

224 { get_dual_phi(); }

libMesh::FEGenericBase::get_dual_phi

const std::vector< std::vector< OutputShape > > & get_dual_phi() const

Definition: fe_base.h:211

◆ request_phi()

template<typename OutputType>

virtual void libMesh::FEGenericBase< OutputType >::request_phi ( ) const

inlineoverridevirtual

request phi calculations

Implements libMesh::FEAbstract.

Definition at line 220 of file fe_base.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_dual_phi().

221 { get_phi(); }

libMesh::FEGenericBase::get_phi

const std::vector< std::vector< OutputShape > > & get_phi() const

Definition: fe_base.h:207

◆ set_calculate_default_dual_coeff()

void libMesh::FEAbstract::set_calculate_default_dual_coeff ( const bool val )

inlineinherited

set calculate_default_dual_coeff as needed

Definition at line 626 of file fe_abstract.h.

References libMesh::FEAbstract::calculate_default_dual_coeff.

626 {calculate_default_dual_coeff = val; }

libMesh::FEAbstract::calculate_default_dual_coeff

bool calculate_default_dual_coeff

Are we calculating the coefficient for the dual basis using the default qrule?

Definition: fe_abstract.h:676

◆ set_calculate_dual()

void libMesh::FEAbstract::set_calculate_dual ( const bool val )

inlineinherited

set calculate_dual as needed

Definition at line 621 of file fe_abstract.h.

References libMesh::FEAbstract::calculate_dual.

621 {calculate_dual = val; }

libMesh::FEAbstract::calculate_dual

bool calculate_dual

Are we calculating dual basis?

Definition: fe_abstract.h:671

◆ 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 531 of file fe_abstract.h.

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

531 { fe_type.order = new_order; }

libMesh::FEType::order

OrderWrapper order

The approximation order of the element (at 0 p-refinement level).

Definition: fe_type.h:203