F77GFMLevelSet.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_GFMLEVELSET_H
#define AMROC_F77_GFMLEVELSET_H

#include "GFMLevelSet.h"

template <class DataType, int dim>
class F77GFMLevelSet : public GFMLevelSet<DataType,dim> {
  typedef GFMLevelSet<DataType,dim> base;

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

  typedef generic_fortran_func generic_func_type; 

  typedef void (*lset_1_func_type) ( const INTEGER& maxmx, 
                                     const INTEGER& mbc,
                                     const INTEGER& mx, 
                                     const DOUBLE x[], 
                                     const DOUBLE& dx, 
                                     DataType q[], const DOUBLE& t); 
  typedef void (*lset_2_func_type) ( const INTEGER& maxmx, const INTEGER& maxmy, 
                                     const INTEGER& mbc,
                                     const INTEGER& mx, const INTEGER& my, 
                                     const DOUBLE x[], const DOUBLE y[], 
                                     const DOUBLE& dx, const DOUBLE& dy, 
                                     DataType q[], const DOUBLE& t);
  typedef void (*lset_3_func_type) ( const INTEGER& maxmx, const INTEGER& maxmy, const INTEGER& maxmz,
                                     const INTEGER& mbc,
                                     const INTEGER& mx, const INTEGER& my, const INTEGER& mz,
                                     const DOUBLE x[], const DOUBLE y[], const DOUBLE z[],
                                     const DOUBLE& dx, const DOUBLE& dy, const DOUBLE& dz, 
                                     DataType q[], const DOUBLE& t);

  F77GFMLevelSet() : base(), f_lset(0), inverse(0) {}
  F77GFMLevelSet(generic_func_type lset) : base(), f_lset(lset), inverse(0) {}

  virtual ~F77GFMLevelSet() {}
  
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::LocCtrl = Ctrl.getSubDevice(prefix+"F77LevelSet");
    RegisterAt(base::LocCtrl,"PlotPhi",base::_PlotPhi);
    RegisterAt(base::LocCtrl,"Stationary",base::_Stationary);
    RegisterAt(base::LocCtrl,"Inverse",inverse);
  } 
  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl, "");
  }

  virtual void SetGrid(grid_data_type& gdphi, const int& level, const double& t) {   
    assert(f_lset != (generic_func_type) 0);
    Coords ex = gdphi.extents();
    DCoords lbcorner = base::GH().worldCoords(gdphi.lower(), gdphi.stepsize());
    DCoords dx = base::GH().worldStep(gdphi.stepsize());
    int maxm[3], mx[3], d;
    DataType* x[3];
    for (d=0; d<dim; d++) {
      maxm[d] = ex(d);
      mx[d] = ex(d)-2*base::NGhosts();
      x[d] = new DataType[maxm[d]];
      for (int i=0; i<maxm[d]; i++) x[d][i] = (i+0.5)*dx(d)+lbcorner(d);
    }

    if (dim == 1) 
      ((lset_1_func_type) f_lset)(AA(1,mx), base::NGhosts(), AA(1,mx), 
                                  AA(1,x), AA(1,dx), gdphi.data(), t); 
    else if (dim == 2)
      ((lset_2_func_type) f_lset)(AA(2,mx), base::NGhosts(), AA(2,mx), 
                                  AA(2,x), AA(2,dx), gdphi.data(), t);
    else if (dim == 3)
      ((lset_3_func_type) f_lset)(AA(3,mx), base::NGhosts(), AA(3,mx), 
                                  AA(3,x), AA(3,dx), gdphi.data(), t);

    if (inverse) gdphi.multiply(-1.0);

    for (d=0; d<dim; d++) 
      delete [] x[d];
  }

  inline void SetFunc(generic_func_type lset) { f_lset = lset; }
  generic_func_type GetFunc() const { return f_lset; }

protected:
  generic_func_type f_lset;
  int inverse; 
};


#endif

---