apply_ray_casting_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand, Ruben Zorrilla
//
 
#if !defined(KRATOS_APPLY_RAY_CASTING_PROCESS_H_INCLUDED )
#define  KRATOS_APPLY_RAY_CASTING_PROCESS_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "processes/find_intersected_geometrical_objects_process.h"
 
namespace Kratos
{
 
 
 
template<std::size_t TDim = 3>
class KRATOS_API(KRATOS_CORE) ApplyRayCastingProcess : public Process
{
 
public:
 
    //TODO: delete after deprecated constructor are removed.
    enum class DistanceDatabase {
        NodeHistorical,
        NodeNonHistorical
    };
 
    KRATOS_CLASS_POINTER_DEFINITION(ApplyRayCastingProcess);
 
    KRATOS_REGISTRY_ADD_TEMPLATE_PROTOTYPE("Processes.KratosMultiphysics", Process, ApplyRayCastingProcess, TDim)
    KRATOS_REGISTRY_ADD_TEMPLATE_PROTOTYPE("Processes.All", Process, ApplyRayCastingProcess, TDim)
 
    //TODO: These using statements have been included to make the old functions able to compile. It is still pending to update them.
    using ConfigurationType = Internals::DistanceSpatialContainersConfigure;
    using CellType = OctreeBinaryCell<ConfigurationType>;
    using OctreeType = OctreeBinary<CellType>;
    using CellNodeDataType = ConfigurationType::cell_node_data_type;
 
    typedef Element::GeometryType IntersectionGeometryType;
    typedef std::vector<std::pair<double, IntersectionGeometryType*> > IntersectionsContainerType;
 
    using NodeType = ModelPart::NodeType;
    using NodeScalarGetFunctionType = std::function<double&(NodeType& rNode, const Variable<double>& rDistanceVariable)>;
    using ApplyNodalFunctorType = std::function<void(NodeType&, const double)>;
 
 
    ApplyRayCastingProcess(
        ModelPart& rVolumePart,
        ModelPart& rSkinPart,
        Parameters ThisParameters = Parameters());
 
    KRATOS_DEPRECATED_MESSAGE("Deprecated constructor, please use the one with Parameters.")
    ApplyRayCastingProcess(
        ModelPart& rVolumePart,
        ModelPart& rSkinPart,
        const double RelativeTolerance);
 
    ApplyRayCastingProcess(
        FindIntersectedGeometricalObjectsProcess& TheFindIntersectedObjectsProcess,
        Parameters ThisParameters = Parameters());
 
    KRATOS_DEPRECATED_MESSAGE("Deprecated constructor, please use the one with Parameters.")
    ApplyRayCastingProcess(
        FindIntersectedGeometricalObjectsProcess& TheFindIntersectedObjectsProcess,
        const double RelativeTolerance,
        const Variable<double>* pDistanceVariable,
        const DistanceDatabase& rDistanceDatabase);
 
    ~ApplyRayCastingProcess() override;
 
 
    ApplyRayCastingProcess()
    {
        mIsSearchStructureAllocated = false; //used in dtor
    }
 
    ApplyRayCastingProcess(ApplyRayCastingProcess const& rOther) = delete;
 
    ApplyRayCastingProcess& operator=(ApplyRayCastingProcess const& rOther) = delete;
 
 
    const Parameters GetDefaultParameters() const override;
 
    virtual double DistancePositionInSpace(const Node &rNode);
 
    virtual void GetRayIntersections(
        const double* ray,
        const unsigned int direction,
        std::vector<std::pair<double,Element::GeometryType*> > &rIntersections);
 
    virtual int GetCellIntersections(
        OctreeType::cell_type* cell,
        const double* ray,
        OctreeType::key_type* ray_key,
        const unsigned int direction,
        std::vector<std::pair<double, Element::GeometryType*> > &rIntersections);
 
    void Execute() override;
 
 
    std::string Info() const override;
 
    void PrintInfo(std::ostream& rOStream) const override;
 
    void PrintData(std::ostream& rOStream) const override;
 
protected:
 
 
 
    Parameters mSettings;
    double mEpsilon;
    double mExtraRayOffset;
    double mRelativeTolerance;
    FindIntersectedGeometricalObjectsProcess* mpFindIntersectedObjectsProcess;
    bool mIsSearchStructureAllocated;
    double mCharacteristicLength;
    const Variable<double>* mpDistanceVariable = nullptr;
    NodeScalarGetFunctionType mDistanceGetterFunctor;
 
 
 
 
 
    int ComputeRayIntersection(
        Element::GeometryType& rGeometry,
        const double* pRayPoint1,
        const double* pRayPoint2,
        double* pIntersectionPoint);
 
    void GetExtraRayOrigins(
        const array_1d<double,3> &rCoords,
        array_1d<array_1d<double,3>, (TDim == 3) ? 9 : 5> &rExtraRayOrigs);
 
 
    void CorrectExtraRayOrigin(double* ExtraRayCoords);
 
    void ComputeExtraRayColors(
        const array_1d<double,3> &rCoords,
        array_1d<double,TDim> &rDistances);
 
 
    void CalculateCharacteristicLength();
 
    void SetRayCastingTolerances();
 
    NodeScalarGetFunctionType CreateDistanceGetterFunctor() const;
 
    virtual ApplyNodalFunctorType CreateApplyNodalFunction() const;
 
 
 
 
 
 
 
 
}; // Class ApplyRayCastingProcess
 
 
 
 
inline std::istream& operator >> (
    std::istream& rIStream,
    ApplyRayCastingProcess<>& rThis);
 
inline std::ostream& operator << (
    std::ostream& rOStream,
    const ApplyRayCastingProcess<>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
} // namespace Kratos.
 
#endif // KRATOS_APPLY_RAY_CASTING_PROCESS_H_INCLUDED  defined