NumLib Namespace Reference

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

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>

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 114 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 143 of file AdvectionMatrixAssembler.h.

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

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

averageGradShapeFunction()

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

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

The function computes the element average of $\nabla N_i$ by

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

Parameters

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

Returns

Averaged $\nabla N_i$ of an element.

Definition at line 40 of file AverageGradShapeFunction.h.

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

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

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

canReduceTimestepSize()

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

Definition at line 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 26 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(), initShapeMatricesAtElementCenter(), and interpolateToHigherOrderNodes().

computeSparsityPattern()

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

Computes a sparsity pattern for the given inputs.

Parameters

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

Returns

The computed sparsity pattern.

Definition at line 76 of file ComputeSparsityPattern.cpp.

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

References computeSparsityPatternPETSc().

Referenced by ProcessLib::Process::computeSparsityPattern(), ProcessLib::HMPhaseField::HMPhaseFieldProcess< DisplacementDim >::constructDofTable(), ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::constructDofTable(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::constructDofTable(), 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__damping_alpha

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__norm_type

Definition at line 131 of file ConvergenceCriterionPerComponentDeltaX.cpp.

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

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

Referenced by createConvergenceCriterion().

createConvergenceCriterionPerComponentResidual()

std::unique_ptr< ConvergenceCriterionPerComponentResidual > NumLib::createConvergenceCriterionPerComponentResidual

(

const BaseLib::ConfigTree &

config

)

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__abstols

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__reltols

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__damping_alpha

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__norm_type

Definition at line 167 of file ConvergenceCriterionPerComponentResidual.cpp.

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

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

Referenced by createConvergenceCriterion().

createConvergenceCriterionResidual()

std::unique_ptr< ConvergenceCriterionResidual > NumLib::createConvergenceCriterionResidual

(

const BaseLib::ConfigTree &

config

)

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__type

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__Residual__abstol

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__Residual__reltol

Input File Parameter

prj__time_loop__processes__process__convergence_criterion__Residual__norm_type

Definition at line 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(), interpolateXCoordinate(), and ApplicationUtils::ComputeNaturalCoordsRootFindingProblem< ShapeFunction >::updateShp().

createIterationNumberBasedTimeStepping()

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

Create a IterationNumberBasedTimeStepping time stepper from the given configuration.

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

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::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 56 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 112 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().

Referenced by ProcessLib::BoundaryConditionAndSourceTerm::Python::BcAndStLocalAssemblerImpl< BcOrStData, ShapeFunction, LowerOrderShapeFunction, GlobalDim >::assemble(), ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::NeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::NormalTractionBoundaryCondition::NormalTractionBoundaryConditionLocalAssembler< ShapeFunctionDisplacement, GlobalDim >::assemble(), ProcessLib::RobinBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::VariableDependentNeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::VectorMatrixAssembler::assemble(), ProcessLib::WellboreCompensateNeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::assembleReactionEquation(), ProcessLib::VectorMatrixAssembler::assembleWithJacobian(), anonymous_namespace{ParallelVectorMatrixAssembler.cpp}::assembleWithJacobianForStaggeredSchemeOneElement(), anonymous_namespace{ParallelVectorMatrixAssembler.cpp}::assembleWithJacobianOneElement(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::computeCrackIntegral(), ProcessLib::LocalAssemblerInterface::computeSecondaryVariable(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::getIntPtDarcyVelocity(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::RichardsComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::SteadyStateDiffusion::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::TES::TESLocalAssembler< ShapeFunction_, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::HeatConduction::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtHeatFlux(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtMolarFlux(), ProcessLib::RichardsComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtSaturation(), getLocalX(), ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::initializeChemicalSystem(), ProcessLib::AnchorTerm< GlobalDim >::integrate(), ProcessLib::VolumetricSourceTermLocalAssembler< ShapeFunction, GlobalDim >::integrate(), ProcessLib::VectorMatrixAssembler::preAssemble(), ProcessLib::LocalAssemblerInterface::preTimestep(), ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::setChemicalSystem(), and ProcessLib::SmallDeformation::writeMaterialForces().

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

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

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

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

getNodalValue()

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

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

Definition at line 102 of file DOFTableUtil.cpp.

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

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

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

getNonGhostNodalValue()

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

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

Definition at line 86 of file DOFTableUtil.cpp.

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

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

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

getRowColumnIndices()

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

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

Definition at line 131 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 79 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 54 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().

Referenced by ProcessLib::ConstraintDirichletBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::ConstraintDirichletBoundaryConditionLocalAssembler(), ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::HeatTransportBHELocalAssemblerBHE(), ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::HeatTransportBHELocalAssemblerSoil(), ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::HTFEM(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::HydroMechanicsLocalAssembler(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerFracture< ShapeFunctionDisplacement, ShapeFunctionPressure, GlobalDim >::HydroMechanicsLocalAssemblerFracture(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, GlobalDim >::HydroMechanicsLocalAssemblerMatrix(), ProcessLib::LargeDeformation::LargeDeformationLocalAssembler< ShapeFunction, DisplacementDim >::LargeDeformationLocalAssembler(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::LiquidFlowLocalAssembler(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalAssemblerData(), ProcessLib::RichardsComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalAssemblerData(), ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalAssemblerData(), ProcessLib::StokesFlow::LocalAssemblerData< ShapeFunctionLiquidVelocity, ShapeFunctionPressure, GlobalDim >::LocalAssemblerData(), ProcessLib::NormalTractionBoundaryCondition::NormalTractionBoundaryConditionLocalAssembler< ShapeFunctionDisplacement, GlobalDim >::NormalTractionBoundaryConditionLocalAssembler(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler(), NumLib::ShapeMatrixCache::ShapeMatrixCache(), ProcessLib::SmallDeformation::SmallDeformationLocalAssembler< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssembler(), ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrix< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerMatrix(), ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerMatrixNearFracture(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::SmallDeformationNonlocalLocalAssembler(), ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, GlobalDim >::SurfaceFluxLocalAssembler(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::TH2MLocalAssembler(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::ThermalTwoPhaseFlowWithPPLocalAssembler(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::ThermoHydroMechanicsLocalAssembler(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicalPhaseFieldLocalAssembler(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicsLocalAssembler(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::ThermoRichardsFlowLocalAssembler(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::ThermoRichardsMechanicsLocalAssembler(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::TwoPhaseFlowWithPPLocalAssembler(), ProcessLib::VolumetricSourceTermLocalAssembler< ShapeFunction, GlobalDim >::VolumetricSourceTermLocalAssembler(), ProcessLib::WellboreSimulator::WellboreSimulatorFEM< ShapeFunction, GlobalDim >::WellboreSimulatorFEM(), MeshToolsLib::computeElementVolumeNumerically(), ProcessLib::BoundaryConditionAndSourceTerm::Python::computeNsAndWeights(), ProcessLib::GenericNaturalBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::initNsAndWeights(), and anonymous_namespace{ShapeMatrixCache.cpp}::initShapeMatrices().

initShapeMatricesAtElementCenter()

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

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

Definition at line 74 of file InitShapeMatrices.h.

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

References computeShapeMatrices().

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

interpolateCoordinates()

template<typename ShapeFunction , typename ShapeMatricesType >

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

Definition at line 102 of file InitShapeMatrices.h.

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

References createIsoparametricFiniteElement(), and N.

Referenced by ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::ThermoRichardsFlowLocalAssembler(), ProcessLib::HeatConduction::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble(), ProcessLib::NeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::RobinBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assemble(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleBlockMatrices(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleKCmCn(), ProcessLib::SmallDeformation::SmallDeformationLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assembleWithJacobian(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::assembleWithJacobian(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::computeSecondaryVariableConcrete(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::initializeConcrete(), ProcessLib::LargeDeformation::LargeDeformationLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::initializeConcrete(), ProcessLib::SmallDeformation::SmallDeformationLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::initializeConcrete(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::initializeConcrete(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::initializeConcrete(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::initializeConcrete(), ProcessLib::VolumetricSourceTermLocalAssembler< ShapeFunction, GlobalDim >::integrate(), interpolateElementCoords(), ProcessLib::SmallDeformation::SmallDeformationLocalAssembler< ShapeFunction, DisplacementDim >::postTimestepConcrete(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::postTimestepConcrete(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::setInitialConditionsConcrete(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::setInitialConditionsConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::setInitialConditionsConcrete(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::setInitialConditionsConcrete(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveVariables(), and ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveVariablesDerivatives().

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 91 of file InitShapeMatrices.h.

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

References createIsoparametricFiniteElement(), and N.

Referenced by ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assemble(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assemble(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, GlobalDim >::assembleBlockMatricesWithJacobian(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::LargeDeformation::LargeDeformationLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrix< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::SmallDeformation::SmallDeformationLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianPhaseFieldEquations(), averageGradShapeFunction(), ProcessLib::NonLinearFbar::computeFBarInitialVariablesElementCenter(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::computeSecondaryVariableConcrete(), ProcessLib::SmallDeformation::getMaterialForces(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::getNodalValues(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::postNonLinearSolverConcrete(), ProcessLib::LargeDeformation::LargeDeformationLocalAssembler< ShapeFunction, DisplacementDim >::postTimestepConcrete(), ProcessLib::SmallDeformation::SmallDeformationLocalAssembler< ShapeFunction, DisplacementDim >::postTimestepConcrete(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::postTimestepConcrete(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, GlobalDim >::postTimestepConcreteWithBlockVectors(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::preAssemble(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::setInitialConditionsConcrete(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::setInitialConditionsConcrete(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::setInitialConditionsConcrete(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveRelations(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveVariables(), and ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveVariablesDerivatives().

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::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::localDOF(), ProcessLib::SmallDeformation::SmallDeformationLocalAssembler< ShapeFunction, DisplacementDim >::localDOF(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::localDOF(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::localDOF().

makeExtrapolatable()

template<typename LocalAssemblerCollection , typename IntegrationPointValuesMethod >

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

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

Definition at line 149 of file ExtrapolatableElementCollection.h.

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

Referenced by ProcessLib::makeExtrapolator().

makeNewtonRaphson()

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

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

Definition at line 150 of file NewtonRaphson.h.

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

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

norm()

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

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

Remarks

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

Definition at line 151 of file DOFTableUtil.cpp.

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

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

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

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [1/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Hex	,
		ShapeHex8	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [2/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Hex20	,
		ShapeHex20	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [3/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Line	,
		ShapeLine2	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [4/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Line3	,
		ShapeLine3	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [5/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Point	,
		ShapePoint1	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [6/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Prism	,
		ShapePrism6	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [7/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Prism15	,
		ShapePrism15	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [8/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Pyramid	,
		ShapePyra5	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [9/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Pyramid13	,
		ShapePyra13	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [10/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Quad	,
		ShapeQuad4	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [11/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Quad8	,
		ShapeQuad8	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [12/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Quad9	,
		ShapeQuad9	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [13/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Tet	,
		ShapeTet4	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [14/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Tet10	,
		ShapeTet10	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [15/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Tri	,
		ShapeTri3	)

OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE() [16/16]

NumLib::OGS_SPECIALIZE_ELEMENT_TRAITS_LAGRANGE	(	Tri6	,
		ShapeTri6	)

operator<<() [1/2]

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

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

Definition at line 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 60 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);
        for (auto const& l : MeshLib::views::meshLocations(
                 mesh_subset, MeshLib::MeshItemType::Node))
        {
            auto const node_id = l.item_id;
            auto const input_index = local_to_global_index_map.getGlobalIndex(
                l, variable_id, component);
            double const value = input_vector[input_index];
 
            output_vector.getComponent(node_id, component) =
                map_function(value);
        }
    }
}

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

transformVariableFromGlobalVector() [2/2]

template<typename Functor >

void NumLib::transformVariableFromGlobalVector	(	GlobalVector const &	input_vector_on_bulk_mesh,
		int const	variable_id,
		NumLib::LocalToGlobalIndexMap const &	local_to_global_index_map,
		MeshLib::PropertyVector< double > &	output_vector_on_submesh,
		std::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 96 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().