mesher.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosDelaunayMeshingApplication $
//   Created by:          $Author:             JMCarbonell $
//   Last modified by:    $Co-Author:                      $
//   Date:                $Date:                April 2018 $
//   Revision:            $Revision:                   0.0 $
//
//
 
#if !defined(KRATOS_MESHER_H_INCLUDED )
#define  KRATOS_MESHER_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/model_part.h"
#include "containers/variables_list_data_value_container.h"
#include "spatial_containers/spatial_containers.h"
#include "utilities/openmp_utils.h"
#include "custom_utilities/mesher_utilities.hpp"
#include "custom_processes/mesher_process.hpp"
 
 
//Data:
//StepData:
//Flags:    (checked)
//          (set)
//          (modified)
//          (reset)
 
namespace Kratos
{
 
 
 
 
 
 
 
class KRATOS_API(DELAUNAY_MESHING_APPLICATION) Mesher
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION( Mesher );
 
    typedef std::size_t SizeType;
    typedef std::size_t IndexType;
 
    typedef MesherUtilities::MeshingInfoParameters  InfoParametersType;
    typedef MesherUtilities::MeshingParameters   MeshingParametersType;
    typedef MesherUtilities::RefiningParameters   RefineParametersType;
 
    typedef GlobalPointersVector<Node >          NodeWeakPtrVectorType;
    typedef GlobalPointersVector<Element>        ElementWeakPtrVectorType;
    typedef GlobalPointersVector<Condition>    ConditionWeakPtrVectorType;
 
    Mesher() {}
 
    Mesher(Mesher const& rOther)
      :mpMeshingVariables(rOther.mpMeshingVariables)
      ,mPreMeshingProcesses(rOther.mPreMeshingProcesses)
      ,mPostMeshingProcesses(rOther.mPostMeshingProcesses)
      ,mpMesherUtilities(rOther.mpMesherUtilities)
      ,mpDataTransferUtilities(rOther.mpDataTransferUtilities)
      ,mEchoLevel(rOther.mEchoLevel)
    {};
 
    virtual ~Mesher() {}
 
 
 
 
 
 
    //************* STARTING METHODS
 
    void Initialize();
 
 
    virtual void SetEchoLevel(int Level)
    {
        mEchoLevel = Level;
    }
 
    int GetEchoLevel()
    {
        return mEchoLevel;
    }
 
    void SetMeshingParameters( MeshingParametersType::Pointer& rMeshingParameters );
 
    void SetPreMeshingProcess( MesherProcess::Pointer pPreMeshingProcess );
 
    void SetPostMeshingProcess( MesherProcess::Pointer pPostMeshingProcess );
 
 
    void SetPreMeshingProcessVector( std::vector<MesherProcess::Pointer>& rPreMeshingProcessVector );
 
    void SetPostMeshingProcessVector( std::vector<MesherProcess::Pointer>& rPostMeshingProcessVector );
 
 
    void SetMesherUtilities( MesherUtilities::Pointer rMesherUtilities );
 
    void SetDataTransferUtilities( MeshDataTransferUtilities::Pointer rDataTransferUtilities );
 
 
    //*******************************************************************************************
    //*******************************************************************************************
 
    virtual void InitializeMesher(ModelPart& rModelPart);
 
 
    virtual void ExecuteMeshing(ModelPart& rModelPart);
 
    virtual void FinalizeMesher(ModelPart& rModelPart);
 
 
 
 
 
 
    virtual std::string Info() const
    {
        return "Mesher";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << Info();
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
    }
 
 
 
 
 
protected:
 
 
 
    MeshingParametersType::Pointer          mpMeshingVariables;
 
    std::vector<MesherProcess::Pointer>   mPreMeshingProcesses;
    std::vector<MesherProcess::Pointer>  mPostMeshingProcesses;
 
    MesherUtilities::Pointer                 mpMesherUtilities;
 
    MeshDataTransferUtilities::Pointer mpDataTransferUtilities;
 
    int mEchoLevel;
 
 
    Mesher& operator=(Mesher const& rOther);
 
 
    virtual void StartEcho(ModelPart& rSubModelPart,
               std::string GenerationMessage);
 
 
    virtual void EndEcho(ModelPart& rSubModelPart,
             std::string GenerationMessage);
 
 
 
    virtual void SetNodes(ModelPart& rModelPart,
              MeshingParametersType& rMeshingVariables);
 
    virtual void SetElements(ModelPart& rModelPart,
                 MeshingParametersType& rMeshingVariables);
 
    virtual void SetNeighbours(ModelPart& rModelPart,
                   MeshingParametersType& rMeshingVariables);
 
 
    virtual void ExecutePreMeshingProcesses();
 
 
    virtual void ExecutePostMeshingProcesses();
 
 
 
    virtual void Generate (ModelPart& rModelPart,
               MeshingParametersType& rMeshingVariables){};
 
 
    virtual void SetElementNeighbours(ModelPart& rModelPart,
                      MeshingParametersType& rMeshingVariables);
 
    virtual void RecoverBoundaryPosition(ModelPart& rModelPart,
                     MeshingParametersType& rMeshingVariables);
 
 
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
}; // Class Mesher
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  Mesher& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const Mesher& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_MESHER_H_INCLUDED  defined