ProcessLib::VectorMatrixAssembler Class Reference

Detailed Description

Utility class used to assemble global matrices and vectors.

The methods of this class get the global matrices and vectors as input and pass only local data on to the local assemblers.

Definition at line 25 of file VectorMatrixAssembler.h.

#include <VectorMatrixAssembler.h>

Collaboration diagram for ProcessLib::VectorMatrixAssembler:

Public Member Functions
	VectorMatrixAssembler (AbstractJacobianAssembler &jacobian_assembler)
void	preAssemble (const std::size_t mesh_item_id, LocalAssemblerInterface &local_assembler, const NumLib::LocalToGlobalIndexMap &dof_table, const double t, double const dt, const GlobalVector &x)
void	assemble (std::size_t const mesh_item_id, LocalAssemblerInterface &local_assembler, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, 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)
void	assembleWithJacobian (std::size_t const mesh_item_id, LocalAssemblerInterface &local_assembler, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalVector *b, GlobalMatrix *Jac)

Private Attributes
std::vector< double >	_local_M_data
std::vector< double >	_local_K_data
std::vector< double >	_local_b_data
std::vector< double >	_local_Jac_data
AbstractJacobianAssembler &	_jacobian_assembler
	Used to assemble the Jacobian.
Assembly::LocalMatrixOutput	_local_output

Constructor & Destructor Documentation

VectorMatrixAssembler()

ProcessLib::VectorMatrixAssembler::VectorMatrixAssembler ( AbstractJacobianAssembler & jacobian_assembler )

explicit

Definition at line 15 of file VectorMatrixAssembler.cpp.

    : _jacobian_assembler(jacobian_assembler)
{
}

References _jacobian_assembler.

Member Function Documentation

assemble()

void ProcessLib::VectorMatrixAssembler::assemble	(	std::size_t const	mesh_item_id,
		LocalAssemblerInterface &	local_assembler,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_tables,
		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 )

AssemblesM, K, and b.

Remarks

Jacobian is not assembled here, see assembleWithJacobian().

Definition at line 32 of file VectorMatrixAssembler.cpp.

{
    std::vector<std::vector<GlobalIndexType>> indices_of_processes;
    indices_of_processes.reserve(dof_tables.size());
    transform(cbegin(dof_tables), cend(dof_tables),
              back_inserter(indices_of_processes),
              [&](auto const dof_table)
              { return NumLib::getIndices(mesh_item_id, *dof_table); });
 
    auto const& indices = indices_of_processes[process_id];
    _local_M_data.clear();
    _local_K_data.clear();
    _local_b_data.clear();
 
    std::size_t const number_of_processes = x.size();
    // Monolithic scheme
    if (number_of_processes == 1)
    {
        auto const local_x = x[process_id]->get(indices);
        auto const local_x_prev = x_prev[process_id]->get(indices);
        local_assembler.assemble(t, dt, local_x, local_x_prev, _local_M_data,
                                 _local_K_data, _local_b_data);
    }
    else  // Staggered scheme
    {
        auto local_coupled_xs =
            getCoupledLocalSolutions(x, indices_of_processes);
        auto const local_x = MathLib::toVector(local_coupled_xs);
 
        auto local_coupled_x_prevs =
            getCoupledLocalSolutions(x_prev, indices_of_processes);
        auto const local_x_prev = MathLib::toVector(local_coupled_x_prevs);
 
        local_assembler.assembleForStaggeredScheme(
            t, dt, local_x, local_x_prev, process_id, _local_M_data,
            _local_K_data, _local_b_data);
    }
 
    auto const num_r_c = indices.size();
    auto const r_c_indices =
        NumLib::LocalToGlobalIndexMap::RowColumnIndices(indices, indices);
 
    if (M && !_local_M_data.empty())
    {
        auto const local_M = MathLib::toMatrix(_local_M_data, num_r_c, num_r_c);
        M->add(r_c_indices, local_M);
    }
    if (K && !_local_K_data.empty())
    {
        auto const local_K = MathLib::toMatrix(_local_K_data, num_r_c, num_r_c);
        K->add(r_c_indices, local_K);
    }
    if (b && !_local_b_data.empty())
    {
        assert(_local_b_data.size() == num_r_c);
        b->add(indices, _local_b_data);
    }
 
    _local_output(t, process_id, mesh_item_id, _local_M_data, _local_K_data,
                  _local_b_data);
}

References _local_b_data, _local_K_data, _local_M_data, _local_output, MathLib::EigenMatrix::add(), MathLib::EigenVector::add(), ProcessLib::LocalAssemblerInterface::assemble(), ProcessLib::LocalAssemblerInterface::assembleForStaggeredScheme(), ProcessLib::getCoupledLocalSolutions(), NumLib::getIndices(), MathLib::toMatrix(), and MathLib::toVector().

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleConcreteProcess(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), and ProcessLib::WellboreSimulator::WellboreSimulatorProcess::assembleConcreteProcess().

assembleWithJacobian()

void ProcessLib::VectorMatrixAssembler::assembleWithJacobian	(	std::size_t const	mesh_item_id,
		LocalAssemblerInterface &	local_assembler,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_tables,
		const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	x_prev,
		int const	process_id,
		GlobalVector *	b,
		GlobalMatrix *	Jac )

Assembles b, and the Jacobian Jac of the residual.

Note

The Jacobian must be assembled.

Definition at line 99 of file VectorMatrixAssembler.cpp.

{
    std::vector<std::vector<GlobalIndexType>> indices_of_processes;
    indices_of_processes.reserve(dof_tables.size());
    transform(cbegin(dof_tables), cend(dof_tables),
              back_inserter(indices_of_processes),
              [&](auto const dof_table)
              { return NumLib::getIndices(mesh_item_id, *dof_table); });
 
    auto const& indices = indices_of_processes[process_id];
 
    _local_b_data.clear();
    _local_Jac_data.clear();
 
    std::size_t const number_of_processes = x.size();
    // Monolithic scheme
    if (number_of_processes == 1)
    {
        auto const local_x = x[process_id]->get(indices);
        auto const local_x_prev = x_prev[process_id]->get(indices);
        _jacobian_assembler.assembleWithJacobian(
            local_assembler, t, dt, local_x, local_x_prev, _local_b_data,
            _local_Jac_data);
    }
    else  // Staggered scheme
    {
        auto local_coupled_xs =
            getCoupledLocalSolutions(x, indices_of_processes);
        auto const local_x = MathLib::toVector(local_coupled_xs);
 
        auto local_coupled_x_prevs =
            getCoupledLocalSolutions(x_prev, indices_of_processes);
        auto const local_x_prev = MathLib::toVector(local_coupled_x_prevs);
 
        _jacobian_assembler.assembleWithJacobianForStaggeredScheme(
            local_assembler, t, dt, local_x, local_x_prev, process_id,
            _local_b_data, _local_Jac_data);
    }
 
    auto const num_r_c = indices.size();
    auto const r_c_indices =
        NumLib::LocalToGlobalIndexMap::RowColumnIndices(indices, indices);
 
    if (b && !_local_b_data.empty())
    {
        assert(_local_b_data.size() == num_r_c);
        b->add(indices, _local_b_data);
    }
    if (Jac && !_local_Jac_data.empty())
    {
        auto const local_Jac =
            MathLib::toMatrix(_local_Jac_data, num_r_c, num_r_c);
        Jac->add(r_c_indices, local_Jac);
    }
    else
    {
        OGS_FATAL(
            "No Jacobian has been assembled! This might be due to programming "
            "errors in the local assembler of the current process.");
    }
 
    _local_output(t, process_id, mesh_item_id, _local_b_data, _local_Jac_data);
}

References _jacobian_assembler, _local_b_data, _local_Jac_data, _local_output, MathLib::EigenMatrix::add(), MathLib::EigenVector::add(), ProcessLib::getCoupledLocalSolutions(), NumLib::getIndices(), OGS_FATAL, MathLib::toMatrix(), and MathLib::toVector().

Referenced by ProcessLib::HMPhaseField::HMPhaseFieldProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleWithJacobianConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), and ProcessLib::WellboreSimulator::WellboreSimulatorProcess::assembleWithJacobianConcreteProcess().

preAssemble()

void ProcessLib::VectorMatrixAssembler::preAssemble	(	const std::size_t	mesh_item_id,
		LocalAssemblerInterface &	local_assembler,
		const NumLib::LocalToGlobalIndexMap &	dof_table,
		const double	t,
		double const	dt,
		const GlobalVector &	x )

Definition at line 21 of file VectorMatrixAssembler.cpp.

{
    auto const indices = NumLib::getIndices(mesh_item_id, dof_table);
    auto const local_x = x.get(indices);
 
    local_assembler.preAssemble(t, dt, local_x);
}

References MathLib::EigenVector::get(), NumLib::getIndices(), and ProcessLib::LocalAssemblerInterface::preAssemble().

Member Data Documentation

_jacobian_assembler

AbstractJacobianAssembler& ProcessLib::VectorMatrixAssembler::_jacobian_assembler

private

Used to assemble the Jacobian.

Definition at line 65 of file VectorMatrixAssembler.h.

Referenced by VectorMatrixAssembler(), and assembleWithJacobian().

_local_b_data

std::vector<double> ProcessLib::VectorMatrixAssembler::_local_b_data

private

Definition at line 61 of file VectorMatrixAssembler.h.

Referenced by assemble(), and assembleWithJacobian().

_local_Jac_data

std::vector<double> ProcessLib::VectorMatrixAssembler::_local_Jac_data

private

Definition at line 62 of file VectorMatrixAssembler.h.

Referenced by assembleWithJacobian().

_local_K_data

std::vector<double> ProcessLib::VectorMatrixAssembler::_local_K_data

private

Definition at line 60 of file VectorMatrixAssembler.h.

Referenced by assemble().

_local_M_data

std::vector<double> ProcessLib::VectorMatrixAssembler::_local_M_data

private

Definition at line 59 of file VectorMatrixAssembler.h.

Referenced by assemble().

_local_output

Assembly::LocalMatrixOutput ProcessLib::VectorMatrixAssembler::_local_output

private

Definition at line 67 of file VectorMatrixAssembler.h.

Referenced by assemble(), and assembleWithJacobian().

---

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

• VectorMatrixAssembler.h
• VectorMatrixAssembler.cpp