GhostFluidMethod.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2002 Ralf Deiterding
// Brandenburgische Universitaet Cottbus
//
// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@amroc.net

#ifndef AMROC_GHOSTFLUIDMETHOD_H
#define AMROC_GHOSTFLUIDMETHOD_H

#include "GFMBoundary.h"
#include "GFMLevelSet.h"
#include "AMRBase.h"

template <class VectorType, int dim>
class GhostFluidMethod : public AMRBase<VectorType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef AMRBase<VectorType,dim> base;
public:
  typedef typename base::vec_grid_fct_type vec_grid_fct_type;  
  typedef GridFunction<DataType,dim> grid_fct_type;   
  typedef GridFunction<bool,dim> bool_grid_fct_type;  

  typedef GFMBoundary<VectorType,dim> boundary_type;
  typedef GFMLevelSet<DataType,dim> levelset_type;
  typedef BoundaryConditions<DataType,dim> boundary_conditions_type;

  typedef GFBndryUpdateSpecificFunc<boundary_conditions_type,DataType,dim> boundary_functor_type;

  GhostFluidMethod(boundary_type* boundary, levelset_type* levelset) : 
    _Boundary(boundary), _LevelSet(levelset), _EstimateError(false), _Ignore(0) {      
    _BoundaryConditions = (boundary_conditions_type*) 0; 
    _phi = (grid_fct_type *) 0; 
    _phi_sh = (grid_fct_type *) 0; 
    _BoundaryFunc = (boundary_functor_type *) 0;
    _myprefix = "";
  }

  GhostFluidMethod(boundary_type* boundary, levelset_type* levelset, 
                   boundary_conditions_type* boundary_conditions) : 
    _Boundary(boundary), _LevelSet(levelset), 
    _BoundaryConditions(boundary_conditions),
    _EstimateError(false), _Ignore(0)  {      
    _phi = (grid_fct_type *) 0; 
    _phi_sh = (grid_fct_type *) 0; 
    _BoundaryFunc = (boundary_functor_type *) 0;
    _myprefix = "";
  }

  virtual ~GhostFluidMethod() {
    if (_phi) delete _phi;
    if (_phi_sh) delete _phi_sh;
    if (_BoundaryFunc) delete _BoundaryFunc;
  }

  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    _myprefix = prefix;
    base::LocCtrl = Ctrl.getSubDevice(prefix+"GFM");    
    RegisterAt(base::LocCtrl,"Ignore",_Ignore);
    LevelSet().register_at(base::LocCtrl,"");
    Boundary().register_at(base::LocCtrl,"");
  } 
  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl, "");
  }

  virtual void init() {
    LevelSet().init();
    Boundary().init(); 
  }
  virtual void update() {
    LevelSet().update();
    Boundary().update(); 
  }
  virtual void finish() {
    if (_phi) {
      delete _phi;
      _phi = (grid_fct_type *) 0; 
    }
    if (_phi_sh) {
      delete _phi_sh;
      _phi_sh = (grid_fct_type *) 0; 
    }
    LevelSet().finish();
    Boundary().finish(); 
  } 

  virtual void SetupData(GridHierarchy* gh, const int& ghosts) {
    base::SetupData(gh, ghosts);
    LevelSet().SetupData(gh, ghosts);
    Boundary().SetupData(gh, ghosts);
    int t_sten = 1;            
    int s_sten = base::NGhosts(); 
    std::sprintf(phiName,"%sphi",_myprefix.c_str());
    _phi = new grid_fct_type(phiName, t_sten, s_sten, base::GH(), DAGHCellCentered,
                             DAGHCommSimple, DAGHNoBoundary, DAGHNoAdaptBoundary,
                             DAGHNoExternalGhost);
    if (Stationary()) { SetTimeAlias(*_phi, 1, 0); SetTimeAlias(*_phi, -1, 0); }
    else SetTimeAlias(*_phi, -1, 1);
    SetCheckpointFlag(*_phi, DAGHTrue);
    if (_BoundaryConditions) 
      _BoundaryFunc = new boundary_functor_type(_BoundaryConditions, 
                                                &boundary_conditions_type::SetBndry);
    SetProlongFlag(*_phi, DAGHFalse);   
    if (_BoundaryFunc) {
      _phi->GF_SetBndryUpdateFlag(DAGHTrue);
      _phi->GF_SetBoundaryType(DAGHBoundaryUserDef);
      _phi->GF_SetBndryUpdateFunc(_BoundaryFunc);
    }

    if (ErrorEstimation()) {
      std::sprintf(phiNamesh,"%sphish",_myprefix.c_str()); 
      _phi_sh = new grid_fct_type(phiNamesh, t_sten, s_sten, base::GH(), DAGHCellCentered, 0, 
                                  DAGHShadowFactor, DAGH_All, DAGHCommSimple, 
                                  DAGHNoBoundary, DAGHNoAdaptBoundary, DAGHNoExternalGhost);
      if (Stationary()) { SetTimeAlias(*_phi_sh, 1, 0); SetTimeAlias(*_phi_sh, -1, 0); }
      else SetTimeAlias(*_phi_sh, -1, 1);
      SetCheckpointFlag(*_phi_sh, DAGHTrue);
      SetProlongFlag(*_phi_sh, DAGHFalse);   
      if (_BoundaryFunc) {
        _phi_sh->GF_SetBndryUpdateFlag(DAGHTrue);
        _phi_sh->GF_SetBoundaryType(DAGHBoundaryUserDef);
        _phi_sh->GF_SetBndryUpdateFunc(_BoundaryFunc);
      }
    }   
  }

  virtual void SetLevelSet(vec_grid_fct_type& u, const int Time, 
                           const int Level, double t) {
    START_WATCH
      forall (Phi(u),Time,Level,c)  
        Phi(u)(Time,Level,c) = DataType(0.0);
      end_forall    
    END_WATCH(LS_SET_WHOLE)
    if (_Ignore) {
      START_WATCH
        forall (Phi(u),Time,Level,c)  
          Phi(u)(Time,Level,c) = Boundary().FarAway();
        end_forall    
      END_WATCH(LS_SET_WHOLE)
      return;
    }
#ifdef DEBUG_PRINT_AMRSOLVER
      ( comm_service::log() <<  "  *** Setting level set: Level " << Level << 
        "  Time = " << Time << "  t = " << t << "\n" ).flush();
#endif
    START_WATCH
      LevelSet().SetPhi(Phi(u),Time,Level,t);
    END_WATCH(LS_SET_WHOLE)
  }   

  virtual void SetBndry(vec_grid_fct_type& u, bool_grid_fct_type& bf, 
                        const int Time, const int Level, 
                        double t, bool extrapolate=false) {
    if (_Ignore) return;
#ifdef DEBUG_PRINT_AMRSOLVER
    ( comm_service::log() <<  "  *** Setting GFM bndry: Level " << Level << 
      "  Time = " << Time << "  t = " << t << "\n" ).flush();
#endif
    Boundary().SetPhysbd(u,Phi(u),bf,Time,Level,t,extrapolate); 
  }   

  void SetMaxRecomposeLevel(const int l) {
    Phi().GF_SetMaxRecomposeLevel(l);
    if (ErrorEstimation()) 
      Phish().GF_SetMaxRecomposeLevel(l);
  }

  inline bool IsUsed() const { return (_Ignore==0); }
  inline const int& Stationary() const { return LevelSet().Stationary(); }
  inline grid_fct_type& Phi() { return *_phi; }
  inline const grid_fct_type& Phi() const { return *_phi; }
  inline grid_fct_type& Phish() { return *_phi_sh; }
  inline const grid_fct_type& Phish() const { return *_phi_sh; }
  inline grid_fct_type& Phi(vec_grid_fct_type& u) 
  { return (&u==_u_sh ? *_phi_sh : *_phi); }
  inline const grid_fct_type& Phi(vec_grid_fct_type& u) const
  { return (&u==_u_sh ? *_phi_sh : *_phi); }
  inline const bool& ErrorEstimation() const { return _EstimateError;}
  void SetErrorEstimation(const bool est) { _EstimateError = est; }

  inline void SetBoundaryP(boundary_type* _boundary) { _Boundary = _boundary; }
  inline boundary_type* GetBoundaryP() { return _Boundary; }
  inline boundary_type& Boundary() { assert (_Boundary!=0); return *_Boundary; }
  inline const boundary_type& Boundary() const { assert (_Boundary!=0); return *_Boundary; }

  inline void SetLevelSetP(levelset_type* _levelset) { _LevelSet = _levelset; }
  inline levelset_type* GetLevelSetP() { return _LevelSet; }
  inline levelset_type& LevelSet() { assert (_LevelSet!=0); return *_LevelSet; }
  inline const levelset_type& LevelSet() const { assert (_LevelSet!=0); return *_LevelSet; }

  inline void SetBoundaryConditionsP(boundary_conditions_type* boundary_conditions) 
  { _BoundaryConditions = boundary_conditions; }
  inline boundary_conditions_type* GetBoundaryConditionsP() { return _BoundaryConditions; }
  inline boundary_conditions_type& BoundaryConditions_() 
  { assert (_BoundaryConditions!=0); return *_BoundaryConditions; }
  inline const boundary_conditions_type& BoundaryConditions_() const 
  { assert (_BoundaryConditions!=0); return *_BoundaryConditions; }

  inline void SetGridFunctions(vec_grid_fct_type* u, vec_grid_fct_type* ush) {
    _u = u; _u_sh = ush;
  }
  inline vec_grid_fct_type& U() { return *_u; }
  inline const vec_grid_fct_type& U() const { return *_u; }
  inline vec_grid_fct_type& Ush() { return *_u_sh; }
  inline const vec_grid_fct_type& Ush() const { return *_u_sh; }

protected:
  boundary_type* _Boundary;
  levelset_type* _LevelSet;
  grid_fct_type *_phi, *_phi_sh;
  boundary_conditions_type* _BoundaryConditions;
  boundary_functor_type* _BoundaryFunc;
  vec_grid_fct_type *_u, *_u_sh;
  char phiName[DAGHBktGFNameWidth], phiNamesh[DAGHBktGFNameWidth];
  bool _EstimateError;
  int _Ignore;
  std::string _myprefix;
};


#endif

---