StdCriterion.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_STDCRITERION_H
#define AMROC_STDCRITERION_H

#include "Criterion.h"

template <class VectorType, class FlagType, int dim> class StdCriterion; 

template <class VectorType, class FlagType>
class StdCriterion<VectorType,FlagType,1> : 
  public Criterion<VectorType,FlagType,1> {
  typedef typename VectorType::InternalDataType DataType;
  typedef Criterion<VectorType,FlagType,1> base;
public:
  typedef typename base::grid_fct_type grid_fct_type;
  typedef typename base::flag_fct_type flag_fct_type;
  typedef typename base::grid_data_type grid_data_type;

  StdCriterion() : base() {}

  virtual ~StdCriterion() {}

  virtual void FlagByValue(grid_fct_type& work, flag_fct_type& flags,
                           const int& Time, const int& Level, 
                           const DataType& Tol, const FlagType& FlagValue,
                           const int comparison = 0, const int growby = 0) {

    int TStep = TimeStep(work,Level);
    forall(flags, Time, Level, c)
      BeginFastIndex1(work, work(Time+TStep,Level,c).bbox(), 
                      work(Time+TStep,Level,c).data(), DataType);        
      BeginFastIndex1(flags, flags(Time,Level,c).bbox(), 
                      flags(Time,Level,c).data(), FlagType);

      BBox OpBox = flags.interiorbbox(Time,Level,c);
      Coords& Os = OpBox.stepsize();
      BBox OpwBox = work(Time+TStep,Level,c).bbox();
      Coords& Ows = OpwBox.stepsize();

      for_1 (n, OpBox, Os)
        if ((comparison==0 && FastIndex1(work,n-n%Ows(0))>=Tol) ||
            (comparison==1 && FastIndex1(work,n-n%Ows(0))< Tol)) {
          if (growby<=0) 
            FastIndex1(flags,n) = FlagValue;
          else {
            BBox bbflag(1,n,n,Os(0)); bbflag.grow(growby);
            flags(Time,Level,c).equals(FlagValue,bbflag);
          }
        }
      end_for

      EndFastIndex1(work);
      EndFastIndex1(flags);
    end_forall
  } 

  virtual void Difference(grid_fct_type& work, const int& Time, const int& Level, 
                          int* Offset1, int* Offset2) {

    int TStep = TimeStep(work,Level);
    forall(work, Time, Level, c)
      BBox OpBox = work.interiorbbox(Time,Level,c);
      Coords& OpBox_stepsize = OpBox.stepsize();
      BeginFastIndex1(work, work(Time,Level,c).bbox(), 
                      work(Time,Level,c).data(), DataType);
      BeginFastIndex1(workout, work(Time+TStep,Level,c).bbox(), 
                      work(Time+TStep,Level,c).data(), DataType);

      Coords o1 = Coords(1,Offset1)*OpBox_stepsize;
      Coords o2 = Coords(1,Offset2)*OpBox_stepsize;
      for_1 (n, OpBox, OpBox_stepsize)
        FastIndex1(workout,n) = std::max(FastIndex1(workout,n),
           std::fabs(FastIndex1(work,n+o1(0))-FastIndex1(work,n+o2(0))));
      end_for

      EndFastIndex1(work);
      EndFastIndex1(workout);
    end_forall
  }

  virtual void Abs(grid_data_type& work) {
    BBox OpBox = work.bbox();
    Coords& OpBox_stepsize = OpBox.stepsize();
    BeginFastIndex1(work, OpBox, work.data(), DataType);
    for_1 (n, OpBox, OpBox_stepsize)
      FastIndex1(work,n) = std::fabs(FastIndex1(work,n));
    end_for
    EndFastIndex1(work);
  }

  virtual void Max(grid_data_type& work, const DataType& val) {
    BBox OpBox = work.bbox();
    Coords& OpBox_stepsize = OpBox.stepsize();
    BeginFastIndex1(work, OpBox, work.data(), DataType);
    for_1 (n, OpBox, OpBox_stepsize)
      FastIndex1(work,n) = std::max(FastIndex1(work,n), val);
    end_for
    EndFastIndex1(work);
  }

  virtual void Min(grid_data_type& work, const DataType& val) {
    BBox OpBox = work.bbox();
    Coords& OpBox_stepsize = OpBox.stepsize();
    BeginFastIndex1(work, OpBox, work.data(), DataType);
    for_1 (n, OpBox, OpBox_stepsize)
      FastIndex1(work,n) = std::min(FastIndex1(work,n), val);
    end_for
    EndFastIndex1(work);
  }
};


template <class VectorType, class FlagType>
class StdCriterion<VectorType,FlagType,2> : 
  public Criterion<VectorType,FlagType,2> {
  typedef typename VectorType::InternalDataType DataType;
  typedef Criterion<VectorType,FlagType,2> base;
public:
  typedef typename base::grid_fct_type grid_fct_type;
  typedef typename base::flag_fct_type flag_fct_type;
  typedef typename base::grid_data_type grid_data_type;

  StdCriterion() : base() {}

  virtual ~StdCriterion() {}

  virtual void FlagByValue(grid_fct_type& work, flag_fct_type& flags,
                           const int& Time, const int& Level, 
                           const DataType& Tol, const FlagType& FlagValue,
                           const int comparison = 0, const int growby = 0) {

    int TStep = TimeStep(work,Level);
    forall(flags, Time, Level, c)
      BeginFastIndex2(work, work(Time+TStep,Level,c).bbox(), 
                      work(Time+TStep,Level,c).data(), DataType);        
      BeginFastIndex2(flags, flags(Time,Level,c).bbox(), 
                      flags(Time,Level,c).data(), FlagType);

      BBox OpBox = flags.interiorbbox(Time,Level,c);
      Coords& Os = OpBox.stepsize();
      BBox OpwBox = work(Time+TStep,Level,c).bbox();
      Coords& Ows = OpwBox.stepsize();

      for_2 (n, m, OpBox, Os)
        if ((comparison==0 && FastIndex2(work,n-n%Ows(0),m-m%Ows(1))>=Tol) ||
            (comparison==1 && FastIndex2(work,n-n%Ows(0),m-m%Ows(1))< Tol)) {
          if (growby<=0) 
            FastIndex2(flags,n,m) = FlagValue;
          else {
            BBox bbflag(2,n,m,n,m,Os(0),Os(1)); bbflag.grow(growby);
            flags(Time,Level,c).equals(FlagValue,bbflag);
          }
        }
      end_for

      EndFastIndex2(work);
      EndFastIndex2(flags);
    end_forall
  } 

  virtual void Difference(grid_fct_type& work, const int& Time, const int& Level, 
                          int* Offset1, int* Offset2) {

    int TStep = TimeStep(work,Level);
    forall(work, Time, Level, c)
      BBox OpBox = work.interiorbbox(Time,Level,c);
      Coords& OpBox_stepsize = OpBox.stepsize();
      BeginFastIndex2(work, work(Time,Level,c).bbox(), 
                      work(Time,Level,c).data(), DataType);
      BeginFastIndex2(workout, work(Time+TStep,Level,c).bbox(), 
                      work(Time+TStep,Level,c).data(), DataType);

      Coords o1 = Coords(2,Offset1)*OpBox_stepsize;
      Coords o2 = Coords(2,Offset2)*OpBox_stepsize;
      for_2 (n, m, OpBox, OpBox_stepsize)
        FastIndex2(workout,n,m) = std::max(FastIndex2(workout,n,m),
           std::fabs(FastIndex2(work,n+o1(0),m+o1(1))-FastIndex2(work,n+o2(0),m+o2(1))));
      end_for

      EndFastIndex2(work);
      EndFastIndex2(workout);
    end_forall
  }

  virtual void Abs(grid_data_type& work) {
    BBox OpBox = work.bbox();
    Coords& OpBox_stepsize = OpBox.stepsize();
    BeginFastIndex2(work, OpBox, work.data(), DataType);
    for_2 (n, m, OpBox, OpBox_stepsize)
      FastIndex2(work,n,m) = std::fabs(FastIndex2(work,n,m));
    end_for
    EndFastIndex2(work);
  }

  virtual void Max(grid_data_type& work, const DataType& val) {
    BBox OpBox = work.bbox();
    Coords& OpBox_stepsize = OpBox.stepsize();
    BeginFastIndex2(work, OpBox, work.data(), DataType);
    for_2 (n, m, OpBox, OpBox_stepsize)
      FastIndex2(work,n,m) = std::max(FastIndex2(work,n,m), val);
    end_for
    EndFastIndex2(work);
  }

  virtual void Min(grid_data_type& work, const DataType& val) {
    BBox OpBox = work.bbox();
    Coords& OpBox_stepsize = OpBox.stepsize();
    BeginFastIndex2(work, OpBox, work.data(), DataType);
    for_2 (n, m, OpBox, OpBox_stepsize)
      FastIndex2(work,n,m) = std::min(FastIndex2(work,n,m), val);
    end_for
    EndFastIndex2(work);
  }
};


template <class VectorType, class FlagType>
class StdCriterion<VectorType,FlagType,3> : 
  public Criterion<VectorType,FlagType,3> {
  typedef typename VectorType::InternalDataType DataType;
  typedef Criterion<VectorType,FlagType,3> base;
public:
  typedef typename base::grid_fct_type grid_fct_type;
  typedef typename base::flag_fct_type flag_fct_type;
  typedef typename base::grid_data_type grid_data_type;

  StdCriterion() : base() {}

  virtual ~StdCriterion() {}

  virtual void FlagByValue(grid_fct_type& work, flag_fct_type& flags,
                           const int& Time, const int& Level, 
                           const DataType& Tol, const FlagType& FlagValue,
                           const int comparison = 0, const int growby = 0) {

    int TStep = TimeStep(work,Level);
    forall(flags, Time, Level, c)
      BeginFastIndex3(work, work(Time+TStep,Level,c).bbox(), 
                      work(Time+TStep,Level,c).data(), DataType);        
      BeginFastIndex3(flags, flags(Time,Level,c).bbox(), 
                      flags(Time,Level,c).data(), FlagType);

      BBox OpBox = flags.interiorbbox(Time,Level,c);
      Coords& Os = OpBox.stepsize();
      BBox OpwBox = work(Time+TStep,Level,c).bbox();
      Coords& Ows = OpwBox.stepsize();

      for_3 (n, m, l, OpBox, Os)
        if ((comparison==0 && FastIndex3(work,n-n%Ows(0),m-m%Ows(1),l-l%Ows(2))>=Tol) ||
            (comparison==1 && FastIndex3(work,n-n%Ows(0),m-m%Ows(1),l-l%Ows(2))< Tol)) {
          if (growby<=0) 
            FastIndex3(flags,n,m,l) = FlagValue;
          else {
            BBox bbflag(3,n,m,l,n,m,l,Os(0),Os(1),Os(2)); bbflag.grow(growby);
            flags(Time,Level,c).equals(FlagValue,bbflag);
          }
        }
      end_for

      EndFastIndex3(work);
      EndFastIndex3(flags);
    end_forall
  } 

  virtual void Difference(grid_fct_type& work, const int& Time, const int& Level, 
                          int* Offset1, int* Offset2) {

    int TStep = TimeStep(work,Level);
    forall(work, Time, Level, c)
      BBox OpBox = work.interiorbbox(Time,Level,c);
      Coords& OpBox_stepsize = OpBox.stepsize();
      BeginFastIndex3(work, work(Time,Level,c).bbox(), 
                      work(Time,Level,c).data(), DataType);
      BeginFastIndex3(workout, work(Time+TStep,Level,c).bbox(), 
                      work(Time+TStep,Level,c).data(), DataType);

      Coords o1 = Coords(3,Offset1)*OpBox_stepsize;
      Coords o2 = Coords(3,Offset2)*OpBox_stepsize;
      for_3 (n, m, l, OpBox, OpBox_stepsize)
        FastIndex3(workout,n,m,l) = std::max(FastIndex3(workout,n,m,l),
           std::fabs(FastIndex3(work,n+o1(0),m+o1(1),l+o1(2))-FastIndex3(work,n+o2(0),m+o2(1),l+o2(2))));
      end_for

      EndFastIndex3(work);
      EndFastIndex3(workout);
    end_forall
  }

  virtual void Abs(grid_data_type& work) {
    BBox OpBox = work.bbox();
    Coords& OpBox_stepsize = OpBox.stepsize();
    BeginFastIndex3(work, OpBox, work.data(), DataType);
    for_3 (n, m, l, OpBox, OpBox_stepsize)
      FastIndex3(work,n,m,l) = std::fabs(FastIndex3(work,n,m,l));
    end_for
    EndFastIndex3(work);
  }

  virtual void Max(grid_data_type& work, const DataType& val) {
    BBox OpBox = work.bbox();
    Coords& OpBox_stepsize = OpBox.stepsize();
    BeginFastIndex3(work, OpBox, work.data(), DataType);
    for_3 (n, m, l, OpBox, OpBox_stepsize)
      FastIndex3(work,n,m,l) = std::max(FastIndex3(work,n,m,l), val);
    end_for
    EndFastIndex3(work);
  }

  virtual void Min(grid_data_type& work, const DataType& val) {
    BBox OpBox = work.bbox();
    Coords& OpBox_stepsize = OpBox.stepsize();
    BeginFastIndex3(work, OpBox, work.data(), DataType);
    for_3 (n, m, l, OpBox, OpBox_stepsize)
      FastIndex3(work,n,m,l) = std::min(FastIndex3(work,n,m,l), val);
    end_for
    EndFastIndex3(work);
  }
};


#endif

---