Reference documentation for deal.II version GIT 4e92747666 2022-12-02 08:40:02+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
internal Namespace Reference

Namespaces

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

Classes

class  AlignedVectorCopyConstruct
 
class  AlignedVectorMoveConstruct
 
class  AlignedVectorInitialize
 
class  AlignedVectorDefaultInitialize
 
struct  argument_type
 
struct  argument_type< T(U)>
 
struct  SubfacePossibilities
 
struct  SubfacePossibilities< 0 >
 
struct  SubfacePossibilities< 1 >
 
struct  SubfacePossibilities< 2 >
 
struct  SubfacePossibilities< 3 >
 
class  SubfaceCase
 
struct  VectorizedArrayWidthSpecifier
 
struct  VectorizedArrayWidthSpecifier< double >
 
struct  VectorizedArrayWidthSpecifier< float >
 
struct  is_explicitly_convertible
 
struct  NumberType
 
struct  NumberType< std::complex< T > >
 
struct  NumberType< cuComplex >
 
struct  NumberType< cuDoubleComplex >
 
struct  ProductTypeImpl< SymmetricTensor< rank, dim, T >, std::complex< U > >
 
struct  ProductTypeImpl< SymmetricTensor< rank, dim, std::complex< T > >, std::complex< U > >
 
struct  ProductTypeImpl< std::complex< T >, SymmetricTensor< rank, dim, U > >
 
struct  ProductTypeImpl< std::complex< T >, SymmetricTensor< rank, dim, std::complex< U > > >
 
struct  TableEntry
 
struct  ProductTypeImpl
 
struct  ProductTypeImpl< std::complex< T >, std::complex< T > >
 
struct  ProductTypeImpl< std::complex< T >, std::complex< U > >
 
struct  ProductTypeImpl< double, std::complex< U > >
 
struct  ProductTypeImpl< std::complex< T >, double >
 
struct  ProductTypeImpl< float, std::complex< U > >
 
struct  ProductTypeImpl< std::complex< T >, float >
 
struct  VectorizedArrayTrait
 
struct  VectorizedArrayTrait< VectorizedArray< T, width_ > >
 
struct  ProductTypeImpl< adouble, adouble >
 
struct  ProductTypeImpl< adub, adouble >
 
struct  ProductTypeImpl< adouble, adub >
 
struct  ProductTypeImpl< double, adouble >
 
struct  ProductTypeImpl< adouble, double >
 
struct  ProductTypeImpl< double, adub >
 
struct  ProductTypeImpl< adub, double >
 
struct  ProductTypeImpl< float, adouble >
 
struct  ProductTypeImpl< adouble, float >
 
struct  ProductTypeImpl< float, adub >
 
struct  ProductTypeImpl< adub, float >
 
struct  ProductTypeImpl< std::complex< double >, std::complex< adouble > >
 
struct  ProductTypeImpl< std::complex< adouble >, std::complex< double > >
 
struct  ProductTypeImpl< std::complex< adouble >, std::complex< adouble > >
 
struct  ProductTypeImpl< std::complex< adub >, std::complex< adouble > >
 
struct  ProductTypeImpl< std::complex< adouble >, std::complex< adub > >
 
struct  ProductTypeImpl< std::complex< float >, std::complex< adouble > >
 
struct  ProductTypeImpl< std::complex< adouble >, std::complex< float > >
 
struct  ProductTypeImpl< double, adtl::adouble >
 
struct  ProductTypeImpl< adtl::adouble, double >
 
struct  ProductTypeImpl< adtl::adouble, adtl::adouble >
 
struct  ProductTypeImpl< float, adtl::adouble >
 
struct  ProductTypeImpl< adtl::adouble, float >
 
struct  ProductTypeImpl< std::complex< double >, std::complex< adtl::adouble > >
 
struct  ProductTypeImpl< std::complex< adtl::adouble >, std::complex< double > >
 
struct  ProductTypeImpl< std::complex< adtl::adouble >, std::complex< adtl::adouble > >
 
struct  ProductTypeImpl< std::complex< float >, std::complex< adtl::adouble > >
 
struct  ProductTypeImpl< std::complex< adtl::adouble >, std::complex< float > >
 
struct  ProductTypeImpl< Sacado::Fad::DFad< T >, float >
 
struct  ProductTypeImpl< float, Sacado::Fad::DFad< T > >
 
struct  ProductTypeImpl< Sacado::Fad::DFad< T >, double >
 
struct  ProductTypeImpl< double, Sacado::Fad::DFad< T > >
 
struct  ProductTypeImpl< Sacado::Fad::DFad< T >, int >
 
struct  ProductTypeImpl< int, Sacado::Fad::DFad< T > >
 
struct  ProductTypeImpl< Sacado::Fad::DFad< T >, Sacado::Fad::DFad< U > >
 
struct  ProductTypeImpl< Sacado::Fad::Expr< T >, U >
 
struct  ProductTypeImpl< T, Sacado::Fad::Expr< U > >
 
struct  ProductTypeImpl< Sacado::Fad::Expr< T >, Sacado::Fad::Expr< U > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvar< T >, float >
 
struct  ProductTypeImpl< float, Sacado::Rad::ADvar< T > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvar< T >, double >
 
struct  ProductTypeImpl< double, Sacado::Rad::ADvar< T > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvar< T >, int >
 
struct  ProductTypeImpl< int, Sacado::Rad::ADvar< T > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvar< T >, Sacado::Rad::ADvar< U > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvari< T >, float >
 
struct  ProductTypeImpl< float, Sacado::Rad::ADvari< T > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvari< T >, double >
 
struct  ProductTypeImpl< double, Sacado::Rad::ADvari< T > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvari< T >, int >
 
struct  ProductTypeImpl< int, Sacado::Rad::ADvari< T > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvari< T >, Sacado::Rad::ADvari< U > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvar< T >, Sacado::Rad::ADvari< U > >
 
struct  ProductTypeImpl< Sacado::Rad::ADvari< T >, Sacado::Rad::ADvar< U > >
 
struct  ProductTypeImpl< Differentiation::SD::Expression, Differentiation::SD::Expression >
 
struct  ProductTypeImpl< T, Differentiation::SD::Expression >
 
struct  ProductTypeImpl< Differentiation::SD::Expression, T >
 
struct  GenericDoFsPerObject
 
struct  CurlType
 
struct  CurlType< 1, NumberType >
 
struct  CurlType< 2, NumberType >
 
struct  CurlType< 3, NumberType >
 
class  CellIDTranslator
 
class  ActiveCellIterator
 
class  NoPermutation
 
struct  ElementAccess
 
struct  ElementAccess< LinearAlgebra::TpetraWrappers::Vector< NumberType > >
 
struct  EvaluatorSelector
 
struct  EvaluatorSelector< MatrixFreeFunctions::tensor_general, is_long >
 
struct  EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric, false >
 
struct  EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric, true >
 
struct  EvaluatorSelector< MatrixFreeFunctions::truncated_tensor, is_long >
 
struct  EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric_plus_dg0, false >
 
struct  EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric_plus_dg0, true >
 
struct  EvaluatorSelector< MatrixFreeFunctions::tensor_symmetric_collocation, is_long >
 
struct  EvaluatorSelector< MatrixFreeFunctions::tensor_raviart_thomas, is_long >
 
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  FEEvaluationImplTransformToCollocation
 
struct  FEEvaluationImplEvaluateSelector
 
struct  FEEvaluationImplIntegrateSelector
 
struct  FEFaceEvaluationImpl
 
struct  FEFaceEvaluationImplRaviartThomas
 
struct  FEFaceNormalEvaluationImpl
 
struct  FEFaceEvaluationImplEvaluateSelector
 
struct  FEFaceEvaluationImplIntegrateSelector
 
struct  FEFaceEvaluationImplGatherEvaluateSelector
 
struct  FEFaceEvaluationImplIntegrateScatterSelector
 
struct  CellwiseInverseMassMatrixImplBasic
 
struct  CellwiseInverseMassMatrixImplFlexible
 
struct  CellwiseInverseMassMatrixImplTransformFromQPoints
 
class  FEEvaluationImplHangingNodesRunner
 
class  FEEvaluationImplHangingNodesRunner< FEEvaluationImplHangingNodesRunnerTypes::vectorized, dim, fe_degree, Number >
 
struct  Trait
 
struct  Trait< T1, VectorizationTypes::index >
 
struct  Trait< T1, VectorizationTypes::mask >
 
struct  Trait< T1, VectorizationTypes::group >
 
struct  Trait< T1, VectorizationTypes::sorted >
 
class  HelperBase
 
class  Helper
 
class  Helper< HelperType::dynamic, Number, VectorizationType, fe_degree, transpose >
 
class  Helper< HelperType::constant, Number, VectorizationType, fe_degree, transpose >
 
class  FEEvaluationImplHangingNodesRunner< FEEvaluationImplHangingNodesRunnerTypes::scalar, dim, fe_degree, Number >
 
struct  FEEvaluationImplHangingNodes
 
struct  FEEvaluationFactory
 
struct  FEFaceEvaluationFactory
 
struct  FEFaceEvaluationGatherFactory
 
struct  CellwiseInverseMassFactory
 
struct  FEEvaluationHangingNodesFactory
 
struct  MFWorkerInterface
 
struct  EvaluatorTensorProduct
 
struct  EvaluatorTensorProductAnisotropic
 
struct  EvaluatorTensorProduct< evaluate_general, dim, n_rows, n_columns, Number, Number2 >
 
struct  EvaluatorTensorProduct< evaluate_general, dim, 0, 0, Number, Number2 >
 
struct  EvaluatorTensorProduct< evaluate_symmetric, dim, n_rows, n_columns, Number, Number2 >
 
struct  EvaluatorTensorProduct< evaluate_evenodd, dim, n_rows, n_columns, Number, Number2 >
 
struct  EvaluatorTensorProduct< evaluate_evenodd, dim, 0, 0, Number, Number2 >
 
struct  EvaluatorTensorProduct< evaluate_symmetric_hierarchical, dim, n_rows, n_columns, Number, Number2 >
 
struct  EvaluatorTensorProductAnisotropic< evaluate_raviart_thomas, dim, n_rows, n_columns, Number, normal_dir, Number2 >
 
struct  ProductTypeNoPoint
 
struct  ProductTypeNoPoint< Point< dim, Number >, Number2 >
 
struct  VectorReader
 
struct  VectorDistributorLocalToGlobal
 
struct  VectorSetter
 
struct  MatrixSelector
 
struct  MatrixSelector< LinearAlgebra::distributed::Vector< Number > >
 
struct  MatrixSelector<::TrilinosWrappers::MPI::Vector >
 
struct  MatrixSelector<::LinearAlgebra::TpetraWrappers::Vector< Number > >
 
struct  MatrixSelector<::LinearAlgebra::EpetraWrappers::Vector >
 
struct  MatrixSelector<::PETScWrappers::MPI::Vector >
 

Typedefs

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

Enumerations

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 ,
  evaluate_raviart_thomas
}
 
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)
 
internal::GenericDoFsPerObject expand (const unsigned int dim, const std::vector< unsigned int > &dofs_per_object, const ::ReferenceCell reference_cell)
 
template<typename MatrixType >
void reinit (MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
 
template<typename number >
void reinit (MatrixBlock<::SparseMatrix< number >> &v, const BlockSparsityPattern &p)
 
constexpr bool use_collocation_evaluation (const unsigned int fe_degree, const unsigned int n_q_points_1d)
 
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 ::ExceptionBaseExcAccessToUninitializedField ()
 
static ::ExceptionBaseExcMatrixFreeAccessToUninitializedMappingField (std::string arg1)
 
template<int dim, int n_rows_static, int n_columns_static, typename Number , typename Number2 , int direction, bool contract_over_rows, bool add, int type, bool one_line>
void even_odd_apply (const int n_rows_in, const int n_columns_in, const Number2 *DEAL_II_RESTRICT shapes, const Number *in, Number *out)
 
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 std::vector< Number > &values, const Point< dim, Number2 > &p, const bool d_linear=false, 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 std::vector< Number > &values, const Point< dim, Number2 > &p, const std::vector< unsigned int > &renumber={})
 
template<int dim, typename Number , typename Number2 >
void integrate_add_tensor_product_value_and_gradient (const std::vector< Polynomials::Polynomial< double >> &poly, const Number2 &value, const Tensor< 1, dim, Number2 > &gradient, const Point< dim, Number > &p, AlignedVector< Number2 > &values, const std::vector< unsigned int > &renumber={})
 
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 >
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<typename VectorType , std::enable_if_t<!has_local_element< VectorType >, VectorType > * = nullptr>
VectorType::value_type vector_access (const VectorType &vec, const unsigned int entry)
 
template<typename VectorType , std::enable_if_t<!has_local_element< VectorType >, 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<class ACCESSOR >
bool is_active_iterator (const TriaActiveIterator< ACCESSOR > &)
 
template<class ACCESSOR >
bool is_active_iterator (const ::FilteredIterator< TriaActiveIterator< ACCESSOR >> &)
 
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< Number >::value, typename numbers::NumberTraits< Number >::real_type > get_abs (const Number a)
 
template<typename Number >
std::enable_if_t< std::is_unsigned< Number >::value, 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)
 
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 unsigned int n_q_points, 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<class VectorType >
VectorType::value_type get_vector_element (const VectorType &vector, const types::global_dof_index cell_number)
 
IndexSet::value_type get_vector_element (const IndexSet &is, const types::global_dof_index cell_number)
 
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 Number2 *dof_values_ptr, const ::Table< 2, double > &shape_values, std::vector< Number > &values)
 
template<int dim, int spacedim, typename VectorType >
void do_function_values (const typename VectorType::value_type *dof_values_ptr, 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 Number *dof_values_ptr, 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 Number *dof_values_ptr, 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 Number2 *dof_values_ptr, 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 Number *dof_values_ptr, 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)
 
template<int dim, int spacedim>
void extract_interpolation_matrices (const ::DoFHandler< dim, spacedim > &dof, ::Table< 2, FullMatrix< double >> &matrices)
 
template<int dim, int spacedim>
void restriction_additive (const FiniteElement< dim, spacedim > &, std::vector< std::vector< bool >> &)
 
template<int dim, int spacedim>
void restriction_additive (const ::hp::FECollection< dim, spacedim > &fe, std::vector< std::vector< bool >> &restriction_is_additive)
 

Variables

static constexpr const ::ndarray< unsigned int, 6, 2 > wedge_table_1
 
static constexpr const ::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

◆ has_block_t

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

Definition at line 49 of file block_vector_base.h.

◆ has_n_blocks_t

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

Definition at line 55 of file block_vector_base.h.

◆ set_ghost_state_t

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

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

Definition at line 99 of file dof_accessor_set.cc.

Enumeration Type Documentation

◆ FEEvaluationImplHangingNodesRunnerTypes

Enumerator
scalar 
vectorized 

Definition at line 41 of file evaluation_kernels_hanging_nodes.h.

◆ VectorizationTypes

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 53 of file evaluation_kernels_hanging_nodes.h.

◆ HelperType

enum 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 1107 of file evaluation_kernels_hanging_nodes.h.

◆ 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.

evaluate_raviart_thomas 

Raviart-Thomas elements with anisotropic polynomials.

Definition at line 38 of file tensor_product_kernels.h.

◆ EvaluatorQuantity

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 79 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 
)

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 24 of file function_restriction.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 25 of file fe_data.cc.

◆ reinit() [1/2]

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

Definition at line 618 of file matrix_block.h.

◆ reinit() [2/2]

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

Definition at line 627 of file matrix_block.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 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 2243 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 3881 of file evaluation_kernels.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 3893 of file evaluation_kernels.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 3903 of file evaluation_kernels.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 3917 of file evaluation_kernels.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 3929 of file evaluation_kernels.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 3941 of file evaluation_kernels.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 3953 of file evaluation_kernels.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 3967 of file evaluation_kernels.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 3985 of file evaluation_kernels.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 4048 of file evaluation_kernels.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 4594 of file evaluation_kernels.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 33 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 63 of file evaluation_template_factory_internal.h.

◆ even_odd_apply()

template<int dim, int n_rows_static, int n_columns_static, typename Number , typename Number2 , int direction, bool contract_over_rows, bool add, int type, bool one_line>
void internal::even_odd_apply ( const int  n_rows_in,
const int  n_columns_in,
const Number2 *DEAL_II_RESTRICT  shapes,
const Number *  in,
Number *  out 
)
inline

Definition at line 1581 of file tensor_product_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 std::vector< 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
polyThe underlying one-dimensional polynomial basis \(\{\varphi^{1D}_{i_1}\}\) given as a vector of polynomials.
valuesThe 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.
pThe position in reference coordinates where the interpolation should be evaluated.
d_linearFlag 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.
renumberOptional 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 3023 of file tensor_product_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 std::vector< Number > &  values,
const Point< dim, Number2 > &  p,
const std::vector< unsigned int > &  renumber = {} 
)

Definition at line 3164 of file tensor_product_kernels.h.

◆ integrate_add_tensor_product_value_and_gradient()

template<int dim, typename Number , typename Number2 >
void internal::integrate_add_tensor_product_value_and_gradient ( const std::vector< Polynomials::Polynomial< double >> &  poly,
const Number2 &  value,
const Tensor< 1, dim, Number2 > &  gradient,
const Point< dim, Number > &  p,
AlignedVector< Number2 > &  values,
const std::vector< unsigned int > &  renumber = {} 
)
inline

Same as evaluate_tensor_product_value_and_gradient() but for integration.

Definition at line 3268 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 3329 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 3366 of file tensor_product_kernels.h.

◆ vector_access() [1/2]

template<typename VectorType , std::enable_if_t<!has_local_element< VectorType >, VectorType > * = nullptr>
VectorType::value_type internal::vector_access ( const VectorType &  vec,
const unsigned int  entry 
)
inline

Definition at line 46 of file vector_access_internal.h.

◆ vector_access() [2/2]

template<typename VectorType , std::enable_if_t<!has_local_element< VectorType >, VectorType > * = nullptr>
VectorType::value_type & internal::vector_access ( VectorType &  vec,
const unsigned int  entry 
)
inline

Definition at line 60 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 97 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 123 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 149 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 182 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 49 of file loop.h.

◆ is_active_iterator() [2/3]

template<class ACCESSOR >
bool internal::is_active_iterator ( const TriaActiveIterator< ACCESSOR > &  )
inline

Definition at line 56 of file loop.h.

◆ is_active_iterator() [3/3]

template<class ACCESSOR >
bool internal::is_active_iterator ( const ::FilteredIterator< TriaActiveIterator< ACCESSOR >> &  )
inline

Definition at line 63 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 71 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<Number>::value, 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 63 of file dof_accessor_set.cc.

◆ get_abs() [2/2]

template<typename Number >
std::enable_if_t<std::is_unsigned<Number>::value, Number> internal::get_abs ( const Number  a)

Definition at line 70 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 110 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 135 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 179 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 53 of file dof_handler.cc.

◆ number_unique_entries()

unsigned int internal::number_unique_entries ( const std::vector< unsigned int > &  vector)

Definition at line 99 of file fe_data.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 57 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 94 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 unsigned int  n_q_points,
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 135 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 183 of file fe_system.cc.

◆ get_vector_element() [1/2]

template<class VectorType >
VectorType::value_type internal::get_vector_element ( const VectorType &  vector,
const types::global_dof_index  cell_number 
)
inline

Definition at line 62 of file fe_values.cc.

◆ get_vector_element() [2/2]

IndexSet::value_type internal::get_vector_element ( const IndexSet is,
const types::global_dof_index  cell_number 
)
inline

Definition at line 71 of file fe_values.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 82 of file fe_values.cc.

◆ do_function_values() [1/2]

template<typename Number , typename Number2 >
void internal::do_function_values ( const Number2 *  dof_values_ptr,
const ::Table< 2, double > &  shape_values,
std::vector< Number > &  values 
)

Definition at line 2906 of file fe_values.cc.

◆ do_function_values() [2/2]

template<int dim, int spacedim, typename VectorType >
void internal::do_function_values ( const typename VectorType::value_type *  dof_values_ptr,
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 2946 of file fe_values.cc.

◆ do_function_derivatives() [1/2]

template<int order, int spacedim, typename Number >
void internal::do_function_derivatives ( const Number *  dof_values_ptr,
const ::Table< 2, Tensor< order, spacedim >> &  shape_derivatives,
std::vector< Tensor< order, spacedim, Number >> &  derivatives 
)

Definition at line 3057 of file fe_values.cc.

◆ do_function_derivatives() [2/2]

template<int order, int dim, int spacedim, typename Number >
void internal::do_function_derivatives ( const Number *  dof_values_ptr,
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 3097 of file fe_values.cc.

◆ do_function_laplacians() [1/2]

template<int spacedim, typename Number , typename Number2 >
void internal::do_function_laplacians ( const Number2 *  dof_values_ptr,
const ::Table< 2, Tensor< 2, spacedim >> &  shape_hessians,
std::vector< Number > &  laplacians 
)

Definition at line 3204 of file fe_values.cc.

◆ do_function_laplacians() [2/2]

template<int dim, int spacedim, typename VectorType , typename Number >
void internal::do_function_laplacians ( const Number *  dof_values_ptr,
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 3241 of file fe_values.cc.

◆ apply_exponential_map()

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

Definition at line 54 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 74 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 85 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 92 of file manifold_lib.cc.

◆ extract_interpolation_matrices()

template<int dim, int spacedim>
void internal::extract_interpolation_matrices ( const ::DoFHandler< dim, spacedim > &  dof,
::Table< 2, FullMatrix< double >> &  matrices 
)

Generate a table that contains interpolation matrices between each combination of finite elements used in a DoFHandler of some kind. Since not all elements can be interpolated onto each other, the table may contain empty matrices for those combinations of elements for which no such interpolation is implemented.

Definition at line 220 of file solution_transfer.cc.

◆ restriction_additive() [1/2]

template<int dim, int spacedim>
void internal::restriction_additive ( const FiniteElement< dim, spacedim > &  ,
std::vector< std::vector< bool >> &   
)

Definition at line 257 of file solution_transfer.cc.

◆ restriction_additive() [2/2]

template<int dim, int spacedim>
void internal::restriction_additive ( const ::hp::FECollection< dim, spacedim > &  fe,
std::vector< std::vector< bool >> &  restriction_is_additive 
)

Definition at line 263 of file solution_transfer.cc.

Variable Documentation

◆ wedge_table_1

constexpr const ::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 and within the line.

Definition at line 36 of file polynomials_wedge.h.

◆ wedge_table_2

constexpr const ::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 and within the line.

Definition at line 44 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
typename detected_or< nonesuch, Op, Args... >::value_t is_detected

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 155 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 52 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 58 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 62 of file block_vector_base.h.

◆ is_dealii_vector

template<typename VectorType >
constexpr bool internal::is_dealii_vector
constexpr
Initial value:
=
std::is_same<VectorType,
std::is_same<VectorType,
std::is_same<
VectorType,
std::is_same<VectorType,
typename VectorType::value_type>>::value ||
std::is_same<VectorType,
typename VectorType::value_type>>::value

Check if a vector is a deal.II vector.

Definition at line 79 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 103 of file dof_accessor_set.cc.

◆ invalid_pull_back_coordinate

constexpr double internal::invalid_pull_back_coordinate = 20.0
staticconstexpr

Definition at line 48 of file manifold_lib.cc.