model_subdivision_utilities.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Máté Kelemen
//
 
#ifndef KRATOS_WIND_MODEL_SUBDIVISION_UTILITIES
#define KRATOS_WIND_MODEL_SUBDIVISION_UTILITIES
 
// Project includes
#include "includes/model_part.h"
#include "includes/lock_object.h"
 
 
namespace Kratos
{
namespace Wind
{
 
 
class KRATOS_API(WIND_ENGINEERING_APPLICATION) ModelSubdivisionUtilities
{
public:
    static std::vector<Kratos::shared_ptr<ModelPart>> SortNodesBySlabs(
        ModelPart& rModelPart,
        const array_1d<double,3>& rBottomPoint,
        const array_1d<double,3>& rTopPoint,
        std::size_t numberOfSlabs,
        bool isRootSlabOpen);
 
    static void SortNodes(
        ModelPart& rModelPart,
        std::function<ModelPart*(const Node&)> sortFunction,
        std::vector<ModelPart*>& rSubModelParts);
 
    static void SortElements(
        ModelPart& rModelPart,
        std::function<ModelPart*(const Element&)> sortFunction,
        std::vector<ModelPart*>& rSubModelParts);
 
    static void SortConditions(
        ModelPart& rModelPart,
        std::function<ModelPart*(const Condition&)> sortFunction,
        std::vector<ModelPart*>& rSubModelParts);
 
protected:
    class ThreadSafeIndexSet
    {
    public:
        using IndexType = ModelPart::IndexType;
 
        ThreadSafeIndexSet(std::vector<ModelPart*>& rSubModelParts);
 
        void Push(ModelPart* pSubModelPart, IndexType value);
 
        template <class TFunction = std::function<void(ModelPart*, const std::vector<IndexType>&, IndexType)>>
        void Apply(TFunction function);
 
    private:
        using LockType = LockObject;
 
        std::map<ModelPart*,
                 std::pair<std::vector<IndexType>,
                           unique_ptr<LockType>>> mIndexSets;
    };
 
 
    class Slab
    {
    public:
        Slab(const array_1d<double,3>& rBottomPoint,
             const array_1d<double,3>& rTopPoint,
             bool isOpen = false);
 
        bool IsBelow(const array_1d<double,3>& rPoint) const;
 
        bool IsAbove(const array_1d<double,3>& rPoint) const;
 
        bool IsInside(const array_1d<double,3>& rPoint) const;
 
    protected:
        struct Plane
        {
            bool IsOnPositiveSide(const array_1d<double,3>& rPoint, bool open) const;
 
            array_1d<double,3> mReferencePoint;
            array_1d<double,3> mNormal;
        }; // struct Plane
 
        const array_1d<double,3>& Normal() const;
 
        const Plane mBottomPlane;
        const Plane mTopPlane;
        const bool  mIsOpen;
    }; // class Slab
 
    class SlabStack : public Slab
    {
    public:
 
        SlabStack(const array_1d<double,3> rBottomPoint,
                  const array_1d<double,3> rTopPoint,
                  std::size_t numberOfSlabs,
                  bool isOpen);
 
        std::size_t SlabIndex(const array_1d<double,3>& rPoint) const;
 
        std::size_t size() const;
 
    private:
        std::vector<Slab::Plane> mInnerPlanes;
    }; // class SlabStack
}; // class ModelSubdivisionUtilities
 
 
} // namespace Wind
} // namespace Kratos
 
#include "model_subdivision_utilities_impl.h"
 
#endif // KRATOS_MODEL_SUBDIVISION_UTILITIES