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

// -*- C++ -*-

#ifndef AMROC_PROBLEM_H
#define AMROC_PROBLEM_H

#define DIM  2

#include "WENOProblem.h"

#define OWN_GFMAMRSOLVER
#define OWN_FLAGGING
#define NZONES 1

#include "WENOStdGFMProblem.h"

// ===

// Due to the underscore in the Fortran procedure name, an extra underscore will
// be added to its symbol. Therefore, instead of using FORTRAN_NAME, the macro
// FORTRAN_NAME_ should be used.
#define  f9x_lset          FORTRAN_NAME_(f9x_lset,F9X_LSET)
extern "C" {
   void f9x_lset();
};

#ifdef f_lset
#  undef f_lset
#endif /* f_lset */
#define  f_lset            f9x_lset

// ===

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 F77GFMFileOutput<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 F77GFMFileOutput<VectorType,FixupType,FlagType,DIM>(*this,f_flgout));
#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)));
      }

      ~SolverSpecific() {
         DeleteGFM(_GFM[0]);
         delete _Flagging;
         delete _Fixup;
      }
};
#endif

---