amroc/amr/F77Interfaces/F77InitialCondition.h

Go to the documentation of this file.

// -*- C++ -*-

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

#ifndef AMROC_F77_INITIALCONDITION_H
#define AMROC_F77_INITIALCONDITION_H

#include "InitialCondition.h"

template <class VectorType, int dim>
class F77InitialCondition : 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 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[]); 
  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[]);
  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[]);

  F77InitialCondition() : base(), f_init(0) {}
  F77InitialCondition(generic_func_type init) : base(), f_init(init) {}

  virtual ~F77InitialCondition() {}
  
  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()); 
    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());
    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());

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

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

protected:
  generic_func_type f_init;
};


#endif

---