amroc/amr/Interfaces/SchemeIntegrator.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2013 Oak Ridge National Laboratory
// Ralf Deiterding, deiterdingr@ornl.gov

#ifndef SCHEME_INTEGRATOR_H
#define SCHEME_INTEGRATOR_H

#include "Integrator.h"

template <class SchemeType, int dim>
class SchemeIntegrator : public Integrator<typename SchemeType::VectorType,dim> {
  typedef Integrator<typename SchemeType::VectorType,dim> base;
public:   
  typedef typename SchemeType::VectorType VectorType;
  typedef typename VectorType::InternalDataType DataType;
  typedef typename base::vec_grid_data_type vec_grid_data_type;

  SchemeIntegrator(SchemeType &scheme) : base(), _scheme(scheme), _check(0) { 
    FluxData = (VectorType*) 0;  
  }

  virtual ~SchemeIntegrator() {
    if (FluxData) {
      delete [] FluxData;
      FluxData = (VectorType*) 0;
    }  
  }

  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    ControlDevice LocCtrl = Ctrl.getSubDevice(prefix+"Integrator");
    RegisterAt(LocCtrl,"Check",_check);
    Scheme().register_at(LocCtrl,prefix);
  }
  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl, "");
  }
  virtual void init() {
    base::init();
    Scheme().init(); 
  }
  virtual void update() {
    base::update();
    Scheme().update();   
  }
  virtual void finish() {
    base::finish();
    Scheme().finish();       
  } 
   
  virtual void SetupData(GridHierarchy* gh, const int& ghosts) {  
    base::SetupData(gh,ghosts);
    base::SetMaxIntegratorPasses(NMaxPass());
    base::_abort = (NCheck()>=10 ? DAGHTrue : DAGHFalse);
    Scheme().SetupData(gh,ghosts);
  }

  virtual double CalculateGrid(vec_grid_data_type& NewStateVec, 
                               vec_grid_data_type& OldStateVec,
                               vec_grid_data_type* Flux[],
                               const int& level, const double& t, 
                               const double& dt, const int& mpass) {
    if (NCheck()>0)
      base::CheckGrid(OldStateVec, level, OldStateVec.bbox(), t, "CalculateGrid::before Step");

    if (NMaxPass()==0 || mpass==1) 
      NewStateVec.copy(OldStateVec);

    double cfl = Scheme().Step(NewStateVec,OldStateVec,Flux,t,dt,mpass);
    
    if (NCheck()%10>1)
      base::CheckGrid(NewStateVec, level, NewStateVec.bbox(), t, "CalculateGrid::after Step");

    return cfl;
  } 

  virtual void AllocGridFluxes(const BBox &bb, vec_grid_data_type**& Flux) {
    // The solver assumes a CONSECUTIVE array for the fluxes in ALL directions!
    // We need a member variable to store it between different member function calls.
    FluxData = new VectorType[base::Dim()*bb.size()];
    Flux = new vec_grid_data_type* [2*base::Dim()]; 
    for (register int d=0; d<base::Dim(); d++) {
      Flux[2*d] = new vec_grid_data_type(bb,&(FluxData[d*bb.size()])); 
      Flux[2*d+1] = Flux[2*d];
    }
  }

  virtual void DeAllocGridFluxes(vec_grid_data_type**& Flux) {
    if (Flux) {
      VectorType* dummy;
      for (register int d=0; d<base::Dim(); d++) 
        if (Flux[2*d]) {
          // Erease pointer to data
          Flux[2*d]->deallocate(dummy);
          delete Flux[2*d];
        }
      delete [] Flux;
    }
    if (FluxData) {
      delete [] FluxData;
      FluxData = (VectorType*) 0;
    }
  }
    
  virtual void ResetGridFluxes(vec_grid_data_type**& Flux) {
    if (Flux) {
      VectorType zero(0.0);
      for (register int d=0; d<base::Dim(); d++) 
        if (Flux[2*d]) 
          Flux[2*d]->equals(zero);
    }
  }

  virtual int ControlGrid(vec_grid_data_type& StateVec, const int& level, 
                          const BBox& where, const double& time, const int verbose) 
  { return Scheme().Check(StateVec,where,time,verbose); }  

  inline const int& NCheck() const { return _check; }
  virtual int NMethodOrder() const { return Scheme().NMethodOrder(); }
  inline int NMaxPass() const { return Scheme().NMaxPass(); }

  inline SchemeType& Scheme() { return _scheme; }
  inline const SchemeType& Scheme() const { return _scheme; }
  
protected:
  SchemeType &_scheme;
  int _check;
  VectorType* FluxData;
};


#endif

---