base_geometry.h

Go to the documentation of this file.

/* -------------------------------------------------------------------------*
 *                              SPHinXsys                                   *
 * --------------------------------------------------------------------------*
 * SPHinXsys (pronunciation: s'finksis) is an acronym from Smoothed Particle    *
 * Hydrodynamics for industrial compleX systems. It provides C++ APIs for   *
 * physical accurate simulation and aims to model coupled industrial dynamic *
 * systems including fluid, solid, multi-body dynamics and beyond with SPH  *
 * (smoothed particle hydrodynamics), a meshless computational method using *
 * particle discretization.                                                 *
 *                                                                          *
 * SPHinXsys is partially funded by German Research Foundation              *
 * (Deutsche Forschungsgemeinschaft) DFG HU1527/6-1, HU1527/10-1                *
 * and HU1527/12-1.                                                         *
 *                                                                           *
 * Portions copyright (c) 2017-2020 Technical University of Munich and      *
 * the authors' affiliations.                                               *
 *                                                                           *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may   *
 * not use this file except in compliance with the License. You may obtain a *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.        *
 *                                                                           *
 * --------------------------------------------------------------------------*/
#ifndef BASE_GEOMETRY_H
#define BASE_GEOMETRY_H

#include "base_data_package.h"
#include "sph_data_containers.h"

#include <string>

namespace SPH
{
    enum class ShapeBooleanOps
    {
        add,
        sub,
        sym_diff,
        intersect
    };

    class Shape
    {
    public:
        explicit Shape(const std::string &shape_name)
            : name_(shape_name), is_bounds_found_(false){};
        virtual ~Shape(){};

        std::string getName() { return name_; };
        void setName(const std::string &name) { name_ = name; };
        BoundingBox getBounds();
        virtual bool isValid() { return true; };
        virtual bool checkContain(const Vecd &pnt, bool BOUNDARY_INCLUDED = true) = 0;
        virtual Vecd findClosestPoint(const Vecd &input_pnt) = 0;

        bool checkNotFar(const Vecd &input_pnt, Real threshold);
        bool checkNearSurface(const Vecd &input_pnt, Real threshold);
        Real findSignedDistance(const Vecd &input_pnt);
        Vecd findNormalDirection(const Vecd &input_pnt);

    protected:
        std::string name_;
        BoundingBox bounding_box_;
        bool is_bounds_found_;

        virtual BoundingBox findBounds() = 0;
    };

    using ShapeAndOp = std::pair<Shape *, ShapeBooleanOps>;
    class BinaryShapes : public Shape
    {
    public:
        BinaryShapes() : Shape("BinaryShapes"){};
        explicit BinaryShapes(const std::string &shapes_name) : Shape(shapes_name){};
        virtual ~BinaryShapes(){};

        template <class ShapeType, typename... Args>
        void add(Args &&...args)
        {
            Shape *shape = shapes_ptr_keeper_.createPtr<ShapeType>(std::forward<Args>(args)...);
            ShapeAndOp shape_and_op(shape, ShapeBooleanOps::add);
            shapes_and_ops_.push_back(shape_and_op);
        };

        template <class ShapeType, typename... Args>
        void subtract(Args &&...args)
        {
            Shape *shape = shapes_ptr_keeper_.createPtr<ShapeType>(std::forward<Args>(args)...);
            ShapeAndOp shape_and_op(shape, ShapeBooleanOps::sub);
            shapes_and_ops_.push_back(shape_and_op);
        };

        virtual bool isValid() override;
        virtual bool checkContain(const Vecd &pnt, bool BOUNDARY_INCLUDED = true) override;
        virtual Vecd findClosestPoint(const Vecd &input_pnt) override;
        Shape *getShapeByName(const std::string &shape_name);
        ShapeAndOp *getShapeAndOpByName(const std::string &shape_name);
        size_t getShapeIndexByName(const std::string &shape_name);

    protected:
        UniquePtrKeepers<Shape> shapes_ptr_keeper_;
        StdVec<ShapeAndOp> shapes_and_ops_;

        virtual BoundingBox findBounds() override;
    };

    template <typename InEdgeType, typename OutEdgeType>
    class Edge
    {
    public:
        template <class EdgeStructureType>
        explicit Edge(EdgeStructureType *structure)
            : id_(structure->ContainerSize()), in_edge_(MaxSize_t){};
        template <class EdgeStructureType>
        Edge(InEdgeType in_edge, EdgeStructureType *structure)
            : id_(structure->ContainerSize()), in_edge_(in_edge){};
        virtual ~Edge(){};

        size_t id_;            
        InEdgeType in_edge_;   
        OutEdgeType out_edge_; 
    };
}
#endif // BASE_GEOMETRY_H