F77Criteria.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_F77_CRITERIA_H
#define AMROC_F77_CRITERIA_H

#include "Criteria/ByValue.h"
#include "Criteria/ScaledGradient.h"
#include "Criteria/AbsoluteError.h"
#include "Criteria/LimiterType.h"
#include "Criteria/RelativeError.h"
#include "F77Interfaces/F77FileOutput.h"

template <class VectorType, class FlagType, int dim>
class F77ByValue : public F77OutBase<VectorType,dim>,
  public ByValue<VectorType,FlagType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef ByValue<VectorType,FlagType,dim> base;
  typedef F77OutBase<VectorType,dim> out_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 out_base::generic_func_type generic_func_type;

  F77ByValue(generic_func_type out) : out_base(out), base() {}

  virtual ~F77ByValue() {}
  
  virtual void register_at(ControlDevice& Ctrl) { base::register_at(Ctrl, "F77"); }
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) 
  { base::register_at(Ctrl, "F77"); }

  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 (base::Tol(cnt) <= 0.0 || 
        (base::MaxLevel(cnt)<Level && base::MaxLevel(cnt)>=0)) return false;
    out_base::Transform(u,work,Time,Level,cnt+1,t);
    int TStep = TimeStep(work,Level);
    forall(work,Time+TStep,Level,c)
      work(Time+TStep,Level,c).equals(work(Time,Level,c));
    end_forall 
    base::FlagByValue(work, flags, Time, Level, base::Tol(cnt), FlagValue, 
                      base::_Comparison[cnt]);
    return true;
  }

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


template <class VectorType, class FlagType, int dim>
class F77ScaledGradient : public F77OutBase<VectorType,dim>,
  public ScaledGradient<VectorType,FlagType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef ScaledGradient<VectorType,FlagType,dim> base;
  typedef F77OutBase<VectorType,dim> out_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 out_base::generic_func_type generic_func_type;

  F77ScaledGradient(generic_func_type out) : out_base(out), base() {}

  virtual ~F77ScaledGradient() {}
  
  virtual void register_at(ControlDevice& Ctrl) { base::register_at(Ctrl, "F77"); }
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) 
  { base::register_at(Ctrl, "F77"); }

  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 (base::Tol(cnt) <= 0.0 || 
        (base::MaxLevel(cnt)<Level && base::MaxLevel(cnt)>=0)) return false;
    out_base::Transform(u,work,Time,Level,cnt+1,t);
    return base::FlagByScaledGradient(work, flags, Time, Level, base::Tol(cnt), FlagValue);
  }

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


template <class VectorType, class Fixup, class FlagType, int dim>
class F77AbsoluteError : public F77OutBase<VectorType,dim>,
  public AbsoluteError<VectorType,Fixup,FlagType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef AbsoluteError<VectorType,Fixup,FlagType,dim> base;
  typedef F77OutBase<VectorType,dim> out_base;
public:
  typedef typename base::solver_type solver_type;
  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 out_base::generic_func_type generic_func_type;

  F77AbsoluteError(solver_type& solver, generic_func_type out) : out_base(out), base(solver) {}

  virtual ~F77AbsoluteError() {}
  
  virtual void register_at(ControlDevice& Ctrl) { base::register_at(Ctrl, "F77"); }
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) 
  { base::register_at(Ctrl, "F77"); }

  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 (base::Tol(cnt) <= 0.0 || Time==0 || 
        (base::MaxLevel(cnt)<Level && base::MaxLevel(cnt)>=0)) return false;
    int TStep = TimeStep(work,Level);
    out_base::Transform(u,work,Time,Level,cnt+1,t);
    out_base::Transform(u,work,Time+TStep,Level,cnt+1,t);
    forall(work,Time,Level,c)
      work(Time+TStep,Level,c).minus(work(Time,Level,c));
      base::Abs(work(Time+TStep,Level,c));
      work(Time+TStep,Level,c).divide(base::Order);
    end_forall 
    base::FlagByValue(work, flags, Time, Level, base::Tol(cnt), FlagValue);
    return true;
  }

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


template <class VectorType, class FlagType, int dim>
class F77LimiterType : public F77OutBase<VectorType,dim>,
  public LimiterType<VectorType,FlagType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef LimiterType<VectorType,FlagType,dim> base;
  typedef F77OutBase<VectorType,dim> out_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 out_base::generic_func_type generic_func_type;

  F77LimiterType(generic_func_type out) : out_base(out), base() {}

  virtual ~F77LimiterType() {}
  
  virtual void register_at(ControlDevice& Ctrl) { base::register_at(Ctrl, "F77"); }
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) 
  { base::register_at(Ctrl, "F77"); }

  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 (base::Tol(cnt) <= 0.0 || base::Sc(cnt)<=0.0 || 
        (base::MaxLevel(cnt)<Level && base::MaxLevel(cnt)>=0)) return false;
    out_base::Transform(u,work,Time,Level,cnt+1,t);
    return base::FlagByLimiter(work, flags, Time, Level, base::Tol(cnt), base::Sc(cnt), FlagValue);
  }

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


template <class VectorType, class Fixup, class FlagType, int dim>
class F77RelativeError : public F77OutBase<VectorType,dim>,
  public RelativeError<VectorType,Fixup,FlagType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef RelativeError<VectorType,Fixup,FlagType,dim> base;
  typedef F77OutBase<VectorType,dim> out_base;
public:
  typedef typename base::solver_type solver_type;
  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 out_base::generic_func_type generic_func_type;

  F77RelativeError(solver_type& solver, generic_func_type out) : out_base(out), base(solver) {}

  virtual ~F77RelativeError() {}
  
  virtual void register_at(ControlDevice& Ctrl) { base::register_at(Ctrl, "F77"); }
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) 
  { base::register_at(Ctrl, "F77"); }

  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 (base::Tol(cnt) <= 0.0 || base::Sc(cnt)<=0.0 || Time==0 || 
        (base::MaxLevel(cnt)<Level && base::MaxLevel(cnt)>=0)) return false;
    int TStep = TimeStep(work,Level);
    out_base::Transform(u,work,Time,Level,cnt+1,t);
    out_base::Transform(u,work,Time+TStep,Level,cnt+1,t);
    forall(u,Time,Level,c)
      work(Time+TStep,Level,c).minus(work(Time,Level,c));
      base::Abs(work(Time+TStep,Level,c));
    end_forall 

    if (base::OutputFlags() && base::Solver_().LastOutputTime()==Time && Level==0) {
      DataType Maxv = MaxVal(work, Time, 0);
      if (MY_PROC == VizServer) 
        std::cout << " F77Max(" << cnt+1 << ") on L0=" << Maxv << "  ";   
    }
          
    forall(u,Time,Level,c)
      base::Abs(work(Time,Level,c));
      base::Max(work(Time,Level,c),base::Sc(cnt));
      work(Time+TStep,Level,c).divide(work(Time,Level,c));
      work(Time+TStep,Level,c).divide(base::Order);
    end_forall 

    base::FlagByValue(work, flags, Time, Level, base::Tol(cnt), FlagValue);
    return true;
  }

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

#endif

---