|
| void | set_data_pointers (AlignedVector< Number > *scratch_data, const unsigned int n_components) |
| |
| void | reinit_face (const internal::MatrixFreeFunctions::FaceToCellTopology< n_lanes > &face) |
| |
|
| 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 |
| |
|
| ArrayView< Number > | get_scratch_data () const |
| |
| Number | JxW (const unsigned int q_point) const |
| |
| Point< dim, Number > | quadrature_point (const unsigned int q) const |
| |
| Tensor< 2, dim, Number > | inverse_jacobian (const unsigned int q_point) const |
| |
| Tensor< 1, dim, Number > | get_normal_vector (const unsigned int q_point) const |
| |
|
| const Number * | begin_dof_values () const |
| |
| Number * | begin_dof_values () |
| |
| const Number * | begin_values () const |
| |
| Number * | begin_values () |
| |
| const Number * | begin_gradients () const |
| |
| Number * | begin_gradients () |
| |
| const Number * | begin_hessians () const |
| |
| Number * | begin_hessians () |
| |
|
| unsigned int | get_mapping_data_index_offset () const |
| |
| internal::MatrixFreeFunctions::GeometryType | get_cell_type () const |
| |
| const ShapeInfoType & | get_shape_info () const |
| |
| const internal::MatrixFreeFunctions::DoFInfo & | get_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 | is_interior_face () const |
| |
| const std::array< unsigned int, n_lanes > & | get_cell_ids () const |
| |
| const std::array< unsigned int, n_lanes > & | get_face_ids () const |
| |
| unsigned int | get_cell_or_face_batch_id () const |
| |
| const std::array< unsigned int, n_lanes > & | get_cell_or_face_ids () const |
| |
| std_cxx20::ranges::iota_view< unsigned int, unsigned int > | quadrature_point_indices () const |
| |
|
| 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 |
| |
| AlignedVector< VectorizedArray< Number > > * | scratch_data_array |
| |
| const MatrixFree< dim, Number, VectorizedArray< Number > > * | matrix_free |
| |
| std::vector< types::global_dof_index > | local_dof_indices |
| |
| 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) |
| |
| gradient_type | get_gradient (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_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) |
| |
| Tensor< 1, n_components_, Tensor< 2, dim, VectorizedArray< Number > > > | get_hessian (const unsigned int q_point) const |
| |
| gradient_type | get_hessian_diagonal (const unsigned int q_point) const |
| |
| value_type | get_laplacian (const unsigned int q_point) const |
| |
| VectorizedArray< Number > | get_divergence (const unsigned int q_point) const |
| |
| SymmetricTensor< 2, dim, VectorizedArray< Number > > | get_symmetric_gradient (const unsigned int q_point) const |
| |
| Tensor< 1,(dim==2 ? 1 :dim), VectorizedArray< Number > > | get_curl (const unsigned int q_point) const |
| |
| void | submit_divergence (const VectorizedArray< Number > div_in, const unsigned int q_point) |
| |
| void | submit_symmetric_gradient (const SymmetricTensor< 2, dim, VectorizedArray< Number > > grad_in, const unsigned int q_point) |
| |
| void | submit_curl (const Tensor< 1, dim==2 ? 1 :dim, VectorizedArray< Number > > curl_in, const unsigned int q_point) |
| |
| value_type | integrate_value () const |
| |
| const MatrixFree< dim, Number, VectorizedArray< Number > > & | get_matrix_free () const |
| |
|
| const ShapeInfoType * | data |
| |
| const DoFInfo * | dof_info |
| |
| const MappingInfoStorageType * | mapping_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::QuadratureDescriptor * | descriptor |
| |
| const unsigned int | n_quadrature_points |
| |
| const Point< dim, Number > * | quadrature_points |
| |
| const Tensor< 2, dim, Number > * | jacobian |
| |
| const Tensor< 1, dim *(dim+1)/2, Tensor< 1, dim, Number > > * | jacobian_gradients |
| |
| const Number * | J_value |
| |
| const Tensor< 1, dim, Number > * | normal_vectors |
| |
| const Tensor< 1, dim, Number > * | normal_x_jacobian |
| |
| const ScalarNumber * | quadrature_weights |
| |
| ArrayView< Number > | scratch_data |
| |
| Number * | values_dofs |
| |
| Number * | values_quad |
| |
| Number * | gradients_quad |
| |
| Number * | gradients_from_hessians_quad |
| |
| Number * | hessians_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 | interior_face |
| |
| internal::MatrixFreeFunctions::DoFInfo::DoFAccessIndex | dof_access_index |
| |
| std::array< std::uint8_t, n_lanes > | face_numbers |
| |
| std::array< std::uint8_t, n_lanes > | face_orientations |
| |
| unsigned int | subface_index |
| |
| internal::MatrixFreeFunctions::GeometryType | cell_type |
| |
| std::array< unsigned int, n_lanes > | cell_ids |
| |
| std::array< unsigned int, n_lanes > | face_ids |
| |
| std::shared_ptr< internal::MatrixFreeFunctions::MappingDataOnTheFly< dim, Number > > | mapped_geometry |
| |
| Number | read_cell_data (const AlignedVector< Number > &array) const |
| |
| template<typename T > |
| std::array< T, Number::size()> | read_cell_data (const AlignedVector< std::array< T, Number::size()>> &array) const |
| |
| void | set_cell_data (AlignedVector< Number > &array, const Number &value) const |
| |
| template<typename T > |
| void | set_cell_data (AlignedVector< std::array< T, Number::size()>> &array, const std::array< T, Number::size()> &value) const |
| |
| Number | read_face_data (const AlignedVector< Number > &array) const |
| |
| template<typename T > |
| std::array< T, Number::size()> | read_face_data (const AlignedVector< std::array< T, Number::size()>> &array) const |
| |
| void | set_face_data (AlignedVector< Number > &array, const Number &value) const |
| |
| template<typename T > |
| void | set_face_data (AlignedVector< std::array< T, Number::size()>> &array, const std::array< T, Number::size()> &value) const |
| |
template<int dim, int n_components_, typename Number, bool is_face, typename VectorizedArrayType = VectorizedArray<Number>>
class FEEvaluationAccess< dim, n_components_, Number, is_face, VectorizedArrayType >
This class provides access to the data fields of the FEEvaluation classes. Generic access is achieved through the base class, and specializations for scalar and vector-valued elements are defined separately.
Definition at line 760 of file fe_evaluation.h.
| void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArray< Number > >::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).
| void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArray< Number > >::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).
| void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArray< Number > >::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).
| void FEEvaluationBase< dim, n_components_, Number, is_face, VectorizedArray< Number > >::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).
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).
template<int dim, typename Number , bool is_face>
| Tensor<2, dim, Number> FEEvaluationData< dim, Number, 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\).
template<int dim, typename Number , bool is_face>
| Tensor<1, dim, Number> FEEvaluationData< dim, Number, 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.
template<int dim, typename Number , bool is_face>
| const Number* FEEvaluationData< dim, Number, 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.
template<int dim, typename Number , bool is_face>
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.
template<int dim, typename Number , bool is_face>
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.
template<int dim, typename Number , bool is_face>
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.
template<int dim, typename Number , bool is_face>
| const Number* FEEvaluationData< dim, Number, 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.
template<int dim, typename Number , bool is_face>
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.
template<int dim, typename Number , bool is_face>
| const Number* FEEvaluationData< dim, Number, 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.
template<int dim, typename Number , bool is_face>
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.
template<int dim, typename Number , bool is_face>
| unsigned int FEEvaluationData< dim, Number, 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.
template<int dim, typename Number , bool is_face>
| unsigned int FEEvaluationData< dim, Number, 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.
template<int dim, typename Number , bool is_face>
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 674 of file fe_evaluation_data.h.
template<int dim, typename Number , bool is_face>
A pointer to the inverse transpose Jacobian information of the present cell. Only the first inverse transpose Jacobian (q_point = 0) is set for Cartesian/affine cells, and the actual Jacobian is stored at index 1 instead. For faces on hypercube elements, the derivatives are reorder s.t. the derivative orthogonal to the face is stored last, i.e for dim = 3 and face_no = 0 or 1, the derivatives are ordered as [dy, dz, dx], face_no = 2 or 3: [dz, dx, dy], and face_no = 5 or 6: [dx, dy, dz]. If the Jacobian also is stored, the components are instead reordered in the same way. Filled from MappingInfoStorage.jacobians in include/deal.II/matrix_free/mapping_info.templates.h
Definition at line 751 of file fe_evaluation_data.h.
template<int dim, typename Number , bool is_face>
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 766 of file fe_evaluation_data.h.
template<int dim, typename Number , bool is_face>
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 801 of file fe_evaluation_data.h.
template<int dim, typename Number , bool is_face>
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 812 of file fe_evaluation_data.h.
template<int dim, typename Number , bool is_face>
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 825 of file fe_evaluation_data.h.
template<int dim, typename Number , bool is_face>
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 838 of file fe_evaluation_data.h.
template<int dim, typename Number , bool is_face>
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 849 of file fe_evaluation_data.h.
template<int dim, typename Number , bool is_face>
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 953 of file fe_evaluation_data.h.
1.9.1