FixupBase.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@amroc.net

#ifndef AMROC_FIXUP_BASE_H
#define AMROC_FIXUP_BASE_H

#include "GridFunction.h"
#include <string>
#include "AMRBase.h"

template <int dim> class minus_1;

template <> class minus_1<1> { 
public:
  static const int dim = 1;
};

template <> class minus_1<2> { 
public:
  static const int dim = 1;
};

template <> class minus_1<3> { 
public:
  static const int dim = 2;
};


template <class VectorType, class FixupType, int dim>
class FixupBase : public AMRBase<VectorType,dim> {
  typedef AMRBase<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 GridData<VectorType,minus_1<dim>::dim> ld_vec_grid_data_type;
  typedef GridData<FixupType,minus_1<dim>::dim>  ld_fixup_grid_data_type;
  typedef GridFunction<FixupType,minus_1<dim>::dim> ld_fixup_grid_fct_type;  

  FixupBase() : base(), _FixupEquations(FixupType::Length()) {    
    for (int d=0; d<dim; d++) {
      _f[2*d] = (ld_fixup_grid_fct_type *) 0;
      _f[2*d+1] = (ld_fixup_grid_fct_type *) 0;
      _f_name[2*d] = (char *) 0;
      _f_name[2*d+1] = (char *) 0;
    }
  }

  virtual ~FixupBase() {
    for (int d=0; d<dim; d++) {
      if (_f[2*d]) delete _f[2*d];
      if (_f_name[2*d]) delete [] _f_name[2*d];
      if (_f[2*d+1]) delete _f[2*d+1];
      if (_f_name[2*d+1]) delete [] _f_name[2*d+1];
    }
  }

  //******************************************************************************
  // Abstract class interface
  //******************************************************************************
  virtual void SaveFluxes(const int Time, const int Level, const int c,
                          vec_grid_data_type* flux[], const double dt,
                          const int& mdim) = 0;
  virtual void AddFluxes(const int Time, const int Level, const int c,
                         vec_grid_data_type* flux[], const double tc, 
                         const double tf, const double dt, const int& mdim) = 0;
  virtual void Correction(const int Time, const int WTime, const int Level) = 0;
  //******************************************************************************

  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::LocCtrl = Ctrl.getSubDevice(prefix+"FixupBase");
  }
  virtual void register_at(ControlDevice& Ctrl) { register_at(Ctrl,""); }
  virtual void finish() {
    for (int d=0; d<dim; d++) {
      if (_f[2*d]) {
        delete _f[2*d];
        _f[2*d] = (ld_fixup_grid_fct_type *) 0;
      }
      if (_f_name[2*d]) {
        delete [] _f_name[2*d];
        _f_name[2*d] = (char *) 0;
      }
      if (_f[2*d+1]) { 
        delete _f[2*d+1];
        _f[2*d+1] = (ld_fixup_grid_fct_type *) 0;
      }
      if (_f_name[2*d+1]) {
        delete [] _f_name[2*d+1];
        _f_name[2*d+1] = (char *) 0;
      }
    }
  } 

  virtual void SetupData(GridHierarchy* gh, const int& ghosts) {
    base::SetupData(gh, ghosts);
    int t_sten = 0;
    int s_sten = 0;
    AllocError::SetTexts("FixupBase","allocation of GridFunctions");
    int DAGH_Base = DAGH_X;
    if (dim == 2) DAGH_Base = DAGH_Y;
    if (dim == 3) DAGH_Base = DAGH_YZ;

    for (int d=0; d<dim; d++) {
      _f_name[2*d] = new char[DAGHBktGFNameWidth];
      sprintf(_f_name[2*d],"f_lower");
      _f[2*d] = new ld_fixup_grid_fct_type(_f_name[2*d], t_sten, s_sten, base::GH(),
                                           DAGHCellCentered, 1, 1, DAGH_Base-d, 
                                           DAGHNoComm, DAGHNoBoundary,
                                           DAGHNoAdaptBoundary, DAGHNoExternalGhost);
      SetProlongFlag(F(2*d), DAGHFalse);   
      SetCheckpointFlag(F(2*d), DAGHFalse);   

      _f_name[2*d+1] = new char[DAGHBktGFNameWidth];
      sprintf(_f_name[2*d+1],"f_upper");
      _f[2*d+1] = new ld_fixup_grid_fct_type(_f_name[2*d+1], t_sten, s_sten, base::GH(),
                                             DAGHCellCentered, 1, 1, (DAGH_Base-d) | DAGH_Dim1ToTop,
                                             DAGHNoComm, DAGHNoBoundary,
                                             DAGHNoAdaptBoundary, DAGHNoExternalGhost);
      SetProlongFlag(F(2*d+1), DAGHFalse);   
      SetCheckpointFlag(F(2*d+1), DAGHFalse);   
    }

    SetMaxRecomposeLevel(DAGHNull);
  }    

  void SetMaxRecomposeLevel(const int l) {
    for (int d=0; d<dim; d++) {
      F(2*d).GF_SetMaxRecomposeLevel(l);
      F(2*d+1).GF_SetMaxRecomposeLevel(l);
    }
  }

  inline ld_fixup_grid_fct_type& F(int d) { 
#ifdef DEBUG_PRINT
    assert(d>=0 && d<2*dim); 
#endif
    return *_f[d]; 
  }

  inline const ld_fixup_grid_fct_type& F(int d) const { 
#ifdef DEBUG_PRINT
    assert(d>=0 && d<2*dim); 
#endif
    return *_f[d]; 
  }

  inline const int& NFixupEquations() { return _FixupEquations; }

protected:
  int _FixupEquations;
  ld_fixup_grid_fct_type* _f[2*dim];
  char *_f_name[2*dim]; 
};

template <class VectorType, class FixupType, int dim> class FixupOps;
template <class VectorType, class FixupType, int dim> class Fixup;

#endif

---