amroc/amr/F77Interfaces/F77ExactSolution.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2002 Ralf Deiterding
// Brandenburgische Universitaet Cottbus
//
// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@cacr.caltech.edu

#ifndef AMROC_F77_EXACT_SOLUTION_H
#define AMROC_F77_EXACT_SOLUTION_H

#include "ExactSolution.h"

template <class VectorType, int dim>
class F77ExactBase {
  typedef typename VectorType::InternalDataType DataType;
  typedef GridData<VectorType,dim> vec_grid_data_type;
  typedef GridData<DataType,dim> grid_data_type;

public:
  typedef generic_fortran_func generic_func_type; 

  typedef void (*exact_1_func_type) ( const INTEGER& maxmx, 
                                      const INTEGER& meqn, const INTEGER& mbc,
                                      const INTEGER& mx, 
                                      const DOUBLE x[], 
                                      const DOUBLE& dx, 
                                      const DOUBLE& t, VectorType q[]); 
  typedef void (*exact_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, 
                                      const DOUBLE& t, VectorType q[]);
  typedef void (*exact_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, 
                                      const DOUBLE& t, VectorType q[]);

  F77ExactBase() : f_exact(0), _Equations(VectorType::Length()) {}
  F77ExactBase(generic_func_type exact) : f_exact(exact), _Equations(VectorType::Length()) {}

  void SetGrid(GridHierarchy& GH, const int& NGhosts, vec_grid_data_type& gd, 
               grid_data_type& gdw, const int& level, double t) {
    assert(f_exact != (generic_func_type) 0);
    Coords ex = gd.extents();
    DCoords lbcorner = GH.worldCoords(gd.lower(), gd.stepsize());
    DCoords dx = 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*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) 
      ((exact_1_func_type) f_exact)(AA(1,mx),_Equations, NGhosts, 
                                    AA(1,mx), AA(1,x), AA(1,dx), t, gd.data()); 
    else if (dim == 2)
      ((exact_2_func_type) f_exact)(AA(2,mx),_Equations, NGhosts, 
                                    AA(2,mx), AA(2,x), AA(2,dx), t, gd.data());
    else if (dim == 3)
      ((exact_3_func_type) f_exact)(AA(3,mx),_Equations, NGhosts, 
                                    AA(3,mx), AA(3,x), AA(3,dx), t, gd.data());

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

  inline void SetFunc(generic_func_type exact) { f_exact = exact; }
  generic_func_type GetFunc() const { return f_exact; }

protected:
  generic_func_type f_exact;
  int _Equations;
};

template <class VectorType, int dim>
class F77ExactSolution : public F77ExactBase<VectorType,dim>,
  public ExactSolution<VectorType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef ExactSolution<VectorType,dim> base;
  typedef F77ExactBase<VectorType,dim> exact_base;

public:
  typedef typename base::vec_grid_data_type vec_grid_data_type;
  typedef typename base::grid_data_type grid_data_type;
  typedef typename exact_base::generic_func_type generic_func_type;

  F77ExactSolution() : exact_base(), base() {}
  F77ExactSolution(generic_func_type exact) : exact_base(exact), base() {}

  virtual ~F77ExactSolution() {}
  
  virtual void SetGrid(vec_grid_data_type& gd, grid_data_type& gdw, 
                       const int& level, const double& t) {
    exact_base::SetGrid(base::GH(),base::NGhosts(),gd,gdw,level,t);
  }
};


#endif

---