ProcessLib::HT Namespace Reference

Namespaces
namespace	anonymous_namespace{HTFEM.cpp}

Classes
class	HTFEM
class	HTLocalAssemblerInterface
class	HTProcess
struct	HTProcessData
struct	IntegrationPointData
class	MonolithicHTFEM
class	StaggeredHTFEM

Functions
void	checkThermalExpansivitySetting (MaterialPropertyLib::MaterialSpatialDistributionMap const &media_map)
void	checkMPLProperties (MeshLib::Mesh const &mesh, MaterialPropertyLib::MaterialSpatialDistributionMap const &media_map)
std::unique_ptr< Process >	createHTProcess (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
double	evalEffectiveThermalExpansivity (double const t, double const dt, ParameterLib::SpatialPosition const &pos, MaterialPropertyLib::VariableArray const &vars, MaterialPropertyLib::Medium const &medium, MaterialPropertyLib::Phase const &liquid_phase, MaterialPropertyLib::Phase const &solid_phase, bool const has_solid_thermal_expansivity, double const specific_storage)
void	checkBiotStorageRelation (double const t, double const dt, ParameterLib::SpatialPosition const &pos, MaterialPropertyLib::VariableArray const &vars, MaterialPropertyLib::Medium const &medium, MaterialPropertyLib::Phase const &solid_phase)

Variables
const unsigned	NUM_NODAL_DOF = 2

Function Documentation

checkBiotStorageRelation()

void ProcessLib::HT::checkBiotStorageRelation	(	double const	t,
		double const	dt,
		ParameterLib::SpatialPosition const &	pos,
		MaterialPropertyLib::VariableArray const &	vars,
		MaterialPropertyLib::Medium const &	medium,
		MaterialPropertyLib::Phase const &	solid_phase )

Checks the requirement \(\alpha_B=1 \Rightarrow S_s=0\) on the evaluated Biot coefficient of medium and the evaluated specific storage of solid_phase at the position pos, and ends the run with OGS_FATAL if it is violated.

Both properties are evaluated with vars, t and dt, i.e. with the state the caller has set. At initialisation time the caller passes an empty vars and \(t=dt=0\) – the literal zero, not the initial time of the time loop, which may differ. Properties that depend on neither the primary variables nor the time are therefore fully checked there. Properties that do depend on the primary variables evaluate to NaN instead; a Biot coefficient of NaN compares unequal to one and a specific storage of NaN is excluded explicitly, so the check passes in both cases. A property depending on the time is checked at \(t=0\) only, which is a state the simulation need not pass through at all. Those cases are covered by the check on the evaluated values in evalEffectiveThermalExpansivity().

Definition at line 83 of file HTFEM.cpp.

{
    double const biot_coefficient =
        medium.property(MaterialPropertyLib::PropertyType::biot_coefficient)
            .template value<double>(vars, pos, t, dt);
    double const specific_storage =
        solid_phase.property(MaterialPropertyLib::PropertyType::storage)
            .template value<double>(vars, pos, t, dt);
 
    checkBiotStorageRelationValues(pos, biot_coefficient, specific_storage);
}

References MaterialPropertyLib::biot_coefficient, MaterialPropertyLib::Medium::property(), MaterialPropertyLib::Phase::property(), and MaterialPropertyLib::storage.

Referenced by ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::initializeConcrete().

checkMPLProperties()

void ProcessLib::HT::checkMPLProperties	(	MeshLib::Mesh const &	mesh,
		MaterialPropertyLib::MaterialSpatialDistributionMap const &	media_map )

Definition at line 58 of file CreateHTProcess.cpp.

{
    std::array const required_property_medium = {
        MaterialPropertyLib::PropertyType::permeability,
        MaterialPropertyLib::PropertyType::porosity,
        MaterialPropertyLib::PropertyType::thermal_conductivity,
        MaterialPropertyLib::PropertyType::thermal_longitudinal_dispersivity,
        MaterialPropertyLib::PropertyType::thermal_transversal_dispersivity};
 
    std::array const required_property_liquid_phase = {
        MaterialPropertyLib::PropertyType::viscosity,
        MaterialPropertyLib::PropertyType::density,
        MaterialPropertyLib::PropertyType::specific_heat_capacity,
        MaterialPropertyLib::PropertyType::thermal_conductivity};
 
    std::array const required_property_solid_phase = {
        MaterialPropertyLib::PropertyType::specific_heat_capacity,
        MaterialPropertyLib::PropertyType::density,
        MaterialPropertyLib::PropertyType::thermal_conductivity,
        MaterialPropertyLib::PropertyType::storage};
 
    std::array<MaterialPropertyLib::PropertyType, 0> const
        required_gas_properties{};
 
    MaterialPropertyLib::checkMaterialSpatialDistributionMap(
        mesh, media_map, required_property_medium,
        required_property_solid_phase, required_property_liquid_phase,
        required_gas_properties);
 
    checkThermalExpansivitySetting(media_map);
}

References MaterialPropertyLib::checkMaterialSpatialDistributionMap(), checkThermalExpansivitySetting(), MaterialPropertyLib::density, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::specific_heat_capacity, MaterialPropertyLib::storage, MaterialPropertyLib::thermal_conductivity, MaterialPropertyLib::thermal_longitudinal_dispersivity, MaterialPropertyLib::thermal_transversal_dispersivity, and MaterialPropertyLib::viscosity.

Referenced by createHTProcess().

checkThermalExpansivitySetting()

void ProcessLib::HT::checkThermalExpansivitySetting

(

MaterialPropertyLib::MaterialSpatialDistributionMap const &

media_map

)

Definition at line 27 of file CreateHTProcess.cpp.

{
    for (auto const& medium : media_map.media())
    {
        auto const& solid_phase =
            medium->phase(MaterialPropertyLib::PhaseName::Solid);
 
        bool const has_thermal_expansivity = solid_phase.hasProperty(
            MaterialPropertyLib::PropertyType::thermal_expansivity);
        if (has_thermal_expansivity)
        {
            bool const has_biot_coefficient = medium->hasProperty(
                MaterialPropertyLib::PropertyType::biot_coefficient);
            if (!has_biot_coefficient)
            {
                OGS_FATAL(
                    "Thermal expansivity is defined in the solid phase of "
                    "{:s}, which requires the Biot coefficient. Add the "
                    "'biot_coefficient' property to that medium's properties "
                    "in the material configuration.",
                    medium->description());
            }
 
            // The requirement alpha_B = 1 => S_s = 0 is checked on the
            // evaluated values in checkBiotStorageRelation() and
            // evalEffectiveThermalExpansivity().
        }
    }
}

References MaterialPropertyLib::biot_coefficient, MaterialPropertyLib::MaterialSpatialDistributionMap::media(), OGS_FATAL, MaterialPropertyLib::Solid, and MaterialPropertyLib::thermal_expansivity.

Referenced by checkMPLProperties().

createHTProcess()

std::unique_ptr< Process > ProcessLib::HT::createHTProcess	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< MeshLib::Mesh > > const &	meshes,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	media )

Input File Parameter

prj__processes__process__type

Input File Parameter

prj__processes__process__HT__coupling_scheme

Process Variables

Input File Parameter

prj__processes__process__HT__process_variables

Primary process variables as they appear in the global component vector:

Input File Parameter

prj__processes__process__HT__process_variables__temperature

Input File Parameter

prj__processes__process__HT__process_variables__pressure

Process Parameters

Input File Parameter

prj__processes__process__HT__specific_body_force

Input File Parameter

prj__processes__process__calculatesurfaceflux

Input File Parameter

prj__processes__process__HT__aperture_size

Input File Parameter

prj__processes__process__HT__aperture_size__parameter

Input File Parameter

prj__processes__process__HT__equation_balance_type

Definition at line 92 of file CreateHTProcess.cpp.

{
    config.checkConfigParameter("type", "HT");
 
    DBUG("Create HTProcess.");
 
    auto const coupling_scheme =
        config.getConfigParameterOptional<std::string>("coupling_scheme");
    const bool use_monolithic_scheme =
        !(coupling_scheme && (*coupling_scheme == "staggered"));


    auto const pv_config = config.getConfigSubtree("process_variables");
 
    // Process IDs, which are set according to the appearance order of the
    // process variables.
    int const heat_transport_process_id = 0;
    int hydraulic_process_id = 0;
 
    std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
        process_variables;
    if (use_monolithic_scheme)  // monolithic scheme.
    {
        auto per_process_variables = findProcessVariables(
            variables, pv_config,
            {
             "temperature",
             "pressure"});
        process_variables.push_back(std::move(per_process_variables));
    }
    else  // staggered scheme.
    {
        using namespace std::string_literals;
        for (auto const& variable_name : {"temperature"s, "pressure"s})
        {
            auto per_process_variables =
                findProcessVariables(variables, pv_config, {variable_name});
            process_variables.push_back(std::move(per_process_variables));
        }
        hydraulic_process_id = 1;
    }

    std::vector<double> const b =
        config.getConfigParameter<std::vector<double>>("specific_body_force");
    assert(!b.empty() && b.size() < 4);
    int const mesh_space_dimension =
        MeshLib::getSpaceDimension(mesh.getNodes());
    if (static_cast<int>(b.size()) != mesh_space_dimension)
    {
        OGS_FATAL(
            "specific body force (gravity vector) has {:d} components, "
            "mesh dimension is {:d}",
            b.size(), mesh_space_dimension);
    }
 
    // Specific body force parameter.
    Eigen::VectorXd specific_body_force(b.size());
    bool const has_gravity = MathLib::toVector(b).norm() > 0;
    if (has_gravity)
    {
        std::copy_n(b.data(), b.size(), specific_body_force.data());
    }
 
    std::unique_ptr<ProcessLib::SurfaceFluxData> surfaceflux;
    auto calculatesurfaceflux_config =
        config.getConfigSubtreeOptional("calculatesurfaceflux");
    if (calculatesurfaceflux_config)
    {
        surfaceflux = ProcessLib::SurfaceFluxData::createSurfaceFluxData(
            *calculatesurfaceflux_config, meshes);
    }
 
    auto media_map =
        MaterialPropertyLib::createMaterialSpatialDistributionMap(media, mesh);
 
    DBUG("Check the media properties of HT process ...");
    checkMPLProperties(mesh, media_map);
    DBUG("Media properties verified.");
 
    auto stabilizer = NumLib::createNumericalStabilization(mesh, config);
 
    auto const* aperture_size_parameter = &ParameterLib::findParameter<double>(
        ProcessLib::Process::constant_one_parameter_name, parameters, 1);
    auto const aperture_config =
        config.getConfigSubtreeOptional("aperture_size");
    if (aperture_config)
    {
        aperture_size_parameter = &ParameterLib::findParameter<double>(
            *aperture_config, "parameter", parameters, 1);
    }
 
    auto const rotation_matrices = MeshLib::getElementRotationMatrices(
        mesh_space_dimension, mesh.getDimension(), mesh.getElements());
    std::vector<Eigen::VectorXd> projected_specific_body_force_vectors;
    projected_specific_body_force_vectors.reserve(rotation_matrices.size());
 
    std::transform(rotation_matrices.begin(), rotation_matrices.end(),
                   std::back_inserter(projected_specific_body_force_vectors),
                   [&specific_body_force](const auto& R)
                   { return R * R.transpose() * specific_body_force; });
 
    auto const equation_balance_type_str =
        config.getConfigParameter<std::string>("equation_balance_type",
                                               "volume");
    if (equation_balance_type_str != "volume" &&
        equation_balance_type_str != "mass")
    {
        OGS_FATAL(
            "Invalid equation_balance_type '{}'. Supported values: 'volume' or "
            "'mass'.",
            equation_balance_type_str);
    }
    bool const is_volume_balance_equation_type =
        (equation_balance_type_str == "volume");
 
    if (is_volume_balance_equation_type)
    {
        ProcessLib::Common::HydraulicProcess::checkVolumeBalanceEquationSetting(
            media_map);
    }
 
    HTProcessData process_data{std::move(media_map),
                               has_gravity,
                               heat_transport_process_id,
                               hydraulic_process_id,
                               std::move(stabilizer),
                               projected_specific_body_force_vectors,
                               mesh_space_dimension,
                               *aperture_size_parameter,
                               is_volume_balance_equation_type,
                               NumLib::ShapeMatrixCache{integration_order}};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<HTProcess>(
        std::move(name), mesh, std::move(jacobian_assembler), parameters,
        integration_order, std::move(process_variables),
        std::move(process_data), std::move(secondary_variables),
        use_monolithic_scheme, std::move(surfaceflux));
}

References BaseLib::ConfigTree::checkConfigParameter(), checkMPLProperties(), ProcessLib::Common::HydraulicProcess::checkVolumeBalanceEquationSetting(), ProcessLib::Process::constant_one_parameter_name, MaterialPropertyLib::createMaterialSpatialDistributionMap(), NumLib::createNumericalStabilization(), ProcessLib::createSecondaryVariables(), ProcessLib::SurfaceFluxData::createSurfaceFluxData(), DBUG(), ParameterLib::findParameter(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), MeshLib::Mesh::getDimension(), MeshLib::getElementRotationMatrices(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::getSpaceDimension(), OGS_FATAL, and MathLib::toVector().

Referenced by ProjectData::parseProcesses().

evalEffectiveThermalExpansivity()

double ProcessLib::HT::evalEffectiveThermalExpansivity	(	double const	t,
		double const	dt,
		ParameterLib::SpatialPosition const &	pos,
		MaterialPropertyLib::VariableArray const &	vars,
		MaterialPropertyLib::Medium const &	medium,
		MaterialPropertyLib::Phase const &	liquid_phase,
		MaterialPropertyLib::Phase const &	solid_phase,
		bool const	has_solid_thermal_expansivity,
		double const	specific_storage )

Computes the effective thermal expansivity \(3(\alpha_B-\phi)\alpha_T^s - \phi\frac{\partial \varrho_f}{\partial T}/\varrho_f\) used in the thermal expansion term of the pressure equation.

The fluid contribution \(-\phi\frac{\partial \varrho_f}{\partial T}/\varrho_f\) is always present. The solid contribution \(3(\alpha_B-\phi)\alpha_T^s\) is added only if has_solid_thermal_expansivity is true.

Parameters

t	Current time.
dt	Time increment.
pos	Spatial position of the current integration point.
vars	Variable array of the current integration point. Its density and porosity members must already be set, since they are read instead of being evaluated here.
medium	Medium, provides the Biot coefficient \(\alpha_B\).
liquid_phase	Liquid phase, provides \(\frac{\partial \varrho_f}{\partial T}\).
solid_phase	Solid phase, provides the linear solid thermal expansivity \(\alpha_T^s\).
has_solid_thermal_expansivity	Whether the solid phase defines thermal_expansivity. Passed in rather than queried here so that the callers can hoist the property lookup out of their integration point loop.
specific_storage	Specific storage \(S_s\) of the solid phase at the current integration point. Not used in the returned value; it is passed in only so that the requirement \(\alpha_B=1 \Rightarrow S_s=0\) can be checked against the evaluated values, which is the only place where it can be checked for properties that depend on the primary variables. The function is fatal if the requirement is violated. Passed in rather than evaluated here to avoid evaluating the storage property twice per integration point, since the callers already need its value.

Definition at line 43 of file HTFEM.cpp.

{
    double const dfluid_density_dT =
        liquid_phase.property(MaterialPropertyLib::PropertyType::density)
            .template dValue<double>(
                vars, MaterialPropertyLib::Variable::temperature, pos, t, dt);
 
    double const fluid_density = vars.density;
    double const porosity = vars.porosity;
    double const fluid_thermal_expansivity =
        -porosity * dfluid_density_dT / fluid_density;
 
    if (!has_solid_thermal_expansivity)
    {
        return fluid_thermal_expansivity;
    }
 
    double const linear_solid_thermal_expansivity =
        solid_phase
            .property(MaterialPropertyLib::PropertyType::thermal_expansivity)
            .template value<double>(vars, pos, t, dt);
    double const biot_coefficient =
        medium.property(MaterialPropertyLib::PropertyType::biot_coefficient)
            .template value<double>(vars, pos, t, dt);
 
    // Both properties may vary in space and time, so the evaluated values are
    // the only ones that can be compared. The state independent cases are
    // caught earlier by checkBiotStorageRelation().
    checkBiotStorageRelationValues(pos, biot_coefficient, specific_storage);
 
    return fluid_thermal_expansivity + 3.0 * (biot_coefficient - porosity) *
                                           linear_solid_thermal_expansivity;
}

References MaterialPropertyLib::biot_coefficient, MaterialPropertyLib::density, MaterialPropertyLib::VariableArray::density, MaterialPropertyLib::VariableArray::porosity, MaterialPropertyLib::Medium::property(), MaterialPropertyLib::Phase::property(), MaterialPropertyLib::temperature, and MaterialPropertyLib::thermal_expansivity.

Referenced by ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::assemble(), and ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::assembleHydraulicEquation().

Variable Documentation

NUM_NODAL_DOF

const unsigned ProcessLib::HT::NUM_NODAL_DOF = 2

Definition at line 27 of file MonolithicHTFEM.h.

Referenced by ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::MonolithicHTFEM(), and ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::assemble().