ProcessLib::ComponentTransport::ComponentTransportProcess Class Reference

Detailed Description

ComponentTransport process

Governing equations

The flow process is described by

\[\phi \frac{\partial \rho}{\partial p} \frac{\partial p}{\partial t} + \phi \frac{\partial \rho}{\partial C} \frac{\partial C}{\partial t} - \nabla \cdot \left[\frac{\kappa}{\mu(C)} \rho \nabla \left( p + \rho g z \right)\right] + Q_p = 0, \]

where the storage \(S\) has been substituted by \(\phi \frac{\partial \rho}{\partial p}\), \(\phi\) is the porosity, \(C\) is the concentration, \(p\) is the pressure, \(\kappa\) is permeability, \(\mu\) is viscosity of the fluid, \(\rho\) is the density of the fluid, and \(g\) is the gravitational acceleration.

The mass transport process is described by

\[\phi R C \frac{\partial \rho}{\partial p} \frac{\partial p}{\partial t} + \phi R \left(\rho + C \frac{\partial \rho}{\partial C}\right) \frac{\partial C}{\partial t} - \nabla \cdot \left[\frac{\kappa}{\mu(C)} \rho C \nabla \left( p + \rho g z \right) + \rho D \nabla C\right] + Q_C + R \vartheta \phi \rho C = 0, \]

where \(R\) is the retardation factor, \(\vec{q} = -\frac{\kappa}{\mu(C)} \nabla \left( p + \rho g z \right)\) is the Darcy velocity, \(D\) is the hydrodynamic dispersion tensor, \(\vartheta\) is the decay rate.

For the hydrodynamic dispersion tensor the relation

\[D = (\phi D_d + \beta_T \|\vec{q}\|) I + (\beta_L - \beta_T) \frac{\vec{q} \vec{q}^T}{\|\vec{q}\|} \]

is implemented, where \(D_d\) is the molecular diffusion coefficient, \(\beta_L\) the longitudinal dispersivity of chemical species, and \(\beta_T\) the transverse dispersivity of chemical species.

The implementation uses a monolithic approach, i.e., both processes are assembled within one global system of equations.

Process Coupling

The advective term of the concentration equation is given by the confined groundwater flow process, i.e., the concentration distribution depends on Darcy velocity of the groundwater flow process. On the other hand the concentration dependencies of the viscosity and density in the groundwater flow couples the H process to the C process.

Note

At the moment there is not any coupling by source or sink terms, i.e., the coupling is implemented only by density and viscosity changes due to concentration changes as well as by the temporal derivatives of each variable.

Definition at line 95 of file ComponentTransportProcess.h.

#include <ComponentTransportProcess.h>

Inheritance diagram for ProcessLib::ComponentTransport::ComponentTransportProcess:

Collaboration diagram for ProcessLib::ComponentTransport::ComponentTransportProcess:

Public Member Functions
	ComponentTransportProcess (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > &&process_variables, ComponentTransportProcessData &&process_data, SecondaryVariableCollection &&secondary_variables, bool const use_monolithic_scheme, std::unique_ptr< ProcessLib::SurfaceFluxData > &&surfaceflux, std::unique_ptr< ChemistryLib::ChemicalSolverInterface > &&chemical_solver_interface, bool const is_linear, bool const ls_compute_only_upon_timestep_change)
Eigen::Vector3d	getFlux (std::size_t const element_id, MathLib::Point3d const &p, double const t, std::vector< GlobalVector * > const &x) const override
void	solveReactionEquation (std::vector< GlobalVector * > &x, std::vector< GlobalVector * > const &x_prev, double const t, double const dt, NumLib::EquationSystem &ode_sys, int const process_id) override
void	computeSecondaryVariableConcrete (double const, double const, std::vector< GlobalVector * > const &x, GlobalVector const &, int const) override
void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, const double dt, int const process_id) override
bool	shouldLinearSolverComputeOnlyUponTimestepChange () const override
ODESystem interface
bool	isLinear () const override
Public Member Functions inherited from ProcessLib::Process
	Process (std::string name_, MeshLib::Mesh &mesh, std::unique_ptr< AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > &&process_variables, SecondaryVariableCollection &&secondary_variables, const bool use_monolithic_scheme=true)
void	preTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, const int process_id)
	Preprocessing before starting assembly for new timestep.
void	postTimestep (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, const double delta_t, int const process_id)
	Postprocessing after a complete timestep.
void	postNonLinearSolver (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, double const dt, int const process_id)
void	preIteration (const unsigned iter, GlobalVector const &x) final
void	computeSecondaryVariable (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id)
	compute secondary variables for the coupled equations or for output.
NumLib::IterationResult	postIteration (GlobalVector const &x) final
void	initialize (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
void	setInitialConditions (std::vector< GlobalVector * > &process_solutions, std::vector< GlobalVector * > const &process_solutions_prev, double const t, int const process_id)
MathLib::MatrixSpecifications	getMatrixSpecifications (const int process_id) const override
void	updateDeactivatedSubdomains (double const time, const int process_id)
virtual bool	isMonolithicSchemeUsed () const
virtual void	extrapolateIntegrationPointValuesToNodes (const double, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > &)
void	preAssemble (const double t, double const dt, GlobalVector const &x) final
void	assemble (const double 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) final
void	assembleWithJacobian (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) final
void	preOutput (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id)
std::vector< NumLib::IndexValueVector< GlobalIndexType > > const *	getKnownSolutions (double const t, GlobalVector const &x, int const process_id) const final
virtual NumLib::LocalToGlobalIndexMap const &	getDOFTable (const int) const
MeshLib::Mesh &	getMesh () const
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > const &	getProcessVariables () const
std::vector< std::reference_wrapper< ProcessVariable > > const &	getProcessVariables (const int process_id) const
std::vector< std::size_t > const &	getActiveElementIDs () const
SecondaryVariableCollection const &	getSecondaryVariables () const
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const &	getIntegrationPointWriters () const
bool	requiresNormalization () const override
Public Member Functions inherited from ProcessLib::SubmeshAssemblySupport
virtual std::vector< std::vector< std::string > >	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &meshes)
virtual	~SubmeshAssemblySupport ()=default

Private Member Functions
void	initializeConcreteProcess (NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order) override
	Process specific initialization called by initialize().
void	setInitialConditionsConcreteProcess (std::vector< GlobalVector * > &x, double const t, int const process_id) override
void	assembleConcreteProcess (const double 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) override
void	assembleWithJacobianConcreteProcess (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) override
void	preOutputConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id) override

Private Attributes
ComponentTransportProcessData	_process_data
std::vector< std::unique_ptr< ComponentTransportLocalAssemblerInterface > >	_local_assemblers
std::unique_ptr< ProcessLib::SurfaceFluxData >	_surfaceflux
std::unique_ptr< ChemistryLib::ChemicalSolverInterface >	_chemical_solver_interface
std::vector< MeshLib::PropertyVector< double > * >	_residua
AssembledMatrixCache	_asm_mat_cache
bool const	_ls_compute_only_upon_timestep_change

Additional Inherited Members
Public Attributes inherited from ProcessLib::Process
std::string const	name
Static Public Attributes inherited from ProcessLib::Process
static PROCESSLIB_EXPORT const std::string	constant_one_parameter_name = "constant_one"
Protected Member Functions inherited from ProcessLib::Process
std::vector< NumLib::LocalToGlobalIndexMap const * >	getDOFTables (int const number_of_processes) const
NumLib::Extrapolator &	getExtrapolator () const
NumLib::LocalToGlobalIndexMap const &	getSingleComponentDOFTable () const
void	initializeProcessBoundaryConditionsAndSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
virtual void	constructDofTable ()
void	constructMonolithicProcessDofTable ()
void	constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_process_id)
virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool >	getDOFTableForExtrapolatorData () const
std::vector< GlobalIndexType >	getIndicesOfResiduumWithoutInitialCompensation () const override
void	setReleaseNodalForces (GlobalVector const *r_neq, int const process_id) override
Protected Attributes inherited from ProcessLib::Process
MeshLib::Mesh &	_mesh
std::unique_ptr< MeshLib::MeshSubset const >	_mesh_subset_all_nodes
std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_local_to_global_index_map
SecondaryVariableCollection	_secondary_variables
CellAverageData	cell_average_data_
std::unique_ptr< ProcessLib::AbstractJacobianAssembler >	_jacobian_assembler
VectorMatrixAssembler	_global_assembler
const bool	_use_monolithic_scheme
unsigned const	_integration_order
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > >	_integration_point_writer
GlobalSparsityPattern	_sparsity_pattern
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > >	_process_variables
std::vector< BoundaryConditionCollection >	_boundary_conditions

Constructor & Destructor Documentation

ComponentTransportProcess()

ProcessLib::ComponentTransport::ComponentTransportProcess::ComponentTransportProcess	(	std::string	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		unsigned const	integration_order,
		std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > &&	process_variables,
		ComponentTransportProcessData &&	process_data,
		SecondaryVariableCollection &&	secondary_variables,
		bool const	use_monolithic_scheme,
		std::unique_ptr< ProcessLib::SurfaceFluxData > &&	surfaceflux,
		std::unique_ptr< ChemistryLib::ChemicalSolverInterface > &&	chemical_solver_interface,
		bool const	is_linear,
		bool const	ls_compute_only_upon_timestep_change )

Definition at line 40 of file ComponentTransportProcess.cpp.

    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
              integration_order, std::move(process_variables),
              std::move(secondary_variables), use_monolithic_scheme),
      _process_data(std::move(process_data)),
      _surfaceflux(std::move(surfaceflux)),
      _chemical_solver_interface(std::move(chemical_solver_interface)),
      _asm_mat_cache{is_linear, use_monolithic_scheme},
      _ls_compute_only_upon_timestep_change{
          ls_compute_only_upon_timestep_change}
{
    if (ls_compute_only_upon_timestep_change)
    {
        // TODO move this feature to some common location for all processes.
        if (!is_linear)
        {
            OGS_FATAL(
                "Using the linear solver compute() method only upon timestep "
                "change only makes sense for linear model equations.");
        }
 
        WARN(
            "You specified that the ComponentTransport linear solver will do "
            "the compute() step only upon timestep change. This is an expert "
            "option. It is your responsibility to ensure that "
            "the conditions for the correct use of this feature are met! "
            "Otherwise OGS might compute garbage without being recognized. "
            "There is no safety net!");
 
        WARN(
            "You specified that the ComponentTransport linear solver will do "
            "the compute() step only upon timestep change. This option will "
            "only be used by the Picard non-linear solver. The Newton-Raphson "
            "non-linear solver will silently ignore this setting, i.e., it "
            "won't do any harm, there, but you won't observe the speedup you "
            "probably expect.");
    }
 
    auto residuum_name = [&](auto const& pv) -> std::string
    {
        std::string const& pv_name = pv.getName();
        if (pv_name == "pressure")
        {
            return "LiquidMassFlowRate";
        }
        if (pv_name == "temperature")
        {
            return "HeatFlowRate";
        }
        return pv_name + "FlowRate";
    };
 
    if (_use_monolithic_scheme)
    {
        int const process_id = 0;
        for (auto const& pv : _process_variables[process_id])
        {
            _residua.push_back(MeshLib::getOrCreateMeshProperty<double>(
                mesh, residuum_name(pv.get()), MeshLib::MeshItemType::Node, 1));
        }
    }
    else
    {
        for (auto const& pv : _process_variables)
        {
            _residua.push_back(MeshLib::getOrCreateMeshProperty<double>(
                mesh, residuum_name(pv[0].get()), MeshLib::MeshItemType::Node,
                1));
        }
    }
}

References ProcessLib::Process::Process(), _asm_mat_cache, _chemical_solver_interface, _ls_compute_only_upon_timestep_change, _process_data, ProcessLib::Process::_process_variables, _residua, _surfaceflux, ProcessLib::Process::_use_monolithic_scheme, MeshLib::getOrCreateMeshProperty(), ProcessLib::Process::name, MeshLib::Node, OGS_FATAL, and WARN().

Member Function Documentation

assembleConcreteProcess()

void ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess ( const double 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 )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 240 of file ComponentTransportProcess.cpp.

{
    DBUG("Assemble ComponentTransportProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    if (_use_monolithic_scheme)
    {
        dof_tables.push_back(_local_to_global_index_map.get());
    }
    else
    {
        std::generate_n(std::back_inserter(dof_tables),
                        _process_variables.size(),
                        [&]() { return _local_to_global_index_map.get(); });
    }
 
    _asm_mat_cache.assemble(t, dt, x, x_prev, process_id, &M, &K, &b,
                            dof_tables, _global_assembler, _local_assemblers,
                            getActiveElementIDs());
 
    // TODO (naumov) What about temperature? A test with FCT would reveal any
    // problems.
    if (process_id == _process_data.hydraulic_process_id)
    {
        return;
    }
    auto const matrix_specification = getMatrixSpecifications(process_id);
 
    NumLib::computeFluxCorrectedTransport(_process_data.stabilizer, t, dt, x,
                                          x_prev, process_id,
                                          matrix_specification, M, K, b);
}

References _asm_mat_cache, ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, _process_data, ProcessLib::Process::_process_variables, ProcessLib::Process::_use_monolithic_scheme, NumLib::computeFluxCorrectedTransport(), DBUG(), ProcessLib::Process::getActiveElementIDs(), and ProcessLib::Process::getMatrixSpecifications().

Referenced by preOutputConcreteProcess().

assembleWithJacobianConcreteProcess()

void ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess ( 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 )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 276 of file ComponentTransportProcess.cpp.

{
    DBUG("AssembleWithJacobian ComponentTransportProcess.");
 
    if (_use_monolithic_scheme)
    {
        OGS_FATAL(
            "The AssembleWithJacobian() for ComponentTransportProcess is "
            "implemented only for staggered scheme.");
    }
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
 
    std::generate_n(std::back_inserter(dof_tables), _process_variables.size(),
                    [&]() { return _local_to_global_index_map.get(); });
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
        _local_assemblers, getActiveElementIDs(), dof_tables, t, dt, x, x_prev,
        process_id, &b, &Jac);
 
    // b is the negated residumm used in the Newton's method.
    // Here negating b is to recover the primitive residuum.
    transformVariableFromGlobalVector(b, 0, *_local_to_global_index_map,
                                      *_residua[process_id],
                                      std::negate<double>());
}

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_process_variables, _residua, ProcessLib::Process::_use_monolithic_scheme, ProcessLib::VectorMatrixAssembler::assembleWithJacobian(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), ProcessLib::Process::getActiveElementIDs(), and OGS_FATAL.

computeSecondaryVariableConcrete()

void ProcessLib::ComponentTransport::ComponentTransportProcess::computeSecondaryVariableConcrete ( double const t, double const dt, std::vector< GlobalVector * > const & x, GlobalVector const & x_prev, int const process_id )

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 440 of file ComponentTransportProcess.cpp.

{
    if (process_id != 0)
    {
        return;
    }
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    dof_tables.reserve(x.size());
    std::generate_n(std::back_inserter(dof_tables), x.size(),
                    [&]() { return _local_to_global_index_map.get(); });
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &ComponentTransportLocalAssemblerInterface::computeSecondaryVariable,
        _local_assemblers, getActiveElementIDs(), dof_tables, t, dt, x, x_prev,
        process_id);
 
    if (!_chemical_solver_interface)
    {
        return;
    }
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &ComponentTransportLocalAssemblerInterface::
            computeReactionRelatedSecondaryVariable,
        _local_assemblers, _chemical_solver_interface->activeElementIDs());
}

References _chemical_solver_interface, _local_assemblers, ProcessLib::LocalAssemblerInterface::computeSecondaryVariable(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), and ProcessLib::Process::getActiveElementIDs().

getFlux()

Eigen::Vector3d ProcessLib::ComponentTransport::ComponentTransportProcess::getFlux ( std::size_t const element_id, MathLib::Point3d const & p, double const t, std::vector< GlobalVector * > const & x ) const

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 308 of file ComponentTransportProcess.cpp.

{
    std::vector<GlobalIndexType> indices_cache;
    auto const r_c_indices = NumLib::getRowColumnIndices(
        element_id, *_local_to_global_index_map, indices_cache);
 
    std::vector<std::vector<GlobalIndexType>> indices_of_all_coupled_processes{
        x.size(), r_c_indices.rows};
    auto const local_xs =
        getCoupledLocalSolutions(x, indices_of_all_coupled_processes);
 
    return _local_assemblers[element_id]->getFlux(p, t, local_xs);
}

References _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::getCoupledLocalSolutions(), and NumLib::getRowColumnIndices().

initializeConcreteProcess()

void ProcessLib::ComponentTransport::ComponentTransportProcess::initializeConcreteProcess ( NumLib::LocalToGlobalIndexMap const & dof_table, MeshLib::Mesh const & mesh, unsigned const integration_order )

overrideprivatevirtual

Process specific initialization called by initialize().

Implements ProcessLib::Process.

Definition at line 127 of file ComponentTransportProcess.cpp.

{
    int const mesh_space_dimension = _process_data.mesh_space_dimension;
 
    _process_data.mesh_prop_velocity = MeshLib::getOrCreateMeshProperty<double>(
        const_cast<MeshLib::Mesh&>(mesh), "velocity",
        MeshLib::MeshItemType::Cell, mesh_space_dimension);
 
    _process_data.mesh_prop_porosity = MeshLib::getOrCreateMeshProperty<double>(
        const_cast<MeshLib::Mesh&>(mesh), "porosity_avg",
        MeshLib::MeshItemType::Cell, 1);
 
    std::vector<std::reference_wrapper<ProcessLib::ProcessVariable>>
        transport_process_variables;
    if (_use_monolithic_scheme)
    {
        const int process_id = 0;
        for (auto pv_iter = std::next(_process_variables[process_id].begin());
             pv_iter != _process_variables[process_id].end();
             ++pv_iter)
        {
            transport_process_variables.push_back(*pv_iter);
        }
    }
    else
    {
        // All process variables but the pressure and optionally the temperature
        // are transport variables.
        for (auto const& pv :
             _process_variables |
                 ranges::views::drop(_process_data.isothermal ? 1 : 2))
        {
            transport_process_variables.push_back(pv[0]);
        }
    }
 
    ProcessLib::createLocalAssemblers<LocalAssemblerData>(
        mesh_space_dimension, mesh.getElements(), dof_table, _local_assemblers,
        NumLib::IntegrationOrder{integration_order}, mesh.isAxiallySymmetric(),
        _process_data, transport_process_variables);
 
    if (_chemical_solver_interface && !_use_monolithic_scheme)
    {
        GlobalExecutor::executeSelectedMemberOnDereferenced(
            &ComponentTransportLocalAssemblerInterface::setChemicalSystemID,
            _local_assemblers, _chemical_solver_interface->activeElementIDs());
 
        _chemical_solver_interface->initialize();
    }
 
    _secondary_variables.addSecondaryVariable(
        "darcy_velocity",
        makeExtrapolator(
            mesh_space_dimension, getExtrapolator(), _local_assemblers,
            &ComponentTransportLocalAssemblerInterface::getIntPtDarcyVelocity));
 
    for (std::size_t component_id = 0;
         component_id < transport_process_variables.size();
         ++component_id)
    {
        auto const& pv = transport_process_variables[component_id].get();
 
        auto integration_point_values_accessor = [component_id](
            ComponentTransportLocalAssemblerInterface const& loc_asm,
            const double t,
            std::vector<GlobalVector*> const& x,
            std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_tables,
            std::vector<double>& cache) -> auto const&
        {
            return loc_asm.getIntPtMolarFlux(t, x, dof_tables, cache,
                                             component_id);
        };
 
        _secondary_variables.addSecondaryVariable(
            pv.getName() + "Flux",
            makeExtrapolator(mesh_space_dimension, getExtrapolator(),
                             _local_assemblers,
                             integration_point_values_accessor));
    }
}

References _chemical_solver_interface, _local_assemblers, _process_data, ProcessLib::Process::_process_variables, ProcessLib::Process::_secondary_variables, ProcessLib::Process::_use_monolithic_scheme, MeshLib::Cell, ProcessLib::createLocalAssemblers(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), MeshLib::Mesh::getElements(), ProcessLib::Process::getExtrapolator(), ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::getIntPtDarcyVelocity(), ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::getIntPtMolarFlux(), MeshLib::getOrCreateMeshProperty(), MeshLib::Mesh::isAxiallySymmetric(), ProcessLib::makeExtrapolator(), and ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::setChemicalSystemID().

isLinear()

bool ProcessLib::ComponentTransport::ComponentTransportProcess::isLinear ( ) const

inlineoverride

Definition at line 120 of file ComponentTransportProcess.h.

{ return _asm_mat_cache.isLinear(); }

References _asm_mat_cache.

postTimestepConcreteProcess()

void ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess ( std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, const double t, const double dt, int const process_id )

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 473 of file ComponentTransportProcess.cpp.

{
    if (process_id != 0)
    {
        return;
    }
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    dof_tables.reserve(x.size());
    std::generate_n(std::back_inserter(dof_tables), x.size(),
                    [&]() { return _local_to_global_index_map.get(); });
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &ComponentTransportLocalAssemblerInterface::postTimestep,
        _local_assemblers, getActiveElementIDs(), dof_tables, x, x_prev, t, dt,
        process_id);
 
    if (!_surfaceflux)  // computing the surfaceflux is optional
    {
        return;
    }
    _surfaceflux->integrate(x, t, *this, process_id, _integration_order, _mesh,
                            getActiveElementIDs());
}

References ProcessLib::Process::_integration_order, _local_assemblers, ProcessLib::Process::_mesh, _surfaceflux, NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::Process::getActiveElementIDs(), and ProcessLib::LocalAssemblerInterface::postTimestep().

preOutputConcreteProcess()

void ProcessLib::ComponentTransport::ComponentTransportProcess::preOutputConcreteProcess ( const double t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, int const process_id )

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 503 of file ComponentTransportProcess.cpp.

{
    auto const matrix_specification = 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();
 
    assembleConcreteProcess(t, dt, x, x_prev, process_id, *M, *K, *b);
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    if (_use_monolithic_scheme)
    {
        dof_tables.push_back(_local_to_global_index_map.get());
    }
    else
    {
        std::generate_n(std::back_inserter(dof_tables),
                        _process_variables.size(),
                        [&]() { return _local_to_global_index_map.get(); });
    }
 
    BaseLib::RunTime time_residuum;
    time_residuum.start();
 
    if (_use_monolithic_scheme)
    {
        auto const residuum =
            computeResiduum(dt, *x[0], *x_prev[0], *M, *K, *b);
        for (std::size_t variable_id = 0; variable_id < _residua.size();
             ++variable_id)
        {
            transformVariableFromGlobalVector(
                residuum, variable_id, *dof_tables[0], *_residua[variable_id],
                std::negate<double>());
        }
    }
    else
    {
        auto const residuum = computeResiduum(dt, *x[process_id],
                                              *x_prev[process_id], *M, *K, *b);
        transformVariableFromGlobalVector(residuum, 0, *dof_tables[process_id],
                                          *_residua[process_id],
                                          std::negate<double>());
    }
 
    INFO("[time] Computing residuum flow rates took {:g} s",
         time_residuum.elapsed());
}

References ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_process_variables, _residua, ProcessLib::Process::_use_monolithic_scheme, assembleConcreteProcess(), ProcessLib::computeResiduum(), BaseLib::RunTime::elapsed(), ProcessLib::Process::getMatrixSpecifications(), INFO(), and BaseLib::RunTime::start().

setInitialConditionsConcreteProcess()

void ProcessLib::ComponentTransport::ComponentTransportProcess::setInitialConditionsConcreteProcess ( std::vector< GlobalVector * > & x, double const t, int const process_id )

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 211 of file ComponentTransportProcess.cpp.

{
    if (!_chemical_solver_interface)
    {
        return;
    }
 
    if (process_id != static_cast<int>(x.size() - 1))
    {
        return;
    }
 
    std::for_each(
        x.begin(), x.end(),
        [](auto const process_solution)
        { MathLib::LinAlg::setLocalAccessibleVector(*process_solution); });
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    dof_tables.reserve(x.size());
    std::generate_n(std::back_inserter(dof_tables), x.size(),
                    [&]() { return _local_to_global_index_map.get(); });
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &ComponentTransportLocalAssemblerInterface::initializeChemicalSystem,
        _local_assemblers, _chemical_solver_interface->activeElementIDs(),
        dof_tables, x, t);
}

References _chemical_solver_interface, _local_assemblers, NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), and ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::initializeChemicalSystem().

shouldLinearSolverComputeOnlyUponTimestepChange()

bool ProcessLib::ComponentTransport::ComponentTransportProcess::shouldLinearSolverComputeOnlyUponTimestepChange ( ) const

inlineoverride

Definition at line 145 of file ComponentTransportProcess.h.

    {
        return _ls_compute_only_upon_timestep_change;
    }

References _ls_compute_only_upon_timestep_change.

solveReactionEquation()

void ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation ( std::vector< GlobalVector * > & x, std::vector< GlobalVector * > const & x_prev, double const t, double const dt, NumLib::EquationSystem & ode_sys, int const process_id )

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 326 of file ComponentTransportProcess.cpp.

{
    // todo (renchao): move chemical calculation to elsewhere.
    if (_process_data.lookup_table && process_id == 0)
    {
        INFO("Update process solutions via the look-up table approach");
        _process_data.lookup_table->lookup(x, x_prev, _mesh.getNumberOfNodes());
 
        return;
    }
 
    if (!_chemical_solver_interface)
    {
        return;
    }
 
    // Sequential non-iterative approach applied here to split the reactive
    // transport process into the transport stage followed by the reaction
    // stage.
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    dof_tables.reserve(x.size());
    std::generate_n(std::back_inserter(dof_tables), x.size(),
                    [&]() { return _local_to_global_index_map.get(); });
 
    if (process_id == 0)
    {
        GlobalExecutor::executeSelectedMemberOnDereferenced(
            &ComponentTransportLocalAssemblerInterface::setChemicalSystem,
            _local_assemblers, _chemical_solver_interface->activeElementIDs(),
            dof_tables, x, t, dt);
 
        BaseLib::RunTime time_phreeqc;
        time_phreeqc.start();
 
        _chemical_solver_interface->setAqueousSolutionsPrevFromDumpFile();
 
        _chemical_solver_interface->executeSpeciationCalculation(dt);
 
        INFO("[time] Phreeqc took {:g} s.", time_phreeqc.elapsed());
 
        GlobalExecutor::executeSelectedMemberOnDereferenced(
            &ComponentTransportLocalAssemblerInterface::
                postSpeciationCalculation,
            _local_assemblers, _chemical_solver_interface->activeElementIDs(),
            t, dt);
 
        return;
    }
 
    auto const matrix_specification = getMatrixSpecifications(process_id);
 
    std::size_t matrix_id = 0u;
    auto& M = NumLib::GlobalMatrixProvider::provider.getMatrix(
        matrix_specification, matrix_id);
    auto& K = NumLib::GlobalMatrixProvider::provider.getMatrix(
        matrix_specification, matrix_id);
    auto& b =
        NumLib::GlobalVectorProvider::provider.getVector(matrix_specification);
 
    M.setZero();
    K.setZero();
    b.setZero();
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &ComponentTransportLocalAssemblerInterface::assembleReactionEquation,
        _local_assemblers, getActiveElementIDs(), dof_tables, x, t, dt, M, K, b,
        process_id);
 
    // todo (renchao): incorporate Neumann boundary condition
    MathLib::finalizeMatrixAssembly(M);
    MathLib::finalizeMatrixAssembly(K);
    MathLib::finalizeVectorAssembly(b);
 
    auto& A = NumLib::GlobalMatrixProvider::provider.getMatrix(
        matrix_specification, matrix_id);
    auto& rhs =
        NumLib::GlobalVectorProvider::provider.getVector(matrix_specification);
 
    A.setZero();
    rhs.setZero();
 
    MathLib::finalizeMatrixAssembly(A);
    MathLib::finalizeVectorAssembly(rhs);
 
    // compute A
    MathLib::LinAlg::copy(M, A);
    MathLib::LinAlg::aypx(A, 1.0 / dt, K);
 
    // compute rhs
    MathLib::LinAlg::matMult(M, *x[process_id], rhs);
    MathLib::LinAlg::aypx(rhs, 1.0 / dt, b);
 
    using Tag = NumLib::NonlinearSolverTag;
    using EqSys = NumLib::NonlinearSystem<Tag::Picard>;
    auto& equation_system = static_cast<EqSys&>(ode_sys);
    equation_system.applyKnownSolutionsPicard(
        A, rhs, *x[process_id],
        MathLib::DirichletBCApplicationMode::COMPLETE_MATRIX_UPDATE);
 
    auto& linear_solver =
        _process_data.chemical_solver_interface->linear_solver;
    MathLib::LinAlg::setLocalAccessibleVector(*x[process_id]);
    linear_solver.solve(A, rhs, *x[process_id]);
 
    NumLib::GlobalMatrixProvider::provider.releaseMatrix(M);
    NumLib::GlobalMatrixProvider::provider.releaseMatrix(K);
    NumLib::GlobalVectorProvider::provider.releaseVector(b);
    NumLib::GlobalMatrixProvider::provider.releaseMatrix(A);
    NumLib::GlobalVectorProvider::provider.releaseVector(rhs);
}

References _chemical_solver_interface, _local_assemblers, ProcessLib::Process::_mesh, _process_data, ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::assembleReactionEquation(), MathLib::LinAlg::aypx(), MathLib::COMPLETE_MATRIX_UPDATE, MathLib::LinAlg::copy(), BaseLib::RunTime::elapsed(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), MathLib::finalizeMatrixAssembly(), MathLib::finalizeVectorAssembly(), ProcessLib::Process::getActiveElementIDs(), ProcessLib::Process::getMatrixSpecifications(), INFO(), MathLib::LinAlg::matMult(), NumLib::GlobalMatrixProvider::provider, NumLib::GlobalVectorProvider::provider, ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::setChemicalSystem(), MathLib::LinAlg::setLocalAccessibleVector(), and BaseLib::RunTime::start().

Member Data Documentation

_asm_mat_cache

AssembledMatrixCache ProcessLib::ComponentTransport::ComponentTransportProcess::_asm_mat_cache

private

Definition at line 188 of file ComponentTransportProcess.h.

Referenced by ComponentTransportProcess(), assembleConcreteProcess(), and isLinear().

_chemical_solver_interface

std::unique_ptr<ChemistryLib::ChemicalSolverInterface> ProcessLib::ComponentTransport::ComponentTransportProcess::_chemical_solver_interface

private

Definition at line 184 of file ComponentTransportProcess.h.

Referenced by ComponentTransportProcess(), computeSecondaryVariableConcrete(), initializeConcreteProcess(), setInitialConditionsConcreteProcess(), and solveReactionEquation().

_local_assemblers

std::vector<std::unique_ptr<ComponentTransportLocalAssemblerInterface> > ProcessLib::ComponentTransport::ComponentTransportProcess::_local_assemblers

private

Definition at line 179 of file ComponentTransportProcess.h.

Referenced by assembleConcreteProcess(), assembleWithJacobianConcreteProcess(), computeSecondaryVariableConcrete(), getFlux(), initializeConcreteProcess(), postTimestepConcreteProcess(), setInitialConditionsConcreteProcess(), and solveReactionEquation().

_ls_compute_only_upon_timestep_change

bool const ProcessLib::ComponentTransport::ComponentTransportProcess::_ls_compute_only_upon_timestep_change

private

Definition at line 190 of file ComponentTransportProcess.h.

Referenced by ComponentTransportProcess(), and shouldLinearSolverComputeOnlyUponTimestepChange().

_process_data

ComponentTransportProcessData ProcessLib::ComponentTransport::ComponentTransportProcess::_process_data

private

Definition at line 176 of file ComponentTransportProcess.h.

Referenced by ComponentTransportProcess(), assembleConcreteProcess(), initializeConcreteProcess(), and solveReactionEquation().

_residua

std::vector<MeshLib::PropertyVector<double>*> ProcessLib::ComponentTransport::ComponentTransportProcess::_residua

private

Definition at line 186 of file ComponentTransportProcess.h.

Referenced by ComponentTransportProcess(), assembleWithJacobianConcreteProcess(), and preOutputConcreteProcess().

_surfaceflux

std::unique_ptr<ProcessLib::SurfaceFluxData> ProcessLib::ComponentTransport::ComponentTransportProcess::_surfaceflux

private

Definition at line 181 of file ComponentTransportProcess.h.

Referenced by ComponentTransportProcess(), and postTimestepConcreteProcess().

---

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

• ProcessLib/ComponentTransport/ComponentTransportProcess.h
• ProcessLib/ComponentTransport/ComponentTransportProcess.cpp