 |
Reference documentation for deal.II version 8.5.1
|
|
Reference documentation for deal.II version 8.5.1
|
#include <deal.II/matrix_free/fe_evaluation.h>
Public Member Functions | |
1: General operations | |
| ~FEEvaluationBase () | |
| void | reinit (const unsigned int cell) |
| template<typename DoFHandlerType , bool level_dof_access> | |
| void | reinit (const TriaIterator< DoFCellAccessor< DoFHandlerType, level_dof_access > > &cell) |
| void | reinit (const typename Triangulation< dim >::cell_iterator &cell) |
| unsigned int | get_cell_data_number () const |
| internal::MatrixFreeFunctions::CellType | get_cell_type () const |
| const internal::MatrixFreeFunctions::ShapeInfo< Number > & | get_shape_info () const |
| void | fill_JxW_values (AlignedVector< VectorizedArray< Number > > &JxW_values) const |
2: Reading from and writing to vectors | |
| template<typename VectorType > | |
| void | read_dof_values (const VectorType &src, const unsigned int first_index=0) |
| template<typename VectorType > | |
| void | read_dof_values_plain (const VectorType &src, const unsigned int first_index=0) |
| template<typename VectorType > | |
| void | distribute_local_to_global (VectorType &dst, const unsigned int first_index=0) const |
| template<typename VectorType > | |
| void | set_dof_values (VectorType &dst, const unsigned int first_index=0) const |
3: Data access | |
| 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 |
| void | submit_gradient (const gradient_type grad_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 |
| VectorizedArray< Number > | JxW (const unsigned int q_point) const |
4: Access to internal data | |
| const VectorizedArray< Number > * | begin_dof_values () const |
| VectorizedArray< Number > * | begin_dof_values () |
| const VectorizedArray< Number > * | begin_values () const |
| VectorizedArray< Number > * | begin_values () |
| const VectorizedArray< Number > * | begin_gradients () const |
| VectorizedArray< Number > * | begin_gradients () |
| const VectorizedArray< Number > * | begin_hessians () const |
| VectorizedArray< Number > * | begin_hessians () |
| const std::vector< unsigned int > & | get_internal_dof_numbering () const |
| ArrayView< VectorizedArray< Number > > | get_scratch_data () const |
Protected Member Functions | |
| FEEvaluationBase (const MatrixFree< dim, Number > &matrix_free, const unsigned int fe_no, const unsigned int quad_no, const unsigned int fe_degree, const unsigned int n_q_points) | |
| template<int n_components_other> | |
| FEEvaluationBase (const Mapping< dim > &mapping, const FiniteElement< dim > &fe, const Quadrature< 1 > &quadrature, const UpdateFlags update_flags, const unsigned int first_selected_component, const FEEvaluationBase< dim, n_components_other, Number > *other) | |
| FEEvaluationBase (const FEEvaluationBase &other) | |
| FEEvaluationBase & | operator= (const FEEvaluationBase &other) |
| template<typename VectorType , typename VectorOperation > | |
| void | read_write_operation (const VectorOperation &operation, VectorType *vectors[]) const |
| template<typename VectorType > | |
| void | read_dof_values_plain (const VectorType *src_data[]) |
Private Member Functions | |
| void | set_data_pointers () |
Friends | |
| template<int , int , typename > | |
| class | FEEvaluationBase |
| template<int , int , int , int , typename > | |
| class | FEEvaluation |
This is the base class for the FEEvaluation classes. This class is a base class and needs usually not be called in user code. It does not have any public constructor. The usage is through the class FEEvaluation instead. It implements a reinit method that is used to set pointers so that operations on quadrature points can be performed quickly, access functions to vectors for the read_dof_values, set_dof_values, and distributed_local_to_global functions, as well as methods to access values and gradients of finite element functions.
This class has three template arguments:
| dim | Dimension in which this class is to be used |
| n_components | Number of vector components when solving a system of PDEs. If the same operation is applied to several components of a PDE (e.g. a vector Laplace equation), they can be applied simultaneously with one call (and often more efficiently) |
| Number | Number format, usually double or float |
Definition at line 80 of file fe_evaluation.h.
| FEEvaluationBase< dim, n_components_, Number >::~FEEvaluationBase | ( | ) |
Destructor.
|
protected |
Constructor. Made protected to prevent users from directly using this class. 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, fe_no and quad_no allow to select the appropriate components.
|
protected |
Constructor that comes with reduced functionality and works similar as FEValues. The arguments are similar to the ones passed to the constructor of FEValues, with the notable difference that FEEvaluation expects a one- dimensional quadrature formula, Quadrature<1>, instead of a dim dimensional one. The finite element can be both scalar or vector valued, but this method always only selects a scalar base element at a time (with n_components copies as specified by the class template argument). For vector-valued elements, the optional argument first_selected_component allows to specify the index of the base element to be used for evaluation. Note that the internal data structures always assume that the base element is primitive, non-primitive are not supported currently.
As known from FEValues, a call to the reinit method with a Triangulation::cell_iterator is necessary to make the geometry and degrees of freedom of the current class known. If the iterator includes DoFHandler information (i.e., it is a DoFHandler::cell_iterator or similar), the initialization allows to also read from or write to vectors in the standard way for DoFHandler::active_cell_iterator types for one cell at a time. However, this approach is much slower than the path with MatrixFree with MPI since index translation has to be done. As only one cell at a time is used, this method does not vectorize over several elements (which is most efficient for vector operations), but only possibly within the element if the evaluate/integrate routines are combined inside user code (e.g. for computing cell matrices).
The optional FEEvaluationBase object allows several FEEvaluation objects to share the geometry evaluation, i.e., the underlying mapping and quadrature points do only need to be evaluated once. This only works if the quadrature formulas are the same. Otherwise, a new evaluation object is created. Make sure to not pass an optional object around when you intend to use the FEEvaluation object in parallel with another one because otherwise the intended sharing may create race conditions.
|
protected |
Copy constructor. If FEEvaluationBase was constructed from a mapping, fe, quadrature, and update flags, the underlying geometry evaluation based on FEValues will be deep-copied in order to allow for using in parallel with threads.
| void FEEvaluationBase< dim, n_components_, Number >::reinit | ( | const unsigned int | cell | ) |
Initializes the operation pointer to the current cell. Unlike the reinit functions taking a cell iterator as argument below and the FEValues::reinit() methods, where the information related to a particular cell is generated in the reinit call, this function is very cheap since all data is pre-computed in matrix_free, and only a few indices have to be set appropriately.
| void FEEvaluationBase< dim, n_components_, Number >::reinit | ( | const TriaIterator< DoFCellAccessor< DoFHandlerType, level_dof_access > > & | cell | ) |
Initialize the data to the current cell using a TriaIterator object as usual in FEValues. The argument is either of type DoFHandler::active_cell_iterator or DoFHandler::level_cell_iterator. This option is only available if the FEEvaluation object was created with a finite element, quadrature formula and correct update flags and without a MatrixFree object. This initialization method loses the ability to use vectorization, see also the description of the FEEvaluation class. When this reinit method is used, FEEvaluation can also read from vectors (but less efficient than with data coming from MatrixFree).
| void FEEvaluationBase< dim, n_components_, Number >::reinit | ( | const typename Triangulation< dim >::cell_iterator & | cell | ) |
Initialize the data to the current cell using a TriaIterator object as usual in FEValues. This option is only available if the FEEvaluation object was created with a finite element, quadrature formula and correct update flags and without a MatrixFree object. This initialization method loses the ability to use vectorization, see also the description of the FEEvaluation class. When this reinit method is used, FEEvaluation can not read from vectors because no DoFHandler information is available.
| unsigned int FEEvaluationBase< dim, n_components_, Number >::get_cell_data_number | ( | ) | const |
For the transformation information stored in MappingInfo, this function returns the index which belongs to the current cell as specified in reinit. Note that MappingInfo has different fields for Cartesian cells, cells with affine mapping and with general mappings, so in order to access the correct data, this interface must be used together with get_cell_type.
| internal::MatrixFreeFunctions::CellType FEEvaluationBase< dim, n_components_, Number >::get_cell_type | ( | ) | const |
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.
| const internal::MatrixFreeFunctions::ShapeInfo<Number>& FEEvaluationBase< dim, n_components_, Number >::get_shape_info | ( | ) | const |
Return a reference to the ShapeInfo object currently in use.
| void FEEvaluationBase< dim, n_components_, Number >::fill_JxW_values | ( | AlignedVector< VectorizedArray< Number > > & | JxW_values | ) | const |
Fills the JxW values currently used.
| void FEEvaluationBase< dim, n_components_, Number >::read_dof_values | ( | const VectorType & | src, |
| const unsigned int | first_index = 0 |
||
| ) |
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 ConstraintMatrix::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 ConstraintMatrix::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 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::n_array_elements same copies are worked on).
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.
| void FEEvaluationBase< dim, n_components_, Number >::read_dof_values_plain | ( | const VectorType & | src, |
| const unsigned int | first_index = 0 |
||
| ) |
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 ConstraintMatrix::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 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::n_array_elements same copies are worked on).
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.
| void FEEvaluationBase< dim, n_components_, Number >::distribute_local_to_global | ( | VectorType & | dst, |
| const unsigned int | first_index = 0 |
||
| ) | const |
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 ConstraintMatrix::distribute_local_to_global. If vectorization is enabled, the DoF values for several cells are used.
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::n_array_elements same copies are worked on).
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.
| void FEEvaluationBase< dim, n_components_, Number >::set_dof_values | ( | VectorType & | dst, |
| const unsigned int | first_index = 0 |
||
| ) | const |
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.
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::n_array_elements same copies are worked on).
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.
| value_type FEEvaluationBase< dim, n_components_, Number >::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. 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).
| void FEEvaluationBase< dim, n_components_, Number >::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).
| value_type FEEvaluationBase< dim, n_components_, Number >::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 evaluate(true,...), or the value that has been stored there with a call to 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).
| void FEEvaluationBase< dim, n_components_, Number >::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 integrate(true,...) 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).
| gradient_type FEEvaluationBase< dim, n_components_, Number >::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 evaluate(...,true,...), or the value that has been stored there with a call to 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).
| void FEEvaluationBase< dim, n_components_, Number >::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 integrate(...,true) 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).
| Tensor<1,n_components_,Tensor<2,dim,VectorizedArray<Number> > > FEEvaluationBase< dim, n_components_, Number >::get_hessian | ( | const unsigned int | q_point | ) | const |
Return the Hessian of a finite element function at quadrature point number q_point after a call to evaluate(...,true). 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).
| gradient_type FEEvaluationBase< dim, n_components_, Number >::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 evaluate(...,true).
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).
| value_type FEEvaluationBase< dim, n_components_, Number >::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 evaluate(...,true). 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).
| VectorizedArray<Number> FEEvaluationBase< dim, n_components_, Number >::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,...).
| SymmetricTensor<2, dim, VectorizedArray<Number> > FEEvaluationBase< dim, n_components_, Number >::get_symmetric_gradient | ( | const unsigned int | q_point | ) | const |
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).
| Tensor<1,(dim==2?1:dim), VectorizedArray<Number> > FEEvaluationBase< dim, n_components_, Number >::get_curl | ( | const unsigned int | q_point | ) | const |
Return the curl of the vector field, \(\nabla \times v\) after a call to evaluate(...,true,...).
| void FEEvaluationBase< dim, n_components_, Number >::submit_divergence | ( | const VectorizedArray< Number > | div_in, |
| const unsigned int | q_point | ||
| ) |
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.
| void FEEvaluationBase< dim, n_components_, Number >::submit_symmetric_gradient | ( | const SymmetricTensor< 2, dim, VectorizedArray< Number > > | grad_in, |
| const unsigned int | q_point | ||
| ) |
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.
| void FEEvaluationBase< dim, n_components_, Number >::submit_curl | ( | const Tensor< 1, dim==2?1:dim, VectorizedArray< Number > > | curl_in, |
| const unsigned int | q_point | ||
| ) |
Write the components of a curl containing the values on quadrature point q_point. Access to the same data field as through get_gradient.
| value_type FEEvaluationBase< dim, n_components_, Number >::integrate_value | ( | ) | const |
Takes values on 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 represented together.
| VectorizedArray<Number> FEEvaluationBase< dim, n_components_, Number >::JxW | ( | const unsigned int | q_point | ) | const |
Return the determinant of the Jacobian from the unit to the real cell times the quadrature weight.
| const VectorizedArray<Number>* FEEvaluationBase< dim, n_components_, Number >::begin_dof_values | ( | ) | const |
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 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.
| VectorizedArray<Number>* FEEvaluationBase< dim, n_components_, Number >::begin_dof_values | ( | ) |
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 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.
| const VectorizedArray<Number>* FEEvaluationBase< dim, n_components_, Number >::begin_values | ( | ) | const |
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.
| VectorizedArray<Number>* FEEvaluationBase< dim, n_components_, Number >::begin_values | ( | ) |
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.
| const VectorizedArray<Number>* FEEvaluationBase< dim, n_components_, Number >::begin_gradients | ( | ) | const |
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.
| VectorizedArray<Number>* FEEvaluationBase< dim, n_components_, Number >::begin_gradients | ( | ) |
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.
| const VectorizedArray<Number>* FEEvaluationBase< dim, n_components_, Number >::begin_hessians | ( | ) | const |
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.
| VectorizedArray<Number>* FEEvaluationBase< dim, n_components_, Number >::begin_hessians | ( | ) |
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.
| const std::vector<unsigned int>& FEEvaluationBase< dim, n_components_, Number >::get_internal_dof_numbering | ( | ) | const |
Return the numbering of local degrees of freedom within the evaluation routines of FEEvaluation in terms of the standard numbering on finite elements.
| ArrayView<VectorizedArray<Number> > FEEvaluationBase< dim, n_components_, Number >::get_scratch_data | ( | ) | const |
Returns 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 (n_components+2)*dofs_per_cell+2*n_q_points.
|
protected |
Copy assignment operator. If FEEvaluationBase was constructed from a mapping, fe, quadrature, and update flags, the underlying geometry evaluation based on FEValues will be deep-copied in order to allow for using in parallel with threads.
|
protected |
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.
|
protected |
For a collection of several vector src, read out the values on the degrees of freedom of the current cell for n_components (template argument), and store them internally. Similar functionality as the function DoFAccessor::read_dof_values. Note that if vectorization is enabled, the DoF values for several cells are set.
|
private |
Sets the pointers for values, gradients, hessians to the central scratch_data_array.
|
friend |
Make other FEEvaluationBase as well as FEEvaluation objects friends.
Definition at line 944 of file fe_evaluation.h.
|
protected |
This is the general array for all data fields.
Definition at line 690 of file fe_evaluation.h.
|
protected |
This is the user-visible part of scratch_data_array, only showing the last part of scratch_data_array. The first part is consumed by values_dofs, values_quad, etc.
Definition at line 697 of file fe_evaluation.h.
|
protected |
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. As opposed to requesting memory on the stack, this approach allows for very large polynomial degrees.
Definition at line 711 of file fe_evaluation.h.
|
protected |
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. As opposed to requesting memory on the stack, this approach allows for very large polynomial degrees.
Definition at line 724 of file fe_evaluation.h.
|
protected |
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. As opposed to requesting memory on the stack, this approach allows for very large polynomial degrees.
Definition at line 739 of file fe_evaluation.h.
|
protected |
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. As opposed to requesting memory on the stack, this approach allows for very large polynomial degrees.
Definition at line 752 of file fe_evaluation.h.
|
protected |
Stores the number of the quadrature formula of the present cell.
Definition at line 757 of file fe_evaluation.h.
|
protected |
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 763 of file fe_evaluation.h.
|
protected |
Stores the active fe index for this class for efficient indexing in the hp case.
Definition at line 769 of file fe_evaluation.h.
|
protected |
Stores the active quadrature index for this class for efficient indexing in the hp case.
Definition at line 775 of file fe_evaluation.h.
|
protected |
Stores a pointer to the underlying data.
Definition at line 780 of file fe_evaluation.h.
|
protected |
Stores 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 787 of file fe_evaluation.h.
|
protected |
Stores 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 795 of file fe_evaluation.h.
|
protected |
Stores 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 803 of file fe_evaluation.h.
|
protected |
A pointer to the Cartesian Jacobian information of the present cell. Only set to a useful value if on a Cartesian cell, otherwise zero.
Definition at line 809 of file fe_evaluation.h.
|
protected |
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 815 of file fe_evaluation.h.
|
protected |
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 823 of file fe_evaluation.h.
|
protected |
A pointer to the quadrature weights of the underlying quadrature formula.
Definition at line 828 of file fe_evaluation.h.
|
protected |
A pointer to the quadrature points on the present cell.
Definition at line 833 of file fe_evaluation.h.
|
protected |
A pointer to the diagonal part of the Jacobian gradient on the present cell. Only set to a useful value if on a general cell with non-constant Jacobian.
Definition at line 840 of file fe_evaluation.h.
|
protected |
A pointer to the upper diagonal part of the Jacobian gradient on the present cell. Only set to a useful value if on a general cell with non- constant Jacobian.
Definition at line 847 of file fe_evaluation.h.
|
protected |
After a call to reinit(), stores the number of the cell we are currently working with.
Definition at line 853 of file fe_evaluation.h.
|
protected |
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 861 of file fe_evaluation.h.
|
protected |
The stride to access the correct data in MappingInfo.
Definition at line 866 of file fe_evaluation.h.
|
protected |
Debug information to track whether dof values have been initialized before accessed. Used to control exceptions when uninitialized data is used.
Definition at line 873 of file fe_evaluation.h.
|
protected |
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 880 of file fe_evaluation.h.
|
protected |
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 887 of file fe_evaluation.h.
|
protected |
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 894 of file fe_evaluation.h.
|
protected |
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 901 of file fe_evaluation.h.
|
protected |
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 908 of file fe_evaluation.h.
|
protected |
Geometry data that can be generated FEValues on the fly with the respective constructor.
Definition at line 914 of file fe_evaluation.h.
|
protected |
For use with on-the-fly evaluation, provide a data structure to store the global dof indices on the current cell from a reinit call.
Definition at line 920 of file fe_evaluation.h.
|
protected |
For a FiniteElement with more than one finite element, select at which component this data structure should start.
Definition at line 926 of file fe_evaluation.h.
|
mutableprotected |
A temporary data structure necessary to read degrees of freedom when no MatrixFree object was given at initialization.
Definition at line 932 of file fe_evaluation.h.
1.8.14