ProcessLib::LiquidFlow::LiquidFlowProcess Class Reference

Detailed Description

A class to simulate the single phase flow process in porous media described by the governing equation:

\[ \left(\frac{\partial}{\partial p}(\phi \rho) + \rho \beta_s\right) \frac{\partial p}{\partial t} -\nabla \left(\rho\frac{\mathbf K}{\mu}(\nabla p + \rho g \nabla z)\right ) = \rho Q, \]

where

\begin{eqnarray*} &p:& \mbox{pore pressure,}\\ &\phi:& \mbox{porosity,}\\ &\rho:& \mbox{liquid or gas density,}\\ &\beta_s:& \mbox{specific storage,}\\ &{\mathbf K}:& \mbox{permeability,}\\ &\mu:& \mbox{viscosity,}\\ &g:& \mbox{gravitational constant,}\\ &Q:& \mbox{Source/sink term in m}^3/{\text s}.\\ \end{eqnarray*}

This governing equation represents the mass balance.

If the density is assumed constant, for example for a groundwater modelling, the governing equation is scaled with the density, and it becomes volume balanced as:

\[ \left(\frac{1}{\rho}\frac{\partial}{\partial p}(\phi \rho) + \beta_s\right) \frac{\partial p}{\partial t} -\nabla \left(\frac{\mathbf K}{\mu}(\nabla p + \rho g \nabla z)\right ) = Q, \]

An optional input tag equation_balance_type of this process can be used to select whether to use the volume balanced equation or the mass balanced equation. By default, we assume that volume balanced equation is used.

Be aware that the Neumann condition is

\begin{eqnarray*} & -\frac{\mathbf K}{\mu}(\nabla p + \rho g \nabla z) \cdot \mathbf n = q_v [\text{m/s}]: & \mbox{ for the volume balance equation,}\\ & -\rho\frac{\mathbf K}{\mu}(\nabla p + \rho g \nabla z) \cdot \mathbf n = q_f [\text{kg/m²/s}]: & \mbox{for the mass balance equation,} \end{eqnarray*}

with \( \mathbf n \) the outer normal of the boundary.

Definition at line 72 of file LiquidFlowProcess.h.

#include <LiquidFlowProcess.h>

Inheritance diagram for ProcessLib::LiquidFlow::LiquidFlowProcess:

Collaboration diagram for ProcessLib::LiquidFlow::LiquidFlowProcess:

Public Member Functions
	LiquidFlowProcess (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, LiquidFlowData &&process_data, SecondaryVariableCollection &&secondary_variables, std::unique_ptr< ProcessLib::SurfaceFluxData > &&surfaceflux, bool const is_linear)
void	computeSecondaryVariableConcrete (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id) override
bool	isLinear () const override
Eigen::Vector3d	getFlux (std::size_t const element_id, MathLib::Point3d const &p, double const t, std::vector< GlobalVector * > const &x) 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
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
virtual void	solveReactionEquation (std::vector< GlobalVector * > &, std::vector< GlobalVector * > const &, double const, double const, NumLib::EquationSystem &, int 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	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

Private Attributes
LiquidFlowData	_process_data
std::vector< std::unique_ptr< LiquidFlowLocalAssemblerInterface > >	_local_assemblers
std::unique_ptr< ProcessLib::SurfaceFluxData >	_surfaceflux
MeshLib::PropertyVector< double > *	_hydraulic_flow = nullptr
bool	_is_linear = false

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

LiquidFlowProcess()

ProcessLib::LiquidFlow::LiquidFlowProcess::LiquidFlowProcess	(	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,
		LiquidFlowData &&	process_data,
		SecondaryVariableCollection &&	secondary_variables,
		std::unique_ptr< ProcessLib::SurfaceFluxData > &&	surfaceflux,
		bool const	is_linear )

Definition at line 20 of file LiquidFlowProcess.cpp.

    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
              integration_order, std::move(process_variables),
              std::move(secondary_variables)),
      _process_data(std::move(process_data)),
      _surfaceflux(std::move(surfaceflux)),
      _is_linear(is_linear)
{
    DBUG("Create Liquid flow process.");
 
    // For numerical Jacobian assembler
    this->_jacobian_assembler->setNonDeformationComponentIDs(
        {0} /* only one variable: pressure */);
 
    std::string const residuum_name =
        _process_data.equation_balance_type == EquationBalanceType::volume
            ? "VolumetricFlowRate"
            : "MassFlowRate";
    _hydraulic_flow = MeshLib::getOrCreateMeshProperty<double>(
        mesh, residuum_name, MeshLib::MeshItemType::Node, 1);
}

References ProcessLib::Process::Process(), _hydraulic_flow, _is_linear, ProcessLib::Process::_jacobian_assembler, _process_data, _surfaceflux, DBUG(), MeshLib::getOrCreateMeshProperty(), ProcessLib::Process::name, MeshLib::Node, and ProcessLib::LiquidFlow::volume.

Member Function Documentation

assembleConcreteProcess()

void ProcessLib::LiquidFlow::LiquidFlowProcess::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 70 of file LiquidFlowProcess.cpp.

{
    DBUG("Assemble LiquidFlowProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
        getActiveElementIDs(), dof_table, t, dt, x, x_prev, process_id, &M, &K,
        &b);
 
    MathLib::finalizeMatrixAssembly(M);
    MathLib::finalizeMatrixAssembly(K);
    MathLib::finalizeVectorAssembly(b);
 
    auto const residuum = computeResiduum(dt, *x[0], *x_prev[0], M, K, b);
    transformVariableFromGlobalVector(residuum, 0 /*variable id*/,
                                      *_local_to_global_index_map,
                                      *_hydraulic_flow, std::negate<double>());
}

References ProcessLib::Process::_global_assembler, _hydraulic_flow, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::VectorMatrixAssembler::assemble(), ProcessLib::computeResiduum(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), MathLib::finalizeMatrixAssembly(), MathLib::finalizeVectorAssembly(), and ProcessLib::Process::getActiveElementIDs().

assembleWithJacobianConcreteProcess()

void ProcessLib::LiquidFlow::LiquidFlowProcess::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 96 of file LiquidFlowProcess.cpp.

{
    DBUG("AssembleWithJacobian LiquidFlowProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
        _local_assemblers, getActiveElementIDs(), dof_table, t, dt, x, x_prev,
        process_id, &b, &Jac);
}

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

computeSecondaryVariableConcrete()

void ProcessLib::LiquidFlow::LiquidFlowProcess::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 113 of file LiquidFlowProcess.cpp.

{
    DBUG("Compute the velocity for LiquidFlowProcess.");
    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(
        &LiquidFlowLocalAssemblerInterface::computeSecondaryVariable,
        _local_assemblers, getActiveElementIDs(), dof_tables, t, dt, x, x_prev,
        process_id);
}

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

getFlux()

Eigen::Vector3d ProcessLib::LiquidFlow::LiquidFlowProcess::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 129 of file LiquidFlowProcess.cpp.

{
    // fetch local_x from primary variable
    std::vector<GlobalIndexType> indices_cache;
    auto const r_c_indices = NumLib::getRowColumnIndices(
        element_id, *_local_to_global_index_map, indices_cache);
    constexpr int process_id = 0;  // monolithic scheme.
    std::vector<double> local_x(x[process_id]->get(r_c_indices.rows));
 
    return _local_assemblers[element_id]->getFlux(p, t, local_x);
}

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

initializeConcreteProcess()

void ProcessLib::LiquidFlow::LiquidFlowProcess::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 52 of file LiquidFlowProcess.cpp.

{
    int const mesh_space_dimension = _process_data.mesh_space_dimension;
    ProcessLib::createLocalAssemblers<LiquidFlowLocalAssembler>(
        mesh_space_dimension, mesh.getElements(), dof_table, _local_assemblers,
        NumLib::IntegrationOrder{integration_order}, mesh.isAxiallySymmetric(),
        _process_data);
 
    _secondary_variables.addSecondaryVariable(
        "darcy_velocity",
        makeExtrapolator(
            mesh_space_dimension, getExtrapolator(), _local_assemblers,
            &LiquidFlowLocalAssemblerInterface::getIntPtDarcyVelocity));
}

References _local_assemblers, _process_data, ProcessLib::Process::_secondary_variables, ProcessLib::createLocalAssemblers(), MeshLib::Mesh::getElements(), ProcessLib::Process::getExtrapolator(), ProcessLib::LiquidFlow::LiquidFlowLocalAssemblerInterface::getIntPtDarcyVelocity(), MeshLib::Mesh::isAxiallySymmetric(), and ProcessLib::makeExtrapolator().

isLinear()

bool ProcessLib::LiquidFlow::LiquidFlowProcess::isLinear ( ) const

inlineoverride

Definition at line 93 of file LiquidFlowProcess.h.

{ return _is_linear; }

References _is_linear.

postTimestepConcreteProcess()

void ProcessLib::LiquidFlow::LiquidFlowProcess::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 146 of file LiquidFlowProcess.cpp.

{
    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, and ProcessLib::Process::getActiveElementIDs().

Member Data Documentation

_hydraulic_flow

MeshLib::PropertyVector<double>* ProcessLib::LiquidFlow::LiquidFlowProcess::_hydraulic_flow = nullptr

private

Definition at line 128 of file LiquidFlowProcess.h.

Referenced by LiquidFlowProcess(), and assembleConcreteProcess().

_is_linear

bool ProcessLib::LiquidFlow::LiquidFlowProcess::_is_linear = false

private

Definition at line 129 of file LiquidFlowProcess.h.

Referenced by LiquidFlowProcess(), and isLinear().

_local_assemblers

std::vector<std::unique_ptr<LiquidFlowLocalAssemblerInterface> > ProcessLib::LiquidFlow::LiquidFlowProcess::_local_assemblers

private

Definition at line 125 of file LiquidFlowProcess.h.

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

_process_data

LiquidFlowData ProcessLib::LiquidFlow::LiquidFlowProcess::_process_data

private

Definition at line 122 of file LiquidFlowProcess.h.

Referenced by LiquidFlowProcess(), and initializeConcreteProcess().

_surfaceflux

std::unique_ptr<ProcessLib::SurfaceFluxData> ProcessLib::LiquidFlow::LiquidFlowProcess::_surfaceflux

private

Definition at line 127 of file LiquidFlowProcess.h.

Referenced by LiquidFlowProcess(), and postTimestepConcreteProcess().

---

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

• LiquidFlowProcess.h
• LiquidFlowProcess.cpp