amroc/amr/F77Interfaces/F77LevelSetInitialCondition.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2008 Ralf Deiterding
// Brandenburgische Universitaet Cottbus

#ifndef AMROC_F77_LEVELSETINITIALCONDITION_H
#define AMROC_F77_LEVELSETINITIALCONDITION_H

#include "InitialCondition.h"
#include "GFMLevelSet.h"

template <class VectorType, int dim>
class F77LevelSetInitialCondition : public InitialCondition<VectorType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef InitialCondition<VectorType,dim> 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 GFMLevelSet<DataType,dim> levelset_type;

  typedef generic_fortran_func generic_func_type; 

  typedef void (*init_1_func_type) ( const INTEGER& maxmx, 
                                     const INTEGER& meqn, const INTEGER& mbc,
                                     const INTEGER& mx, 
                                     const DOUBLE x[], 
                                     const DOUBLE& dx, 
                                     VectorType q[], DataType phi[]); 
  typedef void (*init_2_func_type) ( const INTEGER& maxmx, const INTEGER& maxmy, 
                                     const INTEGER& meqn, const INTEGER& mbc,
                                     const INTEGER& mx, const INTEGER& my, 
                                     const DOUBLE x[], const DOUBLE y[], 
                                     const DOUBLE& dx, const DOUBLE& dy, 
                                     VectorType q[], DataType phi[]);
  typedef void (*init_3_func_type) ( const INTEGER& maxmx, const INTEGER& maxmy, const INTEGER& maxmz,
                                     const INTEGER& meqn, 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, 
                                     VectorType q[], DataType phi[]);

  F77LevelSetInitialCondition() : base(), _LevelSet(0), f_init(0) {}
  F77LevelSetInitialCondition(generic_func_type init) : base(), 
    _LevelSet(0), f_init(init) {}

  virtual ~F77LevelSetInitialCondition() {
    if (_LevelSet) delete _LevelSet;
  }
  
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::LocCtrl = Ctrl.getSubDevice(prefix+"InitialCondition");
    if (_LevelSet) LevelSet().register_at(base::LocCtrl,"");
  }
  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl, "");
  }

  virtual void SetupData(GridHierarchy* gh, const int& ghosts) {
    base::SetupData(gh,ghosts);
    if (_LevelSet) LevelSet().SetupData(gh,ghosts);
  }

  virtual void SetGrid(vec_grid_data_type& gd, grid_data_type& gdw, const int& level) {   
    assert(f_init != (generic_func_type) 0);
    Coords ex = gd.extents();
    DCoords lbcorner = base::GH().worldCoords(gd.lower(), gd.stepsize());
    DCoords dx = base::GH().worldStep(gd.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) 
      ((init_1_func_type) f_init)(AA(1,mx),base::NEquations(), base::NGhosts(), 
                                  AA(1,mx), AA(1,x), AA(1,dx), gd.data(), gdw.data()); 
    else if (dim == 2)
      ((init_2_func_type) f_init)(AA(2,mx),base::NEquations(), base::NGhosts(), 
                                  AA(2,mx), AA(2,x), AA(2,dx), gd.data(), gdw.data());
    else if (dim == 3)
      ((init_3_func_type) f_init)(AA(3,mx),base::NEquations(), base::NGhosts(), 
                                  AA(3,mx), AA(3,x), AA(3,dx), gd.data(), gdw.data());

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

  virtual void Set(vec_grid_fct_type& u, grid_fct_type& work, const int Level) {
    if (_LevelSet) LevelSet().SetPhi(work,0,Level,0.0);
    base::Set(u,work,Level);
  }

  inline void SetLevelSet(levelset_type* _levelset) { _LevelSet = _levelset; }
  inline levelset_type& LevelSet() { assert (_LevelSet!=0); return *_LevelSet; }
  inline const levelset_type& LevelSet() const { assert (_LevelSet!=0); return *_LevelSet; }

  inline void SetFunc(generic_func_type init) { f_init = init; }
  generic_func_type GetFunc() const { return f_init; }

protected:
  levelset_type* _LevelSet;
  generic_func_type f_init;
};


#endif

---