ProcessLib::AssemblyMixin< Process > Class Template Reference

Detailed Description

template<typename Process>
class ProcessLib::AssemblyMixin< Process >

A mixin providing assembly functionality to a specific Process.

The process must be derived from this class (CRTP).

Definition at line 94 of file AssemblyMixin.h.

#include <AssemblyMixin.h>

Inheritance diagram for ProcessLib::AssemblyMixin< Process >:

Collaboration diagram for ProcessLib::AssemblyMixin< Process >:

Public Member Functions
void	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &submeshes, std::vector< std::vector< std::string > > const &residuum_names)
void	updateActiveElements ()
void	assemble (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, std::vector< std::size_t > const *const sorted_element_subset=nullptr, bool const copy_residua_to_mesh=false)
void	assembleWithJacobian (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac, std::vector< std::size_t > const *const sorted_element_subset=nullptr, bool const copy_residua_to_mesh=false)
void	preOutput (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id)

Private Member Functions
Process &	derived ()
Process const &	derived () const
std::exception_ptr	assembleOnBulkMeshOrOnSubmeshCommon (Assembly::CommonAssemblyData const &assembly_data, AssembledMatrixCache &mat_cache, double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, std::vector< std::size_t > const *const sorted_element_subset)
	Common code for Picard assembly on the bulk mesh or on submeshes.
std::exception_ptr	assembleOnBulkMesh (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, std::vector< std::size_t > const *const sorted_element_subset)
std::exception_ptr	assembleOnSubmeshes (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, std::vector< std::size_t > const *const sorted_element_subset, bool const copy_residua_to_mesh)
std::exception_ptr	assembleWithJacobianOnBulkMeshOrOnSubmeshCommon (Assembly::CommonAssemblyData const &assembly_data, double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, int const process_id, GlobalVector &b, GlobalMatrix &Jac, std::vector< std::size_t > const *const sorted_element_subset)
std::exception_ptr	assembleWithJacobianOnSubmeshes (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, int const process_id, GlobalVector &b, GlobalMatrix &Jac, std::vector< std::size_t > const *const sorted_element_subset, bool const)
void	preOutputPicard (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id)
void	preOutputNewton (double const, double const, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, int const)
	AssemblyMixinBase (AbstractJacobianAssembler &jacobian_assembler, bool const is_linear, bool const use_monolithic_scheme)
Private Member Functions inherited from ProcessLib::AssemblyMixinBase
	AssemblyMixinBase (AbstractJacobianAssembler &jacobian_assembler, bool const is_linear, bool const use_monolithic_scheme)
void	initializeAssemblyOnSubmeshes (MeshLib::Mesh &bulk_mesh, std::vector< std::reference_wrapper< MeshLib::Mesh > > const &submeshes, std::vector< std::vector< std::string > > const &residuum_names, std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > const &pvs)
void	updateActiveElements (ProcessLib::Process const &process)
bool	isLinear () const

Private Attributes
friend	Process
Private Attributes inherited from ProcessLib::AssemblyMixinBase
std::vector< ProcessLib::Assembly::SubmeshAssemblyData >	submesh_assembly_data_
	SubmeshAssemblyData for each submesh.
std::vector< AssembledMatrixCache >	submesh_matrix_cache_
	AssembledMatrixCache for each submesh.
std::optional< ProcessLib::Assembly::BulkMeshAssemblyData >	bulk_mesh_assembly_data_
	Empty if submesh assembly is used.
AssembledMatrixCache	bulk_mesh_matrix_cache_
Assembly::ParallelVectorMatrixAssembler	pvma_
bool	is_linear_
std::optional< NumLib::NonlinearSolverTag >	last_assembly_was_

Additional Inherited Members
Static Private Member Functions inherited from ProcessLib::AssemblyMixinBase
static void	copyResiduumVectorsToBulkMesh (GlobalVector const &rhs, NumLib::LocalToGlobalIndexMap const &local_to_global_index_map, std::vector< std::reference_wrapper< MeshLib::PropertyVector< double > > > residuum_vectors)
static void	copyResiduumVectorsToSubmesh (int const process_id, GlobalVector const &rhs, NumLib::LocalToGlobalIndexMap const &local_to_global_index_map, ProcessLib::Assembly::SubmeshAssemblyData const &sad)

Member Function Documentation

assemble()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::assemble ( double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, int const process_id, GlobalMatrix & M, GlobalMatrix & K, GlobalVector & b, std::vector< std::size_t > const *const sorted_element_subset = nullptr, bool const copy_residua_to_mesh = false )

inline

Definition at line 140 of file AssemblyMixin.h.

    {
        DBUG("AssemblyMixin assemble(t={:g}, dt={:g}, process_id={}).", t, dt,
             process_id);
 
        last_assembly_was_ = NumLib::NonlinearSolverTag::Picard;
 
        std::vector<NumLib::LocalToGlobalIndexMap const*> const dof_tables =
            derived().getDOFTables(x.size());
 
        std::exception_ptr const exception =
            submesh_assembly_data_.empty()
                ? assembleOnBulkMesh(t, dt, x, x_prev, dof_tables, process_id,
                                     M, K, b, sorted_element_subset)
                : assembleOnSubmeshes(t, dt, x, x_prev, dof_tables, process_id,
                                      M, K, b, sorted_element_subset,
                                      copy_residua_to_mesh);
 
        BaseLib::MPI::allRanksThrowOrNone<NumLib::AssemblyException>(exception);
 
        if (copy_residua_to_mesh && bulk_mesh_assembly_data_)
        {
            // Note: computeResiduum() uses bwd/fwd Euler scheme.
            GlobalVector const neg_res_bulkmesh = ProcessLib::computeResiduum(
                dt, *x[process_id], *x_prev[process_id], M, K, b);
 
            AssemblyMixinBase::copyResiduumVectorsToBulkMesh(
                neg_res_bulkmesh, *(dof_tables[process_id]),
                bulk_mesh_assembly_data_->residuum_vectors[process_id]);
        }
    }

References BaseLib::MPI::allRanksThrowOrNone(), assembleOnBulkMesh(), assembleOnSubmeshes(), ProcessLib::AssemblyMixinBase::bulk_mesh_assembly_data_, ProcessLib::computeResiduum(), ProcessLib::AssemblyMixinBase::copyResiduumVectorsToBulkMesh(), DBUG(), derived(), ProcessLib::Process::getDOFTables(), ProcessLib::AssemblyMixinBase::last_assembly_was_, NumLib::Picard, and ProcessLib::AssemblyMixinBase::submesh_assembly_data_.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), and preOutputPicard().

assembleOnBulkMesh()

template<typename Process>

std::exception_ptr ProcessLib::AssemblyMixin< Process >::assembleOnBulkMesh ( double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, int const process_id, GlobalMatrix & M, GlobalMatrix & K, GlobalVector & b, std::vector< std::size_t > const *const sorted_element_subset )

inlineprivate

Definition at line 310 of file AssemblyMixin.h.

    {
        if (!bulk_mesh_matrix_cache_.hasMKb())
        {
            return assembleOnBulkMeshOrOnSubmeshCommon(
                *bulk_mesh_assembly_data_, bulk_mesh_matrix_cache_, t, dt, x,
                x_prev, dof_tables, process_id, M, K, b, sorted_element_subset);
        }
 
        DBUG("Reusing saved global M, K, b.");
 
        BaseLib::RunTime time_restore;
        time_restore.start();
 
        auto const [M_, K_, b_] = bulk_mesh_matrix_cache_.MKb();
        MathLib::LinAlg::copy(M_, M);
        MathLib::LinAlg::copy(K_, K);
        MathLib::LinAlg::copy(b_, b);
 
        INFO("[time] Restoring global M, K, b took {:g} s",
             time_restore.elapsed());
 
        return nullptr;
    }

References assembleOnBulkMeshOrOnSubmeshCommon(), ProcessLib::AssemblyMixinBase::bulk_mesh_assembly_data_, ProcessLib::AssemblyMixinBase::bulk_mesh_matrix_cache_, MathLib::LinAlg::copy(), DBUG(), BaseLib::RunTime::elapsed(), INFO(), and BaseLib::RunTime::start().

Referenced by assemble().

assembleOnBulkMeshOrOnSubmeshCommon()

template<typename Process>

std::exception_ptr ProcessLib::AssemblyMixin< Process >::assembleOnBulkMeshOrOnSubmeshCommon ( Assembly::CommonAssemblyData const & assembly_data, AssembledMatrixCache & mat_cache, double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, int const process_id, GlobalMatrix & M, GlobalMatrix & K, GlobalVector & b, std::vector< std::size_t > const *const sorted_element_subset )

inlinenodiscardprivate

Common code for Picard assembly on the bulk mesh or on submeshes.

Definition at line 264 of file AssemblyMixin.h.

    {
        std::exception_ptr exception = nullptr;
 
        try
        {
            auto const& loc_asms = derived().local_assemblers_;
 
            pvma_.assemble(
                loc_asms,
                assembly_data.activeElementIDsSorted(sorted_element_subset)
                    .get(),
                dof_tables, t, dt, x, x_prev, process_id, M, K, b);
        }
        catch (NumLib::AssemblyException const&)
        {
            exception = std::current_exception();
        }
 
        MathLib::LinAlg::finalizeAssembly(M);
        MathLib::LinAlg::finalizeAssembly(K);
        MathLib::LinAlg::finalizeAssembly(b);
 
        if (is_linear_)
        {
            DBUG("Saving global M, K, b for later reuse.");
 
            BaseLib::RunTime time_save;
            time_save.start();
 
            mat_cache.storeMKb(M, K, b);
 
            INFO("[time] Saving global M, K, b took {:g} s",
                 time_save.elapsed());
        }
 
        return exception;
    }

References ProcessLib::Assembly::CommonAssemblyData::activeElementIDsSorted(), DBUG(), derived(), BaseLib::RunTime::elapsed(), MathLib::LinAlg::finalizeAssembly(), INFO(), ProcessLib::AssemblyMixinBase::is_linear_, ProcessLib::AssemblyMixinBase::pvma_, BaseLib::RunTime::start(), and ProcessLib::AssembledMatrixCache::storeMKb().

Referenced by assembleOnBulkMesh(), and assembleOnSubmeshes().

assembleOnSubmeshes()

template<typename Process>

std::exception_ptr ProcessLib::AssemblyMixin< Process >::assembleOnSubmeshes ( double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, int const process_id, GlobalMatrix & M, GlobalMatrix & K, GlobalVector & b, std::vector< std::size_t > const *const sorted_element_subset, bool const copy_residua_to_mesh )

inlinenodiscardprivate

Definition at line 340 of file AssemblyMixin.h.

    {
        auto const mat_spec = derived().getMatrixSpecifications(process_id);
 
        // Temporary matrices for assembly (reused across submeshes).
        // They will remain nullptr if no assembly is necessary (linear case &
        // cache populated).
        std::unique_ptr<GlobalMatrix> M_tmp;
        std::unique_ptr<GlobalMatrix> K_tmp;
        std::unique_ptr<GlobalVector> b_tmp;
 
        auto getMKb = [&M_tmp, &K_tmp, &b_tmp,
                       &mat_spec](AssembledMatrixCache const& cache)
        {
            if (cache.hasMKb())
            {
                return cache.MKb();
            }
 
            if (!(M_tmp && K_tmp && b_tmp))
            {
                M_tmp = MathLib::MatrixVectorTraits<GlobalMatrix>::newInstance(
                    mat_spec);
                K_tmp = MathLib::MatrixVectorTraits<GlobalMatrix>::newInstance(
                    mat_spec);
                b_tmp = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(
                    mat_spec);
            }
 
            return std::tie(*M_tmp, *K_tmp, *b_tmp);
        };
 
        std::exception_ptr exception = nullptr;
        for (auto const& [sad, mat_cache] :
             ranges::zip_view(submesh_assembly_data_ | ranges::views::all,
                              submesh_matrix_cache_ | ranges::views::all))
        {
            auto [M_submesh, K_submesh, b_submesh] = getMKb(mat_cache);
 
            if (!mat_cache.hasMKb())
            {
                M_submesh.setZero();
                K_submesh.setZero();
                b_submesh.setZero();
 
                exception = assembleOnBulkMeshOrOnSubmeshCommon(
                    sad, mat_cache, t, dt, x, x_prev, dof_tables, process_id,
                    M_submesh, K_submesh, b_submesh, sorted_element_subset);
            }
 
            // TODO: This operates on the entire global vector b once
            // for each submesh. If the number of submeshes is high,
            // that might not perform well.
            MathLib::LinAlg::axpy(M, 1.0, M_submesh);
            MathLib::LinAlg::axpy(K, 1.0, K_submesh);
            MathLib::LinAlg::axpy(b, 1.0, b_submesh);
 
            if (copy_residua_to_mesh)
            {
                // Note: computeResiduum() uses bwd/fwd Euler scheme.
                GlobalVector const neg_res_submesh =
                    computeResiduum(dt, *x[process_id], *x_prev[process_id],
                                    M_submesh, K_submesh, b_submesh);
 
                AssemblyMixinBase::copyResiduumVectorsToSubmesh(
                    process_id, neg_res_submesh, *(dof_tables[process_id]),
                    sad);
            }
        }
 
        return exception;
    }

References assembleOnBulkMeshOrOnSubmeshCommon(), MathLib::LinAlg::axpy(), ProcessLib::computeResiduum(), ProcessLib::AssemblyMixinBase::copyResiduumVectorsToSubmesh(), derived(), ProcessLib::Process::getMatrixSpecifications(), ProcessLib::AssemblyMixinBase::submesh_assembly_data_, and ProcessLib::AssemblyMixinBase::submesh_matrix_cache_.

Referenced by assemble().

assembleWithJacobian()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::assembleWithJacobian ( double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, int const process_id, GlobalVector & b, GlobalMatrix & Jac, std::vector< std::size_t > const *const sorted_element_subset = nullptr, bool const copy_residua_to_mesh = false )

inline

Definition at line 180 of file AssemblyMixin.h.

    {
        DBUG(
            "AssemblyMixin assembleWithJacobian(t={:g}, dt={:g}, "
            "process_id={}).",
            t, dt, process_id);
 
        last_assembly_was_ = NumLib::NonlinearSolverTag::Newton;
 
        // Note: We do not cache the Jacobian or b vector. It does not make
        // sense, because even in the linear case the b vector changes if
        // the solution changes (unless steady state is reached).
        // Todo: If we separated Jacobian and residuum assembly, we could
        // cache at least the Jacobian and only update the residuum.
        if (is_linear_)
        {
            DBUG(
                "You specified that this process is linear. The assembly for "
                "the Newton-Raphson method will be run anyways.");
        }
 
        std::vector<NumLib::LocalToGlobalIndexMap const*> const dof_tables =
            derived().getDOFTables(x.size());
 
        std::exception_ptr const exception =
            submesh_assembly_data_.empty()
                ? assembleWithJacobianOnBulkMeshOrOnSubmeshCommon(
                      *bulk_mesh_assembly_data_, t, dt, x, x_prev, dof_tables,
                      process_id, b, Jac, sorted_element_subset)
                : assembleWithJacobianOnSubmeshes(
                      t, dt, x, x_prev, dof_tables, process_id, b, Jac,
                      sorted_element_subset, copy_residua_to_mesh);
 
        BaseLib::MPI::allRanksThrowOrNone<NumLib::AssemblyException>(exception);
 
        MathLib::LinAlg::finalizeAssembly(Jac);
 
        // TODO better for submesh case, too?
        // TODO check copy_residua_to_mesh, too. But that needs a refactoring of
        // postTimestep(), computeSecondaryVariable() etc. hooks.
        if (/*copy_residua_to_mesh &&*/ bulk_mesh_assembly_data_)
        {
            AssemblyMixinBase::copyResiduumVectorsToBulkMesh(
                b, *(dof_tables[process_id]),
                bulk_mesh_assembly_data_->residuum_vectors[process_id]);
        }
    }

References BaseLib::MPI::allRanksThrowOrNone(), assembleWithJacobianOnBulkMeshOrOnSubmeshCommon(), assembleWithJacobianOnSubmeshes(), ProcessLib::AssemblyMixinBase::bulk_mesh_assembly_data_, ProcessLib::AssemblyMixinBase::copyResiduumVectorsToBulkMesh(), DBUG(), derived(), MathLib::LinAlg::finalizeAssembly(), ProcessLib::Process::getDOFTables(), ProcessLib::AssemblyMixinBase::is_linear_, ProcessLib::AssemblyMixinBase::last_assembly_was_, NumLib::Newton, and ProcessLib::AssemblyMixinBase::submesh_assembly_data_.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), and preOutputNewton().

assembleWithJacobianOnBulkMeshOrOnSubmeshCommon()

template<typename Process>

std::exception_ptr ProcessLib::AssemblyMixin< Process >::assembleWithJacobianOnBulkMeshOrOnSubmeshCommon ( Assembly::CommonAssemblyData const & assembly_data, double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, int const process_id, GlobalVector & b, GlobalMatrix & Jac, std::vector< std::size_t > const *const sorted_element_subset )

inlinenodiscardprivate

Common code for the Newton-Raphson assembly on the bulk mesh or on submeshes.

Definition at line 422 of file AssemblyMixin.h.

    {
        auto const& loc_asms = derived().local_assemblers_;
        std::exception_ptr exception = nullptr;
 
        try
        {
            pvma_.assembleWithJacobian(
                loc_asms,
                assembly_data.activeElementIDsSorted(sorted_element_subset)
                    .get(),
                dof_tables, t, dt, x, x_prev, process_id, b, Jac);
        }
        catch (NumLib::AssemblyException const&)
        {
            exception = std::current_exception();
        }
 
        MathLib::LinAlg::finalizeAssembly(b);
 
        return exception;
    }

References ProcessLib::Assembly::CommonAssemblyData::activeElementIDsSorted(), derived(), MathLib::LinAlg::finalizeAssembly(), and ProcessLib::AssemblyMixinBase::pvma_.

Referenced by assembleWithJacobian(), and assembleWithJacobianOnSubmeshes().

assembleWithJacobianOnSubmeshes()

template<typename Process>

std::exception_ptr ProcessLib::AssemblyMixin< Process >::assembleWithJacobianOnSubmeshes ( double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, int const process_id, GlobalVector & b, GlobalMatrix & Jac, std::vector< std::size_t > const *const sorted_element_subset, bool const  )

inlinenodiscardprivate

Definition at line 451 of file AssemblyMixin.h.

    {
        std::exception_ptr exception = nullptr;
 
        auto const& mat_spec = derived().getMatrixSpecifications(process_id);
        auto b_submesh =
            MathLib::MatrixVectorTraits<GlobalVector>::newInstance(mat_spec);
 
        for (auto const& sad : submesh_assembly_data_)
        {
            b_submesh->setZero();
 
            exception = assembleWithJacobianOnBulkMeshOrOnSubmeshCommon(
                sad, t, dt, x, x_prev, dof_tables, process_id, *b_submesh, Jac,
                sorted_element_subset);
 
            MathLib::LinAlg::axpy(b, 1.0, *b_submesh);
 
            // TODO enabling this check needs a refactoring of postTimestep(),
            // computeSecondaryVariable() etc. hooks.
            if (/*copy_residua_to_mesh*/ true)
            {
                AssemblyMixinBase::copyResiduumVectorsToSubmesh(
                    process_id, *b_submesh, *(dof_tables[process_id]), sad);
            }
        }
 
        return exception;
    }

References assembleWithJacobianOnBulkMeshOrOnSubmeshCommon(), MathLib::LinAlg::axpy(), ProcessLib::AssemblyMixinBase::copyResiduumVectorsToSubmesh(), derived(), ProcessLib::Process::getMatrixSpecifications(), and ProcessLib::AssemblyMixinBase::submesh_assembly_data_.

Referenced by assembleWithJacobian().

AssemblyMixinBase()

template<typename Process>

ProcessLib::AssemblyMixinBase::AssemblyMixinBase ( AbstractJacobianAssembler & jacobian_assembler, bool const is_linear, bool const use_monolithic_scheme )

explicitprivate

Definition at line 32 of file AssemblyMixin.cpp.

    : pvma_{jacobian_assembler}, is_linear_{is_linear}
{
    if (is_linear && !use_monolithic_scheme)
    {
        OGS_FATAL(
            "You requested to assemble only once in combination with staggered "
            "coupling. This use case is not yet implemented.");
    }
 
    if (is_linear_)
    {
        WARN(
            "You specified that the process simulated by OGS is linear. With "
            "this optimization, the system is assembled only once, and the "
            "non-linear solver performs a single iteration per time step. No "
            "non-linearities will be resolved, and OGS will not detect whether "
            "any exist. It is your responsibility to ensure that the assembled "
            "systems are indeed linear; there is no safety net.\n"
            "\n"
            "Be aware that non-linearities may arise in subtle ways. For "
            "example, in an HT problem with a steady-state velocity field, if "
            "the initial pressure field does not match the steady-state "
            "condition (e.g., initialized to zero), then the steady-state "
            "velocity field only emerges during the first iteration—making the "
            "system effectively non-linear under this optimization.");
    }
}

References OGS_FATAL.

derived() [1/2]

template<typename Process>

Process & ProcessLib::AssemblyMixin< Process >::derived ( )

inlineprivate

Definition at line 257 of file AssemblyMixin.h.

{ return static_cast<Process&>(*this); }

References Process.

Referenced by assemble(), assembleOnBulkMeshOrOnSubmeshCommon(), assembleOnSubmeshes(), assembleWithJacobian(), assembleWithJacobianOnBulkMeshOrOnSubmeshCommon(), assembleWithJacobianOnSubmeshes(), initializeAssemblyOnSubmeshes(), preOutputNewton(), preOutputPicard(), and updateActiveElements().

derived() [2/2]

template<typename Process>

Process const & ProcessLib::AssemblyMixin< Process >::derived ( ) const

inlineprivate

Definition at line 258 of file AssemblyMixin.h.

    {
        return static_cast<Process const&>(*this);
    }

References Process.

initializeAssemblyOnSubmeshes()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::initializeAssemblyOnSubmeshes ( std::vector< std::reference_wrapper< MeshLib::Mesh > > const & submeshes, std::vector< std::vector< std::string > > const & residuum_names )

inline

Specifies that the assembly of the process should take place on the passed submeshes.

Note

This method must be called at most once.

Attention

The passed submeshes must be non-overlapping and must cover the entire simulation domain. The caller is responsible to meet this requirement.

The order of the passed residuum_names matters and must match the order of the residuum vectors in the process. Otherwise residuum output on submeshes will be wrong.

Note

As of January 2023 assembly on submeshes has neither been tested with domain decomposition, nor with domain deactivation nor staggered coupling. Use at your own risk in these cases.

Todo

Implement and test with domain decomposition, domain deactivation and staggered coupling.

Definition at line 123 of file AssemblyMixin.h.

    {
        AssemblyMixinBase::initializeAssemblyOnSubmeshes(
            derived().getMesh(), submeshes, residuum_names,
            derived().getProcessVariables());
    }

References derived(), and ProcessLib::AssemblyMixinBase::initializeAssemblyOnSubmeshes().

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::initializeAssemblyOnSubmeshes(), ProcessLib::HeatConduction::HeatConductionProcess::initializeAssemblyOnSubmeshes(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::initializeAssemblyOnSubmeshes(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeAssemblyOnSubmeshes().

preOutput()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::preOutput ( double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, int const process_id )

inline

Definition at line 233 of file AssemblyMixin.h.

    {
        if (!last_assembly_was_)
        {
            WARN("AssemblyMixin. Skipping preOutput() step.");
            return;
        }
 
        switch (*last_assembly_was_)
        {
            case NumLib::NonlinearSolverTag::Picard:
                preOutputPicard(t, dt, x, x_prev, process_id);
                return;
            case NumLib::NonlinearSolverTag::Newton:
                preOutputNewton(t, dt, x, x_prev, process_id);
                return;
        }
    }

References ProcessLib::AssemblyMixinBase::last_assembly_was_, NumLib::Newton, NumLib::Picard, preOutputNewton(), preOutputPicard(), and WARN().

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::preOutputConcreteProcess(), and ProcessLib::HeatConduction::HeatConductionProcess::preOutputConcreteProcess().

preOutputNewton()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::preOutputNewton ( double const , double const , std::vector< GlobalVector * > const & , std::vector< GlobalVector * > const & , int const  )

inlineprivate

Definition at line 510 of file AssemblyMixin.h.

    {
        // TODO enabling this needs a refactoring of postTimestep(),
        // computeSecondaryVariable() etc. hooks.
#if 0
        auto const matrix_specification =
            derived().getMatrixSpecifications(process_id);
 
        auto Jac = MathLib::MatrixVectorTraits<GlobalMatrix>::newInstance(
            matrix_specification);
        auto b = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(
            matrix_specification);
 
        Jac->setZero();
        b->setZero();
 
        assembleWithJacobian(t, dt, x, x_prev, process_id, *b, *Jac, nullptr,
                             true);
#endif
    }

References assembleWithJacobian(), derived(), and ProcessLib::Process::getMatrixSpecifications().

Referenced by preOutput().

preOutputPicard()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::preOutputPicard ( double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, int const process_id )

inlineprivate

Definition at line 487 of file AssemblyMixin.h.

    {
        auto const matrix_specification =
            derived().getMatrixSpecifications(process_id);
 
        auto M = MathLib::MatrixVectorTraits<GlobalMatrix>::newInstance(
            matrix_specification);
        auto K = MathLib::MatrixVectorTraits<GlobalMatrix>::newInstance(
            matrix_specification);
        auto b = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(
            matrix_specification);
 
        M->setZero();
        K->setZero();
        b->setZero();
 
        assemble(t, dt, x, x_prev, process_id, *M, *K, *b, nullptr, true);
    }

References assemble(), derived(), and ProcessLib::Process::getMatrixSpecifications().

Referenced by preOutput().

updateActiveElements()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::updateActiveElements ( )

inline

Definition at line 132 of file AssemblyMixin.h.

    {
        AssemblyMixinBase::updateActiveElements(derived());
    }

References derived(), and ProcessLib::AssemblyMixinBase::updateActiveElements().

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::preTimestepConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::preTimestepConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::preTimestepConcreteProcess(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::preTimestepConcreteProcess().

Member Data Documentation

Process

template<typename Process>

friend ProcessLib::AssemblyMixin< Process >::Process

private

Definition at line 99 of file AssemblyMixin.h.

Referenced by derived(), and derived().

---

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

• AssemblyMixin.h