amroc/weno/WENOStdProblem.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@cacr.caltech.edu

#ifndef AMROC_WENO_STD_PROBLEM_H
#define AMROC_WENO_STD_PROBLEM_H

class IntegratorSpecific :  
  public WENOIntegrator<VectorType,DIM> {
public:   
  IntegratorSpecific() : 
    WENOIntegrator<VectorType,DIM>(f_rkstep,f_bounds,f_check) {}
};
  
class FixupSpecific : 
  public WENOFixup<VectorType,FixupType,DIM> {
public:
  FixupSpecific() : WENOFixup<VectorType,FixupType,DIM>() {}
};

#ifndef OWN_INITIALCONDITION
class InitialConditionSpecific : 
  public F77InitialCondition<VectorType,DIM> {
public:    
  InitialConditionSpecific() : 
    F77InitialCondition<VectorType,DIM>(f_initial) {}
};
#endif
  
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 FlagRegions<VectorType,FlagType,DIM>());
      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(); }

  virtual void init() {
    base::init();
    base::AddCriterion(new UnflagRegions<VectorType,FlagType,DIM>());
  }
};
#endif 

#ifndef OWN_AMRSOLVER
class SolverSpecific : 
  public AMRSolver<VectorType,FixupType,FlagType,DIM> {
  typedef AMRSolver<VectorType,FixupType,FlagType,DIM> base;
  typedef WENOFixup<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) :
    AMRSolver<VectorType,FixupType,FlagType,DIM>(integ, init, bc) {
    SetLevelTransfer(new F77LevelTransfer<VectorType,DIM>(f_prolong, f_restrict));
#ifdef f_flgout
    SetFileOutput(new WENOF77FileOutput<VectorType,DIM>(f_flgout,f_bounds)); 
#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(AMRSolver<VectorType,FixupType,FlagType,DIM>& solver) : 
    SolverControl(solver) {}
}; 


#endif