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

Detailed Description

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

Definition at line 31 of file StaggeredHTFEM.h.

#include <StaggeredHTFEM.h>

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

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

Public Member Functions
	StaggeredHTFEM (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	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) 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::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)
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	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)
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.
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	GlobalDimNodalMatrixType
using	GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType

Private Member Functions
void	assembleHydraulicEquation (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data)
void	assembleHeatTransportEquation (double const t, double const dt, Eigen::VectorXd const &local_x, std::vector< double > &local_M_data, std::vector< double > &local_K_data)

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::StaggeredHTFEM< ShapeFunction, GlobalDim >::GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType

private

Definition at line 49 of file StaggeredHTFEM.h.

GlobalDimNodalMatrixType

template<typename ShapeFunction , int GlobalDim>

using ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::GlobalDimNodalMatrixType

private

Initial value:

 
        typename ShapeMatricesType::GlobalDimNodalMatrixType

Definition at line 47 of file StaggeredHTFEM.h.

GlobalDimVectorType

template<typename ShapeFunction , int GlobalDim>

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

private

Definition at line 46 of file StaggeredHTFEM.h.

LocalMatrixType

template<typename ShapeFunction , int GlobalDim>

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

private

Initial value:

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

Definition at line 36 of file StaggeredHTFEM.h.

LocalVectorType

template<typename ShapeFunction , int GlobalDim>

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

private

Initial value:

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

Definition at line 39 of file StaggeredHTFEM.h.

NodalMatrixType

template<typename ShapeFunction , int GlobalDim>

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

private

Definition at line 43 of file StaggeredHTFEM.h.

NodalRowVectorType

template<typename ShapeFunction , int GlobalDim>

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

private

Definition at line 44 of file StaggeredHTFEM.h.

NodalVectorType

template<typename ShapeFunction , int GlobalDim>

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

private

Definition at line 42 of file StaggeredHTFEM.h.

ShapeMatrices

template<typename ShapeFunction , int GlobalDim>

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

private

Definition at line 34 of file StaggeredHTFEM.h.

ShapeMatricesType

template<typename ShapeFunction , int GlobalDim>

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

private

Definition at line 33 of file StaggeredHTFEM.h.

Constructor & Destructor Documentation

StaggeredHTFEM()

template<typename ShapeFunction , int GlobalDim>

ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::StaggeredHTFEM ( 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 57 of file StaggeredHTFEM.h.

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

Member Function Documentation

assembleForStaggeredScheme()

template<typename ShapeFunction , int GlobalDim>

void ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::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 )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 26 of file StaggeredHTFEM-impl.h.

{
    if (process_id == this->_process_data.heat_transport_process_id)
    {
        assembleHeatTransportEquation(t, dt, local_x, local_M_data,
                                      local_K_data);
        return;
    }
 
    assembleHydraulicEquation(t, dt, local_x, local_x_prev, local_M_data,
                              local_K_data, local_b_data);
}

assembleHeatTransportEquation()

template<typename ShapeFunction , int GlobalDim>

void ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::assembleHeatTransportEquation ( double const t, double const dt, Eigen::VectorXd const & local_x, std::vector< double > & local_M_data, std::vector< double > & local_K_data )

private

Definition at line 177 of file StaggeredHTFEM-impl.h.

{
    auto const local_p =
        local_x.template segment<pressure_size>(pressure_index);
    auto const local_T =
        local_x.template segment<temperature_size>(temperature_index);
 
    auto local_M = MathLib::createZeroedMatrix<LocalMatrixType>(
        local_M_data, temperature_size, temperature_size);
    auto local_K = MathLib::createZeroedMatrix<LocalMatrixType>(
        local_K_data, temperature_size, temperature_size);
 
    ParameterLib::SpatialPosition pos;
    pos.setElementID(this->_element.getID());
 
    auto const& process_data = this->_process_data;
    auto const& medium =
        *process_data.media_map.getMedium(this->_element.getID());
    auto const& liquid_phase = medium.phase("AqueousLiquid");
 
    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++)
    {
        pos.setIntegrationPoint(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;
 
        double p_at_xi = 0.;
        NumLib::shapeFunctionInterpolate(local_p, N, p_at_xi);
        double T_at_xi = 0.;
        NumLib::shapeFunctionInterpolate(local_T, N, T_at_xi);
 
        vars.temperature = T_at_xi;
        vars.liquid_phase_pressure = p_at_xi;
 
        vars.liquid_saturation = 1.0;
 
        auto const porosity =
            medium.property(MaterialPropertyLib::PropertyType::porosity)
                .template value<double>(vars, pos, t, dt);
        vars.porosity = porosity;
 
        // 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;
        auto const specific_heat_capacity_fluid =
            liquid_phase.property(MaterialPropertyLib::specific_heat_capacity)
                .template value<double>(vars, pos, t, dt);
 
        // Assemble mass matrix
        local_M.noalias() += w *
                             this->getHeatEnergyCoefficient(
                                 vars, porosity, fluid_density,
                                 specific_heat_capacity_fluid, pos, t, dt) *
                             N.transpose() * N;
 
        // Assemble Laplace matrix
        auto const viscosity =
            liquid_phase.property(MaterialPropertyLib::PropertyType::viscosity)
                .template value<double>(vars, pos, t, dt);
 
        auto const intrinsic_permeability =
            MaterialPropertyLib::formEigenTensor<GlobalDim>(
                medium.property(MaterialPropertyLib::PropertyType::permeability)
                    .value(vars, pos, t, dt));
 
        GlobalDimMatrixType const K_over_mu =
            intrinsic_permeability / viscosity;
        GlobalDimVectorType const velocity =
            process_data.has_gravity
                ? GlobalDimVectorType(-K_over_mu *
                                      (dNdx * local_p - fluid_density * b))
                : GlobalDimVectorType(-K_over_mu * dNdx * local_p);
 
        GlobalDimMatrixType const thermal_conductivity_dispersivity =
            this->getThermalConductivityDispersivity(
                vars, fluid_density, specific_heat_capacity_fluid, velocity,
                pos, t, dt);
 
        local_K.noalias() +=
            w * dNdx.transpose() * thermal_conductivity_dispersivity * dNdx;
 
        ip_flux_vector.emplace_back(velocity * fluid_density *
                                    specific_heat_capacity_fluid);
        average_velocity_norm += velocity.norm();
    }
 
    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),
        local_K);
}

References NumLib::detail::assembleAdvectionMatrix(), MathLib::createZeroedMatrix(), MaterialPropertyLib::density, MaterialPropertyLib::VariableArray::density, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_saturation, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, ParameterLib::SpatialPosition::setElementID(), ParameterLib::SpatialPosition::setIntegrationPoint(), NumLib::detail::shapeFunctionInterpolate(), MaterialPropertyLib::specific_heat_capacity, MaterialPropertyLib::VariableArray::temperature, and MaterialPropertyLib::viscosity.

assembleHydraulicEquation()

template<typename ShapeFunction , int GlobalDim>

void ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::assembleHydraulicEquation ( double const t, double const dt, Eigen::VectorXd const & local_x, Eigen::VectorXd const & local_x_prev, std::vector< double > & local_M_data, std::vector< double > & local_K_data, std::vector< double > & local_b_data )

private

Definition at line 44 of file StaggeredHTFEM-impl.h.

{
    auto const local_p =
        local_x.template segment<pressure_size>(pressure_index);
    auto const local_T =
        local_x.template segment<temperature_size>(temperature_index);
 
    auto const local_T_prev =
        local_x_prev.template segment<temperature_size>(temperature_index);
 
    auto local_M = MathLib::createZeroedMatrix<LocalMatrixType>(
        local_M_data, pressure_size, pressure_size);
    auto local_K = MathLib::createZeroedMatrix<LocalMatrixType>(
        local_K_data, pressure_size, pressure_size);
    auto local_b = MathLib::createZeroedVector<LocalVectorType>(local_b_data,
                                                                pressure_size);
 
    ParameterLib::SpatialPosition pos;
    pos.setElementID(this->_element.getID());
 
    auto const& process_data = this->_process_data;
    auto const& medium =
        *this->_process_data.media_map.getMedium(this->_element.getID());
    auto const& liquid_phase = medium.phase("AqueousLiquid");
    auto const& solid_phase = medium.phase("Solid");
 
    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();
 
    auto const& Ns =
        process_data.shape_matrix_cache
            .template NsHigherOrder<typename ShapeFunction::MeshElement>();
 
    for (unsigned ip(0); ip < n_integration_points; ip++)
    {
        pos.setIntegrationPoint(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;
 
        double p_int_pt = 0.0;
        double T_int_pt = 0.0;
        NumLib::shapeFunctionInterpolate(local_p, N, p_int_pt);
        NumLib::shapeFunctionInterpolate(local_T, N, T_int_pt);
 
        vars.temperature = T_int_pt;
        vars.liquid_phase_pressure = p_int_pt;
 
        vars.liquid_saturation = 1.0;
 
        auto const porosity =
            medium.property(MaterialPropertyLib::PropertyType::porosity)
                .template value<double>(vars, pos, t, dt);
        auto const fluid_density =
            liquid_phase.property(MaterialPropertyLib::PropertyType::density)
                .template value<double>(vars, pos, t, dt);
 
        vars.density = fluid_density;
        const double dfluid_density_dp =
            liquid_phase.property(MaterialPropertyLib::PropertyType::density)
                .template dValue<double>(
                    vars, MaterialPropertyLib::Variable::liquid_phase_pressure,
                    pos, t, dt);
 
        // Use the viscosity model to compute the viscosity
        auto const viscosity =
            liquid_phase.property(MaterialPropertyLib::PropertyType::viscosity)
                .template value<double>(vars, pos, t, dt);
 
        // \todo the argument to getValue() has to be changed for non
        // constant storage model
        auto const specific_storage =
            solid_phase.property(MaterialPropertyLib::PropertyType::storage)
                .template value<double>(vars, pos, t, dt);
 
        auto const intrinsic_permeability =
            MaterialPropertyLib::formEigenTensor<GlobalDim>(
                medium.property(MaterialPropertyLib::PropertyType::permeability)
                    .value(vars, pos, t, dt));
        GlobalDimMatrixType const K_over_mu =
            intrinsic_permeability / viscosity;
 
        // matrix assembly
        local_M.noalias() +=
            w *
            (porosity * dfluid_density_dp / fluid_density + specific_storage) *
            N.transpose() * N;
 
        local_K.noalias() += w * dNdx.transpose() * K_over_mu * dNdx;
 
        if (process_data.has_gravity)
        {
            local_b.noalias() +=
                w * fluid_density * dNdx.transpose() * K_over_mu * b;
        }
 
        if (!process_data.has_fluid_thermal_expansion)
        {
            return;
        }
 
        // Add the thermal expansion term
        {
            auto const solid_thermal_expansion =
                process_data.solid_thermal_expansion(t, pos)[0];
            const double dfluid_density_dT =
                liquid_phase
                    .property(MaterialPropertyLib::PropertyType::density)
                    .template dValue<double>(
                        vars, MaterialPropertyLib::Variable::temperature, pos,
                        t, dt);
            double const Tdot_int_pt = (T_int_pt - local_T_prev.dot(N)) / dt;
            auto const biot_constant = process_data.biot_constant(t, pos)[0];
            const double eff_thermal_expansion =
                3.0 * (biot_constant - porosity) * solid_thermal_expansion -
                porosity * dfluid_density_dT / fluid_density;
            local_b.noalias() += eff_thermal_expansion * Tdot_int_pt * w * N;
        }
    }
}

References MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, MaterialPropertyLib::VariableArray::density, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_saturation, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, ParameterLib::SpatialPosition::setElementID(), ParameterLib::SpatialPosition::setIntegrationPoint(), NumLib::detail::shapeFunctionInterpolate(), MaterialPropertyLib::storage, MaterialPropertyLib::temperature, MaterialPropertyLib::VariableArray::temperature, and MaterialPropertyLib::viscosity.

getIntPtDarcyVelocity()

template<typename ShapeFunction , int GlobalDim>

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

overridevirtual

Implements ProcessLib::HT::HTLocalAssemblerInterface.

Definition at line 299 of file StaggeredHTFEM-impl.h.

{
    assert(x.size() == dof_table.size());
    auto const n_processes = dof_table.size();
 
    std::vector<std::vector<GlobalIndexType>> indices_of_all_coupled_processes;
    indices_of_all_coupled_processes.reserve(n_processes);
    for (std::size_t process_id = 0; process_id < n_processes; ++process_id)
    {
        auto const indices =
            NumLib::getIndices(this->_element.getID(), *dof_table[process_id]);
        assert(!indices.empty());
        indices_of_all_coupled_processes.push_back(indices);
    }
    auto const local_xs =
        getCoupledLocalSolutions(x, indices_of_all_coupled_processes);
 
    return this->getIntPtDarcyVelocityLocal(t, local_xs, cache);
}

References ProcessLib::getCoupledLocalSolutions(), and NumLib::getIndices().

---

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

• ProcessLib/HT/StaggeredHTFEM.h
• ProcessLib/HT/StaggeredHTFEM-impl.h