ProcessLib::TH2M Namespace Reference

Namespaces
	detail

Classes
struct	ConstitutiveVariables
struct	IntegrationPointData
struct	LocalAssemblerInterface
class	LocalDataInitializer
struct	PhaseTransitionDissolution
struct	PhaseTransitionEvaporation
struct	PhaseTransitionFull
struct	PhaseTransitionModelVariables
struct	PhaseTransitionModel
struct	PhaseTransitionNone
struct	SecondaryData
class	TH2MLocalAssembler
class	TH2MProcess
struct	TH2MProcessData

Functions
template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void	createLocalAssemblers (const unsigned, std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, const unsigned shapefunction_order, std::vector< std::unique_ptr< LocalAssemblerInterface >> &local_assemblers, ExtraCtorArgs &&... extra_ctor_args)
std::unique_ptr< PhaseTransitionModel >	createPhaseTransitionModel (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
template<int DisplacementDim>
std::unique_ptr< Process >	createTH2MProcess (std::string 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, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
template std::unique_ptr< Process >	createTH2MProcess< 2 > (std::string 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, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
template std::unique_ptr< Process >	createTH2MProcess< 3 > (std::string 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, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
int	numberOfComponents (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media, std::string phase_name)
int	findComponentIndex (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media, std::string phase_name, MaterialPropertyLib::PropertyType property_type)

Function Documentation

createLocalAssemblers()

template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>

void ProcessLib::TH2M::createLocalAssemblers	(	const unsigned	,
		std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		const unsigned	shapefunction_order,
		std::vector< std::unique_ptr< LocalAssemblerInterface >> &	local_assemblers,
		ExtraCtorArgs &&...	extra_ctor_args
	)

Creates local assemblers for each element of the given mesh.

Template Parameters

LocalAssemblerImplementation	the individual local assembler type
LocalAssemblerInterface	the general local assembler interface
ExtraCtorArgs	types of additional constructor arguments. Those arguments will be passed to the constructor of LocalAssemblerImplementation.

The first two template parameters cannot be deduced from the arguments. Therefore they always have to be provided manually.

Definition at line 70 of file CreateLocalAssemblers.h.

{
    DBUG("Create local assemblers.");
 
    detail::createLocalAssemblers<GlobalDim, LocalAssemblerImplementation>(
        dof_table, shapefunction_order, mesh_elements, local_assemblers,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

References DBUG().

Referenced by ProcessLib::TH2M::TH2MProcess< DisplacementDim >::initializeConcreteProcess().

createPhaseTransitionModel()

std::unique_ptr<PhaseTransitionModel> ProcessLib::TH2M::createPhaseTransitionModel

(

std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &

media

)

Definition at line 30 of file CreateTH2MProcess.cpp.

{
    // the approach here is that the number of phase components determines the
    // nature of the phase transition: If the gas phase consists of two or more
    // components, evaporation is involved; if the water phase consists of at
    // least two components, gas can be dissolved in water.
 
    // Fluid phases are always defined in the first medium of the media vector,
    // thus media.begin() points to the right medium.
    const bool evaporation =
        media.begin()->second->phase("Gas").numberOfComponents() > 1;
 
    const bool dissolution =
        media.begin()->second->phase("AqueousLiquid").numberOfComponents() > 1;
 
    if (evaporation && dissolution)
    {
        return std::make_unique<PhaseTransitionFull>(media);
    }
 
    if (evaporation && !dissolution)
    {
        return std::make_unique<PhaseTransitionEvaporation>(media);
    }
 
    if (!evaporation && dissolution)
    {
        return std::make_unique<PhaseTransitionDissolution>(media);
    }
 
    return std::make_unique<PhaseTransitionNone>(media);
}

Referenced by createTH2MProcess().

createTH2MProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::TH2M::createTH2MProcess	(	std::string	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,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &	media
	)

Input File Parameter:

prj__processes__process__type

Input File Parameter:

prj__processes__process__TH2M__coupling_scheme

Input File Parameter:

prj__processes__process__TH2M__process_variables

Input File Parameter:

prj__processes__process__TH2M__process_variables__gas_pressure

Input File Parameter:

prj__processes__process__TH2M__process_variables__capillary_pressure

Input File Parameter:

prj__processes__process__TH2M__process_variables__temperature

Input File Parameter:

prj__processes__process__TH2M__process_variables__displacement

Input File Parameter:

prj__processes__process__TH2M__reference_temperature

Input File Parameter:

prj__processes__process__TH2M__specific_body_force

Input File Parameter:

prj__processes__process__TH2M__initial_stress

Input File Parameter:

prj__processes__process__TH2M__mass_lumping

Definition at line 65 of file CreateTH2MProcess.cpp.

{
    config.checkConfigParameter("type", "TH2M");
    DBUG("Create TH2M Process.");
    DBUG(" ");
    WARN("Attention! TH2M process has not yet been fully tested!");
    WARN("Check its results critically and report any bugs to");
    WARN("  https://gitlab.opengeosys.org/ogs/ogs/-/issues ");
    WARN(" ");
 
    auto const coupling_scheme =
        config.getConfigParameterOptional<std::string>("coupling_scheme");
    const bool use_monolithic_scheme =
        !(coupling_scheme && (*coupling_scheme == "staggered"));
 
    // Process variable.
    auto const pv_config = config.getConfigSubtree("process_variables");
 
    ProcessVariable* variable_pGR;
    ProcessVariable* variable_pCap;
    ProcessVariable* variable_T;
    ProcessVariable* variable_u;
    std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
        process_variables;
    if (use_monolithic_scheme)  // monolithic scheme.
    {
        auto per_process_variables = findProcessVariables(
            variables, pv_config,
            {
             "gas_pressure",
             "capillary_pressure",
             "temperature",
             "displacement"});
        variable_pGR = &per_process_variables[0].get();
        variable_pCap = &per_process_variables[1].get();
        variable_T = &per_process_variables[2].get();
        variable_u = &per_process_variables[3].get();
        process_variables.push_back(std::move(per_process_variables));
    }
    else  // staggered scheme.
    {
        OGS_FATAL("A Staggered version of TH2M is not implemented.");
 
        using namespace std::string_literals;
        for (auto const& variable_name :
             {"gas_pressure"s, "capillary_pressure"s, "temperature"s,
              "displacement"s})
        {
            auto per_process_variables =
                findProcessVariables(variables, pv_config, {variable_name});
            process_variables.push_back(std::move(per_process_variables));
        }
        variable_pGR = &process_variables[0][0].get();
        variable_pCap = &process_variables[1][0].get();
        variable_T = &process_variables[2][0].get();
        variable_u = &process_variables[3][0].get();
    }
 
    DBUG("Associate displacement with process variable '{:s}'.",
         variable_u->getName());
 
    if (variable_u->getNumberOfGlobalComponents() != DisplacementDim)
    {
        OGS_FATAL(
            "Number of components of the process variable '{:s}' is different "
            "from the displacement dimension: got {:d}, expected {:d}",
            variable_u->getName(),
            variable_u->getNumberOfGlobalComponents(),
            DisplacementDim);
    }
 
    DBUG("Associate gas pressure with process variable '{:s}'.",
         variable_pGR->getName());
    if (variable_pGR->getNumberOfGlobalComponents() != 1)
    {
        OGS_FATAL(
            "Gas pressure process variable '{:s}' is not a scalar variable but "
            "has "
            "{:d} components.",
            variable_pGR->getName(),
            variable_pGR->getNumberOfGlobalComponents());
    }
 
    DBUG("Associate capillary pressure with process variable '{:s}'.",
         variable_pCap->getName());
    if (variable_pCap->getNumberOfGlobalComponents() != 1)
    {
        OGS_FATAL(
            "Capillary pressure process variable '{:s}' is not a scalar "
            "variable but has "
            "{:d} components.",
            variable_pCap->getName(),
            variable_pCap->getNumberOfGlobalComponents());
    }
 
    DBUG("Associate temperature with process variable '{:s}'.",
         variable_T->getName());
    if (variable_T->getNumberOfGlobalComponents() != 1)
    {
        OGS_FATAL(
            "temperature process variable '{:s}' is not a scalar variable but "
            "has {:d} components.",
            variable_T->getName(),
            variable_T->getNumberOfGlobalComponents());
    }
 
    auto solid_constitutive_relations =
        MaterialLib::Solids::createConstitutiveRelations<DisplacementDim>(
            parameters, local_coordinate_system, config);
 
    // reference temperature
    const auto& reference_temperature = ParameterLib::findParameter<double>(
        config,
        "reference_temperature", parameters, 1, &mesh);
    DBUG("Use '{:s}' as reference temperature parameter.",
         reference_temperature.name);
 
    // Specific body force
    Eigen::Matrix<double, DisplacementDim, 1> specific_body_force;
    {
        std::vector<double> const b =
            config.getConfigParameter<std::vector<double>>(
                "specific_body_force");
        if (b.size() != DisplacementDim)
        {
            OGS_FATAL(
                "The size of the specific body force vector does not match the "
                "displacement dimension. Vector size is {:d}, displacement "
                "dimension is {:d}",
                b.size(), DisplacementDim);
        }
 
        std::copy_n(b.data(), b.size(), specific_body_force.data());
    }
 
    // Initial stress conditions
    auto const initial_stress = ParameterLib::findOptionalTagParameter<double>(
        config, "initial_stress", parameters,
        // Symmetric tensor size, 4 or 6, not a Kelvin vector.
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim),
        &mesh);
 
    auto const mass_lumping =
        config.getConfigParameter<bool>("mass_lumping", false);
 
    auto media_map =
        MaterialPropertyLib::createMaterialSpatialDistributionMap(media, mesh);
 
    auto phase_transition_model = createPhaseTransitionModel(media);
    TH2MProcessData<DisplacementDim> process_data{
        materialIDs(mesh),
        std::move(media_map),
        std::move(solid_constitutive_relations),
        std::move(phase_transition_model),
        reference_temperature,
        initial_stress,
        specific_body_force,
        mass_lumping};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<TH2MProcess<DisplacementDim>>(
        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);
}

References BaseLib::ConfigTree::checkConfigParameter(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), createPhaseTransitionModel(), ProcessLib::createSecondaryVariables(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), ProcessLib::ProcessVariable::getName(), ProcessLib::ProcessVariable::getNumberOfGlobalComponents(), MathLib::KelvinVector::kelvin_vector_dimensions(), MeshLib::materialIDs(), MaterialPropertyLib::name, OGS_FATAL, MaterialPropertyLib::reference_temperature, and WARN().

createTH2MProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::TH2M::createTH2MProcess< 2 >	(	std::string	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,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &	media
	)

Referenced by ProjectData::parseProcesses().

createTH2MProcess< 3 >()

template std::unique_ptr< Process > ProcessLib::TH2M::createTH2MProcess< 3 >	(	std::string	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,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &	media
	)

Referenced by ProjectData::parseProcesses().

findComponentIndex()

int ProcessLib::TH2M::findComponentIndex	(	std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &	media,
		std::string	phase_name,
		MaterialPropertyLib::PropertyType	property_type
	)

Definition at line 25 of file PhaseTransitionModel.cpp.

{
    // It is always the first (begin) medium that holds fluid phases.
    auto const medium = media.begin()->second;
    auto const& phase = medium->phase(phase_name);
 
    // find the component for which the property 'property_type' is defined
    for (std::size_t c = 0; c < phase.numberOfComponents(); c++)
    {
        if (phase.component(c).hasProperty(property_type))
        {
            return c;
        }
    }
 
    // A lot of checks can (and should) be done to make sure that the right
    // components with the right properties are used. For example, the names
    // of the components can be compared to check that the name of the
    // evaporable component does not also correspond to the name of the
    // solvate.
 
    OGS_FATAL(
        "PhaseTransitionModel: findComponentIndex() could not find the "
        "specified property type '{:s}' in phase '{:s}'.",
        MaterialPropertyLib::property_enum_to_string[property_type],
        phase_name);
}

References MaterialPropertyLib::c, OGS_FATAL, and MaterialPropertyLib::property_enum_to_string.

numberOfComponents()

int ProcessLib::TH2M::numberOfComponents	(	std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &	media,
		std::string	phase_name
	)

Definition at line 16 of file PhaseTransitionModel.cpp.

{
    // Always the first (begin) medium that holds fluid phases.
    auto const medium = media.begin()->second;
    return medium->phase(phase_name).numberOfComponents();
}

Referenced by MaterialPropertyLib::AverageMolarMass::dValue(), and MaterialPropertyLib::AverageMolarMass::value().