Prob.H

Go to the documentation of this file.

 
#ifndef _PROB_H_
#define _PROB_H_
 
#include <string>
#include <vector>
#include "../Core/CRPacket.H"
#include "../Core/CRSource.H"
#include "../Core/CRTree.H"
#include "../Core/Geometry.H"
#include "../Gas/Gas.H"
#include "../Gas/UniformGas.H"
#include "../IO/ParmParser.H"
#include "../Propagation/Propagation.H"
#include "../Propagation/PropPowerlaw.H"
#include "../Utils/RngThread.H"
#include "../Utils/Types.H"
#include "../Utils/Vec3.H"
 
namespace criptic {
 
  class Prob {
 
  public:
 
    Prob(const ParmParser& pp_,
     const Geometry& geom_,
     RngThread& rng_) : pp(pp_), geom(geom_), rng(rng_)
    { }
  
    virtual gas::Gas *initGas() {
      return new gas::UniformGas(pp);
    }
 
    virtual propagation::Propagation *initProp() {
      return new propagation::PropPowerlaw(pp);
    }
 
    virtual void initPackets(std::vector<RealVec>& x,
                 std::vector<CRPacket>& packets)
    { }
 
    virtual void initSources(std::vector<RealVec>& x,
                 std::vector<CRSource>& sources)
    { }
 
    virtual void userSetup()
    { }
    
    virtual void userWork(const Real t,
              Real& dt,
              gas::Gas& gasBG,
              propagation::Propagation& prop,
              CRTree& tree)
    { }
 
    virtual void userRead(const std::string& filename,
              const int step,
              Real& t,
              Real& dt,
              CRTree& tree)
    { }
 
    virtual void userWrite(const int step,
               const Real t,
               const Real dt,
               const int chkNum,
               const std::string& baseChkName,
               const CRTree& tree)
    { }
 
    virtual void userFinalize(const Real t,
                  gas::Gas& gasBG,
                  propagation::Propagation& prop,
                  CRTree& tree)
    { }
 
  protected:
    
    const ParmParser& pp;    
    const Geometry& geom;    
    const RngThread& rng;    
  };
 
  Prob *initProb(const criptic::ParmParser& pp,
         const criptic::Geometry& geom,
         criptic::RngThread& rng);
}
 
#endif
// _PROB_H_