clawpack/applications/scaling/2d/ConvShock/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 "eulerznd2.h"
#include "ClpProblem.h"

#define f_lsetrdi FORTRAN_NAME(lsrdi, LSRDI)

extern "C" {
  void f_lsetrdi();
}

#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 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_ibndex,f_itrans),
              new F77GFMLevelSet<DataType,DIM>(f_lset)));
    AddGFM(new GhostFluidMethod<VectorType,DIM>(
              new F77GFMBoundary<VectorType,DIM>(f_ibndrfl,f_itrans),
              new F77GFMLevelSet<DataType,DIM>(f_lsetrdi)));
    last[0]=0.; last[1]=0.; last[2]=0.;
    TraceDumpEvery = 1;
  }  
 
  ~SolverSpecific() {
    DeleteGFM(_GFM[0]);
    DeleteGFM(_GFM[1]);
    delete _Flagging;
    delete _Fixup;
  }

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

  virtual void Initialize(double& t, double& dt) {
    base::Initialize(t,dt);
    TraceDump(0);
  }

  virtual void Advance(double& t, double& dt) {
    base::Advance(t,dt);
    int TimeZero  = CurrentTime(base::GH(),0);
    TimeZero /= RefinedBy(base::GH(),MaxLevel(base::GH()));
    if (TimeZero%TraceDumpEvery==0 && TraceDumpEvery>0) 
      TraceDump(TimeZero/TraceDumpEvery);
  }

  void TraceDump(int time) {
    int me = MY_PROC; 
#ifdef TIMING_AMR
    double stats[3], current[3];
    timing.collect_timing(comm_service::comm(),Timing::INTEGRATION_MAIN,current);
    timing.collect_timing(comm_service::comm(),Timing::INTEGRATION_ESTIMATE,stats);
    if (me == VizServer) {
      current[0]+=stats[0]; current[1]+=stats[1]; current[2]+=stats[2];
    }
    timing.collect_timing(comm_service::comm(),Timing::INTEGRATION_SHADOW,stats);
    if (me == VizServer) {
      current[0]+=stats[0]; current[1]+=stats[1]; current[2]+=stats[2];
    }
    timing.collect_timing(comm_service::comm(),Timing::SOURCE_INTEGRATION,stats);
    if (me == VizServer) {
      current[0]+=stats[0]; current[1]+=stats[1]; current[2]+=stats[2];
    }
    if (me == VizServer) {
      stats[0] = current[0]-last[0]; stats[1] = current[1]-last[1]; stats[2] = current[2]-last[2]; 
      std::ofstream ofst("balance.txt", std::ios::out | std::ios::app);
      char str[128];
      std::sprintf(str, "\t%3.9f    %2.4f    %2.4f    %2.4f", base::t[0], 
                   (stats[2]>0. ? stats[0]/stats[2] : 1.),
                   (stats[2]>0. ? stats[1]/stats[2] : 1.),
                   (stats[2]>0. ? (stats[0]-stats[1])/stats[2] : 1.));
      ofst << time << str << std::endl;
      ofst.close();
    }
#endif

    if (me == VizServer) {
      int id=0;
      std::ofstream ofs("trace.txt", std::ios::out | std::ios::app);
      for (register int l=0; l<=FineLevel(base::GH()); l++)
        for (GridBox *gb=base::GH().ggbl(l)->first();gb;gb=base::GH().ggbl(l)->next())
          dumpBox(gb->gbBBox(), l, gb->gbOwner(), time, id++, ofs);
      ofs.close();
    }
  }

  void dumpBox(const BBox &bb, int l, int proc, int time, int id, std::ofstream &ofs) {
    ofs << time << "\t" << proc << "\t" << l << "\t" << id <<"\t";
    ofs << bb.extents(0) <<"\t";
    if (bb.rank>1) ofs << bb.extents(1) <<"\t";
    else ofs << "-1\t";
    if (bb.rank>2) ofs << bb.extents(2) <<"\t";
    else ofs << "-1\t";
    ofs << bb.lower(0) <<"\t";
    if (bb.rank>1) ofs << bb.lower(1) <<"\t";
    else ofs << "-1\t";
    if (bb.rank>2) ofs << bb.lower(2) <<"\t";
    else ofs << "-1\t";
    ofs << bb.upper(0) <<"\t";
    if (bb.rank>1) ofs << bb.upper(1) <<"\t";
    else ofs << "-1\t";
    if (bb.rank>2) ofs << bb.upper(2) <<"\t";
    else ofs << "-1\t";
    ofs << std::endl;
  }

protected:
  double last[3];
  int TraceDumpEvery;