ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties Class Reference

Detailed Description

Definition at line 33 of file TwoPhaseFlowWithPrhoMaterialProperties.h.

#include <TwoPhaseFlowWithPrhoMaterialProperties.h>

Collaboration diagram for ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties:

Public Types
using	ArrayType = MaterialLib::Fluid::FluidProperty::ArrayType

Public Member Functions
	TwoPhaseFlowWithPrhoMaterialProperties (MeshLib::PropertyVector< int > const *material_ids, std::vector< std::unique_ptr< MaterialLib::PorousMedium::CapillaryPressureSaturation > > &&capillary_pressure_models, std::vector< std::unique_ptr< MaterialLib::PorousMedium::RelativePermeability > > &&relative_permeability_models)
int	getMaterialID (const std::size_t element_id)
double	getNonwetRelativePermeability (const double t, const ParameterLib::SpatialPosition &pos, const double p, const double T, const double saturation) const
double	getWetRelativePermeability (const double t, const ParameterLib::SpatialPosition &pos, const double p, const double T, const double saturation) const
double	getCapillaryPressure (const int material_id, const double t, const ParameterLib::SpatialPosition &pos, const double p, const double T, const double saturation) const
double	getCapillaryPressureDerivative (const int material_id, const double t, const ParameterLib::SpatialPosition &pos, const double p, const double T, const double saturation) const
bool	computeConstitutiveRelation (double const t, ParameterLib::SpatialPosition const &x, const int material_id, double const pg, double const X, double const T, double &Sw, double &X_m, double &dsw_dpg, double &dsw_dX, double &dxm_dpg, double &dxm_dX)

Protected Attributes
MeshLib::PropertyVector< int > const *const	_material_ids
std::vector< std::unique_ptr< MaterialLib::PorousMedium::CapillaryPressureSaturation > >	_capillary_pressure_models
std::vector< std::unique_ptr< MaterialLib::PorousMedium::RelativePermeability > >	_relative_permeability_models

Private Types
using	ResidualVector = Eigen::Matrix<double, jacobian_residual_size, 1>
using	JacobianMatrix
using	UnknownVector = Eigen::Matrix<double, jacobian_residual_size, 1>

Private Member Functions
void	calculateResidual (const int material_id, double const pl, double const X, double const T, double Sw, double rho_h2_wet, ResidualVector &res)
void	calculateJacobian (const int material_id, double const t, ParameterLib::SpatialPosition const &x, double const pl, double const X, double const T, JacobianMatrix &Jac, double Sw, double rho_h2_wet)
double	calculatedSwdP (double pl, double S, double rho_wet_h2, double const T, int current_material_id) const
double	calculatedSwdX (double const pl, const double, const double S, const double rho_wet_h2, double const T, int current_material_id) const
double	calculatedXmdX (double pl, double Sw, double rho_wet_h2, double dSwdX, int current_material_id) const
double	calculatedXmdP (double pl, double Sw, double rho_wet_h2, double dSwdP, int current_material_id) const

Static Private Member Functions
static double	calculateEquilibiumRhoWetLight (double const pg, double const Sw, double const rho_wet_h2)
static double	calculateSaturation (double, double X, double Sw, double rho_wet_h2, double rho_nonwet_h2, double)

Static Private Attributes
static int const	jacobian_residual_size = 2

Member Typedef Documentation

ArrayType

using ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::ArrayType = MaterialLib::Fluid::FluidProperty::ArrayType

Definition at line 36 of file TwoPhaseFlowWithPrhoMaterialProperties.h.

JacobianMatrix

using ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::JacobianMatrix

private

Initial value:

 
        Eigen::Matrix<double, jacobian_residual_size, jacobian_residual_size,
                      Eigen::RowMajor>

Definition at line 93 of file TwoPhaseFlowWithPrhoMaterialProperties.h.

ResidualVector

using ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::ResidualVector = Eigen::Matrix<double, jacobian_residual_size, 1>

private

Definition at line 92 of file TwoPhaseFlowWithPrhoMaterialProperties.h.

UnknownVector

using ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::UnknownVector = Eigen::Matrix<double, jacobian_residual_size, 1>

private

Definition at line 96 of file TwoPhaseFlowWithPrhoMaterialProperties.h.

Constructor & Destructor Documentation

TwoPhaseFlowWithPrhoMaterialProperties()

ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::TwoPhaseFlowWithPrhoMaterialProperties	(	MeshLib::PropertyVector< int > const *	material_ids,
		std::vector< std::unique_ptr< MaterialLib::PorousMedium::CapillaryPressureSaturation > > &&	capillary_pressure_models,
		std::vector< std::unique_ptr< MaterialLib::PorousMedium::RelativePermeability > > &&	relative_permeability_models )

Definition at line 36 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

    : _material_ids(material_ids),
      _capillary_pressure_models(std::move(capillary_pressure_models)),
      _relative_permeability_models(std::move(relative_permeability_models))
{
    DBUG("Create material properties for Two-Phase flow with P-RHO model.");
}

References DBUG().

Member Function Documentation

calculatedSwdP()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculatedSwdP ( double pl, double S, double rho_wet_h2, double const T, int current_material_id ) const

private

Calculate the derivatives using the analytical way

Definition at line 223 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    const double pg =
        pl +
        _capillary_pressure_models[current_material_id]->getCapillaryPressure(
            S);
    double const rho_equilibrium_wet_h2 = pg * HenryConstantH2 * H2;
    if ((1 - S) < (rho_equilibrium_wet_h2 - rho_wet_h2))
    {
        return 0.0;
    }
    double const drhoh2wet_dpg = HenryConstantH2 * H2;
    double const drhoh2nonwet_dpg = H2 / IdealGasConstant / T;
    double const alpha =
        ((drhoh2nonwet_dpg - drhoh2wet_dpg) * (1 - S) + drhoh2wet_dpg);
    double const beta = (drhoh2nonwet_dpg - drhoh2wet_dpg) *
                        pg;  // NOTE here should be PG^h, but we ignore vapor
    double const dPC_dSw =
        _capillary_pressure_models[current_material_id]->getdPcdS(S);
    return alpha / (beta - alpha * dPC_dSw);
}

References _capillary_pressure_models.

Referenced by computeConstitutiveRelation().

calculatedSwdX()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculatedSwdX ( double const pl, const double , const double S, const double rho_wet_h2, double const T, int current_material_id ) const

private

Calculate the derivatives using the analytical way

Definition at line 249 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    const double pg =
        pl +
        _capillary_pressure_models[current_material_id]->getCapillaryPressure(
            S);
    double const rho_equilibrium_wet_h2 = pg * HenryConstantH2 * H2;
    if ((1 - S) < (rho_equilibrium_wet_h2 - rho_wet_h2))
    {
        return 0.0;
    }
    double const drhoh2wet_dpg = HenryConstantH2 * H2;
    double const drhoh2nonwet_dpg = H2 / IdealGasConstant / T;
    double const alpha =
        ((drhoh2nonwet_dpg - drhoh2wet_dpg) * (1 - S) + drhoh2wet_dpg);
    double const beta = (drhoh2nonwet_dpg - drhoh2wet_dpg) *
                        pg;  // NOTE here should be PG^h, but we ignore vapor
    double const dPC_dSw =
        _capillary_pressure_models[current_material_id]->getdPcdS(S);
    return -1 / (beta - alpha * dPC_dSw);
}

References _capillary_pressure_models.

Referenced by computeConstitutiveRelation().

calculatedXmdP()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculatedXmdP ( double pl, double Sw, double rho_wet_h2, double dSwdP, int current_material_id ) const

private

Calculate the derivatives using the analytical way

Definition at line 295 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    const double pg =
        pl +
        _capillary_pressure_models[current_material_id]->getCapillaryPressure(
            Sw);
    double const rho_equilibrium_wet_h2 = pg * HenryConstantH2 * H2;
    double const dPC_dSw =
        _capillary_pressure_models[current_material_id]->getdPcdS(Sw);
    if ((1 - Sw) < (rho_equilibrium_wet_h2 - rho_wet_h2))
    {
        return 0.0;
    }
    return HenryConstantH2 * H2 * (1 + dPC_dSw * dSwdP);
}

References _capillary_pressure_models.

Referenced by computeConstitutiveRelation().

calculatedXmdX()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculatedXmdX ( double pl, double Sw, double rho_wet_h2, double dSwdX, int current_material_id ) const

private

Calculate the derivatives using the analytical way

Definition at line 275 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    const double pg =
        pl +
        _capillary_pressure_models[current_material_id]->getCapillaryPressure(
            Sw);
    double const rho_equilibrium_wet_h2 = pg * HenryConstantH2 * H2;
    double const dPC_dSw =
        _capillary_pressure_models[current_material_id]->getdPcdS(Sw);
    if ((1 - Sw) < (rho_equilibrium_wet_h2 - rho_wet_h2))
    {
        return 1.0;
    }
    return HenryConstantH2 * H2 * dPC_dSw * dSwdX;
}

References _capillary_pressure_models.

Referenced by computeConstitutiveRelation().

calculateEquilibiumRhoWetLight()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculateEquilibiumRhoWetLight ( double const pg, double const Sw, double const rho_wet_h2 )

staticprivate

Complementary condition 1 for calculating molar fraction of light component in the liquid phase

Definition at line 203 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    double const rho_equilibrium_wet_h2 = pg * HenryConstantH2 * H2;
    return std::min(1 - Sw, rho_equilibrium_wet_h2 - rho_wet_h2);
}

Referenced by calculateResidual().

calculateJacobian()

void ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculateJacobian ( const int material_id, double const t, ParameterLib::SpatialPosition const & x, double const pl, double const X, double const T, JacobianMatrix & Jac, double Sw, double rho_h2_wet )

private

Calculates the Jacobian.

Definition at line 172 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    const double pg =
        pl + _capillary_pressure_models[material_id]->getCapillaryPressure(Sw);
    const double rho_h2_nonwet = pg * H2 / IdealGasConstant / T;
    double const rho_equili_h2_wet = pg * HenryConstantH2 * H2;
    double const dPC_dSw =
        _capillary_pressure_models[material_id]->getdPcdS(Sw);
    double const drhoh2wet_dpg = HenryConstantH2 * H2;
    Jac.setZero();
    if ((1 - Sw) < (rho_equili_h2_wet - rho_h2_wet))
    {
        Jac(0, 0) = -1;
    }
    else
    {
        Jac(0, 0) = drhoh2wet_dpg * dPC_dSw;
        Jac(0, 1) = -1;
    }
 
    Jac(1, 0) = rho_h2_nonwet - rho_h2_wet;
    Jac(1, 1) = -Sw;
}

References _capillary_pressure_models.

Referenced by computeConstitutiveRelation().

calculateResidual()

void ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculateResidual ( const int material_id, double const pl, double const X, double const T, double Sw, double rho_h2_wet, ResidualVector & res )

private

Calculates the residual vector.

Definition at line 159 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    const double pg =
        pl + _capillary_pressure_models[material_id]->getCapillaryPressure(Sw);
    const double rho_h2_nonwet = pg * H2 / IdealGasConstant / T;
 
    // calculating residual
    res[0] = calculateEquilibiumRhoWetLight(pg, Sw, rho_h2_wet);
    res[1] = calculateSaturation(pl, X, Sw, rho_h2_wet, rho_h2_nonwet, T);
}

References _capillary_pressure_models, calculateEquilibiumRhoWetLight(), and calculateSaturation().

Referenced by computeConstitutiveRelation().

calculateSaturation()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculateSaturation ( double , double X, double Sw, double rho_wet_h2, double rho_nonwet_h2, double  )

staticprivate

Complementary condition 2 for calculating the saturation

Definition at line 213 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    return X - (Sw * rho_wet_h2 + (1 - Sw) * rho_nonwet_h2);
}

Referenced by calculateResidual().

computeConstitutiveRelation()

bool ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::computeConstitutiveRelation	(	double const	t,
		ParameterLib::SpatialPosition const &	x,
		const int	material_id,
		double const	pg,
		double const	X,
		double const	T,
		double &	Sw,
		double &	X_m,
		double &	dsw_dpg,
		double &	dsw_dX,
		double &	dxm_dpg,
		double &	dxm_dX )

Definition at line 94 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    {  // Local Newton solver
        using LocalJacobianMatrix =
            Eigen::Matrix<double, 2, 2, Eigen::RowMajor>;
        using LocalResidualVector = Eigen::Matrix<double, 2, 1>;
        using LocalUnknownVector = Eigen::Matrix<double, 2, 1>;
        LocalJacobianMatrix J_loc;
 
        Eigen::PartialPivLU<LocalJacobianMatrix> linear_solver(2);
        auto const update_residual = [&](LocalResidualVector& residual)
        { calculateResidual(material_id, pg, X, T, Sw, X_m, residual); };
 
        auto const update_jacobian = [&](LocalJacobianMatrix& jacobian)
        {
            calculateJacobian(material_id, t, x, pg, X, T, jacobian, Sw,
                              X_m);  // for solution dependent Jacobians
        };
 
        auto const update_solution = [&](LocalUnknownVector const& increment)
        {
            // increment solution vectors
            Sw += increment[0];
            X_m += increment[1];
        };
 
        // TODO Make the following choice of maximum iterations and convergence
        // criteria available from the input file configuration. See Ehlers
        // material model implementation for the example.
        const int maximum_iterations(20);
        const double residuum_tolerance(1.e-14);
        const double increment_tolerance(0);
 
        auto newton_solver = NumLib::NewtonRaphson<
            decltype(linear_solver), LocalJacobianMatrix,
            decltype(update_jacobian), LocalResidualVector,
            decltype(update_residual), decltype(update_solution)>(
            linear_solver, update_jacobian, update_residual, update_solution,
            {maximum_iterations, residuum_tolerance, increment_tolerance});
 
        auto const success_iterations = newton_solver.solve(J_loc);
 
        if (!success_iterations)
        {
            return false;
        }
    }
    dsw_dpg = calculatedSwdP(pg, Sw, X_m, T, material_id);
    dsw_dX = calculatedSwdX(pg, X, Sw, X_m, T, material_id);
    dxm_dpg = calculatedXmdP(pg, Sw, X_m, dsw_dpg, material_id);
    dxm_dX = calculatedXmdX(pg, Sw, X_m, dsw_dX, material_id);
    return true;
}

References calculatedSwdP(), calculatedSwdX(), calculatedXmdP(), calculatedXmdX(), calculateJacobian(), calculateResidual(), and NumLib::NewtonRaphson< LinearSolver, JacobianMatrix, JacobianMatrixUpdate, ResidualVector, ResidualUpdate, SolutionUpdate >::solve().

getCapillaryPressure()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::getCapillaryPressure	(	const int	material_id,
		const double	t,
		const ParameterLib::SpatialPosition &	pos,
		const double	p,
		const double	T,
		const double	saturation ) const

Definition at line 77 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    return _capillary_pressure_models[material_id]->getCapillaryPressure(
        saturation);
}

References _capillary_pressure_models.

getCapillaryPressureDerivative()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::getCapillaryPressureDerivative	(	const int	material_id,
		const double	t,
		const ParameterLib::SpatialPosition &	pos,
		const double	p,
		const double	T,
		const double	saturation ) const

Definition at line 86 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    return _capillary_pressure_models[material_id]->getdPcdS(saturation);
}

References _capillary_pressure_models.

getMaterialID()

int ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::getMaterialID

(

const std::size_t

element_id

)

Definition at line 51 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    if (!_material_ids)
    {
        return 0;
    }
 
    assert(element_id < _material_ids->size());
    return (*_material_ids)[element_id];
}

References _material_ids.

getNonwetRelativePermeability()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::getNonwetRelativePermeability	(	const double	t,
		const ParameterLib::SpatialPosition &	pos,
		const double	p,
		const double	T,
		const double	saturation ) const

Definition at line 63 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    return _relative_permeability_models[0]->getValue(saturation);
}

References _relative_permeability_models.

getWetRelativePermeability()

double ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::getWetRelativePermeability	(	const double	t,
		const ParameterLib::SpatialPosition &	pos,
		const double	p,
		const double	T,
		const double	saturation ) const

Definition at line 70 of file TwoPhaseFlowWithPrhoMaterialProperties.cpp.

{
    return _relative_permeability_models[1]->getValue(saturation);
}

References _relative_permeability_models.

Member Data Documentation

_capillary_pressure_models

std::vector< std::unique_ptr<MaterialLib::PorousMedium::CapillaryPressureSaturation> > ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::_capillary_pressure_models

protected

Definition at line 85 of file TwoPhaseFlowWithPrhoMaterialProperties.h.

Referenced by calculatedSwdP(), calculatedSwdX(), calculatedXmdP(), calculatedXmdX(), calculateJacobian(), calculateResidual(), getCapillaryPressure(), and getCapillaryPressureDerivative().

_material_ids

MeshLib::PropertyVector<int> const* const ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::_material_ids

protected

Use two phase models for different material zones. Material IDs must be given as mesh element properties.

Definition at line 81 of file TwoPhaseFlowWithPrhoMaterialProperties.h.

Referenced by getMaterialID().

_relative_permeability_models

std::vector< std::unique_ptr<MaterialLib::PorousMedium::RelativePermeability> > ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::_relative_permeability_models

protected

Definition at line 88 of file TwoPhaseFlowWithPrhoMaterialProperties.h.

Referenced by getNonwetRelativePermeability(), and getWetRelativePermeability().

jacobian_residual_size

int const ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::jacobian_residual_size = 2

staticprivate

Definition at line 91 of file TwoPhaseFlowWithPrhoMaterialProperties.h.

---

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

• ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoMaterialProperties.h
• ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoMaterialProperties.cpp