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 33 of file VectorMatrixAssembler.h.

#include <VectorMatrixAssembler.h>

Public Member Functions
	VectorMatrixAssembler (std::unique_ptr< 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< std::reference_wrapper< NumLib::LocalToGlobalIndexMap >> const &dof_tables, double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b)
void	assembleWithJacobian (std::size_t const mesh_item_id, LocalAssemblerInterface &local_assembler, std::vector< std::reference_wrapper< NumLib::LocalToGlobalIndexMap >> const &dof_tables, const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, const double dxdot_dx, const double dx_dx, int const process_id, GlobalMatrix &M, GlobalMatrix &K, 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
std::unique_ptr< AbstractJacobianAssembler >	_jacobian_assembler
	Used to assemble the Jacobian. More...

Constructor & Destructor Documentation

VectorMatrixAssembler()

ProcessLib::VectorMatrixAssembler::VectorMatrixAssembler ( std::unique_ptr< AbstractJacobianAssembler > &&  jacobian_assembler )

explicit

Definition at line 24 of file VectorMatrixAssembler.cpp.

    : _jacobian_assembler(std::move(jacobian_assembler))
{
}

Member Function Documentation

assemble()

void ProcessLib::VectorMatrixAssembler::assemble	(	std::size_t const	mesh_item_id,
		LocalAssemblerInterface &	local_assembler,
		std::vector< std::reference_wrapper< NumLib::LocalToGlobalIndexMap >> const &	dof_tables,
		double const	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	xdot,
		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 41 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_xdot = xdot[process_id]->get(indices);
        local_assembler.assemble(t, dt, local_x, local_xdot, _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_xdots =
            getCoupledLocalSolutions(xdot, indices_of_processes);
        auto const local_xdot = MathLib::toVector(local_coupled_xdots);
 
        local_assembler.assembleForStaggeredScheme(
            t, dt, local_x, local_xdot, 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 (!_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 (!_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 (!_local_b_data.empty())
    {
        assert(_local_b_data.size() == num_r_c);
        b.add(indices, _local_b_data);
    }
}

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

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::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::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleConcreteProcess(), ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >::assembleConcreteProcess(), ProcessLib::TES::TESProcess::assembleConcreteProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess(), and ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::assembleConcreteProcess().

assembleWithJacobian()

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

Assembles M, K, b, and the Jacobian Jac of the residual.

Note

The Jacobian must be assembled.

Definition at line 106 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();
    _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_xdot = xdot[process_id]->get(indices);
        _jacobian_assembler->assembleWithJacobian(
            local_assembler, t, dt, local_x, local_xdot, dxdot_dx, dx_dx,
            _local_M_data, _local_K_data, _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_xdots =
            getCoupledLocalSolutions(xdot, indices_of_processes);
        auto const local_xdot = MathLib::toVector(local_coupled_xdots);
 
        _jacobian_assembler->assembleWithJacobianForStaggeredScheme(
            local_assembler, t, dt, local_x, local_xdot, dxdot_dx, dx_dx,
            process_id, _local_M_data, _local_K_data, _local_b_data,
            _local_Jac_data);
    }
 
    auto const num_r_c = indices.size();
    auto const r_c_indices =
        NumLib::LocalToGlobalIndexMap::RowColumnIndices(indices, indices);
 
    if (!_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 (!_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 (!_local_b_data.empty())
    {
        assert(_local_b_data.size() == num_r_c);
        b.add(indices, _local_b_data);
    }
    if (!_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.");
    }
}

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

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::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::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess(), and ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::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 30 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().

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::preAssembleConcreteProcess().

Member Data Documentation

_jacobian_assembler

std::unique_ptr<AbstractJacobianAssembler> ProcessLib::VectorMatrixAssembler::_jacobian_assembler

private

Used to assemble the Jacobian.

Definition at line 77 of file VectorMatrixAssembler.h.

Referenced by assembleWithJacobian().

_local_b_data

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

private

Definition at line 73 of file VectorMatrixAssembler.h.

Referenced by assemble(), and assembleWithJacobian().

_local_Jac_data

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

private

Definition at line 74 of file VectorMatrixAssembler.h.

Referenced by assembleWithJacobian().

_local_K_data

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

private

Definition at line 72 of file VectorMatrixAssembler.h.

Referenced by assemble(), and assembleWithJacobian().

_local_M_data

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

private

Definition at line 71 of file VectorMatrixAssembler.h.

Referenced by assemble(), and assembleWithJacobian().

---

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

• ProcessLib/VectorMatrixAssembler.h
• ProcessLib/VectorMatrixAssembler.cpp