Namespaces
namespace	anonymous_namespace{DOFTableUtil.cpp}
namespace	detail
namespace	IntegrationMethodRegistry

Classes
struct	AssemblyException
class	BackwardEuler
	Backward Euler scheme. More...
struct	CentralDifferencesStrategy
class	ConvergenceCriterion
class	ConvergenceCriterionDeltaX
class	ConvergenceCriterionPerComponent
class	ConvergenceCriterionPerComponentDeltaX
class	ConvergenceCriterionPerComponentResidual
class	ConvergenceCriterionResidual
struct	CouplingNode
	Information of a coupling node. More...
class	DefaultIntegrationMethodProvider
struct	ElementTraitsLagrange
class	EquationSystem
class	EvolutionaryPIDcontroller
struct	EvolutionaryPIDcontrollerParameters
class	ExtrapolatableElement
class	ExtrapolatableElementCollection
class	ExtrapolatableLocalAssemblerCollection
class	Extrapolator
struct	FeHEX20
struct	FeHEX8
struct	FeLINE2
struct	FeLINE3
struct	FePOINT1
struct	FePRISM15
struct	FePRISM6
struct	FePYRA13
struct	FePYRA5
struct	FeQUAD4
struct	FeQUAD8
struct	FeQUAD9
struct	FeTET10
struct	FeTET4
struct	FeTRI3
struct	FeTRI6
class	FixedTimeStepping
	Fixed time stepping algorithm. More...
struct	FixedTimeSteppingParameters
class	FluxCorrectedTransport
struct	ForwardDifferencesStrategy
class	FullUpwind
struct	GaussLegendreIntegrationPolicy
struct	GaussLegendreIntegrationPolicy< MeshLib::Point >
struct	GaussLegendreIntegrationPolicy< MeshLib::Prism >
struct	GaussLegendreIntegrationPolicy< MeshLib::Prism15 >
struct	GaussLegendreIntegrationPolicy< MeshLib::Pyramid >
struct	GaussLegendreIntegrationPolicy< MeshLib::Pyramid13 >
struct	GaussLegendreIntegrationPolicy< MeshLib::Tet >
struct	GaussLegendreIntegrationPolicy< MeshLib::Tet10 >
struct	GaussLegendreIntegrationPolicy< MeshLib::Tri >
struct	GaussLegendreIntegrationPolicy< MeshLib::Tri6 >
class	GenericIntegrationMethod
struct	GlobalMatrixProvider
struct	GlobalVectorProvider
struct	IndexValueVector
class	IntegrationGaussLegendrePrism
	Gauss-Legendre quadrature rule for prisms. More...
class	IntegrationGaussLegendrePyramid
	Gauss-Legendre quadrature rule for pyramid. More...
class	IntegrationGaussLegendreRegular
class	IntegrationGaussLegendreTet
	Gauss-Legendre quadrature rule for tetrahedrals. More...
class	IntegrationGaussLegendreTri
	Gauss-Legendre quadrature rule for triangles. More...
struct	IntegrationOrder
class	IntegrationPoint
class	IsotropicDiffusionStabilization
class	IterationNumberBasedTimeStepping
	Iteration number based adaptive time stepping. More...
struct	IterationNumberBasedTimeSteppingParameters
struct	LocalCouplingParameters
class	LocalLinearLeastSquaresExtrapolator
class	LocalToGlobalIndexMap
struct	LowerDim
struct	LowerDim< NumLib::ShapeHex20 >
struct	LowerDim< NumLib::ShapeLine3 >
struct	LowerDim< NumLib::ShapePrism15 >
struct	LowerDim< NumLib::ShapePyra13 >
struct	LowerDim< NumLib::ShapeQuad8 >
struct	LowerDim< NumLib::ShapeQuad9 >
struct	LowerDim< NumLib::ShapeTet10 >
struct	LowerDim< NumLib::ShapeTri6 >
class	MatrixProvider
class	MatrixTranslator
class	MatrixTranslator< ODESystemTag::FirstOrderImplicitQuasilinear >
class	MatrixTranslatorGeneral
class	MatrixTranslatorGeneral< ODESystemTag::FirstOrderImplicitQuasilinear >
class	MeshComponentMap
	Multidirectional mapping between mesh entities and degrees of freedom. More...
struct	NaturalCoordinates
struct	NaturalCoordinates< MeshLib::Hex >
struct	NaturalCoordinates< MeshLib::Hex20 >
struct	NaturalCoordinates< MeshLib::Line >
struct	NaturalCoordinates< MeshLib::Line3 >
struct	NaturalCoordinates< MeshLib::Point >
struct	NaturalCoordinates< MeshLib::Prism >
struct	NaturalCoordinates< MeshLib::Prism15 >
struct	NaturalCoordinates< MeshLib::Pyramid >
struct	NaturalCoordinates< MeshLib::Pyramid13 >
struct	NaturalCoordinates< MeshLib::Quad >
struct	NaturalCoordinates< MeshLib::Quad8 >
struct	NaturalCoordinates< MeshLib::Quad9 >
struct	NaturalCoordinates< MeshLib::Tet >
struct	NaturalCoordinates< MeshLib::Tet10 >
struct	NaturalCoordinates< MeshLib::Tri >
struct	NaturalCoordinates< MeshLib::Tri6 >
struct	NaturalCoordinatesMapping
class	NewtonRaphson
struct	NewtonRaphsonSolverParameters
class	NonlinearSolver
class	NonlinearSolver< NonlinearSolverTag::Newton >
class	NonlinearSolver< NonlinearSolverTag::Picard >
class	NonlinearSolverBase
struct	NonlinearSolverStatus
	Status of the non-linear solver. More...
class	NonlinearSystem
class	NonlinearSystem< NonlinearSolverTag::Newton >
class	NonlinearSystem< NonlinearSolverTag::Picard >
struct	NoStabilization
struct	NumericalDerivative
class	ODESystem
class	ODESystem< ODESystemTag::FirstOrderImplicitQuasilinear, NonlinearSolverTag::Newton >
class	ODESystem< ODESystemTag::FirstOrderImplicitQuasilinear, NonlinearSolverTag::Picard >
class	PETScNonlinearSolver
class	ReferenceElement
struct	RootCouplingNode
struct	SerialExecutor
class	ShapeHex20
class	ShapeHex8
class	ShapeLine2
class	ShapeLine3
struct	ShapeMatrices
	Coordinates mapping matrices at particular location. More...
class	ShapeMatrixCache
class	ShapePoint1
	Shape function for a point element in natural coordinates. More...
class	ShapePrism15
class	ShapePrism6
class	ShapePyra13
class	ShapePyra5
class	ShapeQuad4
class	ShapeQuad8
class	ShapeQuad9
class	ShapeTet10
class	ShapeTet4
class	ShapeTri3
class	ShapeTri6
class	SimpleMatrixVectorProvider
class	StaggeredCoupling
class	TemplateIsoparametric
	Template class for isoparametric elements. More...
struct	Time
class	TimeDiscretization
class	TimeDiscretizedODESystem
class	TimeDiscretizedODESystem< ODESystemTag::FirstOrderImplicitQuasilinear, NonlinearSolverTag::Newton >
class	TimeDiscretizedODESystem< ODESystemTag::FirstOrderImplicitQuasilinear, NonlinearSolverTag::Picard >
class	TimeDiscretizedODESystemBase
struct	TimeIncrement
class	TimeStep
	Time step object. More...
class	TimeStepAlgorithm
	Interface of time stepping algorithms. More...
struct	Vectorial
class	VectorProvider

Typedefs
using	AllElementTraitsLagrange
using	RelativeEpsilon = BaseLib::StrongType<double, struct RelativeEpsilonTag>
using	MinimumPerturbation
using	NumericalStabilization
using	CouplingNodeVariant = std::variant<CouplingNode, RootCouplingNode>
using	RepeatDtPair = std::tuple<std::size_t, double>

Enumerations
enum class	ComponentOrder { BY_COMPONENT , BY_LOCATION }
	Ordering of components in global matrix/vector. More...
enum class	ShapeMatrixType { N , DNDR , N_J , DNDR_J , DNDX , ALL }
	Shape matrix type to be calculated. More...
enum class	IterationResult : char { IterationResult::SUCCESS , IterationResult::FAILURE , IterationResult::REPEAT_ITERATION }
	Status flags telling the NonlinearSolver if an iteration succeeded. More...
enum class	NonlinearSolverTag : bool { NonlinearSolverTag::Picard , NonlinearSolverTag::Newton }
	Tag used to specify which nonlinear solver will be used. More...
enum class	ODESystemTag : char { ODESystemTag::FirstOrderImplicitQuasilinear , ODESystemTag::NeumannBC }
	Tag used to specify the type of ODE. More...
enum class	MultiplyerInterpolationType { PiecewiseConstant , PiecewiseLinear }

Functions
NewtonRaphsonSolverParameters	createNewtonRaphsonSolverParameters (BaseLib::ConfigTree const &config)
GlobalSparsityPattern	computeSparsityPattern (LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh)
	Computes a sparsity pattern for the given inputs.
double	getNonGhostNodalValue (GlobalVector const &x, MeshLib::Location const &location, NumLib::LocalToGlobalIndexMap const &dof_table, std::size_t const global_component_id)
double	getNodalValue (GlobalVector const &x, MeshLib::Location const &location, NumLib::LocalToGlobalIndexMap const &dof_table, std::size_t const global_component_id)
std::vector< GlobalIndexType >	getIndices (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table)
std::vector< GlobalIndexType >	getIndices (std::size_t const variable_id, std::size_t const component_id, std::size_t const bulk_element_id, NumLib::LocalToGlobalIndexMap const &dof_table)
NumLib::LocalToGlobalIndexMap::RowColumnIndices	getRowColumnIndices (std::size_t const id, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< GlobalIndexType > &indices)
double	norm (GlobalVector const &x, unsigned const global_component, MathLib::VecNormType norm_type, LocalToGlobalIndexMap const &dof_table)
Eigen::VectorXd	getLocalX (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x)
template<typename Functor>
void	transformVariableFromGlobalVector (GlobalVector const &input_vector, int const variable_id, NumLib::LocalToGlobalIndexMap const &local_to_global_index_map, MeshLib::PropertyVector< double > &output_vector, Functor map_function)
template<typename Functor>
void	transformVariableFromGlobalVector (GlobalVector const &input_vector_on_bulk_mesh, int const variable_id, NumLib::LocalToGlobalIndexMap const &local_to_global_index_map, MeshLib::PropertyVector< double > &output_vector_on_submesh, std::span< std::size_t const > const &map_submesh_node_id_to_bulk_mesh_node_id, Functor map_function)
void	cleanupGlobalMatrixProviders ()
template<typename... Ns_t, typename ElementDOFVector>
auto	localDOF (ElementDOFVector const &x)
std::ostream &	operator<< (std::ostream &os, LocalToGlobalIndexMap const &map)
GlobalIndexType	getGlobalIndexWithTaylorHoodElement (MeshLib::NodePartitionedMesh const &partitioned_mesh, std::size_t const global_node_id, int const number_of_components_at_base_node, int const number_of_components_at_high_order_node, int const component_id_at_base_node, int const component_id_at_high_order_node, bool const is_base_node)
template<typename LocalAssemblerCollection, typename IntegrationPointValuesMethod>
ExtrapolatableLocalAssemblerCollection< LocalAssemblerCollection >	makeExtrapolatable (LocalAssemblerCollection const &local_assemblers, IntegrationPointValuesMethod integration_point_values_method)
template<int DisplacementDim, typename ShapeFunction, typename ShapeMatricesType, typename IpData>
Eigen::Vector3d	averageGradShapeFunction (int const local_node_id, MeshLib::Element const &element, NumLib::GenericIntegrationMethod const &integration_method, std::vector< IpData, Eigen::aligned_allocator< IpData > > const &ip_data, const bool is_axially_symmetric)
template<class T_N, class T_DNDR, class T_J, class T_DNDX>
std::ostream &	operator<< (std::ostream &os, const ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &shape)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Point, ShapePoint1)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Line, ShapeLine2)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Line3, ShapeLine3)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Quad, ShapeQuad4)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Quad8, ShapeQuad8)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Quad9, ShapeQuad9)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Hex, ShapeHex8)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Hex20, ShapeHex20)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Tri, ShapeTri3)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Tri6, ShapeTri6)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Tet, ShapeTet4)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Tet10, ShapeTet10)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Prism, ShapePrism6)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Prism15, ShapePrism15)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Pyramid, ShapePyra5)
	OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE (Pyramid13, ShapePyra13)
template<typename ShapeFunction, typename ShapeMatricesType>
NumLib::TemplateIsoparametric< ShapeFunction, ShapeMatricesType >	createIsoparametricFiniteElement (MeshLib::Element const &e)
template<typename ShapeFunction, typename ShapeMatricesType, int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL, typename PointContainer>
std::vector< typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator< typename ShapeMatricesType::ShapeMatrices > >	computeShapeMatrices (MeshLib::Element const &e, bool const is_axially_symmetric, PointContainer const &points)
template<typename ShapeFunction, typename ShapeMatricesType, int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL, typename IntegrationMethod>
std::vector< typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator< typename ShapeMatricesType::ShapeMatrices > >	initShapeMatrices (MeshLib::Element const &e, bool const is_axially_symmetric, IntegrationMethod const &integration_method)
template<typename ShapeFunction, typename ShapeMatricesType, int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL>
ShapeMatricesType::ShapeMatrices	initShapeMatricesAtElementCenter (MeshLib::Element const &e, bool const is_axially_symmetric)
template<typename ShapeFunction, typename ShapeMatricesType>
double	interpolateXCoordinate (MeshLib::Element const &e, typename ShapeMatricesType::ShapeMatrices::ShapeType const &N)
template<typename ShapeFunction, typename ShapeMatricesType>
std::array< double, 3 >	interpolateCoordinates (MeshLib::Element const &e, typename ShapeMatricesType::ShapeMatrices::ShapeType const &N)
DefaultIntegrationMethodProvider	getIntegrationMethodProvider (NumLib::IntegrationOrder const integration_order)
template<typename NodalValues, typename ShapeMatrix, typename... ScalarTypes>
void	shapeFunctionInterpolate (const NodalValues &nodal_values, const ShapeMatrix &shape_matrix_N, double &interpolated_value, ScalarTypes &... interpolated_values)
template<typename LowerOrderShapeFunction, typename HigherOrderMeshElementType, int GlobalDim, typename EigenMatrixType>
void	interpolateToHigherOrderNodes (MeshLib::Element const &element, bool const is_axially_symmetric, Eigen::MatrixBase< EigenMatrixType > const &node_values, MeshLib::PropertyVector< double > &interpolated_values_global_vector)
template<typename LinearSolver, typename JacobianMatrixUpdate, typename ResidualUpdate, typename SolutionUpdate>
NewtonRaphson< LinearSolver, JacobianMatrixUpdate, ResidualUpdate, SolutionUpdate >	makeNewtonRaphson (LinearSolver &linear_solver, JacobianMatrixUpdate &&jacobian_update, ResidualUpdate &&residual_update, SolutionUpdate &&solution_update, NewtonRaphsonSolverParameters const &solver_parameters)
template<typename MeshElementType, typename IPData, typename FluxVectorType, typename Derived>
void	assembleAdvectionMatrix (NumericalStabilization const &stabilizer, IPData const &ip_data_vector, NumLib::ShapeMatrixCache const &shape_matrix_cache, std::vector< FluxVectorType > const &ip_flux_vector, double const average_velocity, Eigen::MatrixBase< Derived > &laplacian_matrix)
template<typename IPData, typename FluxVectorType, typename Derived>
void	assembleAdvectionMatrix (NumericalStabilization const &stabilizer, IPData const &ip_data_vector, std::vector< FluxVectorType > const &ip_flux_vector, double const average_velocity, Eigen::MatrixBase< Derived > &laplacian_matrix)
NumericalStabilization	createNumericalStabilization (MeshLib::Mesh const &mesh, BaseLib::ConfigTree const &config)
void	computeFluxCorrectedTransport (NumericalStabilization const &stabilizer, const double t, const double dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, const MathLib::MatrixSpecifications &matrix_specification, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b)
Eigen::MatrixXd	computeHydrodynamicDispersion (NumericalStabilization const &stabilizer, std::size_t const element_id, Eigen::MatrixXd const &pore_diffusion_coefficient, Eigen::VectorXd const &velocity, double const porosity, double const solute_dispersivity_transverse, double const solute_dispersivity_longitudinal)
std::unique_ptr< ConvergenceCriterion >	createConvergenceCriterion (BaseLib::ConfigTree const &config)
	Creates a convergence criterion from the given configuration.
bool	checkRelativeTolerance (const double reltol, const double numerator, const double denominator)
std::unique_ptr< ConvergenceCriterionDeltaX >	createConvergenceCriterionDeltaX (const BaseLib::ConfigTree &config)
std::unique_ptr< ConvergenceCriterionPerComponentDeltaX >	createConvergenceCriterionPerComponentDeltaX (const BaseLib::ConfigTree &config)
std::unique_ptr< ConvergenceCriterionPerComponentResidual >	createConvergenceCriterionPerComponentResidual (const BaseLib::ConfigTree &config)
std::unique_ptr< ConvergenceCriterionResidual >	createConvergenceCriterionResidual (const BaseLib::ConfigTree &config)
template<ODESystemTag ODETag>
std::unique_ptr< MatrixTranslator< ODETag > >	createMatrixTranslator (TimeDiscretization const &timeDisc)
std::pair< std::unique_ptr< NonlinearSolverBase >, NonlinearSolverTag >	createNonlinearSolver (GlobalLinearSolver &linear_solver, BaseLib::ConfigTree const &config)
std::unique_ptr< TimeDiscretization >	createTimeDiscretization (BaseLib::ConfigTree const &config)
template<typename ProcessData>
void	checkLocalCouplingParameters (std::vector< std::unique_ptr< ProcessData > > const &per_process_data, std::vector< LocalCouplingParameters > const &all_local_coupling_parameters)
template<typename ProcessData>
std::vector< CouplingNodeVariant >	createRegularCouplingNodes (std::vector< std::unique_ptr< ProcessData > > const &per_process_data, std::vector< LocalCouplingParameters > const &all_local_coupling_parameters, int const global_max_coupling_iterations, std::vector< std::unique_ptr< NumLib::ConvergenceCriterion > > &global_coupling_conv_criteria)
	Create coupling nodes that do not have local-coupling nodes.
template<typename ProcessData>
std::vector< CouplingNodeVariant >	createRootCouplingNodes (std::vector< std::unique_ptr< ProcessData > > const &per_process_data, std::vector< LocalCouplingParameters > const &all_local_coupling_parameters, int const global_max_coupling_iterations, std::vector< std::unique_ptr< NumLib::ConvergenceCriterion > > &global_coupling_conv_criteria)
	Create coupling nodes that have local-coupling nodes.
template<typename ProcessData>
std::vector< CouplingNodeVariant >	createCouplingNodes (std::vector< std::unique_ptr< ProcessData > > const &per_process_data, std::vector< LocalCouplingParameters > const &all_local_coupling_parameters, int const global_max_coupling_iterations, std::vector< std::unique_ptr< NumLib::ConvergenceCriterion > > &global_coupling_conv_criteria)
template<typename ProcessData>
std::unique_ptr< StaggeredCoupling >	createStaggeredCoupling (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ProcessData > > const &per_process_data)
	Create a StaggeredCoupling instance from the given configuration.
std::vector< LocalCouplingParameters >	parseLocalCoupling (BaseLib::ConfigTree const &config, const std::size_t max_process_number)
std::tuple< std::vector< std::unique_ptr< NumLib::ConvergenceCriterion > >, std::vector< LocalCouplingParameters >, int >	parseCoupling (BaseLib::ConfigTree const &config)
EvolutionaryPIDcontrollerParameters	parseEvolutionaryPIDcontroller (BaseLib::ConfigTree const &config)
std::unique_ptr< TimeStepAlgorithm >	createEvolutionaryPIDcontroller (EvolutionaryPIDcontrollerParameters const &config, std::vector< double > const &fixed_times_for_output)
FixedTimeSteppingParameters	parseFixedTimeStepping (BaseLib::ConfigTree const &config)
std::unique_ptr< TimeStepAlgorithm >	createFixedTimeStepping (FixedTimeSteppingParameters const &parameters, std::vector< double > const &fixed_times_for_output)
IterationNumberBasedTimeSteppingParameters	parseIterationNumberBasedTimeStepping (BaseLib::ConfigTree const &config)
std::unique_ptr< TimeStepAlgorithm >	createIterationNumberBasedTimeStepping (IterationNumberBasedTimeSteppingParameters &&parameters, std::vector< double > const &fixed_times_for_output)
std::size_t	findDeltatInterval (Time const &t_initial, std::vector< double > const &delta_ts, Time const &fixed_output_time)
void	incorporateFixedTimesForOutput (NumLib::Time const t_initial, NumLib::Time const t_end, std::vector< double > &delta_ts, std::vector< double > const &fixed_times_for_output)
double	findMultiplier (int const number_iterations, bool const current_time_step_is_accepted, std::vector< int > const &nonlinear_iteration_numbers, std::vector< double > const &multipliers, MultiplyerInterpolationType const multiplier_interpolation_type)
	Find a multiplier for the given number of iterations.
double	possiblyClampDtToNextFixedTime (Time const &t, double const dt, std::vector< double > const &fixed_output_times)
bool	canReduceTimestepSize (TimeStep const &timestep_previous, TimeStep const &timestep_current, double const min_dt)
std::unique_ptr< TimeStepAlgorithm >	createTimeStepper (BaseLib::ConfigTree const &config, std::vector< double > const &fixed_times_for_output)
void	updateTimeSteps (double const dt, TimeStep &previous_timestep, TimeStep &current_timestep)

Typedef Documentation

◆ AllElementTraitsLagrange

using NumLib::AllElementTraitsLagrange

Initial value:

BaseLib::TMP::Map_t<ElementTraitsLagrange, MeshLib::AllElementTypes>

BaseLib::TMP::Map_t

typename Map< MapFromTypeToType, List >::type Map_t

Definition TMP.h:95

Definition at line 93 of file ElementTraitsLagrange.h.

◆ CouplingNodeVariant

using NumLib::CouplingNodeVariant = std::variant<CouplingNode, RootCouplingNode>

Definition at line 14 of file CreateStaggeredCoupling-impl.h.

◆ MinimumPerturbation

using NumLib::MinimumPerturbation

Initial value:

BaseLib::StrongType<double, struct MinimumPerturbationTag>

BaseLib::StrongType

Definition StrongType.h:18

Definition at line 15 of file NumericalDifferentiation.h.

◆ NumericalStabilization

typedef std::variant< NoStabilization, IsotropicDiffusionStabilization, FullUpwind, FluxCorrectedTransport > NumLib::NumericalStabilization

Initial value:

 
    std::variant<NoStabilization, IsotropicDiffusionStabilization, FullUpwind,
                 FluxCorrectedTransport>

Definition at line 25 of file CreateNumericalStabilization.h.

◆ RelativeEpsilon

using NumLib::RelativeEpsilon = BaseLib::StrongType<double, struct RelativeEpsilonTag>

Definition at line 14 of file NumericalDifferentiation.h.

◆ RepeatDtPair

using NumLib::RepeatDtPair = std::tuple<std::size_t, double>

Definition at line 13 of file FixedTimeStepping.h.

Enumeration Type Documentation

◆ ComponentOrder

enum class NumLib::ComponentOrder

strong

Ordering of components in global matrix/vector.

Enumerator
BY_COMPONENT	Ordering data by component type.
BY_LOCATION	Ordering data by spatial location.

Definition at line 13 of file MeshComponentMap.h.

{
    BY_COMPONENT,  
    BY_LOCATION    
};

◆ MultiplyerInterpolationType

enum class NumLib::MultiplyerInterpolationType

strong

Enumerator
PiecewiseConstant
PiecewiseLinear

Definition at line 8 of file MultiplyerInterpolationType.h.

{
    PiecewiseConstant,
    PiecewiseLinear
};

◆ ShapeMatrixType

enum class NumLib::ShapeMatrixType

strong

Shape matrix type to be calculated.

Enumerator
N	calculates N
DNDR	calculates dNdr
N_J	calculates N, dNdr, J, and detJ
DNDR_J	calculates dNdr, J, and detJ
DNDX	calculates dNdr, J, detJ, invJ, and dNdx
ALL	calculates all

Definition at line 14 of file ShapeMatrices.h.

{
    N,       
    DNDR,    
    N_J,     
    DNDR_J,  
    DNDX,    
    ALL      
};

Function Documentation

◆ assembleAdvectionMatrix() [1/2]

template<typename MeshElementType, typename IPData, typename FluxVectorType, typename Derived>

void NumLib::assembleAdvectionMatrix	(	NumericalStabilization const &	stabilizer,
		IPData const &	ip_data_vector,
		NumLib::ShapeMatrixCache const &	shape_matrix_cache,
		std::vector< FluxVectorType > const &	ip_flux_vector,
		double const	average_velocity,
		Eigen::MatrixBase< Derived > &	laplacian_matrix )

Definition at line 108 of file AdvectionMatrixAssembler.h.

{
    std::visit(
        [&](auto&& stabilizer)
        {
            using Stabilizer = std::decay_t<decltype(stabilizer)>;
            if constexpr (std::is_same_v<Stabilizer, FullUpwind>)
            {
                if (average_velocity > stabilizer.getCutoffVelocity())
                {
                    detail::applyFullUpwind(ip_data_vector, ip_flux_vector,
                                            laplacian_matrix);
                    return;
                }
            }
 
            detail::assembleAdvectionMatrix<MeshElementType>(
                ip_data_vector, shape_matrix_cache, ip_flux_vector,
                laplacian_matrix);
        },
        stabilizer);
}

References NumLib::detail::applyFullUpwind(), and NumLib::detail::assembleAdvectionMatrix().

◆ assembleAdvectionMatrix() [2/2]

template<typename IPData, typename FluxVectorType, typename Derived>

void NumLib::assembleAdvectionMatrix	(	NumericalStabilization const &	stabilizer,
		IPData const &	ip_data_vector,
		std::vector< FluxVectorType > const &	ip_flux_vector,
		double const	average_velocity,
		Eigen::MatrixBase< Derived > &	laplacian_matrix )

Definition at line 137 of file AdvectionMatrixAssembler.h.

{
    std::visit(
        [&](auto&& stabilizer)
        {
            using Stabilizer = std::decay_t<decltype(stabilizer)>;
            if constexpr (std::is_same_v<Stabilizer, FullUpwind>)
            {
                if (average_velocity > stabilizer.getCutoffVelocity())
                {
                    detail::applyFullUpwind(ip_data_vector, ip_flux_vector,
                                            laplacian_matrix);
                    return;
                }
            }
 
            detail::assembleAdvectionMatrix(
                ip_data_vector, ip_flux_vector, laplacian_matrix);
        },
        stabilizer);
}

References NumLib::detail::applyFullUpwind(), and NumLib::detail::assembleAdvectionMatrix().

◆ averageGradShapeFunction()

template<int DisplacementDim, typename ShapeFunction, typename ShapeMatricesType, typename IpData>

Eigen::Vector3d NumLib::averageGradShapeFunction	(	int const	local_node_id,
		MeshLib::Element const &	element,
		NumLib::GenericIntegrationMethod const &	integration_method,
		std::vector< IpData, Eigen::aligned_allocator< IpData > > const &	ip_data,
		const bool	is_axially_symmetric )

The function computes the element average of \(\nabla N_i\) by

\[ \bar{\nabla N_i} = \frac{\int_{\Omega_e}\nabla N_i{\mathrm d}\Omega} {\int_{\Omega_e}{\mathrm d}\Omega}. \]

Parameters

local_node_id	Node ID in an element,
element	Element,
integration_method	Integration method,
ip_data	Integration point data,
is_axially_symmetric	Indicator for axisymmetry.

Returns: Averaged \(\nabla N_i\) of an element.

Definition at line 32 of file AverageGradShapeFunction.h.

{
    Eigen::Vector3d bar_gradN = Eigen::Vector3d::Zero();
    unsigned const n_integration_points =
        integration_method.getNumberOfPoints();
    assert(n_integration_points == ip_data.size());
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& N = ip_data[ip].N_u;
        auto const& dNdx = ip_data[ip].dNdx_u;
 
        auto const dNidx = dNdx.col(local_node_id);
 
        auto const& w = ip_data[ip].integration_weight;
        bar_gradN.template segment<DisplacementDim>(0) += dNidx * w;
 
        if (is_axially_symmetric)
        {
            auto const x_coord =
                NumLib::interpolateXCoordinate<ShapeFunction,
                                               ShapeMatricesType>(element, N);
            bar_gradN[2] += w * N(local_node_id) / x_coord;
        }
    }
    return bar_gradN;
}

References NumLib::GenericIntegrationMethod::getNumberOfPoints(), interpolateXCoordinate(), and N.

Referenced by ProcessLib::LinearBMatrix::computeDilatationalBbar(), and ProcessLib::NonLinearFbar::computeFBarInitialVariablesAverage().

◆ canReduceTimestepSize()

bool NumLib::canReduceTimestepSize	(	TimeStep const &	timestep_previous,
		TimeStep const &	timestep_current,
		double const	min_dt )

Definition at line 34 of file TimeStepAlgorithm.cpp.

{
    return !(timestep_current.dt() == min_dt &&
             timestep_previous.dt() == min_dt);
}

References NumLib::TimeStep::dt().

Referenced by NumLib::EvolutionaryPIDcontroller::canReduceTimestepSize(), and NumLib::IterationNumberBasedTimeStepping::canReduceTimestepSize().

◆ checkLocalCouplingParameters()

template<typename ProcessData>

void NumLib::checkLocalCouplingParameters	(	std::vector< std::unique_ptr< ProcessData > > const &	per_process_data,
		std::vector< LocalCouplingParameters > const &	all_local_coupling_parameters )

Definition at line 17 of file CreateStaggeredCoupling-impl.h.

{
    // Check whether the process names in the sub-coupling definitions exist in
    // the process data.
    for (auto const& local_coupling_parameters : all_local_coupling_parameters)
    {
        for (auto const& process_name : local_coupling_parameters.process_names)
        {
            if (std::none_of(
                    per_process_data.begin(),
                    per_process_data.end(),
                    [&process_name](auto const& process_data)
                    { return process_data->process_name == process_name; }))
            {
                OGS_FATAL(
                    "The given process name '{}' for the element "
                    "'time_loop/global_process_coupling/"
                    "local_coupling_processes/process_name' is not found "
                    "in the element 'time_loop/global_process_coupling/"
                    "local_coupling_processes/process_name' in the project "
                    "file.",
                    process_name);
            }
        }
    }
}

References OGS_FATAL.

Referenced by createCouplingNodes().

◆ checkRelativeTolerance()

bool NumLib::checkRelativeTolerance	(	double const	reltol,
		double const	numerator,
		double const	denominator )

Returns if |numerator/denominator| < |reltol|. This method copes with the case that denominator = 0 by always adding epsilon to the denominator.

Definition at line 41 of file ConvergenceCriterion.cpp.

{
    auto const eps = std::numeric_limits<double>::epsilon();
    return std::abs(numerator) <
           std::abs(reltol) * (std::abs(denominator) + eps);
}

Referenced by NumLib::ConvergenceCriterionDeltaX::checkDeltaX(), NumLib::ConvergenceCriterionPerComponentDeltaX::checkDeltaX(), NumLib::ConvergenceCriterionPerComponentResidual::checkResidual(), and NumLib::ConvergenceCriterionResidual::checkResidual().

◆ cleanupGlobalMatrixProviders()

void NumLib::cleanupGlobalMatrixProviders ( )

Definition at line 22 of file GlobalMatrixProviders.cpp.

{
    globalSetupGlobalMatrixVectorProvider->clear();
}

References globalSetupGlobalMatrixVectorProvider.

Referenced by ApplicationsLib::LinearSolverLibrarySetup::~LinearSolverLibrarySetup().

◆ computeFluxCorrectedTransport()

void NumLib::computeFluxCorrectedTransport	(	NumericalStabilization const &	stabilizer,
		const double	t,
		const double	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	x_prev,
		int const	process_id,
		const MathLib::MatrixSpecifications &	matrix_specification,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b )

Definition at line 542 of file FluxCorrectedTransport.cpp.

{
    // if needed, calling the Flux-Corrected-Transport function
    return std::visit(
        [&](auto&& stabilizer)
        {
            using Stabilizer = std::decay_t<decltype(stabilizer)>;
            if constexpr (std::is_same_v<Stabilizer,
                                         NumLib::FluxCorrectedTransport>)
            {
                return detail::calculateFluxCorrectedTransport(
                    t, dt, x, x_prev, process_id, matrix_specification, M, K,
                    b);
            }
        },
        stabilizer);
}

References NumLib::detail::calculateFluxCorrectedTransport().

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess().

◆ computeHydrodynamicDispersion()

Eigen::MatrixXd NumLib::computeHydrodynamicDispersion	(	NumericalStabilization const &	stabilizer,
		std::size_t const	element_id,
		Eigen::MatrixXd const &	pore_diffusion_coefficient,
		Eigen::VectorXd const &	velocity,
		double const	porosity,
		double const	solute_dispersivity_transverse,
		double const	solute_dispersivity_longitudinal )

inline

Definition at line 65 of file HydrodynamicDispersion.h.

{
    return std::visit(
        [&](auto&& stabilizer)
        {
            using Stabilizer = std::decay_t<decltype(stabilizer)>;
            if constexpr (std::is_same_v<Stabilizer,
                                         IsotropicDiffusionStabilization>)
            {
                return detail::getHydrodynamicDispersionWithArtificialDiffusion(
                    stabilizer,
                    element_id,
                    pore_diffusion_coefficient,
                    velocity,
                    porosity,
                    solute_dispersivity_transverse,
                    solute_dispersivity_longitudinal);
            }
 
            return detail::getHydrodynamicDispersion(
                pore_diffusion_coefficient,
                velocity,
                porosity,
                solute_dispersivity_transverse,
                solute_dispersivity_longitudinal);
        },
        stabilizer);
}

References NumLib::detail::getHydrodynamicDispersion(), and NumLib::detail::getHydrodynamicDispersionWithArtificialDiffusion().

Referenced by ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleBlockMatrices(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleComponentTransportEquation(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleWithJacobianComponentTransportEquation(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtMolarFlux(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getThermalConductivityDispersivity(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getThermalConductivityDispersivity(), and ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveRelations().

◆ computeShapeMatrices()

template<typename ShapeFunction, typename ShapeMatricesType, int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL, typename PointContainer>

std::vector< typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator< typename ShapeMatricesType::ShapeMatrices > > NumLib::computeShapeMatrices	(	MeshLib::Element const &	e,
		bool const	is_axially_symmetric,
		PointContainer const &	points )

Definition at line 20 of file InitShapeMatrices.h.

{
    std::vector<
        typename ShapeMatricesType::ShapeMatrices,
        Eigen::aligned_allocator<typename ShapeMatricesType::ShapeMatrices>>
        shape_matrices;
 
    auto const fe =
        createIsoparametricFiniteElement<ShapeFunction, ShapeMatricesType>(e);
 
    shape_matrices.reserve(points.size());
    for (auto const& p : points)
    {
        shape_matrices.emplace_back(ShapeFunction::DIM, GlobalDim,
                                    ShapeFunction::NPOINTS);
        fe.template computeShapeFunctions<SelectedShapeMatrixType>(
            p.data(), shape_matrices.back(), GlobalDim, is_axially_symmetric);
    }
 
    return shape_matrices;
}

References createIsoparametricFiniteElement().

Referenced by ProcessLib::PythonBoundaryConditionLocalAssembler< ShapeFunction, LowerOrderShapeFunction, GlobalDim >::computeLowerOrderShapeMatrix(), NumLib::TemplateIsoparametric< ShapePoint1, T_SHAPE_MATRIX_POLICY< ShapePoint1 > >::computeShapeFunctions(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::SteadyStateDiffusion::LocalAssemblerData< ShapeFunction, GlobalDim >::getFlux(), initShapeMatrices(), initShapeMatricesAtElementCenter(), and interpolateToHigherOrderNodes().

◆ computeSparsityPattern()

GlobalSparsityPattern NumLib::computeSparsityPattern	(	LocalToGlobalIndexMap const &	dof_table,
		MeshLib::Mesh const &	mesh )

Computes a sparsity pattern for the given inputs.

Parameters

dof_table	maps mesh nodes to global indices
mesh	mesh for which the two parameters above are defined

Returns: The computed sparsity pattern.

Definition at line 69 of file ComputeSparsityPattern.cpp.

{
#ifdef USE_PETSC
    return computeSparsityPatternPETSc(dof_table, mesh);
#else
    return computeSparsityPatternNonPETSc(dof_table, mesh);
#endif
}

References computeSparsityPatternPETSc().

Referenced by ProcessLib::Process::computeSparsityPattern(), ProcessLib::HMPhaseField::HMPhaseFieldProcess< DisplacementDim >::constructDofTable(), ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::constructDofTable(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::constructDofTable(), and ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::constructDofTable().

◆ createConvergenceCriterion()

std::unique_ptr< ConvergenceCriterion > NumLib::createConvergenceCriterion ( const BaseLib::ConfigTree & config )

Creates a convergence criterion from the given configuration.

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__type

Definition at line 15 of file ConvergenceCriterion.cpp.

{
    auto const type = config.peekConfigParameter<std::string>("type");
 
    if (type == "DeltaX")
    {
        return createConvergenceCriterionDeltaX(config);
    }
    if (type == "Residual")
    {
        return createConvergenceCriterionResidual(config);
    }
    if (type == "PerComponentDeltaX")
    {
        return createConvergenceCriterionPerComponentDeltaX(config);
    }
    if (type == "PerComponentResidual")
    {
        return createConvergenceCriterionPerComponentResidual(config);
    }
 
    OGS_FATAL("There is no convergence criterion of type `{:s}'.", type);
}

References createConvergenceCriterionDeltaX(), createConvergenceCriterionPerComponentDeltaX(), createConvergenceCriterionPerComponentResidual(), createConvergenceCriterionResidual(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by ProcessLib::createPerProcessData().

◆ createConvergenceCriterionDeltaX()

std::unique_ptr< ConvergenceCriterionDeltaX > NumLib::createConvergenceCriterionDeltaX ( const BaseLib::ConfigTree & config )

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__DeltaX__abstol

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__DeltaX__reltol

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__DeltaX__norm_type

Definition at line 54 of file ConvergenceCriterionDeltaX.cpp.

{
    config.checkConfigParameter("type", "DeltaX");
    auto abstol = config.getConfigParameterOptional<double>("abstol");
    auto reltol = config.getConfigParameterOptional<double>("reltol");
    auto const norm_type_str =
        config.getConfigParameter<std::string>("norm_type");
    auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
 
    if (norm_type == MathLib::VecNormType::INVALID)
    {
        OGS_FATAL("Unknown vector norm type `{:s}'.", norm_type_str);
    }
 
    return std::make_unique<ConvergenceCriterionDeltaX>(
        std::move(abstol), std::move(reltol), norm_type);
}

References BaseLib::ConfigTree::checkConfigParameter(), MathLib::convertStringToVecNormType(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), MathLib::INVALID, and OGS_FATAL.

Referenced by createConvergenceCriterion().

◆ createConvergenceCriterionPerComponentDeltaX()

std::unique_ptr< ConvergenceCriterionPerComponentDeltaX > NumLib::createConvergenceCriterionPerComponentDeltaX ( const BaseLib::ConfigTree & config )

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__abstols

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__reltols

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__damping_alpha

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__norm_type

Definition at line 126 of file ConvergenceCriterionPerComponentDeltaX.cpp.

{
    config.checkConfigParameter("type", "PerComponentDeltaX");
 
    auto abstols =
        config.getConfigParameterOptional<std::vector<double>>("abstols");
    auto reltols =
        config.getConfigParameterOptional<std::vector<double>>("reltols");
    auto damping_alpha =
        config.getConfigParameterOptional<std::vector<double>>("damping_alpha");
    auto const norm_type_str =
        config.getConfigParameter<std::string>("norm_type");
 
    bool damping_alpha_switch = true;
    if ((!abstols) && (!reltols))
    {
        OGS_FATAL(
            "At least one of absolute or relative tolerance has to be "
            "specified.");
    }
    if (!abstols)
    {
        abstols = std::vector<double>(reltols->size());
    }
    else if (!reltols)
    {
        reltols = std::vector<double>(abstols->size());
    }
    if (!damping_alpha)
    {
        damping_alpha = std::vector<double>(abstols->size(), 0.0);
        damping_alpha_switch = false;
    }
 
    auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
 
    if (norm_type == MathLib::VecNormType::INVALID)
    {
        OGS_FATAL("Unknown vector norm type `{:s}'.", norm_type_str);
    }
 
    return std::make_unique<ConvergenceCriterionPerComponentDeltaX>(
        std::move(*abstols), std::move(*reltols), std::move(*damping_alpha),
        damping_alpha_switch, norm_type);
}

References BaseLib::ConfigTree::checkConfigParameter(), MathLib::convertStringToVecNormType(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), MathLib::INVALID, and OGS_FATAL.

Referenced by createConvergenceCriterion().

◆ createConvergenceCriterionPerComponentResidual()

std::unique_ptr< ConvergenceCriterionPerComponentResidual > NumLib::createConvergenceCriterionPerComponentResidual ( const BaseLib::ConfigTree & config )

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__abstols

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__reltols

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__damping_alpha

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__norm_type

Definition at line 162 of file ConvergenceCriterionPerComponentResidual.cpp.

{
    config.checkConfigParameter("type", "PerComponentResidual");
 
    auto abstols =
        config.getConfigParameterOptional<std::vector<double>>("abstols");
    auto reltols =
        config.getConfigParameterOptional<std::vector<double>>("reltols");
    auto damping_alpha =
        config.getConfigParameterOptional<std::vector<double>>("damping_alpha");
    auto const norm_type_str =
        config.getConfigParameter<std::string>("norm_type");
 
    bool damping_alpha_switch = true;
    if ((!abstols) && (!reltols))
    {
        OGS_FATAL(
            "At least one of absolute or relative tolerance has to be "
            "specified.");
    }
    if (!abstols)
    {
        abstols = std::vector<double>(reltols->size());
    }
    else if (!reltols)
    {
        reltols = std::vector<double>(abstols->size());
    }
    if (!damping_alpha)
    {
        damping_alpha = std::vector<double>(abstols->size(), 0.0);
        damping_alpha_switch = false;
    }
 
    auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
 
    if (norm_type == MathLib::VecNormType::INVALID)
    {
        OGS_FATAL("Unknown vector norm type `{:s}'.", norm_type_str);
    }
 
    return std::make_unique<ConvergenceCriterionPerComponentResidual>(
        std::move(*abstols), std::move(*reltols), std::move(*damping_alpha),
        damping_alpha_switch, norm_type);
}

References BaseLib::ConfigTree::checkConfigParameter(), MathLib::convertStringToVecNormType(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), MathLib::INVALID, and OGS_FATAL.

Referenced by createConvergenceCriterion().

◆ createConvergenceCriterionResidual()

std::unique_ptr< ConvergenceCriterionResidual > NumLib::createConvergenceCriterionResidual ( const BaseLib::ConfigTree & config )

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__Residual__abstol

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__Residual__reltol

Input File Parameter: prj__time_loop__processes__process__convergence_criterion__Residual__norm_type

Definition at line 88 of file ConvergenceCriterionResidual.cpp.

{
    config.checkConfigParameter("type", "Residual");
    auto abstol = config.getConfigParameterOptional<double>("abstol");
    auto reltol = config.getConfigParameterOptional<double>("reltol");
    auto const norm_type_str =
        config.getConfigParameter<std::string>("norm_type");
    auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
 
    if (norm_type == MathLib::VecNormType::INVALID)
    {
        OGS_FATAL("Unknown vector norm type `{:s}'.", norm_type_str);
    }
 
    return std::make_unique<ConvergenceCriterionResidual>(
        std::move(abstol), std::move(reltol), norm_type);
}

References BaseLib::ConfigTree::checkConfigParameter(), MathLib::convertStringToVecNormType(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), MathLib::INVALID, and OGS_FATAL.

Referenced by createConvergenceCriterion().

◆ createCouplingNodes()

template<typename ProcessData>

std::vector< CouplingNodeVariant > NumLib::createCouplingNodes	(	std::vector< std::unique_ptr< ProcessData > > const &	per_process_data,
		std::vector< LocalCouplingParameters > const &	all_local_coupling_parameters,
		int const	global_max_coupling_iterations,
		std::vector< std::unique_ptr< NumLib::ConvergenceCriterion > > &	global_coupling_conv_criteria )

Definition at line 137 of file CreateStaggeredCoupling-impl.h.

{
    checkLocalCouplingParameters(per_process_data,
                                 all_local_coupling_parameters);
 
    // First, get the coupling nodes that do not have local-coupling nodes.
    std::vector<CouplingNodeVariant> coupling_nodes =
        createRegularCouplingNodes(
            per_process_data, all_local_coupling_parameters,
            global_max_coupling_iterations, global_coupling_conv_criteria);
 
    // Second, get the coupling nodes that have local-coupling nodes.
    std::vector<CouplingNodeVariant> root_coupling_nodes =
        createRootCouplingNodes(per_process_data, all_local_coupling_parameters,
                                global_max_coupling_iterations,
                                global_coupling_conv_criteria);
 
    std::size_t const num_coupling_nodes =
        coupling_nodes.size() +
        std::accumulate(
            root_coupling_nodes.begin(),
            root_coupling_nodes.end(),
            std::size_t{0},
            [](std::size_t accumulated_sizes, const auto& coupling_node)
            {
                return accumulated_sizes +
                       std::get<RootCouplingNode>(coupling_node)
                           .sub_coupling_nodes.size();
            });
 
    if (num_coupling_nodes != per_process_data.size())
    {
        OGS_FATAL(
            "The number of all coupling nodes including sub-nodes is not "
            "identical to the number of the processes! Please check the "
            "element by tag global_process_coupling in the project file.");
    }
 
    if (coupling_nodes.empty())
    {
        coupling_nodes = std::move(root_coupling_nodes);
    }
    else
    {
        coupling_nodes.reserve(coupling_nodes.size() +
                               root_coupling_nodes.size());
 
        std::move(std::begin(root_coupling_nodes),
                  std::end(root_coupling_nodes),
                  std::back_inserter(coupling_nodes));
    }
 
    return coupling_nodes;
}

References checkLocalCouplingParameters(), createRegularCouplingNodes(), createRootCouplingNodes(), and OGS_FATAL.

Referenced by createStaggeredCoupling().

◆ createEvolutionaryPIDcontroller()

std::unique_ptr< TimeStepAlgorithm > NumLib::createEvolutionaryPIDcontroller	(	EvolutionaryPIDcontrollerParameters const &	config,
		std::vector< double > const &	fixed_times_for_output )

Create an EvolutionaryPIDcontroller time stepper from the given configuration

Definition at line 44 of file CreateEvolutionaryPIDcontroller.cpp.

{
    if (config.t_end < config.t0)
    {
        OGS_FATAL(
            "Evolutionary PID controller timestepping: end time ({}) is "
            "smaller than initial time ({})",
            config.t_end,
            config.t0);
    }
 
    return std::make_unique<EvolutionaryPIDcontroller>(config.t0,
                                                       config.t_end,
                                                       config.h0,
                                                       config.h_min,
                                                       config.h_max,
                                                       config.rel_h_min,
                                                       config.rel_h_max,
                                                       config.tol,
                                                       fixed_times_for_output);
}

References NumLib::EvolutionaryPIDcontrollerParameters::h0, NumLib::EvolutionaryPIDcontrollerParameters::h_max, NumLib::EvolutionaryPIDcontrollerParameters::h_min, OGS_FATAL, NumLib::EvolutionaryPIDcontrollerParameters::rel_h_max, NumLib::EvolutionaryPIDcontrollerParameters::rel_h_min, NumLib::EvolutionaryPIDcontrollerParameters::t0, NumLib::EvolutionaryPIDcontrollerParameters::t_end, and NumLib::EvolutionaryPIDcontrollerParameters::tol.

Referenced by createTimeStepper().

◆ createFixedTimeStepping()

std::unique_ptr< TimeStepAlgorithm > NumLib::createFixedTimeStepping	(	FixedTimeSteppingParameters const &	parameters,
		std::vector< double > const &	fixed_times_for_output )

Definition at line 78 of file CreateFixedTimeStepping.cpp.

{
    if (parameters.t_end < parameters.t_initial)
    {
        OGS_FATAL(
            "fixed timestepping: end time ({}) is smaller than initial time "
            "({})",
            parameters.t_end,
            parameters.t_initial);
    }
 
    if (!FixedTimeStepping::areRepeatDtPairsValid(parameters.repeat_dt_pairs))
    {
        OGS_FATAL(
            "CreateFixedTimeStepping: invalid specification of (repeat, "
            "delta_t) pairs");
    }
 
    return std::make_unique<FixedTimeStepping>(parameters.t_initial,
                                               parameters.t_end,
                                               parameters.repeat_dt_pairs,
                                               fixed_times_for_output);
}

References NumLib::FixedTimeStepping::areRepeatDtPairsValid(), OGS_FATAL, NumLib::FixedTimeSteppingParameters::repeat_dt_pairs, NumLib::FixedTimeSteppingParameters::t_end, and NumLib::FixedTimeSteppingParameters::t_initial.

Referenced by createTimeStepper().

◆ createIsoparametricFiniteElement()

template<typename ShapeFunction, typename ShapeMatricesType>

NumLib::TemplateIsoparametric< ShapeFunction, ShapeMatricesType > NumLib::createIsoparametricFiniteElement ( MeshLib::Element const & e )

Creates a TemplateIsoparametric element for the given shape functions and the underlying mesh element.

Definition at line 152 of file TemplateIsoparametric.h.

{
    using FemType =
        NumLib::TemplateIsoparametric<ShapeFunction, ShapeMatricesType>;
 
    return FemType{e};
}

Referenced by ProcessLib::BoundaryConditionAndSourceTerm::Python::BcAndStLocalAssemblerImpl< BcOrStData, ShapeFunction, LowerOrderShapeFunction, GlobalDim >::assemble(), computeShapeMatrices(), ProcessLib::computeShapeMatrix(), interpolateCoordinates(), interpolateXCoordinate(), and ApplicationUtils::ComputeNaturalCoordsRootFindingProblem< ShapeFunction >::updateShp().

◆ createIterationNumberBasedTimeStepping()

std::unique_ptr< TimeStepAlgorithm > NumLib::createIterationNumberBasedTimeStepping	(	IterationNumberBasedTimeSteppingParameters &&	parameters,
		std::vector< double > const &	fixed_times_for_output )

Create a IterationNumberBasedTimeStepping time stepper from the given configuration.

Definition at line 70 of file CreateIterationNumberBasedTimeStepping.cpp.

{
    if (parameters.t_end < parameters.t_initial)
    {
        OGS_FATAL(
            "iteration number based timestepping: end time ({}) is smaller "
            "than initial time ({})",
            parameters.t_end,
            parameters.t_initial);
    }
 
    return std::make_unique<IterationNumberBasedTimeStepping>(
        parameters.t_initial, parameters.t_end, parameters.minimum_dt,
        parameters.maximum_dt, parameters.initial_dt,
        parameters.multiplier_interpolation_type,
        std::move(parameters.number_iterations),
        std::move(parameters.multiplier), fixed_times_for_output);
}

References OGS_FATAL.

Referenced by createTimeStepper().

◆ createNewtonRaphsonSolverParameters()

NewtonRaphsonSolverParameters NumLib::createNewtonRaphsonSolverParameters ( BaseLib::ConfigTree const & config )

Input File Parameter: nonlinear_solver__maximum_iterations

Input File Parameter: nonlinear_solver__error_tolerance

Input File Parameter: nonlinear_solver__residuum_tolerance

Input File Parameter: nonlinear_solver__increment_tolerance

Definition at line 11 of file CreateNewtonRaphsonSolverParameters.cpp.

{
    DBUG("Create local nonlinear solver parameters.");
    auto const maximum_iterations =
        config.getConfigParameter<int>("maximum_iterations");
 
    DBUG("\tmaximum_iterations: {:d}.", maximum_iterations);
 
    auto const error_tolerance =
        config.getConfigParameterOptional<double>("error_tolerance");
    if (error_tolerance)
    {
        WARN(
            "The 'error_tolerance' tag for the Newton-Raphson solver is "
            "deprecated.\n"
            "Use new tags 'residuum_tolerance' and 'increment_tolerance'.\n"
            "For now we use residuum_tolerance {} and increment_tolerance 0.",
            *error_tolerance);
        return {maximum_iterations, *error_tolerance, 0};
    }
 
    auto const residuum_tolerance =
        config.getConfigParameter<double>("residuum_tolerance");
 
    DBUG("\tresiduum_tolerance: {:g}.", residuum_tolerance);
 
    auto const increment_tolerance =
        config.getConfigParameter<double>("increment_tolerance");
 
    DBUG("\tincrement_tolerance: {:g}.", increment_tolerance);
 
    return {maximum_iterations, residuum_tolerance, increment_tolerance};
}

References DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), and WARN().

Referenced by MaterialLib::Fracture::createCoulomb(), MaterialLib::Solids::Creep::createCreepBGRa(), MaterialLib::Solids::Ehlers::createEhlers(), MaterialLib::Solids::Lubby2::createLubby2(), and ProcessLib::RichardsMechanics::createRichardsMechanicsProcess().

◆ createNumericalStabilization()

NumericalStabilization NumLib::createNumericalStabilization	(	MeshLib::Mesh const &	mesh,
		BaseLib::ConfigTree const &	config )

Input File Parameter: prj__processes__process__numerical_stabilization

Input File Parameter: prj__processes__process__numerical_stabilization__type

Input File Parameter: prj__processes__process__numerical_stabilization__IsotropicDiffusion__cutoff_velocity

Input File Parameter: prj__processes__process__numerical_stabilization__IsotropicDiffusion__tuning_parameter

Input File Parameter: prj__processes__process__numerical_stabilization__FullUpwind__cutoff_velocity

Input File Parameter: prj__processes__process__numerical_stabilization__FluxCorrectedTransport

Definition at line 14 of file CreateNumericalStabilization.cpp.

{
    auto const stabilization_config =
        config.getConfigSubtreeOptional("numerical_stabilization");
    if (!stabilization_config)
    {
        return NoStabilization{};
    }
 
    auto const type =
        stabilization_config->getConfigParameter<std::string>("type");
 
    INFO("Using {:s} numerical stabilization.", type);
    if (type == "IsotropicDiffusion")
    {
        auto const cutoff_velocity =
            stabilization_config->getConfigParameter<double>("cutoff_velocity");
 
        auto const tuning_parameter =
            stabilization_config->getConfigParameter<double>(
                "tuning_parameter");
 
        return IsotropicDiffusionStabilization{
            cutoff_velocity, tuning_parameter,
            MeshLib::getMaxiumElementEdgeLengths(mesh.getElements())};
    }
    if (type == "FullUpwind")
    {
        auto const cutoff_velocity =
            stabilization_config->getConfigParameter<double>("cutoff_velocity");
 
        return FullUpwind{cutoff_velocity};
    }
    if (type == "FluxCorrectedTransport")
    {
        return FluxCorrectedTransport();
    }
 
    OGS_FATAL("The stabilization type {:s} is not available.", type);
}

References BaseLib::ConfigTree::getConfigSubtreeOptional(), MeshLib::Mesh::getElements(), MeshLib::getMaxiumElementEdgeLengths(), INFO(), and OGS_FATAL.

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HT::createHTProcess(), and ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess().

◆ createRegularCouplingNodes()

template<typename ProcessData>

std::vector< CouplingNodeVariant > NumLib::createRegularCouplingNodes	(	std::vector< std::unique_ptr< ProcessData > > const &	per_process_data,
		std::vector< LocalCouplingParameters > const &	all_local_coupling_parameters,
		int const	global_max_coupling_iterations,
		std::vector< std::unique_ptr< NumLib::ConvergenceCriterion > > &	global_coupling_conv_criteria )

Create coupling nodes that do not have local-coupling nodes.

Definition at line 48 of file CreateStaggeredCoupling-impl.h.

{
    std::vector<CouplingNodeVariant> coupling_nodes;
 
    for (auto const& process_data : per_process_data)
    {
        auto const& process_name = process_data->process_name;
 
        // If process_data->process_name occurs in local_coupling_parameters
        // do nothing
        if (std::any_of(
                all_local_coupling_parameters.begin(),
                all_local_coupling_parameters.end(),
                [&process_name](auto const& local_coupling_parameters)
                {
                    auto const& process_names =
                        local_coupling_parameters.process_names;
                    return std::find(process_names.begin(), process_names.end(),
                                     process_name) != process_names.end();
                }))
        {
            continue;
        }
 
        std::string const used_process_name =
            process_name.empty() ? "not given" : process_name;
        CouplingNode regular_node{
            used_process_name,
            std::move(global_coupling_conv_criteria[process_data->process_id]),
            global_max_coupling_iterations,
            process_data->process_id,
        };
        coupling_nodes.emplace_back(std::move(regular_node));
    }
 
    return coupling_nodes;
}

Referenced by createCouplingNodes().

◆ createRootCouplingNodes()

template<typename ProcessData>

std::vector< CouplingNodeVariant > NumLib::createRootCouplingNodes	(	std::vector< std::unique_ptr< ProcessData > > const &	per_process_data,
		std::vector< LocalCouplingParameters > const &	all_local_coupling_parameters,
		int const	global_max_coupling_iterations,
		std::vector< std::unique_ptr< NumLib::ConvergenceCriterion > > &	global_coupling_conv_criteria )

Create coupling nodes that have local-coupling nodes.

Definition at line 93 of file CreateStaggeredCoupling-impl.h.

{
    std::vector<CouplingNodeVariant> coupling_nodes;
 
    for (auto const& local_coupling_parameters : all_local_coupling_parameters)
    {
        RootCouplingNode root_node = {global_max_coupling_iterations, {}};
 
        for (auto const& local_process_name :
             local_coupling_parameters.process_names)
        {
            if (auto it = std::find_if(
                    per_process_data.begin(),
                    per_process_data.end(),
                    [&local_process_name](auto const& process_data) {
                        return process_data->process_name == local_process_name;
                    });
                it != per_process_data.end())
            {
                auto const& process_data = *it;
 
                CouplingNode regular_node{
                    process_data->process_name,
                    std::move(global_coupling_conv_criteria[process_data
                                                                ->process_id]),
                    local_coupling_parameters.max_iterations,
                    process_data->process_id};
 
                root_node.sub_coupling_nodes.emplace_back(
                    std::move(regular_node));
            }
        }
        coupling_nodes.emplace_back(std::move(root_node));
    }
 
    return coupling_nodes;
}

References NumLib::RootCouplingNode::sub_coupling_nodes.

Referenced by createCouplingNodes().

◆ createStaggeredCoupling()

template<typename ProcessData>

std::unique_ptr< StaggeredCoupling > NumLib::createStaggeredCoupling	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ProcessData > > const &	per_process_data )

Create a StaggeredCoupling instance from the given configuration.

Definition at line 199 of file CreateStaggeredCoupling-impl.h.

{
    auto [global_coupling_conv_criteria, all_local_coupling_parameters,
          max_coupling_iterations] = parseCoupling(config);
 
    if (per_process_data.size() != global_coupling_conv_criteria.size())
    {
        OGS_FATAL(
            "The number of convergence criteria of the global "
            "staggered coupling loop is not identical to the number of the "
            "processes! Please check the element by tag "
            "global_process_coupling in the project file.");
    }
 
    auto coupling_nodes = createCouplingNodes(
        per_process_data, all_local_coupling_parameters,
        max_coupling_iterations, global_coupling_conv_criteria);
 
    return std::make_unique<StaggeredCoupling>(max_coupling_iterations,
                                               std::move(coupling_nodes));
}

References createCouplingNodes(), OGS_FATAL, and parseCoupling().

Referenced by ProcessLib::createTimeLoop().

◆ createTimeDiscretization()

std::unique_ptr< TimeDiscretization > NumLib::createTimeDiscretization ( BaseLib::ConfigTree const & config )

Input File Parameter: prj__time_loop__processes__process__time_discretization__type

Input File Parameter: prj__time_loop__processes__process__time_discretization__BackwardEuler

Definition at line 12 of file TimeDiscretizationBuilder.cpp.

{
    auto const type = config.getConfigParameter<std::string>("type");
    if (type == "BackwardEuler")
    {
        return std::make_unique<BackwardEuler>();
    }
    OGS_FATAL("Unrecognized time discretization type `{:s}'", type);
}

References BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by ProcessLib::createPerProcessData().

◆ createTimeStepper()

std::unique_ptr< TimeStepAlgorithm > NumLib::createTimeStepper	(	BaseLib::ConfigTree const &	config,
		std::vector< double > const &	fixed_times_for_output )

Input File Parameter: prj__time_loop__processes__process__time_stepping__type

Input File Parameter: prj__time_loop__processes__process__time_stepping__SingleStep

Definition at line 18 of file CreateTimeStepper.cpp.

{
    auto const type = config.peekConfigParameter<std::string>("type");
 
    if (type == "SingleStep")
    {
        config.ignoreConfigParameter("type");
        return std::make_unique<NumLib::FixedTimeStepping>(0.0, 1.0, 1.0);
    }
    if (type == "FixedTimeStepping")
    {
        return NumLib::createFixedTimeStepping(parseFixedTimeStepping(config),
                                               fixed_times_for_output);
    }
    if (type == "EvolutionaryPIDcontroller")
    {
        return NumLib::createEvolutionaryPIDcontroller(
            parseEvolutionaryPIDcontroller(config), fixed_times_for_output);
    }
    if (type == "IterationNumberBasedTimeStepping")
    {
        return NumLib::createIterationNumberBasedTimeStepping(
            parseIterationNumberBasedTimeStepping(config),
            fixed_times_for_output);
    }
    OGS_FATAL(
        "Unknown time stepping type: '{:s}'. The available types are: "
        "\n\tSingleStep,"
        "\n\tFixedTimeStepping,"
        "\n\tEvolutionaryPIDcontroller,",
        "\n\tIterationNumberBasedTimeStepping\n",
        type.data());
}

References createEvolutionaryPIDcontroller(), createFixedTimeStepping(), createIterationNumberBasedTimeStepping(), BaseLib::ConfigTree::ignoreConfigParameter(), OGS_FATAL, parseEvolutionaryPIDcontroller(), parseFixedTimeStepping(), parseIterationNumberBasedTimeStepping(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by ProcessLib::createPerProcessData().

◆ findDeltatInterval()

std::size_t NumLib::findDeltatInterval	(	Time const &	t_initial,
		std::vector< double > const &	delta_ts,
		Time const &	fixed_output_time )

Definition at line 47 of file FixedTimeStepping.cpp.

{
    if (fixed_output_time < t_initial)
    {
        return std::numeric_limits<std::size_t>::max();
    }
 
    auto timestepper_time = t_initial;
    for (std::size_t k = 0; k < delta_ts.size(); ++k)
    {
        if (timestepper_time <= fixed_output_time &&
            fixed_output_time < timestepper_time + delta_ts[k])
        {
            return k;
        }
        timestepper_time += delta_ts[k];
    }
 
    return std::numeric_limits<std::size_t>::max();
}

Referenced by incorporateFixedTimesForOutput().

◆ findMultiplier()

double NumLib::findMultiplier	(	int const	number_iterations,
		bool const	current_time_step_is_accepted,
		std::vector< int > const &	nonlinear_iteration_numbers,
		std::vector< double > const &	multipliers,
		MultiplyerInterpolationType const	multiplier_interpolation_type )

Find a multiplier for the given number of iterations.

Definition at line 94 of file IterationNumberBasedTimeStepping.cpp.

{
    double multiplier = multipliers.front();
    switch (multiplier_interpolation_type)
    {
        case MultiplyerInterpolationType::PiecewiseLinear:
        {
            auto const& pwli = MathLib::PiecewiseLinearInterpolation(
                nonlinear_iteration_numbers, multipliers, false);
            multiplier = pwli.getValue(number_iterations);
            break;
        }
        case MultiplyerInterpolationType::PiecewiseConstant:
            auto const& piecewise_constant_interpolation =
                MathLib::PiecewiseConstantInterpolation(
                    nonlinear_iteration_numbers, multipliers);
            multiplier =
                piecewise_constant_interpolation.value(number_iterations);
            break;
    }
 
    if (!current_time_step_is_accepted && (multiplier >= 1.0))
    {
        return *std::min_element(multipliers.begin(), multipliers.end());
    }
 
    return multiplier;
}

References PiecewiseConstant, and PiecewiseLinear.

Referenced by NumLib::IterationNumberBasedTimeStepping::getNextTimeStepSize().

◆ getGlobalIndexWithTaylorHoodElement()

GlobalIndexType NumLib::getGlobalIndexWithTaylorHoodElement	(	MeshLib::NodePartitionedMesh const &	partitioned_mesh,
		std::size_t const	global_node_id,
		int const	number_of_components_at_base_node,
		int const	number_of_components_at_high_order_node,
		int const	component_id_at_base_node,
		int const	component_id_at_high_order_node,
		bool const	is_base_node )

Definition at line 314 of file MeshComponentMap.cpp.

{
    int const partition_id = partitioned_mesh.getPartitionID(global_node_id);
 
    auto const n_total_active_base_nodes_before_this_rank =
        partitioned_mesh.getNumberOfRegularBaseNodesAtRank(partition_id);
 
    auto const n_total_active_high_order_nodes_before_this_rank =
        partitioned_mesh.getNumberOfRegularHighOrderNodesAtRank(partition_id);
 
    auto const node_id_offset =
        n_total_active_base_nodes_before_this_rank +
        n_total_active_high_order_nodes_before_this_rank;
 
    auto const index_offset = n_total_active_base_nodes_before_this_rank *
                                  number_of_components_at_base_node +
                              n_total_active_high_order_nodes_before_this_rank *
                                  number_of_components_at_high_order_node;
 
    if (is_base_node)
    {
        return static_cast<GlobalIndexType>(
                   index_offset + (global_node_id - node_id_offset) *
                                      number_of_components_at_base_node) +
               component_id_at_base_node;
    }
 
    int const n_active_base_nodes_of_this_partition =
        partitioned_mesh.getNumberOfRegularBaseNodesAtRank(partition_id + 1) -
        n_total_active_base_nodes_before_this_rank;
 
    /*
        The global indices of components are numbered as what depicted below by
        assuming that the base node has three components and the high order node
        has two components:
 
        Partition     |       0       |      1       |   ...
                      --------------------------------
        Regular nodes | Base | higher | Base | higher|   ...
                      --------------------------------
                  c0  x      x         x      x          ...
                  c1  x      x         x      x          ...
                  c2  x                x                 ...
    */
    return static_cast<GlobalIndexType>(
               index_offset +
               n_active_base_nodes_of_this_partition *
                   number_of_components_at_base_node +
               (global_node_id - node_id_offset -
                n_active_base_nodes_of_this_partition) *
                   number_of_components_at_high_order_node) +
           component_id_at_high_order_node;
}

References MeshLib::NodePartitionedMesh::getNumberOfRegularBaseNodesAtRank(), MeshLib::NodePartitionedMesh::getNumberOfRegularHighOrderNodesAtRank(), and MeshLib::NodePartitionedMesh::getPartitionID().

Referenced by NumLib::MeshComponentMap::createParallelMeshComponentMap().

◆ getIndices() [1/2]

std::vector< GlobalIndexType > NumLib::getIndices	(	std::size_t const	mesh_item_id,
		NumLib::LocalToGlobalIndexMap const &	dof_table )

Returns nodal indices for the item identified by mesh_item_id from the given dof_table.

Definition at line 105 of file DOFTableUtil.cpp.

{
    assert(dof_table.size() > mesh_item_id);
    std::vector<GlobalIndexType> indices;
 
    // Local matrices and vectors will always be ordered by component
    // no matter what the order of the global matrix is.
    for (int c = 0; c < dof_table.getNumberOfGlobalComponents(); ++c)
    {
        auto const& idcs = dof_table(mesh_item_id, c).rows;
        indices.reserve(indices.size() + idcs.size());
        indices.insert(indices.end(), idcs.begin(), idcs.end());
    }
 
    return indices;
}

References NumLib::LocalToGlobalIndexMap::getNumberOfGlobalComponents(), and NumLib::LocalToGlobalIndexMap::size().

◆ getIndices() [2/2]

std::vector< GlobalIndexType > NumLib::getIndices	(	std::size_t const	variable_id,
		std::size_t const	component_id,
		std::size_t const	bulk_element_id,
		NumLib::LocalToGlobalIndexMap const &	dof_table )

Returns nodal indices for the item identified by component_item_id and variable_id and bulk_element_id from thegiven dof_table.

Definition at line 124 of file DOFTableUtil.cpp.

{
    auto const& ms =
        dof_table.getMeshSubset(variable_id, component_id).getMesh();
    std::vector<GlobalIndexType> indices;
    auto const& bulk_element = ms.getElement(bulk_element_id);
    auto const global_component =
        dof_table.getGlobalComponent(variable_id, component_id);
    auto const mesh_id = ms.getID();
 
    for (auto const node_id : bulk_element->nodes() | MeshLib::views::ids)
    {
        MeshLib::Location const loc{mesh_id, MeshLib::MeshItemType::Node,
                                    node_id};
        // TODO: possible issues on higher order meshes with first order
        // variables (e.g. pressure in HM).
        indices.push_back(dof_table.getGlobalIndex(loc, global_component));
    }
    return indices;
}

References MeshLib::Mesh::getElement(), NumLib::LocalToGlobalIndexMap::getGlobalComponent(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::MeshSubset::getMesh(), NumLib::LocalToGlobalIndexMap::getMeshSubset(), MeshLib::views::ids, and MeshLib::Node.

◆ getIntegrationMethodProvider()

DefaultIntegrationMethodProvider NumLib::getIntegrationMethodProvider ( NumLib::IntegrationOrder const integration_order )

inline

Used in template functions to get the DefaultIntegrationMethodProvider for the given integration_order.

Definition at line 48 of file IntegrationMethodProvider.h.

{
    return DefaultIntegrationMethodProvider{integration_order};
}

◆ getLocalX()

Eigen::VectorXd NumLib::getLocalX	(	std::size_t const	mesh_item_id,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_tables,
		std::vector< GlobalVector * > const &	x )

Definition at line 186 of file DOFTableUtil.cpp.

{
    Eigen::VectorXd local_x_vec;
 
    auto const n_processes = x.size();
    for (std::size_t process_id = 0; process_id < n_processes; ++process_id)
    {
        auto const indices =
            NumLib::getIndices(mesh_item_id, *dof_tables[process_id]);
        assert(!indices.empty());
        auto const last = local_x_vec.size();
        local_x_vec.conservativeResize(last + indices.size());
        auto const local_solution = x[process_id]->get(indices);
        assert(indices.size() == local_solution.size());
        local_x_vec.tail(local_solution.size()).noalias() =
            MathLib::toVector(local_solution);
    }
    return local_x_vec;
}

References getIndices(), and MathLib::toVector().

Referenced by ProcessLib::LocalAssemblerInterface::computeSecondaryVariable(), ProcessLib::LocalAssemblerInterface::postNonLinearSolver(), ProcessLib::LocalAssemblerInterface::postTimestep(), and ProcessLib::LocalAssemblerInterface::setInitialConditions().

◆ getNodalValue()

double NumLib::getNodalValue	(	GlobalVector const &	x,
		MeshLib::Location const &	location,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::size_t const	global_component_id )

Returns the value for the given location and global_component_id from the vector x.

Definition at line 95 of file DOFTableUtil.cpp.

{
    auto const index = dof_table.getGlobalIndex(location, global_component_id);
    assert(index != NumLib::MeshComponentMap::nop);
 
    return x.get(index);
}

References MathLib::EigenVector::get(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), and NumLib::MeshComponentMap::nop.

◆ getNonGhostNodalValue()

double NumLib::getNonGhostNodalValue	(	GlobalVector const &	x,
		MeshLib::Location const &	location,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::size_t const	global_component_id )

Returns the value for the given location and global_component_id from the vector x in case the node is not a ghost node. Else 0.0 is returned.

Definition at line 79 of file DOFTableUtil.cpp.

{
    auto const index = dof_table.getGlobalIndex(location, global_component_id);
    assert(index != NumLib::MeshComponentMap::nop);
 
    if (index < 0)
    {  // ghost node value
        return 0.0;
    }
 
    return x.get(index);
}

References MathLib::EigenVector::get(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), and NumLib::MeshComponentMap::nop.

Referenced by NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm().

◆ getRowColumnIndices()

LocalToGlobalIndexMap::RowColumnIndices NumLib::getRowColumnIndices	(	std::size_t const	id,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< GlobalIndexType > &	indices )

Returns row/column indices for the item identified by id from the given dof_table.

Definition at line 149 of file DOFTableUtil.cpp.

{
    assert(dof_table.size() > id);
    indices.clear();
 
    // Local matrices and vectors will always be ordered by component,
    // no matter what the order of the global matrix is.
    for (int c = 0; c < dof_table.getNumberOfGlobalComponents(); ++c)
    {
        auto const& idcs = dof_table(id, c).rows;
        indices.reserve(indices.size() + idcs.size());
        indices.insert(indices.end(), idcs.begin(), idcs.end());
    }
 
    return NumLib::LocalToGlobalIndexMap::RowColumnIndices(indices, indices);
}

References NumLib::LocalToGlobalIndexMap::getNumberOfGlobalComponents(), and NumLib::LocalToGlobalIndexMap::size().

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::getFlux(), ProcessLib::HT::HTProcess::getFlux(), ProcessLib::LiquidFlow::LiquidFlowProcess::getFlux(), and ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::getFlux().

◆ incorporateFixedTimesForOutput()

void NumLib::incorporateFixedTimesForOutput	(	NumLib::Time const	t_initial,
		NumLib::Time const	t_end,
		std::vector< double > &	delta_ts,
		std::vector< double > const &	fixed_times_for_output )

Definition at line 70 of file FixedTimeStepping.cpp.

{
    if (fixed_times_for_output.empty())
    {
        return;
    }
 
    if (auto lower_bound = std::lower_bound(
            begin(fixed_times_for_output), end(fixed_times_for_output),
            t_initial,
            [](auto const time, NumLib::Time const& initial_time)
            { return NumLib::Time(time) < initial_time; });
        lower_bound != begin(fixed_times_for_output))
    {
        WARN(
            "Request for output at times {}, but the simulation's start time "
            "is {}. Output will be skipped.",
            fmt::join(begin(fixed_times_for_output), lower_bound, ", "),
            t_initial());
    }
 
    if (auto upper_bound =
            std::upper_bound(begin(fixed_times_for_output),
                             end(fixed_times_for_output), t_end());
        upper_bound != end(fixed_times_for_output))
    {
        WARN(
            "Request for output at times {}, but simulation's end time is {}. "
            "Output will be skipped.",
            fmt::join(upper_bound, end(fixed_times_for_output), ", "),
            t_end());
    }
 
    if (delta_ts.empty())
    {
        WARN("No timesteps specified.");
        return;
    }
 
    // incorporate fixed output times into dts vector
    for (auto const fixed_time_for_output : fixed_times_for_output)
    {
        auto const interval_number = findDeltatInterval(
            t_initial, delta_ts, Time(fixed_time_for_output));
        if (interval_number == std::numeric_limits<std::size_t>::max())
        {
            WARN("Did not find interval for fixed output time {}",
                 fixed_time_for_output);
            continue;
        }
 
        auto const lower_bound = std::accumulate(
            begin(delta_ts), begin(delta_ts) + interval_number, t_initial);
        auto const upper_bound = lower_bound + delta_ts[interval_number];
        // in order to use the comparison from struct Time
        if (NumLib::Time(fixed_time_for_output) == lower_bound)
        {
            continue;
        }
        if (upper_bound == NumLib::Time(fixed_time_for_output))
        {
            continue;
        }
        delta_ts[interval_number] = fixed_time_for_output - lower_bound();
 
        delta_ts.insert(delta_ts.begin() + interval_number + 1,
                        upper_bound() - fixed_time_for_output);
    }
}

References findDeltatInterval(), and WARN().

Referenced by NumLib::FixedTimeStepping::FixedTimeStepping().

◆ initShapeMatrices()

template<typename ShapeFunction, typename ShapeMatricesType, int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL, typename IntegrationMethod>

std::vector< typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator< typename ShapeMatricesType::ShapeMatrices > > NumLib::initShapeMatrices	(	MeshLib::Element const &	e,
		bool const	is_axially_symmetric,
		IntegrationMethod const &	integration_method )

Definition at line 48 of file InitShapeMatrices.h.

{
    int const n_integration_points = integration_method.getNumberOfPoints();
 
    std::vector<MathLib::WeightedPoint> points;
    points.reserve(n_integration_points);
    for (int ip = 0; ip < n_integration_points; ++ip)
    {
        points.push_back(integration_method.getWeightedPoint(ip));
    }
 
    return computeShapeMatrices<ShapeFunction, ShapeMatricesType, GlobalDim,
                                SelectedShapeMatrixType>(
        e, is_axially_symmetric, points);
}

References computeShapeMatrices().

◆ initShapeMatricesAtElementCenter()

template<typename ShapeFunction, typename ShapeMatricesType, int GlobalDim, ShapeMatrixType SelectedShapeMatrixType = ShapeMatrixType::ALL>

ShapeMatricesType::ShapeMatrices NumLib::initShapeMatricesAtElementCenter	(	MeshLib::Element const &	e,
		bool const	is_axially_symmetric )

Definition at line 68 of file InitShapeMatrices.h.

{
    static constexpr std::array integration_points = {
        MathLib::WeightedPoint{ShapeFunction::reference_element_centre, 1.0}};
 
    auto const shape_matrices =
        computeShapeMatrices<ShapeFunction, ShapeMatricesType, GlobalDim,
                             SelectedShapeMatrixType>(e, is_axially_symmetric,
                                                      integration_points);
    return shape_matrices[0];
}

References computeShapeMatrices().

Referenced by ProcessLib::NonLinearFbar::computeFBarInitialVariablesElementCenter().

◆ interpolateCoordinates()

template<typename ShapeFunction, typename ShapeMatricesType>

std::array< double, 3 > NumLib::interpolateCoordinates	(	MeshLib::Element const &	e,
		typename ShapeMatricesType::ShapeMatrices::ShapeType const &	N )

Definition at line 93 of file InitShapeMatrices.h.

{
    auto const fe =
        createIsoparametricFiniteElement<ShapeFunction, ShapeMatricesType>(e);
 
    return fe.interpolateCoordinates(N);
}

References createIsoparametricFiniteElement(), and N.

◆ interpolateToHigherOrderNodes()

template<typename LowerOrderShapeFunction, typename HigherOrderMeshElementType, int GlobalDim, typename EigenMatrixType>

void NumLib::interpolateToHigherOrderNodes	(	MeshLib::Element const &	element,
		bool const	is_axially_symmetric,
		Eigen::MatrixBase< EigenMatrixType > const &	node_values,
		MeshLib::PropertyVector< double > &	interpolated_values_global_vector )

Interpolates scalar node_values given in lower order element nodes (e.g. the base nodes) to higher order element's nodes (e.g. quadratic nodes) and writes the result into the global property vector.

The base nodes' values are copied. For each higher order node the shape matrices are evaluated for the lower order element (the base nodes), and used for the the scalar quantity interpolation.

Definition at line 100 of file Interpolation.h.

{
    assert(dynamic_cast<HigherOrderMeshElementType const*>(&element));
    assert(node_values.cols() == 1);  // Scalar quantity only.
 
    using SF = LowerOrderShapeFunction;
    using ShapeMatricesType = ShapeMatrixPolicyType<SF, GlobalDim>;
 
    int const number_base_nodes = element.getNumberOfBaseNodes();
    int const number_all_nodes = element.getNumberOfNodes();
 
    // Copy the values for linear nodes.
    for (int n = 0; n < number_base_nodes; ++n)
    {
        std::size_t const global_index = getNodeIndex(element, n);
        interpolated_values_global_vector[global_index] = node_values[n];
    }
 
    //
    // Interpolate values for higher order nodes.
    //
 
    int const number_higher_order_nodes = number_all_nodes - number_base_nodes;
    std::vector<MathLib::Point3d> higher_order_nodes;
    higher_order_nodes.reserve(number_higher_order_nodes);
    for (int n = 0; n < number_higher_order_nodes; ++n)
    {
        higher_order_nodes.emplace_back(
            NaturalCoordinates<HigherOrderMeshElementType>::coordinates
                [number_base_nodes + n]);
    }
 
    // Shape matrices evaluated at higher order nodes' coordinates.
    auto const shape_matrices =
        computeShapeMatrices<SF, ShapeMatricesType, GlobalDim,
                             ShapeMatrixType::N>(element, is_axially_symmetric,
                                                 higher_order_nodes);
 
    for (int n = 0; n < number_higher_order_nodes; ++n)
    {
        std::size_t const global_index =
            getNodeIndex(element, number_base_nodes + n);
        interpolated_values_global_vector[global_index] =
            shape_matrices[n].N * node_values;
    }
}

References computeShapeMatrices(), MeshLib::Element::getNumberOfBaseNodes(), MeshLib::Element::getNumberOfNodes(), and N.

Referenced by ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::computeSecondaryVariableConcrete(), and ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::postTimestepConcreteWithBlockVectors().

◆ interpolateXCoordinate()

template<typename ShapeFunction, typename ShapeMatricesType>

double NumLib::interpolateXCoordinate	(	MeshLib::Element const &	e,
		typename ShapeMatricesType::ShapeMatrices::ShapeType const &	N )

Definition at line 82 of file InitShapeMatrices.h.

{
    auto const fe =
        createIsoparametricFiniteElement<ShapeFunction, ShapeMatricesType>(e);
 
    return fe.interpolateZerothCoordinate(N);
}

References createIsoparametricFiniteElement(), and N.

Referenced by averageGradShapeFunction(), ProcessLib::NonLinearFbar::computeFBarInitialVariablesElementCenter(), and ProcessLib::SmallDeformation::getMaterialForces().

◆ localDOF()

template<typename... Ns_t, typename ElementDOFVector>

auto NumLib::localDOF ( ElementDOFVector const & x )

Decomposes the passed d.o.f.s of an entire finite element into d.o.f.s belonging to individual unknowns—such as pressure, temperature, or displacement—via the passed shape functions.

Attention: The order of the passed shape functions indicates the order of the primary unknowns in the element d.o.f.s, and the order of the returned data, i.e., the order is important!

Returns: a std::tuple of mapped d.o.f. data (cf. Eigen::Map)

Definition at line 56 of file LocalDOF.h.

{
    using namespace boost::mp11;
 
    static_assert(sizeof...(Ns_t) > 0);
 
    using Sizes = mp_list_c<int, detail::NumberOfDofs<Ns_t>::value...>;
    using Offsets =
        mp_push_front<mp_pop_back<mp_partial_sum<Sizes, mp_int<0>, mp_plus>>,
                      mp_int<0>>;
 
    assert((mp_back<Offsets>::value + mp_back<Sizes>::value == x.size()) &&
           "The passed shape matrices require a different number of "
           "d.o.f.s than present in the passed element d.o.f. vector.");
 
    return detail::localDOFImpl<Ns_t...>(x, Offsets{}, Sizes{});
}

References NumLib::detail::localDOFImpl().

Referenced by ProcessLib::LargeDeformation::LargeDeformationLocalAssembler< ShapeFunction, DisplacementDim >::localDOF(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::localDOF(), ProcessLib::SmallDeformation::SmallDeformationLocalAssembler< ShapeFunction, DisplacementDim >::localDOF(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::localDOF(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::localDOF().

◆ makeExtrapolatable()

template<typename LocalAssemblerCollection, typename IntegrationPointValuesMethod>

ExtrapolatableLocalAssemblerCollection< LocalAssemblerCollection > NumLib::makeExtrapolatable	(	LocalAssemblerCollection const &	local_assemblers,
		IntegrationPointValuesMethod	integration_point_values_method )

Creates an ExtrapolatableLocalAssemblerCollection, which can be used to provide information to an Extrapolator.

Definition at line 142 of file ExtrapolatableElementCollection.h.

{
    return ExtrapolatableLocalAssemblerCollection<LocalAssemblerCollection>{
        local_assemblers, integration_point_values_method};
}

Referenced by ProcessLib::makeExtrapolator().

◆ makeNewtonRaphson()

template<typename LinearSolver, typename JacobianMatrixUpdate, typename ResidualUpdate, typename SolutionUpdate>

NewtonRaphson< LinearSolver, JacobianMatrixUpdate, ResidualUpdate, SolutionUpdate > NumLib::makeNewtonRaphson	(	LinearSolver &	linear_solver,
		JacobianMatrixUpdate &&	jacobian_update,
		ResidualUpdate &&	residual_update,
		SolutionUpdate &&	solution_update,
		NewtonRaphsonSolverParameters const &	solver_parameters )

Definition at line 143 of file NewtonRaphson.h.

{
    return NewtonRaphson<LinearSolver, JacobianMatrixUpdate, ResidualUpdate,
                         SolutionUpdate>(
        linear_solver, std::forward<JacobianMatrixUpdate>(jacobian_update),
        std::forward<ResidualUpdate>(residual_update),
        std::forward<SolutionUpdate>(solution_update), solver_parameters);
}

Referenced by ApplicationUtils::ComputeNaturalCoordsSolverImplementation< ShapeFunction >::solve().

◆ norm()

double NumLib::norm	(	GlobalVector const &	x,
		unsigned const	global_component,
		MathLib::VecNormType	norm_type,
		LocalToGlobalIndexMap const &	dof_table )

Computes the specified norm of the given global component of the given vector x.

Remarks: x is typically the solution vector of a monolithically coupled process with several primary variables.

Definition at line 169 of file DOFTableUtil.cpp.

{
    switch (norm_type)
    {
        case MathLib::VecNormType::NORM1:
            return norm1(x, global_component, dof_table);
        case MathLib::VecNormType::NORM2:
            return norm2(x, global_component, dof_table);
        case MathLib::VecNormType::INFINITY_N:
            return normInfinity(x, global_component, dof_table);
        default:
            OGS_FATAL("An invalid norm type has been passed.");
    }
}

References MathLib::INFINITY_N, MathLib::NORM1, MathLib::NORM2, and OGS_FATAL.

Referenced by NumLib::ConvergenceCriterionPerComponentDeltaX::checkDeltaX(), NumLib::ConvergenceCriterionPerComponentResidual::checkDeltaX(), NumLib::ConvergenceCriterionPerComponentResidual::checkResidual(), NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm1(), NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm2(), and NumLib::anonymous_namespace{DOFTableUtil.cpp}::normInfinity().

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [1/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Hex	,
		ShapeHex8	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [2/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Hex20	,
		ShapeHex20	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [3/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Line	,
		ShapeLine2	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [4/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Line3	,
		ShapeLine3	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [5/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Point	,
		ShapePoint1	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [6/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Prism	,
		ShapePrism6	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [7/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Prism15	,
		ShapePrism15	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [8/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Pyramid	,
		ShapePyra5	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [9/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Pyramid13	,
		ShapePyra13	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [10/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Quad	,
		ShapeQuad4	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [11/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Quad8	,
		ShapeQuad8	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [12/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Quad9	,
		ShapeQuad9	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [13/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Tet	,
		ShapeTet4	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [14/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Tet10	,
		ShapeTet10	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [15/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Tri	,
		ShapeTri3	)

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [16/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Tri6	,
		ShapeTri6	)

◆ operator<<() [1/2]

template<class T_N, class T_DNDR, class T_J, class T_DNDX>

std::ostream & NumLib::operator<<	(	std::ostream &	os,
		const ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX > &	shape )

Definition at line 120 of file ShapeMatrices-impl.h.

{
    shape.write(os);
    return os;
}

References NumLib::ShapeMatrices< T_N, T_DNDR, T_J, T_DNDX >::write().

◆ operator<<() [2/2]

std::ostream & NumLib::operator<<	(	std::ostream &	os,
		LocalToGlobalIndexMap const &	map )

Definition at line 434 of file LocalToGlobalIndexMap.cpp.

{
    std::size_t const max_lines = 10;
    std::size_t lines_printed = 0;
 
    os << "Rows of the local to global index map; " << map._rows.size()
       << " rows\n";
    for (std::size_t e = 0; e < map.size(); ++e)
    {
        os << "== e " << e << " ==\n";
        for (int c = 0; c < map.getNumberOfGlobalComponents(); ++c)
        {
            auto const& line = map._rows(e, c);
 
            os << "c" << c << " { ";
            std::copy(line.cbegin(), line.cend(),
                      std::ostream_iterator<std::size_t>(os, " "));
            os << " }\n";
        }
 
        if (lines_printed++ > max_lines)
        {
            os << "...\n";
            break;
        }
    }
 
    os << "Mesh component map:\n" << map._mesh_component_map;
    return os;
}

◆ parseCoupling()

std::tuple< std::vector< std::unique_ptr< NumLib::ConvergenceCriterion > >, std::vector< LocalCouplingParameters >, int > NumLib::parseCoupling ( BaseLib::ConfigTree const & config )

Input File Parameter: prj__time_loop__global_process_coupling

Input File Parameter: prj__time_loop__global_process_coupling__max_iter

Input File Parameter: prj__time_loop__global_process_coupling__convergence_criteria

Input File Parameter: prj__time_loop__global_process_coupling__convergence_criteria__convergence_criterion

Definition at line 97 of file CreateStaggeredCoupling.cpp.

{
    auto const& coupling_config
        = config.getConfigSubtreeOptional("global_process_coupling");
 
    std::vector<std::unique_ptr<NumLib::ConvergenceCriterion>>
        global_coupling_conv_criteria;
 
    std::vector<LocalCouplingParameters> all_local_coupling_parameters;
 
    int max_coupling_iterations = 1;
    if (coupling_config)
    {
        max_coupling_iterations
            = coupling_config->getConfigParameter<int>("max_iter");
 
        auto const& coupling_convergence_criteria_config =
            coupling_config->getConfigSubtree("convergence_criteria");
 
        auto coupling_convergence_criterion_config =
            coupling_convergence_criteria_config.getConfigSubtreeList(
                "convergence_criterion");
        std::transform(coupling_convergence_criterion_config.begin(),
                       coupling_convergence_criterion_config.end(),
                       std::back_inserter(global_coupling_conv_criteria),
                       [](BaseLib::ConfigTree const& c)
                       { return NumLib::createConvergenceCriterion(c); });
 
        all_local_coupling_parameters = parseLocalCoupling(
            *coupling_config, global_coupling_conv_criteria.size());
    }
 
    return {std::move(global_coupling_conv_criteria),
            std::move(all_local_coupling_parameters), max_coupling_iterations};
}

References BaseLib::ConfigTree::getConfigSubtreeOptional(), and parseLocalCoupling().

Referenced by createStaggeredCoupling().

◆ parseEvolutionaryPIDcontroller()

EvolutionaryPIDcontrollerParameters NumLib::parseEvolutionaryPIDcontroller ( BaseLib::ConfigTree const & config )

Parse an EvolutionaryPIDcontroller time stepper from the given configuration

Input File Parameter: prj__time_loop__processes__process__time_stepping__type

Input File Parameter: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__t_initial

Input File Parameter: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__t_end

Input File Parameter: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__dt_guess

Input File Parameter: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__dt_min

Input File Parameter: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__dt_max

Input File Parameter: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__rel_dt_min

Input File Parameter: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__rel_dt_max

Input File Parameter: prj__time_loop__processes__process__time_stepping__EvolutionaryPIDcontroller__tol

Definition at line 15 of file CreateEvolutionaryPIDcontroller.cpp.

{
    config.checkConfigParameter("type", "EvolutionaryPIDcontroller");
    auto const t0 = config.getConfigParameter<double>("t_initial");
    auto const t_end = config.getConfigParameter<double>("t_end");
    auto const h0 = config.getConfigParameter<double>("dt_guess");
    auto const h_min = config.getConfigParameter<double>("dt_min");
    auto const h_max = config.getConfigParameter<double>("dt_max");
    auto const rel_h_min = config.getConfigParameter<double>("rel_dt_min");
    auto const rel_h_max = config.getConfigParameter<double>("rel_dt_max");
    auto const tol = config.getConfigParameter<double>("tol");
 
    return {t0, t_end, h0, h_min, h_max, rel_h_min, rel_h_max, tol};
}

References BaseLib::ConfigTree::checkConfigParameter(), and BaseLib::ConfigTree::getConfigParameter().

Referenced by createTimeStepper().

◆ parseFixedTimeStepping()

FixedTimeSteppingParameters NumLib::parseFixedTimeStepping ( BaseLib::ConfigTree const & config )

Create a FixedTimeStepping time stepper from the given configuration

Input File Parameter: prj__time_loop__processes__process__time_stepping__type

Input File Parameter: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__t_initial

Input File Parameter: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__t_end

Input File Parameter: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__n_steps

Input File Parameter: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__timesteps

Input File Parameter: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__timesteps__pair

Input File Parameter: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__timesteps__pair__repeat

Input File Parameter: prj__time_loop__processes__process__time_stepping__FixedTimeStepping__timesteps__pair__delta_t

Definition at line 13 of file CreateFixedTimeStepping.cpp.

{
    config.checkConfigParameter("type", "FixedTimeStepping");
    auto const t_initial = config.getConfigParameter<double>("t_initial");
    auto const t_end = config.getConfigParameter<double>("t_end");
    auto const n_steps = config.getConfigParameterOptional<int>("n_steps");
    if (n_steps.has_value())
    {
        if (t_end <= t_initial)
        {
            OGS_FATAL(
                "Creating linearly spaced time steps vector using "
                "FixedTimeStepping algorithm failed! "
                "User provided start value (t_initial) "
                "{} is not smaller then end value (t_end) {}.",
                t_initial, t_end);
        }
 
        if (*n_steps <= 0)
        {
            OGS_FATAL(
                "Requested number of time steps in time steps vector "
                "(n_steps) must be greater then 0. "
                "{} time steps were requested",
                *n_steps);
        }
        // Create the RepeatDtPair
        double const t_step =
            (t_end - t_initial) / static_cast<double>(*n_steps);
        std::vector const repeat_pairs = {
            RepeatDtPair{static_cast<std::size_t>(*n_steps), t_step}};
        return {t_initial, t_end, repeat_pairs};
    }
    auto const delta_ts_config = config.getConfigSubtree("timesteps");
 
    // TODO: consider adding call "listNonEmpty" to config tree
    auto const range = delta_ts_config.getConfigSubtreeList("pair");
    if (range.begin() == range.end())
    {
        OGS_FATAL("no timesteps have been given");
    }
 
    std::vector<RepeatDtPair> repeat_dt_pairs;
    for (auto const pair : range)
    {
        repeat_dt_pairs.emplace_back(
            pair.getConfigParameter<std::size_t>("repeat"),
            pair.getConfigParameter<double>("delta_t"));
    }
 
    return {t_initial, t_end, repeat_dt_pairs};
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeList(), and OGS_FATAL.

Referenced by createTimeStepper().

◆ parseIterationNumberBasedTimeStepping()

IterationNumberBasedTimeSteppingParameters NumLib::parseIterationNumberBasedTimeStepping ( BaseLib::ConfigTree const & config )

Input File Parameter: prj__time_loop__processes__process__time_stepping__type

Input File Parameter: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__t_initial

Input File Parameter: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__t_end

Input File Parameter: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__initial_dt

Input File Parameter: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__minimum_dt

Input File Parameter: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__maximum_dt

Input File Parameter: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__number_iterations

Input File Parameter: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__multiplier

Input File Parameter: prj__time_loop__processes__process__time_stepping__IterationNumberBasedTimeStepping__multiplier_interpolation_type

Definition at line 17 of file CreateIterationNumberBasedTimeStepping.cpp.

{
    config.checkConfigParameter("type", "IterationNumberBasedTimeStepping");
    auto const t_initial = config.getConfigParameter<double>("t_initial");
    auto const t_end = config.getConfigParameter<double>("t_end");
    if (t_end < t_initial)
    {
        OGS_FATAL(
            "iteration number based timestepping: t_end({}) is smaller than "
            "t_initial({})",
            t_end,
            t_initial);
    }
    auto const initial_dt = config.getConfigParameter<double>("initial_dt");
    auto const minimum_dt = config.getConfigParameter<double>("minimum_dt");
    auto const maximum_dt = config.getConfigParameter<double>("maximum_dt");
 
    auto number_iterations =
        config.getConfigParameter<std::vector<int>>("number_iterations");
    auto multiplier =
        config.getConfigParameter<std::vector<double>>("multiplier");
 
    std::string const multiplier_interpolation_type_string =
        config.getConfigParameter<std::string>("multiplier_interpolation_type",
                                               "PiecewiseConstant");
    auto const multiplier_interpolation_type =
        (multiplier_interpolation_type_string == "PiecewiseLinear")
            ? MultiplyerInterpolationType::PiecewiseLinear
            : MultiplyerInterpolationType::PiecewiseConstant;
 
    return {t_initial,
            t_end,
            minimum_dt,
            maximum_dt,
            initial_dt,
            multiplier_interpolation_type,
            std::move(number_iterations),
            std::move(multiplier)};
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, PiecewiseConstant, and PiecewiseLinear.

Referenced by createTimeStepper().

◆ parseLocalCoupling()

std::vector< LocalCouplingParameters > NumLib::parseLocalCoupling	(	BaseLib::ConfigTree const &	config,
		const std::size_t	max_process_number )

The function returns a set of process names and the maximum iteration number of a sub-coupling or nothing.

Input File Parameter: prj__time_loop__global_process_coupling__local_coupling_processes

Input File Parameter: prj__time_loop__global_process_coupling__local_coupling_processes__process_name

Input File Parameter: prj__time_loop__global_process_coupling__local_coupling_processes__max_iter

Definition at line 16 of file CreateStaggeredCoupling.cpp.

{
    auto const local_coupling_configs =
        config.getConfigSubtreeList("local_coupling_processes");
 
    if (local_coupling_configs.empty())
    {
        return {};
    }
 
    std::vector<LocalCouplingParameters> all_local_coupling_parameters;
    std::vector<std::string> all_local_process_names;
    for (auto const& local_coupling_config : local_coupling_configs)
    {
        std::vector<std::string> process_names;
 
        for (
            auto name :
            local_coupling_config
                .getConfigParameterList<std::string>("process_name"))
        {
            if (std::find(process_names.begin(), process_names.end(), name) !=
                process_names.end())
            {
                OGS_FATAL(
                    "The name of locally coupled process, {}, is not unique.",
                    name);
            }
            process_names.push_back(name);
 
            all_local_process_names.push_back(name);
        }
 
        if (process_names.size() > max_process_number)
        {
            OGS_FATAL(
                "The number of the locally coupled processes is greater "
                "than the number of total coupled processes. "
                "Please check the number of elements in the tag "
                "'time_loop/global_process_coupling/"
                "local_coupling_processes' in the project file.");
        }
 
        INFO("There are {:d} locally coupled processes.", process_names.size());
 
        int max_iterations =
            local_coupling_config
                .getConfigParameter<int>("max_iter");
 
        all_local_coupling_parameters.push_back(
            {process_names, max_iterations});
    }
 
    // std::adjacent_find only finds equal elements directly next to each other.
    // Therefore, a copy of the vector is sorted first and then it is checked
    // for duplicated element.
    std::vector<std::string> copy_all_local_process_names =
        all_local_process_names;
    std::sort(copy_all_local_process_names.begin(),
              copy_all_local_process_names.end());
    if (auto it = std::adjacent_find(copy_all_local_process_names.begin(),
                                     copy_all_local_process_names.end());
        it != copy_all_local_process_names.end())
    {
        OGS_FATAL(
            "There are process names appearing in multiple tags of "
            "'time_loop/global_process_coupling/local_coupling_processes'. For "
            "example, name {}",
            *it);
    }
 
    return all_local_coupling_parameters;
}

References BaseLib::ConfigTree::getConfigSubtreeList(), INFO(), and OGS_FATAL.

Referenced by parseCoupling().

◆ possiblyClampDtToNextFixedTime()

double NumLib::possiblyClampDtToNextFixedTime	(	Time const &	t,
		double const	dt,
		std::vector< double > const &	fixed_output_times )

If any of the fixed times will be reached with given time increment, it will be reduced, otherwise the input will be returned.

Precondition: The input vector of fixed times must be sorted.

Parameters

t	Current time.
dt	Suggested time increment.
fixed_output_times	Sorted list of times which are to be reached.

Definition at line 12 of file TimeStepAlgorithm.cpp.

{
    auto const specific_time = ranges::upper_bound(
        fixed_output_times, t, ranges::less{}, [](auto t) { return Time(t); });
 
    if (specific_time == ranges::cend(fixed_output_times))
    {
        return dt;
    }
 
    Time const fixed_output_time(*specific_time);
    if ((t < fixed_output_time) && (t + dt) > fixed_output_time)
    {
        double const t_to_specific_time = fixed_output_time() - t();
        return t_to_specific_time;
    }
 
    return dt;
}

Referenced by ProcessLib::TimeLoop::generateOutputTimeStepConstraints().

◆ shapeFunctionInterpolate()

template<typename NodalValues, typename ShapeMatrix, typename... ScalarTypes>

void NumLib::shapeFunctionInterpolate	(	const NodalValues &	nodal_values,
		const ShapeMatrix &	shape_matrix_N,
		double &	interpolated_value,
		ScalarTypes &...	interpolated_values )

Interpolates variables given at element nodes according to the given shape matrix.

This function simply does the usual finite-element interpolation, i.e. multiplication of nodal values with the shape function.

Parameters

nodal_values	vector of nodal values, ordered by component
shape_matrix_N	shape matrix of the point to which will be interpolated
interpolated_value	interpolated value of the first d.o.f. (output parameter)
interpolated_values	interpolated value of further d.o.f. (output parameter)

Template Parameters

NodalValues	type of the container where nodal values are stored
ShapeMatrix	type of the shape matrix \(N\).
ScalarValues	all of the types in this pack must currently be `double`.

Note: nodal_values have to be ordered by component and it is assumed that all passed d.o.f. are single-component and are interpolated using the same shape function.

Definition at line 73 of file Interpolation.h.

{
    auto const num_nodal_dof = sizeof...(interpolated_values) + 1;
    auto const num_nodes = shape_matrix_N.size();
 
    assert(num_nodes * num_nodal_dof ==
           static_cast<std::size_t>(nodal_values.size()));
    (void)num_nodal_dof;
    (void)num_nodes;  // no warnings when not in debug build
 
    detail::shapeFunctionInterpolate<0>(nodal_values, shape_matrix_N,
                                        interpolated_value,
                                        interpolated_values...);
}

References NumLib::detail::shapeFunctionInterpolate().

◆ transformVariableFromGlobalVector() [1/2]

template<typename Functor>

void NumLib::transformVariableFromGlobalVector	(	GlobalVector const &	input_vector,
		int const	variable_id,
		NumLib::LocalToGlobalIndexMap const &	local_to_global_index_map,
		MeshLib::PropertyVector< double > &	output_vector,
		Functor	map_function )

Copies part of a global vector for the given variable into output_vector while applying a function to each value.

Attention: The output_vector is accessed through node id and component, therefore multiple meshes are not supported.

Definition at line 62 of file DOFTableUtil.h.

{
    MathLib::LinAlg::setLocalAccessibleVector(input_vector);
 
    // We fill the output with zeroes, because filling with NaN
    // "breaks" visualization, e.g. of heat or mass flow rate
    // with Taylor-Hood elements. I.e., all lower order
    // properties would have NaN on the higher order nodes.
    ranges::fill(output_vector, 0);
 
    int const n_components =
        local_to_global_index_map.getNumberOfVariableComponents(variable_id);
    for (int component = 0; component < n_components; ++component)
    {
        auto const& mesh_subset =
            local_to_global_index_map.getMeshSubset(variable_id, component);
        for (auto const& l : MeshLib::views::meshLocations(
                 mesh_subset, MeshLib::MeshItemType::Node))
        {
            auto const node_id = l.item_id;
            auto const input_index = local_to_global_index_map.getGlobalIndex(
                l, variable_id, component);
            double const value = input_vector[input_index];
 
            output_vector.getComponent(node_id, component) =
                map_function(value);
        }
    }
}

References MeshLib::PropertyVector< PROP_VAL_TYPE >::getComponent(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), NumLib::LocalToGlobalIndexMap::getMeshSubset(), NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), MeshLib::views::meshLocations(), MeshLib::Node, and MathLib::LinAlg::setLocalAccessibleVector().

◆ transformVariableFromGlobalVector() [2/2]

template<typename Functor>

void NumLib::transformVariableFromGlobalVector	(	GlobalVector const &	input_vector_on_bulk_mesh,
		int const	variable_id,
		NumLib::LocalToGlobalIndexMap const &	local_to_global_index_map,
		MeshLib::PropertyVector< double > &	output_vector_on_submesh,
		std::span< std::size_t const > const &	map_submesh_node_id_to_bulk_mesh_node_id,
		Functor	map_function )

Overload that can be used to transform and project nodal data from the bulk mesh to submeshes, e.g., for the output if residuum vectors on submeshes.

Definition at line 98 of file DOFTableUtil.h.

{
    MathLib::LinAlg::setLocalAccessibleVector(input_vector_on_bulk_mesh);
 
    // We fill the output with zeroes, because filling with NaN
    // "breaks" visualization, e.g. of heat or mass flow rate
    // with Taylor-Hood elements. I.e., all lower order
    // properties would have NaN on the higher order nodes.
    ranges::fill(output_vector_on_submesh, 0);
 
    int const n_components =
        local_to_global_index_map.getNumberOfVariableComponents(variable_id);
    for (int component = 0; component < n_components; ++component)
    {
        auto const& mesh_subset =
            local_to_global_index_map.getMeshSubset(variable_id, component);
        auto const mesh_id = mesh_subset.getMeshID();
 
        for (std::size_t submesh_node_id = 0;
             submesh_node_id < map_submesh_node_id_to_bulk_mesh_node_id.size();
             ++submesh_node_id)
        {
            std::size_t const bulk_node_id =
                map_submesh_node_id_to_bulk_mesh_node_id[submesh_node_id];
            MeshLib::Location const l(mesh_id, MeshLib::MeshItemType::Node,
                                      bulk_node_id);
            auto const input_index = local_to_global_index_map.getGlobalIndex(
                l, variable_id, component);
 
            // On higher-order meshes some d.o.f.s might not be defined on all
            // nodes. We silently ignore the d.o.f.s we cannot find.
            [[unlikely]] if (input_index == NumLib::MeshComponentMap::nop)
            {
                continue;
            }
 
            double const value = input_vector_on_bulk_mesh[input_index];
 
            output_vector_on_submesh.getComponent(submesh_node_id, component) =
                map_function(value);
        }
    }
}

References MeshLib::PropertyVector< PROP_VAL_TYPE >::getComponent(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::MeshSubset::getMeshID(), NumLib::LocalToGlobalIndexMap::getMeshSubset(), NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), MeshLib::Node, NumLib::MeshComponentMap::nop, and MathLib::LinAlg::setLocalAccessibleVector().

◆ updateTimeSteps()

void NumLib::updateTimeSteps	(	double const	dt,
		TimeStep &	previous_timestep,
		TimeStep &	current_timestep )

inline

Definition at line 101 of file TimeStep.h.

{
    previous_timestep = current_timestep;
    current_timestep += dt;
}

Referenced by ProcessLib::TimeLoop::computeTimeStepping().

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ AllElementTraitsLagrange

◆ CouplingNodeVariant

◆ MinimumPerturbation

◆ NumericalStabilization

◆ RelativeEpsilon

◆ RepeatDtPair

Enumeration Type Documentation

◆ ComponentOrder

◆ MultiplyerInterpolationType

◆ ShapeMatrixType

Function Documentation

◆ assembleAdvectionMatrix() [1/2]

◆ assembleAdvectionMatrix() [2/2]

◆ averageGradShapeFunction()

◆ canReduceTimestepSize()

◆ checkLocalCouplingParameters()

◆ checkRelativeTolerance()

◆ cleanupGlobalMatrixProviders()

◆ computeFluxCorrectedTransport()

◆ computeHydrodynamicDispersion()

◆ computeShapeMatrices()

◆ computeSparsityPattern()

◆ createConvergenceCriterion()

◆ createConvergenceCriterionDeltaX()

◆ createConvergenceCriterionPerComponentDeltaX()

◆ createConvergenceCriterionPerComponentResidual()

◆ createConvergenceCriterionResidual()

◆ createCouplingNodes()

◆ createEvolutionaryPIDcontroller()

◆ createFixedTimeStepping()

◆ createIsoparametricFiniteElement()

◆ createIterationNumberBasedTimeStepping()

◆ createNewtonRaphsonSolverParameters()

◆ createNumericalStabilization()

◆ createRegularCouplingNodes()

◆ createRootCouplingNodes()

◆ createStaggeredCoupling()

◆ createTimeDiscretization()

◆ createTimeStepper()

◆ findDeltatInterval()

◆ findMultiplier()

◆ getGlobalIndexWithTaylorHoodElement()

◆ getIndices() [1/2]

◆ getIndices() [2/2]

◆ getIntegrationMethodProvider()

◆ getLocalX()

◆ getNodalValue()

◆ getNonGhostNodalValue()

◆ getRowColumnIndices()

◆ incorporateFixedTimesForOutput()

◆ initShapeMatrices()

◆ initShapeMatricesAtElementCenter()

◆ interpolateCoordinates()

◆ interpolateToHigherOrderNodes()

◆ interpolateXCoordinate()

◆ localDOF()

◆ makeExtrapolatable()

◆ makeNewtonRaphson()

◆ norm()

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [1/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [2/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [3/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [4/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [5/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [6/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [7/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [8/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [9/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [10/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [11/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [12/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [13/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [14/16]

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [15/16]