ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim > Class Template Reference

Detailed Description

template<typename ShapeFunction, int GlobalDim>
class ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >

Definition at line 30 of file MonolithicHTFEM.h.

#include <MonolithicHTFEM.h>

Inheritance diagram for ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >:

Collaboration diagram for ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >:

Public Member Functions
	MonolithicHTFEM (MeshLib::Element const &element, std::size_t const local_matrix_size, NumLib::GenericIntegrationMethod const &integration_method, bool is_axially_symmetric, HTProcessData 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
std::vector< double > const &	getIntPtDarcyVelocity (double const 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::HT::HTFEM< ShapeFunction, GlobalDim >
	HTFEM (MeshLib::Element const &element, std::size_t const local_matrix_size, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, HTProcessData const &process_data, const unsigned dof_per_node)
void	initializeConcrete () override
Eigen::Map< const Eigen::RowVectorXd >	getShapeMatrix (const unsigned integration_point) const override
	Provides the shape matrix at the given integration point.
Eigen::Vector3d	getFlux (MathLib::Point3d const &pnt_local_coords, double const t, std::vector< double > const &local_x) const override
Public Member Functions inherited from ProcessLib::HT::HTLocalAssemblerInterface
	HTLocalAssemblerInterface ()=default
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 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	LocalMatrixType
using	LocalVectorType
using	NodalVectorType = typename ShapeMatricesType::NodalVectorType
using	NodalMatrixType = typename ShapeMatricesType::NodalMatrixType
using	NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType
using	GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType
using	GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType

Additional Inherited Members
Protected Member Functions inherited from ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >
double	getHeatEnergyCoefficient (MaterialPropertyLib::VariableArray const &vars, const double porosity, const double fluid_density, const double specific_heat_capacity_fluid, ParameterLib::SpatialPosition const &pos, double const t, double const dt)
GlobalDimMatrixType	getThermalConductivityDispersivity (MaterialPropertyLib::VariableArray const &vars, const double fluid_density, const double specific_heat_capacity_fluid, const GlobalDimVectorType &velocity, ParameterLib::SpatialPosition const &pos, double const t, double const dt)
std::vector< double > const &	getIntPtDarcyVelocityLocal (const double t, std::vector< double > const &local_x, std::vector< double > &cache) const
Protected Attributes inherited from ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >
MeshLib::Element const &	_element
HTProcessData const &	_process_data
NumLib::GenericIntegrationMethod const &	_integration_method
std::vector< IntegrationPointData< GlobalDimNodalMatrixType > >	_ip_data
Static Protected Attributes inherited from ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >
static const int	pressure_index = ShapeFunction::NPOINTS
static const int	pressure_size = ShapeFunction::NPOINTS
static const int	temperature_index = 0
static const int	temperature_size = ShapeFunction::NPOINTS

Member Typedef Documentation

GlobalDimMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType

private

Definition at line 47 of file MonolithicHTFEM.h.

GlobalDimVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType

private

Definition at line 46 of file MonolithicHTFEM.h.

LocalMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::LocalMatrixType

private

Initial value:

 typename ShapeMatricesType::template MatrixType<
        NUM_NODAL_DOF * ShapeFunction::NPOINTS,
        NUM_NODAL_DOF * ShapeFunction::NPOINTS>

Definition at line 35 of file MonolithicHTFEM.h.

LocalVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::LocalVectorType

private

Initial value:

 
        typename ShapeMatricesType::template VectorType<NUM_NODAL_DOF *
                                                        ShapeFunction::NPOINTS>

Definition at line 38 of file MonolithicHTFEM.h.

NodalMatrixType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

private

Definition at line 43 of file MonolithicHTFEM.h.

NodalRowVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType

private

Definition at line 44 of file MonolithicHTFEM.h.

NodalVectorType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

private

Definition at line 42 of file MonolithicHTFEM.h.

ShapeMatrices

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

private

Definition at line 33 of file MonolithicHTFEM.h.

ShapeMatricesType

template<typename ShapeFunction, int GlobalDim>

using ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, GlobalDim>

private

Definition at line 32 of file MonolithicHTFEM.h.

Constructor & Destructor Documentation

MonolithicHTFEM()

template<typename ShapeFunction, int GlobalDim>

ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::MonolithicHTFEM ( MeshLib::Element const & element, std::size_t const local_matrix_size, NumLib::GenericIntegrationMethod const & integration_method, bool is_axially_symmetric, HTProcessData const & process_data )

inline

Definition at line 50 of file MonolithicHTFEM.h.

        : HTFEM<ShapeFunction, GlobalDim>(
              element, local_matrix_size, integration_method,
              is_axially_symmetric, process_data, NUM_NODAL_DOF)
    {
    }

References ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::HTFEM(), and ProcessLib::HT::NUM_NODAL_DOF.

Member Function Documentation

assemble()

template<typename ShapeFunction, int GlobalDim>

void ProcessLib::HT::MonolithicHTFEM< 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 61 of file MonolithicHTFEM.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<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 KTT = local_K.template block<temperature_size, temperature_size>(
            temperature_index, temperature_index);
        auto MTT = local_M.template block<temperature_size, temperature_size>(
            temperature_index, temperature_index);
        auto Kpp = local_K.template block<pressure_size, pressure_size>(
            pressure_index, pressure_index);
        auto Mpp = local_M.template block<pressure_size, pressure_size>(
            pressure_index, pressure_index);
        auto MpT = local_M.template block<pressure_size, temperature_size>(
            pressure_index, temperature_index);
        auto Bp = local_b.template block<pressure_size, 1>(pressure_index, 0);
 
        typename ShapeMatricesType::NodalMatrixType NtN;
 
        auto const& process_data = this->_process_data;
 
        auto p_nodal_values = Eigen::Map<const NodalVectorType>(
            &local_x[pressure_index], pressure_size);
 
        auto const& medium =
            *process_data.media_map.getMedium(this->_element.getID());
        auto const& liquid_phase =
            medium.phase(MaterialPropertyLib::PhaseName::AqueousLiquid);
        auto const& solid_phase =
            medium.phase(MaterialPropertyLib::PhaseName::Solid);
 
        bool const has_solid_thermal_expansivity = solid_phase.hasProperty(
            MaterialPropertyLib::PropertyType::thermal_expansivity);
 
        auto const& b =
            process_data
                .projected_specific_body_force_vectors[this->_element.getID()];
 
        MaterialPropertyLib::VariableArray vars;
 
        unsigned const n_integration_points =
            this->_integration_method.getNumberOfPoints();
 
        std::vector<GlobalDimVectorType> ip_flux_vector;
        double average_velocity_norm = 0.0;
        ip_flux_vector.reserve(n_integration_points);
 
        auto const& Ns =
            process_data.shape_matrix_cache
                .template NsHigherOrder<typename ShapeFunction::MeshElement>();
 
        for (unsigned ip(0); ip < n_integration_points; ip++)
        {
            auto const& ip_data = this->_ip_data[ip];
            auto const& dNdx = ip_data.dNdx;
            auto const& N = Ns[ip];
            auto const& w = ip_data.integration_weight;
 
            ParameterLib::SpatialPosition const pos{
                std::nullopt, this->_element.getID(),
                MathLib::Point3d(
                    NumLib::interpolateCoordinates<ShapeFunction,
                                                   ShapeMatricesType>(
                        this->_element, N))};
 
            double T_int_pt = 0.0;
            double p_int_pt = 0.0;
            // Order matters: First T, then P!
            NumLib::shapeFunctionInterpolate(local_x, N, T_int_pt, p_int_pt);
 
            vars.temperature = T_int_pt;
            vars.liquid_phase_pressure = p_int_pt;
 
            vars.liquid_saturation = 1.0;
            auto const specific_storage =
                solid_phase.property(MaterialPropertyLib::PropertyType::storage)
                    .template value<double>(vars, pos, t, dt);
 
            auto const porosity =
                medium.property(MaterialPropertyLib::PropertyType::porosity)
                    .template value<double>(vars, pos, t, dt);
            vars.porosity = porosity;
 
            auto const intrinsic_permeability =
                MaterialPropertyLib::formEigenTensor<GlobalDim>(
                    medium
                        .property(
                            MaterialPropertyLib::PropertyType::permeability)
                        .value(vars, pos, t, dt));
 
            auto const specific_heat_capacity_fluid =
                liquid_phase
                    .property(MaterialPropertyLib::specific_heat_capacity)
                    .template value<double>(vars, pos, t, dt);
 
            // Use the fluid density model to compute the density
            auto const fluid_density =
                liquid_phase
                    .property(MaterialPropertyLib::PropertyType::density)
                    .template value<double>(vars, pos, t, dt);
 
            vars.density = fluid_density;
 
            // Use the viscosity model to compute the viscosity
            auto const viscosity =
                liquid_phase
                    .property(MaterialPropertyLib::PropertyType::viscosity)
                    .template value<double>(vars, pos, t, dt);
            GlobalDimMatrixType K_over_mu = intrinsic_permeability / viscosity;
 
            GlobalDimVectorType const velocity =
                process_data.has_gravity
                    ? GlobalDimVectorType(-K_over_mu * (dNdx * p_nodal_values -
                                                        fluid_density * b))
                    : GlobalDimVectorType(-K_over_mu * dNdx * p_nodal_values);
 
            // matrix assembly
            GlobalDimMatrixType const thermal_conductivity_dispersivity =
                this->getThermalConductivityDispersivity(
                    vars, fluid_density, specific_heat_capacity_fluid, velocity,
                    pos, t, dt);
 
            KTT.noalias() +=
                dNdx.transpose() * thermal_conductivity_dispersivity * dNdx * w;
 
            ip_flux_vector.emplace_back(velocity * fluid_density *
                                        specific_heat_capacity_fluid);
            average_velocity_norm += velocity.norm();
 
            NtN.noalias() = N.transpose() * N;
 
            MTT.noalias() +=
                (w * this->getHeatEnergyCoefficient(
                         vars, porosity, fluid_density,
                         specific_heat_capacity_fluid, pos, t, dt)) *
                NtN;
 
            double const scaling_factor =
                process_data.is_volume_balance_equation_type ? 1.0
                                                             : fluid_density;
 
            Kpp.noalias() +=
                (scaling_factor * w) * dNdx.transpose() * K_over_mu * dNdx;
 
            double const dfluid_density_dp =
                liquid_phase
                    .property(MaterialPropertyLib::PropertyType::density)
                    .template dValue<double>(
                        vars,
                        MaterialPropertyLib::Variable::liquid_phase_pressure,
                        pos, t, dt);
 
            Mpp.noalias() += (scaling_factor * w *
                              (porosity * dfluid_density_dp / fluid_density +
                               specific_storage)) *
                             NtN;
            if (process_data.has_gravity)
            {
                Bp += (scaling_factor * w * fluid_density) * dNdx.transpose() *
                      K_over_mu * b;
            }
 
            // Add the thermal expansion term
            {
                double const eff_thermal_expansivity =
                    evalEffectiveThermalExpansivity(
                        t, dt, pos, vars, medium, liquid_phase, solid_phase,
                        has_solid_thermal_expansivity, specific_storage);
                MpT.noalias() -=
                    (scaling_factor * w * eff_thermal_expansivity) * NtN;
            }
        }
 
        NumLib::assembleAdvectionMatrix<typename ShapeFunction::MeshElement>(
            process_data.stabilizer, this->_ip_data,
            process_data.shape_matrix_cache, ip_flux_vector,
            average_velocity_norm / static_cast<double>(n_integration_points),
            KTT);
    }

References ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::_element, ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::_integration_method, ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::_ip_data, ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::_process_data, MaterialPropertyLib::AqueousLiquid, NumLib::detail::assembleAdvectionMatrix(), MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, MaterialPropertyLib::VariableArray::density, ProcessLib::HT::evalEffectiveThermalExpansivity(), MaterialPropertyLib::formEigenTensor(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getHeatEnergyCoefficient(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getThermalConductivityDispersivity(), NumLib::interpolateCoordinates(), MaterialPropertyLib::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_saturation, ProcessLib::HT::NUM_NODAL_DOF, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::pressure_index, ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::pressure_size, NumLib::detail::shapeFunctionInterpolate(), MaterialPropertyLib::Solid, MaterialPropertyLib::specific_heat_capacity, MaterialPropertyLib::storage, MaterialPropertyLib::VariableArray::temperature, ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::temperature_index, MaterialPropertyLib::thermal_expansivity, and MaterialPropertyLib::viscosity.

getIntPtDarcyVelocity()

template<typename ShapeFunction, int GlobalDim>

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

inlineoverridevirtual

Implements ProcessLib::HT::HTLocalAssemblerInterface.

Definition at line 255 of file MonolithicHTFEM.h.

    {
        int const process_id = 0;  // monolithic case.
        auto const indices =
            NumLib::getIndices(this->_element.getID(), *dof_table[process_id]);
        assert(!indices.empty());
        auto const& local_x = x[process_id]->get(indices);
 
        return this->getIntPtDarcyVelocityLocal(t, local_x, cache);
    }

References ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::_element, NumLib::getIndices(), and ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getIntPtDarcyVelocityLocal().

---

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

• MonolithicHTFEM.h