clawpack/applications/euler/3d/Conical_Shocktube/src/Problem.h

#ifndef AMROC_PROBLEM_H
#define AMROC_PROBLEM_H

#include "euler3.h"
#include "ClpProblem.h"
// add the track FORTRAN function used in finding the shock location
#define f_track FORTRAN_NAME(track, TRACK)

extern "C" {
  void f_track(const INTEGER &, const DOUBLE *, const DOUBLE *, DOUBLE *, INTEGER&,
               const DOUBLE&, const DOUBLE&, const DOUBLE&,
               DOUBLE&, DOUBLE&, DOUBLE&, DOUBLE&, DOUBLE&, DOUBLE&); 
}

#define OWN_GFMAMRSOLVER
#include "ClpStdGFMProblem.h"
#include "AMRGFMInterpolation.h"

class SolverSpecific : 
  public AMRGFMSolver<VectorType,FixupType,FlagType,DIM> {
  typedef VectorType::InternalDataType DataType;
  typedef AMRGFMSolver<VectorType,FixupType,FlagType,DIM> base;
  typedef AMRGFMInterpolation<VectorType,FixupType,FlagType,DIM> interpolation_type;
  typedef interpolation_type::point_type point_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 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(integ));
    SetFlagging(new FlaggingSpecific(*this)); 
    AddGFM(new GhostFluidMethod<VectorType,DIM>(
              new F77GFMBoundary<VectorType,DIM>(f_ibndrfl,f_itrans),
              new F77GFMLevelSet<DataType,DIM>(f_lset)));
    _Interpolation = new interpolation_type(*this);
  }  
 
  ~SolverSpecific() {
    DeleteGFM(_GFM[0]);
    delete _Flagging;
    delete _Fixup;
    delete _Interpolation;
  }

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

  virtual double Tick(int VariableTimeStepping, const double dtv[], const double cflv[],
                      int& Rejections) {

    double cfl = base::Tick(VariableTimeStepping, dtv, cflv, Rejections);

    int me = MY_PROC; 
    int Npoints;
    int finelevel = FineLevel(base::GH());
    Npoints = base::shape[0]*RefinedBy(base::GH(),finelevel);
    double dx = DeltaX(base::GH(),0,finelevel);
    
    double pmax = 0.0;
    // double rpmaxloc = -1.0;
    double shk_pos = -0.12;
    double aMa,aMb,aMc,aMd,aMe,aMm;
    // the min and max pressure ranges expected
    double fmin = 150., fmax = 200000.;
    double dfmin = 0.1;
    double x0rdi = 0.424779, y0rdi, z0rdi; 
    double reflection_time = 0.00021;
 

    // look along the ray (x=[-.12 ,0.4338],y=0,z=0 )
    DataType* p = new DataType[Npoints];
    DataType* r = new DataType[Npoints];
    DataType* xr = new DataType[Npoints];
    point_type* xc = new point_type[Npoints];
    
    // the probe diameter is 3.2mm
    y0rdi = .0011314;
    z0rdi = .0011314;
     

    register int n;
    
    // discretize the ray - into Npoints points xc[n](dim)
    for (n=0; n<Npoints; n++) {
      r[n] =  base::geom[0]+Npoints*dx -(n+0.5)*dx;

      if((r[n])>x0rdi) {
        xc[n](0) = x0rdi; 
      } else {
        xc[n](0) = r[n];
      } 

      xc[n](1) = y0rdi;
      xc[n](2) = z0rdi;
    }
    
    for (register int l=0; l<=FineLevel(base::GH()); l++) {
      int Time = CurrentTime(base::GH(),l);
      int press_cnt = base::Dim()+4;
      ((output_type*) _FileOutput)->Transform(base::U(), base::Work(), Time, l, 
                                              press_cnt, base::t[l]);
    }

    // get the interpolated pressure values
    _Interpolation->PointsValues(base::Work(),base::t[0],Npoints,xc,p);
    _Interpolation->ArrayCombine(VizServer,Npoints,p);

    if (me == VizServer) {
      int nc;
      for (n=0; n<Npoints; n++) 
        if (p[n]>pmax) {
          pmax = p[n];
          // rpmaxloc = xc[n](0);
        }
      if (base::t[0]<reflection_time) {
        dfmin = 0.0000001;
        f_track(Npoints,p,r,xr,nc,fmin,fmax,dfmin,aMa,aMb,aMc,aMd,aMe,aMm);
        // 0 is the point with the largest x-coordinate (see indexing above)
        // so this is the shock location closes to the appex of the cone.
        shk_pos = xr[0];
      }
      else {
        dfmin = 0.1;
        f_track(Npoints,p,r,xr,nc,fmin,fmax,dfmin,aMa,aMb,aMc,aMd,aMe,aMm);
        // nc-1 is the point with the smallest x-coordinate (see indexing above)
        shk_pos = xr[nc-1];
      }
    }

      
    delete [] p;
    delete [] r;
    delete [] xr;       
    delete [] xc;

    // done extracting the shock locations along the ray
    // now output the locations to the file shk.dat
     
    if (me == VizServer) {
      std::ofstream outfile;
      std::ostream* out;
      std::string fname = "shk.dat";
      outfile.open(fname.c_str(), std::ios::out | std::ios::app);
      out = new std::ostream(outfile.rdbuf());
      // output the time and the max pressure
      *out << base::t[0] << " " << shk_pos << " " << pmax;
      // also output the shock location
      *out << " " << aMa << " " << aMb << " " << aMc;
      *out << " " << aMd << " " << aMe << " " << aMm;
      *out << std::endl;
      outfile.close();
      delete out;      
    }
    return cfl;
  } 

  protected:
  interpolation_type* _Interpolation;