find_intersected_geometrical_objects_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                     Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Davand
//  Collaborators:   Ruben Zorrilla Martinez
//                   Vicente Mataix Ferrandiz
//
 
#if !defined(KRATOS_FIND_INTERSECTED_GEOMETRICAL_OBJECTS_PROCESS_H_INCLUDED )
#define  KRATOS_FIND_INTERSECTED_GEOMETRICAL_OBJECTS_PROCESS_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "processes/process.h"
#include "containers/model.h"
#include "includes/kratos_parameters.h"
#include "spatial_containers/octree_binary.h"
 
namespace Kratos
{
namespace Internals {
 
    class DistanceSpatialContainersConfigure
    {
    public:
        class CellNodeData
        {
            double mDistance;
            double mCoordinates[3];
            std::size_t mId;
        public:
            double& Distance() { return mDistance; }
            double& X() { return mCoordinates[0]; }
            double& Y() { return mCoordinates[1]; }
            double& Z() { return mCoordinates[2]; }
            double& Coordinate(int i) { return mCoordinates[i]; }
            std::size_t& Id() { return mId; }
        };
 
 
        enum {
            Dimension = 3,
            DIMENSION = 3,
            MAX_LEVEL = 12,
            MIN_LEVEL = 2    // this cannot be less than 2!!!
        };
 
 
        typedef std::size_t IndexType;
 
        typedef Point PointType;
 
        typedef std::vector<double>::iterator DistanceIteratorType;
 
        typedef PointerVectorSet<GeometricalObject, IndexedObject> EntityContainerType;
 
        typedef typename EntityContainerType::ContainerType ContainerType;
 
        typedef typename ContainerType::value_type PointerType;
 
        typedef CellNodeData cell_node_data_type;
 
        typedef std::vector<CellNodeData*> data_type;
 
        typedef PointerType pointer_type;
 
        KRATOS_CLASS_POINTER_DEFINITION(DistanceSpatialContainersConfigure);
 
 
        DistanceSpatialContainersConfigure() {}
 
        virtual ~DistanceSpatialContainersConfigure() {}
 
 
 
 
 
        static data_type* AllocateData() {
            return new data_type(27, (CellNodeData*)NULL);
        }
 
        static void CopyData(
            data_type* pSource,
            data_type* pDestination
            )
        {
            *pDestination = *pSource;
        }
 
        static void DeleteData(data_type* pData) {
            delete pData;
        }
 
        static inline void CalculateBoundingBox(
            const PointerType& pObject,
            PointType& rLowPoint,
            PointType& rHighPoint
            )
        {
            // Getting the geoemtry
            auto& r_geometry = pObject->GetGeometry();
 
            // Initializing the highest and lowest point
            rHighPoint = r_geometry.GetPoint(0);
            rLowPoint = r_geometry.GetPoint(0);
 
            // Iterating over the nodes
            for (IndexType point = 1; point< r_geometry.PointsNumber(); ++point) {
                const auto& r_point = r_geometry.GetPoint(point);
                for (IndexType i = 0; i < 3; ++i) {
                    rLowPoint[i] = (rLowPoint[i]  >  r_point[i]) ? r_point[i] : rLowPoint[i];
                    rHighPoint[i] = (rHighPoint[i] <  r_point[i]) ? r_point[i] : rHighPoint[i];
                }
            }
        }
 
        static inline void GetBoundingBox(
            const typename GeometricalObject::Pointer pObject,
            double* rLowPoint,
            double* rHighPoint
            )
        {
            // Getting the geoemtry
            auto& r_geometry = pObject->GetGeometry();
 
            // Initializing the highest and lowest point
            for (IndexType i = 0; i<3; ++i) {
                rLowPoint[i] = r_geometry.GetPoint(0)[i];
                rHighPoint[i] = r_geometry.GetPoint(0)[i];
            }
 
            // Iterating over the nodes
            for (IndexType point = 1; point< r_geometry.PointsNumber(); ++point) {
                const auto& r_point = r_geometry.GetPoint(point);
                for (IndexType i = 0; i < 3; ++i) {
                    rLowPoint[i] = (rLowPoint[i]  >  r_point[i]) ? r_point[i] : rLowPoint[i];
                    rHighPoint[i] = (rHighPoint[i] <  r_point[i]) ? r_point[i] : rHighPoint[i];
                }
            }
        }
 
        static inline bool Intersection(
            const typename GeometricalObject::Pointer pObj1,
            const typename GeometricalObject::Pointer pObj2
            )
        {
            auto& r_geom_1 = pObj1->GetGeometry();
            auto& r_geom_2 = pObj2->GetGeometry();
            return r_geom_1.HasIntersection(r_geom_2);
        }
 
        static inline bool IntersectionBox(
            const typename GeometricalObject::Pointer pObject,
            const PointType& rLowPoint,
            const PointType& rHighPoint
            )
        {
            return pObject->GetGeometry().HasIntersection(rLowPoint, rHighPoint);
        }
 
        static inline bool IsIntersected(
            const typename GeometricalObject::Pointer pObject,
            double Tolerance,
            const double* rLowPoint,
            const double* rHighPoint
            )
        {
            PointType low_point(rLowPoint[0] - Tolerance, rLowPoint[1] - Tolerance, rLowPoint[2] - Tolerance);
            PointType high_point(rHighPoint[0] + Tolerance, rHighPoint[1] + Tolerance, rHighPoint[2] + Tolerance);
 
            KRATOS_ERROR << "Not Implemented method" << std::endl;
//             return HasIntersection(pObject->GetGeometry(), low_point, high_point);
        }
 
 
        virtual std::string Info() const
        {
            return " Spatial Containers Configure";
        }
 
        virtual void PrintInfo(std::ostream& rOStream) const {}
 
        virtual void PrintData(std::ostream& rOStream) const {}
 
 
    protected:
 
    private:
 
        DistanceSpatialContainersConfigure& operator=(DistanceSpatialContainersConfigure const& rOther) = delete;
 
        DistanceSpatialContainersConfigure(DistanceSpatialContainersConfigure const& rOther) = delete;
 
 
    }; // Class DistanceSpatialContainersConfigure
 
 
} // manespace Internals
 
 
 
class KRATOS_API(KRATOS_CORE) FindIntersectedGeometricalObjectsProcess
    : public Process
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(FindIntersectedGeometricalObjectsProcess);
 
    KRATOS_DEFINE_LOCAL_FLAG( INTERSECTING_CONDITIONS );
    KRATOS_DEFINE_LOCAL_FLAG( INTERSECTING_ELEMENTS );
    KRATOS_DEFINE_LOCAL_FLAG( INTERSECTED_CONDITIONS );
    KRATOS_DEFINE_LOCAL_FLAG( INTERSECTED_ELEMENTS );
 
    using ConfigurationType = Internals::DistanceSpatialContainersConfigure;
    using CellType = OctreeBinaryCell<ConfigurationType>;
    using OctreeType = OctreeBinary<CellType>;
    using OctreePointerType = unique_ptr<OctreeType>;
    using CellNodeDataType = typename ConfigurationType::cell_node_data_type;
    typedef std::vector<typename OctreeType::cell_type*> OtreeCellVectorType;
 
    typedef std::size_t IndexType;
 
    typedef std::size_t SizeType;
 
    typedef Point PointType;
 
    using NodeType = Node;
 
    using GeometryType = Geometry<NodeType>;
 
 
    FindIntersectedGeometricalObjectsProcess() = delete;
 
    FindIntersectedGeometricalObjectsProcess(
        ModelPart& rModelPartIntersected,
        ModelPart& rModelPartIntersecting,
        const Flags Options = INTERSECTING_CONDITIONS|INTERSECTING_ELEMENTS|INTERSECTED_CONDITIONS|INTERSECTED_ELEMENTS
        );
 
    FindIntersectedGeometricalObjectsProcess(
        Model& rModel,
        Parameters ThisParameters
        );
 
    FindIntersectedGeometricalObjectsProcess(FindIntersectedGeometricalObjectsProcess const& rOther) = delete;
 
    ~FindIntersectedGeometricalObjectsProcess() override = default;
 
 
    std::vector<PointerVector<GeometricalObject>> mIntersectedObjects; 
 
 
    KRATOS_DEPRECATED_MESSAGE("Please do not use this method - Use ExecuteInitialize instead\"")
    virtual void Initialize();
 
    virtual void FindIntersectedSkinObjects(std::vector<PointerVector<GeometricalObject>>& rResults);
 
    virtual void FindIntersections();
 
    virtual std::vector<PointerVector<GeometricalObject>>& GetIntersections();
 
    virtual ModelPart& GetModelPart1();
 
    virtual ModelPart& GetModelPart2();
 
    virtual OctreePointerType& GetOctreePointer();
 
    void Clear() override;
 
    void Execute() override;
 
    void ExecuteInitialize() override;
 
    virtual void IdentifyNearEntitiesAndCheckEntityForIntersection(
        GeometricalObject::Pointer pGeometricalObject,
        OtreeCellVectorType& rLeaves
        );
 
    const Parameters GetDefaultParameters() const override;
 
 
    std::string Info() const override {
        return "FindIntersectedGeometricalObjectsProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override  {
 
    }
 
protected:
 
 
    ModelPart& mrModelPartIntersected;  
    ModelPart& mrModelPartIntersecting; 
    Flags mOptions;                     
    OctreePointerType mpOctree;         
 
 
 
    virtual void SetOctreeBoundingBox();
 
    virtual void MarkIfIntersected(
        GeometricalObject& rIntersectedGeometricalObject,
        OtreeCellVectorType& rLeaves
        );
 
    virtual bool HasIntersection(
        GeometryType& rFirstGeometry,
        GeometryType& rSecondGeometry
        );
 
 
 
 
private:
 
 
 
 
    std::size_t WorkingSpaceDimension();
 
    void GenerateOctree();
 
    virtual void FindIntersectedSkinObjects(
        GeometricalObject& rIntersectedEntity,
        OtreeCellVectorType& rLeaves,
        PointerVector<GeometricalObject>& rResults
        );
 
 
    FindIntersectedGeometricalObjectsProcess& operator=(FindIntersectedGeometricalObjectsProcess const& rOther) = delete;
 
 
 
}; // Class FindIntersectedGeometricalObjectsProcess
 
 
}  // namespace Kratos.
 
#endif // KRATOS_FIND_INTERSECTED_GEOMETRICAL_OBJECTS_PROCESS_H_INCLUDED  defined