GFMFileOutput.h

Go to the documentation of this file.

// -*- C++ -*-

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

#ifndef AMROC_GFM_FILE_OUTPUT_H
#define AMROC_GFM_FILE_OUTPUT_H

#include "FileOutput.h"

template <class VectorType, class FixupType, class FlagType, int dim>
class GFMFileOutput : public FileOutput<VectorType,dim> {
  typedef FileOutput<VectorType,dim> base;
  typedef typename VectorType::InternalDataType DataType;

public:
  typedef typename base::vec_grid_fct_type vec_grid_fct_type;  
  typedef typename base::grid_fct_type grid_fct_type;
  typedef typename base::grid_data_type grid_data_type;

  typedef AMRGFMSolver<VectorType,FixupType,FlagType,dim> gfm_solver_type;
  typedef GridFunction<bool,dim> bool_grid_fct_type;  
  typedef GhostFluidMethod<VectorType,dim> gfm_type;

  GFMFileOutput(gfm_solver_type& solver) : base(), _solver(solver), CutOut(1), CutOutValue(-1.e37) {} 

  virtual ~GFMFileOutput() {}

  virtual void register_at(ControlDevice& Ctrl) { base::register_at(Ctrl, ""); }
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::register_at(Ctrl, prefix);
    RegisterAt(base::LocCtrl,"CutOut",CutOut);
    RegisterAt(base::LocCtrl,"CutOutValue",CutOutValue); 
  }

  virtual void WriteOut(vec_grid_fct_type& u, grid_fct_type& IOfunc) 
  { base::WriteOut(u,IOfunc); }  

  virtual void WriteOut(grid_fct_type& IOfunc, const char* name) 
  { base::WriteOut(IOfunc,name); }  

  virtual void WriteOut(grid_fct_type& IOfunc, const char* name, 
                        const int& Time, const int& Level, const double& t) {
    if (CutOut) {
      forall (IOfunc,Time,Level,c)           
        for (int g=0; g<NGFM(); g++) {
          if (!GFM(g).IsUsed()) continue;
          if (base::Dim() == 1) {
            BeginFastIndex1(bf, BF()(Time,Level,c).bbox(),
                            BF()(Time,Level,c).data(), bool);
            BeginFastIndex1(IO, IOfunc(Time,Level,c).bbox(),
                            IOfunc(Time,Level,c).data(), DataType);
            for_1 (n, BF()(Time,Level,c).bbox(), BF()(Time,Level,c).bbox().stepsize())
              if (FastIndex1(bf,n)) 
                FastIndex1(IO,n) = CutOutValue;
            end_for
            EndFastIndex1(IO);
            EndFastIndex1(bf);
          }      
          else if (base::Dim() == 2) {
            BeginFastIndex2(bf, BF()(Time,Level,c).bbox(),
                            BF()(Time,Level,c).data(), bool);
            BeginFastIndex2(IO, IOfunc(Time,Level,c).bbox(),
                            IOfunc(Time,Level,c).data(), DataType);
            for_2 (n, m, BF()(Time,Level,c).bbox(), BF()(Time,Level,c).bbox().stepsize())
              if (FastIndex2(bf,n,m)) 
                FastIndex2(IO,n,m) = CutOutValue;
            end_for
            EndFastIndex2(IO);
            EndFastIndex2(bf);
          }
          else if (base::Dim() == 3) {
            BeginFastIndex3(bf, BF()(Time,Level,c).bbox(),
                            BF()(Time,Level,c).data(), bool);
            BeginFastIndex3(IO, IOfunc(Time,Level,c).bbox(),
                            IOfunc(Time,Level,c).data(), DataType);
            for_3 (n, m, l, BF()(Time,Level,c).bbox(), BF()(Time,Level,c).bbox().stepsize())
              if (FastIndex3(bf,n,m,l)) 
                FastIndex3(IO,n,m,l) = CutOutValue;
            end_for
            EndFastIndex3(IO);
            EndFastIndex3(bf);
          }
        }
      end_forall
    }      
    base::WritePlain(IOfunc,name,Time,Level,t);
  }   

  virtual void WriteOut(grid_data_type& IOdata, const char* name, 
                        const int& Time, const int& Level, const double& t) {
    if (CutOut) {
      BBox bb = IOdata.bbox();
      grid_data_type phi(bb);
      for (int g=0; g<NGFM(); g++) {
        if (!GFM(g).IsUsed()) continue;
        GFM(g).LevelSet().SetGrid(phi,Level,t);   
        if (base::Dim() == 1) {
          BeginFastIndex1(phi, bb, phi.data(), DataType);
          BeginFastIndex1(IO, bb, IOdata.data(), DataType);
          for_1 (n, bb, bb.stepsize())
            if (FastIndex1(phi,n)<-Cutoff(g) && 
                FastIndex1(phi,n)>=-FarAway(g) && FastIndex1(phi,n)<=FarAway(g)) 
              FastIndex1(IO,n) = CutOutValue;
          end_for
          EndFastIndex1(IO);
          EndFastIndex1(phi);
        }      
        else if (base::Dim() == 2) {
          BeginFastIndex2(phi, bb, phi.data(), DataType);
          BeginFastIndex2(IO, bb, IOdata.data(), DataType);
          for_2 (n, m, bb, bb.stepsize())
            if (FastIndex2(phi,n,m)<-Cutoff(g) && 
                FastIndex2(phi,n,m)>=-FarAway(g) && FastIndex2(phi,n,m)<=FarAway(g)) 
              FastIndex2(IO,n,m) = CutOutValue;
          end_for
          EndFastIndex2(IO);
          EndFastIndex2(phi);
        }
        else if (base::Dim() == 3) {
          BeginFastIndex3(phi, bb, phi.data(), DataType);
          BeginFastIndex3(IO, bb, IOdata.data(), DataType);
          for_3 (n, m, l, bb, bb.stepsize())
            if (FastIndex3(phi,n,m,l)<-Cutoff(g) && 
                FastIndex3(phi,n,m,l)>=-FarAway(g) && FastIndex3(phi,n,m,l)<=FarAway(g)) 
              FastIndex3(IO,n,m,l) = CutOutValue;
          end_for
          EndFastIndex3(IO);
          EndFastIndex3(phi);
        }
      }
    }      
    base::WritePlain(IOdata,name,Time,Level,t);
  }

  inline bool_grid_fct_type& BF() { return _solver.BF(); }
  inline const bool_grid_fct_type& BF() const { return _solver.BF(); }
  inline gfm_type& GFM(const int& n) { return _solver.GFM(n); }
  inline const int& NGFM() { return _solver.NGFM(); }
  inline grid_fct_type& Phi(const int& n) { return GFM(n).Phi(); }
  inline const grid_fct_type& Phi(const int& n) const { return GFM(n).Phi(); }
  inline const DataType& Cutoff(const int& n) { return GFM(n).Boundary().Cutoff(); }
  inline const DataType& FarAway(const int& n) { return GFM(n).Boundary().FarAway(); }
protected:
  gfm_solver_type& _solver;
  int CutOut;
  DataType CutOutValue;
};


#endif

---