clawpack/applications/intro/3d/Explosion/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 "DAGH.h"                           
#include "IO/control-device.h"
#include "Vector.h"
#include "VectorLarge.h"

#define DIM        3
#define NEQUATIONS 5
typedef DOUBLE DataType;
typedef Vector<DataType,NEQUATIONS> VectorType;

#include "DAGHFortranInterfaces.h"                           

//----------------------------------------------------------------------
// Clawpack integrator in Fortran 77 without usage of auxiliary array aux and 
// source term integration
//----------------------------------------------------------------------

#define NEQUSED    5
#define NWAVES     3
#define NAUX       0
typedef Vector<DataType,NAUX> AuxType;
   
#define f_step_3 FORTRAN_NAME(step3, STEP3)
#define f_normalflux FORTRAN_NAME(rpn3eu, RPN3EU)
#define f_transverseflux FORTRAN_NAME(rpt3eu, RPT3EU)

extern "C" {
  void f_step_3();
  void f_normalflux();
  void f_transverseflux();
}

#include "ClpIntegrator3.h"  

class IntegratorSpecific :  
  public ClpIntegrator<VectorType,AuxType,DIM> {
public:   
  IntegratorSpecific() : 
    ClpIntegrator<VectorType,AuxType,DIM>(NEQUSED,NWAVES,f_normalflux,f_transverseflux) {}
};

//----------------------------------------------------------------------
// Initial conditions in Fortran 77
//----------------------------------------------------------------------

#define f_initial FORTRAN_NAME(ic, IC)

extern "C" {
  void f_initial();
}

#include "F77Interfaces/F77InitialCondition.h"  

class InitialConditionSpecific : 
  public F77InitialCondition<VectorType,DIM> {
public:    
  InitialConditionSpecific() : 
    F77InitialCondition<VectorType,DIM>(f_initial) {}
};

//----------------------------------------------------------------------
// Boundary conditions in Fortran 77
//----------------------------------------------------------------------

#define f_boundary FORTRAN_NAME(physbd, PHYSBD)

extern "C" {
  void f_boundary();
}

#include "F77Interfaces/F77BoundaryConditions.h"  

class BoundaryConditionsSpecific : 
  public F77BoundaryConditions<VectorType,DIM> {
public:    
  BoundaryConditionsSpecific() : 
    F77BoundaryConditions<VectorType,DIM>(f_boundary) {}
};

//----------------------------------------------------------------------
// Inter-level operators in Fortran 77
//----------------------------------------------------------------------

#define f_restrict FORTRAN_NAME(restrict3, RESTRICT3)
#define f_prolong FORTRAN_NAME(prolong3, PROLONG3)

extern "C" {
  void f_restrict();
  void f_prolong();
}

#include "F77Interfaces/F77LevelTransfer.h"  

class LevelTransferSpecific : 
  public F77LevelTransfer<VectorType,DIM> {
public:    
  LevelTransferSpecific() : 
    F77LevelTransfer<VectorType,DIM>(f_prolong, f_restrict) {}
};

//----------------------------------------------------------------------
// Flux correction
//----------------------------------------------------------------------

#define NFIXUP     5   
typedef Vector<DataType,NFIXUP> FixupType;

#include "AMRFixup.h"  

class FixupSpecific : public AMRFixup<VectorType,FixupType,DIM> {
public:
  FixupSpecific() : AMRFixup<VectorType,FixupType,DIM>() {}
};

//----------------------------------------------------------------------
// Flagging for refinement
//----------------------------------------------------------------------

typedef short FlagType; 

#include "AMRFlagging.h"
#include "Criteria/ScaledGradient.h"
#include "Criteria/AbsoluteError.h"

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 ScaledGradient<VectorType,FlagType,DIM>());
    base::AddCriterion(new AbsoluteError<VectorType,FixupType,FlagType,DIM>(solver));
  }

  ~FlaggingSpecific() { DeleteAllCriterions(); }
};

//----------------------------------------------------------------------
// Berger-Collela AMR algorithmus
//----------------------------------------------------------------------

#include "AMRSolver.h" 

class SolverSpecific : 
  public AMRSolver<VectorType,FixupType,FlagType,DIM> {
  typedef AMRSolver<VectorType,FixupType,FlagType,DIM> base;
public:
  SolverSpecific(IntegratorSpecific& integ, 
                 base::initial_condition_type& init,
                 base::boundary_conditions_type& bc) :
    AMRSolver<VectorType,FixupType,FlagType,DIM>(integ, init, bc) {
    SetLevelTransfer(new LevelTransferSpecific());
    SetFileOutput(new FileOutput<VectorType,DIM>()); 
    SetFixup(new FixupSpecific());
    SetFlagging(new FlaggingSpecific(*this)); 
  }  

  ~SolverSpecific() {
    delete _LevelTransfer;
    delete _Flagging;
    delete _Fixup;
    delete _FileOutput;
  }
}; 
 
//----------------------------------------------------------------------
// Time stepping and file output
//----------------------------------------------------------------------

#include "SolverControl.h"

class SolverControlSpecific : 
  public SolverControl {
public:
  SolverControlSpecific(AMRSolver<VectorType,FixupType,FlagType,DIM>& solver) : 
    SolverControl(solver) {}