ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim > Class Template Reference

Detailed Description

template<typename ShapeFunction, int GlobalDim>
class ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >

Definition at line 67 of file LiquidFlowLocalAssembler.h.

#include <LiquidFlowLocalAssembler.h>

Inheritance diagram for ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >:

Collaboration diagram for ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >:

Classes
struct	AnisotropicCalculator
struct	IsotropicCalculator

Public Member Functions
	LiquidFlowLocalAssembler (MeshLib::Element const &element, std::size_t const, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, LiquidFlowData 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::Vector3d	getFlux (MathLib::Point3d const &p_local_coords, double const t, std::vector< double > const &local_x) const 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 &	getIntPtDarcyVelocity (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &velocity_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< 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	NodalMatrixType = typename LocalAssemblerTraits::LocalMatrix
using	NodalVectorType = typename LocalAssemblerTraits::LocalVector
using	NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType
using	GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType
using	GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType
using	GlobalDimNodalMatrixType

Private Member Functions
template<typename LaplacianGravityVelocityCalculator>
void	assembleMatrixAndVector (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data)
template<typename LaplacianGravityVelocityCalculator, typename VelocityCacheType>
void	computeProjectedDarcyVelocity (const double t, const double dt, std::vector< double > const &local_x, ParameterLib::SpatialPosition const &pos, VelocityCacheType &darcy_velocity_at_ips) const
template<typename VelocityCacheType>
void	computeDarcyVelocity (bool const is_scalar_permeability, const double t, const double dt, std::vector< double > const &local_x, ParameterLib::SpatialPosition const &pos, VelocityCacheType &darcy_velocity_at_ips) const

Private Attributes
MeshLib::Element const &	_element
NumLib::GenericIntegrationMethod const &	_integration_method
std::vector< IntegrationPointData< GlobalDimNodalMatrixType > >	_ip_data
const LiquidFlowData &	_process_data

Member Typedef Documentation

GlobalDimMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType

private

Definition at line 79 of file LiquidFlowLocalAssembler.h.

GlobalDimNodalMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::GlobalDimNodalMatrixType

private

Initial value:

 
        typename ShapeMatricesType::GlobalDimNodalMatrixType

Definition at line 80 of file LiquidFlowLocalAssembler.h.

GlobalDimVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType

private

Definition at line 78 of file LiquidFlowLocalAssembler.h.

LocalAssemblerTraits

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::LocalAssemblerTraits

private

Initial value:

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

Definition at line 72 of file LiquidFlowLocalAssembler.h.

NodalMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::NodalMatrixType = typename LocalAssemblerTraits::LocalMatrix

private

Definition at line 75 of file LiquidFlowLocalAssembler.h.

NodalRowVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType

private

Definition at line 77 of file LiquidFlowLocalAssembler.h.

NodalVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::NodalVectorType = typename LocalAssemblerTraits::LocalVector

private

Definition at line 76 of file LiquidFlowLocalAssembler.h.

ShapeMatrices

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

private

Definition at line 70 of file LiquidFlowLocalAssembler.h.

ShapeMatricesType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, GlobalDim>

private

Definition at line 69 of file LiquidFlowLocalAssembler.h.

Constructor & Destructor Documentation

LiquidFlowLocalAssembler()

template<typename ShapeFunction, int GlobalDim>

ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::LiquidFlowLocalAssembler ( MeshLib::Element const & element, std::size_t const , NumLib::GenericIntegrationMethod const & integration_method, bool const is_axially_symmetric, LiquidFlowData const & process_data )

inline

Definition at line 84 of file LiquidFlowLocalAssembler.h.

        : _element(element),
          _integration_method(integration_method),
          _process_data(process_data)
    {
        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);
 
        ParameterLib::SpatialPosition pos;
        pos.setElementID(_element.getID());
 
        double const aperture_size =
            (_element.getDimension() == 3u)
                ? 1.0
                : _process_data.aperture_size(0.0, pos)[0];
 
        for (unsigned ip = 0; ip < n_integration_points; ip++)
        {
            _ip_data.emplace_back(
                shape_matrices[ip].dNdx,
                _integration_method.getWeightedPoint(ip).getWeight() *
                    shape_matrices[ip].integralMeasure *
                    shape_matrices[ip].detJ * aperture_size);
        }
    }

References _element, _integration_method, _ip_data, _process_data, NumLib::initShapeMatrices(), and ParameterLib::SpatialPosition::setElementID().

Member Function Documentation

assemble()

template<typename ShapeFunction, int GlobalDim>

void ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< 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 )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 27 of file LiquidFlowLocalAssembler-impl.h.

{
    // Dummy integration point
    unsigned const ip = 0;
    // auto const& ip_data = _ip_data[ip];
    auto const& Ns = _process_data.shape_matrix_cache
                         .NsHigherOrder<typename ShapeFunction::MeshElement>();
    auto const& N = Ns[ip];
 
    ParameterLib::SpatialPosition const pos{
        std::nullopt, _element.getID(),
        MathLib::Point3d(
            NumLib::interpolateCoordinates<ShapeFunction, ShapeMatricesType>(
                _element, N))};
 
    auto const& medium = *_process_data.media_map.getMedium(_element.getID());
    MaterialPropertyLib::VariableArray vars;
    vars.temperature =
        medium[MaterialPropertyLib::PropertyType::reference_temperature]
            .template value<double>(vars, pos, t, dt);
    vars.liquid_phase_pressure = std::numeric_limits<double>::quiet_NaN();
    GlobalDimMatrixType const permeability =
        MaterialPropertyLib::formEigenTensor<GlobalDim>(
            medium[MaterialPropertyLib::PropertyType::permeability].value(
                vars, pos, t, dt));
    // Note: For Inclined 1D in 2D/3D or 2D element in 3D, the first item in
    //  the assert must be changed to permeability.rows() ==
    //  _element->getDimension()
    assert(permeability.rows() == GlobalDim || permeability.rows() == 1);
 
    if (permeability.size() == 1)
    {  // isotropic or 1D problem.
        assembleMatrixAndVector<IsotropicCalculator>(
            t, dt, local_x, local_M_data, local_K_data, local_b_data);
    }
    else
    {
        assembleMatrixAndVector<AnisotropicCalculator>(
            t, dt, local_x, local_M_data, local_K_data, local_b_data);
    }
}

References _element, _process_data, assembleMatrixAndVector(), MaterialPropertyLib::formEigenTensor(), NumLib::interpolateCoordinates(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, MaterialPropertyLib::reference_temperature, and MaterialPropertyLib::VariableArray::temperature.

assembleMatrixAndVector()

template<typename ShapeFunction, int GlobalDim>

template<typename LaplacianGravityVelocityCalculator>

void ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::assembleMatrixAndVector ( double const t, double const dt, std::vector< double > const & local_x, std::vector< double > & local_M_data, std::vector< double > & local_K_data, std::vector< double > & local_b_data )

private

Definition at line 121 of file LiquidFlowLocalAssembler-impl.h.

{
    auto const local_matrix_size = local_x.size();
    assert(local_matrix_size == ShapeFunction::NPOINTS);
 
    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);
    const auto local_p_vec =
        MathLib::toVector<NodalVectorType>(local_x, 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& fluid_phase = fluidPhase(medium);
 
    MaterialPropertyLib::VariableArray vars;
    auto& phase_pressure = medium.hasPhase("Gas") ? vars.gas_phase_pressure
                                                  : vars.liquid_phase_pressure;
 
    GlobalDimVectorType const projected_body_force_vector =
        _process_data.element_rotation_matrices[_element.getID()] *
        _process_data.element_rotation_matrices[_element.getID()].transpose() *
        _process_data.specific_body_force;
 
    auto const& Ns = _process_data.shape_matrix_cache
                         .NsHigherOrder<typename ShapeFunction::MeshElement>();
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& ip_data = _ip_data[ip];
        auto const& N = Ns[ip];
 
        phase_pressure = N.dot(local_p_vec);
        ParameterLib::SpatialPosition const pos{
            std::nullopt, _element.getID(),
            MathLib::Point3d(NumLib::interpolateCoordinates<ShapeFunction,
                                                            ShapeMatricesType>(
                _element, N))};
 
        vars.temperature =
            medium[MaterialPropertyLib::PropertyType::reference_temperature]
                .template value<double>(vars, pos, t, dt);
 
        auto const [fluid_density, viscosity] =
            MaterialPropertyLib::getFluidDensityAndViscosity(t, dt, pos,
                                                             fluid_phase, vars);
 
        auto const porosity =
            medium[MaterialPropertyLib::PropertyType::porosity]
                .template value<double>(vars, pos, t, dt);
        auto const specific_storage =
            medium[MaterialPropertyLib::PropertyType::storage]
                .template value<double>(vars, pos, t, dt);
 
        auto const get_drho_dp = [&]()
        {
            return fluid_phase[MaterialPropertyLib::PropertyType::density]
                .template dValue<double>(vars, _process_data.phase_variable,
                                         pos, t, dt);
        };
        auto const storage =
            _process_data.equation_balance_type == EquationBalanceType::volume
                ? specific_storage
                : specific_storage + porosity * get_drho_dp() / fluid_density;
 
        double const scaling_factor =
            _process_data.equation_balance_type == EquationBalanceType::volume
                ? 1.0
                : fluid_density;
        // Assemble mass matrix, M
        local_M.noalias() += scaling_factor * storage * N.transpose() * N *
                             ip_data.integration_weight;
 
        GlobalDimMatrixType const permeability =
            MaterialPropertyLib::formEigenTensor<GlobalDim>(
                medium[MaterialPropertyLib::PropertyType::permeability].value(
                    vars, pos, t, dt));
 
        // Assemble Laplacian, K, and RHS by the gravitational term
        LaplacianGravityVelocityCalculator::calculateLaplacianAndGravityTerm(
            local_K, local_b, ip_data, scaling_factor * permeability, viscosity,
            fluid_density, projected_body_force_vector,
            _process_data.has_gravity);
    }
}

References _element, _integration_method, _ip_data, _process_data, MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::VariableArray::gas_phase_pressure, MaterialPropertyLib::getFluidDensityAndViscosity(), NumLib::interpolateCoordinates(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::reference_temperature, ParameterLib::SpatialPosition::setElementID(), MaterialPropertyLib::storage, MaterialPropertyLib::VariableArray::temperature, MathLib::toVector(), and ProcessLib::LiquidFlow::volume.

Referenced by assemble().

computeDarcyVelocity()

template<typename ShapeFunction, int GlobalDim>

template<typename VelocityCacheType>

void ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::computeDarcyVelocity ( bool const is_scalar_permeability, const double t, const double dt, std::vector< double > const & local_x, ParameterLib::SpatialPosition const & pos, VelocityCacheType & darcy_velocity_at_ips ) const

private

Definition at line 222 of file LiquidFlowLocalAssembler-impl.h.

{
    if (is_scalar_permeability)
    {  // isotropic or 1D problem.
        computeProjectedDarcyVelocity<IsotropicCalculator>(
            t, dt, local_x, pos, darcy_velocity_at_ips);
    }
    else
    {
        computeProjectedDarcyVelocity<AnisotropicCalculator>(
            t, dt, local_x, pos, darcy_velocity_at_ips);
    }
}

References computeProjectedDarcyVelocity().

Referenced by getIntPtDarcyVelocity().

computeProjectedDarcyVelocity()

template<typename ShapeFunction, int GlobalDim>

template<typename LaplacianGravityVelocityCalculator, typename VelocityCacheType>

void ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::computeProjectedDarcyVelocity ( const double t, const double dt, std::vector< double > const & local_x, ParameterLib::SpatialPosition const & pos, VelocityCacheType & darcy_velocity_at_ips ) const

private

Definition at line 301 of file LiquidFlowLocalAssembler-impl.h.

{
    auto const local_matrix_size = local_x.size();
    assert(local_matrix_size == ShapeFunction::NPOINTS);
 
    const auto local_p_vec =
        MathLib::toVector<NodalVectorType>(local_x, local_matrix_size);
 
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    auto const& medium = *_process_data.media_map.getMedium(_element.getID());
    auto const& fluid_phase = fluidPhase(medium);
 
    MaterialPropertyLib::VariableArray vars;
    auto& phase_pressure = medium.hasPhase("Gas") ? vars.gas_phase_pressure
                                                  : vars.liquid_phase_pressure;
 
    GlobalDimVectorType const projected_body_force_vector =
        _process_data.element_rotation_matrices[_element.getID()] *
        _process_data.element_rotation_matrices[_element.getID()].transpose() *
        _process_data.specific_body_force;
 
    auto const& Ns = _process_data.shape_matrix_cache
                         .NsHigherOrder<typename ShapeFunction::MeshElement>();
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& ip_data = _ip_data[ip];
        auto const& N = Ns[ip];
 
        phase_pressure = N.dot(local_p_vec);
        ParameterLib::SpatialPosition const pos{
            std::nullopt, _element.getID(),
            MathLib::Point3d(NumLib::interpolateCoordinates<ShapeFunction,
                                                            ShapeMatricesType>(
                _element, N))};
 
        vars.temperature =
            medium[MaterialPropertyLib::PropertyType::reference_temperature]
                .template value<double>(vars, pos, t, dt);
        auto const [fluid_density, viscosity] =
            MaterialPropertyLib::getFluidDensityAndViscosity(t, dt, pos,
                                                             fluid_phase, vars);
 
        GlobalDimMatrixType const permeability =
            MaterialPropertyLib::formEigenTensor<GlobalDim>(
                medium[MaterialPropertyLib::PropertyType::permeability].value(
                    vars, pos, t, dt));
 
        darcy_velocity_at_ips.col(ip) =
            LaplacianGravityVelocityCalculator::calculateVelocity(
                local_p_vec, ip_data, permeability, viscosity, fluid_density,
                projected_body_force_vector, _process_data.has_gravity);
    }
}

References _element, _integration_method, _ip_data, _process_data, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::VariableArray::gas_phase_pressure, MaterialPropertyLib::getFluidDensityAndViscosity(), NumLib::interpolateCoordinates(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, MaterialPropertyLib::reference_temperature, MaterialPropertyLib::VariableArray::temperature, and MathLib::toVector().

Referenced by computeDarcyVelocity().

getFlux()

template<typename ShapeFunction, int GlobalDim>

Eigen::Vector3d ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::getFlux ( MathLib::Point3d const & p_local_coords, double const t, std::vector< double > const & local_x ) const

overridevirtual

Computes the flux in the point p_local_coords that is given in local coordinates using the values from local_x.

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 74 of file LiquidFlowLocalAssembler-impl.h.

{
    // TODO (tf) Temporary value not used by current material models. Need
    // extension of getFlux interface
    double const dt = std::numeric_limits<double>::quiet_NaN();
 
    // Note: Axial symmetry is set to false here, because we only need dNdx
    // here, which is not affected by axial symmetry.
    auto const shape_matrices =
        NumLib::computeShapeMatrices<ShapeFunction, ShapeMatricesType,
                                     GlobalDim>(_element,
                                                false /*is_axially_symmetric*/,
                                                std::array{p_local_coords})[0];
 
    // create pos object to access the correct media property
    ParameterLib::SpatialPosition pos;
    pos.setElementID(_element.getID());
 
    auto const& medium = *_process_data.media_map.getMedium(_element.getID());
    auto const& fluid_phase = fluidPhase(medium);
 
    MaterialPropertyLib::VariableArray vars;
 
    double pressure = 0.0;
    NumLib::shapeFunctionInterpolate(local_x, shape_matrices.N, pressure);
    vars.liquid_phase_pressure = pressure;
 
    GlobalDimMatrixType const intrinsic_permeability =
        MaterialPropertyLib::formEigenTensor<GlobalDim>(
            medium[MaterialPropertyLib::PropertyType::permeability].value(
                vars, pos, t, dt));
    auto const viscosity =
        fluid_phase[MaterialPropertyLib::PropertyType::viscosity]
            .template value<double>(vars, pos, t, dt);
 
    Eigen::Vector3d flux(0.0, 0.0, 0.0);
    flux.head<GlobalDim>() =
        -intrinsic_permeability / viscosity * shape_matrices.dNdx *
        Eigen::Map<const NodalVectorType>(local_x.data(), local_x.size());
 
    return flux;
}

References _element, _process_data, NumLib::computeShapeMatrices(), MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, ParameterLib::SpatialPosition::setElementID(), NumLib::detail::shapeFunctionInterpolate(), and MaterialPropertyLib::viscosity.

getIntPtDarcyVelocity()

template<typename ShapeFunction, int GlobalDim>

std::vector< double > const & ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity ( const double t, std::vector< GlobalVector * > const & x, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table, std::vector< double > & velocity_cache ) const

overridevirtual

Implements ProcessLib::LiquidFlow::LiquidFlowLocalAssemblerInterface.

Definition at line 242 of file LiquidFlowLocalAssembler-impl.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;
    auto const indices =
        NumLib::getIndices(_element.getID(), *dof_tables[process_id]);
    auto const local_x = x[process_id]->get(indices);
    auto const n_integration_points = _integration_method.getNumberOfPoints();
    velocity_cache.clear();
 
    // Dummy integration point
    unsigned const ip = 0;
    // auto const& ip_data = _ip_data[ip];
    auto const& Ns = _process_data.shape_matrix_cache
                         .NsHigherOrder<typename ShapeFunction::MeshElement>();
    auto const& N = Ns[ip];
 
    ParameterLib::SpatialPosition const pos{
        std::nullopt, _element.getID(),
        MathLib::Point3d(
            NumLib::interpolateCoordinates<ShapeFunction, ShapeMatricesType>(
                _element, N))};
 
    auto const& medium = *_process_data.media_map.getMedium(_element.getID());
    MaterialPropertyLib::VariableArray vars;
    vars.temperature =
        medium[MaterialPropertyLib::PropertyType::reference_temperature]
            .template value<double>(vars, pos, t, dt);
    vars.liquid_phase_pressure = std::numeric_limits<double>::quiet_NaN();
 
    GlobalDimMatrixType const permeability =
        MaterialPropertyLib::formEigenTensor<GlobalDim>(
            medium[MaterialPropertyLib::PropertyType::permeability].value(
                vars, pos, t, dt));
 
    assert(permeability.rows() == GlobalDim || permeability.rows() == 1);
 
    bool const is_scalar_permeability = (permeability.size() == 1);
 
    auto velocity_cache_vectors = MathLib::createZeroedMatrix<
        Eigen::Matrix<double, GlobalDim, Eigen::Dynamic, Eigen::RowMajor>>(
        velocity_cache, GlobalDim, n_integration_points);
 
    computeDarcyVelocity(is_scalar_permeability, t, dt, local_x, pos,
                         velocity_cache_vectors);
 
    return velocity_cache;
}

References _element, _integration_method, _process_data, computeDarcyVelocity(), MathLib::createZeroedMatrix(), MaterialPropertyLib::formEigenTensor(), NumLib::getIndices(), NumLib::interpolateCoordinates(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, MaterialPropertyLib::reference_temperature, and MaterialPropertyLib::VariableArray::temperature.

getShapeMatrix()

template<typename ShapeFunction, int GlobalDim>

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

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 134 of file LiquidFlowLocalAssembler.h.

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

References _process_data.

Member Data Documentation

_element

template<typename ShapeFunction, int GlobalDim>

MeshLib::Element const& ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::_element

private

Definition at line 153 of file LiquidFlowLocalAssembler.h.

Referenced by LiquidFlowLocalAssembler(), assemble(), assembleMatrixAndVector(), computeProjectedDarcyVelocity(), getFlux(), and getIntPtDarcyVelocity().

_integration_method

template<typename ShapeFunction, int GlobalDim>

NumLib::GenericIntegrationMethod const& ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::_integration_method

private

Definition at line 155 of file LiquidFlowLocalAssembler.h.

Referenced by LiquidFlowLocalAssembler(), assembleMatrixAndVector(), computeProjectedDarcyVelocity(), and getIntPtDarcyVelocity().

_ip_data

template<typename ShapeFunction, int GlobalDim>

std::vector<IntegrationPointData<GlobalDimNodalMatrixType> > ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::_ip_data

private

Definition at line 156 of file LiquidFlowLocalAssembler.h.

Referenced by LiquidFlowLocalAssembler(), assembleMatrixAndVector(), and computeProjectedDarcyVelocity().

_process_data

template<typename ShapeFunction, int GlobalDim>

const LiquidFlowData& ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::_process_data

private

Definition at line 225 of file LiquidFlowLocalAssembler.h.

Referenced by LiquidFlowLocalAssembler(), assemble(), assembleMatrixAndVector(), computeProjectedDarcyVelocity(), getFlux(), getIntPtDarcyVelocity(), and getShapeMatrix().

---

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

• LiquidFlowLocalAssembler.h
• LiquidFlowLocalAssembler-impl.h