Classes
struct	ChainWalkResult

Functions
std::vector< MeshLib::Element * >	extractOneDimensionalElements (std::vector< MeshLib::Element * > const &elements)
std::vector< int >	getUniqueMaterialIds (MeshLib::PropertyVector< int > const &material_ids, std::vector< MeshLib::Element * > const &elements)
std::array< MeshLib::Node *, 2 >	getElementEndpoints (MeshLib::Element &element)
std::unordered_map< std::size_t, std::vector< MeshLib::Element * > >	buildNodeToElementMap (std::vector< MeshLib::Element * > const &elements)
	Build a node-to-elements adjacency map for a set of BHE elements.
MeshLib::Node *	findWellheadNode (std::vector< MeshLib::Node * > const &bhe_nodes, std::unordered_map< std::size_t, std::vector< MeshLib::Element * > > const &node_to_elements)
ChainWalkResult	walkChainFromWellhead (std::vector< MeshLib::Element * > const &bhe_elements, std::vector< MeshLib::Node * > const &bhe_nodes)

Function Documentation

◆ buildNodeToElementMap()

std::unordered_map< std::size_t, std::vector< MeshLib::Element * > > anonymous_namespace{MeshUtils.cpp}::buildNodeToElementMap ( std::vector< MeshLib::Element * > const & elements )

Build a node-to-elements adjacency map for a set of BHE elements.

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

{
    std::unordered_map<std::size_t, std::vector<MeshLib::Element*>> map;
    for (auto* element : elements)
    {
        auto const [n0, n1] = getElementEndpoints(*element);
        map[n0->getID()].push_back(element);
        map[n1->getID()].push_back(element);
    }
    return map;
}

References getElementEndpoints().

Referenced by walkChainFromWellhead().

◆ extractOneDimensionalElements()

std::vector< MeshLib::Element * > anonymous_namespace{MeshUtils.cpp}::extractOneDimensionalElements ( std::vector< MeshLib::Element * > const & elements )

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

{
    std::vector<MeshLib::Element*> one_dimensional_elements;
 
    copy_if(
        begin(elements), end(elements), back_inserter(one_dimensional_elements),
        [](MeshLib::Element const* const e) { return e->getDimension() == 1; });
 
    return one_dimensional_elements;
}

References MeshLib::Element::getDimension().

◆ findWellheadNode()

MeshLib::Node * anonymous_namespace{MeshUtils.cpp}::findWellheadNode	(	std::vector< MeshLib::Node * > const &	bhe_nodes,
		std::unordered_map< std::size_t, std::vector< MeshLib::Element * > > const &	node_to_elements )

Find the wellhead node by filtering BHE nodes. Record the nodes that are connected to only one element. Then verifying that there are exactly two nodes exist, and returning the one with the greater z-coordinate.

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

{
    if (bhe_nodes.empty())
    {
        OGS_FATAL("BHE node list is empty while constructing mesh data.");
    }
 
    std::vector<MeshLib::Node*> endpoints;
    std::copy_if(
        bhe_nodes.begin(), bhe_nodes.end(), std::back_inserter(endpoints),
        [&node_to_elements](MeshLib::Node* node)
        {
            auto const it = node_to_elements.find(node->getID());
            return it != node_to_elements.end() && it->second.size() == 1;
        });
 
    if (endpoints.size() != 2)
    {
        OGS_FATAL(
            "The BHE mesh must form a single continuous linear chain with "
            "exactly 2 endpoints. Found {:d} endpoints.",
            endpoints.size());
    }
 
    auto* a = endpoints[0];
    auto* b = endpoints[1];
 
    if ((*a)[2] == (*b)[2])
    {
        OGS_FATAL(
            "Both BHE chain endpoints share the same z-coordinate ({:g}). "
            "The wellhead choice is ambiguous.",
            (*a)[2]);
    }
 
    return ((*a)[2] > (*b)[2]) ? a : b;
}

References OGS_FATAL.

Referenced by walkChainFromWellhead().

◆ getElementEndpoints()

std::array< MeshLib::Node *, 2 > anonymous_namespace{MeshUtils.cpp}::getElementEndpoints ( MeshLib::Element & element )

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

{
    if (element.getGeomType() != MeshLib::MeshElemType::LINE)
    {
        OGS_FATAL(
            "Expected a line element for BHE element id {:d}, but got {:s}.",
            element.getID(),
            MeshLib::MeshElemType2String(element.getGeomType()));
    }
 
    return {element.getNode(0), element.getNode(1)};
}

References MeshLib::Element::getGeomType(), MeshLib::Element::getID(), MeshLib::Element::getNode(), MeshLib::LINE, MeshLib::MeshElemType2String(), and OGS_FATAL.

Referenced by buildNodeToElementMap(), and walkChainFromWellhead().

◆ getUniqueMaterialIds()

std::vector< int > anonymous_namespace{MeshUtils.cpp}::getUniqueMaterialIds	(	MeshLib::PropertyVector< int > const &	material_ids,
		std::vector< MeshLib::Element * > const &	elements )

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

{
    std::set<int> unique_material_ids;
    std::transform(begin(elements), end(elements),
                   inserter(unique_material_ids, end(unique_material_ids)),
                   [&material_ids](MeshLib::Element const* const e)
                   { return material_ids[e->getID()]; });
    return {begin(unique_material_ids), end(unique_material_ids)};
}

References MeshLib::Element::getID().

◆ walkChainFromWellhead()

ChainWalkResult anonymous_namespace{MeshUtils.cpp}::walkChainFromWellhead	(	std::vector< MeshLib::Element * > const &	bhe_elements,
		std::vector< MeshLib::Node * > const &	bhe_nodes )

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

{
    if (bhe_elements.empty())
    {
        return {};
    }
 
    auto const node_to_elements = buildNodeToElementMap(bhe_elements);
    MeshLib::Node* wellhead = findWellheadNode(bhe_nodes, node_to_elements);
 
    // The wellhead node must be an endpoint of exactly one element.
    auto const it = node_to_elements.find(wellhead->getID());
    if (it == node_to_elements.end() || it->second.empty())
    {
        OGS_FATAL("Wellhead node {:d} is not connected to any BHE element.",
                  wellhead->getID());
    }
    if (it->second.size() != 1)
    {
        OGS_FATAL(
            "Wellhead node {:d} is connected to {:d} BHE elements; "
            "expected exactly 1 (chain endpoint).",
            wellhead->getID(), it->second.size());
    }
 
    std::vector<MeshLib::Element*> ordered;
    ordered.reserve(bhe_elements.size());
    std::vector<MeshLib::Node*> ordered_nodes;
    ordered_nodes.reserve(bhe_elements.size() + 1);
    ordered_nodes.push_back(wellhead);
    std::unordered_map<std::size_t, double> distances;
    distances.reserve(bhe_elements.size());
 
    MeshLib::Node* prev_node = wellhead;
    MeshLib::Element* current = it->second.front();
    double accumulated_distance = 0.0;
 
    while (current != nullptr)
    {
        ordered.push_back(current);
        double const len = current->computeVolume();
        distances[current->getID()] = accumulated_distance + 0.5 * len;
        accumulated_distance += len;
 
        // Find exit node (the endpoint not shared with prev_node).
        auto const [n0, n1] = getElementEndpoints(*current);
        MeshLib::Node* exit_node = (n0 == prev_node) ? n1 : n0;
        ordered_nodes.push_back(exit_node);
 
        // Find the next element connected to exit_node.
        auto const exit_it = node_to_elements.find(exit_node->getID());
        MeshLib::Element* next = nullptr;
        if (exit_it != node_to_elements.end())
        {
            auto const& elems = exit_it->second;
            auto const next_it =
                std::find_if(elems.begin(), elems.end(),
                             [current](auto* e) { return e != current; });
            if (next_it != elems.end())
            {
                next = *next_it;
            }
        }
 
        prev_node = exit_node;
        current = next;
    }
 
    if (ordered.size() != bhe_elements.size())
    {
        OGS_FATAL(
            "BHE chain walk visited {:d} elements but the group has {:d}. "
            "The BHE mesh must form a single continuous linear chain.",
            ordered.size(), bhe_elements.size());
    }
 
    return {std::move(ordered), std::move(ordered_nodes), std::move(distances)};
}

References buildNodeToElementMap(), MeshLib::Element::computeVolume(), findWellheadNode(), getElementEndpoints(), MathLib::Point3dWithID::getID(), MeshLib::Element::getID(), and OGS_FATAL.

Classes