ProcessLib::HeatTransportBHE Namespace Reference

Namespaces
	BHE
	detail

Classes
struct	BHEMeshData
class	BHEBottomDirichletBoundaryCondition
class	BHEInflowDirichletBoundaryCondition
class	HeatTransportBHEProcess
struct	HeatTransportBHEProcessData
class	HeatTransportBHELocalAssemblerBHE
class	HeatTransportBHELocalAssemblerSoil
class	HeatTransportBHELocalAssemblerInterface
struct	IntegrationPointDataBHE
struct	IntegrationPointDataSoil
class	LocalDataInitializer
struct	SecondaryData

Functions
BHEMeshData	getBHEDataInMesh (MeshLib::Mesh const &mesh)
std::unique_ptr< BHEBottomDirichletBoundaryCondition >	createBHEBottomDirichletBoundaryCondition (std::pair< GlobalIndexType, GlobalIndexType > &&in_out_global_indices)
template<typename BHEUpdateCallback >
std::unique_ptr< BHEInflowDirichletBoundaryCondition< BHEUpdateCallback > >	createBHEInflowDirichletBoundaryCondition (std::pair< GlobalIndexType, GlobalIndexType > &&in_out_global_indices, BHEUpdateCallback bhe_update_callback)
std::unique_ptr< Process >	createHeatTransportBHEProcess (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, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
template<template< typename, typename > class LocalAssemblerSoilImplementation, template< typename, typename, typename > class LocalAssemblerBHEImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void	createLocalAssemblers (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface >> &local_assemblers, ExtraCtorArgs &&... extra_ctor_args)
Eigen::Vector3d	compute1Dto3DRotationMatrix (MeshLib::Element const &e)

Function Documentation

compute1Dto3DRotationMatrix()

Eigen::Vector3d ProcessLib::HeatTransportBHE::compute1Dto3DRotationMatrix

(

MeshLib::Element const &

e

)

Definition at line 22 of file HeatTransportBHELocalAssemblerBHE-impl.h.

{
    constexpr int global_dim = 3;
    constexpr int element_dim = 1;
 
    assert(e.getDimension() == element_dim);
    const MeshLib::ElementCoordinatesMappingLocal ele_local_coord(e,
                                                                  global_dim);
    return ele_local_coord.getRotationMatrixToGlobal()
        .template topLeftCorner<global_dim, element_dim>();
}

References MeshLib::Element::getDimension(), and MeshLib::ElementCoordinatesMappingLocal::getRotationMatrixToGlobal().

createBHEBottomDirichletBoundaryCondition()

std::unique_ptr< BHEBottomDirichletBoundaryCondition > ProcessLib::HeatTransportBHE::createBHEBottomDirichletBoundaryCondition

(

std::pair< GlobalIndexType, GlobalIndexType > &&

in_out_global_indices

)

Definition at line 32 of file BHEBottomDirichletBoundaryCondition.cpp.

{
    DBUG("Constructing BHEBottomDirichletBoundaryCondition.");
 
    // In case of partitioned mesh the boundary could be empty, i.e. there is no
    // boundary condition.
#ifdef USE_PETSC
    // For this special boundary condition the boundary condition is not empty
    // if the global indices are non-negative.
    if (in_out_global_indices.first < 0 && in_out_global_indices.second < 0)
    {
        return nullptr;
    }
    // If only one of the global indices (in or out) is negative the
    // implementation is not valid.
    if (in_out_global_indices.first < 0 || in_out_global_indices.second < 0)
    {
        OGS_FATAL(
            "The partition cuts the BHE into two independent parts. This "
            "behaviour is not implemented.");
    }
#endif  // USE_PETSC
 
    return std::make_unique<BHEBottomDirichletBoundaryCondition>(
        std::move(in_out_global_indices));
}

References DBUG(), and OGS_FATAL.

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom().

createBHEInflowDirichletBoundaryCondition()

template<typename BHEUpdateCallback >

std::unique_ptr<BHEInflowDirichletBoundaryCondition<BHEUpdateCallback> > ProcessLib::HeatTransportBHE::createBHEInflowDirichletBoundaryCondition	(	std::pair< GlobalIndexType, GlobalIndexType > &&	in_out_global_indices,
		BHEUpdateCallback	bhe_update_callback
	)

Definition at line 50 of file BHEInflowDirichletBoundaryCondition.h.

{
    DBUG("Constructing BHEInflowDirichletBoundaryCondition.");
 
    // In case of partitioned mesh the boundary could be empty, i.e. there is no
    // boundary condition.
#ifdef USE_PETSC
    // For this special boundary condition the boundary condition is not empty
    // if the global indices are non-negative.
    if (in_out_global_indices.first < 0 && in_out_global_indices.second < 0)
    {
        return nullptr;
    }
    // If only one of the global indices (in or out) is negative the
    // implementation is not valid.
    if (in_out_global_indices.first < 0 || in_out_global_indices.second < 0)
    {
        OGS_FATAL(
            "The partition cuts the BHE into two independent parts. This "
            "behaviour is not implemented.");
    }
#endif  // USE_PETSC
 
    return std::make_unique<
        BHEInflowDirichletBoundaryCondition<BHEUpdateCallback>>(
        std::move(in_out_global_indices), bhe_update_callback);
}

References DBUG(), and OGS_FATAL.

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom().

createHeatTransportBHEProcess()

std::unique_ptr< Process > ProcessLib::HeatTransportBHE::createHeatTransportBHEProcess	(	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,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &	media
	)

Input File Parameter:

prj__processes__process__type

Input File Parameter:

prj__processes__process__HEAT_TRANSPORT_BHE__process_variables

Input File Parameter:

prj__processes__process__HEAT_TRANSPORT_BHE__process_variables__process_variable

Input File Parameter:

prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers

Input File Parameter:

prj__processes__process__HEAT_TRANSPORT_BHE__use_server_communication

Input File Parameter:

prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger

Input File Parameter:

prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__type

Python object computing BC values.

Definition at line 31 of file CreateHeatTransportBHEProcess.cpp.

{
    config.checkConfigParameter("type", "HEAT_TRANSPORT_BHE");
 
    DBUG("Create HeatTransportBHE Process.");
 
    // Process variable.
 
    auto const pv_config = config.getConfigSubtree("process_variables");
    std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
        process_variables;
 
    // reading primary variables for each
    // BHE----------------------------------------------------------
    auto range =
        pv_config.getConfigParameterList<std::string>("process_variable");
    std::vector<std::reference_wrapper<ProcessVariable>> per_process_variables;
 
    for (std::string const& pv_name : range)
    {
        if (pv_name != "temperature_soil" &&
            pv_name.find("temperature_BHE") == std::string::npos)
        {
            OGS_FATAL(
                "Found a process variable name '{:s}'. It should be "
                "'temperature_soil' or 'temperature_BHE_X'");
        }
        auto variable = std::find_if(variables.cbegin(), variables.cend(),
                                     [&pv_name](ProcessVariable const& v)
                                     { return v.getName() == pv_name; });
 
        if (variable == variables.end())
        {
            OGS_FATAL(
                "Could not find process variable '{:s}' in the provided "
                "variables list for config tag <{:s}>.",
                pv_name, "process_variable");
        }
        DBUG("Found process variable '{:s}' for config tag <{:s}>.",
             variable->getName(), "process_variable");
 
        per_process_variables.emplace_back(
            const_cast<ProcessVariable&>(*variable));
    }
    process_variables.push_back(std::move(per_process_variables));
    // end of reading primary variables for each
    // BHE----------------------------------------------------------
 
    // reading BHE parameters --------------------------------------------------
    std::vector<BHE::BHETypes> bhes;
 
    auto const& bhe_configs =
        config.getConfigSubtree("borehole_heat_exchangers");
 
    auto const using_server_communication =
        config.getConfigParameter<bool>("use_server_communication", false);
 
    for (
        auto const& bhe_config :
        bhe_configs.getConfigSubtreeList("borehole_heat_exchanger"))
    {
        // read in the parameters
        const std::string bhe_type =
            bhe_config.getConfigParameter<std::string>("type");
 
        if (bhe_type == "1U")
        {
            bhes.emplace_back(
                BHE::createBHEUType<BHE::BHE_1U>(bhe_config, curves));
            continue;
        }
 
        if (bhe_type == "CXA")
        {
            bhes.emplace_back(
                BHE::createBHECoaxial<BHE::BHE_CXA>(bhe_config, curves));
            continue;
        }
 
        if (bhe_type == "CXC")
        {
            bhes.emplace_back(
                BHE::createBHECoaxial<BHE::BHE_CXC>(bhe_config, curves));
            continue;
        }
 
        if (bhe_type == "2U")
        {
            bhes.emplace_back(
                BHE::createBHEUType<BHE::BHE_2U>(bhe_config, curves));
            continue;
        }
 
        if (bhe_type == "1P")
        {
            bhes.emplace_back(
                BHE::createBHE1PType<BHE::BHE_1P>(bhe_config, curves));
            continue;
        }
        OGS_FATAL("Unknown BHE type '{:s}'.", bhe_type);
    }
    // end of reading BHE parameters -------------------------------------------
 
    auto media_map =
        MaterialPropertyLib::createMaterialSpatialDistributionMap(media, mesh);
 
    // find if bhe uses python boundary condition
    auto const using_tespy =
        visit([](auto const& bhe) { return bhe.use_python_bcs; }, bhes[0]);
 
    BHEInflowPythonBoundaryConditionPythonSideInterface* py_object = nullptr;
    // create a pythonBoundaryCondition object
    if (using_tespy || using_server_communication)
    {
#ifdef OGS_USE_PYTHON
        // Evaluate Python code in scope of main module
        pybind11::object scope =
            pybind11::module::import("__main__").attr("__dict__");
 
        if (!scope.contains("bc_bhe"))
            OGS_FATAL(
                "Function 'bc_bhe' is not defined in the python script file, "
                "or there was no python script file specified.");
 
        py_object =
            scope["bc_bhe"]
                .cast<BHEInflowPythonBoundaryConditionPythonSideInterface*>();
 
        if (py_object == nullptr)
            OGS_FATAL(
                "Not able to access the correct bc pointer from python script "
                "file specified.");
 
        // create BHE network dataframe from Python
        py_object->dataframe_network = py_object->initializeDataContainer();
        if (!py_object->isOverriddenEssential())
        {
            DBUG(
                "Method `initializeDataContainer' not overridden in Python "
                "script.");
        }
        // clear ogs bc_node_id memory in dataframe
        std::get<3>(py_object->dataframe_network).clear();  // ogs_bc_node_id
 
        // here calls the tespyHydroSolver to get the pipe flow velocity in bhe
        // network
        /* for 2U type the flowrate initialization process below causes conflict
        // replace the value in flow velocity Matrix _u
        auto const tespy_flow_rate = std::get<4>(py_object->dataframe_network);
        const std::size_t n_bhe = tespy_flow_rate.size();
        if (bhes.size() != n_bhe)
            OGS_FATAL(
                "The number of BHEs defined in OGS and TESPy are not the "
                "same!");
 
        for (std::size_t idx_bhe = 0; idx_bhe < n_bhe; idx_bhe++)
        {
            // the flow_rate in OGS should be updated from the flow_rate
            // computed by TESPy.
            auto update_flow_rate = [&](auto& bhe) {
                bhe.updateHeatTransferCoefficients(tespy_flow_rate[idx_bhe]);
            };
            visit(update_flow_rate, bhes[idx_bhe]);
        }
        */
#else
        OGS_FATAL(
            "Input files suggest the coupling of BHE with pipe network. "
            "This means the compiling flag OGS_USE_PYTHON must be switched "
            "on. ");
#endif  // OGS_USE_PYTHON
    }
 
    HeatTransportBHEProcessData process_data(
        std::move(media_map), std::move(bhes), py_object, using_tespy,
        using_server_communication);
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<HeatTransportBHEProcess>(
        std::move(name), mesh, std::move(jacobian_assembler), parameters,
        integration_order, std::move(process_variables),
        std::move(process_data), std::move(secondary_variables));
}

References BaseLib::ConfigTree::checkConfigParameter(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterList(), BaseLib::ConfigTree::getConfigSubtree(), MaterialPropertyLib::name, and OGS_FATAL.

Referenced by ProjectData::parseProcesses().

createLocalAssemblers()

template<template< typename, typename > class LocalAssemblerSoilImplementation, template< typename, typename, typename > class LocalAssemblerBHEImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>

void ProcessLib::HeatTransportBHE::createLocalAssemblers	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		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 71 of file CreateLocalAssemblers.h.

{
    DBUG("Create local assemblers for the HeatTransportBHE process.");
 
    detail::createLocalAssemblers<LocalAssemblerSoilImplementation,
                                  LocalAssemblerBHEImplementation>(
        dof_table, mesh_elements, local_assemblers,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

References ProcessLib::HeatTransportBHE::detail::createLocalAssemblers(), and DBUG().

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::initializeConcreteProcess().

getBHEDataInMesh()

BHEMeshData ProcessLib::HeatTransportBHE::getBHEDataInMesh

(

MeshLib::Mesh const &

mesh

)

get data about fracture and matrix elements/nodes from a mesh

Parameters

mesh	A mesh which includes BHE elements, i.e. 1-dimensional elements. It is assumed that elements forming a BHE have a distinct material ID.

Definition at line 51 of file MeshUtils.cpp.

{
    std::vector<MeshLib::Element*> const all_bhe_elements =
        extractOneDimensionalElements(mesh.getElements());
 
    // finally counting two types of elements
    // They are (i) soil, and (ii) BHE type of elements
    DBUG("-> found total {:d} soil elements and {:d} BHE elements",
         mesh.getNumberOfElements() - all_bhe_elements.size(),
         all_bhe_elements.size());
 
    // get BHE material IDs
    auto const* const opt_material_ids = MeshLib::materialIDs(mesh);
    if (opt_material_ids == nullptr)
    {
        OGS_FATAL("Not able to get material IDs! ");
    }
    auto const& material_ids = *opt_material_ids;
 
    auto const& bhe_material_ids =
        getUniqueMaterialIds(material_ids, all_bhe_elements);
    DBUG("-> found {:d} BHE material groups", bhe_material_ids.size());
 
    // create a vector of BHE elements for each group
    std::vector<std::vector<MeshLib::Element*>> bhe_elements;
    bhe_elements.resize(bhe_material_ids.size());
    for (unsigned bhe_id = 0; bhe_id < bhe_material_ids.size(); bhe_id++)
    {
        const auto bhe_mat_id = bhe_material_ids[bhe_id];
        std::vector<MeshLib::Element*>& vec_elements = bhe_elements[bhe_id];
        copy_if(begin(all_bhe_elements), end(all_bhe_elements),
                back_inserter(vec_elements),
                [&](MeshLib::Element* e)
                { return material_ids[e->getID()] == bhe_mat_id; });
        DBUG("-> found {:d} elements on the BHE_{:d}", vec_elements.size(),
             bhe_id);
    }
 
    // get a vector of BHE nodes
    std::vector<std::vector<MeshLib::Node*>> bhe_nodes;
    bhe_nodes.resize(bhe_material_ids.size());
    for (unsigned bhe_id = 0; bhe_id < bhe_material_ids.size(); bhe_id++)
    {
        std::vector<MeshLib::Node*>& vec_nodes = bhe_nodes[bhe_id];
        for (MeshLib::Element* e : bhe_elements[bhe_id])
        {
            for (unsigned i = 0; i < e->getNumberOfNodes(); i++)
            {
                vec_nodes.push_back(const_cast<MeshLib::Node*>(e->getNode(i)));
            }
        }
        BaseLib::makeVectorUnique(vec_nodes,
                                  [](MeshLib::Node* node1, MeshLib::Node* node2)
                                  { return node1->getID() < node2->getID(); });
        DBUG("-> found {:d} nodes on the BHE_{:d}", vec_nodes.size(), bhe_id);
    }
 
    return {bhe_material_ids, bhe_elements, bhe_nodes};
}

References DBUG(), anonymous_namespace{MeshUtils.cpp}::extractOneDimensionalElements(), MeshLib::Mesh::getElements(), MathLib::Point3dWithID::getID(), MeshLib::Element::getID(), MeshLib::Mesh::getNumberOfElements(), anonymous_namespace{MeshUtils.cpp}::getUniqueMaterialIds(), BaseLib::makeVectorUnique(), MeshLib::materialIDs(), and OGS_FATAL.