ProcessLib::ThermalTwoPhaseFlowWithPP Namespace Reference

Detailed Description

TODO in this implementation, the thermal properties of gas component directly use the properties of air, e.g. the specific heat capacity of gas component use the specific heat capacity of air, and since a constant specific heat capacity of air is assumed, the enthalpy of air is calculated based on a simplified model. Next, a strategy which can automatically(or from input file)switch between different gas components is required, and should be implemented as a material class, also different enthalpy models for different components are need to be implemented.

Classes
struct	IntegrationPointData
class	ThermalTwoPhaseFlowWithPPLocalAssemblerInterface
class	ThermalTwoPhaseFlowWithPPLocalAssembler
class	ThermalTwoPhaseFlowWithPPMaterialProperties
class	ThermalTwoPhaseFlowWithPPProcess
	A class to simulate the nonisothermal two-phase flow process with phase change phenomena between wetting phase and nonwetting phase in porous media. Note that the phase change here can be caused by evaporation, or by condensation, or by dissolution. The phase appearance and vanish are also taken into account. More...
struct	ThermalTwoPhaseFlowWithPPProcessData

Functions
std::unique_ptr< ThermalTwoPhaseFlowWithPPMaterialProperties >	createThermalTwoPhaseFlowWithPPMaterialProperties (BaseLib::ConfigTree const &config, MeshLib::PropertyVector< int > const *material_ids, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< Process >	createThermalTwoPhaseFlowWithPPProcess (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, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &curves)

Variables
const unsigned	NUM_NODAL_DOF = 3

Function Documentation

createThermalTwoPhaseFlowWithPPMaterialProperties()

std::unique_ptr< ThermalTwoPhaseFlowWithPPMaterialProperties > ProcessLib::ThermalTwoPhaseFlowWithPP::createThermalTwoPhaseFlowWithPPMaterialProperties	(	BaseLib::ConfigTree const &	config,
		MeshLib::PropertyVector< int > const *	material_ids,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__material_property__specific_heat_capacity_solid

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__material_property__specific_heat_capacity_water

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__material_property__specific_heat_capacity_air

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__material_property__specific_heat_capacity_water_vapor

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__material_property__thermal_conductivity_dry_solid

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__material_property__thermal_conductivity_wet_solid

Definition at line 38 of file CreateThermalTwoPhaseFlowWithPPMaterialProperties.cpp.

{
    DBUG(
        "Reading material properties of nonisothermal two-phase flow process.");
    auto two_phase_model_tuple =
        MaterialLib::TwoPhaseFlowWithPP::createTwoPhaseFlowMaterialProperties(
            config, material_ids, parameters);
    auto two_phase_material_model =
        std::move(std::get<0>(two_phase_model_tuple));
    auto const& fluid_config = std::get<1>(two_phase_model_tuple);
 
    // Get fluid properties
    auto const& spec_heat_capacity_solid_conf =
        fluid_config.getConfigSubtree("specific_heat_capacity_solid");
    auto specific_heat_capacity_solid =
        MaterialLib::Fluid::createSpecificFluidHeatCapacityModel(
            spec_heat_capacity_solid_conf);
    auto const& spec_heat_capacity_water_conf =
        fluid_config.getConfigSubtree("specific_heat_capacity_water");
    auto specific_heat_capacity_water =
        MaterialLib::Fluid::createSpecificFluidHeatCapacityModel(
            spec_heat_capacity_water_conf);
    auto const& spec_heat_capacity_air_conf =
        fluid_config.getConfigSubtree("specific_heat_capacity_air");
    auto specific_heat_capacity_air =
        MaterialLib::Fluid::createSpecificFluidHeatCapacityModel(
            spec_heat_capacity_air_conf);
    auto const& spec_heat_capacity_vapor_conf =
        fluid_config.getConfigSubtree("specific_heat_capacity_water_vapor");
    auto specific_heat_capacity_vapor =
        MaterialLib::Fluid::createSpecificFluidHeatCapacityModel(
            spec_heat_capacity_vapor_conf);
 
    auto const& thermal_conductivity_dry_solid_conf =
        fluid_config.getConfigSubtree("thermal_conductivity_dry_solid");
    auto thermal_conductivity_dry_solid =
        MaterialLib::Fluid::createFluidThermalConductivityModel(
            thermal_conductivity_dry_solid_conf);
    auto const& thermal_conductivity_wet_solid_conf =
        fluid_config.getConfigSubtree("thermal_conductivity_wet_solid");
    auto thermal_conductivity_wet_solid =
        MaterialLib::Fluid::createFluidThermalConductivityModel(
            thermal_conductivity_wet_solid_conf);
 
    std::unique_ptr<MaterialLib::Fluid::WaterVaporProperties> vapor_property =
        std::make_unique<MaterialLib::Fluid::WaterVaporProperties>();
 
    return std::make_unique<ThermalTwoPhaseFlowWithPPMaterialProperties>(
        std::move(two_phase_material_model),
        std::move(specific_heat_capacity_solid),
        std::move(specific_heat_capacity_water),
        std::move(specific_heat_capacity_air),
        std::move(specific_heat_capacity_vapor),
        std::move(thermal_conductivity_dry_solid),
        std::move(thermal_conductivity_wet_solid),
        std::move(vapor_property));
}

References MaterialLib::Fluid::createFluidThermalConductivityModel(), MaterialLib::Fluid::createSpecificFluidHeatCapacityModel(), MaterialLib::TwoPhaseFlowWithPP::createTwoPhaseFlowMaterialProperties(), and DBUG().

Referenced by createThermalTwoPhaseFlowWithPPProcess().

createThermalTwoPhaseFlowWithPPProcess()

std::unique_ptr< Process > ProcessLib::ThermalTwoPhaseFlowWithPP::createThermalTwoPhaseFlowWithPPProcess	(	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,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &	curves
	)

Input File Parameter:

prj__processes__process__type

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__process_variables

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__process_variables__gas_pressure

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__process_variables__capillary_pressure

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__process_variables__temperature

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__specific_body_force

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__mass_lumping

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__diffusion_coeff_component_b

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__diffusion_coeff_component_a

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__density_solid

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__latent_heat_evaporation

Input File Parameter:

prj__processes__process__TWOPHASE_FLOW_THERMAL__material_property

Definition at line 27 of file CreateThermalTwoPhaseFlowWithPPProcess.cpp.

{
    config.checkConfigParameter("type", "THERMAL_TWOPHASE_WITH_PP");
 
    DBUG("Create nonisothermal two-phase flow model.");
    auto const pv_config = config.getConfigSubtree("process_variables");
 
    auto per_process_variables = findProcessVariables(
        variables, pv_config,
        {
         "gas_pressure",
         "capillary_pressure",
         "temperature"});
    std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
        process_variables;
    process_variables.push_back(std::move(per_process_variables));
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
    // Specific body force
    std::vector<double> const b =
        config.getConfigParameter<std::vector<double>>("specific_body_force");
    assert(!b.empty() && b.size() < 4);
    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());
    }
 
    auto mass_lumping = config.getConfigParameter<bool>("mass_lumping");
    // diffusion coeff
    auto const& diff_coeff_b = ParameterLib::findParameter<double>(
        config,
        "diffusion_coeff_component_b", parameters, 1, &mesh);
    auto const& diff_coeff_a = ParameterLib::findParameter<double>(
        config,
        "diffusion_coeff_component_a", parameters, 1, &mesh);
 
    // Parameter for the density of the solid.
 
    auto const& density_solid = ParameterLib::findParameter<double>(
        config,
        "density_solid", parameters, 1, &mesh);
    DBUG("Use '{:s}' as density_solid parameter.", density_solid.name);
 
    // Parameter for the latent heat of evaporation.
    auto const& latent_heat_evaporation = ParameterLib::findParameter<double>(
        config,
        "latent_heat_evaporation", parameters, 1, &mesh);
    DBUG("Use '{:s}' as latent_heat_evaporation parameter.",
         latent_heat_evaporation.name);
 
    auto const& mat_config = config.getConfigSubtree("material_property");
 
    std::unique_ptr<ThermalTwoPhaseFlowWithPPMaterialProperties> material =
        createThermalTwoPhaseFlowWithPPMaterialProperties(
            mat_config, materialIDs(mesh), parameters);
 
    ThermalTwoPhaseFlowWithPPProcessData process_data{specific_body_force,
                                                      has_gravity,
                                                      mass_lumping,
                                                      diff_coeff_b,
                                                      diff_coeff_a,
                                                      density_solid,
                                                      latent_heat_evaporation,
                                                      std::move(material)};
 
    return std::make_unique<ThermalTwoPhaseFlowWithPPProcess>(
        std::move(name), mesh, std::move(jacobian_assembler), parameters,
        integration_order, std::move(process_variables),
        std::move(process_data), std::move(secondary_variables), mat_config,
        curves);
}

References BaseLib::ConfigTree::checkConfigParameter(), ProcessLib::createSecondaryVariables(), createThermalTwoPhaseFlowWithPPMaterialProperties(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), MeshLib::materialIDs(), MaterialPropertyLib::name, and MathLib::toVector().

Referenced by ProjectData::parseProcesses().

Variable Documentation

NUM_NODAL_DOF

const unsigned ProcessLib::ThermalTwoPhaseFlowWithPP::NUM_NODAL_DOF = 3

Definition at line 56 of file ThermalTwoPhaseFlowWithPPLocalAssembler.h.

Referenced by ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble().