ProcessLib::ComponentTransport::ComponentTransportProcess Class Reference

Detailed Description

ComponentTransport process

Governing equations

The flow process is described by

\[\left(\rho \beta_s + \phi \frac{\partial \rho}{\partial p} \right)\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, \]

\(\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, \(g\) is the gravitational acceleration, and \(\beta_s = \frac{\partial \phi}{\partial p}\).

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 88 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
std::vector< std::vector< std::string > >	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &meshes) override
void	preTimestepConcreteProcess (std::vector< GlobalVector * > const &, const double, const double, const int) 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	~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 Member Functions inherited from ProcessLib::AssemblyMixin< ComponentTransportProcess >
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 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
bool const	_ls_compute_only_upon_timestep_change

Friends
class	AssemblyMixin< ComponentTransportProcess >

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 34 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),
      AssemblyMixin<ComponentTransportProcess>{*_jacobian_assembler, is_linear,
                                               use_monolithic_scheme},
      _process_data(std::move(process_data)),
      _surfaceflux(std::move(surfaceflux)),
      _chemical_solver_interface(std::move(chemical_solver_interface)),
      _ls_compute_only_upon_timestep_change{
          ls_compute_only_upon_timestep_change}
{
    this->_jacobian_assembler->checkPerturbationSize(_process_variables.size());
 
    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.");
    }
 
    if (_use_monolithic_scheme)
    {
        // For numerical Jacobian:
        std::vector<int> non_deformation_component_ids(
            _process_variables.size());
        std::iota(non_deformation_component_ids.begin(),
                  non_deformation_component_ids.end(), 0);
        this->_jacobian_assembler->setNonDeformationComponentIDsNoSizeCheck(
            non_deformation_component_ids);
    }
}

References ComponentTransportProcess(), ProcessLib::Process::Process(), ProcessLib::Process::_jacobian_assembler, and ProcessLib::Process::name.

Referenced by ComponentTransportProcess(), and AssemblyMixin< ComponentTransportProcess >.

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 233 of file ComponentTransportProcess.cpp.

{
    DBUG("Assemble ComponentTransportProcess.");
 
    if (!_use_monolithic_scheme)
    {
        this->_jacobian_assembler->setNonDeformationComponentIDsNoSizeCheck(
            {process_id});
    }
 
    AssemblyMixin<ComponentTransportProcess>::assemble(t, dt, x, x_prev,
                                                       process_id, M, K, b);
 
    // 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 ProcessLib::Process::_jacobian_assembler, _process_data, ProcessLib::Process::_use_monolithic_scheme, ProcessLib::AssemblyMixin< Process >::assemble(), NumLib::computeFluxCorrectedTransport(), DBUG(), and ProcessLib::Process::getMatrixSpecifications().

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 262 of file ComponentTransportProcess.cpp.

{
    DBUG("AssembleWithJacobian ComponentTransportProcess.");
 
    if (_use_monolithic_scheme)
    {
        OGS_FATAL(
            "The AssembleWithJacobian() for ComponentTransportProcess is "
            "implemented only for staggered scheme.");
    }
 
    if (!_process_data.isothermal)
    {
        OGS_FATAL(
            "The Newton-Raphson scheme (AssembleWithJacobian()) is not "
            "implemented for non-isothermal ComponentTransport. Please use the "
            "Picard scheme for non-isothermal setups.");
    }
 
    AssemblyMixin<ComponentTransportProcess>::assembleWithJacobian(
        t, dt, x, x_prev, process_id, b, Jac);
}

References _process_data, ProcessLib::Process::_use_monolithic_scheme, ProcessLib::AssemblyMixin< Process >::assembleWithJacobian(), DBUG(), 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 426 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(); });
 
    // Refresh ip_data.porosity first: assembly pinned it to porosity_prev, and
    // computeSecondaryVariable below averages it into the permeability output.
    if (_chemical_solver_interface)
    {
        GlobalExecutor::executeSelectedMemberOnDereferenced(
            &ComponentTransportLocalAssemblerInterface::
                computeReactionRelatedSecondaryVariable,
            local_assemblers_, _chemical_solver_interface->activeElementIDs());
    }
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &ComponentTransportLocalAssemblerInterface::computeSecondaryVariable,
        local_assemblers_, getActiveElementIDs(), dof_tables, t, dt, x, x_prev,
        process_id);
}

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

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 288 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 ProcessLib::Process::_local_to_global_index_map, ProcessLib::getCoupledLocalSolutions(), NumLib::getRowColumnIndices(), and local_assemblers_.

initializeAssemblyOnSubmeshes()

std::vector< std::vector< std::string > > ProcessLib::ComponentTransport::ComponentTransportProcess::initializeAssemblyOnSubmeshes ( std::vector< std::reference_wrapper< MeshLib::Mesh > > const & meshes )

overridevirtual

Initializes the assembly on submeshes

Parameters

meshes

the submeshes on whom the assembly shall proceed.

Attention

meshes must be a must be a non-overlapping cover of the entire simulation domain (bulk mesh)!

Returns

The names of the residuum vectors that will be assembled for each process: outer vector of size 1 for monolithic schemes and greater for staggered schemes.

Reimplemented from ProcessLib::SubmeshAssemblySupport.

Definition at line 460 of file ComponentTransportProcess.cpp.

{
    DBUG("CT process initializeSubmeshOutput().");
 
    namespace R = ranges;
    namespace RV = ranges::views;
 
    auto get_residuum_name =
        [](ProcessLib::ProcessVariable 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";
    };
 
    auto get_residuum_names = [get_residuum_name](auto const& pvs)
    { return pvs | RV::transform(get_residuum_name); };
 
    auto residuum_names = _process_variables |
                          RV::transform(get_residuum_names) |
                          R::to<std::vector<std::vector<std::string>>>();
 
    AssemblyMixin<ComponentTransportProcess>::initializeAssemblyOnSubmeshes(
        meshes, residuum_names);
 
    return residuum_names;
}

References ProcessLib::Process::_process_variables, DBUG(), and ProcessLib::AssemblyMixin< Process >::initializeAssemblyOnSubmeshes().

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 102 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);
    _process_data.mesh_prop_permeability =
        MeshLib::getOrCreateMeshProperty<double>(
            const_cast<MeshLib::Mesh&>(mesh), "permeability_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)
    {
        // Note: active element IDs from ChemicalSolverInterface are
        // initialized from the reactive domain mesh's bulk_element_ids
        // property. When meshes are partitioned with partmesh, the
        // bulk_element_ids are already renumbered to partition-local
        // element indices (by renumberBulkElementIdsProperty), so no
        // additional remapping is needed.
 
        GlobalExecutor::executeSelectedMemberOnDereferenced(
            &ComponentTransportLocalAssemblerInterface::setChemicalSystemID,
            local_assemblers_, _chemical_solver_interface->activeElementIDs());
 
        _chemical_solver_interface->initialize();
    }
 
    _secondary_variables.addSecondaryVariable(
        "liquid_density",
        makeExtrapolator(
            1, getExtrapolator(), local_assemblers_,
            &ComponentTransportLocalAssemblerInterface::getIntPtLiquidDensity));
 
    _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, _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::getIntPtLiquidDensity(), ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::getIntPtMolarFlux(), MeshLib::getOrCreateMeshProperty(), MeshLib::Mesh::isAxiallySymmetric(), local_assemblers_, ProcessLib::makeExtrapolator(), and ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::setChemicalSystemID().

isLinear()

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

inlineoverride

Definition at line 117 of file ComponentTransportProcess.h.

    {
        return AssemblyMixin<ComponentTransportProcess>::isLinear();
    }

References ProcessLib::AssemblyMixinBase::isLinear().

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 508 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, ProcessLib::Process::_mesh, _surfaceflux, NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::Process::getActiveElementIDs(), local_assemblers_, 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 538 of file ComponentTransportProcess.cpp.

{
    AssemblyMixin<ComponentTransportProcess>::preOutput(t, dt, x, x_prev,
                                                        process_id);
}

References ProcessLib::AssemblyMixin< Process >::preOutput().

preTimestepConcreteProcess()

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

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 496 of file ComponentTransportProcess.cpp.

{
    if (process_id == 0)
    {
        AssemblyMixin<ComponentTransportProcess>::updateActiveElements();
    }
}

References ProcessLib::AssemblyMixin< Process >::updateActiveElements().

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 205 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, NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::initializeChemicalSystem(), and local_assemblers_.

shouldLinearSolverComputeOnlyUponTimestepChange()

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

inlineoverride

Definition at line 154 of file ComponentTransportProcess.h.

    {
        // TODO unify for all processes?
        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 306 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)
    {
        // Synchronize ghost node values before accessing solution vectors
        // for chemistry calculations (required for MPI)
        std::for_each(
            x.begin(), x.end(), [](auto const process_solution)
            { MathLib::LinAlg::setLocalAccessibleVector(*process_solution); });
 
        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, 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(), local_assemblers_, MathLib::LinAlg::matMult(), NumLib::GlobalMatrixProvider::provider, NumLib::GlobalVectorProvider::provider, ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface::setChemicalSystem(), MathLib::LinAlg::setLocalAccessibleVector(), and BaseLib::RunTime::start().

Friends And Related Symbol Documentation

AssemblyMixin< ComponentTransportProcess >

friend class AssemblyMixin< ComponentTransportProcess >

friend

Definition at line 88 of file ComponentTransportProcess.h.

References ComponentTransportProcess(), ProcessLib::Process::Process(), and ProcessLib::Process::name.

Member Data Documentation

_chemical_solver_interface

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

private

Definition at line 194 of file ComponentTransportProcess.h.

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

_ls_compute_only_upon_timestep_change

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

private

Definition at line 196 of file ComponentTransportProcess.h.

Referenced by shouldLinearSolverComputeOnlyUponTimestepChange().

_process_data

ComponentTransportProcessData ProcessLib::ComponentTransport::ComponentTransportProcess::_process_data

private

Definition at line 186 of file ComponentTransportProcess.h.

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

_surfaceflux

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

private

Definition at line 191 of file ComponentTransportProcess.h.

Referenced by postTimestepConcreteProcess().

local_assemblers_

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

private

Definition at line 189 of file ComponentTransportProcess.h.

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

---

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

• ComponentTransportProcess.h
• ComponentTransportProcess.cpp