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

[legend]

Collaboration diagram for ProcessLib::AssemblyMixin< Process >:

[legend]

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);
 
        [[unlikely]] if (BaseLib::MPI::anyOf(exception != nullptr))
        {
            if (exception)  // Only the rank with the exception rethrows...
            {
                std::rethrow_exception(exception);
            }
            // TODO should other ranks rather throw a new exception?
            // ... but all ranks quit.
            return;
        }
 
        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::anyOf(), 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 327 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 281 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 357 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 189 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);
 
        [[unlikely]] if (BaseLib::MPI::anyOf(exception != nullptr))
        {
            if (exception)  // Only the rank with the exception rethrows...
            {
                std::rethrow_exception(exception);
            }
            // ... but all ranks quit.
            return;
        }
 
        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::anyOf(), 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 439 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 468 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 274 of file AssemblyMixin.h.

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

ProcessLib::AssemblyMixin::Process

friend Process

Definition AssemblyMixin.h:99

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 275 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 250 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 527 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 504 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

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Member Function Documentation

◆ assemble()

◆ assembleOnBulkMesh()

◆ assembleOnBulkMeshOrOnSubmeshCommon()

◆ assembleOnSubmeshes()

◆ assembleWithJacobian()

◆ assembleWithJacobianOnBulkMeshOrOnSubmeshCommon()

◆ assembleWithJacobianOnSubmeshes()

◆ AssemblyMixinBase()

◆ derived() [1/2]

◆ derived() [2/2]

◆ initializeAssemblyOnSubmeshes()

◆ preOutput()

◆ preOutputNewton()

◆ preOutputPicard()

◆ updateActiveElements()

Member Data Documentation

◆ Process