ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim > Class Template Reference

Detailed Description

template<typename ShapeFunction, int GlobalDim>
class ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >

Definition at line 73 of file RichardsFlowFEM.h.

#include <RichardsFlowFEM.h>

Inheritance diagram for ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >:

Collaboration diagram for ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >:

Public Member Functions
	LocalAssemblerData (MeshLib::Element const &element, std::size_t const local_matrix_size, NumLib::GenericIntegrationMethod const &integration_method, bool is_axially_symmetric, RichardsFlowProcessData const &process_data)
void	assemble (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &, 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 &	getIntPtDarcyVelocity (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) 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 int	getNumberOfVectorElementsForDeformation () 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

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

Member Typedef Documentation

GlobalDimMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType

private

Definition at line 86 of file RichardsFlowFEM.h.

GlobalDimNodalMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::GlobalDimNodalMatrixType

private

Initial value:

 
        typename ShapeMatricesType::GlobalDimNodalMatrixType

Definition at line 82 of file RichardsFlowFEM.h.

GlobalDimVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType

private

Definition at line 87 of file RichardsFlowFEM.h.

LocalAssemblerTraits

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalAssemblerTraits

private

Initial value:

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

Definition at line 78 of file RichardsFlowFEM.h.

NodalMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

private

Definition at line 84 of file RichardsFlowFEM.h.

NodalRowVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType

private

Definition at line 81 of file RichardsFlowFEM.h.

NodalVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

private

Definition at line 85 of file RichardsFlowFEM.h.

ShapeMatrices

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

private

Definition at line 76 of file RichardsFlowFEM.h.

ShapeMatricesType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, GlobalDim>

private

Definition at line 75 of file RichardsFlowFEM.h.

Constructor & Destructor Documentation

LocalAssemblerData()

template<typename ShapeFunction, int GlobalDim>

ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalAssemblerData ( MeshLib::Element const & element, std::size_t const local_matrix_size, NumLib::GenericIntegrationMethod const & integration_method, bool is_axially_symmetric, RichardsFlowProcessData const & process_data )

inline

Definition at line 90 of file RichardsFlowFEM.h.

        : _element(element),
          _process_data(process_data),
          _integration_method(integration_method),
          _saturation(
              std::vector<double>(_integration_method.getNumberOfPoints()))
    {
        // This assertion is valid only if all nodal d.o.f. use the same shape
        // matrices.
        assert(local_matrix_size == ShapeFunction::NPOINTS * NUM_NODAL_DOF);
        (void)local_matrix_size;
 
        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];
            const double integration_factor = sm.integralMeasure * sm.detJ;
            _ip_data.emplace_back(
                sm.N, sm.dNdx,
                _integration_method.getWeightedPoint(ip).getWeight() *
                    integration_factor,
                sm.N.transpose() * sm.N * integration_factor *
                    _integration_method.getWeightedPoint(ip).getWeight());
        }
    }

References _element, _integration_method, _ip_data, _process_data, _saturation, NumLib::initShapeMatrices(), and ProcessLib::RichardsFlow::NUM_NODAL_DOF.

Member Function Documentation

assemble()

template<typename ShapeFunction, int GlobalDim>

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

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 129 of file RichardsFlowFEM.h.

    {
        auto const local_matrix_size = local_x.size();
        // This assertion is valid only if all nodal d.o.f. use the same shape
        // matrices.
        assert(local_matrix_size == ShapeFunction::NPOINTS * NUM_NODAL_DOF);
 
        auto local_M = MathLib::createZeroedMatrix<NodalMatrixType>(
            local_M_data, local_matrix_size, local_matrix_size);
        auto local_K = MathLib::createZeroedMatrix<NodalMatrixType>(
            local_K_data, local_matrix_size, local_matrix_size);
        auto local_b = MathLib::createZeroedVector<NodalVectorType>(
            local_b_data, local_matrix_size);
 
        unsigned const n_integration_points =
            _integration_method.getNumberOfPoints();
        ParameterLib::SpatialPosition pos;
        pos.setElementID(_element.getID());
 
        auto const& medium =
            *_process_data.media_map.getMedium(_element.getID());
        auto const& liquid_phase = medium.phase("AqueousLiquid");
        MaterialPropertyLib::VariableArray vars;
        vars.temperature =
            medium
                .property(
                    MaterialPropertyLib::PropertyType::reference_temperature)
                .template value<double>(vars, pos, t, dt);
 
        for (unsigned ip = 0; ip < n_integration_points; ip++)
        {
            double p_int_pt = 0.0;
            NumLib::shapeFunctionInterpolate(local_x, _ip_data[ip].N, p_int_pt);
 
            pos = {std::nullopt, _element.getID(),
                   MathLib::Point3d(
                       NumLib::interpolateCoordinates<ShapeFunction,
                                                      ShapeMatricesType>(
                           _element, _ip_data[ip].N))};
 
            vars.liquid_phase_pressure = p_int_pt;
            vars.capillary_pressure = -p_int_pt;
            // setting pG to 1 atm
            // TODO : rewrite equations s.t. p_L = pG-p_cap
            vars.gas_phase_pressure = 1.0e5;
 
            auto const permeability =
                MaterialPropertyLib::formEigenTensor<GlobalDim>(
                    medium.property(MaterialPropertyLib::permeability)
                        .value(vars, pos, t, dt));
 
            auto const porosity =
                medium.property(MaterialPropertyLib::PropertyType::porosity)
                    .template value<double>(vars, pos, t, dt);
 
            double const Sw =
                medium.property(MaterialPropertyLib::PropertyType::saturation)
                    .template value<double>(vars, pos, t, dt);
            _saturation[ip] = Sw;
            vars.liquid_saturation = Sw;
 
            double const dSw_dpc =
                medium.property(MaterialPropertyLib::PropertyType::saturation)
                    .template dValue<double>(
                        vars, MaterialPropertyLib::Variable::capillary_pressure,
                        pos, t, dt);
 
            auto const rho_w =
                liquid_phase
                    .property(MaterialPropertyLib::PropertyType::density)
                    .template value<double>(vars, pos, t, dt);
 
            auto const drhow_dp =
                liquid_phase
                    .property(MaterialPropertyLib::PropertyType::density)
                    .template dValue<double>(
                        vars,
                        MaterialPropertyLib::Variable::liquid_phase_pressure,
                        pos, t, dt);
            auto const storage =
                medium.property(MaterialPropertyLib::PropertyType::storage)
                    .template value<double>(vars, pos, t, dt);
            double const mass_mat_coeff = storage * Sw +
                                          porosity * Sw / rho_w * drhow_dp -
                                          porosity * dSw_dpc;
 
            local_M.noalias() += mass_mat_coeff * _ip_data[ip].mass_operator;
 
            double const k_rel =
                medium
                    .property(MaterialPropertyLib::PropertyType::
                                  relative_permeability)
                    .template value<double>(vars, pos, t, dt);
 
            auto const mu =
                liquid_phase.property(MaterialPropertyLib::viscosity)
                    .template value<double>(vars, pos, t, dt);
            local_K.noalias() += _ip_data[ip].dNdx.transpose() * permeability *
                                 _ip_data[ip].dNdx *
                                 _ip_data[ip].integration_weight * (k_rel / mu);
 
            if (_process_data.has_gravity)
            {
                auto const& body_force = _process_data.specific_body_force;
                assert(body_force.size() == GlobalDim);
                NodalVectorType gravity_operator =
                    _ip_data[ip].dNdx.transpose() * permeability * body_force *
                    _ip_data[ip].integration_weight;
                local_b.noalias() += (k_rel / mu) * rho_w * gravity_operator;
            }
        }
        if (_process_data.has_mass_lumping)
        {
            for (int idx_ml = 0; idx_ml < local_M.cols(); idx_ml++)
            {
                double const mass_lump_val = local_M.col(idx_ml).sum();
                local_M.col(idx_ml).setZero();
                local_M(idx_ml, idx_ml) = mass_lump_val;
            }
        }  // end of mass lumping
    }

References _element, _integration_method, _ip_data, _process_data, _saturation, MaterialPropertyLib::capillary_pressure, MaterialPropertyLib::VariableArray::capillary_pressure, MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::VariableArray::gas_phase_pressure, NumLib::interpolateCoordinates(), MaterialPropertyLib::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_saturation, ProcessLib::RichardsFlow::NUM_NODAL_DOF, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::reference_temperature, MaterialPropertyLib::saturation, ParameterLib::SpatialPosition::setElementID(), NumLib::detail::shapeFunctionInterpolate(), MaterialPropertyLib::storage, MaterialPropertyLib::VariableArray::temperature, and MaterialPropertyLib::viscosity.

getIntPtDarcyVelocity()

template<typename ShapeFunction, int GlobalDim>

std::vector< double > const & ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity ( const double t, std::vector< GlobalVector * > const & x, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table, std::vector< double > & cache ) const

inlineoverridevirtual

Implements ProcessLib::RichardsFlow::RichardsFlowLocalAssemblerInterface.

Definition at line 275 of file RichardsFlowFEM.h.

    {
        // TODO (tf) Temporary value not used by current material models. Need
        // extension of secondary variable interface
        double const dt = std::numeric_limits<double>::quiet_NaN();
 
        constexpr int process_id = 0;  // monolithic scheme.
        auto const indices =
            NumLib::getIndices(_element.getID(), *dof_table[process_id]);
        assert(!indices.empty());
        auto const local_x = x[process_id]->get(indices);
 
        ParameterLib::SpatialPosition pos;
        pos.setElementID(_element.getID());
 
        auto const& medium =
            *_process_data.media_map.getMedium(_element.getID());
        auto const& liquid_phase = medium.phase("AqueousLiquid");
 
        MaterialPropertyLib::VariableArray vars;
        vars.temperature =
            medium
                .property(
                    MaterialPropertyLib::PropertyType::reference_temperature)
                .template value<double>(vars, pos, t, dt);
 
        auto const p_nodal_values = Eigen::Map<const NodalVectorType>(
            &local_x[0], ShapeFunction::NPOINTS);
 
        unsigned const n_integration_points =
            _integration_method.getNumberOfPoints();
 
        cache.clear();
        auto cache_vec = MathLib::createZeroedMatrix<
            Eigen::Matrix<double, GlobalDim, Eigen::Dynamic, Eigen::RowMajor>>(
            cache, GlobalDim, n_integration_points);
 
        for (unsigned ip = 0; ip < n_integration_points; ++ip)
        {
            double p_int_pt = 0.0;
            NumLib::shapeFunctionInterpolate(local_x, _ip_data[ip].N, p_int_pt);
 
            pos = {std::nullopt, _element.getID(),
                   MathLib::Point3d(
                       NumLib::interpolateCoordinates<ShapeFunction,
                                                      ShapeMatricesType>(
                           _element, _ip_data[ip].N))};
            vars.liquid_phase_pressure = p_int_pt;
            vars.capillary_pressure = -p_int_pt;
            // setting pG to 1 atm
            // TODO : rewrite equations s.t. p_L = pG-p_cap
            vars.gas_phase_pressure = 1.0e5;
 
            double const Sw =
                medium.property(MaterialPropertyLib::PropertyType::saturation)
                    .template value<double>(vars, pos, t, dt);
            vars.liquid_saturation = Sw;
 
            auto const permeability =
                MaterialPropertyLib::formEigenTensor<GlobalDim>(
                    medium.property(MaterialPropertyLib::permeability)
                        .value(vars, pos, t, dt));
 
            double const k_rel =
                medium
                    .property(MaterialPropertyLib::PropertyType::
                                  relative_permeability)
                    .template value<double>(vars, pos, t, dt);
            auto const mu =
                liquid_phase.property(MaterialPropertyLib::viscosity)
                    .template value<double>(vars, pos, t, dt);
            auto const K_mat_coeff = permeability * (k_rel / mu);
            cache_vec.col(ip).noalias() =
                -K_mat_coeff * _ip_data[ip].dNdx * p_nodal_values;
            if (_process_data.has_gravity)
            {
                auto const rho_w =
                    liquid_phase
                        .property(MaterialPropertyLib::PropertyType::density)
                        .template value<double>(vars, pos, t, dt);
                auto const& body_force = _process_data.specific_body_force;
                assert(body_force.size() == GlobalDim);
                // here it is assumed that the vector body_force is directed
                // 'downwards'
                cache_vec.col(ip).noalias() += K_mat_coeff * rho_w * body_force;
            }
        }
 
        return cache;
    }

References _element, _integration_method, _ip_data, _process_data, MaterialPropertyLib::VariableArray::capillary_pressure, MathLib::createZeroedMatrix(), MaterialPropertyLib::density, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::VariableArray::gas_phase_pressure, NumLib::getIndices(), NumLib::interpolateCoordinates(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_saturation, MaterialPropertyLib::permeability, MaterialPropertyLib::reference_temperature, 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::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtSaturation ( const double , std::vector< GlobalVector * > const & , std::vector< NumLib::LocalToGlobalIndexMap const * > const & , std::vector< double > &  ) const

inlineoverridevirtual

Implements ProcessLib::RichardsFlow::RichardsFlowLocalAssemblerInterface.

Definition at line 265 of file RichardsFlowFEM.h.

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

References _saturation.

getShapeMatrix()

template<typename ShapeFunction, int GlobalDim>

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

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 256 of file RichardsFlowFEM.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.

Member Data Documentation

_element

template<typename ShapeFunction, int GlobalDim>

MeshLib::Element const& ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::_element

private

Definition at line 371 of file RichardsFlowFEM.h.

Referenced by LocalAssemblerData(), assemble(), and getIntPtDarcyVelocity().

_integration_method

template<typename ShapeFunction, int GlobalDim>

NumLib::GenericIntegrationMethod const& ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::_integration_method

private

Definition at line 374 of file RichardsFlowFEM.h.

Referenced by LocalAssemblerData(), assemble(), and getIntPtDarcyVelocity().

_ip_data

template<typename ShapeFunction, int GlobalDim>

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

private

Definition at line 380 of file RichardsFlowFEM.h.

Referenced by LocalAssemblerData(), assemble(), getIntPtDarcyVelocity(), and getShapeMatrix().

_process_data

template<typename ShapeFunction, int GlobalDim>

RichardsFlowProcessData const& ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::_process_data

private

Definition at line 372 of file RichardsFlowFEM.h.

Referenced by LocalAssemblerData(), assemble(), and getIntPtDarcyVelocity().

_saturation

template<typename ShapeFunction, int GlobalDim>

std::vector<double> ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::_saturation

private

Definition at line 381 of file RichardsFlowFEM.h.

Referenced by LocalAssemblerData(), assemble(), and getIntPtSaturation().

---

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

• RichardsFlowFEM.h