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

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::Mesh const &mesh, NumLib::LocalToGlobalIndexMap const &dof_table, std::size_t const node_id, std::size_t const global_component_id)

double	getNodalValue (GlobalVector const &x, MeshLib::Mesh const &mesh, NumLib::LocalToGlobalIndexMap const &dof_table, std::size_t const node_id, std::size_t const global_component_id)

std::vector< GlobalIndexType >	getIndices (std::size_t const mesh_item_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, MeshLib::Mesh const &mesh)

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::vector< std::size_t > 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<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 >
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 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	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:102

Definition at line 100 of file ElementTraitsLagrange.h.

◆ CouplingNodeVariant

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

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

◆ MinimumPerturbation

using NumLib::MinimumPerturbation

Initial value:

BaseLib::StrongType<double, struct MinimumPerturbationTag>

BaseLib::StrongType

Definition StrongType.h:25

Definition at line 22 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 31 of file CreateNumericalStabilization.h.

◆ RelativeEpsilon

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

Definition at line 21 of file NumericalDifferentiation.h.

◆ RepeatDtPair

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

Definition at line 22 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 22 of file MeshComponentMap.h.

{
    BY_COMPONENT,  
    BY_LOCATION    
};

◆ 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 23 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 109 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 138 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().

◆ canReduceTimestepSize()

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

Definition at line 40 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 25 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 48 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 29 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 )

inline

Definition at line 211 of file FluxCorrectedTransport.h.

{
    // 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 71 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 25 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< ShapeFunctionType_, ShapeMatrixTypes_ >::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(), 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 74 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::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::constructDofTable(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< 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 22 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 61 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__norm_type

Definition at line 91 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 const norm_type_str =
        config.getConfigParameter<std::string>("norm_type");
 
    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());
    }
 
    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), 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__norm_type

Definition at line 128 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 const norm_type_str =
        config.getConfigParameter<std::string>("norm_type");
 
    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());
    }
 
    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), 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 95 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 145 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(),
            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 52 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 86 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 161 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(), interpolateCoordinates(), and interpolateXCoordinate().

◆ 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 66 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,
        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 17 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

Definition at line 20 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 56 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;
}

References NumLib::CouplingNode::process_id.

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 101 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::CouplingNode::process_name, and 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 207 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 19 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 26 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 54 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().

◆ 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 323 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()

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 120 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().

◆ 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 55 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 176 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::Mesh const &	mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::size_t const	node_id,
		std::size_t const	global_component_id )

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

Definition at line 106 of file DOFTableUtil.cpp.

{
    MeshLib::Location const l{mesh.getID(), MeshLib::MeshItemType::Node,
                              node_id};
 
    auto const index = dof_table.getGlobalIndex(l, global_component_id);
    assert(index != NumLib::MeshComponentMap::nop);
 
    return x.get(index);
}

References MathLib::EigenVector::get(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::Mesh::getID(), MeshLib::Node, and NumLib::MeshComponentMap::nop.

Referenced by ProcessLib::TES::TESProcess::computeEquilibriumLoading(), ProcessLib::TES::TESProcess::computeRelativeHumidity(), and ProcessLib::TES::TESProcess::computeVapourPartialPressure().

◆ getNonGhostNodalValue()

double NumLib::getNonGhostNodalValue	(	GlobalVector const &	x,
		MeshLib::Mesh const &	mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::size_t const	node_id,
		std::size_t const	global_component_id )

Returns the value for the given node_id 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 87 of file DOFTableUtil.cpp.

{
    MeshLib::Location const l{mesh.getID(), MeshLib::MeshItemType::Node,
                              node_id};
 
    auto const index = dof_table.getGlobalIndex(l, 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(), MeshLib::Mesh::getID(), MeshLib::Node, 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 139 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(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::getFlux(), and ProcessLib::TES::TESProcess::postIterationConcreteProcess().

◆ 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 77 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 53 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().

◆ 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 82 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 107 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::StokesFlow::LocalAssemblerData< ShapeFunctionLiquidVelocity, ShapeFunctionPressure, GlobalDim >::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, GlobalDim >::postTimestepConcreteWithBlockVectors().

◆ interpolateXCoordinate()

template<typename ShapeFunction , typename ShapeMatricesType >

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

Definition at line 71 of file InitShapeMatrices.h.

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

References createIsoparametricFiniteElement(), and N.

◆ 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 64 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::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 149 of file ExtrapolatableElementCollection.h.

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

Referenced by ProcessLib::makeExtrapolator().

◆ norm()

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

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 159 of file DOFTableUtil.cpp.

{
    switch (norm_type)
    {
        case MathLib::VecNormType::NORM1:
            return norm1(x, global_component, dof_table, mesh);
        case MathLib::VecNormType::NORM2:
            return norm2(x, global_component, dof_table, mesh);
        case MathLib::VecNormType::INFINITY_N:
            return normInfinity(x, global_component, dof_table, mesh);
        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 129 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 441 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 105 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 23 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 21 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

Definition at line 23 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");
 
    return {t_initial,
            t_end,
            minimum_dt,
            maximum_dt,
            initial_dt,
            std::move(number_iterations),
            std::move(multiplier)};
}

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

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 24 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 19 of file TimeStepAlgorithm.cpp.

{
    auto const specific_time = std::upper_bound(
        std::cbegin(fixed_output_times), std::cend(fixed_output_times), t());
 
    if (specific_time == std::cend(fixed_output_times))
    {
        return dt;
    }
 
    if ((t < Time(*specific_time)) && t + dt > Time(*specific_time))
    {
        double const t_to_specific_time = *specific_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 80 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 61 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.
    std::fill(begin(output_vector), end(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);
        auto const mesh_id = mesh_subset.getMeshID();
        for (auto const& node : mesh_subset.getNodes())
        {
            auto const node_id = node->getID();
            MeshLib::Location const l(mesh_id, MeshLib::MeshItemType::Node,
                                      node_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(), MeshLib::MeshSubset::getMeshID(), NumLib::LocalToGlobalIndexMap::getMeshSubset(), NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), 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::vector< std::size_t > 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 99 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.
    std::fill(begin(output_vector_on_submesh), end(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 100 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

◆ ShapeMatrixType

Function Documentation

◆ assembleAdvectionMatrix() [1/2]

◆ assembleAdvectionMatrix() [2/2]

◆ 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()

◆ getGlobalIndexWithTaylorHoodElement()

◆ getIndices()

◆ getIntegrationMethodProvider()

◆ getLocalX()

◆ getNodalValue()

◆ getNonGhostNodalValue()

◆ getRowColumnIndices()

◆ incorporateFixedTimesForOutput()

◆ initShapeMatrices()

◆ interpolateCoordinates()

◆ interpolateToHigherOrderNodes()

◆ interpolateXCoordinate()

◆ localDOF()

◆ makeExtrapolatable()

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

◆ OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [16/16]

◆ operator<<() [1/2]

◆ operator<<() [2/2]

◆ parseCoupling()

◆ parseEvolutionaryPIDcontroller()

◆ parseFixedTimeStepping()