WENOF77GFMFileOutput.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, Carlos Pantano

#ifndef AMROC_WENO_F77_GFM_FILEOUTPUT_H
#define AMROC_WENO_F77_GFM_FILEOUTPUT_H

#include "F77Interfaces/F77FileOutput.h"
#include "GFMFileOutput.h"
#include "F77Interfaces/F77GFMFileOutput.h"

template <class VectorType, class FixupType, class FlagType, int dim>
class WENOF77GFMFileOutput : public F77OutBase<VectorType,dim>,
  public GFMFileOutput<VectorType,FixupType,FlagType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef GFMFileOutput<VectorType,FixupType,FlagType,dim> base;
  typedef F77OutBase<VectorType,dim> out_base;
public:
  typedef typename base::vec_grid_fct_type vec_grid_fct_type;  
  typedef typename base::vec_grid_data_type vec_grid_data_type;  
  typedef typename base::grid_fct_type grid_fct_type;
  typedef typename base::grid_data_type grid_data_type;
  typedef typename base::gfm_solver_type gfm_solver_type;
  typedef typename out_base::generic_func_type generic_func_type;

  typedef void (*out_1_func_type) ( FI(1,VectorType), FI(1,DataType), BI, 
                                    const INTEGER& meqn, 
                                    const INTEGER& cnt, const DOUBLE& t );
  typedef void (*out_2_func_type) ( FI(2,VectorType), FI(2,DataType), BI, 
                                    const INTEGER& meqn, 
                                    const INTEGER& cnt, const DOUBLE& t );
  typedef void (*out_3_func_type) ( FI(3,VectorType), FI(3,DataType), BI, 
                                    const INTEGER& meqn, 
                                    const INTEGER& cnt, const DOUBLE& t );

   typedef void (*bnds_func_type) (INTEGER ix[], DOUBLE lbc[], DOUBLE ubc[], 
                                  DOUBLE dx[], const DOUBLE* bnd, 
                                  const INTEGER& mb, const INTEGER per[]);

  WENOF77GFMFileOutput(gfm_solver_type& solver, generic_func_type out,
                       generic_func_type bnds = 0) : 
    out_base(out), base(solver), f_bnds(bnds) {}

  virtual ~WENOF77GFMFileOutput() {}
  
  virtual void WriteOut(vec_grid_fct_type& u, grid_fct_type& IOfunc) {
    if (!out_base::f_out) return;    
    for (int cnt=1; cnt<=base::Ncnt(); cnt++) { 
      if (base::CompName[cnt-1].c_str()[0] == '-') 
        continue;
      for (int lev=0; lev<=FineLevel(base::GH()); lev++) {
        int Time = CurrentTime(base::GH(),lev); 
        double t = GetPhysicalTime(u,Time,lev);
        Transform(u,IOfunc,Time,lev,cnt,t);
        base::WriteOut(IOfunc,base::CompName[cnt-1].c_str(),Time,lev,t);
      }
#ifndef DAGH_NO_MPI
      MPI_Barrier(comm_service::comm()); 
#endif
    }
  }

  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) 
  { base::WriteOut(IOfunc,name,Time,Level,t); }

  virtual void WriteOut(grid_data_type& IOdata, const char* name, 
                        const int& Time, const int& Level, const double& t) {
    base::WriteOut(IOdata,name,Time,Level,t);
  }

  virtual void Transform(vec_grid_fct_type& u, grid_fct_type& work, 
                         const int Time, const int& Level, 
                         const int cnt, const double& t) {
    if (!out_base::f_out) return;    
    
    forall(u,Time,Level,c)
      vec_grid_data_type& u_old = u(Time, Level, c);
      BBox bb = u_old.bbox();

      if (f_bnds) {
        int mx[dim], d, per[dim];
        Coords ex = u_old.extents();
        for (d=0; d<dim; d++) { 
          mx[d] = ex(d)-2*base::NGhosts();
          per[d] = base::GH().periodicboundary(d);
        }
        
        DCoords dx = base::GH().worldStep(u_old.stepsize());
        DCoords lbc = base::GH().worldCoords(u_old.lower(), u_old.stepsize());
        DCoords ubc = base::GH().worldCoords(u_old.upper(), u_old.stepsize());
        
        ((bnds_func_type) f_bnds)(mx,lbc(),ubc(),dx(),base::GH().wholebndry(),
                                  base::GH().nbndry(),per);
      }

      if (dim == 1) 
        ((out_1_func_type) out_base::f_out)(FA(1,u(Time,Level,c)),
                                  FA(1,work(Time,Level,c)),
                                  BOUNDING_BOX(bb),out_base::_Equations,cnt,t);
      else if (dim == 2) 
        ((out_2_func_type) out_base::f_out)(FA(2,u(Time,Level,c)),
                                  FA(2,work(Time,Level,c)),
                                  BOUNDING_BOX(bb),out_base::_Equations,cnt,t);
      else if (dim == 3) 
        ((out_3_func_type) out_base::f_out)(FA(3,u(Time,Level,c)),
                                  FA(3,work(Time,Level,c)),
                                  BOUNDING_BOX(bb),out_base::_Equations,cnt,t);
    end_forall 
  }
protected:
generic_func_type f_bnds;
};

#endif