WENOStdSyncTimeProblem.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, Carlos Pantano

#ifndef AMROC_WENO_STD_SYNCTIME_PROBLEM_H
#define AMROC_WENO_STD_SYNCTIME_PROBLEM_H

#include "AMRSolverSyncTime.h" 
#include "AMRPreAdaptSolverSyncTime.h" 

class IntegratorSpecific :  
  public WENOIntegrator<VectorType,DIM> {
  typedef WENOIntegrator<VectorType,DIM> base;
public:   
  IntegratorSpecific() : 
    WENOIntegrator<VectorType,DIM>(f_rkstep,f_bounds,f_check) {
    base::SetNoTimeRefine(1);
  }
};
  
class FixupSpecific : 
  public AMRFixup<VectorType,FixupType,DIM> {
public:
  FixupSpecific() : AMRFixup<VectorType,FixupType,DIM>() {}
};

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

#ifndef OWN_FLAGGING
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
    }

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

#ifndef OWN_AMRSOLVER
class SolverSpecific : 
  public AMRSolverSyncTime<VectorType,FixupType,FlagType,DIM> {
  typedef AMRSolverSyncTime<VectorType,FixupType,FlagType,DIM> base;
  typedef AMRFixup<VectorType,FixupType,DIM> weno_fixup_type;
  typedef WENOIntegrator<VectorType,DIM> weno_integ_type;
public:
  SolverSpecific(IntegratorSpecific& integ, 
                 base::initial_condition_type& init,
                 base::boundary_conditions_type& bc) :
    AMRSolverSyncTime<VectorType,FixupType,FlagType,DIM>(integ, init, bc) {
    SetLevelTransfer(new F77LevelTransfer<VectorType,DIM>(f_prolong, f_restrict));
#ifdef f_flgout
    SetFileOutput(new F77FileOutput<VectorType,DIM>(f_flgout)); 
#else   
    SetFileOutput(new FileOutput<VectorType,DIM>()); 
#endif
    SetFixup(new FixupSpecific());
    SetFlagging(new FlaggingSpecific(*this)); 
  }

  ~SolverSpecific() {
    delete _LevelTransfer;
    delete _Flagging;
    delete _Fixup;
    delete _FileOutput;
  }
}; 
#endif 
 
class SolverControlSpecific : 
  public SolverControl {
public:
  SolverControlSpecific(AMRSolverSyncTime<VectorType,FixupType,FlagType,DIM>& solver) : 
    SolverControl(solver) {}
}; 


#endif