refine_fluid_elements_in_edges_mesher_process.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosPfemFluidApplication $
//   Created by:          $Author:       JMCarbonell $
//   Last modified by:    $Co-Author:                $
//   Date:                $Date:           July 2018 $
//   Revision:            $Revision:             0.0 $
//
//
 
#if !defined(KRATOS_REFINE_FLUID_ELEMENTS_IN_EDGES_MESHER_PROCESS_H_INCLUDED )
#define  KRATOS_REFINE_FLUID_ELEMENTS_IN_EDGES_MESHER_PROCESS_H_INCLUDED
 
 
// External includes
 
// System includes
 
// Project includes
#include "custom_processes/refine_elements_in_edges_mesher_process.hpp"
 
namespace Kratos
{
 
 
 
class RefineFluidElementsInEdgesMesherProcess
    : public RefineElementsInEdgesMesherProcess
{
 public:
 
  KRATOS_CLASS_POINTER_DEFINITION( RefineFluidElementsInEdgesMesherProcess );
 
  typedef ModelPart::ConditionType         ConditionType;
  typedef ModelPart::PropertiesType       PropertiesType;
  typedef ConditionType::GeometryType       GeometryType;
 
  typedef RefineElementsInEdgesMesherProcess    BaseType;
 
  typedef GlobalPointersVector<Node > NodeWeakPtrVectorType;
 
  RefineFluidElementsInEdgesMesherProcess(ModelPart& rModelPart,
                                          MesherUtilities::MeshingParameters& rRemeshingParameters,
                                          int EchoLevel) : BaseType(rModelPart,rRemeshingParameters,EchoLevel)
  {
  }
 
 
  virtual ~RefineFluidElementsInEdgesMesherProcess() {}
 
 
 
  void operator()()
  {
    Execute();
  }
 
 
 
 
 
 
 
 
 
  std::string Info() const override
  {
    return "RefineFluidElementsInEdgesMesherProcess";
  }
 
  void PrintInfo(std::ostream& rOStream) const override
  {
    rOStream << "RefineFluidElementsInEdgesMesherProcess";
  }
 
  void PrintData(std::ostream& rOStream) const override
  {
  }
 
 
 
 
 protected:
 
 
 
  //**************************************************************************
  //**************************************************************************
 
  void SelectFullBoundaryEdgedElements(ModelPart& rModelPart,
                                       ModelPart::ElementsContainerType& rBoundaryEdgedElements) override
  {
    KRATOS_TRY
 
    bool is_full_rigid_boundary = false;
    bool is_full_fluid_boundary = false;
    for(ModelPart::ElementsContainerType::iterator i_elem = rModelPart.ElementsBegin();
        i_elem != rModelPart.ElementsEnd(); ++i_elem)
    {
      Geometry< Node >& rGeometry = i_elem->GetGeometry();
 
      is_full_rigid_boundary = true;
      for(unsigned int i=0; i<rGeometry.size(); ++i)
      {
        if( rGeometry[i].IsNot(BOUNDARY) || rGeometry[i].IsNot(RIGID) ){
          is_full_rigid_boundary = false;
          break;
        }
 
      }
 
      is_full_fluid_boundary = true;
      for(unsigned int i=0; i<rGeometry.size(); ++i)
      {
        if( rGeometry[i].IsNot(FREE_SURFACE) || rGeometry[i].Is(RIGID) || rGeometry[i].Is(SOLID) ){
          is_full_fluid_boundary = false;
          break;
        }
 
        // this condition fails
        // if ( rGeometry[i].GetValue(NEIGHBOUR_NODES).size() > rGeometry.size()-1 ){
        //   is_full_fluid_boundary = false;
        //   break;
        // }
 
        NodeWeakPtrVectorType& nNodes = rGeometry[i].GetValue(NEIGHBOUR_NODES);
        for(auto& i_nnode : nNodes)
        {
          if(i_nnode.Is(SOLID) || i_nnode.Is(RIGID))
          {
            is_full_fluid_boundary = false;
            break;
          }
        }
      }
      // if( is_full_rigid_boundary )
      //   std::cout<<" is full rigid boundary "<<std::endl;
 
      // if( is_full_fluid_boundary )
      //   std::cout<<" is full fluid boundary "<<std::endl;
 
      if( is_full_rigid_boundary || is_full_fluid_boundary ){
        rBoundaryEdgedElements.push_back(*(i_elem.base()));
      }
 
    }
 
    KRATOS_CATCH( "" )
  }
 
 
 private:
 
  RefineFluidElementsInEdgesMesherProcess& operator=(RefineFluidElementsInEdgesMesherProcess const& rOther);
 
 
 
 
  //Process(Process const& rOther);
 
 
 
}; // Class Process
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  RefineFluidElementsInEdgesMesherProcess& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const RefineFluidElementsInEdgesMesherProcess& rThis)
{
  rThis.PrintInfo(rOStream);
  rOStream << std::endl;
  rThis.PrintData(rOStream);
 
  return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_REFINE_FLUID_ELEMENTS_IN_EDGES_MESHER_PROCESS_H_INCLUDED  defined