amroc/amr/Criteria/ScaledGradient.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@cacr.caltech.edu

#ifndef AMROC_SCALEDGRADIENT_H
#define AMROC_SCALEDGRADIENT_H

#include "StdCriterion.h"

template <class VectorType, class FlagType, int dim>
class ScaledGradient : 
  public StdCriterion<VectorType,FlagType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef StdCriterion<VectorType,FlagType,dim> base;
public:
  typedef typename base::vec_grid_fct_type vec_grid_fct_type;  
  typedef typename base::grid_fct_type grid_fct_type;
  typedef typename base::flag_fct_type flag_fct_type;
  typedef typename base::max_vector_type max_vector_type;

  ScaledGradient() : base() {
    base::SetShadowCriterion(false);
    Tol = static_cast<DataType>(0.0);
  }

  virtual ~ScaledGradient() {}
  
  virtual void register_at(ControlDevice& Ctrl) {}
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::LocCtrl = Ctrl.getSubDevice(prefix+"ScaledGradient");
    char Name[16];
    for (int d=0; d<max_vector_type::Length(); d++) {
      std::sprintf(Name,"Tol(%d)",d+1);
      RegisterAt(base::LocCtrl,Name,Tol(d));
      std::sprintf(Name,"MaxLev(%d)",d+1);
      RegisterAt(base::LocCtrl,Name,base::_MaxLevel[d]);
    }    
    RegisterAt(base::LocCtrl,"Output",base::_Output);
  }

  virtual void update() { 
    int d=max_vector_type::Length();
    for (; d>0; d--) 
      if (Tol(d-1) > static_cast<DataType>(0.0)) 
        break;
    if (d>0) {
      base::SetNcnt(d);
      base::SetIsUsed(true);
    }
    else 
      base::SetIsUsed(false);
  }

  virtual bool SetFlags(vec_grid_fct_type& u, grid_fct_type& work, flag_fct_type& flags, 
                        const int& cnt, const int& Time, const int& Level, const double& t, 
                        const FlagType& FlagValue) {
    if (Tol(cnt) <= 0.0) return false;
    int TStep = TimeStep(work,Level);
    if (base::MaxLevel(cnt)<Level && base::MaxLevel(cnt)>=0) {
      if (base::OutputFlags()) {
        forall(work,Time,Level,c)
          work(Time+TStep,Level,c) = static_cast<DataType>(0.0);
        end_forall 
      }
      return true;
    }

    forall(work,Time,Level,c)
      equals_from(work(Time,Level,c), u(Time,Level,c), cnt);
    end_forall 
    return FlagByScaledGradient(work, flags, Time, Level, Tol(cnt), FlagValue);
  }

  virtual bool FlagByScaledGradient(grid_fct_type& work, flag_fct_type& flags,
                                    const int& Time, const int& Level, 
                                    const DataType& TolVal, const FlagType& FlagValue) { 
    if (TolVal <= 0.0) return false;

    int TStep = TimeStep(work,Level);
    forall(work,Time,Level,c)
      work(Time+TStep,Level,c) = static_cast<DataType>(0.0);
    end_forall 

    if (dim == 1) {
      int East[1]  = { 1 }; int West[1]  = { -1 };
      base::Difference(work, Time, Level, East, West);
    }
    else if (dim == 2) {
      int East[2]  = { 1, 0 }; int West[2]  = { -1, 0 };
      int North[2] = { 0, 1 }; int South[2] = { 0, -1 };
      base::Difference(work, Time, Level, East, West);
      base::Difference(work, Time, Level, North, South);
      
      int NorthEast[2] = {  1, 1 }; int SouthWest[2] = { -1, -1 };
      int NorthWest[2] = { -1, 1 }; int SouthEast[2] = {  1, -1 };
      base::Difference(work, Time, Level, NorthEast, SouthWest);
      base::Difference(work, Time, Level, NorthWest, SouthEast);
    }
    else if (dim == 3) {
      int East[3]  = { 1, 0, 0 }; int West[3]   = {-1,  0,  0 };
      int North[3] = { 0, 1, 0 }; int South[3]  = { 0, -1,  0 };
      int Top[3]   = { 0, 0, 1 }; int Bottom[3] = { 0,  0, -1 };
      base::Difference(work, Time, Level, East, West);
      base::Difference(work, Time, Level, North, South);
      base::Difference(work, Time, Level, Top, Bottom);

      int NorthEastTop[3]    = {  1, 1,  1}; int SouthWestBottom[3] = { -1, -1, -1};
      int NorthEastBottom[3] = {  1, 1, -1}; int SouthWestTop[3]    = { -1, -1,  1};
      int NorthWestTop[3]    = { -1, 1,  1}; int SouthEastBottom[3] = {  1, -1, -1};
      int NorthWestBottom[3] = { -1, 1, -1}; int SouthEastTop[3]    = {  1, -1,  1};
      base::Difference(work, Time, Level, NorthEastTop, SouthWestBottom);
      base::Difference(work, Time, Level, NorthEastBottom, SouthWestTop);
      base::Difference(work, Time, Level, NorthWestTop, SouthEastBottom);
      base::Difference(work, Time, Level, NorthWestBottom, SouthEastTop);
    }      
    base::FlagByValue(work, flags, Time, Level, TolVal, FlagValue);
    return true;
  }

  virtual void OutputName(char* name, int cnt) { std::sprintf(name,"grad_%d",cnt+1); }

  max_vector_type Tol;
};

#endif

---