ProcessLib::AbstractJacobianAssembler Class Reference

Detailed Description

Base class for Jacobian assemblers.

Definition at line 18 of file AbstractJacobianAssembler.h.

#include <AbstractJacobianAssembler.h>

Inheritance diagram for ProcessLib::AbstractJacobianAssembler:

Public Member Functions
	AbstractJacobianAssembler (std::vector< double > const &&absolute_epsilons)
	AbstractJacobianAssembler ()
virtual void	assembleWithJacobian (LocalAssemblerInterface &local_assembler, double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)=0
virtual void	assembleWithJacobianForStaggeredScheme (LocalAssemblerInterface &, double const, double const, Eigen::VectorXd const &, Eigen::VectorXd const &, int const, std::vector< double > &, std::vector< double > &)
virtual std::unique_ptr< AbstractJacobianAssembler >	copy () const =0
virtual	~AbstractJacobianAssembler ()=default
void	checkPerturbationSize (int const max_non_deformation_dofs_per_node) const
void	setNonDeformationComponentIDs (std::vector< int > const &non_deformation_component_ids)
void	setNonDeformationComponentIDsNoSizeCheck (std::vector< int > const &non_deformation_component_ids)
auto	getVariableComponentEpsilonsView () const
auto	isPerturbationEnabled () const

Protected Attributes
std::vector< int >	non_deformation_component_ids_
std::vector< double > const	absolute_epsilons_

Constructor & Destructor Documentation

AbstractJacobianAssembler() [1/2]

ProcessLib::AbstractJacobianAssembler::AbstractJacobianAssembler ( std::vector< double > const && absolute_epsilons )

inlineexplicit

Constructs a new instance for the numerical Jacobian.

Parameters

absolute_epsilons

perturbations of the components of the local solution vector used for evaluating the finite differences.

Definition at line 24 of file AbstractJacobianAssembler.h.

        : absolute_epsilons_(std::move(absolute_epsilons))
    {
        if (absolute_epsilons_.empty())
        {
            OGS_FATAL(
                "Numerical Jacobian assembler requires perturbation values "
                "(epsilons) for finite difference approximation, but none were "
                "provided.\n"
                "Please specify <epsilons> in the <jacobian_assembler> section "
                "of your project file.\n"
                "Example: <epsilons>1e-8 1e-8</epsilons> for a process with 2 "
                "non-deformation variables.");
        }
    }

References absolute_epsilons_.

Referenced by ProcessLib::CentralDifferencesJacobianAssembler::CentralDifferencesJacobianAssembler(), and ProcessLib::ForwardDifferencesJacobianAssembler::ForwardDifferencesJacobianAssembler().

AbstractJacobianAssembler() [2/2]

ProcessLib::AbstractJacobianAssembler::AbstractJacobianAssembler ( )

inlineexplicit

Definition at line 41 of file AbstractJacobianAssembler.h.

: absolute_epsilons_({}) {}

References absolute_epsilons_.

~AbstractJacobianAssembler()

virtual ProcessLib::AbstractJacobianAssembler::~AbstractJacobianAssembler ( )

virtualdefault

Member Function Documentation

assembleWithJacobian()

virtual void ProcessLib::AbstractJacobianAssembler::assembleWithJacobian ( LocalAssemblerInterface & local_assembler, double const t, double const dt, std::vector< double > const & local_x, std::vector< double > const & local_x_prev, std::vector< double > & local_b_data, std::vector< double > & local_Jac_data )

pure virtual

Assembles the Jacobian, the matrices \(M\) and \(K\), and the vector \(b\).

Implemented in ProcessLib::AnalyticalJacobianAssembler, ProcessLib::CentralDifferencesJacobianAssembler, ProcessLib::CompareJacobiansJacobianAssembler, and ProcessLib::ForwardDifferencesJacobianAssembler.

Referenced by anonymous_namespace{ParallelVectorMatrixAssembler.cpp}::assembleWithJacobianOneElement().

assembleWithJacobianForStaggeredScheme()

virtual void ProcessLib::AbstractJacobianAssembler::assembleWithJacobianForStaggeredScheme ( LocalAssemblerInterface & , double const , double const , Eigen::VectorXd const & , Eigen::VectorXd const & , int const , std::vector< double > & , std::vector< double > &  )

inlinevirtual

Assembles the Jacobian, the matrices \(M\) and \(K\), and the vector \(b\) with coupling.

Reimplemented in ProcessLib::AnalyticalJacobianAssembler.

Definition at line 54 of file AbstractJacobianAssembler.h.

    {
        // TODO make pure virtual.
        OGS_FATAL("not implemented.");
    }

References OGS_FATAL.

Referenced by anonymous_namespace{ParallelVectorMatrixAssembler.cpp}::assembleWithJacobianForStaggeredSchemeOneElement().

checkPerturbationSize()

void ProcessLib::AbstractJacobianAssembler::checkPerturbationSize ( int const max_non_deformation_dofs_per_node ) const

inline

Checks that the number of specified perturbations is not smaller than the maximum number of non-deformation degrees of freedom per node.

Definition at line 73 of file AbstractJacobianAssembler.h.

    {
        if (absolute_epsilons_.empty())
        {  // No epsilons specified — this assembler is used for the Picard
           // nonlinear solver or for the Newton nonlinear solver with
           // analytical Jacobian, so there is nothing to do.
            return;
        }
 
        int const num_abs_eps = static_cast<int>(absolute_epsilons_.size());
        if (num_abs_eps != max_non_deformation_dofs_per_node)
        {
            OGS_FATAL(
                "Mismatch in numerical Jacobian perturbation configuration:\n"
                "  Provided epsilons:  {:d}\n"
                "  Required epsilons:  {:d} (one per non-deformation variable "
                "component)\n\n"
                "Each non-deformation variable needs exactly one epsilon value "
                "for numerical differentiation.\n"
                "Deformation variables use analytical Jacobian and do not "
                "require epsilons.\n"
                "Please adjust the <epsilons> array in your project file to "
                "match the number of required components.",
                num_abs_eps, max_non_deformation_dofs_per_node);
        }
    }

References absolute_epsilons_, and OGS_FATAL.

Referenced by setNonDeformationComponentIDs().

copy()

virtual std::unique_ptr< AbstractJacobianAssembler > ProcessLib::AbstractJacobianAssembler::copy ( ) const

pure virtual

Implemented in ProcessLib::AnalyticalJacobianAssembler, ProcessLib::CentralDifferencesJacobianAssembler, ProcessLib::CompareJacobiansJacobianAssembler, and ProcessLib::ForwardDifferencesJacobianAssembler.

getVariableComponentEpsilonsView()

auto ProcessLib::AbstractJacobianAssembler::getVariableComponentEpsilonsView ( ) const

inline

Definition at line 129 of file AbstractJacobianAssembler.h.

    {
        assert(!non_deformation_component_ids_.empty());
        namespace rv = ranges::views;
        return non_deformation_component_ids_ |
               rv::transform(
                   [this](int comp_id) -> double const&
                   {
                       return absolute_epsilons_[static_cast<std::size_t>(
                           comp_id)];
                   });
    }

References absolute_epsilons_, and non_deformation_component_ids_.

Referenced by ProcessLib::CentralDifferencesJacobianAssembler::assembleWithJacobian(), and ProcessLib::ForwardDifferencesJacobianAssembler::assembleWithJacobian().

isPerturbationEnabled()

auto ProcessLib::AbstractJacobianAssembler::isPerturbationEnabled ( ) const

inline

Definition at line 142 of file AbstractJacobianAssembler.h.

{ return !absolute_epsilons_.empty(); }

References absolute_epsilons_.

setNonDeformationComponentIDs()

void ProcessLib::AbstractJacobianAssembler::setNonDeformationComponentIDs ( std::vector< int > const & non_deformation_component_ids )

inline

Definition at line 101 of file AbstractJacobianAssembler.h.

    {
        // Repeated in checkPerturbationSize to cover staggered scheme in TH2M
        // and THM, which may be supported in future.
        if (absolute_epsilons_.empty())
        {  // No epsilons specified — this assembler is used for the Picard
           // nonlinear solver or for the Newton nonlinear solver with
           // analytical Jacobian, so there is nothing to do.
            return;
        }
 
        // So far, the number of specified perturbations is checked inside this
        // function, assuming the TH2M and THM processes do not use the
        // staggered scheme. If the staggered scheme is supported in these
        // processes, call `checkPerturbationSize(...)` and then
        // `setNonDeformationComponentIDsNoSizeCheck(...)` instead.
        checkPerturbationSize(non_deformation_component_ids.size());
 
        non_deformation_component_ids_ = non_deformation_component_ids;
    }

References absolute_epsilons_, checkPerturbationSize(), and non_deformation_component_ids_.

setNonDeformationComponentIDsNoSizeCheck()

void ProcessLib::AbstractJacobianAssembler::setNonDeformationComponentIDsNoSizeCheck ( std::vector< int > const & non_deformation_component_ids )

inline

Definition at line 123 of file AbstractJacobianAssembler.h.

    {
        non_deformation_component_ids_ = non_deformation_component_ids;
    }

References non_deformation_component_ids_.

Member Data Documentation

absolute_epsilons_

std::vector<double> const ProcessLib::AbstractJacobianAssembler::absolute_epsilons_

protected

Perturbations of the variable components used for evaluating finite differences (excluding deformation).

Note

The perturbations must be specified component-wise for each non-deformation variable. If the number of perturbations is not equal to the number of non-deformation variable components, a fatal error is issued. The deformation block of the local Jacobian matrix is calculated analytically; therefore, perturbations for deformation components are not required.

Definition at line 158 of file AbstractJacobianAssembler.h.

Referenced by AbstractJacobianAssembler(), AbstractJacobianAssembler(), checkPerturbationSize(), getVariableComponentEpsilonsView(), isPerturbationEnabled(), and setNonDeformationComponentIDs().

non_deformation_component_ids_

std::vector<int> ProcessLib::AbstractJacobianAssembler::non_deformation_component_ids_

protected

IDs of the components that are not deformation variables. Used by the numerical Jacobian assembler. It is manipulated by processes that use the numerical Jacobian assembler. Therefore, it is thread-safe.

Definition at line 148 of file AbstractJacobianAssembler.h.

Referenced by ProcessLib::CentralDifferencesJacobianAssembler::assembleWithJacobian(), ProcessLib::ForwardDifferencesJacobianAssembler::assembleWithJacobian(), getVariableComponentEpsilonsView(), setNonDeformationComponentIDs(), and setNonDeformationComponentIDsNoSizeCheck().

---

The documentation for this class was generated from the following file:

• AbstractJacobianAssembler.h