find_global_nodal_neighbours_for_entities_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//                   Suneth Warnakulasuriya
//
 
#if !defined(KRATOS_FIND_NODAL_NEIGHBOURS_FOR_ENTITIES_PROCESS_H_INCLUDED)
#define KRATOS_FIND_NODAL_NEIGHBOURS_FOR_ENTITIES_PROCESS_H_INCLUDED
 
// System includes
#include <iostream>
#include <string>
#include <unordered_map>
 
// External includes
 
// Project includes
#include "containers/global_pointers_vector.h"
#include "includes/data_communicator.h"
#include "includes/define.h"
#include "includes/model_part.h"
#include "processes/process.h"
 
namespace Kratos
{
 
 
template <class TContainerType>
class KRATOS_API(KRATOS_CORE) FindNodalNeighboursForEntitiesProcess : public Process
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(FindNodalNeighboursForEntitiesProcess);
 
    using NodeType = ModelPart::NodeType;
    using NodesContainerType = ModelPart::NodesContainerType;
 
 
    FindNodalNeighboursForEntitiesProcess(
        ModelPart& rModelPart,
        const Variable<GlobalPointersVector<NodeType>>& rOutputVariable)
        : mrModelPart(rModelPart),
          mrDataCommunicator(rModelPart.GetCommunicator().GetDataCommunicator()),
          mrOutputVariable(rOutputVariable)
    {
    }
 
    KRATOS_DEPRECATED_MESSAGE("Use of DataCommunicator is deprecated. Please use constructor without it.")
    FindNodalNeighboursForEntitiesProcess(
        const DataCommunicator& rDataCommunicator,
        ModelPart& rModelPart,
        const Variable<GlobalPointersVector<NodeType>>& rOutputVariable)
        : FindNodalNeighboursForEntitiesProcess(rModelPart, rOutputVariable)
    {
    }
 
    ~FindNodalNeighboursForEntitiesProcess() override = default;
 
    FindNodalNeighboursForEntitiesProcess& operator=(
        FindNodalNeighboursForEntitiesProcess const& rOther) = delete;
 
 
    void operator()()
    {
        Execute();
    }
 
 
    void Execute() override;
 
    void ClearNeighbours();
 
    std::unordered_map<int, std::vector<int>> GetNeighbourIds(
        NodesContainerType& rNodes) const
    {
        return FindNodalNeighboursForEntitiesProcess<TContainerType>::GetNodalNeighbourIdsMap(
            rNodes, this->mrDataCommunicator, this->mrOutputVariable);
    }
 
    static std::unordered_map<int, std::vector<int>> GetNodalNeighbourIdsMap(
        NodesContainerType& rNodes,
        const DataCommunicator& rDataCommunicator,
        const Variable<GlobalPointersVector<NodeType>>& rNodalGlobalPointerVariable);
 
 
    std::string Info() const override
    {
        return "FindNodalNeighboursForEntitiesProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "FindNodalNeighboursForEntitiesProcess";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
private:
 
    ModelPart& mrModelPart;
    const DataCommunicator& mrDataCommunicator;
    const Variable<GlobalPointersVector<NodeType>>& mrOutputVariable;
 
 
    TContainerType& GetContainer();
 
    void AddHangingNodeIds(
        std::unordered_map<int, std::unordered_map<int, std::vector<int>>>& rNeighbourIds) const;
 
    void AddUnique(
        std::vector<int>& rContainer,
        const int Item) const;
 
    template <class TDataType>
    void AddUniqueGlobalPointer(
        GlobalPointersVector<TDataType>& rGPVector,
        const GlobalPointer<TDataType>& rCandidate) const
    {
        bool found = false;
        for (const auto& gp : rGPVector.GetContainer()) {
            if (&(*gp) == &(*rCandidate) && gp.GetRank() == rCandidate.GetRank()) {
                found = true;
                break;
            }
        }
        if (!found) {
            rGPVector.push_back(rCandidate);
        }
    }
 
}; // Class FindNodalNeighboursForEntitiesProcess
 
 
template <class TContainerType>
inline std::istream& operator>>(
    std::istream& rIStream,
    FindNodalNeighboursForEntitiesProcess<TContainerType>& rThis);
 
template <class TContainerType>
inline std::ostream& operator<<(
    std::ostream& rOStream,
    const FindNodalNeighboursForEntitiesProcess<TContainerType>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
} // namespace Kratos.
 
#endif // KRATOS_FIND_NODAL_NEIGHBOURS_FOR_ENTITIES_PROCESS_H_INCLUDED defined