Flagging.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_FLAGGING_H
#define AMROC_FLAGGING_H

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

template <class VectorType, class FixupType, class FlagType, int dim> class AMRSolverBase;

#define GoodPoint (0)
#define BadPoint  (1)
#define VizServer 0                                               

template <class VectorType, class FlagType, int dim>
class Flagging : public AMRBase<VectorType,dim> {
  typedef AMRBase<VectorType,dim> base;
  typedef typename VectorType::InternalDataType DataType;
public:
  typedef GridFunction<FlagType,dim> flag_fct_type;
  typedef Criterion<VectorType,FlagType,dim> criterion_type;

  Flagging() : base(), _ncrit(0), _Bufferwidth(2) {    
    _crit = (criterion_type**) 0;
    _flag = (flag_fct_type *) 0; 
  }

  virtual ~Flagging() {
    if (_flag) delete _flag;
    if (_crit) delete [] _crit;
  }

  //******************************************************************************
  // Abstract class interface
  //******************************************************************************
  virtual void SetFlags(const int Time, const int Level, double t, double dt) = 0;   
  //******************************************************************************

  virtual void register_at(ControlDevice& Ctrl) {}
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::LocCtrl = Ctrl.getSubDevice(prefix+"Flagging");
    for (register int n=0; n<NCrit(); n++) 
      Criterion_(n).register_at(base::LocCtrl,"");
  }

  virtual void init() {
    base::init();
    for (register int n=0; n<NCrit(); n++) 
      Criterion_(n).init();
  }
  virtual void update() {
    base::update();
    for (register int n=0; n<NCrit(); n++) 
      Criterion_(n).update();
  }
  virtual void finish() {
    base::finish();
    for (register int n=0; n<NCrit(); n++) 
      Criterion_(n).finish();
    if (_flag) {
      delete _flag;
      _flag = (flag_fct_type *) 0; 
    }
  }

  virtual void SetupData(GridHierarchy* gh, const int& ghosts) {
    base::SetupData(gh, ghosts);
    for (register int n=0; n<NCrit(); n++)
      Criterion_(n).SetupData(gh, ghosts);
    int t_sten = 0;            
    int s_sten = Bufferwidth(); 
    sprintf(flagName,"Flags");
    _flag = new flag_fct_type(flagName, t_sten, s_sten, base::GH(), DAGHCellCentered,
                              DAGHCommSimple, DAGHNoBoundary, DAGHNoAdaptBoundary,
                              DAGHNoExternalGhost);
    SetCheckpointFlag(*_flag, DAGHFalse);   
    SetProlongFlag(*_flag, DAGHFalse);   
    _flag->GF_SetMaxRecomposeLevel(DAGHNull);
  }    

  void AddCriterion(criterion_type* crit) {
    if (crit) {
      criterion_type** _crit_new = new criterion_type*[_ncrit+1];
      if (_crit) {
        for (register int n=0; n<_ncrit; n++)
          _crit_new[n] = _crit[n];
        delete [] _crit;
      }
      _crit = _crit_new;
      _crit[_ncrit] = crit;
      _ncrit++;
    }
  }

  void EliminateCriterion(criterion_type* crit) {
    if (crit) {
      int c=0;
      for (register int n=0; n<_ncrit; n++)
        if (_crit[n] == crit) c++;
      if (c>0) {
        criterion_type** _crit_new = (criterion_type**) 0;
        if (_ncrit-c>0) {
          _crit_new = new criterion_type*[_ncrit-c];
          for (register int n=0, m=0; n<_ncrit; n++)
            if (_crit[n] != crit) 
              _crit_new[m++] = _crit[n];
        }
        delete [] _crit;
        _crit = _crit_new;
        _ncrit = _ncrit-c;
      }
    }
  }

  void DeleteCriterion(criterion_type* crit) {
    EliminateCriterion(crit);
    if (crit) delete crit;
  }

  void DeleteAllCriterions() {
    while (NCrit()>0)
      DeleteCriterion(_crit[0]);
  }

  inline criterion_type* CriterionP(const int n) { assert (n>=0 && n<_ncrit); return _crit[n]; }
  inline criterion_type& Criterion_(const int n) { assert (n>=0 && n<_ncrit); return *(_crit[n]); }
  inline const criterion_type& Criterion_(const int n) const { assert (n>=0 && n<_ncrit); return *(_crit[n]); }
  inline const int& NCrit() const { return _ncrit; }

  void SetBufferwidth(const int buffw) { _Bufferwidth = buffw; }
  inline const int& Bufferwidth() const { return _Bufferwidth; }
  inline int Bufferwidth() { return _Bufferwidth; }

  inline flag_fct_type& Flags() { return *_flag; }
  inline const flag_fct_type& Flags() const { return *_flag; }

protected:
  criterion_type** _crit;
  int _ncrit;
  flag_fct_type* _flag;
  char flagName[DAGHBktGFNameWidth];
  int _Bufferwidth;
};


#endif

---