ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp} Namespace Reference

Classes
class	IsCrackTip

Functions

void

findFracutreIntersections (MeshLib::Mesh const &mesh, std::vector< int > const &vec_fracture_mat_IDs, std::vector< std::vector< MeshLib::Node * > > const &vec_fracture_nodes, std::vector< std::vector< MeshLib::Element * > > &intersected_fracture_elements, std::vector< std::pair< std::size_t, std::vector< int > > > &vec_branch_nodeID_matIDs, std::vector< std::pair< std::size_t, std::vector< int > > > &vec_junction_nodeID_matIDs)

Function Documentation

findFracutreIntersections()

void ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp}::findFracutreIntersections	(	MeshLib::Mesh const &	mesh,
		std::vector< int > const &	vec_fracture_mat_IDs,
		std::vector< std::vector< MeshLib::Node * > > const &	vec_fracture_nodes,
		std::vector< std::vector< MeshLib::Element * > > &	intersected_fracture_elements,
		std::vector< std::pair< std::size_t, std::vector< int > > > &	vec_branch_nodeID_matIDs,
		std::vector< std::pair< std::size_t, std::vector< int > > > &	vec_junction_nodeID_matIDs )

Definition at line 64 of file LIE/Common/MeshUtils.cpp.

{
    auto const n_fractures = vec_fracture_mat_IDs.size();
    std::map<unsigned, unsigned> matID_to_fid;
    for (unsigned i = 0; i < n_fractures; i++)
    {
        matID_to_fid[vec_fracture_mat_IDs[i]] = i;
    }
 
    // make a vector all fracture nodes
    std::vector<std::size_t> all_fracture_nodes;
    for (auto& vec : vec_fracture_nodes)
    {
        transform(cbegin(vec), cend(vec), back_inserter(all_fracture_nodes),
                  [](auto* const n) { return n->getID(); });
    }
 
    // create a table of a node id and connected material IDs
    std::map<std::size_t, std::vector<std::size_t>> frac_nodeID_to_matIDs;
    for (unsigned i = 0; i < n_fractures; i++)
    {
        for (auto* node : vec_fracture_nodes[i])
        {
            frac_nodeID_to_matIDs[node->getID()].push_back(
                vec_fracture_mat_IDs[i]);
        }
    }
 
    auto const* const opt_material_ids = MeshLib::materialIDs(mesh);
 
    // find branch/junction nodes which connect to multiple fractures
    intersected_fracture_elements.resize(n_fractures);
    for (auto frac_nodeID_to_matID : frac_nodeID_to_matIDs)
    {
        auto nodeID = frac_nodeID_to_matID.first;
        auto const* node = mesh.getNode(frac_nodeID_to_matID.first);
        auto const& matIDs = frac_nodeID_to_matID.second;
        if (matIDs.size() < 2)
        {
            continue;  // no intersection
        }
 
        auto const elements_connected_to_node =
            mesh.getElementsConnectedToNode(*node);
        std::vector<MeshLib::Element*> conn_fracture_elements;
        {
            for (auto const* e : elements_connected_to_node)
            {
                if (e->getDimension() == (mesh.getDimension() - 1))
                {
                    conn_fracture_elements.push_back(
                        const_cast<MeshLib::Element*>(e));
                }
            }
        }
 
        std::map<int, int> vec_matID_counts;
        {
            for (auto matid : matIDs)
            {
                vec_matID_counts[matid] = 0;
            }
 
            for (auto const* e : conn_fracture_elements)
            {
                auto matid = (*opt_material_ids)[e->getID()];
                vec_matID_counts[matid]++;
            }
        }
 
        for (auto matid : matIDs)
        {
            auto fid = matID_to_fid[matid];
            for (auto* e : conn_fracture_elements)
            {
                auto e_matid = (*opt_material_ids)[e->getID()];
                if (matID_to_fid[e_matid] != fid)
                {  // only slave elements
                    intersected_fracture_elements[fid].push_back(e);
                }
            }
        }
 
        bool isBranch = false;
        {
            for (auto vec_matID_count : vec_matID_counts)
            {
                auto count = vec_matID_count.second;
                if (count % 2 == 1)
                {
                    isBranch = true;
                    break;
                }
            }
        }
 
        if (isBranch)
        {
            std::vector<int> branch_matIDs(2);
            for (auto vec_matID_count : vec_matID_counts)
            {
                auto matid = vec_matID_count.first;
                auto count = vec_matID_count.second;
                if (count % 2 == 0)
                {
                    branch_matIDs[0] = matid;  // master
                }
                else
                {
                    branch_matIDs[1] = matid;  // slave
                }
            }
            vec_branch_nodeID_matIDs.emplace_back(nodeID, branch_matIDs);
        }
        else
        {
            std::vector<int> junction_matIDs(2);
            junction_matIDs[0] = std::min(vec_matID_counts.begin()->first,
                                          vec_matID_counts.rbegin()->first);
            junction_matIDs[1] = std::max(vec_matID_counts.begin()->first,
                                          vec_matID_counts.rbegin()->first);
            vec_junction_nodeID_matIDs.emplace_back(nodeID, junction_matIDs);
        }
    }
 
    for (auto& elements : intersected_fracture_elements)
    {
        BaseLib::makeVectorUnique(elements);
    }
 
    DBUG("-> found {:d} branches and {:d} junctions",
         vec_branch_nodeID_matIDs.size(), vec_junction_nodeID_matIDs.size());
}

References DBUG(), findFracutreIntersections(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::Mesh::getNode(), BaseLib::makeVectorUnique(), and MeshLib::materialIDs().

Referenced by findFracutreIntersections().