ulf_apply_bc_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Author Julio Marti.
//
 
 
//
//   Project Name:        Kratos
//   Last Modified by:    $Author: anonymous $
//   Date:                $Date: 2008-10-23 12:50:01 $
//   Revision:            $Revision: 1.4 $
//
//  this process save structural elements in a separate list
 
#if !defined(KRATOS_ULF_APPLY_BC_PROCESS_INCLUDED )
#define  KRATOS_ULF_APPLY_BC_PROCESS_INCLUDED
 
 
 
// System includes
#include <string>
#include <iostream>
#include <algorithm>
 
// External includes
 
 
// Project includes
#include "includes/define.h"
#include "processes/process.h"
#include "includes/node.h"
#include "includes/element.h"
#include "includes/model_part.h"
//#include "custom_utilities/geometry_utilities2D.h"
//#include "custom_elements/updated_lagrangian_fluid.h"
 
 
namespace Kratos
{
 
 
 
 
 
 
 
 
  class Pfem2ApplyBCProcess
    : public Process
  {
  public:
 
  KRATOS_CLASS_POINTER_DEFINITION(Pfem2ApplyBCProcess);
 
 
 Pfem2ApplyBCProcess(ModelPart& model_part)
      : mr_model_part(model_part)
    {
    }
 
    virtual ~Pfem2ApplyBCProcess()
      {
      }
 
 
 
    void operator()()
    {
      Execute();
    }
 
 
 
    virtual void Execute() override
    {
      KRATOS_TRY
        for(ModelPart::NodesContainerType::const_iterator in = mr_model_part.NodesBegin(); in!=mr_model_part.NodesEnd(); in++)
      {
            //marking wet nodes
            /*                  if(in->FastGetSolutionStepValue(IS_STRUCTURE) )
                        if( (in->GetValue(NEIGHBOUR_ELEMENTS)).size() != 0)
                        in->FastGetSolutionStepValue(IS_FLUID) = 1.0;
                        else //it is not anymore of fluid
                        in->FastGetSolutionStepValue(IS_FLUID) = 0.0;
                        //marking as free surface the lonely nodes
                                else
            */                      if( (in->GetValue(NEIGHBOUR_ELEMENTS)).size() == 0)
        in->FastGetSolutionStepValue(IS_BOUNDARY) = 1.0;
        }
 
        //identify the free surface
        for(ModelPart::NodeIterator i = mr_model_part.NodesBegin() ;
        i != mr_model_part.NodesEnd() ; ++i)
      {
            //reset the free surface
            i->FastGetSolutionStepValue(IS_FREE_SURFACE) = 0;
            //identify the free surface and fix the pressure accordingly
            if( i->FastGetSolutionStepValue(IS_BOUNDARY) != 0
        &&
        i->FastGetSolutionStepValue(IS_STRUCTURE) == 0)
          {
                i->FastGetSolutionStepValue(IS_FREE_SURFACE) = 1;
          }
      }
 
 
        KRATOS_CATCH("")
      }
 
 
 
 
 
 
 
    virtual std::string Info() const override
    {
      return "Pfem2ApplyBCProcess";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const override
    {
      rOStream << "Pfem2ApplyBCProcess";
    }
 
    virtual void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
 
 
 
 protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 private:
 
 
    ModelPart& mr_model_part;
 
 
 
 
 
 
 
 
 
 
    //      UlfApplyBCProcess& operator=(UlfApplyBCProcess const& rOther);
 
    //      UlfApplyBCProcess(UlfApplyBCProcess const& rOther);
 
 
 
}; // Class UlfApplyBCProcess
 
 
 
 
 
 
 inline std::istream& operator >> (std::istream& rIStream,
                   Pfem2ApplyBCProcess& rThis);
 
 inline std::ostream& operator << (std::ostream& rOStream,
                   const Pfem2ApplyBCProcess& rThis)
 {
   rThis.PrintInfo(rOStream);
   rOStream << std::endl;
   rThis.PrintData(rOStream);
 
   return rOStream;
 }
 
 
}  // namespace Kratos.
 
#endif // KRATOS_ULF_APPLY_BC_PROCESS_INCLUDED  defined