Blockstructured Adaptive Mesh Refinement in object-oriented C++

---

       

---

FixupBase.h

Go to the documentation of this file.

#ifndef AMROC_FIXUP_BASE_H
#define AMROC_FIXUP_BASE_H

#include "GridFunction.h"
#include "FixupBaseInterface.h"
#include "Integrator.h"

#ifndef FixupBaseName
#define FixupBase(dim)      name2(FixupBase,dim)
#define FixupBaseName
#endif

template <class VectorType, class FixupType>
class FixupBase(DIM) : 
  public FixupBaseInterface(DIM)<VectorType,FixupType> {

  typedef Integrator(DIM)<VectorType> integrator_type;
  typedef GridData(DIM)<VectorType>  vec_grid_data_type;

  typedef GridData(DIM_1)<VectorType> ld_vec_grid_data_type;
  typedef GridData(DIM_1)<FixupType>  ld_fixup_grid_data_type;

  typedef GridFunction(DIM)<VectorType> vec_grid_fct_type;  
  typedef GridFunction(DIM_1)<FixupType> ld_fixup_grid_fct_type;  

public:
  FixupBase(DIM)(integrator_type& integ) : _Integrator(integ),
    _FixupEquations(FixupType::Length()) {    
    _Hierarchy = (GridHierarchy*) 0;
    _u = (vec_grid_fct_type *) 0;
    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;
    }
  }

  ~FixupBase(DIM)() {
    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];
    }
  }

  virtual void register_at(ControlDevice& Ctrl,const string& prefix) {
    LocCtrl = Ctrl.getSubDevice(prefix+"FixupBase");
  }
  virtual void register_at(ControlDevice& Ctrl) { register_at(Ctrl,""); }
  virtual void init() {}
  virtual void update() {}
  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;
      }
    }
  } 

  void SetupData() {
    if (!_u) return; 
    int t_sten = 0;
    int s_sten = 0;
    AllocError::SetTexts("FixupBase(DIM)","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, 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, 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 void SetGridHierarchy(GridHierarchy* gh) { _Hierarchy = gh; }
  inline GridHierarchy& GH() { return *_Hierarchy; }
  inline const GridHierarchy& GH() const { return *_Hierarchy; }

  inline void SetGridFunctions(vec_grid_fct_type* u) { _u = u; }
  inline vec_grid_fct_type& U() { return *_u; }
  inline const vec_grid_fct_type& U() const { return *_u; }

  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 integrator_type& Integrator_() { return _Integrator; }
  inline const integrator_type& Integrator_() const { return _Integrator; }

  inline const int& NEquations() { return _Integrator.NEquations(); }
  inline const int& NFixupEquations() { return _FixupEquations; }
  inline const int& NGhosts() const { return _Integrator.NGhosts(); }

protected:
  integrator_type& _Integrator;
  int _FixupEquations;
  GridHierarchy* _Hierarchy;
  vec_grid_fct_type* _u;
  ld_fixup_grid_fct_type* _f[2*DIM];
  char *_f_name[2*DIM]; 
  ControlDevice LocCtrl;
};


void AlignBBox(BBox &bb, const int s) {
  int DAGH_Base = DAGH_X;
  if (DIM == 2) DAGH_Base = DAGH_Y;
  if (DIM == 3) DAGH_Base = DAGH_YZ;
#ifdef DEBUG_PRINT
  assert (s>=0 && s<2*DIM);
#endif
  if (s % 2 != 0) 
    DAGH_Base = DAGH_Base | DAGH_Dim1ToTop;
  gdbAlignBBox(DIM_1, bb, DAGH_Base - s/2);
  bb.rank = DIM_1;
  bb.lower().rank = DIM_1;
  bb.upper().rank = DIM_1;
  bb.stepsize().rank = DIM_1;
} 


#endif

---

Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download

---

AMROC Main      Home      Contact

last update: 06/01/04