class FEComputeData hides arbitrary data to be passed to and from children of FEBase through the FEInterface::compute_data() method. More...

#include <fe_compute_data.h>

Public Member Functions
	FEComputeData (const EquationSystems &es, const Point &pin)
	Constructor.

void	clear ()
	Clears the output data completely.

void	init ()
	Inits the output data to default values, provided the fields are correctly resized.

void	enable_derivative ()
	Enable the computation of shape gradients (dshape).

void	disable_derivative ()
	Disable the computation of shape gradients (dshape).

bool	need_derivative ()
	Check whether derivatives should be computed or not.

Public Attributes
const EquationSystems &	equation_systems
	Const reference to the `EquationSystems` object that contains simulation-specific data.

const Point &	p
	Holds the point where the data are to be computed.

std::vector< Number >	shape
	Storage for the computed shape function values.

std::vector< Gradient >	dshape
	Storage for the computed shape derivative values.

std::vector< std::vector< Real > >	local_transform
	Storage for local to global mapping at `p`.

Real	phase
	Storage for the computed phase lag.

Real	speed
	The wave speed.

Number	frequency
	The frequency to evaluate shape functions including the wave number depending terms.

Private Attributes
bool	_need_dshape
	variable indicating whether the shape-derivative should be computed or not.

Detailed Description

class FEComputeData hides arbitrary data to be passed to and from children of FEBase through the FEInterface::compute_data() method.

This enables the efficient computation of data on the finite element level, while maintaining library integrity.

With special finite elements disabled (like infinite elements), this class wraps the return values of all shape functions from FEInterface::shape() in a std::vector<Number>.
With infinite elements enabled, this class returns a vector of physically correct shape functions, both for finite and infinite elements.

Author: Daniel Dreyer

Date: 2003

Helper class used with FEInterface::compute_data().

Definition at line 51 of file fe_compute_data.h.

Constructor & Destructor Documentation

◆ FEComputeData()

libMesh::FEComputeData::FEComputeData	(	const EquationSystems &	es,
		const Point &	pin
	)

inline

Constructor.

Takes the required input data and clears the output data using clear().

Definition at line 58 of file fe_compute_data.h.

                                    :
    equation_systems(es),
    p(pin),
    _need_dshape(false)
  {
    this->clear();
  }

References clear().

Member Function Documentation

◆ clear()

void libMesh::FEComputeData::clear ( )

Clears the output data completely.

Definition at line 25 of file fe_compute_data.C.

{
  this->shape.clear();
  this->dshape.clear();
  this->local_transform.clear();
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  this->phase = 0.;
  this->speed = 1.;
  this->frequency = 1.;
 
#endif
}

References dshape, frequency, local_transform, phase, shape, and speed.

Referenced by FEComputeData().

◆ disable_derivative()

void libMesh::FEComputeData::disable_derivative ( )

inline

Disable the computation of shape gradients (dshape).

Default is disabled.

Definition at line 137 of file fe_compute_data.h.

138 {_need_dshape=false; }

References _need_dshape.

◆ enable_derivative()

void libMesh::FEComputeData::enable_derivative ( )

Enable the computation of shape gradients (dshape).

Definition at line 71 of file fe_compute_data.C.

{
  _need_dshape=true;
  if (!(this->dshape.empty()))
    std::fill (this->dshape.begin(),   this->dshape.end(),  0);
}

References _need_dshape, and dshape.

Referenced by libMesh::MeshFunction::_gradient_on_elem(), and libMesh::System::point_gradient().

◆ init()

void libMesh::FEComputeData::init ( )

Inits the output data to default values, provided the fields are correctly resized.

Definition at line 40 of file fe_compute_data.C.

{
  if (!(this->shape.empty()))
    std::fill (this->shape.begin(),   this->shape.end(),   0.);
 
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  if (equation_systems.parameters.have_parameter<Real>("speed"))
    this->speed = this->equation_systems.parameters.get<Real>("speed");
 
  // ensure that the wavenumber k=2. * libMesh::pi * frequency / speed is well-defined.
  libmesh_assert_not_equal_to(this->speed, 0);
 
  if (equation_systems.parameters.have_parameter<Number>("current frequency"))
    this->frequency = this->equation_systems.parameters.get<Number>("current frequency");
 
#if LIBMESH_USE_COMPLEX_NUMBERS
  else if (equation_systems.parameters.have_parameter<Real>("current frequency"))
    {
      // please use the type Number instead.
      libmesh_deprecated();
      this->frequency = static_cast<Number> (this->equation_systems.parameters.get<Real>("current frequency"));
    }
#endif
 
  this->phase = 0.;
 
#endif //LIBMESH_ENABLE_INFINITE_ELEMENTS
 
}

References equation_systems, frequency, libMesh::Parameters::get(), libMesh::Parameters::have_parameter(), libMesh::EquationSystems::parameters, phase, libMesh::Real, shape, and speed.

Referenced by libMesh::FEInterface::compute_data().

◆ need_derivative()

bool libMesh::FEComputeData::need_derivative ( )

inline

Check whether derivatives should be computed or not.

Definition at line 143 of file fe_compute_data.h.

144 {return _need_dshape; }

References _need_dshape.

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), and libMesh::FEInterface::compute_data().

Member Data Documentation

◆ _need_dshape

bool libMesh::FEComputeData::_need_dshape

private

variable indicating whether the shape-derivative should be computed or not.

Default is false to save time and be compatible with elements where derivatives are not implemented/ cannot be computed.

Definition at line 152 of file fe_compute_data.h.

Referenced by disable_derivative(), enable_derivative(), and need_derivative().

◆ dshape

std::vector<Gradient> libMesh::FEComputeData::dshape

Storage for the computed shape derivative values.

Definition at line 86 of file fe_compute_data.h.

Referenced by libMesh::MeshFunction::_gradient_on_elem(), clear(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::FEInterface::compute_data(), enable_derivative(), and libMesh::System::point_gradient().

◆ equation_systems

const EquationSystems& libMesh::FEComputeData::equation_systems

Const reference to the EquationSystems object that contains simulation-specific data.

Definition at line 71 of file fe_compute_data.h.

Referenced by init().

◆ frequency

Number libMesh::FEComputeData::frequency

The frequency to evaluate shape functions including the wave number depending terms.

Use imaginary contributions for exponential damping

Definition at line 114 of file fe_compute_data.h.

Referenced by clear(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), and init().

◆ local_transform

std::vector<std::vector<Real> > libMesh::FEComputeData::local_transform

Storage for local to global mapping at p.

This is needed when the gradient in physical coordinates is of interest. FIXME: What kind of type should one use for it? The matrix-class don't look as if they were made for it and neither are the TensorTool-members.

Definition at line 96 of file fe_compute_data.h.

Referenced by libMesh::MeshFunction::_gradient_on_elem(), clear(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::FEInterface::compute_data(), and libMesh::System::point_gradient().