ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim > Class Template Reference

Detailed Description

template<typename ShapeFunction, int GlobalDim>
class ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >

Definition at line 70 of file TwoPhaseFlowWithPPLocalAssembler.h.

#include <TwoPhaseFlowWithPPLocalAssembler.h>

Inheritance diagram for ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >:

Collaboration diagram for ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >:

Public Member Functions
	TwoPhaseFlowWithPPLocalAssembler (MeshLib::Element const &element, std::size_t const, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, TwoPhaseFlowWithPPProcessData const &process_data)
void	setInitialConditionsConcrete (Eigen::VectorXd const local_x, double const t, int const process_id) override
void	assemble (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &local_x_prev, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data) override
Eigen::Map< const Eigen::RowVectorXd >	getShapeMatrix (const unsigned integration_point) const override
	Provides the shape matrix at the given integration point.
std::vector< double > const &	getIntPtSaturation (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &) const override
std::vector< double > const &	getIntPtWetPressure (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &) const override
Public Member Functions inherited from ProcessLib::LocalAssemblerInterface
virtual	~LocalAssemblerInterface ()=default
virtual void	setInitialConditions (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, int const process_id)
virtual void	initialize (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table)
virtual void	preAssemble (double const, double const, std::vector< double > const &)
virtual void	assembleForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, int const process_id, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data)
virtual void	assembleWithJacobian (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
virtual void	assembleWithJacobianForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, int const process_id, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
virtual void	computeSecondaryVariable (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id)
virtual void	preTimestep (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, double const t, double const delta_t)
virtual void	postTimestep (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, double const t, double const dt, int const process_id)
void	postNonLinearSolver (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, double const t, double const dt, int const process_id)
virtual Eigen::Vector3d	getFlux (MathLib::Point3d const &, double const, std::vector< double > const &) const
virtual Eigen::Vector3d	getFlux (MathLib::Point3d const &, double const, std::vector< std::vector< double > > const &) const
	Fits to staggered scheme.
virtual std::optional< VectorSegment >	getVectorDeformationSegment () const
Public Member Functions inherited from NumLib::ExtrapolatableElement
virtual	~ExtrapolatableElement ()=default

Private Types
using	ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, GlobalDim>
using	ShapeMatrices = typename ShapeMatricesType::ShapeMatrices
using	LocalAssemblerTraits
using	NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType
using	GlobalDimNodalMatrixType
using	NodalMatrixType = typename ShapeMatricesType::NodalMatrixType
using	NodalVectorType = typename ShapeMatricesType::NodalVectorType
using	GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType
using	GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType
using	LocalMatrixType = typename LocalAssemblerTraits::LocalMatrix
using	LocalVectorType = typename LocalAssemblerTraits::LocalVector

Private Attributes
MeshLib::Element const &	_element
NumLib::GenericIntegrationMethod const &	_integration_method
TwoPhaseFlowWithPPProcessData const &	_process_data
std::vector< IntegrationPointData< NodalRowVectorType, GlobalDimNodalMatrixType, NodalMatrixType >, Eigen::aligned_allocator< IntegrationPointData< NodalRowVectorType, GlobalDimNodalMatrixType, NodalMatrixType > > >	_ip_data
std::vector< double >	_saturation
std::vector< double >	_pressure_wet

Static Private Attributes
static const int	nonwet_pressure_coeff_index = 0
static const int	cap_pressure_coeff_index = 1
static const int	nonwet_pressure_matrix_index = 0
static const int	cap_pressure_matrix_index = ShapeFunction::NPOINTS
static const int	nonwet_pressure_size = ShapeFunction::NPOINTS
static const int	cap_pressure_size = ShapeFunction::NPOINTS

Member Typedef Documentation

GlobalDimMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType

private

Definition at line 84 of file TwoPhaseFlowWithPPLocalAssembler.h.

GlobalDimNodalMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::GlobalDimNodalMatrixType

private

Initial value:

 
        typename ShapeMatricesType::GlobalDimNodalMatrixType

Definition at line 80 of file TwoPhaseFlowWithPPLocalAssembler.h.

GlobalDimVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType

private

Definition at line 85 of file TwoPhaseFlowWithPPLocalAssembler.h.

LocalAssemblerTraits

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::LocalAssemblerTraits

private

Initial value:

 ProcessLib::LocalAssemblerTraits<
        ShapeMatricesType, ShapeFunction::NPOINTS, NUM_NODAL_DOF, GlobalDim>

Definition at line 76 of file TwoPhaseFlowWithPPLocalAssembler.h.

LocalMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::LocalMatrixType = typename LocalAssemblerTraits::LocalMatrix

private

Definition at line 86 of file TwoPhaseFlowWithPPLocalAssembler.h.

LocalVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::LocalVectorType = typename LocalAssemblerTraits::LocalVector

private

Definition at line 87 of file TwoPhaseFlowWithPPLocalAssembler.h.

NodalMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

private

Definition at line 82 of file TwoPhaseFlowWithPPLocalAssembler.h.

NodalRowVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType

private

Definition at line 78 of file TwoPhaseFlowWithPPLocalAssembler.h.

NodalVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

private

Definition at line 83 of file TwoPhaseFlowWithPPLocalAssembler.h.

ShapeMatrices

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

private

Definition at line 74 of file TwoPhaseFlowWithPPLocalAssembler.h.

ShapeMatricesType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, GlobalDim>

private

Definition at line 73 of file TwoPhaseFlowWithPPLocalAssembler.h.

Constructor & Destructor Documentation

TwoPhaseFlowWithPPLocalAssembler()

template<typename ShapeFunction, int GlobalDim>

ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::TwoPhaseFlowWithPPLocalAssembler ( MeshLib::Element const & element, std::size_t const , NumLib::GenericIntegrationMethod const & integration_method, bool const is_axially_symmetric, TwoPhaseFlowWithPPProcessData const & process_data )

inline

Definition at line 90 of file TwoPhaseFlowWithPPLocalAssembler.h.

        : _element(element),
          _integration_method(integration_method),
          _process_data(process_data),
          _saturation(
              std::vector<double>(_integration_method.getNumberOfPoints())),
          _pressure_wet(
              std::vector<double>(_integration_method.getNumberOfPoints()))
    {
        unsigned const n_integration_points =
            _integration_method.getNumberOfPoints();
        _ip_data.reserve(n_integration_points);
        auto const shape_matrices =
            NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType,
                                      GlobalDim>(element, is_axially_symmetric,
                                                 _integration_method);
        for (unsigned ip = 0; ip < n_integration_points; ip++)
        {
            auto const& sm = shape_matrices[ip];
            _ip_data.emplace_back(
                sm.N, sm.dNdx,
                sm.integralMeasure * sm.detJ *
                    _integration_method.getWeightedPoint(ip).getWeight());
        }
    }

References _element, _integration_method, _ip_data, _pressure_wet, _process_data, _saturation, and NumLib::initShapeMatrices().

Member Function Documentation

assemble()

template<typename ShapeFunction, int GlobalDim>

void ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::assemble ( double const t, double const dt, std::vector< double > const & local_x, std::vector< double > const & local_x_prev, std::vector< double > & local_M_data, std::vector< double > & local_K_data, std::vector< double > & local_b_data )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 71 of file TwoPhaseFlowWithPPLocalAssembler-impl.h.

{
    auto const local_matrix_size = local_x.size();
 
    assert(local_matrix_size == ShapeFunction::NPOINTS * NUM_NODAL_DOF);
 
    auto local_M = MathLib::createZeroedMatrix<LocalMatrixType>(
        local_M_data, local_matrix_size, local_matrix_size);
    auto local_K = MathLib::createZeroedMatrix<LocalMatrixType>(
        local_K_data, local_matrix_size, local_matrix_size);
    auto local_b = MathLib::createZeroedVector<LocalVectorType>(
        local_b_data, local_matrix_size);
 
    auto Mgp =
        local_M.template block<nonwet_pressure_size, nonwet_pressure_size>(
            nonwet_pressure_matrix_index, nonwet_pressure_matrix_index);
    auto Mgpc = local_M.template block<nonwet_pressure_size, cap_pressure_size>(
        nonwet_pressure_matrix_index, cap_pressure_matrix_index);
 
    auto Mlpc = local_M.template block<cap_pressure_size, cap_pressure_size>(
        cap_pressure_matrix_index, cap_pressure_matrix_index);
 
    NodalMatrixType laplace_operator =
        NodalMatrixType::Zero(ShapeFunction::NPOINTS, ShapeFunction::NPOINTS);
 
    auto Kgp =
        local_K.template block<nonwet_pressure_size, nonwet_pressure_size>(
            nonwet_pressure_matrix_index, nonwet_pressure_matrix_index);
 
    auto Klp = local_K.template block<cap_pressure_size, nonwet_pressure_size>(
        cap_pressure_matrix_index, nonwet_pressure_matrix_index);
 
    auto Klpc = local_K.template block<cap_pressure_size, cap_pressure_size>(
        cap_pressure_matrix_index, cap_pressure_matrix_index);
 
    auto Bg = local_b.template segment<nonwet_pressure_size>(
        nonwet_pressure_matrix_index);
 
    auto Bl =
        local_b.template segment<cap_pressure_size>(cap_pressure_matrix_index);
 
    auto const& medium = *_process_data.media_map.getMedium(_element.getID());
    auto const& liquid_phase = medium.phase("AqueousLiquid");
    auto const& gas_phase = medium.phase("Gas");
 
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    ParameterLib::SpatialPosition pos;
    pos.setElementID(_element.getID());
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& w = _ip_data[ip].integration_weight;
        auto const& N = _ip_data[ip].N;
        auto const& dNdx = _ip_data[ip].dNdx;
 
        NodalMatrixType M = N.transpose() * N * w;
 
        double pc_int_pt = 0.;
        double pn_int_pt = 0.;
        NumLib::shapeFunctionInterpolate(local_x, _ip_data[ip].N, pn_int_pt,
                                         pc_int_pt);
 
        _pressure_wet[ip] = pn_int_pt - pc_int_pt;
        MPL::VariableArray variables;
 
        variables.gas_phase_pressure = pn_int_pt;
        variables.capillary_pressure = pc_int_pt;
        variables.temperature = _process_data.temperature(t, pos)[0];
        variables.molar_mass =
            gas_phase.property(MPL::PropertyType::molar_mass)
                .template value<double>(variables, pos, t, dt);
 
        auto const rho_nonwet =
            gas_phase.property(MPL::PropertyType::density)
                .template value<double>(variables, pos, t, dt);
 
        auto const rho_wet = liquid_phase.property(MPL::PropertyType::density)
                                 .template value<double>(variables, pos, t, dt);
        auto& Sw = _saturation[ip];
        Sw = medium.property(MPL::PropertyType::saturation)
                 .template value<double>(variables, pos, t, dt);
 
        variables.liquid_saturation = Sw;
        auto const dSw_dpc =
            medium.property(MPL::PropertyType::saturation)
                .template dValue<double>(
                    variables, MPL::Variable::capillary_pressure, pos, t, dt);
 
        auto const porosity =
            medium.property(MPL::PropertyType::porosity)
                .template value<double>(variables, pos, t, dt);
 
        auto const drhononwet_dpn =
            gas_phase.property(MPL::PropertyType::density)
                .template dValue<double>(
                    variables, MPL::Variable::gas_phase_pressure, pos, t, dt);
 
        auto const k_rel_wet =
            medium.property(MPL::PropertyType::relative_permeability)
                .template value<double>(variables, pos, t, dt);
        auto const k_rel_nonwet =
            medium
                .property(
                    MPL::PropertyType::relative_permeability_nonwetting_phase)
                .template value<double>(variables, pos, t, dt);
 
        auto const mu_nonwet =
            gas_phase.property(MPL::PropertyType::viscosity)
                .template value<double>(variables, pos, t, dt);
 
        auto const lambda_nonwet = k_rel_nonwet / mu_nonwet;
 
        auto const mu_wet = liquid_phase.property(MPL::PropertyType::viscosity)
                                .template value<double>(variables, pos, t, dt);
 
        auto const lambda_wet = k_rel_wet / mu_wet;
 
        auto const K = MPL::formEigenTensor<GlobalDim>(
            medium.property(MPL::PropertyType::permeability)
                .template value<double>(variables, pos, t, dt));
 
        Mgp.noalias() += porosity * (1 - Sw) * drhononwet_dpn * M;
        Mgpc.noalias() += -porosity * rho_nonwet * dSw_dpc * M;
        Mlpc.noalias() += porosity * dSw_dpc * rho_wet * M;
 
        laplace_operator.noalias() = dNdx.transpose() * K * dNdx * w;
 
        Kgp.noalias() += rho_nonwet * lambda_nonwet * laplace_operator;
        Klp.noalias() += rho_wet * lambda_wet * laplace_operator;
        Klpc.noalias() += -rho_wet * lambda_wet * laplace_operator;
 
        if (_process_data.has_gravity)
        {
            auto const& b = _process_data.specific_body_force;
 
            NodalVectorType gravity_operator = dNdx.transpose() * K * b * w;
            Bg.noalias() +=
                rho_nonwet * rho_nonwet * lambda_nonwet * gravity_operator;
            Bl.noalias() += rho_wet * rho_wet * lambda_wet * gravity_operator;
        }  // end of has gravity
    }
    if (_process_data.has_mass_lumping)
    {
        for (unsigned row = 0; row < Mgpc.cols(); row++)
        {
            for (unsigned column = 0; column < Mgpc.cols(); column++)
            {
                if (row != column)
                {
                    Mgpc(row, row) += Mgpc(row, column);
                    Mgpc(row, column) = 0.0;
                    Mgp(row, row) += Mgp(row, column);
                    Mgp(row, column) = 0.0;
                    Mlpc(row, row) += Mlpc(row, column);
                    Mlpc(row, column) = 0.0;
                }
            }
        }
    }  // end of mass-lumping
}

References _element, _integration_method, _ip_data, _pressure_wet, _process_data, _saturation, cap_pressure_matrix_index, MaterialPropertyLib::capillary_pressure, MaterialPropertyLib::VariableArray::capillary_pressure, MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::gas_phase_pressure, MaterialPropertyLib::VariableArray::gas_phase_pressure, MaterialPropertyLib::VariableArray::liquid_saturation, MaterialPropertyLib::molar_mass, MaterialPropertyLib::VariableArray::molar_mass, nonwet_pressure_matrix_index, ProcessLib::TwoPhaseFlowWithPP::NUM_NODAL_DOF, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::relative_permeability, MaterialPropertyLib::relative_permeability_nonwetting_phase, MaterialPropertyLib::saturation, ParameterLib::SpatialPosition::setElementID(), NumLib::detail::shapeFunctionInterpolate(), MaterialPropertyLib::VariableArray::temperature, and MaterialPropertyLib::viscosity.

getIntPtSaturation()

template<typename ShapeFunction, int GlobalDim>

std::vector< double > const & ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::getIntPtSaturation ( const double , std::vector< GlobalVector * > const & , std::vector< NumLib::LocalToGlobalIndexMap const * > const & , std::vector< double > &  ) const

inlineoverridevirtual

Implements ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssemblerInterface.

Definition at line 141 of file TwoPhaseFlowWithPPLocalAssembler.h.

    {
        assert(!_saturation.empty());
        return _saturation;
    }

References _saturation.

getIntPtWetPressure()

template<typename ShapeFunction, int GlobalDim>

std::vector< double > const & ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::getIntPtWetPressure ( const double , std::vector< GlobalVector * > const & , std::vector< NumLib::LocalToGlobalIndexMap const * > const & , std::vector< double > &  ) const

inlineoverridevirtual

Implements ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssemblerInterface.

Definition at line 151 of file TwoPhaseFlowWithPPLocalAssembler.h.

    {
        assert(!_pressure_wet.empty());
        return _pressure_wet;
    }

References _pressure_wet.

getShapeMatrix()

template<typename ShapeFunction, int GlobalDim>

Eigen::Map< const Eigen::RowVectorXd > ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::getShapeMatrix ( const unsigned integration_point ) const

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 132 of file TwoPhaseFlowWithPPLocalAssembler.h.

    {
        auto const& N = _ip_data[integration_point].N;
 
        // assumes N is stored contiguously in memory
        return Eigen::Map<const Eigen::RowVectorXd>(N.data(), N.size());
    }

References _ip_data.

setInitialConditionsConcrete()

template<typename ShapeFunction, int GlobalDim>

void ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::setInitialConditionsConcrete ( Eigen::VectorXd const local_x, double const t, int const process_id )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 46 of file TwoPhaseFlowWithPPLocalAssembler-impl.h.

{
    auto const& medium = *_process_data.media_map.getMedium(_element.getID());
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    auto const pc =
        local_x.segment(cap_pressure_matrix_index, cap_pressure_size);
    constexpr double dt = std::numeric_limits<double>::quiet_NaN();
    ParameterLib::SpatialPosition pos;
    pos.setElementID(_element.getID());
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& N = _ip_data[ip].N;
        MPL::VariableArray variables;
        variables.capillary_pressure = N.dot(pc);
        _saturation[ip] = medium.property(MPL::PropertyType::saturation)
                              .template value<double>(variables, pos, t, dt);
    }
}

References _element, _integration_method, _ip_data, _process_data, _saturation, cap_pressure_matrix_index, cap_pressure_size, MaterialPropertyLib::VariableArray::capillary_pressure, MaterialPropertyLib::saturation, and ParameterLib::SpatialPosition::setElementID().

Member Data Documentation

_element

template<typename ShapeFunction, int GlobalDim>

MeshLib::Element const& ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::_element

private

Definition at line 162 of file TwoPhaseFlowWithPPLocalAssembler.h.

Referenced by TwoPhaseFlowWithPPLocalAssembler(), assemble(), and setInitialConditionsConcrete().

_integration_method

template<typename ShapeFunction, int GlobalDim>

NumLib::GenericIntegrationMethod const& ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::_integration_method

private

Definition at line 164 of file TwoPhaseFlowWithPPLocalAssembler.h.

Referenced by TwoPhaseFlowWithPPLocalAssembler(), assemble(), and setInitialConditionsConcrete().

_ip_data

template<typename ShapeFunction, int GlobalDim>

std::vector< IntegrationPointData<NodalRowVectorType, GlobalDimNodalMatrixType, NodalMatrixType>, Eigen::aligned_allocator<IntegrationPointData< NodalRowVectorType, GlobalDimNodalMatrixType, NodalMatrixType> > > ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::_ip_data

private

Definition at line 172 of file TwoPhaseFlowWithPPLocalAssembler.h.

Referenced by TwoPhaseFlowWithPPLocalAssembler(), assemble(), getShapeMatrix(), and setInitialConditionsConcrete().

_pressure_wet

template<typename ShapeFunction, int GlobalDim>

std::vector<double> ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::_pressure_wet

private

Definition at line 179 of file TwoPhaseFlowWithPPLocalAssembler.h.

Referenced by TwoPhaseFlowWithPPLocalAssembler(), assemble(), and getIntPtWetPressure().

_process_data

template<typename ShapeFunction, int GlobalDim>

TwoPhaseFlowWithPPProcessData const& ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::_process_data

private

Definition at line 166 of file TwoPhaseFlowWithPPLocalAssembler.h.

Referenced by TwoPhaseFlowWithPPLocalAssembler(), assemble(), and setInitialConditionsConcrete().

_saturation

template<typename ShapeFunction, int GlobalDim>

std::vector<double> ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::_saturation

private

Definition at line 176 of file TwoPhaseFlowWithPPLocalAssembler.h.

Referenced by TwoPhaseFlowWithPPLocalAssembler(), assemble(), getIntPtSaturation(), and setInitialConditionsConcrete().

cap_pressure_coeff_index

template<typename ShapeFunction, int GlobalDim>

const int ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::cap_pressure_coeff_index = 1

staticprivate

Definition at line 181 of file TwoPhaseFlowWithPPLocalAssembler.h.

cap_pressure_matrix_index

template<typename ShapeFunction, int GlobalDim>

const int ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::cap_pressure_matrix_index = ShapeFunction::NPOINTS

staticprivate

Definition at line 184 of file TwoPhaseFlowWithPPLocalAssembler.h.

Referenced by assemble(), and setInitialConditionsConcrete().

cap_pressure_size

template<typename ShapeFunction, int GlobalDim>

const int ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::cap_pressure_size = ShapeFunction::NPOINTS

staticprivate

Definition at line 187 of file TwoPhaseFlowWithPPLocalAssembler.h.

Referenced by setInitialConditionsConcrete().

nonwet_pressure_coeff_index

template<typename ShapeFunction, int GlobalDim>

const int ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::nonwet_pressure_coeff_index = 0

staticprivate

Definition at line 180 of file TwoPhaseFlowWithPPLocalAssembler.h.

nonwet_pressure_matrix_index

template<typename ShapeFunction, int GlobalDim>

const int ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::nonwet_pressure_matrix_index = 0

staticprivate

Definition at line 183 of file TwoPhaseFlowWithPPLocalAssembler.h.

Referenced by assemble().

nonwet_pressure_size

template<typename ShapeFunction, int GlobalDim>

const int ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::nonwet_pressure_size = ShapeFunction::NPOINTS

staticprivate

Definition at line 186 of file TwoPhaseFlowWithPPLocalAssembler.h.

---

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

• ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPLocalAssembler.h
• ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPLocalAssembler-impl.h