ClpStdProblem.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2002 Ralf Deiterding
// Brandenburgische Universitaet Cottbus
//
// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@amroc.net

#ifndef AMROC_CLP_STD_PROBLEM_H
#define AMROC_CLP_STD_PROBLEM_H

#ifndef OWN_INTEGRATOR
# if DIM == 1
class IntegratorSpecific :  
  public ClpIntegrator<VectorType,AuxType,DIM> {
public:   
  IntegratorSpecific() : 
    ClpIntegrator<VectorType,AuxType,DIM>(NEQUSED,NWAVES,f_normalflux,
                                          f_check,f_setaux,f_source) {}
};
# else
class IntegratorSpecific :  
  public ClpIntegrator<VectorType,AuxType,DIM> {
public:   
  IntegratorSpecific() : 
    ClpIntegrator<VectorType,AuxType,DIM>(NEQUSED,NWAVES,f_normalflux,f_transverseflux,
                                          f_check,f_setaux,f_source) {}
};
# endif
#endif
  
#ifndef OWN_FIXUP
class FixupSpecific : 
  public ClpFixup<VectorType,FixupType,AuxType,DIM> {
public:
  FixupSpecific(ClpIntegrator<VectorType,AuxType,DIM>& integ) :
    ClpFixup<VectorType,FixupType,AuxType,DIM>(integ) {}
};
#endif

#ifndef OWN_INITIALCONDITION
class InitialConditionSpecific : 
  public F77InitialCondition<VectorType,DIM> {
public:    
  InitialConditionSpecific() : 
    F77InitialCondition<VectorType,DIM>(f_initial) {}
};
#endif
  
#ifndef OWN_BIUNDARYCONDITION
class BoundaryConditionsSpecific : 
  public F77BoundaryConditions<VectorType,DIM> {
public:    
  BoundaryConditionsSpecific() : 
    F77BoundaryConditions<VectorType,DIM>(f_boundary) {}
};
#endif

#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 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 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(integ));
    SetFlagging(new FlaggingSpecific(*this)); 
  }  

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


#endif