RefinePhi.h

Go to the documentation of this file.

// -*- C++ -*-

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

#ifndef AMROC_REFINEPHI_H
#define AMROC_REFINEPHI_H

#include "Criteria/ResolvePhi.h"

template <class VectorType, class Fixup, class FlagType, int dim>
class RefinePhi : 
  public PhiCriterion<VectorType,FlagType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef PhiCriterion<VectorType,FlagType,dim> base;
public:
  typedef AMRGFMSolver<VectorType,FixupType,FlagType,dim> gfm_solver_type;
  typedef GhostFluidMethod<VectorType,dim> gfm_type;
  typedef typename base::vec_grid_fct_type vec_grid_fct_type;  
  typedef typename base::grid_fct_type grid_fct_type;
  typedef typename base::flag_fct_type flag_fct_type;
  typedef typename base::max_vector_type max_vector_type;

  RefinePhi(gfm_solver_type& solver) : base(), _solver(solver) {
    base::SetShadowCriterion(false);
    for (register int i=0; i<MAXCOMPONENTS; i++) {
      Use[i] = 0;
    }
  }

  virtual ~RefinePhi() {}
  
  virtual void register_at(ControlDevice& Ctrl) {}
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::LocCtrl = Ctrl.getSubDevice(prefix+"RefinePhi");
    char Name[16];
    for (int d=0; d<max_vector_type::Length(); d++) {
      std::sprintf(Name,"Use(%d)",d+1);
      RegisterAt(base::LocCtrl,Name,Use[d]);
      std::sprintf(Name,"MaxLev(%d)",d+1);
      RegisterAt(base::LocCtrl,Name,base::_MaxLevel[d]);
    }    
    RegisterAt(base::LocCtrl,"Output",base::_Output);
  }

  virtual void update() { 
    int d=max_vector_type::Length();
    for (; d>0; d--) 
      if (Use[d-1] > 0) 
        break;
    if (d>0) {
      base::SetNcnt(d);
      base::SetIsUsed(true);
    }
    else 
      base::SetIsUsed(false);
  }

  virtual bool SetFlags(vec_grid_fct_type& u, grid_fct_type& work, flag_fct_type& flags, 
                        const int& cnt, const int& Time, const int& Level, const double& t, 
                        const FlagType& FlagValue) {

    if (Use[cnt] <= 0 || cnt>=NGFM() || !GFM(cnt).IsUsed()) return false;
    int TStep = TimeStep(work,Level);
    if (base::MaxLevel(cnt)<Level && base::MaxLevel(cnt)>=0) {
      if (base::OutputFlags()) {
        forall(work,Time,Level,c)
          work(Time+TStep,Level,c) = static_cast<DataType>(0.0);
        end_forall 
      }
      return true;
    }

    DataType MaxDistance=0.0, md;
    forall(work,Time+TStep,Level,c)
      work(Time+TStep,Level,c).equals((GFM(cnt).Phi())(Time,Level,c));
      DCoords dx = base::GH().worldStep((GFM(cnt).Phi())(Time,Level,c).stepsize());
      md = 0.0;
      for (register int d=0; d<dim; d++) 
        md += dx(d)*dx(d);
      md = std::sqrt(md)-GFM(cnt).Boundary().Cutoff();
      if (md>MaxDistance) MaxDistance=md;
    end_forall 

    base::FlagByValue(work, flags, Time, Level, MaxDistance, FlagValue, 1);
    
    return true;
  }

  inline gfm_type& GFM(const int& n) { return _solver.GFM(n); }
  inline const int& NGFM() { return _solver.NGFM(); }

  virtual void OutputName(char* name, int cnt) { 
    std::sprintf(name,"refine_phi_%d",cnt+1); 
  }

protected:
  gfm_solver_type _solver;
  int Use[MAXCOMPONENTS];
};

#endif

---