F77FileInput.h

Go to the documentation of this file.

// -*- C++ -*-

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

#ifndef AMROC_F77_FILEINPUT_H
#define AMROC_F77_FILEINPUT_H

#include "FileInput.h"
#include "F77Interfaces/F77FileOutput.h"

template <class VectorType, int dim>
class F77InBase {
  typedef typename VectorType::InternalDataType DataType;
  typedef GridFunction<VectorType,dim> vec_grid_fct_type;  
  typedef GridFunction<DataType,dim> grid_fct_type;  
  typedef generic_fortran_func generic_func_type;
public:
  typedef void (*in_1_func_type) ( FI(1,DataType), FI(1,VectorType), BI, const INTEGER& meqn, 
                                   const INTEGER& cnt, const DOUBLE& t );
  typedef void (*in_2_func_type) ( FI(2,DataType), FI(2,VectorType), BI, const INTEGER& meqn, 
                                   const INTEGER& cnt, const DOUBLE& t );
  typedef void (*in_3_func_type) ( FI(3,DataType), FI(3,VectorType), BI, const INTEGER& meqn, 
                                   const INTEGER& cnt, const DOUBLE& t );

  F77InBase(generic_func_type in) : f_in(in), _Equations(VectorType::Length()) {}

  virtual ~F77InBase() {}
  
  virtual void Transform(grid_fct_type& work, vec_grid_fct_type& u, const int Time, const int& Level, 
                         const int cnt, const double& t) {
    if (!f_in) return;    
    forall(u,Time,Level,c)
      BBox bb = u.interiorbbox(Time,Level,c);
      if (dim == 1) 
        ((in_1_func_type) f_in)(FA(1,work(Time,Level,c)),FA(1,u(Time,Level,c)),
                                BOUNDING_BOX(bb),_Equations,cnt,t);
      else if (dim == 2) 
        ((in_2_func_type) f_in)(FA(2,work(Time,Level,c)),FA(2,u(Time,Level,c)),
                                BOUNDING_BOX(bb),_Equations,cnt,t);
      else if (dim == 3) 
        ((in_3_func_type) f_in)(FA(3,work(Time,Level,c)),FA(3,u(Time,Level,c)),
                                BOUNDING_BOX(bb),_Equations,cnt,t);
    end_forall 
  }

  inline void SetInFunc(generic_func_type in) { f_in = in; }
  generic_func_type GetInFunc() const { return f_in; }

protected:
  generic_func_type f_in;
  int _Equations;
};


template <class VectorType, int dim>
class F77FileInput : public F77OutBase<VectorType,dim>, public F77InBase<VectorType,dim>,
  public FileInput<VectorType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef FileInput<VectorType,dim> base;
  typedef F77OutBase<VectorType,dim> out_base;
  typedef F77InBase<VectorType,dim> in_base;
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 typename out_base::generic_func_type generic_func_type;

  F77FileInput(generic_func_type in) : 
  out_base(0), in_base(in), base() {}

  F77FileInput(generic_func_type out, generic_func_type in) : 
  out_base(out), in_base(in), base() {}

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

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

  virtual void ReadIn(grid_fct_type& IOfunc, const char* name, 
                      const int& Time, const int& Level) 
  { base::ReadIn(IOfunc,name,Time,Level); }

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

  inline void SetInFunc(generic_func_type in) { in_base::SetInFunc(in); }
  generic_func_type GetInFunc() const { return in_base::GetInFunc(); }
  inline void SetOutFunc(generic_func_type out) { out_base::SetOutFunc(out); }
  generic_func_type GetOutFunc() const { return out_base::GetOutFunc(); }
};

#endif      

---