Reference documentation for deal.II version Git 0a643de468 2022-01-18 20:23:35 -0700
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Public Types | Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType > Class Template Reference

#include <deal.II/matrix_free/fe_evaluation.h>

Inheritance diagram for FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >:
[legend]

Public Types

using number_type = Number
 
using value_type = VectorizedArrayType
 
using gradient_type = Tensor< 1, 1, VectorizedArrayType >
 
using hessian_type = Tensor< 2, 1, VectorizedArrayType >
 
using BaseClass = FEEvaluationBase< 1, 1, Number, is_face, VectorizedArrayType >
 
using NumberType = VectorizedArrayType
 
using ScalarNumber = typename internal::VectorizedArrayTrait< VectorizedArrayType >::value_type
 

Public Member Functions

value_type get_dof_value (const unsigned int dof) const
 
void submit_dof_value (const value_type val_in, const unsigned int dof)
 
value_type get_value (const unsigned int q_point) const
 
void submit_value (const value_type val_in, const unsigned int q_point)
 
void submit_value (const gradient_type val_in, const unsigned int q_point)
 
gradient_type get_gradient (const unsigned int q_point) const
 
value_type get_divergence (const unsigned int q_point) const
 
value_type get_normal_derivative (const unsigned int q_point) const
 
void submit_gradient (const gradient_type grad_in, const unsigned int q_point)
 
void submit_gradient (const value_type grad_in, const unsigned int q_point)
 
void submit_gradient (const Tensor< 2, 1, VectorizedArrayType > grad_in, const unsigned int q_point)
 
void submit_normal_derivative (const value_type grad_in, const unsigned int q_point)
 
void submit_normal_derivative (const gradient_type grad_in, const unsigned int q_point)
 
hessian_type get_hessian (unsigned int q_point) const
 
gradient_type get_hessian_diagonal (const unsigned int q_point) const
 
void submit_hessian (const hessian_type hessian_in, const unsigned int q_point)
 
value_type get_laplacian (const unsigned int q_point) const
 
value_type integrate_value () const
 
VectorizedArrayType read_cell_data (const AlignedVector< VectorizedArrayType > &array) const
 
std::array< T, VectorizedArrayType::size()> read_cell_data (const AlignedVector< std::array< T, VectorizedArrayType::size()>> &array) const
 
void set_cell_data (AlignedVector< VectorizedArrayType > &array, const VectorizedArrayType &value) const
 
void set_cell_data (AlignedVector< std::array< T, VectorizedArrayType::size()>> &array, const std::array< T, VectorizedArrayType::size()> &value) const
 
const MatrixFree< dim, Number, VectorizedArrayType > & get_matrix_free () const
 
void set_data_pointers (AlignedVector< VectorizedArrayType > *scratch_data, const unsigned int n_components)
 
void reinit_face (const internal::MatrixFreeFunctions::FaceToCellTopology< n_lanes > &face)
 
1: Reading from and writing to vectors
void read_dof_values (const VectorType &src, const unsigned int first_index=0, const std::bitset< VectorizedArrayType::size()> &mask=std::bitset< VectorizedArrayType::size()>().flip())
 
void read_dof_values_plain (const VectorType &src, const unsigned int first_index=0, const std::bitset< VectorizedArrayType::size()> &mask=std::bitset< VectorizedArrayType::size()>().flip())
 
void distribute_local_to_global (VectorType &dst, const unsigned int first_index=0, const std::bitset< VectorizedArrayType::size()> &mask=std::bitset< VectorizedArrayType::size()>().flip()) const
 
void set_dof_values (VectorType &dst, const unsigned int first_index=0, const std::bitset< VectorizedArrayType::size()> &mask=std::bitset< VectorizedArrayType::size()>().flip()) const
 
void set_dof_values_plain (VectorType &dst, const unsigned int first_index=0, const std::bitset< VectorizedArrayType::size()> &mask=std::bitset< VectorizedArrayType::size()>().flip()) const
 
2: Access to data at quadrature points or the gather vector data
void submit_dof_value (const value_type val_in, const unsigned int dof)
 
void submit_value (const value_type val_in, const unsigned int q_point)
 
void submit_gradient (const gradient_type grad_in, const unsigned int q_point)
 
void submit_normal_derivative (const value_type grad_in, const unsigned int q_point)
 
void submit_hessian (const hessian_type hessian_in, const unsigned int q_point)
 
SymmetricTensor< 2, dim, VectorizedArrayTypeget_symmetric_gradient (const unsigned int q_point) const
 
Tensor< 1,(dim==2 ? 1 :dim), VectorizedArrayTypeget_curl (const unsigned int q_point) const
 
void submit_divergence (const VectorizedArrayType div_in, const unsigned int q_point)
 
void submit_symmetric_gradient (const SymmetricTensor< 2, dim, VectorizedArrayType > grad_in, const unsigned int q_point)
 
void submit_curl (const Tensor< 1, dim==2 ? 1 :dim, VectorizedArrayType > curl_in, const unsigned int q_point)
 
1: Access to geometry data at quadrature points
ArrayView< VectorizedArrayTypeget_scratch_data () const
 
VectorizedArrayType JxW (const unsigned int q_point) const
 
Tensor< 2, dim, VectorizedArrayTypeinverse_jacobian (const unsigned int q_point) const
 
Tensor< 1, dim, VectorizedArrayTypeget_normal_vector (const unsigned int q_point) const
 
2: Access to internal data arrays
const VectorizedArrayTypebegin_dof_values () const
 
VectorizedArrayTypebegin_dof_values ()
 
const VectorizedArrayTypebegin_values () const
 
VectorizedArrayTypebegin_values ()
 
const VectorizedArrayTypebegin_gradients () const
 
VectorizedArrayTypebegin_gradients ()
 
const VectorizedArrayTypebegin_hessians () const
 
VectorizedArrayTypebegin_hessians ()
 
3: Information about the current cell this class operates on
unsigned int get_mapping_data_index_offset () const
 
internal::MatrixFreeFunctions::GeometryType get_cell_type () const
 
const ShapeInfoTypeget_shape_info () const
 
const internal::MatrixFreeFunctions::DoFInfoget_dof_info () const
 
const std::vector< unsigned int > & get_internal_dof_numbering () const
 
unsigned int get_quadrature_index () const
 
unsigned int get_current_cell_index () const
 
unsigned int get_active_fe_index () const
 
unsigned int get_active_quadrature_index () const
 
unsigned int get_first_selected_component () const
 
std::uint8_t get_face_no (const unsigned int v=0) const
 
unsigned int get_subface_index () const
 
std::uint8_t get_face_orientation (const unsigned int v=0) const
 
internal::MatrixFreeFunctions::DoFInfo::DoFAccessIndex get_dof_access_index () const
 
bool get_is_interior_face () const
 
const std::array< unsigned int, n_lanes > & get_cell_ids () const
 
unsigned int get_cell_or_face_batch_id () const
 
const std::array< unsigned int, n_lanes > & get_cell_or_face_ids () const
 

Static Public Attributes

static constexpr unsigned int dimension = 1
 
static constexpr unsigned int n_components
 
static constexpr unsigned int n_lanes
 

Protected Member Functions

 FEEvaluationAccess (const MatrixFree< 1, Number, VectorizedArrayType > &matrix_free, const unsigned int dof_no, const unsigned int first_selected_component, const unsigned int quad_no, const unsigned int fe_degree, const unsigned int n_q_points, const bool is_interior_face=true, const unsigned int active_fe_index=numbers::invalid_unsigned_int, const unsigned int active_quad_index=numbers::invalid_unsigned_int, const unsigned int face_type=numbers::invalid_unsigned_int)
 
 FEEvaluationAccess (const Mapping< 1 > &mapping, const FiniteElement< 1 > &fe, const Quadrature< 1 > &quadrature, const UpdateFlags update_flags, const unsigned int first_selected_component, const FEEvaluationData< 1, VectorizedArrayType, is_face > *other)
 
 FEEvaluationAccess (const FEEvaluationAccess &other)
 
FEEvaluationAccessoperator= (const FEEvaluationAccess &other)
 
void read_write_operation (const VectorOperation &operation, const std::array< VectorType *, n_components_ > &vectors, const std::array< const std::vector< ArrayView< const typename VectorType::value_type >> *, n_components_ > &vectors_sm, const std::bitset< VectorizedArrayType::size()> &mask, const bool apply_constraints=true) const
 
void read_write_operation_contiguous (const VectorOperation &operation, const std::array< VectorType *, n_components_ > &vectors, const std::array< const std::vector< ArrayView< const typename VectorType::value_type >> *, n_components_ > &vectors_sm, const std::bitset< VectorizedArrayType::size()> &mask) const
 
void read_write_operation_global (const VectorOperation &operation, const std::array< VectorType *, n_components_ > &vectors) const
 
void apply_hanging_node_constraints (const bool transpose) const
 

Protected Attributes

AlignedVector< VectorizedArrayType > * scratch_data_array
 
const MatrixFree< dim, Number, VectorizedArrayType > * matrix_free
 
std::vector< types::global_dof_indexlocal_dof_indices
 
const ShapeInfoTypedata
 
const DoFInfodof_info
 
const MappingInfoStorageTypemapping_data
 
const unsigned int quad_no
 
const unsigned int n_fe_components
 
const unsigned int first_selected_component
 
const unsigned int active_fe_index
 
const unsigned int active_quad_index
 
const MappingInfoStorageType::QuadratureDescriptordescriptor
 
const unsigned int n_quadrature_points
 
const Tensor< 2, dim, VectorizedArrayType > * jacobian
 
const Tensor< 1, dim *(dim+1)/2, Tensor< 1, dim, VectorizedArrayType > > * jacobian_gradients
 
const VectorizedArrayTypeJ_value
 
const Tensor< 1, dim, VectorizedArrayType > * normal_vectors
 
const Tensor< 1, dim, VectorizedArrayType > * normal_x_jacobian
 
const ScalarNumberquadrature_weights
 
ArrayView< VectorizedArrayTypescratch_data
 
VectorizedArrayTypevalues_dofs
 
VectorizedArrayTypevalues_quad
 
VectorizedArrayTypegradients_quad
 
VectorizedArrayTypegradients_from_hessians_quad
 
VectorizedArrayTypehessians_quad
 
bool is_reinitialized
 
bool dof_values_initialized
 
bool values_quad_initialized
 
bool gradients_quad_initialized
 
bool hessians_quad_initialized
 
bool values_quad_submitted
 
bool gradients_quad_submitted
 
bool hessians_quad_submitted
 
unsigned int cell
 
bool is_interior_face
 
internal::MatrixFreeFunctions::DoFInfo::DoFAccessIndex dof_access_index
 
std::array< std::uint8_t, n_lanesface_numbers
 
std::array< std::uint8_t, n_lanesface_orientations
 
unsigned int subface_index
 
internal::MatrixFreeFunctions::GeometryType cell_type
 
std::array< unsigned int, n_lanescell_ids
 
std::array< unsigned int, n_lanescell_or_face_ids
 
std::shared_ptr< internal::MatrixFreeFunctions::MappingDataOnTheFly< dim, VectorizedArrayType > > mapped_geometry
 

Detailed Description

template<typename Number, bool is_face, typename VectorizedArrayType>
class FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >

This class provides access to the data fields of the FEEvaluation classes. Partial specialization for scalar fields in 1d that defines access with simple data fields, i.e., scalars for the values and Tensor<1,1> for the gradients.

Definition at line 1193 of file fe_evaluation.h.

Member Typedef Documentation

◆ number_type

template<typename Number , bool is_face, typename VectorizedArrayType >
using FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::number_type = Number

Definition at line 1201 of file fe_evaluation.h.

◆ value_type

template<typename Number , bool is_face, typename VectorizedArrayType >
using FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::value_type = VectorizedArrayType

Definition at line 1202 of file fe_evaluation.h.

◆ gradient_type

template<typename Number , bool is_face, typename VectorizedArrayType >
using FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::gradient_type = Tensor<1, 1, VectorizedArrayType>

Definition at line 1203 of file fe_evaluation.h.

◆ hessian_type

template<typename Number , bool is_face, typename VectorizedArrayType >
using FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::hessian_type = Tensor<2, 1, VectorizedArrayType>

Definition at line 1204 of file fe_evaluation.h.

◆ BaseClass

template<typename Number , bool is_face, typename VectorizedArrayType >
using FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::BaseClass = FEEvaluationBase<1, 1, Number, is_face, VectorizedArrayType>

Definition at line 1207 of file fe_evaluation.h.

◆ NumberType

Definition at line 122 of file fe_evaluation_data.h.

◆ ScalarNumber

Definition at line 125 of file fe_evaluation_data.h.

Constructor & Destructor Documentation

◆ FEEvaluationAccess() [1/3]

template<typename Number , bool is_face, typename VectorizedArrayType >
FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::FEEvaluationAccess ( const MatrixFree< 1, Number, VectorizedArrayType > &  matrix_free,
const unsigned int  dof_no,
const unsigned int  first_selected_component,
const unsigned int  quad_no,
const unsigned int  fe_degree,
const unsigned int  n_q_points,
const bool  is_interior_face = true,
const unsigned int  active_fe_index = numbers::invalid_unsigned_int,
const unsigned int  active_quad_index = numbers::invalid_unsigned_int,
const unsigned int  face_type = numbers::invalid_unsigned_int 
)
protected

Constructor. Made protected to avoid initialization in user code. Takes all data stored in MatrixFree. If applied to problems with more than one finite element or more than one quadrature formula selected during construction of matrix_free, first_selected_component and quad_no allow to select the appropriate components.

◆ FEEvaluationAccess() [2/3]

template<typename Number , bool is_face, typename VectorizedArrayType >
FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::FEEvaluationAccess ( const Mapping< 1 > &  mapping,
const FiniteElement< 1 > &  fe,
const Quadrature< 1 > &  quadrature,
const UpdateFlags  update_flags,
const unsigned int  first_selected_component,
const FEEvaluationData< 1, VectorizedArrayType, is_face > *  other 
)
protected

Constructor with reduced functionality for similar usage of FEEvaluation as FEValues, including matrix assembly.

◆ FEEvaluationAccess() [3/3]

template<typename Number , bool is_face, typename VectorizedArrayType >
FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::FEEvaluationAccess ( const FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType > &  other)
protected

Copy constructor

Member Function Documentation

◆ get_dof_value()

template<typename Number , bool is_face, typename VectorizedArrayType >
value_type FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::get_dof_value ( const unsigned int  dof) const

Return the value stored for the local degree of freedom with index dof. If the object is vector-valued, a vector-valued return argument is given. Thus, the argument dof can at most run until dofs_per_component rather than dofs_per_cell since the different components of a vector-valued FE are return together. Note that when vectorization is enabled, values from several cells are grouped together. If set_dof_values was called last, the value corresponds to the one set there. If integrate was called last, it instead corresponds to the value of the integrated function with the test function of the given index.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_dof_value() [1/2]

template<typename Number , bool is_face, typename VectorizedArrayType >
void FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::submit_dof_value ( const value_type  val_in,
const unsigned int  dof 
)

Write a value to the field containing the degrees of freedom with component dof. Writes to the same field as is accessed through get_dof_value. Therefore, the original data that was read from a vector is overwritten as soon as a value is submitted.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ get_value()

template<typename Number , bool is_face, typename VectorizedArrayType >
value_type FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::get_value ( const unsigned int  q_point) const

Return the value of a finite element function at quadrature point number q_point after a call to FEEvaluation::evaluate() with EvaluationFlags::values set, or the value that has been stored there with a call to FEEvaluationBase::submit_value(). If the object is vector-valued, a vector-valued return argument is given. Note that when vectorization is enabled, values from several cells are grouped together.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_value() [1/3]

template<typename Number , bool is_face, typename VectorizedArrayType >
void FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::submit_value ( const value_type  val_in,
const unsigned int  q_point 
)

Write a value to the field containing the values on quadrature points with component q_point. Access to the same field as through get_value(). If applied before the function FEEvaluation::integrate() with EvaluationFlags::values set is called, this specifies the value which is tested by all basis function on the current cell and integrated over.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_value() [2/3]

template<typename Number , bool is_face, typename VectorizedArrayType >
void FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::submit_value ( const gradient_type  val_in,
const unsigned int  q_point 
)

Write a value to the field containing the values on quadrature points with component q_point. Access to the same field as through get_value(). If applied before the function FEEvaluation::integrate() with EvaluationFlags::values set is called, this specifies the value which is tested by all basis function on the current cell and integrated over.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ get_gradient()

template<typename Number , bool is_face, typename VectorizedArrayType >
gradient_type FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::get_gradient ( const unsigned int  q_point) const

Return the gradient of a finite element function at quadrature point number q_point after a call to FEEvaluation::evaluate() with EvaluationFlags::gradients, or the value that has been stored there with a call to FEEvaluationBase::submit_gradient().

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ get_divergence()

template<typename Number , bool is_face, typename VectorizedArrayType >
value_type FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::get_divergence ( const unsigned int  q_point) const

Return the divergence of a vector-valued finite element at quadrature point number q_point after a call to evaluate(...,true,...).

Note
Only available for n_components_==dim.

◆ get_normal_derivative()

template<typename Number , bool is_face, typename VectorizedArrayType >
value_type FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::get_normal_derivative ( const unsigned int  q_point) const

Return the derivative of a finite element function at quadrature point number q_point after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face: \(\boldsymbol \nabla u(\mathbf x_q) \cdot \mathbf n(\mathbf x_q)\)

This call is equivalent to calling get_gradient() * get_normal_vector() but will use a more efficient internal representation of data.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_gradient() [1/4]

template<typename Number , bool is_face, typename VectorizedArrayType >
void FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::submit_gradient ( const gradient_type  grad_in,
const unsigned int  q_point 
)

Write a contribution that is tested by the gradient to the field containing the values on quadrature points with component q_point. Access to the same field as through get_gradient(). If applied before the function FEEvaluation::integrate(EvaluationFlags::gradients) is called, this specifies what is tested by all basis function gradients on the current cell and integrated over.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_gradient() [2/4]

template<typename Number , bool is_face, typename VectorizedArrayType >
void FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::submit_gradient ( const value_type  grad_in,
const unsigned int  q_point 
)

Write a contribution that is tested by the gradient to the field containing the values on quadrature points with component q_point. Access to the same field as through get_gradient(). If applied before the function FEEvaluation::integrate(EvaluationFlags::gradients) is called, this specifies what is tested by all basis function gradients on the current cell and integrated over.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_gradient() [3/4]

template<typename Number , bool is_face, typename VectorizedArrayType >
void FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::submit_gradient ( const Tensor< 2, 1, VectorizedArrayType grad_in,
const unsigned int  q_point 
)

Write a contribution that is tested by the gradient to the field containing the values on quadrature points with component q_point. Access to the same field as through get_gradient(). If applied before the function FEEvaluation::integrate(EvaluationFlags::gradients) is called, this specifies what is tested by all basis function gradients on the current cell and integrated over.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_normal_derivative() [1/3]

template<typename Number , bool is_face, typename VectorizedArrayType >
void FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::submit_normal_derivative ( const value_type  grad_in,
const unsigned int  q_point 
)

Write a contribution that is tested by the gradient to the field containing the values on quadrature points with component q_point. Access to the same field as through get_gradient() or get_normal_derivative(). If applied before the function FEEvaluation::integrate(EvaluationFlags::gradients) is called, this specifies what is tested by all basis function gradients on the current cell and integrated over.

Note
This operation writes the data to the same field as submit_gradient(). As a consequence, only one of these two can be used. Usually, the contribution of a potential call to this function must be added into the contribution for submit_gradient().
The derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_normal_derivative() [2/3]

template<typename Number , bool is_face, typename VectorizedArrayType >
void FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::submit_normal_derivative ( const gradient_type  grad_in,
const unsigned int  q_point 
)

Write a contribution that is tested by the gradient to the field containing the values on quadrature points with component q_point. Access to the same field as through get_gradient() or get_normal_derivative(). If applied before the function FEEvaluation::integrate(EvaluationFlags::gradients) is called, this specifies what is tested by all basis function gradients on the current cell and integrated over.

Note
This operation writes the data to the same field as submit_gradient(). As a consequence, only one of these two can be used. Usually, the contribution of a potential call to this function must be added into the contribution for submit_gradient().
The derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ get_hessian()

template<typename Number , bool is_face, typename VectorizedArrayType >
hessian_type FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::get_hessian ( unsigned int  q_point) const

Return the Hessian of a finite element function at quadrature point number q_point after a call to FEEvaluation::evaluate(EvaluationFlags::hessians). If only the diagonal or even the trace of the Hessian, the Laplacian, is needed, use the other functions below.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ get_hessian_diagonal()

template<typename Number , bool is_face, typename VectorizedArrayType >
gradient_type FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::get_hessian_diagonal ( const unsigned int  q_point) const

Return the diagonal of the Hessian of a finite element function at quadrature point number q_point after a call to FEEvaluation::evaluate(EvaluationFlags::hessians).

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_hessian() [1/2]

template<typename Number , bool is_face, typename VectorizedArrayType >
void FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::submit_hessian ( const hessian_type  hessian_in,
const unsigned int  q_point 
)

Write a contribution that is tested by the Hessian to the field containing the values at quadrature points with component q_point. Access to the same field as through get_hessian(). If applied before the function FEEvaluation::integrate(EvaluationFlags::hessians) is called, this specifies what is tested by the Hessians of all basis functions on the current cell and integrated over.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ get_laplacian()

template<typename Number , bool is_face, typename VectorizedArrayType >
value_type FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::get_laplacian ( const unsigned int  q_point) const

Return the Laplacian (i.e., the trace of the Hessian) of a finite element function at quadrature point number q_point after a call to FEEvaluation::evaluate(EvaluationFlags::hessians). Compared to the case when computing the full Hessian, some operations can be saved when only the Laplacian is requested.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ integrate_value()

template<typename Number , bool is_face, typename VectorizedArrayType >
value_type FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::integrate_value ( ) const

Takes values at quadrature points, multiplies by the Jacobian determinant and quadrature weights (JxW) and sums the values for all quadrature points on the cell. The result is a scalar, representing the integral over the function over the cell. If a vector-element is used, the resulting components are still separated. Moreover, if vectorization is enabled, the integral values of several cells are contained in the slots of the returned VectorizedArray field.

Note
In case the FEEvaluation object is initialized with a batch of cells where not all lanes in the SIMD vector VectorizedArray are representing actual data, this method performs computations on dummy data (that is copied from the last valid lane) that will not make sense. Thus, the user needs to make sure that it is not used in any computation explicitly, like when summing the results of several cells.

◆ operator=()

template<typename Number , bool is_face, typename VectorizedArrayType >
FEEvaluationAccess& FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::operator= ( const FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType > &  other)
protected

Copy assignment operator

◆ read_dof_values()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::read_dof_values ( const VectorType src,
const unsigned int  first_index = 0,
const std::bitset< VectorizedArrayType::size()> &  mask = std::bitset<VectorizedArrayType::size()>().flip() 
)
inherited

For the vector src, read out the values on the degrees of freedom of the current cell, and store them internally. Similar functionality as the function DoFAccessor::get_interpolated_dof_values when no constraints are present, but it also includes constraints from hanging nodes, so one can see it as a similar function to AffineConstraints::read_dof_values as well. Note that if vectorization is enabled, the DoF values for several cells are set.

If some constraints on the vector are inhomogeneous, use the function read_dof_values_plain instead and provide the vector with useful data also in constrained positions by calling AffineConstraints::distribute. When accessing vector entries during the solution of linear systems, the temporary solution should always have homogeneous constraints and this method is the correct one.

If the given vector template class is a block vector (determined through the template function 'IsBlockVector<VectorType>::value', which checks for vectors derived from BlockVectorBase) or an std::vector<VectorType> or std::vector<VectorType *>, this function reads n_components blocks from the block vector starting at the index first_index. For non-block vectors, first_index is ignored.

Note
If this class was constructed without a MatrixFree object and the information is acquired on the fly through a DoFHandler<dim>::cell_iterator, only one single cell is used by this class and this function extracts the values of the underlying components on the given cell. This call is slower than the ones done through a MatrixFree object and lead to a structure that does not effectively use vectorization in the evaluate routines based on these values (instead, VectorizedArray::size() same copies are worked on).

◆ read_dof_values_plain()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::read_dof_values_plain ( const VectorType src,
const unsigned int  first_index = 0,
const std::bitset< VectorizedArrayType::size()> &  mask = std::bitset<VectorizedArrayType::size()>().flip() 
)
inherited

For the vector src, read out the values on the degrees of freedom of the current cell, and store them internally. Similar functionality as the function DoFAccessor::get_interpolated_dof_values. As opposed to the read_dof_values function, this function reads out the plain entries from vectors, without taking stored constraints into account. This way of access is appropriate when the constraints have been distributed on the vector by a call to AffineConstraints::distribute previously. This function is also necessary when inhomogeneous constraints are to be used, as MatrixFree can only handle homogeneous constraints. Note that if vectorization is enabled, the DoF values for several cells are set.

If the given vector template class is a block vector (determined through the template function 'IsBlockVector<VectorType>::value', which checks for vectors derived from BlockVectorBase) or an std::vector<VectorType> or std::vector<VectorType *>, this function reads n_components blocks from the block vector starting at the index first_index. For non-block vectors, first_index is ignored.

Note
If this class was constructed without a MatrixFree object and the information is acquired on the fly through a DoFHandler<dim>::cell_iterator, only one single cell is used by this class and this function extracts the values of the underlying components on the given cell. This call is slower than the ones done through a MatrixFree object and lead to a structure that does not effectively use vectorization in the evaluate routines based on these values (instead, VectorizedArray::size() same copies are worked on).

◆ distribute_local_to_global()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::distribute_local_to_global ( VectorType dst,
const unsigned int  first_index = 0,
const std::bitset< VectorizedArrayType::size()> &  mask = std::bitset<VectorizedArrayType::size()>().flip() 
) const
inherited

Takes the values stored internally on dof values of the current cell and sums them into the vector dst. The function also applies constraints during the write operation. The functionality is hence similar to the function AffineConstraints::distribute_local_to_global. If vectorization is enabled, the DoF values for several cells are used.

If the given vector template class is a block vector (determined through the template function 'IsBlockVector<VectorType>::value', which checks for vectors derived from BlockVectorBase) or an std::vector<VectorType> or std::vector<VectorType *>, this function writes to n_components blocks of the block vector starting at the index first_index. For non-block vectors, first_index is ignored.

The mask can be used to suppress the write access for some of the cells contained in the current cell vectorization batch, e.g. in case of local time stepping, where some cells are excluded from a call. A value of true in the bitset means that the respective lane index will be processed, whereas a value of false skips this index. The default setting is a bitset that contains all ones, which will write the accumulated integrals to all cells in the batch.

Note
If this class was constructed without a MatrixFree object and the information is acquired on the fly through a DoFHandler<dim>::cell_iterator, only one single cell is used by this class and this function extracts the values of the underlying components on the given cell. This call is slower than the ones done through a MatrixFree object and lead to a structure that does not effectively use vectorization in the evaluate routines based on these values (instead, VectorizedArray::size() same copies are worked on).

◆ set_dof_values()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::set_dof_values ( VectorType dst,
const unsigned int  first_index = 0,
const std::bitset< VectorizedArrayType::size()> &  mask = std::bitset<VectorizedArrayType::size()>().flip() 
) const
inherited

Takes the values stored internally on dof values of the current cell and writes them into the vector dst. The function skips the degrees of freedom which are constrained. As opposed to the distribute_local_to_global method, the old values at the position given by the current cell are overwritten. Thus, if a degree of freedom is associated to more than one cell (as usual in continuous finite elements), the values will be overwritten and only the value written last is retained. Please note that in a parallel context this function might also touch degrees of freedom owned by other MPI processes, so that a subsequent update or accumulation of ghost values as done by MatrixFree::loop() might invalidate the degrees of freedom set by this function.

If the given vector template class is a block vector (determined through the template function 'IsBlockVector<VectorType>::value', which checks for vectors derived from BlockVectorBase) or an std::vector<VectorType> or std::vector<VectorType *>, this function writes to n_components blocks of the block vector starting at the index first_index. For non-block vectors, first_index is ignored.

The mask can be used to suppress the write access for some of the cells contained in the current cell vectorization batch, e.g. in case of local time stepping, where some cells are excluded from a call. A value of true in the bitset means that the respective lane index will be processed, whereas a value of false skips this index. The default setting is a bitset that contains all ones, which will write the accumulated integrals to all cells in the batch.

Note
If this class was constructed without a MatrixFree object and the information is acquired on the fly through a DoFHandler<dim>::cell_iterator, only one single cell is used by this class and this function extracts the values of the underlying components on the given cell. This call is slower than the ones done through a MatrixFree object and lead to a structure that does not effectively use vectorization in the evaluate routines based on these values (instead, VectorizedArray::size() same copies are worked on).

◆ set_dof_values_plain()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::set_dof_values_plain ( VectorType dst,
const unsigned int  first_index = 0,
const std::bitset< VectorizedArrayType::size()> &  mask = std::bitset<VectorizedArrayType::size()>().flip() 
) const
inherited

Same as set_dof_values(), but without resolving constraints.

◆ submit_dof_value() [2/2]

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::submit_dof_value ( const value_type  val_in,
const unsigned int  dof 
)
inherited

Write a value to the field containing the degrees of freedom with component dof. Writes to the same field as is accessed through get_dof_value. Therefore, the original data that was read from a vector is overwritten as soon as a value is submitted.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_value() [3/3]

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::submit_value ( const value_type  val_in,
const unsigned int  q_point 
)
inherited

Write a value to the field containing the values on quadrature points with component q_point. Access to the same field as through get_value(). If applied before the function FEEvaluation::integrate() with EvaluationFlags::values set is called, this specifies the value which is tested by all basis function on the current cell and integrated over.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_gradient() [4/4]

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::submit_gradient ( const gradient_type  grad_in,
const unsigned int  q_point 
)
inherited

Write a contribution that is tested by the gradient to the field containing the values on quadrature points with component q_point. Access to the same field as through get_gradient(). If applied before the function FEEvaluation::integrate(EvaluationFlags::gradients) is called, this specifies what is tested by all basis function gradients on the current cell and integrated over.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_normal_derivative() [3/3]

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::submit_normal_derivative ( const value_type  grad_in,
const unsigned int  q_point 
)
inherited

Write a contribution that is tested by the gradient to the field containing the values on quadrature points with component q_point. Access to the same field as through get_gradient() or get_normal_derivative(). If applied before the function FEEvaluation::integrate(EvaluationFlags::gradients) is called, this specifies what is tested by all basis function gradients on the current cell and integrated over.

Note
This operation writes the data to the same field as submit_gradient(). As a consequence, only one of these two can be used. Usually, the contribution of a potential call to this function must be added into the contribution for submit_gradient().
The derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ submit_hessian() [2/2]

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::submit_hessian ( const hessian_type  hessian_in,
const unsigned int  q_point 
)
inherited

Write a contribution that is tested by the Hessian to the field containing the values at quadrature points with component q_point. Access to the same field as through get_hessian(). If applied before the function FEEvaluation::integrate(EvaluationFlags::hessians) is called, this specifies what is tested by the Hessians of all basis functions on the current cell and integrated over.

Note that the derived class FEEvaluationAccess overloads this operation with specializations for the scalar case (n_components == 1) and for the vector-valued case (n_components == dim).

◆ get_symmetric_gradient()

SymmetricTensor<2, dim, VectorizedArrayType> FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::get_symmetric_gradient ( const unsigned int  q_point) const
inherited

Return the symmetric gradient of a vector-valued finite element at quadrature point number q_point after a call to evaluate(...,true,...). It corresponds to 0.5 (grad+gradT).

Note
Only available for n_components_==dim.

◆ get_curl()

Tensor<1, (dim == 2 ? 1 : dim), VectorizedArrayType> FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::get_curl ( const unsigned int  q_point) const
inherited

Return the curl of the vector field, \(\nabla \times v\) after a call to evaluate(...,true,...).

Note
Only available for n_components_==dim.

◆ submit_divergence()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::submit_divergence ( const VectorizedArrayType  div_in,
const unsigned int  q_point 
)
inherited

Write a contribution that is tested by the divergence to the field containing the values on quadrature points with component q_point. Access to the same field as through get_gradient. If applied before the function integrate(...,true) is called, this specifies what is tested by all basis function gradients on the current cell and integrated over.

Note
Only available for n_components_==dim.
This operation writes the data to the same field as submit_gradient(). As a consequence, only one of these two can be used. Usually, the contribution of a potential call to this function must be added into the diagonal of the contribution for submit_gradient().

◆ submit_symmetric_gradient()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::submit_symmetric_gradient ( const SymmetricTensor< 2, dim, VectorizedArrayType grad_in,
const unsigned int  q_point 
)
inherited

Write a contribution that is tested by the symmetric gradient to the field containing the values on quadrature points with component q_point. Access to the same field as through get_symmetric_gradient. If applied before the function integrate(...,true) is called, this specifies the symmetric gradient which is tested by all basis function symmetric gradients on the current cell and integrated over.

Note
Only available for n_components_==dim.
This operation writes the data to the same field as submit_gradient(). As a consequence, only one of these two can be used. Usually, the contribution of a potential call to this function must be added to the respective entries of the rank-2 tensor for submit_gradient().

◆ submit_curl()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::submit_curl ( const Tensor< 1, dim==2 ? 1 :dim, VectorizedArrayType curl_in,
const unsigned int  q_point 
)
inherited

Write the components of a curl containing the values on quadrature point q_point. Access to the same data field as through get_gradient.

Note
Only available for n_components_==dim.
This operation writes the data to the same field as submit_gradient(). As a consequence, only one of these two can be used. Usually, the contribution of a potential call to this function must be added to the respective entries of the rank-2 tensor for submit_gradient().

◆ read_cell_data() [1/2]

VectorizedArrayType FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::read_cell_data ( const AlignedVector< VectorizedArrayType > &  array) const
inherited

Provides a unified interface to access data in a vector of VectorizedArray fields of length MatrixFree::n_cell_batches() + MatrixFree::n_ghost_cell_batches() for both cells (plain read) and faces (indirect addressing).

◆ read_cell_data() [2/2]

std::array<T, VectorizedArrayType::size()> FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::read_cell_data ( const AlignedVector< std::array< T, VectorizedArrayType::size()>> &  array) const
inherited

The same as above, just for std::array of length of VectorizedArrayType for arbitrary data type.

◆ set_cell_data() [1/2]

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::set_cell_data ( AlignedVector< VectorizedArrayType > &  array,
const VectorizedArrayType value 
) const
inherited

Provides a unified interface to set data in a vector of VectorizedArray fields of length MatrixFree::n_cell_batches() + MatrixFree::n_ghost_cell_batches() for both cells (plain read) and faces (indirect addressing).

◆ set_cell_data() [2/2]

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::set_cell_data ( AlignedVector< std::array< T, VectorizedArrayType::size()>> &  array,
const std::array< T, VectorizedArrayType::size()> &  value 
) const
inherited

The same as above, just for std::array of length of VectorizedArrayType for arbitrary data type.

◆ get_matrix_free()

const MatrixFree<dim, Number, VectorizedArrayType>& FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::get_matrix_free ( ) const
inherited

Return the underlying MatrixFree object.

◆ read_write_operation()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::read_write_operation ( const VectorOperation operation,
const std::array< VectorType *, n_components_ > &  vectors,
const std::array< const std::vector< ArrayView< const typename VectorType::value_type >> *, n_components_ > &  vectors_sm,
const std::bitset< VectorizedArrayType::size()> &  mask,
const bool  apply_constraints = true 
) const
protectedinherited

A unified function to read from and write into vectors based on the given template operation. It can perform the operation for read_dof_values, distribute_local_to_global, and set_dof_values. It performs the operation for several vectors at a time.

◆ read_write_operation_contiguous()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::read_write_operation_contiguous ( const VectorOperation operation,
const std::array< VectorType *, n_components_ > &  vectors,
const std::array< const std::vector< ArrayView< const typename VectorType::value_type >> *, n_components_ > &  vectors_sm,
const std::bitset< VectorizedArrayType::size()> &  mask 
) const
protectedinherited

A unified function to read from and write into vectors based on the given template operation for DG-type schemes where all degrees of freedom on cells are contiguous. It can perform the operation for read_dof_values(), distribute_local_to_global(), and set_dof_values() for several vectors at a time, depending on n_components.

◆ read_write_operation_global()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::read_write_operation_global ( const VectorOperation operation,
const std::array< VectorType *, n_components_ > &  vectors 
) const
protectedinherited

A unified function to read from and write into vectors based on the given template operation for the case when we do not have an underlying MatrixFree object. It can perform the operation for read_dof_values, distribute_local_to_global, and set_dof_values. It performs the operation for several vectors at a time, depending on n_components.

◆ apply_hanging_node_constraints()

void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::apply_hanging_node_constraints ( const bool  transpose) const
protectedinherited

Apply hanging-node constraints.

◆ set_data_pointers()

void FEEvaluationData< dim, VectorizedArrayType , is_face >::set_data_pointers ( AlignedVector< VectorizedArrayType > *  scratch_data,
const unsigned int  n_components 
)
inherited

Sets the pointers for values, gradients, hessians to the central scratch_data_array inside the given scratch array, for a given number of components as provided by one of the derived classes.

◆ reinit_face()

void FEEvaluationData< dim, VectorizedArrayType , is_face >::reinit_face ( const internal::MatrixFreeFunctions::FaceToCellTopology< n_lanes > &  face)
inherited

Initialize the indices related to the given face description. Used during the reinit() call of the FEFaceEvaluation class.

◆ get_scratch_data()

ArrayView<VectorizedArrayType > FEEvaluationData< dim, VectorizedArrayType , is_face >::get_scratch_data ( ) const
inherited

Return an ArrayView to internal memory for temporary use. Note that some of this memory is overwritten during evaluate() and integrate() calls so do not assume it to be stable over those calls. The maximum size you can write into is 3*dofs_per_cell+2*n_q_points.

◆ JxW()

VectorizedArrayType FEEvaluationData< dim, VectorizedArrayType , is_face >::JxW ( const unsigned int  q_point) const
inherited

Return the determinant of the Jacobian from the unit to the real cell times the quadrature weight.

◆ inverse_jacobian()

Tensor<2, dim, VectorizedArrayType > FEEvaluationData< dim, VectorizedArrayType , is_face >::inverse_jacobian ( const unsigned int  q_point) const
inherited

Return the inverse and transposed version \(J^{-\mathrm T}\) of the Jacobian of the mapping between the unit to the real cell defined as \(J_{ij} = d x_i / d\hat x_j\). The \((i,j)\) entry of the returned tensor contains \(d\hat x_j/dx_i\), i.e., columns refer to reference space coordinates and rows to real cell coordinates. Thus, the returned tensor represents a covariant transformation, which is used in the FEEvaluationBase::get_gradient() function to transform the unit cell gradients to gradients on the real cell by a multiplication \(J^{-\mathrm T} \hat{\nabla} u_h\).

◆ get_normal_vector()

Tensor<1, dim, VectorizedArrayType > FEEvaluationData< dim, VectorizedArrayType , is_face >::get_normal_vector ( const unsigned int  q_point) const
inherited

Return the unit normal vector on a face. Note that both sides of a face use the same orientation of the normal vector: For the faces enumerated as interior in FaceToCellTopology and selected with the is_interior_face=true flag of the constructor, this corresponds to the outer normal vector, whereas for faces enumerated as exterior in FaceToCellTopology and selected with the is_interior_face=false flag of the constructor, the normal points into the element as a consequence of the single normal vector.

Note
Only implemented in case is_face == true.

◆ begin_dof_values() [1/2]

const VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::begin_dof_values ( ) const
inherited

Return a read-only pointer to the first field of the dof values. This is the data field the read_dof_values() functions write into. First come the dof values for the first component, then all values for the second component, and so on. This is related to the internal data structures used in this class. In general, it is safer to use the get_dof_value() function instead.

◆ begin_dof_values() [2/2]

VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::begin_dof_values ( )
inherited

Return a read and write pointer to the first field of the dof values. This is the data field the read_dof_values() functions write into. First come the dof values for the first component, then all values for the second component, and so on. This is related to the internal data structures used in this class. In general, it is safer to use the get_dof_value() function instead.

◆ begin_values() [1/2]

const VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::begin_values ( ) const
inherited

Return a read-only pointer to the first field of function values on quadrature points. First come the function values on all quadrature points for the first component, then all values for the second component, and so on. This is related to the internal data structures used in this class. The raw data after a call to evaluate only contains unit cell operations, so possible transformations, quadrature weights etc. must be applied manually. In general, it is safer to use the get_value() function instead, which does all the transformation internally.

◆ begin_values() [2/2]

VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::begin_values ( )
inherited

Return a read and write pointer to the first field of function values on quadrature points. First come the function values on all quadrature points for the first component, then all values for the second component, and so on. This is related to the internal data structures used in this class. The raw data after a call to evaluate only contains unit cell operations, so possible transformations, quadrature weights etc. must be applied manually. In general, it is safer to use the get_value() function instead, which does all the transformation internally.

◆ begin_gradients() [1/2]

const VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::begin_gradients ( ) const
inherited

Return a read-only pointer to the first field of function gradients on quadrature points. First comes the x-component of the gradient for the first component on all quadrature points, then the y-component, and so on. Next comes the x-component of the second component, and so on. This is related to the internal data structures used in this class. The raw data after a call to evaluate only contains unit cell operations, so possible transformations, quadrature weights etc. must be applied manually. In general, it is safer to use the get_gradient() function instead, which does all the transformation internally.

◆ begin_gradients() [2/2]

VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::begin_gradients ( )
inherited

Return a read and write pointer to the first field of function gradients on quadrature points. First comes the x-component of the gradient for the first component on all quadrature points, then the y-component, and so on. Next comes the x-component of the second component, and so on. This is related to the internal data structures used in this class. The raw data after a call to evaluate only contains unit cell operations, so possible transformations, quadrature weights etc. must be applied manually. In general, it is safer to use the get_gradient() function instead, which does all the transformation internally.

◆ begin_hessians() [1/2]

const VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::begin_hessians ( ) const
inherited

Return a read-only pointer to the first field of function hessians on quadrature points. First comes the xx-component of the hessian for the first component on all quadrature points, then the yy-component, zz-component in (3D), then the xy-component, and so on. Next comes the xx- component of the second component, and so on. This is related to the internal data structures used in this class. The raw data after a call to evaluate only contains unit cell operations, so possible transformations, quadrature weights etc. must be applied manually. In general, it is safer to use the get_laplacian() or get_hessian() functions instead, which does all the transformation internally.

◆ begin_hessians() [2/2]

VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::begin_hessians ( )
inherited

Return a read and write pointer to the first field of function hessians on quadrature points. First comes the xx-component of the hessian for the first component on all quadrature points, then the yy-component, zz-component in (3D), then the xy-component, and so on. Next comes the xx-component of the second component, and so on. This is related to the internal data structures used in this class. The raw data after a call to evaluate only contains unit cell operations, so possible transformations, quadrature weights etc. must be applied manually. In general, it is safer to use the get_laplacian() or get_hessian() functions instead, which does all the transformation internally.

◆ get_mapping_data_index_offset()

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::get_mapping_data_index_offset ( ) const
inherited

Return the index offset within the geometry fields for the cell the reinit() function has been called for. This index can be used to access an index into a field that has the same compression behavior as the Jacobian of the geometry, e.g., to store an effective coefficient tensors that combines a coefficient with the geometry for lower memory transfer as the available data fields.

◆ get_cell_type()

internal::MatrixFreeFunctions::GeometryType FEEvaluationData< dim, VectorizedArrayType , is_face >::get_cell_type ( ) const
inherited

Return the type of the cell the reinit() function has been called for. Valid values are cartesian for Cartesian cells (which allows for considerable data compression), affine for cells with affine mappings, and general for general cells without any compressed storage applied.

◆ get_shape_info()

const ShapeInfoType& FEEvaluationData< dim, VectorizedArrayType , is_face >::get_shape_info ( ) const
inherited

Return a reference to the ShapeInfo object currently in use.

◆ get_dof_info()

const internal::MatrixFreeFunctions::DoFInfo& FEEvaluationData< dim, VectorizedArrayType , is_face >::get_dof_info ( ) const
inherited

Return a reference to the DoFInfo object currently in use.

◆ get_internal_dof_numbering()

const std::vector<unsigned int>& FEEvaluationData< dim, VectorizedArrayType , is_face >::get_internal_dof_numbering ( ) const
inherited

Return the numbering of local degrees of freedom within the evaluation routines of FEEvaluation in terms of the standard numbering on finite elements.

◆ get_quadrature_index()

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::get_quadrature_index ( ) const
inherited

Return the number of the quadrature formula of the present cell.

◆ get_current_cell_index()

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::get_current_cell_index ( ) const
inherited

Return index of the current cell or face.

◆ get_active_fe_index()

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::get_active_fe_index ( ) const
inherited

Return the active FE index for this class for efficient indexing in the hp-case.

◆ get_active_quadrature_index()

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::get_active_quadrature_index ( ) const
inherited

Return the active quadrature index for this class for efficient indexing in the hp-case.

◆ get_first_selected_component()

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::get_first_selected_component ( ) const
inherited

Return the first selected component in a multi-component system.

◆ get_face_no()

std::uint8_t FEEvaluationData< dim, VectorizedArrayType , is_face >::get_face_no ( const unsigned int  v = 0) const
inherited

If is_face is true, this function returns the face number of the given lane within a cell for the face this object was initialized to. On cells where the face makes no sense, an exception is thrown.

Note
Only available for dof_access_index == dof_access_cell and is_interior_face == false.
This function depends on the internal representation of data, which is not stable between releases of deal.II, and is hence mostly for internal use.

◆ get_subface_index()

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::get_subface_index ( ) const
inherited

If is_face is true, this function returns the index of a subface along a face in case this object was initialized to a face with hanging nodes. On faces On cells where the face makes no sense, an exception is thrown.

Note
This function depends on the internal representation of data, which is not stable between releases of deal.II, and is hence mostly for internal use.

◆ get_face_orientation()

std::uint8_t FEEvaluationData< dim, VectorizedArrayType , is_face >::get_face_orientation ( const unsigned int  v = 0) const
inherited

If is_face is true, this function returns for a given lane the orientation index within an array of orientations as stored in ShapeInfo for unknowns and quadrature points.

Note
Only available for dof_access_index == dof_access_cell and is_interior_face == false.

◆ get_dof_access_index()

internal::MatrixFreeFunctions::DoFInfo::DoFAccessIndex FEEvaluationData< dim, VectorizedArrayType , is_face >::get_dof_access_index ( ) const
inherited

Return the current index in the access to compressed indices.

Note
This function depends on the internal representation of data, which is not stable between releases of deal.II, and is hence mostly for internal use.

◆ get_is_interior_face()

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::get_is_interior_face ( ) const
inherited

Return whether this object was set up to work on what is called "interior" faces in the evaluation context.

Note
This function depends on the internal representation of data, which is not stable between releases of deal.II, and is hence mostly for internal use.

◆ get_cell_ids()

const std::array<unsigned int, n_lanes>& FEEvaluationData< dim, VectorizedArrayType , is_face >::get_cell_ids ( ) const
inlineinherited

Return the id of the cells this FEEvaluation or FEFaceEvaluation is associated with.

Definition at line 472 of file fe_evaluation_data.h.

◆ get_cell_or_face_batch_id()

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::get_cell_or_face_batch_id ( ) const
inlineinherited

Return the id of the cell/face batch this FEEvaluation/FEFaceEvaluation is associated with.

Definition at line 484 of file fe_evaluation_data.h.

◆ get_cell_or_face_ids()

const std::array<unsigned int, n_lanes>& FEEvaluationData< dim, VectorizedArrayType , is_face >::get_cell_or_face_ids ( ) const
inlineinherited

Return the id of the cells/faces this FEEvaluation/FEFaceEvaluation is associated with.

Definition at line 496 of file fe_evaluation_data.h.

Member Data Documentation

◆ dimension

template<typename Number , bool is_face, typename VectorizedArrayType >
constexpr unsigned int FEEvaluationAccess< 1, 1, Number, is_face, VectorizedArrayType >::dimension = 1
static

Definition at line 1205 of file fe_evaluation.h.

◆ n_components

constexpr unsigned int FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::n_components
staticinherited

Definition at line 104 of file fe_evaluation.h.

◆ scratch_data_array

AlignedVector<VectorizedArrayType>* FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::scratch_data_array
protectedinherited

This is the general array for all data fields.

Definition at line 769 of file fe_evaluation.h.

◆ matrix_free

const MatrixFree<dim, Number, VectorizedArrayType>* FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::matrix_free
protectedinherited

A pointer to the underlying data.

Definition at line 774 of file fe_evaluation.h.

◆ local_dof_indices

std::vector<types::global_dof_index> FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArrayType >::local_dof_indices
mutableprotectedinherited

A temporary data structure necessary to read degrees of freedom when no MatrixFree object was given at initialization.

Definition at line 780 of file fe_evaluation.h.

◆ n_lanes

constexpr unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::n_lanes
staticinherited

Definition at line 127 of file fe_evaluation_data.h.

◆ data

const ShapeInfoType* FEEvaluationData< dim, VectorizedArrayType , is_face >::data
protectedinherited

A pointer to the unit cell shape data, i.e., values, gradients and Hessians in 1D at the quadrature points that constitute the tensor product. Also contained in matrix_info, but it simplifies code if we store a reference to it.

Definition at line 552 of file fe_evaluation_data.h.

◆ dof_info

const DoFInfo* FEEvaluationData< dim, VectorizedArrayType , is_face >::dof_info
protectedinherited

A pointer to the underlying DoF indices and constraint description for the component specified at construction. Also contained in matrix_info, but it simplifies code if we store a reference to it.

Definition at line 559 of file fe_evaluation_data.h.

◆ mapping_data

const MappingInfoStorageType* FEEvaluationData< dim, VectorizedArrayType , is_face >::mapping_data
protectedinherited

A pointer to the underlying transformation data from unit to real cells for the given quadrature formula specified at construction. Also contained in matrix_info, but it simplifies code if we store a reference to it.

Definition at line 567 of file fe_evaluation_data.h.

◆ quad_no

const unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::quad_no
protectedinherited

The number of the quadrature formula of the present cell among all quadrature formulas available in the MatrixFree objects pass to derived classes.

Definition at line 574 of file fe_evaluation_data.h.

◆ n_fe_components

const unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::n_fe_components
protectedinherited

Stores the number of components in the finite element as detected in the MatrixFree storage class for comparison with the template argument.

Definition at line 580 of file fe_evaluation_data.h.

◆ first_selected_component

const unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::first_selected_component
protectedinherited

For a FiniteElement with more than one base element, select at which component this data structure should start.

Definition at line 586 of file fe_evaluation_data.h.

◆ active_fe_index

const unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::active_fe_index
protectedinherited

The active FE index for this class for efficient indexing in the hp-case.

Definition at line 591 of file fe_evaluation_data.h.

◆ active_quad_index

const unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::active_quad_index
protectedinherited

The active quadrature index for this class for efficient indexing in the hp-case.

Definition at line 597 of file fe_evaluation_data.h.

◆ descriptor

const MappingInfoStorageType::QuadratureDescriptor* FEEvaluationData< dim, VectorizedArrayType , is_face >::descriptor
protectedinherited

A pointer to the underlying quadrature formula specified at construction. Also contained in mapping_data, but it simplifies code if we store a reference to it.

Definition at line 604 of file fe_evaluation_data.h.

◆ n_quadrature_points

const unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::n_quadrature_points
protectedinherited

The number of quadrature points in the current evaluation context.

Definition at line 609 of file fe_evaluation_data.h.

◆ jacobian

const Tensor<2, dim, VectorizedArrayType >* FEEvaluationData< dim, VectorizedArrayType , is_face >::jacobian
protectedinherited

A pointer to the Jacobian information of the present cell. Only set to a useful value if on a non-Cartesian cell.

Definition at line 615 of file fe_evaluation_data.h.

◆ jacobian_gradients

const Tensor<1, dim *(dim + 1) / 2, Tensor<1, dim, VectorizedArrayType > >* FEEvaluationData< dim, VectorizedArrayType , is_face >::jacobian_gradients
protectedinherited

A pointer to the gradients of the inverse Jacobian transformation of the present cell.

Definition at line 622 of file fe_evaluation_data.h.

◆ J_value

const VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::J_value
protectedinherited

A pointer to the Jacobian determinant of the present cell. If on a Cartesian cell or on a cell with constant Jacobian, this is just the Jacobian determinant, otherwise the Jacobian determinant times the quadrature weight.

Definition at line 630 of file fe_evaluation_data.h.

◆ normal_vectors

const Tensor<1, dim, VectorizedArrayType >* FEEvaluationData< dim, VectorizedArrayType , is_face >::normal_vectors
protectedinherited

A pointer to the normal vectors at faces.

Definition at line 635 of file fe_evaluation_data.h.

◆ normal_x_jacobian

const Tensor<1, dim, VectorizedArrayType >* FEEvaluationData< dim, VectorizedArrayType , is_face >::normal_x_jacobian
protectedinherited

A pointer to the normal vectors times the jacobian at faces.

Definition at line 640 of file fe_evaluation_data.h.

◆ quadrature_weights

const ScalarNumber* FEEvaluationData< dim, VectorizedArrayType , is_face >::quadrature_weights
protectedinherited

A pointer to the quadrature weights of the underlying quadrature formula.

Definition at line 645 of file fe_evaluation_data.h.

◆ scratch_data

ArrayView<VectorizedArrayType > FEEvaluationData< dim, VectorizedArrayType , is_face >::scratch_data
mutableprotectedinherited

This is the user-visible part of FEEvaluationBase::scratch_data_array, only showing the part that can be consumed by various users. It is set during the allocation of the internal data structures in FEEvaluationBase.

Definition at line 653 of file fe_evaluation_data.h.

◆ values_dofs

VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::values_dofs
protectedinherited

This field stores the values for local degrees of freedom (e.g. after reading out from a vector but before applying unit cell transformations or before distributing them into a result vector). The methods get_dof_value() and submit_dof_value() read from or write to this field.

The values of this array are stored in the start section of scratch_data_array. Due to its access as a thread local memory, the memory can get reused between different calls.

Definition at line 665 of file fe_evaluation_data.h.

◆ values_quad

VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::values_quad
protectedinherited

This field stores the values of the finite element function on quadrature points after applying unit cell transformations or before integrating. The methods get_value() and submit_value() access this field.

The values of this array are stored in the start section of scratch_data_array. Due to its access as a thread local memory, the memory can get reused between different calls.

Definition at line 676 of file fe_evaluation_data.h.

◆ gradients_quad

VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::gradients_quad
protectedinherited

This field stores the gradients of the finite element function on quadrature points after applying unit cell transformations or before integrating. The methods get_gradient() and submit_gradient() (as well as some specializations like get_symmetric_gradient() or get_divergence()) access this field.

The values of this array are stored in the start section of scratch_data_array. Due to its access as a thread local memory, the memory can get reused between different calls.

Definition at line 689 of file fe_evaluation_data.h.

◆ gradients_from_hessians_quad

VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::gradients_from_hessians_quad
protectedinherited

This field stores the gradients of the finite element function on quadrature points after applying unit cell transformations or before integrating. The methods get_hessian() and submit_hessian() (as well as some specializations like get_hessian_diagonal() or get_laplacian()) access this field for general cell/face types.

The values of this array are stored in the start section of scratch_data_array. Due to its access as a thread local memory, the memory can get reused between different calls.

Definition at line 702 of file fe_evaluation_data.h.

◆ hessians_quad

VectorizedArrayType * FEEvaluationData< dim, VectorizedArrayType , is_face >::hessians_quad
protectedinherited

This field stores the Hessians of the finite element function on quadrature points after applying unit cell transformations. The methods get_hessian(), get_laplacian(), get_hessian_diagonal() access this field.

The values of this array are stored in the start section of scratch_data_array. Due to its access as a thread local memory, the memory can get reused between different calls.

Definition at line 713 of file fe_evaluation_data.h.

◆ is_reinitialized

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::is_reinitialized
protectedinherited

Debug information to track whether the reinit() function of derived classes was called.

Definition at line 719 of file fe_evaluation_data.h.

◆ dof_values_initialized

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::dof_values_initialized
protectedinherited

Debug information to track whether dof values have been initialized before accessed. Used to control exceptions when uninitialized data is used.

Definition at line 726 of file fe_evaluation_data.h.

◆ values_quad_initialized

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::values_quad_initialized
protectedinherited

Debug information to track whether values on quadrature points have been initialized before accessed. Used to control exceptions when uninitialized data is used.

Definition at line 733 of file fe_evaluation_data.h.

◆ gradients_quad_initialized

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::gradients_quad_initialized
protectedinherited

Debug information to track whether gradients on quadrature points have been initialized before accessed. Used to control exceptions when uninitialized data is used.

Definition at line 740 of file fe_evaluation_data.h.

◆ hessians_quad_initialized

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::hessians_quad_initialized
protectedinherited

Debug information to track whether Hessians on quadrature points have been initialized before accessed. Used to control exceptions when uninitialized data is used.

Definition at line 747 of file fe_evaluation_data.h.

◆ values_quad_submitted

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::values_quad_submitted
protectedinherited

Debug information to track whether values on quadrature points have been submitted for integration before the integration is actually stared. Used to control exceptions when uninitialized data is used.

Definition at line 754 of file fe_evaluation_data.h.

◆ gradients_quad_submitted

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::gradients_quad_submitted
protectedinherited

Debug information to track whether gradients on quadrature points have been submitted for integration before the integration is actually stared. Used to control exceptions when uninitialized data is used.

Definition at line 761 of file fe_evaluation_data.h.

◆ hessians_quad_submitted

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::hessians_quad_submitted
protectedinherited

Debug information to track whether hessians on quadrature points have been submitted for integration before the integration is actually stared. Used to control exceptions when uninitialized data is used.

Definition at line 768 of file fe_evaluation_data.h.

◆ cell

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::cell
protectedinherited

After a call to reinit(), stores the number of the cell we are currently working with.

Definition at line 774 of file fe_evaluation_data.h.

◆ is_interior_face

bool FEEvaluationData< dim, VectorizedArrayType , is_face >::is_interior_face
protectedinherited

Flag holding information whether a face is an interior or exterior face according to the defined direction of the normal. For cells it defines if the dof values should be read from the actual cell corresponding to the interior face or the neighboring cell corresponding to the exterior face.

Definition at line 782 of file fe_evaluation_data.h.

◆ dof_access_index

Stores the index an FEFaceEvaluation object is currently pointing into (interior face, exterior face, data associated with cell).

Definition at line 788 of file fe_evaluation_data.h.

◆ face_numbers

std::array<std::uint8_t, n_lanes> FEEvaluationData< dim, VectorizedArrayType , is_face >::face_numbers
protectedinherited

Stores the (non-vectorized) number of faces within cells in case of ECL for the exterior cells where the single number face_no is not enough to cover all cases.

Note
Only available for dof_access_index == dof_access_cell and is_interior_face == false.

Definition at line 798 of file fe_evaluation_data.h.

◆ face_orientations

std::array<std::uint8_t, n_lanes> FEEvaluationData< dim, VectorizedArrayType , is_face >::face_orientations
protectedinherited

Store the orientation of the neighbor's faces with respect to the current cell for the case of exterior faces on ECL with possibly different orientations behind different cells.

Note
Only available for dof_access_index == dof_access_cell and is_interior_face == false.

Definition at line 808 of file fe_evaluation_data.h.

◆ subface_index

unsigned int FEEvaluationData< dim, VectorizedArrayType , is_face >::subface_index
protectedinherited

Stores the subface index of the given face. Usually, this variable takes the value numbers::invalid_unsigned_int to indicate integration over the full face, but in case the current physical face has a neighbor that is more refined, it is a subface and must scale the entries in ShapeInfo appropriately.

Definition at line 817 of file fe_evaluation_data.h.

◆ cell_type

internal::MatrixFreeFunctions::GeometryType FEEvaluationData< dim, VectorizedArrayType , is_face >::cell_type
protectedinherited

Stores the type of the cell we are currently working with after a call to reinit(). Valid values are cartesian, affine and general, which have different implications on how the Jacobian transformations are stored internally in MappingInfo.

Definition at line 825 of file fe_evaluation_data.h.

◆ cell_ids

std::array<unsigned int, n_lanes> FEEvaluationData< dim, VectorizedArrayType , is_face >::cell_ids
protectedinherited

Stores the (non-vectorized) id of the cells or faces this object is initialized to. Relevant for ECL.

Definition at line 831 of file fe_evaluation_data.h.

◆ cell_or_face_ids

std::array<unsigned int, n_lanes> FEEvaluationData< dim, VectorizedArrayType , is_face >::cell_or_face_ids
protectedinherited

Stores the (non-vectorized) id of the cells or faces this object is initialized to. Relevant for ECL.

Definition at line 837 of file fe_evaluation_data.h.

◆ mapped_geometry

std::shared_ptr< internal::MatrixFreeFunctions::MappingDataOnTheFly<dim, VectorizedArrayType > > FEEvaluationData< dim, VectorizedArrayType , is_face >::mapped_geometry
protectedinherited

Geometry data that can be generated FEValues on the fly with the respective constructor, as an alternative to the entry point with MatrixFree.

Definition at line 846 of file fe_evaluation_data.h.


The documentation for this class was generated from the following file: