ProcessLib::HeatTransportBHE Namespace Reference

Namespaces
namespace	BHE
namespace	detail

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

Typedefs
using	BHECreatorFunc

Functions
BHEMeshData	getBHEDataInMesh (MeshLib::Mesh const &mesh)
BHEEndpoints	findBHEEndpointsFromElementOrdering (std::vector< MeshLib::Element * > const &bhe_elements)
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)
void	createAndInsertBHE (const std::string &bhe_type, const std::vector< int > &bhe_ids_of_this_bhe, const BaseLib::ConfigTree &bhe_config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &parameters, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves, BHEMeshData const &bhe_mesh_data, std::map< int, BHE::BHETypes > &bhes_map)
std::unique_ptr< Process >	createHeatTransportBHEProcess (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 > > &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 > class LocalAssemblerSoilImplementation, template< 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, NumLib::IntegrationOrder const integration_order, ExtraCtorArgs &&... extra_ctor_args)

Variables
std::map< std::string_view, BHECreatorFunc >	bheCreators

Typedef Documentation

BHECreatorFunc

using ProcessLib::HeatTransportBHE::BHECreatorFunc

Initial value:

 std::function<BHE::BHETypes(
    BaseLib::ConfigTree const&,
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>>&,
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&)>

Definition at line 29 of file CreateHeatTransportBHEProcess.cpp.

Function Documentation

createAndInsertBHE()

void ProcessLib::HeatTransportBHE::createAndInsertBHE	(	const std::string &	bhe_type,
		const std::vector< int > &	bhe_ids_of_this_bhe,
		const BaseLib::ConfigTree &	bhe_config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &	parameters,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves,
		BHEMeshData const &	bhe_mesh_data,
		std::map< int, BHE::BHETypes > &	bhes_map )

Definition at line 66 of file CreateHeatTransportBHEProcess.cpp.

{
    auto bhe_creator_it = bheCreators.find(bhe_type);
    if (bhe_creator_it == bheCreators.end())
    {
        OGS_FATAL("Unknown BHE type: {:s}", bhe_type);
    }
    for (auto const& id : bhe_ids_of_this_bhe)
    {
        if (id < 0 || id >= static_cast<int>(bhe_mesh_data.BHE_nodes.size()))
        {
            OGS_FATAL(
                "BHE id {:d} is out of range. The mesh contains {:d} "
                "BHE(s) (valid ids: 0 to {:d}).",
                id, bhe_mesh_data.BHE_nodes.size(),
                static_cast<int>(bhe_mesh_data.BHE_nodes.size()) - 1);
        }
        std::pair<std::map<int, BHE::BHETypes>::iterator, bool> result;
        if (id == bhe_ids_of_this_bhe[0])
        {
            result = bhes_map.try_emplace(
                id, bhe_creator_it->second(bhe_config, parameters, curves));
        }
        else
        {
            // Grouped BHEs share all configuration including parameter
            // references.  Spatial variation comes from the SpatialPosition
            // set per-element in the assembler, so a plain copy suffices.
            auto const& first_bhe =
                bhes_map.find(bhe_ids_of_this_bhe[0])->second;
            result = bhes_map.try_emplace(id, first_bhe);
        }
        if (!result.second)
        {
            OGS_FATAL(
                "BHE with id '{:d}' is already present in the list! Check for "
                "duplicate definitions of BHE ids.",
                id);
        }
    }
}

References ProcessLib::HeatTransportBHE::BHEMeshData::BHE_nodes, bheCreators, and OGS_FATAL.

Referenced by createHeatTransportBHEProcess().

createBHEBottomDirichletBoundaryCondition()

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

(

std::pair< GlobalIndexType, GlobalIndexType > &&

in_out_global_indices

)

Definition at line 25 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::createBHEEndpointBoundaryConditions().

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 45 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::createBHEEndpointBoundaryConditions().

createHeatTransportBHEProcess()

std::unique_ptr< Process > ProcessLib::HeatTransportBHE::createHeatTransportBHEProcess	(	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 > > &	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

Process Variables

Input File Parameter

prj__processes__process__HEAT_TRANSPORT_BHE__process_variables

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

Input File Parameter

prj__processes__process__HEAT_TRANSPORT_BHE__process_variables__process_variable

Process Parameters

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__mass_lumping

Input File Parameter

prj__processes__process__HEAT_TRANSPORT_BHE__use_algebraic_bc

Input File Parameter

prj__processes__process__HEAT_TRANSPORT_BHE__weighting_factor

Input File Parameter

prj__processes__process__linear

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__id

Input File Parameter

prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__type

Python object computing BC values.

Definition at line 117 of file CreateHeatTransportBHEProcess.cpp.

{
    config.checkConfigParameter("type", "HEAT_TRANSPORT_BHE");
 
    DBUG("Create HeatTransportBHE Process.");


    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 '{}'. It should be "
                "'temperature_soil' or 'temperature_BHE_X'",
                pv_name);
        }
        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 --------------------------------------------------
 
    auto bhe_mesh_data = getBHEDataInMesh(mesh);
 
    auto const& bhe_configs =
        config.getConfigSubtree("borehole_heat_exchangers");
 
    auto const using_server_communication =
        config.getConfigParameter<bool>("use_server_communication", false);
 
    auto const mass_lumping =
        config.getConfigParameter<bool>("mass_lumping", false);
 
    auto const using_algebraic_bc =
        config.getConfigParameter<bool>("use_algebraic_bc", false);
 
    auto const weighting_factor =
        config.getConfigParameter<float>("weighting_factor", 1000.0);
 
    auto const is_linear =
        config.getConfigParameter<bool>("linear", false);
    if (is_linear)
    {
        if (!using_algebraic_bc)
        {
            WARN(
                "You specified that the process simulated by OGS is linear. "
                "With that optimization the process will be assembled only "
                "once and the non-linear solver will only do iterations per "
                "time step to fulfill the BHE boundary conditions. No other "
                "non-linearities will be resolved and OGS will not detect if "
                "there are any non-linearities. It is your responsibility to "
                "ensure that the assembled equation systems are linear, "
                "indeed! There is no safety net!");
        }
        else
        {
            WARN(
                "You specified that the process simulated by OGS is linear. "
                "With that optimization the process will be assembled only "
                "once and the non-linear solver will do only one iteration per "
                "time step. No non-linearities will be resolved and OGS will "
                "not detect if there are any non-linearities. It is your "
                "responsibility to ensure that the assembled equation systems "
                "are linear, indeed! There is no safety net!");
        }
    }
 
    std::map<int, BHE::BHETypes> bhes_map;
 
    int bhe_iterator = 0;
 
    for (
        auto const& bhe_config :
        bhe_configs.getConfigSubtreeList("borehole_heat_exchanger"))
    {
        auto const bhe_id_string =
            bhe_config.getConfigAttribute<std::string>(
                "id", std::to_string(bhe_iterator));
 
        std::vector<int> bhe_ids_of_this_bhe;
 
        if (bhe_id_string == "*")
        {
            int const size = static_cast<int>(bhe_mesh_data.BHE_mat_IDs.size());
            bhe_ids_of_this_bhe.resize(size);
            std::iota(bhe_ids_of_this_bhe.begin(), bhe_ids_of_this_bhe.end(),
                      0);
        }
        else
        {
            bhe_ids_of_this_bhe =
                MaterialLib::splitMaterialIdString(bhe_id_string);
        }
 
        // read in the parameters
        const std::string bhe_type =
            bhe_config.getConfigParameter<std::string>("type");
 
        createAndInsertBHE(bhe_type, bhe_ids_of_this_bhe, bhe_config,
                           parameters, curves, bhe_mesh_data, bhes_map);
        bhe_iterator++;
    }
 
    if (static_cast<int>(bhes_map.size()) - 1 != bhes_map.rbegin()->first)
    {
        OGS_FATAL(
            "The maximum given BHE id '{:d}' did not match the number of given "
            "BHE definitions '{:d}'. The BHE ids needs to be defined starting "
            "from 0, so the maximum BHE id needs to be number of BHE "
            "definitions minus 1. After all definitions there are no gaps "
            "allowed between the given ids.",
            bhes_map.rbegin()->first, bhes_map.size());
    }
 
    std::vector<BHE::BHETypes> bhes;
    bhes.reserve(bhes_map.size());
    std::ranges::copy(bhes_map | std::views::values, std::back_inserter(bhes));
    //  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)
    {
        // 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]);
        }
        */
    }
 
    HeatTransportBHEProcessData process_data(
        std::move(media_map), std::move(bhes), py_object, using_tespy,
        using_server_communication, mass_lumping,
        {using_algebraic_bc, weighting_factor}, is_linear);
 
    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),
        std::move(bhe_mesh_data));
}

References BaseLib::ConfigTree::checkConfigParameter(), createAndInsertBHE(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), getBHEDataInMesh(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterList(), BaseLib::ConfigTree::getConfigSubtree(), OGS_FATAL, MaterialLib::splitMaterialIdString(), and WARN().

Referenced by ProjectData::parseProcesses().

createLocalAssemblers()

template<template< typename > class LocalAssemblerSoilImplementation, template< 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,
		NumLib::IntegrationOrder const	integration_order,
		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 68 of file HeatTransportBHE/LocalAssemblers/CreateLocalAssemblers.h.

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

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

Referenced by createLocalAssemblers(), and ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::initializeConcreteProcess().

findBHEEndpointsFromElementOrdering()

BHEEndpoints ProcessLib::HeatTransportBHE::findBHEEndpointsFromElementOrdering

(

std::vector< MeshLib::Element * > const &

bhe_elements

)

Derive the inlet/outlet endpoint nodes of a BHE from the line-element chain's local node ordering. Also validates that the elements form a single connected chain with a consistent orientation (every element's node 0 equals the previous element's node 1); calls OGS_FATAL with a diagnostic message naming the offending node on inconsistency.

Definition at line 109 of file HeatTransportBHE/BHE/MeshUtils.cpp.

{
    if (bhe_elements.empty())
    {
        OGS_FATAL(
            "findBHEEndpointsFromElementOrdering called with an empty BHE "
            "element list.");
    }
 
    // Adjacency: node id -> list of (element index, local-node-index 0 or 1)
    // that reference it. For a well-formed BHE chain every node appears in
    // either 1 (endpoint) or 2 (interior) such records.
    std::unordered_map<std::size_t, std::vector<std::pair<std::size_t, int>>>
        adjacency;
    for (std::size_t ei = 0; ei < bhe_elements.size(); ++ei)
    {
        auto const* e = bhe_elements[ei];
        if (e->getNumberOfNodes() != 2)
        {
            OGS_FATAL(
                "BHE element {:d} has {:d} nodes; expected a 2-node line "
                "element.",
                e->getID(), e->getNumberOfNodes());
        }
        for (int local = 0; local < 2; ++local)
        {
            adjacency[e->getNode(local)->getID()].emplace_back(ei, local);
        }
    }
 
    // Endpoints are nodes connected to exactly one BHE line element. Any
    // node connected to more than 2 elements means the BHE is branching and
    // is not a simple chain.
    std::vector<std::size_t> endpoint_node_ids;
    for (auto const& [nid, refs] : adjacency)
    {
        if (refs.size() == 1)
        {
            endpoint_node_ids.push_back(nid);
        }
        else if (refs.size() > 2)
        {
            OGS_FATAL(
                "BHE element chain has a branching junction at node {:d} "
                "(connected to {:d} elements). Expected a simple line chain.",
                nid, refs.size());
        }
    }
 
    if (endpoint_node_ids.size() != 2)
    {
        OGS_FATAL(
            "BHE elements do not form a single connected line chain (found "
            "{:d} endpoints; expected 2). Check that all line elements with "
            "the same BHE material ID share endpoints node-to-node.",
            endpoint_node_ids.size());
    }
 
    // The inlet is the endpoint that appears as local node 0 of its element;
    // the outlet is the endpoint that appears as local node 1 of its
    // element. If neither endpoint is at local node 0 (or both are), the
    // chain-start or chain-end element is reversed.
    MeshLib::Node const* inlet = nullptr;
    MeshLib::Node const* outlet = nullptr;
    for (std::size_t const nid : endpoint_node_ids)
    {
        auto const& [ei, local] = adjacency[nid].front();
        if (local == 0)
        {
            if (inlet != nullptr)
            {
                OGS_FATAL(
                    "Both BHE chain endpoints (nodes {:d} and {:d}) appear "
                    "as local node 0 of their connected element; chain "
                    "orientation is ambiguous. Reorder element nodes so the "
                    "chain runs node 0 -> node 1 from inlet to outlet.",
                    inlet->getID(), nid);
            }
            inlet = bhe_elements[ei]->getNode(0);
        }
        else
        {
            outlet = bhe_elements[ei]->getNode(1);
        }
    }
 
    if (inlet == nullptr || outlet == nullptr)
    {
        OGS_FATAL(
            "BHE chain endpoints are not consistent with the elements' "
            "node-0 -> node-1 ordering. Reorder element nodes so that the "
            "intended inlet endpoint is node 0 of the chain-start element "
            "and the intended outlet endpoint is node 1 of the chain-end "
            "element.");
    }
 
    // Walk the chain from the inlet: at each step, the unused element whose
    // node 0 equals the current node must exist, otherwise some interior
    // element is reversed.
    std::vector<bool> used(bhe_elements.size(), false);
    MeshLib::Node const* cur = inlet;
    for (std::size_t step = 0; step < bhe_elements.size(); ++step)
    {
        auto const& refs = adjacency[cur->getID()];
        bool advanced = false;
        for (auto const& [ei, local] : refs)
        {
            if (!used[ei] && local == 0)
            {
                used[ei] = true;
                cur = bhe_elements[ei]->getNode(1);
                advanced = true;
                break;
            }
        }
        if (!advanced)
        {
            OGS_FATAL(
                "BHE element chain is inconsistently oriented at node {:d}: "
                "an interior element does not have this node as its node 0. "
                "Reorder the element's nodes so the chain runs node 0 -> "
                "node 1 from inlet to outlet.",
                cur->getID());
        }
    }
 
    if (cur != outlet)
    {
        OGS_FATAL(
            "BHE chain walk did not terminate at the expected outlet "
            "endpoint (expected node {:d}, reached node {:d}).",
            outlet->getID(), cur->getID());
    }
 
    return {inlet, outlet};
}

References MathLib::Point3dWithID::getID(), and OGS_FATAL.

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

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 49 of file HeatTransportBHE/BHE/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 const* const 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::idsComparator<MeshLib::Node*>);
 
        DBUG("-> found {:d} nodes on the BHE_{:d}", vec_nodes.size(), bhe_id);
    }
 
    return {bhe_material_ids, bhe_elements, bhe_nodes};
}

References DBUG(), MeshLib::Mesh::getElements(), MeshLib::Element::getID(), MeshLib::Mesh::getNumberOfElements(), MeshLib::idsComparator(), BaseLib::makeVectorUnique(), MeshLib::materialIDs(), and OGS_FATAL.

Referenced by createHeatTransportBHEProcess().

Variable Documentation

bheCreators

std::map<std::string_view, BHECreatorFunc> ProcessLib::HeatTransportBHE::bheCreators

Initial value:

= {
    {"1U",
     [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_1U(
             BHE::createBHEUType<BHE::BHE_1U>(config, parameters, curves));
     }},
    {"2U",
     [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_2U(
             BHE::createBHEUType<BHE::BHE_2U>(config, parameters, curves));
     }},
    {"CXA",
     [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_CXA(
             BHE::createBHECoaxial<BHE::BHE_CXA>(config, parameters, curves));
     }},
    {"CXC",
     [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_CXC(
             BHE::createBHECoaxial<BHE::BHE_CXC>(config, parameters, curves));
     }},
    {"1P", [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_1P(
             BHE::createBHE1PType<BHE::BHE_1P>(config, parameters, curves));
     }}}

Definition at line 35 of file CreateHeatTransportBHEProcess.cpp.

                                                     {
    {"1U",
     [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_1U(
             BHE::createBHEUType<BHE::BHE_1U>(config, parameters, curves));
     }},
    {"2U",
     [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_2U(
             BHE::createBHEUType<BHE::BHE_2U>(config, parameters, curves));
     }},
    {"CXA",
     [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_CXA(
             BHE::createBHECoaxial<BHE::BHE_CXA>(config, parameters, curves));
     }},
    {"CXC",
     [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_CXC(
             BHE::createBHECoaxial<BHE::BHE_CXC>(config, parameters, curves));
     }},
    {"1P", [](auto& config, auto& parameters, auto& curves)
     {
         return BHE::BHE_1P(
             BHE::createBHE1PType<BHE::BHE_1P>(config, parameters, curves));
     }}};

Referenced by createAndInsertBHE().