amroc/lbm/LBMStdProblem.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2012 Oak Ridge National Laboratory
// Ralf Deiterding, deiterdingr@ornl.gov

#ifndef AMROC_LBM_STD_PROBLEM_H
#define AMROC_LBM_STD_PROBLEM_H

typedef LBMType::MicroType MicroType;
typedef Vector<DataType,0> FixupType;

#ifndef OWN_LBMSCHEME
class LBMSpecific : public LBMType {
public:
  LBMSpecific() : LBMType() {}
};
#endif

#ifndef OWN_INTEGRATOR
class IntegratorSpecific : public LBMIntegrator<LBMType,DIM> {
public:   
  IntegratorSpecific(LBMType &lbm) : LBMIntegrator<LBMType,DIM>(lbm) {}
};
#endif

#ifndef OWN_FIXUP
class FixupSpecific : 
  public LBMFixup<LBMType,FixupType,DIM> {
public:
  FixupSpecific(LBMType &lbm) : LBMFixup<LBMType,FixupType,DIM>(lbm) {}
};
#endif

#ifndef OWN_INITIALCONDITION
class InitialConditionSpecific : public LBMInitialCondition<LBMType,DIM> {
public:    
  InitialConditionSpecific(LBMType &lbm) : LBMInitialCondition<LBMType,DIM>(lbm) {}
};
#endif
  
#ifndef OWN_BOUNDARYCONDITION
class BoundaryConditionsSpecific : public LBMBoundaryConditions<LBMType,DIM> {
public:    
  BoundaryConditionsSpecific(LBMType &lbm) : LBMBoundaryConditions<LBMType,DIM>(lbm) {}
};
#endif

#ifndef OWN_FLAGGING
class FlaggingSpecific : 
  public AMRFlagging<MicroType,FixupType,FlagType,DIM> {
  typedef AMRFlagging<MicroType,FixupType,FlagType,DIM> base;
public:
  FlaggingSpecific(base::solver_type& solver, LBMType &lbm) : base(solver) {
    base::AddCriterion(new FlagRegions<MicroType,FlagType,DIM>());
    base::AddCriterion(new ByValue<MicroType,FlagType,DIM>());
    base::AddCriterion(new ScaledGradient<MicroType,FlagType,DIM>());
    base::AddCriterion(new LimiterType<MicroType,FlagType,DIM>());
    base::AddCriterion(new AbsoluteError<MicroType,FixupType,FlagType,DIM>(solver));
    base::AddCriterion(new RelativeError<MicroType,FixupType,FlagType,DIM>(solver));

    base::AddCriterion(new SchemeByValue<LBMType,FlagType,DIM>(lbm));
    base::AddCriterion(new SchemeScaledGradient<LBMType,FlagType,DIM>(lbm));
    base::AddCriterion(new SchemeLimiterType<LBMType,FlagType,DIM>(lbm));
    base::AddCriterion(new SchemeAbsoluteError<LBMType,FixupType,FlagType,DIM>(solver,lbm));
    base::AddCriterion(new SchemeRelativeError<LBMType,FixupType,FlagType,DIM>(solver,lbm));
  }

  ~FlaggingSpecific() { DeleteAllCriterions(); }

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

#ifndef OWN_AMRSOLVER
class SolverSpecific : 
  public AMRSolver<MicroType,FixupType,FlagType,DIM> {
  typedef AMRSolver<MicroType,FixupType,FlagType,DIM> base;
public:
  SolverSpecific(IntegratorSpecific& integ, 
                 base::initial_condition_type& init,
                 base::boundary_conditions_type& bc) : base(integ, init, bc) {
    SetLevelTransfer(new LBMF77LevelTransfer<LBMType,DIM>(integ.Scheme(), f_prolong, f_restrict));
    SetFileOutput(new SchemeFileOutput<LBMType,DIM>(integ.Scheme())); 
    SetFixup(new FixupSpecific(integ.Scheme()));
    SetFlagging(new FlaggingSpecific(*this,integ.Scheme())); 
  }  

  ~SolverSpecific() {
    delete _LevelTransfer;
    delete _Flagging;
    delete _Fixup;
    delete _FileOutput;
  }

  virtual void SetupData() {
    base::SetupData();
    base::NAMRTimeSteps = 1;
    base::AdaptBndTimeInterpolate = 0;
    base::Step[0].LastTime = 1.e37;
    base::Step[0].VariableTimeStepping = -1;
    base::Step[0].dtv[0] = ((LBMIntegrator<LBMType,DIM> &)Integrator_()).LBM().TimeScale();
  }
}; 
#endif
 
#ifndef OWN_SOLVERCONTROL
class SolverControlSpecific : 
  public SolverControl {
  typedef SolverControl base;
public:
  SolverControlSpecific(base::solver_type& solver) : 
    base(solver) {}
  
  virtual void update() { 
    base::update();
    base::HitLastTime=0;
  }
}; 
#endif 


#endif