inlet_mesher_process.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosPfemApplication     $
//   Created by:          $Author:      JMCarbonell $
//   Last modified by:    $Co-Author:               $
//   Date:                $Date:          July 2018 $
//   Revision:            $Revision:            0.0 $
//
//
 
#if !defined(KRATOS_INLET_MESHER_PROCESS_H_INCLUDED )
#define  KRATOS_INLET_MESHER_PROCESS_H_INCLUDED
 
 
// External includes
 
// System includes
 
// Project includes
#include "includes/model_part.h"
#include "custom_utilities/mesher_utilities.hpp"
#include "custom_processes/mesher_process.hpp"
 
 
namespace Kratos
{
 
 
 
class InletMesherProcess
    : public MesherProcess
{
 public:
 
  KRATOS_CLASS_POINTER_DEFINITION( InletMesherProcess );
 
  typedef ModelPart::NodeType                   NodeType;
  typedef ModelPart::ConditionType         ConditionType;
  typedef ModelPart::PropertiesType       PropertiesType;
  typedef ConditionType::GeometryType       GeometryType;
 
 
  InletMesherProcess(ModelPart& rModelPart,
                               MesherUtilities::MeshingParameters& rRemeshingParameters,
                               int EchoLevel)
      : mrModelPart(rModelPart),
    mrRemesh(rRemeshingParameters)
  {
    mEchoLevel = EchoLevel;
  }
 
 
  virtual ~InletMesherProcess() {}
 
 
 
  void operator()()
  {
    Execute();
  }
 
 
 
  void Execute() override
  {
    KRATOS_TRY
 
    if( mEchoLevel > 1 )
      std::cout<<" [ INLET MANAGEMENT PROCESS: "<<std::endl;
 
    if( mrModelPart.Name() != mrRemesh.SubModelPartName )
      std::cout<<" ModelPart Supplied do not corresponds to the Meshing Domain: ("<<mrModelPart.Name()<<" != "<<mrRemesh.SubModelPartName<<")"<<std::endl;
 
    this->SetInletLayer();
 
    if( mEchoLevel > 1 )
      std::cout<<"   INLET MANAGEMENT PROCESS ]; "<<std::endl;
 
    KRATOS_CATCH(" ")
  }
 
 
 
 
 
 
 
  std::string Info() const override
  {
    return "InletMesherProcess";
  }
 
  void PrintInfo(std::ostream& rOStream) const override
  {
    rOStream << "InletMesherProcess";
  }
 
  void PrintData(std::ostream& rOStream) const override
  {
  }
 
 
 
 
 
 private:
 
  ModelPart& mrModelPart;
 
  MesherUtilities::MeshingParameters& mrRemesh;
 
  int mEchoLevel;
 
 
 
 
 
  void SetInletLayer()
 
  {
    KRATOS_TRY
 
    double critical_distance = 4.0*mrRemesh.Refine->CriticalRadius;
 
    unsigned int NodeId = MesherUtilities::GetMaxNodeId( mrModelPart.GetParentModelPart() ) + 1;
 
    ModelPart::NodesContainerType InletNodes;
 
    for(ModelPart::NodesContainerType::iterator i_node = mrModelPart.NodesBegin() ; i_node != mrModelPart.NodesEnd() ; ++i_node)
    {
      if(i_node->Is(INLET) ){
 
          double distance = norm_2(i_node->FastGetSolutionStepValue(DISPLACEMENT));
 
          if( distance > critical_distance ){
 
            // add new inlet node
            NodeType::Pointer pnode = i_node->Clone();
 
            pnode->SetId(NodeId);
            pnode->Coordinates() = pnode->GetInitialPosition();
 
            pnode->Set(INLET,true);
            // release old inlet node
            i_node->Set(INLET,false);
 
            Node::DofsContainerType& Dofs = i_node->GetDofs();
            //free dofs
            for(Node::DofsContainerType::iterator i_dof = Dofs.begin(); i_dof != Dofs.end(); ++i_dof)
            {
              (*i_dof)->FreeDof();
            }
 
            noalias(pnode->FastGetSolutionStepValue(DISPLACEMENT))   = ZeroVector(3);
            noalias(pnode->FastGetSolutionStepValue(DISPLACEMENT,1)) = ZeroVector(3);
 
            noalias(i_node->FastGetSolutionStepValue(VELOCITY,1)) = i_node->FastGetSolutionStepValue(VELOCITY);
            noalias(i_node->FastGetSolutionStepValue(ACCELERATION))   = ZeroVector(3);
            noalias(i_node->FastGetSolutionStepValue(ACCELERATION,1)) = ZeroVector(3);
 
            InletNodes.push_back(pnode);
 
            ++NodeId;
 
          }
 
      }
 
    }
 
    if( InletNodes.size() !=0 )
      mrModelPart.AddNodes(InletNodes.begin(), InletNodes.end());
 
    KRATOS_CATCH("")
  }
 
 
 
 
 
  InletMesherProcess& operator=(InletMesherProcess const& rOther);
 
 
 
 
  //Process(Process const& rOther);
 
 
 
}; // Class Process
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  InletMesherProcess& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const InletMesherProcess& rThis)
{
  rThis.PrintInfo(rOStream);
  rOStream << std::endl;
  rThis.PrintData(rOStream);
 
  return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_INLET_MESHER_PROCESS_H_INCLUDED  defined