weno/applications/euler/3d/InclinedJet/src/Problem.h

// -*- C++ -*-

#ifndef AMROC_PROBLEM_H
#define AMROC_PROBLEM_H

#define DIM  3
#define NEQUATIONS 9  // Euler equations for gases in 3D (5 fields), 
                       // +1 fields for passive scalars
                       // +1 field for temperature
                       // +1 feild to output dcflag and 
                       // +1 fieldsgske
#define NVARS     6   // Fixup used only for vector of state and 2 scalars


#include "WENOProblem.h"
//#include "WENOStdProblem.h"

#define OWN_GFMAMRSOLVER
#define OWN_FLAGGING
#define NZONES 1
#include "WENOStdGFMProblem.h"

#define f_init_commongm FORTRAN_NAME(comblgm, COMBLGM)
extern "C" {
  void f_init_commongm(const INTEGER& dim, INTEGER* shape, DOUBLE* geom,
                       INTEGER& maxlev, INTEGER* refine);
}

class FlaggingSpecific : 
  public AMRFlagging<VectorType,FixupType,FlagType,DIM> {
  typedef AMRFlagging<VectorType,FixupType,FlagType,DIM> base;
public:
  FlaggingSpecific(base::solver_type& solver) : base(solver) {
      base::AddCriterion(new ByValue<VectorType,FlagType,DIM>());
      base::AddCriterion(new ScaledGradient<VectorType,FlagType,DIM>());
      base::AddCriterion(new LimiterType<VectorType,FlagType,DIM>());
      base::AddCriterion(new AbsoluteError<VectorType,FixupType,FlagType,DIM>(solver));
      base::AddCriterion(new RelativeError<VectorType,FixupType,FlagType,DIM>(solver));
#ifdef f_flgout
      base::AddCriterion(new F77ByValue<VectorType,FlagType,DIM>(f_flgout));
      base::AddCriterion(new F77ScaledGradient<VectorType,FlagType,DIM>(f_flgout));
      base::AddCriterion(new F77LimiterType<VectorType,FlagType,DIM>(f_flgout));
      base::AddCriterion(new F77AbsoluteError<VectorType,FixupType,FlagType,DIM>(solver,f_flgout));
      base::AddCriterion(new F77RelativeError<VectorType,FixupType,FlagType,DIM>(solver,f_flgout));
#endif
    }

  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::register_at(Ctrl, prefix);
    char VariableName[32];
    for (int iz=0; iz < NZONES ; iz++)
      for (int d=0; d<DIM; d++) {
        sprintf(VariableName,"DCellsMin%d(%d)",iz+1,d+1);
        RegisterAt(base::LocCtrl,VariableName,dcmin[iz][d]);
        sprintf(VariableName,"DCellsMax%d(%d)",iz+1,d+1);
        RegisterAt(base::LocCtrl,VariableName,dcmax[iz][d]);
      } 
  }
  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl, "");
  }

  virtual void SetFlags(const int Time, const int Level, double t, double dt) {
    base::SetFlags(Time, Level, t, dt);
    //int max_level = MaxLevel(base::GH());
    for ( int iz = 0 ; iz < NZONES ; iz ++ ) {
      Coords lb(base::Dim(), dcmin[iz]), ub(base::Dim(), dcmax[iz]), 
        s(base::Dim(),1);
      BBox bbox(lb*StepSize(base::GH(),0), ub*StepSize(base::GH(),0),
                s*StepSize(base::GH(),0));
      bbox.refine(StepSize(base::GH(),0)/StepSize(base::GH(),Level));
      
      forall (base::Flags(),Time,Level,c)  
          base::Flags()(Time,Level,c).equals(BadPoint, bbox);
      end_forall
    }
  }

  ~FlaggingSpecific() { DeleteAllCriterions(); }
private:
  int dcmin[NZONES][DIM], dcmax[NZONES][DIM];
};

class SolverSpecific : 
  public AMRGFMSolver<VectorType,FixupType,FlagType,DIM> {
  typedef VectorType::InternalDataType DataType;
  typedef AMRGFMSolver<VectorType,FixupType,FlagType,DIM> base;
  typedef WENOF77GFMFileOutput<VectorType,FixupType,FlagType,DIM> output_type;
public:

  SolverSpecific(IntegratorSpecific& integ, 
                 base::initial_condition_type& init,
                 base::boundary_conditions_type& bc) : base(integ, init, bc) {
    SetLevelTransfer(new F77LevelTransfer<VectorType,DIM>(f_prolong, f_restrict));
#ifdef f_flgout
    SetFileOutput(new WENOF77GFMFileOutput<VectorType,FixupType,FlagType,DIM>(*this,f_flgout,f_bounds)); 
#else   
    SetFileOutput(new GFMFileOutput<VectorType,FixupType,FlagType,DIM>(*this)); 
#endif
    SetFixup(new FixupSpecific());
    SetFlagging(new FlaggingSpecific(*this)); 
    AddGFM(new GhostFluidMethod<VectorType,DIM>(
              new F77GFMBoundary<VectorType,DIM>(f_ibndrfl,f_itrans),
              new F77GFMLevelSet<DataType,DIM>(f_lset)));
  }  

  virtual void SetupData() {
    int dim = DIM;
    base::SetupData();
    f_init_commongm(dim,shape,geom,MaxLev,_RefineFactor);
  }
 
  ~SolverSpecific() {
    DeleteGFM(_GFM[0]);
    delete _Flagging;
    delete _Fixup;
  }