clawpack/applications/euler_chem/2d/PipeBend/src/Problem.h

// -*- C++ -*-

// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@amroc.net

#ifndef AMROC_PROBLEM_H
#define AMROC_PROBLEM_H

#include "eulerrhok2.h"

#define NEQUATIONS 14
#define NEQUSED    13
#define NFIXUP     12
#define NAUX        4

#include "ClpProblem.h"

#define OWN_FLAGGING
#define OWN_GFMAMRSOLVER
#include "ClpStdGFMProblem.h"
#include "F77Interfaces/F77UpdateLevelTransfer.h"
#include "SpecialOutput/AMRGridAccumulation.h"

class FlaggingSpecific : 
  public AMRFlagging<VectorType,FixupType,FlagType,DIM> {
  typedef AMRFlagging<VectorType,FixupType,FlagType,DIM> base;
public:
  FlaggingSpecific(solver_type& solver) : base(solver) {
      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));
      base::AddCriterion(new F77ScaledGradient<VectorType,FlagType,DIM>(f_flg));
      base::AddCriterion(new F77LimiterType<VectorType,FlagType,DIM>(f_flg));
      base::AddCriterion(new F77AbsoluteError<VectorType,FixupType,FlagType,DIM>(solver,f_flg));
      base::AddCriterion(new F77RelativeError<VectorType,FixupType,FlagType,DIM>(solver,f_flg));
    }
  ~FlaggingSpecific() { DeleteAllCriterions(); }
};

class SolverSpecific : 
  public AMRGFMSolver<VectorType,FixupType,FlagType,DIM> {
  typedef VectorType::InternalDataType DataType;
  typedef AMRGFMSolver<VectorType,FixupType,FlagType,DIM> base;
  typedef AMRGridAccumulation<DataType,DIM> accumulation_type;
  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 F77UpdateLevelTransfer<VectorType,DIM>(f_prolong, f_restrict, f_tupdate));
    SetFileOutput(new F77GFMFileOutput<VectorType,FixupType,FlagType,DIM>(*this,f_out)); 
    SetFixup(new FixupSpecific(integ));
    SetFlagging(new FlaggingSpecific(*this)); 
    AddGFM(new GhostFluidMethod<VectorType,DIM>(
              new F77GFMBoundary<VectorType,DIM>(f_ibndrfl,f_itrans),
              new F77GFMLevelSet<DataType,DIM>(f_lset)));
    _Accumulation = new accumulation_type();
    MaxType = 1;
  }  

  ~SolverSpecific() {
    delete _LevelTransfer;
    delete _Flagging;
    delete _Fixup;
    delete _FileOutput;
    delete _Accumulation;
  }

  virtual void register_at(ControlDevice& Ctrl) { base::register_at(Ctrl); }
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::register_at(Ctrl, prefix);
    RegisterAt(base::LocCtrl,"MaxType",MaxType);
    _Accumulation->register_at(base::LocCtrl, prefix);
  }

  virtual void SetupData() {
    base::SetupData();
    _Accumulation->SetupData(base::PGH(), base::NGhosts());
  }

  virtual void Initialize_(const double& dt_start) {
    base::Initialize_(dt_start);
    _Accumulation->Initialize();
  }

  virtual void Output() {
    int Time = CurrentTime(base::GH(),0);
    if (Time == base::LastOutputTime()) return;
    _Accumulation->GridCombine(VizServer);
    int me = MY_PROC; 
    if (me == VizServer) {
      int Level = _Accumulation->AccLevel();
      base::FileOutput_().WriteOut(_Accumulation->AccGrid(),_Accumulation->AccName(),
                                   Time,Level,base::t[0]);
    }
    base::Output();
  }

  virtual void Checkpointing_(const char* CheckpointFile) {
    base::Checkpointing_(CheckpointFile);
    _Accumulation->Checkpointing();
  }

  virtual bool Restart_(const char* CheckpointFile) {
    if (base::Restart_(CheckpointFile)) {
      _Accumulation->Restart();
      return true;
    }
    else
      return false;
  }

  virtual void AdvanceLevel(const int Level, int RegridEvery, bool RegridDone, 
                            bool ShadowAllowed, bool DoFixup,
                            bool RecomposeBaseLev, bool RecomposeHighLev) {

    base::AdvanceLevel(Level,RegridEvery,RegridDone,ShadowAllowed,
                       DoFixup,RecomposeBaseLev,RecomposeHighLev);

    int Time = CurrentTime(base::GH(),Level);
    if (MaxType) {
      AdaptiveBoundaryUpdate(base::U(),Time,Level);
      Sync(base::U(),Time,Level);
      ExternalBoundaryUpdate(base::U(),Time,Level);
      
      int irho = 1;
      int iu   = NEQUSED-DIM-2;
      int iv   = NEQUSED-DIM-1;
      int TStep = TimeStep(base::U(),Level);
      ((output_type*) base::_FileOutput)->Transform(base::U(), base::Work(), Time+TStep, 
                                                    Level, irho, base::t[Level]);
      forall (base::U(),Time,Level,c)
        Coords ss(base::U()(Time,Level,c).bbox().stepsize());
        BBox bbi(base::U().interiorbbox(Time,Level,c));
        BeginFastIndex2(U, base::U()(Time,Level,c).bbox(), 
                        base::U()(Time,Level,c).data(), VectorType);
        BeginFastIndex2(Work, Work()(Time,Level,c).bbox(), 
                        Work()(Time,Level,c).data(), DataType);
        BeginFastIndex2(WorkN, Work()(Time+TStep,Level,c).bbox(), 
                        Work()(Time+TStep,Level,c).data(), DataType);
        DataType uy, vx;
        DCoords dx = base::GH().worldStep(ss);
        for_2 (i, j, bbi, ss)
          vx = (FastIndex2(U,i+ss(0),j)(iv)/FastIndex2(WorkN,i+ss(0),j)-
                FastIndex2(U,i-ss(0),j)(iv)/FastIndex2(WorkN,i-ss(0),j))/(2.0*dx(0));
          uy = (FastIndex2(U,i,j+ss(1))(iu)/FastIndex2(WorkN,i,j+ss(1))-
                FastIndex2(U,i,j-ss(1))(iu)/FastIndex2(WorkN,i,j-ss(1)))/(2.0*dx(1));
          FastIndex2(Work,i,j) = std::fabs(vx-uy);
        end_for
        EndFastIndex2(U);      
        EndFastIndex2(Work);      
        EndFastIndex2(WorkN);      
      end_forall
    }
    else {
      int ipress = base::Dim()+4;      
      ((output_type*) base::_FileOutput)->Transform(base::U(), base::Work(), Time, Level, 
                                                    ipress, base::t[Level]);
    }
  
    _Accumulation->Accumulate(base::Work(), Time,  Level, base::t[Level]);
  }

protected:
  int MaxType;
  accumulation_type* _Accumulation;
}; 

#endif