Blockstructured Adaptive Mesh Refinement in object-oriented C++

---

       

---

Solver.h

Go to the documentation of this file.

#ifndef AMROC_SOLVER_H
#define AMROC_SOLVER_H

#include "Integrator.h"
#include "InitialCondition.h"
#include "BoundaryConditions.h"
#include "SolverInterface.h"
#include "Flagging.h"

#if DIM == 1
#   include "Fixup1.h"  
#   include "VectorGridData1Ops.h"
#elif DIM == 2
#   include "Fixup2.h"  
#   include "VectorGridData2Ops.h"
#elif DIM == 3  
#   include "Fixup3.h"
#   include "VectorGridData3Ops.h"
#endif


#define FixedTimeSteps               (0)
#define AutomaticTimeStepsNoRestart  (1)
#define AutomaticTimeStepsRestart    (2)


#ifndef SolverName
#define Solver(dim)      name2(Solver,dim)
#define SolverName
#endif

template <class VectorType, class FixupType, class FlagType>
class Solver(DIM) : public SolverInterface(DIM)<VectorType> {
  typedef typename VectorType::InternalDataType DataType;
  typedef GridFunction(DIM)<VectorType> vec_grid_fct_type;  
  typedef GridFunction(DIM)<DataType>   grid_fct_type;

  typedef Integrator(DIM)<VectorType> integrator_type;
  typedef InitialCondition(DIM)<VectorType> initial_condition_type;
  typedef BoundaryConditions(DIM)<VectorType> boundary_conditions_type;
  typedef Flagging(DIM)<VectorType, FixupType, FlagType> flagging_type;
  typedef Fixup(DIM)<VectorType, FixupType> fixup_type;

public:
  Solver(DIM)(integrator_type& integ, 
              initial_condition_type& init,
              boundary_conditions_type& bc) : 
    _Integrator(integ), _InitialCondition(init), _BoundaryConditions(bc) {
    _Hierarchy = (GridHierarchy*) 0;
    _u = (vec_grid_fct_type *) 0;
    _u_sh = (vec_grid_fct_type *) 0;
    _work = (grid_fct_type *) 0;
    _work_sh = (grid_fct_type *) 0;
    _Flagging = (flagging_type *) 0;
    _Fixup = (fixup_type *) 0;
    _LastOutputTime = -1;
  }

  virtual void register_at(ControlDevice& Ctrl,const string& prefix) {
    LocCtrl = Ctrl.getSubDevice(prefix+"Solver");    
    _Integrator.register_at(LocCtrl,prefix);
    _InitialCondition.register_at(LocCtrl,prefix);
    _BoundaryConditions.register_at(LocCtrl,prefix);
    if (_Flagging)
      _Flagging->register_at(LocCtrl,prefix);
    if (_Fixup)
      _Fixup->register_at(LocCtrl,prefix);
  }
  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl, "");
  }

  virtual void init() {
    _Integrator.init();
    _InitialCondition.init();
    _BoundaryConditions.init();
    if (_Flagging)
      _Flagging->init();
    if (_Fixup)
      _Fixup->init();
  }
  virtual void update() {
    _Integrator.update();
    _InitialCondition.update();
    _BoundaryConditions.update();
    if (_Flagging)
      _Flagging->update();
    if (_Fixup)
      _Fixup->update();
  }
  virtual void finish() {
    _Integrator.finish();
    _InitialCondition.finish();
    _BoundaryConditions.finish();
    if (_Flagging)
      _Flagging->finish();
    if (_Fixup)
      _Fixup->finish();
  } 

  virtual void SetupData() {
    Integrator_().SetupData();
    if (_Flagging) 
      Flagging_().SetupData();
    if (_Fixup)
      Fixup_().SetupData();
  }

  inline void SetBoundaryConditions() { 
    BoundaryConditions_().Set(*_u); 
    if (_u_sh) 
      BoundaryConditions_().Set(*_u_sh);
  }

  void SetGridHierarchy(GridHierarchy* gh) { 
    _Integrator.SetGridHierarchy(gh);
    _InitialCondition.SetGridHierarchy(gh);
    _BoundaryConditions.SetGridHierarchy(gh);
    if (_Flagging)
      _Flagging->SetGridHierarchy(gh);
    if (_Fixup)
      _Fixup->SetGridHierarchy(gh);
    _Hierarchy = gh; 
  }
  inline GridHierarchy& GH() { return *_Hierarchy; }
  inline const GridHierarchy& GH() const { return *_Hierarchy; }

  void SetGridFunctions(vec_grid_fct_type* u, vec_grid_fct_type* ush,
                        grid_fct_type* work, grid_fct_type* worksh) {
    if (_Flagging) 
      _Flagging->SetGridFunctions(u, ush, work, worksh);
    if (_Fixup) 
      _Fixup->SetGridFunctions(u);
    _u = u; _u_sh = ush;
    _work = work; _work_sh = worksh; 
  }
  inline vec_grid_fct_type& U() { return *_u; }
  inline const vec_grid_fct_type& U() const { return *_u; }
  inline vec_grid_fct_type& Ush() { return *_u_sh; }
  inline const vec_grid_fct_type& Ush() const { return *_u_sh; }
  inline grid_fct_type& Work() { return *_work; }
  inline const grid_fct_type& Work() const { return *_work; }
  inline grid_fct_type& Worksh() { return *_work_sh; }
  inline const grid_fct_type& Worksh() const { return *_work_sh; }

  inline initial_condition_type& InitialCondition_() 
    { return _InitialCondition; }
  inline const initial_condition_type& InitialCondition_() const 
    { return _InitialCondition; }

  inline boundary_conditions_type& BoundaryConditions_() 
    { return _BoundaryConditions; }
  inline const boundary_conditions_type& BoundaryConditions_() const 
    { return _BoundaryConditions; }

  inline integrator_type& Integrator_() { return _Integrator; }
  inline const integrator_type& Integrator_() const { return _Integrator; }

  inline void SetFlagging(flagging_type* _flagging) { _Flagging = _flagging; }
  inline flagging_type& Flagging_() { return *_Flagging; }
  inline const flagging_type& Flagging_() const { return *_Flagging; }
  inline const bool& ErrorEstimation() const { return Flagging_().ErrorEstimation();}

  inline void SetFixup(fixup_type* _fixup) { _Fixup = _fixup; }
  inline fixup_type& Fixup_() { return *_Fixup; }
  inline const fixup_type& Fixup_() const { return *_Fixup; }

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

  inline void SetLastOutputTime(int Time) { _LastOutputTime = Time; }
  inline int LastOutputTime() const { return _LastOutputTime; }

protected:
  integrator_type& _Integrator;
  initial_condition_type& _InitialCondition;
  boundary_conditions_type& _BoundaryConditions;
  GridHierarchy* _Hierarchy;
  vec_grid_fct_type *_u, *_u_sh;
  grid_fct_type *_work, *_work_sh;
  flagging_type* _Flagging;
  fixup_type* _Fixup;
  ControlDevice LocCtrl;
  int _LastOutputTime;
};


#endif

---

Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download

---

AMROC Main      Home      Contact

last update: 06/01/04