internal Namespace Reference

Namespaces
namespace	BlockLinearOperatorImplementation
namespace	BlockVectorIterators
namespace	DataOutFacesImplementation
namespace	DataOutImplementation
namespace	DataOutRotationImplementation
namespace	DoFAccessorImplementation
namespace	DoFHandlerImplementation
namespace	FE_BDM
namespace	FE_DGPMonomial
namespace	FE_DGQ
namespace	FE_Enriched
namespace	FE_FaceQImplementation
namespace	FE_Nedelec
namespace	FE_PolyTensor
namespace	FE_Q
namespace	FE_Q_Base
namespace	FE_Q_Bubbles
namespace	FE_Q_Hierarchical
namespace	FEInterfaceViews
namespace	FEPointEvaluation
namespace	FEValuesImplementation
namespace	FEValuesViews
namespace	FilteredIteratorImplementation
namespace	FunctionParser
namespace	GrowingVectorMemoryImplementation
namespace	hp
namespace	LAPACKFullMatrixImplementation
namespace	LinearOperatorImplementation
namespace	MappingFEFieldImplementation
namespace	MappingFEImplementation
namespace	MappingManifoldImplementation
namespace	MappingQ1
namespace	MappingQImplementation
namespace	MatrixFreeFunctions
namespace	MatrixOutImplementation
namespace	MGTransfer
namespace	p4est
namespace	PackagedOperationImplementation
namespace	parallel
namespace	PointValueHistoryImplementation
namespace	PolynomialsRannacherTurekImplementation
namespace	QGaussChebyshev
namespace	QGaussLobatto
namespace	QGaussLobattoChebyshev
namespace	QGaussRadau
namespace	QGaussRadauChebyshev
namespace	QIteratedImplementation
namespace	QProjector
namespace	QRImplementation
namespace	SD
namespace	SolverGMRESImplementation
namespace	SolverIDRImplementation
namespace	SparseMatrixImplementation
namespace	SphericalManifold
namespace	SupportsOperation
namespace	SymmetricTensorAccessors
namespace	SymmetricTensorImplementation
namespace	TableBaseAccessors
namespace	TemplateConstraints
namespace	TensorProductManifoldImplementation
namespace	TensorProductMatrixSymmetricSum
namespace	TensorProductPolynomials
namespace	TimerImplementation
namespace	TriaAccessorImplementation
namespace	TriangulationImplementation
namespace	UtilitiesImplementation
namespace	VectorImplementation
namespace	VectorOperations

Classes
class	ActiveCellIterator
class	AlignedVectorCopyConstruct
class	AlignedVectorDefaultInitialize
class	AlignedVectorInitialize
class	AlignedVectorMoveConstruct
struct	argument_type
struct	argument_type< T(U)>
struct	CellAttachedData
class	CellAttachedDataSerializer
class	CellIDTranslator
struct	CellwiseInverseMassFactory
struct	CellwiseInverseMassMatrixImplBasic
struct	CellwiseInverseMassMatrixImplFlexible
struct	CellwiseInverseMassMatrixImplTransformFromQPoints
struct	CurlType
struct	CurlType< 1, NumberType >
struct	CurlType< 2, NumberType >
struct	CurlType< 3, NumberType >
struct	EigenvalueAlgorithmAdditionalData
struct	EigenvalueInformation
struct	ElementAccess
struct	ElementAccess< LinearAlgebra::TpetraWrappers::Vector< NumberType, MemorySpace > >
struct	EvaluatorSelector
struct	EvaluatorSelector< MatrixFreeFunctions::tensor_general, is_long >
struct	EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric, false >
struct	EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric, true >
struct	EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric_collocation, is_long >
struct	EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric_plus_dg0, false >
struct	EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric_plus_dg0, true >
struct	EvaluatorSelector< MatrixFreeFunctions::truncated_tensor, is_long >
struct	EvaluatorTensorProduct
struct	EvaluatorTensorProduct< variant, dim, 0, 0, Number, Number2 >
struct	EvaluatorTensorProductAnisotropic
struct	FastEvaluationSupported
struct	FEEvaluationFactory
struct	FEEvaluationHangingNodesFactory
struct	FEEvaluationImpl
struct	FEEvaluationImpl< MatrixFreeFunctions::tensor_none, dim, fe_degree, n_q_points_1d, Number >
struct	FEEvaluationImpl< MatrixFreeFunctions::tensor_raviart_thomas, dim, fe_degree, n_q_points_1d, Number >
struct	FEEvaluationImplBasisChange
struct	FEEvaluationImplCollocation
struct	FEEvaluationImplHangingNodes
class	FEEvaluationImplHangingNodesRunner
class	FEEvaluationImplHangingNodesRunner< FEEvaluationImplHangingNodesRunnerTypes::scalar, dim, fe_degree, Number >
class	FEEvaluationImplHangingNodesRunner< FEEvaluationImplHangingNodesRunnerTypes::vectorized, dim, fe_degree, Number >
struct	FEEvaluationImplSelector
struct	FEEvaluationImplTransformToCollocation
struct	FEFaceEvaluationFactory
struct	FEFaceEvaluationGatherFactory
struct	FEFaceEvaluationImpl
struct	FEFaceEvaluationImplCollectFromFaceSelector
struct	FEFaceEvaluationImplEvaluateInFaceSelector
struct	FEFaceEvaluationImplEvaluateSelector
struct	FEFaceEvaluationImplGatherEvaluateSelector
struct	FEFaceEvaluationImplIntegrateInFaceSelector
struct	FEFaceEvaluationImplIntegrateScatterSelector
struct	FEFaceEvaluationImplIntegrateSelector
struct	FEFaceEvaluationImplProjectToFaceSelector
struct	FEFaceEvaluationImplRaviartThomas
struct	FEFaceNormalEvaluationImpl
struct	GenericDoFsPerObject
class	Helper
class	Helper< HelperType::constant, Number, VectorizationType, fe_degree, transpose >
class	Helper< HelperType::dynamic, Number, VectorizationType, fe_degree, transpose >
class	HelperBase
struct	is_explicitly_convertible
struct	MatrixSelector
struct	MatrixSelector< ::LinearAlgebra::TpetraWrappers::Vector< Number, MemorySpace > >
struct	MatrixSelector< LinearAlgebra::distributed::Vector< Number > >
struct	MatrixSelector<::LinearAlgebra::EpetraWrappers::Vector >
struct	MatrixSelector<::PETScWrappers::MPI::Vector >
struct	MatrixSelector<::TrilinosWrappers::MPI::Vector >
struct	MFWorkerInterface
class	NoPermutation
struct	NumberType
struct	NumberType< std::complex< T > >
struct	ParameterAcceptorCompare
struct	PrecomputedEvaluationData
class	PrecomputedEvaluationDataAccessor
struct	PrecomputedEvaluationDataView
struct	ProductTypeImpl
struct	ProductTypeImpl< adouble, adouble >
struct	ProductTypeImpl< adouble, adub >
struct	ProductTypeImpl< adouble, double >
struct	ProductTypeImpl< adouble, float >
struct	ProductTypeImpl< adtl::adouble, adtl::adouble >
struct	ProductTypeImpl< adtl::adouble, double >
struct	ProductTypeImpl< adtl::adouble, float >
struct	ProductTypeImpl< adub, adouble >
struct	ProductTypeImpl< adub, double >
struct	ProductTypeImpl< adub, float >
struct	ProductTypeImpl< Differentiation::SD::Expression, Differentiation::SD::Expression >
struct	ProductTypeImpl< Differentiation::SD::Expression, T >
struct	ProductTypeImpl< double, adouble >
struct	ProductTypeImpl< double, adtl::adouble >
struct	ProductTypeImpl< double, adub >
struct	ProductTypeImpl< double, Sacado::Fad::DFad< T > >
struct	ProductTypeImpl< double, Sacado::Rad::ADvar< T > >
struct	ProductTypeImpl< double, Sacado::Rad::ADvari< T > >
struct	ProductTypeImpl< double, std::complex< U > >
struct	ProductTypeImpl< float, adouble >
struct	ProductTypeImpl< float, adtl::adouble >
struct	ProductTypeImpl< float, adub >
struct	ProductTypeImpl< float, Sacado::Fad::DFad< T > >
struct	ProductTypeImpl< float, Sacado::Rad::ADvar< T > >
struct	ProductTypeImpl< float, Sacado::Rad::ADvari< T > >
struct	ProductTypeImpl< float, std::complex< U > >
struct	ProductTypeImpl< int, Sacado::Fad::DFad< T > >
struct	ProductTypeImpl< int, Sacado::Rad::ADvar< T > >
struct	ProductTypeImpl< int, Sacado::Rad::ADvari< T > >
struct	ProductTypeImpl< Sacado::Fad::DFad< T >, double >
struct	ProductTypeImpl< Sacado::Fad::DFad< T >, float >
struct	ProductTypeImpl< Sacado::Fad::DFad< T >, int >
struct	ProductTypeImpl< Sacado::Fad::DFad< T >, Sacado::Fad::DFad< U > >
struct	ProductTypeImpl< Sacado::Fad::Expr< T >, Sacado::Fad::Expr< U > >
struct	ProductTypeImpl< Sacado::Fad::Expr< T >, U >
struct	ProductTypeImpl< Sacado::Rad::ADvar< T >, double >
struct	ProductTypeImpl< Sacado::Rad::ADvar< T >, float >
struct	ProductTypeImpl< Sacado::Rad::ADvar< T >, int >
struct	ProductTypeImpl< Sacado::Rad::ADvar< T >, Sacado::Rad::ADvar< U > >
struct	ProductTypeImpl< Sacado::Rad::ADvar< T >, Sacado::Rad::ADvari< U > >
struct	ProductTypeImpl< Sacado::Rad::ADvari< T >, double >
struct	ProductTypeImpl< Sacado::Rad::ADvari< T >, float >
struct	ProductTypeImpl< Sacado::Rad::ADvari< T >, int >
struct	ProductTypeImpl< Sacado::Rad::ADvari< T >, Sacado::Rad::ADvar< U > >
struct	ProductTypeImpl< Sacado::Rad::ADvari< T >, Sacado::Rad::ADvari< U > >
struct	ProductTypeImpl< std::complex< adouble >, std::complex< adouble > >
struct	ProductTypeImpl< std::complex< adouble >, std::complex< adub > >
struct	ProductTypeImpl< std::complex< adouble >, std::complex< double > >
struct	ProductTypeImpl< std::complex< adouble >, std::complex< float > >
struct	ProductTypeImpl< std::complex< adtl::adouble >, std::complex< adtl::adouble > >
struct	ProductTypeImpl< std::complex< adtl::adouble >, std::complex< double > >
struct	ProductTypeImpl< std::complex< adtl::adouble >, std::complex< float > >
struct	ProductTypeImpl< std::complex< adub >, std::complex< adouble > >
struct	ProductTypeImpl< std::complex< double >, std::complex< adouble > >
struct	ProductTypeImpl< std::complex< double >, std::complex< adtl::adouble > >
struct	ProductTypeImpl< std::complex< float >, std::complex< adouble > >
struct	ProductTypeImpl< std::complex< float >, std::complex< adtl::adouble > >
struct	ProductTypeImpl< std::complex< T >, double >
struct	ProductTypeImpl< std::complex< T >, float >
struct	ProductTypeImpl< std::complex< T >, std::complex< T > >
struct	ProductTypeImpl< std::complex< T >, std::complex< U > >
struct	ProductTypeImpl< std::complex< T >, SymmetricTensor< rank, dim, std::complex< U > > >
struct	ProductTypeImpl< std::complex< T >, SymmetricTensor< rank, dim, U > >
struct	ProductTypeImpl< SymmetricTensor< rank, dim, std::complex< T > >, std::complex< U > >
struct	ProductTypeImpl< SymmetricTensor< rank, dim, T >, std::complex< U > >
struct	ProductTypeImpl< T, Differentiation::SD::Expression >
struct	ProductTypeImpl< T, Sacado::Fad::Expr< U > >
struct	ProductTypeNoPoint
struct	ProductTypeNoPoint< Point< dim, Number >, Number2 >
class	Rescaler
class	SubfaceCase
struct	SubfacePossibilities
struct	SubfacePossibilities< 0 >
struct	SubfacePossibilities< 1 >
struct	SubfacePossibilities< 2 >
struct	SubfacePossibilities< 3 >
struct	TableEntry
struct	Trait
struct	Trait< T1, VectorizationTypes::group >
struct	Trait< T1, VectorizationTypes::index >
struct	Trait< T1, VectorizationTypes::mask >
struct	Trait< T1, VectorizationTypes::sorted >
struct	VectorDistributorLocalToGlobal
struct	VectorizedArrayTrait
struct	VectorizedArrayTrait< VectorizedArray< T, width_ > >
struct	VectorizedArrayWidthSpecifier
struct	VectorizedArrayWidthSpecifier< double >
struct	VectorizedArrayWidthSpecifier< float >
struct	VectorReader
struct	VectorSetter

Typedefs
template<typename F >
using	argument_type_t = typename argument_type< F >::type
template<typename T >
using	has_block_t = decltype(std::declval< const T >().block(0))
template<typename T >
using	has_n_blocks_t = decltype(std::declval< const T >().n_blocks())
template<typename T >
using	set_ghost_state_t = decltype(std::declval< const T >().set_ghost_state(std::declval< bool >()))

Enumerations
enum class	EigenvalueAlgorithm { lanczos , power_iteration }
enum class	FEEvaluationImplHangingNodesRunnerTypes { scalar , vectorized }
enum class	VectorizationTypes { index , group , mask , sorted }
enum class	HelperType { constant , dynamic }
enum	EvaluatorVariant { evaluate_general , evaluate_symmetric , evaluate_evenodd , evaluate_symmetric_hierarchical }
enum class	EvaluatorQuantity { value , gradient , hessian }

Functions
template<int dim>
Point< dim+1 >	create_higher_dim_point (const Point< dim > &point, const unsigned int component_in_dim_plus_1, const double coordinate_value)
void	ensure_kokkos_initialized ()
internal::GenericDoFsPerObject	expand (const unsigned int dim, const std::vector< unsigned int > &dofs_per_object, const ReferenceCell reference_cell)
constexpr ReferenceCell	make_reference_cell_from_int (const std::uint8_t kind)
static ::ExceptionBase &	ExcNonMatchingReferenceCellTypes (ReferenceCell arg1, ReferenceCell arg2)
unsigned char	combined_face_orientation (const bool face_orientation, const bool face_rotation, const bool face_flip)
std::tuple< bool, bool, bool >	split_face_orientation (const unsigned char combined_face_orientation)
template<typename MatrixType >
void	reinit (MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
template<typename number >
void	reinit (MatrixBlock<::SparseMatrix< number > > &v, const BlockSparsityPattern &p)
template<int n_points_1d, int dim, typename Number , typename Number2 >
void	evaluate_gradients_collocation (const MatrixFreeFunctions::UnivariateShapeData< Number2 > &shape, const Number *values, Number *gradients)
template<int n_points_1d, int dim, typename Number , typename Number2 >
void	integrate_gradients_collocation (const MatrixFreeFunctions::UnivariateShapeData< Number2 > &shape, Number *values, const Number *gradients, const bool add_into_values_array)
template<int n_points_1d, int dim, typename Number >
void	evaluate_hessians_collocation (const unsigned int n_components, FEEvaluationData< dim, Number, false > &fe_eval)
template<int n_q_points_1d, int dim, typename Number >
void	integrate_hessians_collocation (const unsigned int n_components, FEEvaluationData< dim, Number, false > &fe_eval, const bool add_into_values_array)
template<int dim, typename Number >
void	evaluate_hessians_slow (const unsigned int n_components, const Number *values_dofs, FEEvaluationData< dim, Number, false > &fe_eval)
template<int dim, typename Number >
void	integrate_hessians_slow (const unsigned int n_components, const FEEvaluationData< dim, Number, false > &fe_eval, Number *values_dofs, const bool add_into_values_array)
template<typename VectorizedArrayType , typename Number2 >
void	do_vectorized_read (const Number2 *src_ptr, VectorizedArrayType &dst)
template<typename Number , std::size_t width>
void	do_vectorized_read (const Number *src_ptr, VectorizedArray< Number, width > &dst)
template<typename VectorizedArrayType , typename Number2 >
void	do_vectorized_gather (const Number2 *src_ptr, const unsigned int *indices, VectorizedArrayType &dst)
template<typename Number , std::size_t width>
void	do_vectorized_gather (const Number *src_ptr, const unsigned int *indices, VectorizedArray< Number, width > &dst)
template<typename VectorizedArrayType , typename Number2 >
void	do_vectorized_add (const VectorizedArrayType src, Number2 *dst_ptr)
template<typename Number , std::size_t width>
void	do_vectorized_add (const VectorizedArray< Number, width > src, Number *dst_ptr)
template<typename VectorizedArrayType , typename Number2 >
void	do_vectorized_scatter_add (const VectorizedArrayType src, const unsigned int *indices, Number2 *dst_ptr)
template<typename Number , std::size_t width>
void	do_vectorized_scatter_add (const VectorizedArray< Number, width > src, const unsigned int *indices, Number *dst_ptr)
template<typename Number >
void	adjust_for_face_orientation (const unsigned int dim, const unsigned int n_components, const EvaluationFlags::EvaluationFlags flag, const unsigned int *orientation, const bool integrate, const std::size_t n_q_points, Number *tmp_values, Number *values_quad, Number *gradients_quad, Number *hessians_quad)
template<typename Number , typename VectorizedArrayType >
void	adjust_for_face_orientation_per_lane (const unsigned int dim, const unsigned int n_components, const unsigned int v, const EvaluationFlags::EvaluationFlags flag, const unsigned int *orientation, const bool integrate, const std::size_t n_q_points, Number *tmp_values, VectorizedArrayType *values_quad, VectorizedArrayType *gradients_quad=nullptr, VectorizedArrayType *hessians_quad=nullptr)
template<int n_face_orientations, typename Processor , typename EvaluationData , const bool check_face_orientations = false>
void	fe_face_evaluation_process_and_io (Processor &proc, const unsigned int n_components, const EvaluationFlags::EvaluationFlags evaluation_flag, typename Processor::Number2_ *global_vector_ptr, const std::vector< ArrayView< const typename Processor::Number2_ > > *sm_ptr, const EvaluationData &fe_eval, typename Processor::VectorizedArrayType_ *temp1)
template<int degree, typename EvaluatorType , typename... Args>
bool	instantiation_helper_run (const unsigned int given_degree, const unsigned int n_q_points_1d, Args &...args)
template<int degree, typename EvaluatorType , typename... Args>
bool	instantiation_helper_degree_run (const unsigned int given_degree, Args &...args)
static ::ExceptionBase &	ExcAccessToUninitializedField ()
static ::ExceptionBase &	ExcMatrixFreeAccessToUninitializedMappingField (std::string arg1)
template<EvaluatorVariant variant, EvaluatorQuantity quantity, int n_rows, int n_columns, int stride_in, int stride_out, bool transpose_matrix, bool add, typename Number , typename Number2 >
std::enable_if_t<(variant==evaluate_general), void >	apply_matrix_vector_product (const Number2 *matrix, const Number *in, Number *out)
template<EvaluatorVariant variant, EvaluatorQuantity quantity, bool transpose_matrix, bool add, bool consider_strides, typename Number , typename Number2 , int n_components = 1>
std::enable_if_t<(variant==evaluate_general), void >	apply_matrix_vector_product (const Number2 *matrix, const Number *in, Number *out, const int n_rows, const int n_columns, const int stride_in_given, const int stride_out_given)
template<EvaluatorVariant variant, EvaluatorQuantity quantity, int n_rows, int n_columns, int stride_in, int stride_out, bool transpose_matrix, bool add, typename Number , typename Number2 >
std::enable_if_t<(variant==evaluate_symmetric), void >	apply_matrix_vector_product (const Number2 *matrix, const Number *in, Number *out)
template<EvaluatorVariant variant, EvaluatorQuantity quantity, int n_rows_static, int n_columns_static, int stride_in_static, int stride_out_static, bool transpose_matrix, bool add, typename Number , typename Number2 >
std::enable_if_t<(variant==evaluate_evenodd), void >	apply_matrix_vector_product (const Number2 *DEAL_II_RESTRICT matrix, const Number *in, Number *out, int n_rows_runtime=0, int n_columns_runtime=0, int stride_in_runtime=0, int stride_out_runtime=0)
template<EvaluatorVariant variant, EvaluatorQuantity quantity, bool transpose_matrix, bool add, bool consider_strides, typename Number , typename Number2 >
std::enable_if_t<(variant==evaluate_evenodd), void >	apply_matrix_vector_product (const Number2 *matrix, const Number *in, Number *out, int n_rows, int n_columns, int stride_in, int stride_out)
template<EvaluatorVariant variant, EvaluatorQuantity quantity, int n_rows, int n_columns, int stride_in, int stride_out, bool transpose_matrix, bool add, typename Number , typename Number2 >
std::enable_if_t<(variant==evaluate_symmetric_hierarchical), void >	apply_matrix_vector_product (const Number2 *matrix, const Number *in, Number *out)
template<int n_rows_template, int stride_template, bool contract_onto_face, bool add, int max_derivative, typename Number , typename Number2 >
std::enable_if_t< contract_onto_face, void >	interpolate_to_face (const Number2 *shape_values, const std::array< int, 2 > &n_blocks, const std::array< int, 2 > &steps, const Number *input, Number *DEAL_II_RESTRICT output, const int n_rows_runtime=0, const int stride_runtime=1)
constexpr bool	use_collocation_evaluation (const unsigned int fe_degree, const unsigned int n_q_points_1d)
template<int n_rows_template, int stride_template, bool contract_onto_face, bool add, int max_derivative, typename Number , typename Number2 >
std::enable_if_t<!contract_onto_face, void >	interpolate_to_face (const Number2 *shape_values, const std::array< int, 2 > &n_blocks, const std::array< int, 2 > &steps, const Number *input, Number *DEAL_II_RESTRICT output, const int n_rows_runtime=0, const int stride_runtime=1)
template<int dim, int n_points_1d_template, typename Number >
void	weight_fe_q_dofs_by_entity (const Number *weights, const unsigned int n_components, const int n_points_1d_non_template, Number *data)
template<int dim, int n_points_1d_template, typename Number >
void	weight_fe_q_dofs_by_entity_shifted (const Number *weights, const unsigned int n_components, const int n_points_1d_non_template, Number *data)
template<int dim, int n_points_1d_template, typename Number >
bool	compute_weights_fe_q_dofs_by_entity (const Number *data, const unsigned int n_components, const int n_points_1d_non_template, Number *weights)
template<int dim, int n_points_1d_template, typename Number >
bool	compute_weights_fe_q_dofs_by_entity_shifted (const Number *data, const unsigned int n_components, const int n_points_1d_non_template, Number *weights)
template<int dim, typename Number >
void	compute_values_of_array (::ndarray< Number, 2, dim > *shapes, const std::vector< Polynomials::Polynomial< double > > &poly, const Point< dim, Number > &p, const unsigned int derivative=1)
template<typename Number >
void	compute_values_of_array (::ndarray< Number, 2, 0 > *, const std::vector< Polynomials::Polynomial< double > > &, const Point< 0, Number > &, const unsigned int)
template<int dim, typename Number >
void	compute_values_of_array_in_pairs (::ndarray< Number, 2, dim > *shapes, const std::vector< Polynomials::Polynomial< double > > &poly, const Point< dim, Number > &p0, const Point< dim, Number > &p1)
template<int dim, int length, typename Number2 , typename Number , int n_values = 1, bool do_renumber = true, int stride = 1>
std::array< typename ProductTypeNoPoint< Number, Number2 >::type, 2+n_values >	do_interpolate_xy (const Number *values, const std::vector< unsigned int > &renumber, const ::ndarray< Number2, 2, dim > *shapes, const int n_shapes_runtime, int &i)
template<int dim, typename Number , typename Number2 , int n_values = 1, bool do_renumber = true, int stride = 1>
std::array< typename ProductTypeNoPoint< Number, Number2 >::type, dim+n_values >	evaluate_tensor_product_value_and_gradient_shapes (const ::ndarray< Number2, 2, dim > *shapes, const int n_shapes, const Number *values, const std::vector< unsigned int > &renumber={})
template<int dim, typename Number , typename Number2 , int n_values = 1, int stride = 1>
std::array< typename ProductTypeNoPoint< Number, Number2 >::type, dim+n_values >	evaluate_tensor_product_value_and_gradient_linear (const Number *values, const Point< dim, Number2 > &p)
template<int dim, typename Number , typename Number2 >
std::pair< typename ProductTypeNoPoint< Number, Number2 >::type, Tensor< 1, dim, typename ProductTypeNoPoint< Number, Number2 >::type > >	evaluate_tensor_product_value_and_gradient (const std::vector< Polynomials::Polynomial< double > > &poly, const ArrayView< const Number > &values, const Point< dim, Number2 > &p, const bool d_linear=false, const std::vector< unsigned int > &renumber={})
template<int dim, int length, typename Number2 , typename Number , bool do_renumber = true, int stride = 1>
ProductTypeNoPoint< Number, Number2 >::type	do_interpolate_xy_value (const Number *values, const std::vector< unsigned int > &renumber, const ::ndarray< Number2, 2, dim > *shapes, const int n_shapes_runtime, int &i)
template<int dim, typename Number , typename Number2 , bool do_renumber = true, int stride = 1>
ProductTypeNoPoint< Number, Number2 >::type	evaluate_tensor_product_value_shapes (const ::ndarray< Number2, 2, dim > *shapes, const int n_shapes, const Number *values, const std::vector< unsigned int > &renumber={})
template<int dim, typename Number , typename Number2 , int stride = 1>
ProductTypeNoPoint< Number, Number2 >::type	evaluate_tensor_product_value_linear (const Number *values, const Point< dim, Number2 > &p)
template<int dim, typename Number , typename Number2 >
ProductTypeNoPoint< Number, Number2 >::type	evaluate_tensor_product_value (const std::vector< Polynomials::Polynomial< double > > &poly, const ArrayView< const Number > &values, const Point< dim, Number2 > &p, const bool d_linear=false, const std::vector< unsigned int > &renumber={})
template<int derivative_order, typename Number , typename Number2 >
Tensor< 1, 1, typename ProductTypeNoPoint< Number, Number2 >::type >	evaluate_tensor_product_higher_derivatives (const std::vector< Polynomials::Polynomial< double > > &poly, const ArrayView< const Number > &values, const Point< 1, Number2 > &p, const std::vector< unsigned int > &renumber={})
template<int derivative_order, typename Number , typename Number2 >
Tensor< 1, derivative_order+1, typename ProductTypeNoPoint< Number, Number2 >::type >	evaluate_tensor_product_higher_derivatives (const std::vector< Polynomials::Polynomial< double > > &poly, const ArrayView< const Number > &values, const Point< 2, Number2 > &p, const std::vector< unsigned int > &renumber={})
template<int derivative_order, typename Number , typename Number2 >
Tensor< 1,((derivative_order+1) *(derivative_order+2))/2, typename ProductTypeNoPoint< Number, Number2 >::type >	evaluate_tensor_product_higher_derivatives (const std::vector< Polynomials::Polynomial< double > > &poly, const ArrayView< const Number > &values, const Point< 3, Number2 > &p, const std::vector< unsigned int > &renumber={})
template<int dim, typename Number , typename Number2 >
SymmetricTensor< 2, dim, typename ProductTypeNoPoint< Number, Number2 >::type >	evaluate_tensor_product_hessian (const std::vector< Polynomials::Polynomial< double > > &poly, const ArrayView< const Number > &values, const Point< dim, Number2 > &p, const std::vector< unsigned int > &renumber={})
template<int dim, int length, typename Number2 , typename Number , bool add, int n_values = 1>
void	do_apply_test_functions_xy (Number2 *values, const ::ndarray< Number, 2, dim > *shapes, const std::array< Number2, 2+n_values > &test_grads_value, const int n_shapes_runtime, int &i)
template<int dim, typename Number , typename Number2 , bool add, int n_values = 1>
void	integrate_add_tensor_product_value_and_gradient_shapes (const ::ndarray< Number, 2, dim > *shapes, const int n_shapes, const Number2 *value, const Tensor< 1, dim, Number2 > &gradient, Number2 *values)
template<int dim, typename Number , typename Number2 , bool add, int n_values = 1>
void	integrate_add_tensor_product_value_and_gradient_linear (const Number2 *value, const Tensor< 1, dim, Number2 > &gradient, Number2 *values, const Point< dim, Number > &p)
template<bool is_linear, int dim, typename Number , typename Number2 , int n_values = 1>
void	integrate_tensor_product_value_and_gradient (const ::ndarray< Number, 2, dim > *shapes, const unsigned int n_shapes, const Number2 *value, const Tensor< 1, dim, Number2 > &gradient, Number2 *values, const Point< dim, Number > &p, const bool do_add)
template<int dim, int length, typename Number2 , typename Number , bool add>
void	do_apply_test_functions_xy_value (Number2 *values, const ::ndarray< Number, 2, dim > *shapes, const Number2 &test_value, const int n_shapes_runtime, int &i)
template<int dim, typename Number , typename Number2 , bool add>
void	integrate_add_tensor_product_value_shapes (const ::ndarray< Number, 2, dim > *shapes, const int n_shapes, const Number2 &value, Number2 *values)
template<int dim, typename Number , typename Number2 , bool add>
void	integrate_add_tensor_product_value_linear (const Number2 &value, Number2 *values, const Point< dim, Number > &p)
template<bool is_linear, int dim, typename Number , typename Number2 >
void	integrate_tensor_product_value (const ::ndarray< Number, 2, dim > *shapes, const unsigned int n_shapes, const Number2 &value, Number2 *values, const Point< dim, Number > &p, const bool do_add)
template<typename VectorType , std::enable_if_t< is_serial_vector_or_array< VectorType >::value, VectorType > * = nullptr>
VectorType::value_type	vector_access (const VectorType &vec, const unsigned int entry)
template<typename VectorType , std::enable_if_t< is_serial_vector_or_array< VectorType >::value, VectorType > * = nullptr>
VectorType::value_type &	vector_access (VectorType &vec, const unsigned int entry)
template<typename VectorType , std::enable_if_t< has_add_local_element< VectorType >, VectorType > * = nullptr>
void	vector_access_add (VectorType &vec, const unsigned int entry, const typename VectorType::value_type &val)
template<typename VectorType , std::enable_if_t< has_add_local_element< VectorType >, VectorType > * = nullptr>
void	vector_access_add_global (VectorType &vec, const types::global_dof_index entry, const typename VectorType::value_type &val)
template<typename VectorType , std::enable_if_t< has_set_local_element< VectorType >, VectorType > * = nullptr>
void	vector_access_set (VectorType &vec, const unsigned int entry, const typename VectorType::value_type &val)
template<int dim, typename Number , typename VectorizedArrayType , typename VectorType , std::enable_if_t<!has_partitioners_are_compatible< VectorType >, VectorType > * = nullptr>
void	check_vector_compatibility (const VectorType &vec, const MatrixFree< dim, Number, VectorizedArrayType > &matrix_free, const internal::MatrixFreeFunctions::DoFInfo &dof_info)
template<class DI >
bool	is_active_iterator (const DI &)
template<typename AccessorType >
bool	is_active_iterator (const TriaActiveIterator< AccessorType > &)
template<typename AccessorType >
bool	is_active_iterator (const ::FilteredIterator< TriaActiveIterator< AccessorType > > &)
template<int dim, class DOFINFO , class A >
void	assemble (const MeshWorker::DoFInfoBox< dim, DOFINFO > &dinfo, A *assembler)
template<int dim>
unsigned int	get_degree (const std::vector< typename BarycentricPolynomials< dim >::PolyType > &polys)
template<typename Number >
std::enable_if_t<!std::is_unsigned_v< Number >, typename numbers::NumberTraits< Number >::real_type >	get_abs (const Number a)
template<typename Number >
std::enable_if_t< std::is_unsigned_v< Number >, Number >	get_abs (const Number a)
template<typename VectorType , std::enable_if_t< has_set_ghost_state< VectorType >, VectorType > * = nullptr>
void	set_ghost_state (VectorType &vector, const bool ghosted)
template<int dim, int spacedim, bool lda, class OutputVector , typename number >
void	set_dof_values (const DoFCellAccessor< dim, spacedim, lda > &cell, const Vector< number > &local_values, OutputVector &values, const bool perform_check)
template<int dim, int spacedim, bool lda, class OutputVector , typename number >
void	process_by_interpolation (const DoFCellAccessor< dim, spacedim, lda > &cell, const Vector< number > &local_values, OutputVector &values, const types::fe_index fe_index_, const std::function< void(const DoFCellAccessor< dim, spacedim, lda > &cell, const Vector< number > &local_values, OutputVector &values)> &processor)
template<int dim, int spacedim>
std::string	policy_to_string (const ::internal::DoFHandlerImplementation::Policy::PolicyBase< dim, spacedim > &policy)
unsigned int	number_unique_entries (const std::vector< unsigned int > &vector)
unsigned int	get_regularity_from_degree (const unsigned int fe_degree)
std::vector< unsigned int >	get_hermite_dpo_vector (const unsigned int dim, const unsigned int regularity)
template<int dim>
void	hermite_hierarchic_to_lexicographic_numbering (const unsigned int regularity, std::vector< unsigned int > &h2l)
template<>
void	hermite_hierarchic_to_lexicographic_numbering< 1 > (const unsigned int regularity, std::vector< unsigned int > &h2l)
template<>
void	hermite_hierarchic_to_lexicographic_numbering< 2 > (const unsigned int regularity, std::vector< unsigned int > &h2l)
template<>
void	hermite_hierarchic_to_lexicographic_numbering< 3 > (const unsigned int regularity, std::vector< unsigned int > &h2l)
template<int dim>
std::vector< unsigned int >	hermite_hierarchic_to_lexicographic_numbering (const unsigned int regularity)
template<int dim>
std::vector< unsigned int >	hermite_lexicographic_to_hierarchic_numbering (const unsigned int regularity)
template<int dim>
std::vector< unsigned int >	hermite_face_lexicographic_to_hierarchic_numbering (const unsigned int regularity)
template<int dim>
TensorProductPolynomials< dim >	get_hermite_polynomials (const unsigned int fe_degree)
template<int dim, int spacedim = dim>
Table< 2, unsigned int >	setup_primitive_offset_table (const FESystem< dim, spacedim > &fe, const unsigned int base_no)
template<int dim, int spacedim = dim>
std::vector< typename FESystem< dim, spacedim >::BaseOffsets >	setup_nonprimitive_offset_table (const FESystem< dim, spacedim > &fe, const unsigned int base_no)
template<int dim, int spacedim = dim>
void	copy_primitive_base_element_values (const FESystem< dim, spacedim > &fe, const unsigned int base_no, const UpdateFlags base_flags, const Table< 2, unsigned int > &base_to_system_table, const FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &base_data, FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &output_data)
template<int dim, int spacedim = dim>
void	copy_nonprimitive_base_element_values (const FESystem< dim, spacedim > &fe, const unsigned int base_no, const unsigned int n_q_points, const UpdateFlags base_flags, const std::vector< typename FESystem< dim, spacedim >::BaseOffsets > &offsets, const FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &base_data, FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &output_data)
template<int dim, int spacedim>
std::vector< unsigned int >	make_shape_function_to_row_table (const FiniteElement< dim, spacedim > &fe)
template<typename Number , typename Number2 >
void	do_function_values (const ArrayView< Number2 > &dof_values, const ::Table< 2, double > &shape_values, std::vector< Number > &values)
template<int dim, int spacedim, typename VectorType >
void	do_function_values (const ArrayView< typename VectorType::value_type > &dof_values, const ::Table< 2, double > &shape_values, const FiniteElement< dim, spacedim > &fe, const std::vector< unsigned int > &shape_function_to_row_table, ArrayView< VectorType > values, const bool quadrature_points_fastest=false, const unsigned int component_multiple=1)
template<int order, int spacedim, typename Number >
void	do_function_derivatives (const ArrayView< Number > &dof_values, const ::Table< 2, Tensor< order, spacedim > > &shape_derivatives, std::vector< Tensor< order, spacedim, Number > > &derivatives)
template<int order, int dim, int spacedim, typename Number >
void	do_function_derivatives (const ArrayView< Number > &dof_values, const ::Table< 2, Tensor< order, spacedim > > &shape_derivatives, const FiniteElement< dim, spacedim > &fe, const std::vector< unsigned int > &shape_function_to_row_table, ArrayView< std::vector< Tensor< order, spacedim, Number > > > derivatives, const bool quadrature_points_fastest=false, const unsigned int component_multiple=1)
template<int spacedim, typename Number , typename Number2 >
void	do_function_laplacians (const ArrayView< Number2 > &dof_values, const ::Table< 2, Tensor< 2, spacedim > > &shape_hessians, std::vector< Number > &laplacians)
template<int dim, int spacedim, typename VectorType , typename Number >
void	do_function_laplacians (const ArrayView< Number > &dof_values, const ::Table< 2, Tensor< 2, spacedim > > &shape_hessians, const FiniteElement< dim, spacedim > &fe, const std::vector< unsigned int > &shape_function_to_row_table, std::vector< VectorType > &laplacians, const bool quadrature_points_fastest=false, const unsigned int component_multiple=1)
Tensor< 1, 3 >	apply_exponential_map (const Tensor< 1, 3 > &u, const Tensor< 1, 3 > &dir)
Tensor< 1, 3 >	projected_direction (const Tensor< 1, 3 > &u, const Tensor< 1, 3 > &v)
template<int spacedim>
Point< spacedim >	compute_normal (const Tensor< 1, spacedim > &, bool=false)
Point< 3 >	compute_normal (const Tensor< 1, 3 > &vector, bool normalize=false)

Variables
bool	dealii_initialized_kokkos = false
static const constexpr ::ndarray< unsigned int, 6, 2 >	wedge_table_1
static const constexpr ::ndarray< unsigned int, 18, 2 >	wedge_table_2
template<template< class... > class Op, class... Args>
constexpr bool	is_supported_operation
template<typename T >
constexpr bool	has_block = internal::is_supported_operation<has_block_t, T>
template<typename T >
constexpr bool	has_n_blocks
template<typename T >
constexpr bool	is_block_vector = has_block<T> && has_n_blocks<T>
template<typename VectorType >
constexpr bool	is_dealii_vector
template<typename T >
constexpr bool	has_set_ghost_state
static constexpr double	invalid_pull_back_coordinate = 20.0

Detailed Description

This namespace defines the copy and set functions used in AlignedVector. These functions operate in parallel when there are enough elements in the vector.

Typedef Documentation

argument_type_t

template<typename F >

using internal::argument_type_t = typedef typename argument_type<F>::type

Definition at line 2093 of file exceptions.h.

has_block_t

template<typename T >

using internal::has_block_t = typedef decltype(std::declval<const T>().block(0))

Definition at line 48 of file block_vector_base.h.

has_n_blocks_t

template<typename T >

using internal::has_n_blocks_t = typedef decltype(std::declval<const T>().n_blocks())

Definition at line 54 of file block_vector_base.h.

set_ghost_state_t

template<typename T >

using internal::set_ghost_state_t = typedef decltype(std::declval<const T>().set_ghost_state(std::declval<bool>()))

Helper functions that call set_ghost_state() if the vector supports this operation.

Definition at line 94 of file dof_accessor_set.cc.

Enumeration Type Documentation

EigenvalueAlgorithm

enum class internal::EigenvalueAlgorithm

strong

An enum to define the available types of eigenvalue estimation algorithms.

Enumerator
lanczos	This option runs the conjugate gradient solver and computes an eigenvalue estimation from the underlying Lanczos space. This only works for symmetric positive definite matrices.
power_iteration	This option runs a power iteration to estimate the largest eigenvalue. This algorithm also works for non-symmetric matrices, but typically gives less accurate estimates than the option 'lanczos' for the same number of iterations because it does not take the relation between vectors in the iterations into account (roughly speaking the off-diagonal entries in the tri-diagonal matrix of the Lanczos iteration).

Definition at line 67 of file precondition.h.

FEEvaluationImplHangingNodesRunnerTypes

enum class internal::FEEvaluationImplHangingNodesRunnerTypes

strong

Enumerator
scalar
vectorized

Definition at line 40 of file evaluation_kernels_hanging_nodes.h.

VectorizationTypes

enum class internal::VectorizationTypes

strong

Helper enum to specify the type of vectorization for FEEvaluationImplHangingNodesRunnerTypes::scalar.

Enumerator
index	Process cell by cell.
group	Process cells with the same refinement configuration together.
mask	Like index but without access to individual lanes and instead use masks with a single entry with the value one.
sorted	Assume that all lanes have the same refinement configuration.

Definition at line 52 of file evaluation_kernels_hanging_nodes.h.

HelperType

enum class internal::HelperType

strong

Helper enum to specify which Helper implementation should be used.

Enumerator
constant	Compute the start indices of faces and edges based on the template argument fe_degree.
dynamic	Compute the start indices of faces and edges based on the fe_degree passed to the constructor (to be used if the template argument is -1).

Definition at line 1109 of file evaluation_kernels_hanging_nodes.h.

EvaluatorVariant

enum internal::EvaluatorVariant

In this namespace, the evaluator routines that evaluate the tensor products are implemented.

Enumerator
evaluate_general	Do not use anything more than the tensor product structure of the finite element.
evaluate_symmetric	Perform evaluation by exploiting symmetry in the finite element: i.e., skip some computations by utilizing the symmetry in the shape functions and quadrature points.
evaluate_evenodd	Use symmetry to apply the operator to even and odd parts of the input vector separately: see the documentation of the EvaluatorTensorProduct specialization for more information.
evaluate_symmetric_hierarchical	Use symmetry in Legendre and similar polynomial spaces where the shape functions with even number are symmetric about the center of the quadrature points (think about even polynomial degrees) and the shape functions with odd number are anti-symmetric about the center of the quadrature points (think about odd polynomial degrees). This allows to use a strategy similar to the even-odd technique but without separate coefficient arrays. See the documentation of the EvaluatorTensorProduct specialization for more information.

Definition at line 37 of file tensor_product_kernels.h.

EvaluatorQuantity

enum class internal::EvaluatorQuantity

strong

Determine which quantity should be computed via the tensor product kernels.

Enumerator
value	Evaluate/integrate by shape functions.
gradient	Evaluate/integrate by gradients of the shape functions.
hessian	Evaluate/integrate by hessians of the shape functions.

Definition at line 74 of file tensor_product_kernels.h.

Function Documentation

create_higher_dim_point()

template<int dim>

Point< dim+1 > internal::create_higher_dim_point ( const Point< dim > &  point, const unsigned int  component_in_dim_plus_1, const double  coordinate_value  )

private

Creates a (dim + 1)-dimensional point by copying over the coordinates of the incoming dim-dimensional point and setting the "missing" (dim + 1)-dimensional component to the incoming coordinate value.

For example, given the input \(\{(x, y), 2, z \}\) this function creates the point \((x, y, z)\).

The coordinates of the dim-dimensional point are written to the coordinates of the (dim + 1)-dimensional point in the order of the convention given by the function coordinate_to_one_dim_higher. Thus, the order of coordinates on the lower-dimensional point are not preserved: \(\{(z, x), 1, y \}\) creates the point \((x, y, z)\).

Definition at line 23 of file function_restriction.cc.

ensure_kokkos_initialized()

void internal::ensure_kokkos_initialized

(

)

Makes sure that Kokkos is initialized. Sets dealii_initialized_kokkos.

Definition at line 30 of file kokkos.cc.

expand()

internal::GenericDoFsPerObject internal::expand	(	const unsigned int	dim,
		const std::vector< unsigned int > &	dofs_per_object,
		const ReferenceCell	reference_cell
	)

Utility function to convert "dofs per object" information of a dim dimensional reference cell reference_cell.

Definition at line 24 of file fe_data.cc.

make_reference_cell_from_int()

constexpr ReferenceCell internal::make_reference_cell_from_int ( const std::uint8_t  kind )

inlineconstexpr

A helper function to create a ReferenceCell object from an integer. ReferenceCell objects are "singletons" (actually, "multitons" – there are multiple, but they are only a handful and these are all that can be used). What is then necessary is to have a way to create these with their internal id to distinguish the few possible ones in existence. We could do this via a public constructor of ReferenceCell, but that would allow users to create ones outside the range we envision, and we don't want to do that. Rather, the constructor that takes an integer is made private but we have this one function in an internal namespace that is a friend of the class and can be used to create the objects.

Definition at line 1056 of file reference_cell.h.

combined_face_orientation()

unsigned char internal::combined_face_orientation ( const bool  face_orientation, const bool  face_rotation, const bool  face_flip  )

inline

Combine orientation flags.

Definition at line 32 of file tria_orientation.h.

split_face_orientation()

std::tuple< bool, bool, bool > internal::split_face_orientation ( const unsigned char  combined_face_orientation )

inline

Split up a combined orientation flag: orientation flag, rotation flag, flip flag.

Definition at line 45 of file tria_orientation.h.

reinit() [1/2]

template<typename MatrixType >

void internal::reinit	(	MatrixBlock< MatrixType > &	v,
		const BlockSparsityPattern &	p
	)

Definition at line 599 of file matrix_block.h.

reinit() [2/2]

template<typename number >

void internal::reinit	(	MatrixBlock<::SparseMatrix< number > > &	v,
		const BlockSparsityPattern &	p
	)

Definition at line 608 of file matrix_block.h.

evaluate_gradients_collocation()

template<int n_points_1d, int dim, typename Number , typename Number2 >

void internal::evaluate_gradients_collocation ( const MatrixFreeFunctions::UnivariateShapeData< Number2 > &  shape, const Number *  values, Number *  gradients  )

inline

Internal function that evaluates the gradients of finite element functions represented by bases in the collocation space, used by FEEvaluationImplCollocation and FEEvaluationImplTransformToCollocation. The evaluation strategy uses sum factorization with the even-odd optimization and fixed loop bounds.

Definition at line 1313 of file evaluation_kernels.h.

integrate_gradients_collocation()

template<int n_points_1d, int dim, typename Number , typename Number2 >

void internal::integrate_gradients_collocation ( const MatrixFreeFunctions::UnivariateShapeData< Number2 > &  shape, Number *  values, const Number *  gradients, const bool  add_into_values_array  )

inline

Internal function that multiplies by the gradients of test functions and sums over quadrature points for function representations in the collocation space, used by FEEvaluationImplCollocation and FEEvaluationImplTransformToCollocation. The evaluation strategy uses sum factorization with the even-odd optimization and fixed loop bounds.

Definition at line 1367 of file evaluation_kernels.h.

evaluate_hessians_collocation()

template<int n_points_1d, int dim, typename Number >

void internal::evaluate_hessians_collocation ( const unsigned int  n_components, FEEvaluationData< dim, Number, false > &  fe_eval  )

inline

Internal function that evaluates the Hessians of finite element functions represented by bases in the collocation space, used by FEEvaluationImplSelector. The evaluation strategy uses sum factorization with fixed loop bounds.

Definition at line 1430 of file evaluation_kernels.h.

integrate_hessians_collocation()

template<int n_q_points_1d, int dim, typename Number >

void internal::integrate_hessians_collocation ( const unsigned int  n_components, FEEvaluationData< dim, Number, false > &  fe_eval, const bool  add_into_values_array  )

inline

Internal function that multiplies by the Hessians of test functions and sums over quadrature points for function representations in the collocation space, used by FEEvaluationImplSelector. The evaluation strategy uses sum factorization with fixed loop bounds.

Definition at line 1503 of file evaluation_kernels.h.

evaluate_hessians_slow()

template<int dim, typename Number >

void internal::evaluate_hessians_slow	(	const unsigned int	n_components,
		const Number *	values_dofs,
		FEEvaluationData< dim, Number, false > &	fe_eval
	)

Internal function to evaluate the Hessians of finite element functions in the non-collocation setting as a fall-back. The evaluation strategy uses sum factorization with run-time loop bounds and is thus slower than the collocation case, but it is not as widely used and thus uncritical.

Definition at line 1580 of file evaluation_kernels.h.

integrate_hessians_slow()

template<int dim, typename Number >

void internal::integrate_hessians_slow	(	const unsigned int	n_components,
		const FEEvaluationData< dim, Number, false > &	fe_eval,
		Number *	values_dofs,
		const bool	add_into_values_array
	)

Internal function to multiply by the Hessians of the test functions and integrate in the non-collocation setting as a fall-back. The evaluation strategy uses sum factorization with run-time loop bounds and is thus slower than the collocation case, but it is not as widely used and thus uncritical.

Definition at line 1674 of file evaluation_kernels.h.

do_vectorized_read() [1/2]

template<typename VectorizedArrayType , typename Number2 >

void internal::do_vectorized_read	(	const Number2 *	src_ptr,
		VectorizedArrayType &	dst
	)

Definition at line 1212 of file evaluation_kernels_face.h.

do_vectorized_read() [2/2]

template<typename Number , std::size_t width>

void internal::do_vectorized_read	(	const Number *	src_ptr,
		VectorizedArray< Number, width > &	dst
	)

Definition at line 1224 of file evaluation_kernels_face.h.

do_vectorized_gather() [1/2]

template<typename VectorizedArrayType , typename Number2 >

void internal::do_vectorized_gather	(	const Number2 *	src_ptr,
		const unsigned int *	indices,
		VectorizedArrayType &	dst
	)

Definition at line 1234 of file evaluation_kernels_face.h.

do_vectorized_gather() [2/2]

template<typename Number , std::size_t width>

void internal::do_vectorized_gather	(	const Number *	src_ptr,
		const unsigned int *	indices,
		VectorizedArray< Number, width > &	dst
	)

Definition at line 1248 of file evaluation_kernels_face.h.

do_vectorized_add() [1/2]

template<typename VectorizedArrayType , typename Number2 >

void internal::do_vectorized_add	(	const VectorizedArrayType	src,
		Number2 *	dst_ptr
	)

Definition at line 1260 of file evaluation_kernels_face.h.

do_vectorized_add() [2/2]

template<typename Number , std::size_t width>

void internal::do_vectorized_add	(	const VectorizedArray< Number, width >	src,
		Number *	dst_ptr
	)

Definition at line 1272 of file evaluation_kernels_face.h.

do_vectorized_scatter_add() [1/2]

template<typename VectorizedArrayType , typename Number2 >

void internal::do_vectorized_scatter_add	(	const VectorizedArrayType	src,
		const unsigned int *	indices,
		Number2 *	dst_ptr
	)

Definition at line 1284 of file evaluation_kernels_face.h.

do_vectorized_scatter_add() [2/2]

template<typename Number , std::size_t width>

void internal::do_vectorized_scatter_add	(	const VectorizedArray< Number, width >	src,
		const unsigned int *	indices,
		Number *	dst_ptr
	)

Definition at line 1298 of file evaluation_kernels_face.h.

adjust_for_face_orientation()

template<typename Number >

void internal::adjust_for_face_orientation	(	const unsigned int	dim,
		const unsigned int	n_components,
		const EvaluationFlags::EvaluationFlags	flag,
		const unsigned int *	orientation,
		const bool	integrate,
		const std::size_t	n_q_points,
		Number *	tmp_values,
		Number *	values_quad,
		Number *	gradients_quad,
		Number *	hessians_quad
	)

Definition at line 1316 of file evaluation_kernels_face.h.

adjust_for_face_orientation_per_lane()

template<typename Number , typename VectorizedArrayType >

void internal::adjust_for_face_orientation_per_lane	(	const unsigned int	dim,
		const unsigned int	n_components,
		const unsigned int	v,
		const EvaluationFlags::EvaluationFlags	flag,
		const unsigned int *	orientation,
		const bool	integrate,
		const std::size_t	n_q_points,
		Number *	tmp_values,
		VectorizedArrayType *	values_quad,
		VectorizedArrayType *	gradients_quad = nullptr,
		VectorizedArrayType *	hessians_quad = nullptr
	)

Definition at line 1379 of file evaluation_kernels_face.h.

fe_face_evaluation_process_and_io()

template<int n_face_orientations, typename Processor , typename EvaluationData , const bool check_face_orientations = false>

void internal::fe_face_evaluation_process_and_io	(	Processor &	proc,
		const unsigned int	n_components,
		const EvaluationFlags::EvaluationFlags	evaluation_flag,
		typename Processor::Number2_ *	global_vector_ptr,
		const std::vector< ArrayView< const typename Processor::Number2_ > > *	sm_ptr,
		const EvaluationData &	fe_eval,
		typename Processor::VectorizedArrayType_ *	temp1
	)

Definition at line 2456 of file evaluation_kernels_face.h.

instantiation_helper_run()

template<int degree, typename EvaluatorType , typename... Args>

bool internal::instantiation_helper_run	(	const unsigned int	given_degree,
		const unsigned int	n_q_points_1d,
		Args &...	args
	)

Definition at line 47 of file evaluation_template_factory_internal.h.

instantiation_helper_degree_run()

template<int degree, typename EvaluatorType , typename... Args>

bool internal::instantiation_helper_degree_run	(	const unsigned int	given_degree,
		Args &...	args
	)

Definition at line 79 of file evaluation_template_factory_internal.h.

apply_matrix_vector_product() [1/6]

template<EvaluatorVariant variant, EvaluatorQuantity quantity, int n_rows, int n_columns, int stride_in, int stride_out, bool transpose_matrix, bool add, typename Number , typename Number2 >

std::enable_if_t<(variant==evaluate_general), void > internal::apply_matrix_vector_product	(	const Number2 *	matrix,
		const Number *	in,
		Number *	out
	)

One-dimensional kernel for use by the generic tensor product interpolation as provided by the class EvaluatorTensorProduct, implementing a matrix-vector product along this dimension, controlled by the number of rows and columns and the stride in the input and output arrays, which are embedded into some lexicographic ordering of unknowns in a tensor-product arrangement.

Besides this generic function for templated loop lengths, there are several specializations of this class to account for run-time matrix sizes as well as some symmetries that reduce the data access or arithmetic operations. The specializations are technically realized by conditional function overloading with std::enable_if_t based on the first template parameter.

Definition at line 118 of file tensor_product_kernels.h.

apply_matrix_vector_product() [2/6]

template<EvaluatorVariant variant, EvaluatorQuantity quantity, bool transpose_matrix, bool add, bool consider_strides, typename Number , typename Number2 , int n_components = 1>

std::enable_if_t<(variant==evaluate_general), void > internal::apply_matrix_vector_product	(	const Number2 *	matrix,
		const Number *	in,
		Number *	out,
		const int	n_rows,
		const int	n_columns,
		const int	stride_in_given,
		const int	stride_out_given
	)

Specialization of the matrix-vector kernel for run-time loop bounds in the generic evaluator.

Definition at line 201 of file tensor_product_kernels.h.

apply_matrix_vector_product() [3/6]

template<EvaluatorVariant variant, EvaluatorQuantity quantity, int n_rows, int n_columns, int stride_in, int stride_out, bool transpose_matrix, bool add, typename Number , typename Number2 >

std::enable_if_t<(variant==evaluate_symmetric), void > internal::apply_matrix_vector_product	(	const Number2 *	matrix,
		const Number *	in,
		Number *	out
	)

Internal evaluator specialized for "symmetric" finite elements, i.e., when the shape functions and quadrature points are symmetric about the middle point, making the matrix entries the same when starting to read in the (1,1) entry forward compared to the (N,N) entry backward.

Definition at line 760 of file tensor_product_kernels.h.

apply_matrix_vector_product() [4/6]

template<EvaluatorVariant variant, EvaluatorQuantity quantity, int n_rows_static, int n_columns_static, int stride_in_static, int stride_out_static, bool transpose_matrix, bool add, typename Number , typename Number2 >

std::enable_if_t<(variant==evaluate_evenodd), void > internal::apply_matrix_vector_product	(	const Number2 *DEAL_II_RESTRICT	matrix,
		const Number *	in,
		Number *	out,
		int	n_rows_runtime = 0,
		int	n_columns_runtime = 0,
		int	stride_in_runtime = 0,
		int	stride_out_runtime = 0
	)

Internal evaluator specialized for "symmetric" finite elements in the evenodd matrix format.

This function implements a different approach to the symmetric case for values, gradients, and Hessians as in the above matrices: It is possible to reduce the cost per dimension from N^2 to N^2/2, where N is the number of 1d dofs (there are only N^2/2 different entries in the shape matrix, so this is plausible). The approach is based on the idea of applying the operator on the even and odd part of the input vectors separately, given that the basis of shape functions evaluated at quadrature points is symmetric. This method is presented e.g. in the book "Implementing Spectral Methods for Partial Differential Equations" by David A. Kopriva, Springer, 2009, section 3.5.3 (Even-Odd-Decomposition). Even though the experiments in the book say that the method is not efficient for N<20, it is more efficient in the context where the loop bounds are compile-time constants (templates).

Definition at line 1163 of file tensor_product_kernels.h.

apply_matrix_vector_product() [5/6]

template<EvaluatorVariant variant, EvaluatorQuantity quantity, bool transpose_matrix, bool add, bool consider_strides, typename Number , typename Number2 >

std::enable_if_t<(variant==evaluate_evenodd), void > internal::apply_matrix_vector_product	(	const Number2 *	matrix,
		const Number *	in,
		Number *	out,
		int	n_rows,
		int	n_columns,
		int	stride_in,
		int	stride_out
	)

Internal evaluator specialized for "symmetric" finite elements in the evenodd matrix format with run-time bounds.

Definition at line 1350 of file tensor_product_kernels.h.

apply_matrix_vector_product() [6/6]

template<EvaluatorVariant variant, EvaluatorQuantity quantity, int n_rows, int n_columns, int stride_in, int stride_out, bool transpose_matrix, bool add, typename Number , typename Number2 >

std::enable_if_t<(variant==evaluate_symmetric_hierarchical), void > internal::apply_matrix_vector_product	(	const Number2 *	matrix,
		const Number *	in,
		Number *	out
	)

Internal evaluator specialized for "symmetric" finite elements in the symmetric_hierarchical matrix format.

This class implements an approach similar to the even-odd decomposition but with a different type of symmetry. In this case, we assume that a single shape function already shows the symmetry over the quadrature points, rather than the complete basis that is considered in the even-odd case. In particular, we assume that the shape functions are ordered as in the Legendre basis, with symmetric shape functions in the even slots (rows of the values array) and point-symmetric in the odd slots. Like the even-odd decomposition, the number of operations are N^2/2 rather than N^2 FMAs (fused multiply-add), where N is the number of 1d dofs. The difference is in the way the input and output quantities are symmetrized.

Definition at line 1397 of file tensor_product_kernels.h.

interpolate_to_face() [1/2]

template<int n_rows_template, int stride_template, bool contract_onto_face, bool add, int max_derivative, typename Number , typename Number2 >

std::enable_if_t< contract_onto_face, void > internal::interpolate_to_face ( const Number2 *  shape_values, const std::array< int, 2 > &  n_blocks, const std::array< int, 2 > &  steps, const Number *  input, Number *DEAL_II_RESTRICT  output, const int  n_rows_runtime = 0, const int  stride_runtime = 1  )

inline

This function applies the tensor product operation to produce face values from cell values. The algorithm involved here can be interpreted as the first sweep in sum factorization, reducing the dimensionality of the data set from dim-dimensional cell values to (dim-1)-dimensional face values. This step is always done before we evaluate within the face, as it reduces the length of the loops for the successive steps.

Template Parameters

n_rows_template	The number of entries within the interpolation, typically equal to the polynomial degree plus one, if known at compile time, otherwise n_rows_runtime is used.
stride_template	The stride between successive entries in the one-dimensional operation of sum factorization, if known at compile time, otherwise stride_runtime is used.
contract_onto_face	If true, the input vector is of size n_rows^dim and interpolation into n_rows^(dim-1) points is performed. This is a typical scenario in FEFaceEvaluation::evaluate() calls. If false, data from n_rows^(dim-1) points is expanded into the n_rows^dim points of the higher-dimensional data array. Derivatives in the case contract_onto_face==false are summed together.
add	If true, the result is added to the output vector, else the computed values overwrite the content in the output.
max_derivative	Sets the number of derivatives that should be computed. 0 means only values, 1 means values and first derivatives, 2 up to second derivates. Note that all the derivatives access the data in shape_values passed to the constructor of the class.

Parameters

shape_values	Address of the interpolation matrix.
n_blocks	Number of interpolation layers used along the up to two dimensions tangential to the interpolation direction.
steps	Increments in the input array from one step to the next, varied in conjunction with the stride_template variable: We increment by stride_template along the 1d interpolation, and then increment by steps when passing from one line to the next.
input	Address of the input data vector.
output	Address of the output data vector.
n_rows_runtime	Alternative number of rows to be used if the variable n_rows_template is 0, enabling a run-time path.
stride_runtime	Alternative number for the stride to be used if the variable n_rows_template is 0.

Definition at line 2365 of file tensor_product_kernels.h.

use_collocation_evaluation()

constexpr bool internal::use_collocation_evaluation ( const unsigned int  fe_degree, const unsigned int  n_q_points_1d  )

constexpr

Helper function to specify whether a transformation to collocation should be used: It should give correct results (first condition), we need to be able to initialize the fields in shape_info.templates.h from the polynomials (second condition), and it should be the most efficient choice in terms of operation counts (third condition).

Definition at line 2433 of file tensor_product_kernels.h.

interpolate_to_face() [2/2]

template<int n_rows_template, int stride_template, bool contract_onto_face, bool add, int max_derivative, typename Number , typename Number2 >

std::enable_if_t<!contract_onto_face, void > internal::interpolate_to_face ( const Number2 *  shape_values, const std::array< int, 2 > &  n_blocks, const std::array< int, 2 > &  steps, const Number *  input, Number *DEAL_II_RESTRICT  output, const int  n_rows_runtime = 0, const int  stride_runtime = 1  )

inline

This function performs the opposite operation to the interpolate_to_face function, done as the last step in sum factorization to embed face values and gradients back to values on all degrees of freedom of the cell.

Definition at line 2455 of file tensor_product_kernels.h.

weight_fe_q_dofs_by_entity()

template<int dim, int n_points_1d_template, typename Number >

void internal::weight_fe_q_dofs_by_entity ( const Number *  weights, const unsigned int  n_components, const int  n_points_1d_non_template, Number *  data  )

inline

Definition at line 2503 of file tensor_product_kernels.h.

weight_fe_q_dofs_by_entity_shifted()

template<int dim, int n_points_1d_template, typename Number >

void internal::weight_fe_q_dofs_by_entity_shifted ( const Number *  weights, const unsigned int  n_components, const int  n_points_1d_non_template, Number *  data  )

inline

Definition at line 2541 of file tensor_product_kernels.h.

compute_weights_fe_q_dofs_by_entity()

template<int dim, int n_points_1d_template, typename Number >

bool internal::compute_weights_fe_q_dofs_by_entity ( const Number *  data, const unsigned int  n_components, const int  n_points_1d_non_template, Number *  weights  )

inline

Definition at line 2588 of file tensor_product_kernels.h.

compute_weights_fe_q_dofs_by_entity_shifted()

template<int dim, int n_points_1d_template, typename Number >

bool internal::compute_weights_fe_q_dofs_by_entity_shifted ( const Number *  data, const unsigned int  n_components, const int  n_points_1d_non_template, Number *  weights  )

inline

Definition at line 2649 of file tensor_product_kernels.h.

compute_values_of_array() [1/2]

template<int dim, typename Number >

void internal::compute_values_of_array ( ::ndarray< Number, 2, dim > *  shapes, const std::vector< Polynomials::Polynomial< double > > &  poly, const Point< dim, Number > &  p, const unsigned int  derivative = 1  )

inline

Compute the values and derivatives of the 1d polynomials poly at the specified point p and store them in shapes.

Definition at line 60 of file tensor_product_point_kernels.h.

compute_values_of_array() [2/2]

template<typename Number >

void internal::compute_values_of_array ( ::ndarray< Number, 2, 0 > *  , const std::vector< Polynomials::Polynomial< double > > &  , const Point< 0, Number > &  , const unsigned int    )

inline

Specialization of above function for dim = 0. Should not be called.

Definition at line 83 of file tensor_product_point_kernels.h.

compute_values_of_array_in_pairs()

template<int dim, typename Number >

void internal::compute_values_of_array_in_pairs ( ::ndarray< Number, 2, dim > *  shapes, const std::vector< Polynomials::Polynomial< double > > &  poly, const Point< dim, Number > &  p0, const Point< dim, Number > &  p1  )

inline

Evaluate the 1d polynomials poly at the two specified points p0 and p1 and store them in shapes. This function can be used as a more efficient alternative to the compute_values_of_array() function, because of reduced overhead when querying the polynomials (which usually have loop bounds that are not known at compile time).

Definition at line 102 of file tensor_product_point_kernels.h.

do_interpolate_xy()

template<int dim, int length, typename Number2 , typename Number , int n_values = 1, bool do_renumber = true, int stride = 1>

std::array< typename ProductTypeNoPoint< Number, Number2 >::type, 2+n_values > internal::do_interpolate_xy ( const Number *  values, const std::vector< unsigned int > &  renumber, const ::ndarray< Number2, 2, dim > *  shapes, const int  n_shapes_runtime, int &  i  )

inline

Interpolate inner dimensions of tensor product shape functions.

Definition at line 146 of file tensor_product_point_kernels.h.

evaluate_tensor_product_value_and_gradient_shapes()

template<int dim, typename Number , typename Number2 , int n_values = 1, bool do_renumber = true, int stride = 1>

std::array< typename ProductTypeNoPoint< Number, Number2 >::type, dim+n_values > internal::evaluate_tensor_product_value_and_gradient_shapes ( const ::ndarray< Number2, 2, dim > *  shapes, const int  n_shapes, const Number *  values, const std::vector< unsigned int > &  renumber = {}  )

inline

Interpolates the values and gradients into the points specified in compute_values_of_array() with help of the precomputed shapes.

Definition at line 238 of file tensor_product_point_kernels.h.

evaluate_tensor_product_value_and_gradient_linear()

template<int dim, typename Number , typename Number2 , int n_values = 1, int stride = 1>

std::array< typename ProductTypeNoPoint< Number, Number2 >::type, dim+n_values > internal::evaluate_tensor_product_value_and_gradient_linear ( const Number *  values, const Point< dim, Number2 > &  p  )

inline

Specializes evaluate_tensor_product_value_and_gradient() for linear polynomials which massively reduces the necessary instructions.

Definition at line 372 of file tensor_product_point_kernels.h.

evaluate_tensor_product_value_and_gradient()

template<int dim, typename Number , typename Number2 >

std::pair< typename ProductTypeNoPoint< Number, Number2 >::type, Tensor< 1, dim, typename ProductTypeNoPoint< Number, Number2 >::type > > internal::evaluate_tensor_product_value_and_gradient ( const std::vector< Polynomials::Polynomial< double > > &  poly, const ArrayView< const Number > &  values, const Point< dim, Number2 > &  p, const bool  d_linear = false, const std::vector< unsigned int > &  renumber = {}  )

inline

Compute the polynomial interpolation of a tensor product shape function \(\varphi_i\) given a vector of coefficients \(u_i\) in the form \(u_h(\mathbf{x}) = \sum_{i=1}^{k^d} \varphi_i(\mathbf{x}) u_i\). The shape functions \(\varphi_i(\mathbf{x}) = \prod_{d=1}^{\text{dim}}\varphi_{i_d}^\text{1d}(x_d)\) represent a tensor product. The function returns a pair with the value of the interpolation as the first component and the gradient in reference coordinates as the second component. Note that for compound types (e.g. the values field begin a Point<spacedim> argument), the components of the gradient are sorted as Tensor<1, dim, Tensor<1, spacedim>> with the derivatives as the first index; this is a consequence of the generic arguments in the function.

Parameters

poly	The underlying one-dimensional polynomial basis \(\{\varphi^{1d}_{i_1}\}\) given as a vector of polynomials.
values	The expansion coefficients \(u_i\) of type Number in the polynomial interpolation. The coefficients can be simply double variables but e.g. also Point<spacedim> in case they define arithmetic operations with the type Number2.
p	The position in reference coordinates where the interpolation should be evaluated.
d_linear	Flag to specify whether a d-linear (linear in 1d, bi-linear in 2d, tri-linear in 3d) interpolation should be made, which allows to unroll loops and considerably speed up evaluation.
renumber	Optional parameter to specify a renumbering in the coefficient vector, assuming that values[renumber[i]] returns the lexicographic (tensor product) entry of the coefficients. If the vector is entry, the values are assumed to be sorted lexicographically.

Definition at line 499 of file tensor_product_point_kernels.h.

do_interpolate_xy_value()

template<int dim, int length, typename Number2 , typename Number , bool do_renumber = true, int stride = 1>

ProductTypeNoPoint< Number, Number2 >::type internal::do_interpolate_xy_value ( const Number *  values, const std::vector< unsigned int > &  renumber, const ::ndarray< Number2, 2, dim > *  shapes, const int  n_shapes_runtime, int &  i  )

inline

Definition at line 542 of file tensor_product_point_kernels.h.

evaluate_tensor_product_value_shapes()

template<int dim, typename Number , typename Number2 , bool do_renumber = true, int stride = 1>

ProductTypeNoPoint< Number, Number2 >::type internal::evaluate_tensor_product_value_shapes ( const ::ndarray< Number2, 2, dim > *  shapes, const int  n_shapes, const Number *  values, const std::vector< unsigned int > &  renumber = {}  )

inline

Definition at line 581 of file tensor_product_point_kernels.h.

evaluate_tensor_product_value_linear()

template<int dim, typename Number , typename Number2 , int stride = 1>

ProductTypeNoPoint< Number, Number2 >::type internal::evaluate_tensor_product_value_linear ( const Number *  values, const Point< dim, Number2 > &  p  )

inline

Definition at line 671 of file tensor_product_point_kernels.h.

evaluate_tensor_product_value()

template<int dim, typename Number , typename Number2 >

ProductTypeNoPoint< Number, Number2 >::type internal::evaluate_tensor_product_value ( const std::vector< Polynomials::Polynomial< double > > &  poly, const ArrayView< const Number > &  values, const Point< dim, Number2 > &  p, const bool  d_linear = false, const std::vector< unsigned int > &  renumber = {}  )

inline

Definition at line 720 of file tensor_product_point_kernels.h.

evaluate_tensor_product_higher_derivatives() [1/3]

template<int derivative_order, typename Number , typename Number2 >

Tensor< 1, 1, typename ProductTypeNoPoint< Number, Number2 >::type > internal::evaluate_tensor_product_higher_derivatives ( const std::vector< Polynomials::Polynomial< double > > &  poly, const ArrayView< const Number > &  values, const Point< 1, Number2 > &  p, const std::vector< unsigned int > &  renumber = {}  )

inline

This function computes derivatives of arbitrary orders in 1d, returning a Tensor with the respective derivative

Definition at line 756 of file tensor_product_point_kernels.h.

evaluate_tensor_product_higher_derivatives() [2/3]

template<int derivative_order, typename Number , typename Number2 >

Tensor< 1, derivative_order+1, typename ProductTypeNoPoint< Number, Number2 >::type > internal::evaluate_tensor_product_higher_derivatives ( const std::vector< Polynomials::Polynomial< double > > &  poly, const ArrayView< const Number > &  values, const Point< 2, Number2 > &  p, const std::vector< unsigned int > &  renumber = {}  )

inline

This function computes derivatives of arbitrary orders in 2d, returning a Tensor with the respective derivatives

Definition at line 796 of file tensor_product_point_kernels.h.

evaluate_tensor_product_higher_derivatives() [3/3]

template<int derivative_order, typename Number , typename Number2 >

Tensor< 1,((derivative_order+1) *(derivative_order+2))/2, typename ProductTypeNoPoint< Number, Number2 >::type > internal::evaluate_tensor_product_higher_derivatives ( const std::vector< Polynomials::Polynomial< double > > &  poly, const ArrayView< const Number > &  values, const Point< 3, Number2 > &  p, const std::vector< unsigned int > &  renumber = {}  )

inline

This function computes derivatives of arbitrary orders in 3d, returning a Tensor with the respective derivatives

Definition at line 848 of file tensor_product_point_kernels.h.

evaluate_tensor_product_hessian()

template<int dim, typename Number , typename Number2 >

SymmetricTensor< 2, dim, typename ProductTypeNoPoint< Number, Number2 >::type > internal::evaluate_tensor_product_hessian	(	const std::vector< Polynomials::Polynomial< double > > &	poly,
		const ArrayView< const Number > &	values,
		const Point< dim, Number2 > &	p,
		const std::vector< unsigned int > &	renumber = {}
	)

Definition at line 912 of file tensor_product_point_kernels.h.

do_apply_test_functions_xy()

template<int dim, int length, typename Number2 , typename Number , bool add, int n_values = 1>

void internal::do_apply_test_functions_xy ( Number2 *  values, const ::ndarray< Number, 2, dim > *  shapes, const std::array< Number2, 2+n_values > &  test_grads_value, const int  n_shapes_runtime, int &  i  )

inline

Test inner dimensions of tensor product shape functions and accumulate.

Definition at line 961 of file tensor_product_point_kernels.h.

integrate_add_tensor_product_value_and_gradient_shapes()

template<int dim, typename Number , typename Number2 , bool add, int n_values = 1>

void internal::integrate_add_tensor_product_value_and_gradient_shapes ( const ::ndarray< Number, 2, dim > *  shapes, const int  n_shapes, const Number2 *  value, const Tensor< 1, dim, Number2 > &  gradient, Number2 *  values  )

inline

Same as evaluate_tensor_product_value_and_gradient_shapes() but for integration.

Definition at line 1074 of file tensor_product_point_kernels.h.

integrate_add_tensor_product_value_and_gradient_linear()

template<int dim, typename Number , typename Number2 , bool add, int n_values = 1>

void internal::integrate_add_tensor_product_value_and_gradient_linear ( const Number2 *  value, const Tensor< 1, dim, Number2 > &  gradient, Number2 *  values, const Point< dim, Number > &  p  )

inline

Specializes integrate_add_tensor_product_value_and_gradient_shapes() for linear polynomials which massively reduces the necessary instructions.

Definition at line 1158 of file tensor_product_point_kernels.h.

integrate_tensor_product_value_and_gradient()

template<bool is_linear, int dim, typename Number , typename Number2 , int n_values = 1>

void internal::integrate_tensor_product_value_and_gradient ( const ::ndarray< Number, 2, dim > *  shapes, const unsigned int  n_shapes, const Number2 *  value, const Tensor< 1, dim, Number2 > &  gradient, Number2 *  values, const Point< dim, Number > &  p, const bool  do_add  )

inline

Calls the correct integrate_add_tensor_product_value_and_gradient_...() function depending on if values should be added to or set and if polynomials are linear.

Definition at line 1322 of file tensor_product_point_kernels.h.

do_apply_test_functions_xy_value()

template<int dim, int length, typename Number2 , typename Number , bool add>

void internal::do_apply_test_functions_xy_value ( Number2 *  values, const ::ndarray< Number, 2, dim > *  shapes, const Number2 &  test_value, const int  n_shapes_runtime, int &  i  )

inline

Test inner dimensions of tensor product shape functions and accumulate.

Definition at line 1378 of file tensor_product_point_kernels.h.

integrate_add_tensor_product_value_shapes()

template<int dim, typename Number , typename Number2 , bool add>

void internal::integrate_add_tensor_product_value_shapes ( const ::ndarray< Number, 2, dim > *  shapes, const int  n_shapes, const Number2 &  value, Number2 *  values  )

inline

Same as evaluate_tensor_product_value_shapes() but for integration.

Definition at line 1434 of file tensor_product_point_kernels.h.

integrate_add_tensor_product_value_linear()

template<int dim, typename Number , typename Number2 , bool add>

void internal::integrate_add_tensor_product_value_linear ( const Number2 &  value, Number2 *  values, const Point< dim, Number > &  p  )

inline

Specializes integrate_tensor_product_value_shapes() for linear polynomials which massively reduces the necessary instructions.

Definition at line 1491 of file tensor_product_point_kernels.h.

integrate_tensor_product_value()

template<bool is_linear, int dim, typename Number , typename Number2 >

void internal::integrate_tensor_product_value ( const ::ndarray< Number, 2, dim > *  shapes, const unsigned int  n_shapes, const Number2 &  value, Number2 *  values, const Point< dim, Number > &  p, const bool  do_add  )

inline

Calls the correct integrate_add_tensor_product_value_...() function depending on if values should be added to or set and if polynomials are linear.

Definition at line 1588 of file tensor_product_point_kernels.h.

vector_access() [1/2]

template<typename VectorType , std::enable_if_t< is_serial_vector_or_array< VectorType >::value, VectorType > * = nullptr>

VectorType::value_type internal::vector_access ( const VectorType &  vec, const unsigned int  entry  )

inline

Definition at line 45 of file vector_access_internal.h.

vector_access() [2/2]

template<typename VectorType , std::enable_if_t< is_serial_vector_or_array< VectorType >::value, VectorType > * = nullptr>

VectorType::value_type & internal::vector_access ( VectorType &  vec, const unsigned int  entry  )

inline

Definition at line 57 of file vector_access_internal.h.

vector_access_add()

template<typename VectorType , std::enable_if_t< has_add_local_element< VectorType >, VectorType > * = nullptr>

void internal::vector_access_add ( VectorType &  vec, const unsigned int  entry, const typename VectorType::value_type &  val  )

inline

Definition at line 94 of file vector_access_internal.h.

vector_access_add_global()

template<typename VectorType , std::enable_if_t< has_add_local_element< VectorType >, VectorType > * = nullptr>

void internal::vector_access_add_global ( VectorType &  vec, const types::global_dof_index  entry, const typename VectorType::value_type &  val  )

inline

Definition at line 120 of file vector_access_internal.h.

vector_access_set()

template<typename VectorType , std::enable_if_t< has_set_local_element< VectorType >, VectorType > * = nullptr>

void internal::vector_access_set ( VectorType &  vec, const unsigned int  entry, const typename VectorType::value_type &  val  )

inline

Definition at line 146 of file vector_access_internal.h.

check_vector_compatibility()

template<int dim, typename Number , typename VectorizedArrayType , typename VectorType , std::enable_if_t<!has_partitioners_are_compatible< VectorType >, VectorType > * = nullptr>

void internal::check_vector_compatibility ( const VectorType &  vec, const MatrixFree< dim, Number, VectorizedArrayType > &  matrix_free, const internal::MatrixFreeFunctions::DoFInfo &  dof_info  )

inline

Definition at line 179 of file vector_access_internal.h.

is_active_iterator() [1/3]

template<class DI >

bool internal::is_active_iterator ( const DI &  )

inline

Find out if an iterator supports inactive cells.

Definition at line 48 of file loop.h.

is_active_iterator() [2/3]

template<typename AccessorType >

bool internal::is_active_iterator ( const TriaActiveIterator< AccessorType > &  )

inline

Definition at line 55 of file loop.h.

is_active_iterator() [3/3]

template<typename AccessorType >

bool internal::is_active_iterator ( const ::FilteredIterator< TriaActiveIterator< AccessorType > > &  )

inline

Definition at line 62 of file loop.h.

assemble()

template<int dim, class DOFINFO , class A >

void internal::assemble	(	const MeshWorker::DoFInfoBox< dim, DOFINFO > &	dinfo,
		A *	assembler
	)

Definition at line 70 of file loop.h.

get_degree()

template<int dim>

unsigned int internal::get_degree

(

const std::vector< typename BarycentricPolynomials< dim >::PolyType > &

polys

)

Get the highest degree of the barycentric polynomial (in Cartesian coordinates).

Definition at line 29 of file polynomials_barycentric.cc.

get_abs() [1/2]

template<typename Number >

std::enable_if_t<!std::is_unsigned_v< Number >, typename numbers::NumberTraits< Number >::real_type > internal::get_abs

(

const Number

a

)

In the set_dof_values(), we need to invoke abs() also on unsigned data types, which is ill-formed on newer C++ standards. To avoid this, we use std::abs on default types, but simply return the number on unsigned types.

Definition at line 61 of file dof_accessor_set.cc.

get_abs() [2/2]

template<typename Number >

std::enable_if_t< std::is_unsigned_v< Number >, Number > internal::get_abs

(

const Number

a

)

Definition at line 68 of file dof_accessor_set.cc.

set_ghost_state()

template<typename VectorType , std::enable_if_t< has_set_ghost_state< VectorType >, VectorType > * = nullptr>

void internal::set_ghost_state	(	VectorType &	vector,
		const bool	ghosted
	)

Definition at line 105 of file dof_accessor_set.cc.

set_dof_values()

template<int dim, int spacedim, bool lda, class OutputVector , typename number >

void internal::set_dof_values	(	const DoFCellAccessor< dim, spacedim, lda > &	cell,
		const Vector< number > &	local_values,
		OutputVector &	values,
		const bool	perform_check
	)

Helper function that sets the values on a cell, but also checks if the new values are similar to the old values.

Definition at line 130 of file dof_accessor_set.cc.

process_by_interpolation()

template<int dim, int spacedim, bool lda, class OutputVector , typename number >

void internal::process_by_interpolation	(	const DoFCellAccessor< dim, spacedim, lda > &	cell,
		const Vector< number > &	local_values,
		OutputVector &	values,
		const types::fe_index	fe_index_,
		const std::function< void(const DoFCellAccessor< dim, spacedim, lda > &cell, const Vector< number > &local_values, OutputVector &values)> &	processor
	)

Definition at line 174 of file dof_accessor_set.cc.

policy_to_string()

template<int dim, int spacedim>

std::string internal::policy_to_string

(

const ::internal::DoFHandlerImplementation::Policy::PolicyBase< dim, spacedim > &

policy

)

Definition at line 54 of file dof_handler.cc.

number_unique_entries()

unsigned int internal::number_unique_entries

(

const std::vector< unsigned int > &

vector

)

Definition at line 98 of file fe_data.cc.

get_regularity_from_degree()

unsigned int internal::get_regularity_from_degree ( const unsigned int  fe_degree )

inline

Definition at line 65 of file fe_hermite.cc.

get_hermite_dpo_vector()

std::vector< unsigned int > internal::get_hermite_dpo_vector ( const unsigned int  dim, const unsigned int  regularity  )

inline

Definition at line 75 of file fe_hermite.cc.

hermite_hierarchic_to_lexicographic_numbering() [1/2]

template<int dim>

void internal::hermite_hierarchic_to_lexicographic_numbering	(	const unsigned int	regularity,
		std::vector< unsigned int > &	h2l
	)

hermite_hierarchic_to_lexicographic_numbering< 1 >()

template<>

void internal::hermite_hierarchic_to_lexicographic_numbering< 1 >	(	const unsigned int	regularity,
		std::vector< unsigned int > &	h2l
	)

Definition at line 98 of file fe_hermite.cc.

hermite_hierarchic_to_lexicographic_numbering< 2 >()

template<>

void internal::hermite_hierarchic_to_lexicographic_numbering< 2 >	(	const unsigned int	regularity,
		std::vector< unsigned int > &	h2l
	)

Definition at line 116 of file fe_hermite.cc.

hermite_hierarchic_to_lexicographic_numbering< 3 >()

template<>

void internal::hermite_hierarchic_to_lexicographic_numbering< 3 >	(	const unsigned int	regularity,
		std::vector< unsigned int > &	h2l
	)

Definition at line 143 of file fe_hermite.cc.

hermite_hierarchic_to_lexicographic_numbering() [2/2]

template<int dim>

std::vector< unsigned int > internal::hermite_hierarchic_to_lexicographic_numbering ( const unsigned int  regularity )

inline

Definition at line 178 of file fe_hermite.cc.

hermite_lexicographic_to_hierarchic_numbering()

template<int dim>

std::vector< unsigned int > internal::hermite_lexicographic_to_hierarchic_numbering

(

const unsigned int

regularity

)

Definition at line 194 of file fe_hermite.cc.

hermite_face_lexicographic_to_hierarchic_numbering()

template<int dim>

std::vector< unsigned int > internal::hermite_face_lexicographic_to_hierarchic_numbering ( const unsigned int  regularity )

inline

Definition at line 204 of file fe_hermite.cc.

get_hermite_polynomials()

template<int dim>

TensorProductPolynomials< dim > internal::get_hermite_polynomials

(

const unsigned int

fe_degree

)

Definition at line 218 of file fe_hermite.cc.

setup_primitive_offset_table()

template<int dim, int spacedim = dim>

Table< 2, unsigned int > internal::setup_primitive_offset_table	(	const FESystem< dim, spacedim > &	fe,
		const unsigned int	base_no
	)

Setup a table of offsets for a primitive FE. Unlike the nonprimitive case, here the number of nonzero components per shape function is always 1 and the number of components in the FE is always the multiplicity.

Definition at line 56 of file fe_system.cc.

setup_nonprimitive_offset_table()

template<int dim, int spacedim = dim>

std::vector< typename FESystem< dim, spacedim >::BaseOffsets > internal::setup_nonprimitive_offset_table	(	const FESystem< dim, spacedim > &	fe,
		const unsigned int	base_no
	)

Setup a table of offsets for a nonprimitive FE.

Definition at line 93 of file fe_system.cc.

copy_primitive_base_element_values()

template<int dim, int spacedim = dim>

void internal::copy_primitive_base_element_values	(	const FESystem< dim, spacedim > &	fe,
		const unsigned int	base_no,
		const UpdateFlags	base_flags,
		const Table< 2, unsigned int > &	base_to_system_table,
		const FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &	base_data,
		FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &	output_data
	)

Copy data between internal FEValues objects from a primitive FE to the current FE.

Definition at line 134 of file fe_system.cc.

copy_nonprimitive_base_element_values()

template<int dim, int spacedim = dim>

void internal::copy_nonprimitive_base_element_values	(	const FESystem< dim, spacedim > &	fe,
		const unsigned int	base_no,
		const unsigned int	n_q_points,
		const UpdateFlags	base_flags,
		const std::vector< typename FESystem< dim, spacedim >::BaseOffsets > &	offsets,
		const FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &	base_data,
		FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &	output_data
	)

Copy data between internal FEValues objects from a nonprimitive FE to the current FE.

Definition at line 189 of file fe_system.cc.

make_shape_function_to_row_table()

template<int dim, int spacedim>

std::vector< unsigned int > internal::make_shape_function_to_row_table ( const FiniteElement< dim, spacedim > &  fe )

inline

Definition at line 49 of file fe_values.cc.

do_function_values() [1/2]

template<typename Number , typename Number2 >

void internal::do_function_values	(	const ArrayView< Number2 > &	dof_values,
		const ::Table< 2, double > &	shape_values,
		std::vector< Number > &	values
	)

Definition at line 266 of file fe_values_base.cc.

do_function_values() [2/2]

template<int dim, int spacedim, typename VectorType >

void internal::do_function_values	(	const ArrayView< typename VectorType::value_type > &	dof_values,
		const ::Table< 2, double > &	shape_values,
		const FiniteElement< dim, spacedim > &	fe,
		const std::vector< unsigned int > &	shape_function_to_row_table,
		ArrayView< VectorType >	values,
		const bool	quadrature_points_fastest = false,
		const unsigned int	component_multiple = 1
	)

Definition at line 306 of file fe_values_base.cc.

do_function_derivatives() [1/2]

template<int order, int spacedim, typename Number >

void internal::do_function_derivatives	(	const ArrayView< Number > &	dof_values,
		const ::Table< 2, Tensor< order, spacedim > > &	shape_derivatives,
		std::vector< Tensor< order, spacedim, Number > > &	derivatives
	)

Definition at line 417 of file fe_values_base.cc.

do_function_derivatives() [2/2]

template<int order, int dim, int spacedim, typename Number >

void internal::do_function_derivatives	(	const ArrayView< Number > &	dof_values,
		const ::Table< 2, Tensor< order, spacedim > > &	shape_derivatives,
		const FiniteElement< dim, spacedim > &	fe,
		const std::vector< unsigned int > &	shape_function_to_row_table,
		ArrayView< std::vector< Tensor< order, spacedim, Number > > >	derivatives,
		const bool	quadrature_points_fastest = false,
		const unsigned int	component_multiple = 1
	)

Definition at line 457 of file fe_values_base.cc.

do_function_laplacians() [1/2]

template<int spacedim, typename Number , typename Number2 >

void internal::do_function_laplacians	(	const ArrayView< Number2 > &	dof_values,
		const ::Table< 2, Tensor< 2, spacedim > > &	shape_hessians,
		std::vector< Number > &	laplacians
	)

Definition at line 564 of file fe_values_base.cc.

do_function_laplacians() [2/2]

template<int dim, int spacedim, typename VectorType , typename Number >

void internal::do_function_laplacians	(	const ArrayView< Number > &	dof_values,
		const ::Table< 2, Tensor< 2, spacedim > > &	shape_hessians,
		const FiniteElement< dim, spacedim > &	fe,
		const std::vector< unsigned int > &	shape_function_to_row_table,
		std::vector< VectorType > &	laplacians,
		const bool	quadrature_points_fastest = false,
		const unsigned int	component_multiple = 1
	)

Definition at line 601 of file fe_values_base.cc.

apply_exponential_map()

Tensor< 1, 3 > internal::apply_exponential_map	(	const Tensor< 1, 3 > &	u,
		const Tensor< 1, 3 > &	dir
	)

Definition at line 51 of file manifold_lib.cc.

projected_direction()

Tensor< 1, 3 > internal::projected_direction	(	const Tensor< 1, 3 > &	u,
		const Tensor< 1, 3 > &	v
	)

Definition at line 71 of file manifold_lib.cc.

compute_normal() [1/2]

template<int spacedim>

Point< spacedim > internal::compute_normal	(	const Tensor< 1, spacedim > &	,
		bool	= false
	)

Definition at line 82 of file manifold_lib.cc.

compute_normal() [2/2]

Point< 3 > internal::compute_normal	(	const Tensor< 1, 3 > &	vector,
		bool	normalize = false
	)

Definition at line 89 of file manifold_lib.cc.

Variable Documentation

dealii_initialized_kokkos

bool internal::dealii_initialized_kokkos = false

Records if Kokkos has been initialized by deal.II. The value stored is only meaningful after ensure_kokkos_initialized() has been called.

Definition at line 27 of file kokkos.cc.

wedge_table_1

const constexpr ::ndarray<unsigned int, 6, 2> internal::wedge_table_1

staticconstexpr

Initial value:

{
    {{{0, 0}}, {{1, 0}}, {{2, 0}}, {{0, 1}}, {{1, 1}}, {{2, 1}}}}

Decompose the shape-function index of a linear wedge into an index to access the right shape function within the triangle and within the line.

Definition at line 35 of file polynomials_wedge.h.

wedge_table_2

const constexpr ::ndarray<unsigned int, 18, 2> internal::wedge_table_2

staticconstexpr

Initial value:

{
    {{{0, 0}},
     {{1, 0}},
     {{2, 0}},
     {{0, 1}},
     {{1, 1}},
     {{2, 1}},
     {{3, 0}},
     {{4, 0}},
     {{5, 0}},
     {{3, 1}},
     {{4, 1}},
     {{5, 1}},
     {{0, 2}},
     {{1, 2}},
     {{2, 2}},
     {{3, 2}},
     {{4, 2}},
     {{5, 2}}}}

Decompose the shape-function index of a quadratic wedge into an index to access the right shape function within the triangle and within the line.

Definition at line 43 of file polynomials_wedge.h.

is_supported_operation

template<template< class... > class Op, class... Args>

constexpr bool internal::is_supported_operation

constexpr

Initial value:

=
    SupportsOperation::is_detected<Op, Args...>::value

A constexpr variable that describes whether or not Op<Args...> is a valid expression.

The way this is used is to define an Op operation template that describes the operation we want to perform, and Args is a template pack that describes the arguments to the operation. This variable then states whether the operation, with these arguments, leads to a valid C++ expression.

An example is if one wanted to find out whether a type T has a get_mpi_communicator() member function. In that case, one would write the operation as

template <typename T>
using get_mpi_communicator_op
  = decltype(std::declval<T>().get_mpi_communicator());

and could define a variable like

template <typename T>
constexpr bool has_get_mpi_communicator =
is_supported_operation<get_mpi_communicator_op, T>;

The trick used here is that get_mpi_communicator_op is a general template, but when used with a type that does not have a get_mpi_communicator() member variable, the decltype(...) operation will fail because its argument does not represent a valid expression for such a type. In other words, for such types T that do not have such a member function, the general template get_mpi_communicator_op represents a valid declaration, but the instantiation get_mpi_communicator_op<T> is not, and the variable declared here detects and reports this.

Definition at line 158 of file template_constraints.h.

has_block

template<typename T >

constexpr bool internal::has_block = internal::is_supported_operation<has_block_t, T>

constexpr

Definition at line 51 of file block_vector_base.h.

has_n_blocks

template<typename T >

constexpr bool internal::has_n_blocks

constexpr

Initial value:

=
    internal::is_supported_operation<has_n_blocks_t, T>

Definition at line 57 of file block_vector_base.h.

is_block_vector

template<typename T >

constexpr bool internal::is_block_vector = has_block<T> && has_n_blocks<T>

constexpr

Definition at line 61 of file block_vector_base.h.

is_dealii_vector

template<typename VectorType >

constexpr bool internal::is_dealii_vector

constexpr

Initial value:

=
    std::is_same_v<VectorType,
                   ::Vector<typename VectorType::value_type>> ||
    std::is_same_v<VectorType,
                   ::BlockVector<typename VectorType::value_type>> ||
    std::is_same_v<VectorType,
                   ::LinearAlgebra::distributed::Vector<
                     typename VectorType::value_type>> ||
    std::is_same_v<VectorType,
                   ::LinearAlgebra::distributed::BlockVector<
                     typename VectorType::value_type>>

Check if a vector is a deal.II vector.

Definition at line 77 of file dof_accessor_set.cc.

has_set_ghost_state

template<typename T >

constexpr bool internal::has_set_ghost_state

constexpr

Initial value:

=
    is_supported_operation<set_ghost_state_t, T>

Definition at line 98 of file dof_accessor_set.cc.

invalid_pull_back_coordinate

constexpr double internal::invalid_pull_back_coordinate = 20.0

staticconstexpr

Definition at line 45 of file manifold_lib.cc.