spatial_search.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Carlos Roig
//
 
#pragma once
 
// System includes
 
// External includes
 
// Project includes
#include "includes/model_part.h"
 
namespace Kratos
{
 
 
 
 
 
class KRATOS_API(KRATOS_CORE) SpatialSearch
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(SpatialSearch);
 
    using SizeType = std::size_t;
 
    using IndexType = std::size_t;
 
    static constexpr std::size_t Dimension = 3;
 
    static constexpr std::size_t MAX_LEVEL = 16;
 
    static constexpr std::size_t MIN_LEVEL = 2;
 
    using PointType = Point;
 
    using NodeType = Node;
 
    using NodesContainerType = ModelPart::NodesContainerType;
    using ResultNodesContainerType = NodesContainerType::ContainerType;
    using VectorResultNodesContainerType = std::vector<ResultNodesContainerType>;
 
    using ElementsContainerType = ModelPart::ElementsContainerType;
    using ResultElementsContainerType = ElementsContainerType::ContainerType;
    using VectorResultElementsContainerType = std::vector<ResultElementsContainerType>;
 
    using ConditionsContainerType = ModelPart::ConditionsContainerType;
    using ResultConditionsContainerType = ConditionsContainerType::ContainerType;
    using VectorResultConditionsContainerType = std::vector<ResultConditionsContainerType>;
 
    using RadiusArrayType = std::vector<double>;
    using DistanceType = std::vector<double>;
    using VectorDistanceType = std::vector<DistanceType>;
 
 
    SpatialSearch(){}
 
    virtual ~SpatialSearch(){}
 
 
 
    //************************************************************************
    // Elemental Exclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchElementsInRadiusExclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsInRadiusExclusive (
        ModelPart& rModelPart,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsInRadiusExclusive (
        const ElementsContainerType& rStructureElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsInRadiusExclusive (
        const ElementsContainerType& rStructureElements,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Elemental Inclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchElementsInRadiusInclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsInRadiusInclusive (
        ModelPart& rModelPart,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsInRadiusInclusive (
        const ElementsContainerType& rStructureElements,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsInRadiusInclusive (
        const ElementsContainerType& rStructureElements,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Elemental Exclusive search without distance calculation
    //************************************************************************
 
    virtual void SearchElementsInRadiusExclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults
        );
 
    virtual void SearchElementsInRadiusExclusive (
        ModelPart& rModelPart,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults
        );
 
    virtual void SearchElementsInRadiusExclusive (
        const ElementsContainerType& rStructureElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults
        );
 
    virtual void SearchElementsInRadiusExclusive (
        const ElementsContainerType& rStructureElements,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults
        );
 
    //************************************************************************
    // Elemental Inclusive search without distance calculation
    //************************************************************************
 
    virtual void SearchElementsInRadiusInclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchElementsInRadiusInclusive (
        ModelPart& rModelPart,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchElementsInRadiusInclusive (
        const ElementsContainerType& rStructureElements,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchElementsInRadiusInclusive (
        const ElementsContainerType& rStructureElements,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    //************************************************************************
    // Nodal Exclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchNodesInRadiusExclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchNodesInRadiusExclusive (
        ModelPart& rModelPart,
        const NodesContainerType& rInputNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchNodesInRadiusExclusive (
        const NodesContainerType& rStructureNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchNodesInRadiusExclusive (
        const NodesContainerType& rStructureNodes,
        const NodesContainerType& rInputNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Nodal Inclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchNodesInRadiusInclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchNodesInRadiusInclusive (
        ModelPart& rModelPart,
        const NodesContainerType& rInputNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchNodesInRadiusInclusive (
        const NodesContainerType& rStructureNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchNodesInRadiusInclusive (
        const NodesContainerType& rStructureNodes,
        const NodesContainerType& rInputNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Nodal Exclusive search without distance calculation
    //************************************************************************
 
    virtual void SearchNodesInRadiusExclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchNodesInRadiusExclusive (
        ModelPart& rModelPart,
        const NodesContainerType& rInputNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchNodesInRadiusExclusive (
        const NodesContainerType& rStructureNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchNodesInRadiusExclusive (
        const NodesContainerType& rStructureNodes,
        const NodesContainerType& rInputNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    //************************************************************************
    // Nodal Inclusive search without distance calculation
    //************************************************************************
 
    virtual void SearchNodesInRadiusInclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchNodesInRadiusInclusive (
        ModelPart& rModelPart,
        const NodesContainerType& rInputNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchNodesInRadiusInclusive (
        const NodesContainerType& rStructureNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchNodesInRadiusInclusive (
        const NodesContainerType& rStructureNodes,
        const NodesContainerType& rInputNodes,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    //************************************************************************
    // Conditional Exclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchConditionsInRadiusExclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultConditionsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsInRadiusExclusive (
        ModelPart& rModelPart,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultConditionsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsInRadiusExclusive (
        const ConditionsContainerType& rStructureConditions,
        const RadiusArrayType& rRadius,
        VectorResultConditionsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsInRadiusExclusive (
        const ConditionsContainerType& rStructureConditions,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultConditionsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Conditional Inclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchConditionsInRadiusInclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsInRadiusInclusive (
        ModelPart& rModelPart,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsInRadiusInclusive (
        const ConditionsContainerType& rStructureConditions,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsInRadiusInclusive (
        const ConditionsContainerType& rStructureConditions,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Conditional Exclusive search without distance calculation
    //************************************************************************
 
    virtual void SearchConditionsInRadiusExclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultConditionsContainerType& rResults
        );
 
    virtual void SearchConditionsInRadiusExclusive (
        ModelPart& rModelPart,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultConditionsContainerType& rResults
        );
 
    virtual void SearchConditionsInRadiusExclusive (
        const ConditionsContainerType& rStructureConditions,
        const RadiusArrayType& rRadius,
        VectorResultConditionsContainerType& rResults
        );
 
    virtual void SearchConditionsInRadiusExclusive (
        const ConditionsContainerType& rStructureConditions,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultConditionsContainerType& rResults
        );
 
    //************************************************************************
    // Conditional Inclusive search without distance calculation
    //************************************************************************
 
    virtual void SearchConditionsInRadiusInclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchConditionsInRadiusInclusive (
        ModelPart& rModelPart,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchConditionsInRadiusInclusive (
        const ConditionsContainerType& rStructureConditions,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    virtual void SearchConditionsInRadiusInclusive (
        const ConditionsContainerType& rStructureConditions,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultNodesContainerType& rResults
        );
 
    //************************************************************************
    // Elemental vs Condition Exclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchConditionsOverElementsInRadiusExclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsOverElementsInRadiusExclusive (
        ModelPart& rModelPart,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsOverElementsInRadiusExclusive (
        const ElementsContainerType& rStructureElements,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Elemental vs Condition Inclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchConditionsOverElementsInRadiusInclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsOverElementsInRadiusInclusive (
        ModelPart& rModelPart,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchConditionsOverElementsInRadiusInclusive (
        const ElementsContainerType& rStructureElements,
        const ConditionsContainerType& rInputConditions,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Condition vs Elemental Exclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchElementsOverConditionsInRadiusExclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsOverConditionsInRadiusExclusive (
        ModelPart& rModelPart,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsOverConditionsInRadiusExclusive (
        const ConditionsContainerType& rStructureConditions,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Condition vs Elemental Inclusive search with distance calculation
    //************************************************************************
 
    virtual void SearchElementsOverConditionsInRadiusInclusive (
        ModelPart& rModelPart,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsOverConditionsInRadiusInclusive (
        ModelPart& rModelPart,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    virtual void SearchElementsOverConditionsInRadiusInclusive (
        const ConditionsContainerType& rStructureConditions,
        const ElementsContainerType& rInputElements,
        const RadiusArrayType& rRadius,
        VectorResultElementsContainerType& rResults,
        VectorDistanceType& rResultsDistance
        );
 
    //************************************************************************
    // Bounding box methods
    //************************************************************************
 
    virtual void InitializeBoundingBox(const NodesContainerType& rStructureNodes);
 
    virtual void InitializeBoundingBox(const ElementsContainerType& rStructureElements);
 
    virtual void InitializeBoundingBox(const ConditionsContainerType& rStructureConditions);
 
 
 
 
    virtual std::string Info() const
    {
        std::stringstream buffer;
        buffer << "SpatialSearch" ;
 
        return buffer.str();
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const {rOStream << "SpatialSearch";}
 
    virtual void PrintData(std::ostream& rOStream) const {}
 
 
protected:
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
    SpatialSearch& operator=(SpatialSearch const& rOther)
    {
        return *this;
    }
 
    SpatialSearch(SpatialSearch const& rOther)
    {
        *this = rOther;
    }
 
}; // Class SpatialSearch
 
 
 
inline std::ostream& operator << (std::ostream& rOStream, 
                const SpatialSearch& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.