Blockstructured Adaptive Mesh Refinement in object-oriented C++

---

       

---

AMRPreAdaptSolver.h

Go to the documentation of this file.

#ifndef AMROC_AMRPREADAPT_SOLVER_H
#define AMROC_AMRPREADAPT_SOLVER_H

#include "AMRSolver.h"

#ifndef AMRPreAdaptSolverName
#define AMRPreAdaptSolver(dim)      name2(AMRPreAdaptSolver,dim)
#define AMRPreAdaptSolverName
#endif


#define MAXLEVELS 5

class Patch : public controlable {
public:
  Patch() {
    lb.rank = DIM;
    ub.rank = DIM;
    s.rank = DIM;
  }

  virtual void register_at(ControlDevice& Ctrl) {}
  virtual void register_at(ControlDevice& Ctrl, const string& prefix) {
    LocCtrl = Ctrl.getSubDevice(prefix+"Patch");
    for (int d=0; d<DIM; d++) {
      char text[8];
      sprintf(text,"lb(%d)",d+1);
      RegisterAt(LocCtrl,text,lb(d));
      sprintf(text,"ub(%d)",d+1);
      RegisterAt(LocCtrl,text,ub(d));
      sprintf(text,"s(%d)",d+1);
      RegisterAt(LocCtrl,text,s(d));
    }
  }

public:
  Coords lb, ub, s;
  ControlDevice LocCtrl;
};


template <class VectorType, class FixupType, class FlagType>
class AMRPreAdaptSolver(DIM) : 
  public AMRSolver(DIM)<VectorType,FixupType,FlagType> {

  typedef AMRSolver(DIM)<VectorType,FixupType,FlagType> amr_solver_type;

  typedef Integrator(DIM)<VectorType> integrator_type;
  typedef InitialCondition(DIM)<VectorType> initial_condition_type;
  typedef BoundaryConditions(DIM)<VectorType> boundary_conditions_type;

public:
  AMRPreAdaptSolver(DIM)(integrator_type& integ, 
                     initial_condition_type& init,
                     boundary_conditions_type& bc) : 
    amr_solver_type(integ, init, bc), SwitchTime(0) {
    for (int c=0; c<MAXLEVELS; c++) {
      li[c] = 0;
      ls[c] = 0;
      PatchListInit[c] = (Patch*) 0;
      PatchListSwitch[c] = (Patch*) 0;
    }
  }

  ~AMRPreAdaptSolver(DIM)() {
    for (int c=0; c<MAXLEVELS; c++) {
      if (PatchListInit[c])
        delete [] PatchListInit[c];
      if (PatchListSwitch[c])
        delete [] PatchListSwitch[c];
    }
  }

  virtual void register_at(ControlDevice& Ctrl, const string& prefix) {
    amr_solver_type::register_at(Ctrl,prefix);
    ControlDevice LocCtrlInit = LocCtrl.getSubDevice(prefix+"InitialRefinement");
    int c;
    for (c=0; c<MAXLEVELS; c++) {
      char LevelControlsName[24];
      sprintf(LevelControlsName,"PatchesOnLevel%d",c+1);
      RegisterAt(LocCtrlInit,LevelControlsName,li[c]);
    }
    
    RegisterAt(LocCtrl,"SwitchTime",SwitchTime);
    ControlDevice LocCtrlSwitch = LocCtrl.getSubDevice(prefix+"SwitchRefinement");
    for (c=0; c<MAXLEVELS; c++) {
      char LevelControlsName[24];
      sprintf(LevelControlsName,"PatchesOnLevel%d",c+1);
      RegisterAt(LocCtrlSwitch,LevelControlsName,ls[c]);
    }    
  }
  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl, "");
  }

  virtual void SetupData() {
    amr_solver_type::SetupData();

    ControlDevice PatchCtrlInit(GetFileControlDevice("patches_init.in",""));   
    int m;
    for (m=0; m<MAXLEVELS; m++) {
      PatchListInit[m] = new Patch[li[m]];
      for (int i=0; i<li[m]; i++) {
        char text[5];
        sprintf(text,"%d-%d-",m+1,i+1);
        (PatchListInit[m])[i].register_at(PatchCtrlInit,string(text));
      }
    }
    PatchCtrlInit.update();  

    ControlDevice PatchCtrlSwitch(GetFileControlDevice("patches_switch.in",""));   
    for (m=0; m<MAXLEVELS; m++) {
      PatchListSwitch[m] = new Patch[ls[m]];
      for (int i=0; i<ls[m]; i++) {
        char text[5];
        sprintf(text,"%d-%d-",m+1,i+1);
        (PatchListSwitch[m])[i].register_at(PatchCtrlSwitch,string(text));
      }
    }
    PatchCtrlSwitch.update();  
   }

  virtual void Initialize(const double dt_start) {
    BBoxList bblist[MAXLEVELS]; 
    int m;
    for (m=0; m<MAXLEVELS; m++)   
      for (int i=0; i<li[m]; i++) {
        cout << ((PatchListInit[m])[i].lb)*RefinedBy(GH(),MaxLevel(GH())) << "   " <<
          ((PatchListInit[m])[i].ub)*RefinedBy(GH(),MaxLevel(GH())) << "   " << 
          ((PatchListInit[m])[i].s)*StepSize(GH(),m) << endl;

        bblist[m].add(BBox(((PatchListInit[m])[i].lb)*RefinedBy(GH(),MaxLevel(GH())),
                           ((PatchListInit[m])[i].ub)*RefinedBy(GH(),MaxLevel(GH())),
                           ((PatchListInit[m])[i].s)*StepSize(GH(),m)));
      }   
 
    for (m=0; m<MaxLevel(GH());m++)  
      if (li[m] > 0) {
        Refine(GH(),bblist[m],m);        
        RecomposeHierarchy(GH());  
      }

    int Store = RegridEvery;
    RegridEvery = 0;
    amr_solver_type::Initialize(dt_start);
    RegridEvery = Store;
  }

  virtual double Tick(int VariableTimeStepping, const double dtv[], const double cflv[],
                      int& Rejections, int& RecomposeEvery) {
    if (SwitchTime>0 && 
        SwitchTime*RefinedBy(GH(),MaxLevel(GH())) == CurrentTime(GH(),0)) {
      BBoxList bblist[MAXLEVELS]; 
      int m;
      for (m=0; m<MAXLEVELS; m++)   
        for (int i=0; i<ls[m]; i++) {
          bblist[m].add(BBox(((PatchListSwitch[m])[i].lb)*RefinedBy(GH(),MaxLevel(GH())),
                             ((PatchListSwitch[m])[i].ub)*RefinedBy(GH(),MaxLevel(GH())),
                             ((PatchListSwitch[m])[i].s)*StepSize(GH(),m)));
        }

      for (m=0; m<MaxLevel(GH());m++)  
        if (ls[m] > 0) {
          Refine(GH(),bblist[m],m);    
          RecomposeHierarchy(GH());  
        }
    }

    return (amr_solver_type::Tick(VariableTimeStepping, dtv, cflv, Rejections, 
                                  RecomposeEvery));
  }

protected:
  int SwitchTime;
  int li[MAXLEVELS];
  int ls[MAXLEVELS];
  Patch* PatchListInit[MAXLEVELS];
  Patch* PatchListSwitch[MAXLEVELS];
};

#endif

---

Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download

---

AMROC Main      Home      Contact

last update: 06/01/04