AMRPreAdaptSolver.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2002 Ralf Deiterding
// Brandenburgische Universitaet Cottbus

#ifndef AMROC_AMRPREADAPT_SOLVER_H
#define AMROC_AMRPREADAPT_SOLVER_H

#include "AMRSolver.h"

#include <iostream>
#include <string>
#include <cstdio>

#define MAXLEVELS 5

template <int dim>
class Patch : public controlable {
public:
  Patch() {
    lb.rank = dim;
    ub.rank = dim;
    s.rank = dim;
  }

  virtual ~Patch() {}

  virtual void register_at(ControlDevice& Ctrl) {}
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    LocCtrl = Ctrl.getSubDevice(prefix+"Patch");
    for (int d=0; d<dim; d++) {
      char text[8];
      std::sprintf(text,"lb(%d)",d+1);
      RegisterAt(LocCtrl,text,lb(d));
      std::sprintf(text,"ub(%d)",d+1);
      RegisterAt(LocCtrl,text,ub(d));
      std::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, int dim>
class AMRPreAdaptSolver : 
  public AMRSolver<VectorType,FixupType,FlagType,dim> {

  typedef Integrator<VectorType,dim> integrator_type;
  typedef InitialCondition<VectorType,dim> initial_condition_type;
  typedef BoundaryConditions<VectorType,dim> boundary_conditions_type;

  typedef AMRSolver<VectorType,FixupType,FlagType,dim> base;

  typedef Patch<dim> patch_type;

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

  virtual ~AMRPreAdaptSolver() {
    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 std::string& prefix) {
    base::register_at(Ctrl,prefix);
    ControlDevice LocCtrlInit = base::LocCtrl.getSubDevice(prefix+"InitialRefinement");
    int c;
    for (c=0; c<MAXLEVELS; c++) {
      char LevelControlsName[24];
      std::sprintf(LevelControlsName,"PatchesOnLevel%d",c+1);
      RegisterAt(LocCtrlInit,LevelControlsName,li[c]);
    }
    
    RegisterAt(base::LocCtrl,"SwitchTime",SwitchTime);
    ControlDevice LocCtrlSwitch = base::LocCtrl.getSubDevice(prefix+"SwitchRefinement");
    for (c=0; c<MAXLEVELS; c++) {
      char LevelControlsName[24];
      std::sprintf(LevelControlsName,"PatchesOnLevel%d",c+1);
      RegisterAt(LocCtrlSwitch,LevelControlsName,ls[c]);
    }    
  }
  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl, "");
  }

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

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

    ControlDevice PatchCtrlSwitch(GetFileControlDevice("patches_switch.in",""));   
    for (m=0; m<MAXLEVELS; m++) {
      PatchListSwitch[m] = new patch_type[ls[m]];
      for (int i=0; i<ls[m]; i++) {
        char text[5];
        std::sprintf(text,"%d-%d-",m+1,i+1);
        (PatchListSwitch[m])[i].register_at(PatchCtrlSwitch,std::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++) {
        std::cout << ((PatchListInit[m])[i].lb)*RefinedBy(base::GH(),MaxLevel(base::GH()))
                  << "   "
                  << ((PatchListInit[m])[i].ub)*RefinedBy(base::GH(),MaxLevel(base::GH()))
                  << "   "
                  << ((PatchListInit[m])[i].s)*StepSize(base::GH(),m) << std::endl;

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

    int Store = base::RegridEvery;
    base::RegridEvery = 0;
    base::Initialize_(dt_start);
    base::RegridEvery = Store;
  }

  virtual double Tick(int VariableTimeStepping, const double dtv[], const double cflv[],
                      int& Rejections) {
    if (SwitchTime>0 && 
        SwitchTime*RefinedBy(base::GH(),MaxLevel(base::GH())) == CurrentTime(base::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(base::GH(),MaxLevel(base::GH())),
                             ((PatchListSwitch[m])[i].ub)*RefinedBy(base::GH(),MaxLevel(base::GH())),
                             ((PatchListSwitch[m])[i].s)*StepSize(base::GH(),m)));
        }

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

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

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

#endif

---