---

GRBurst.h

#ifndef GRB_BURST_H
#define GRB_BURST_H

#include "GRBobsUtilities.h"
#include <vector>
#include <string>
#include <functional>  // for unary_function and plus
#include <fstream>

class HepRandomEngine;
class TimeEnergy;
class GlobalData;



class GRBurst
{
    friend class GRBobsSpectrum;  // to give it access to the private members
    friend std::ifstream &operator >> (std::ifstream &is, GRBurst &grb);
    
public:
    GRBurst();

    GRBurst(const std::vector<std::string> &paramVector);

    GRBurst(HepRandomEngine *engine, const double duration, const int npuls, 
        const double flux, const double fraction, const double alpha, 
        const double beta, const double epeak, const double specnorm, 
        const bool flag);
      
    virtual ~GRBurst();
      
    GRBurst(const GRBurst &right);   
      
    GRBurst &operator=(const GRBurst &right);
    
    

    // Accessors
    std::pair<float,float> dir() const                 { return m_grbdir; }
    double univFWHM() const                            { return m_univFWHM; }
    const std::vector<double> &specnorm() const        { return m_specnorm; }
    long nphoton() const                               { return m_nphoton; } 
    const std::vector<TimeEnergy> &photonlist() const  { return m_photonlist; }
    GlobalData *globalData() const                     { return m_globalData; }
    
    void setSpecnorm(const std::vector<double> &specnorm)   { m_specnorm = specnorm; }
    
    
    
    void createGRB(HepRandomEngine *engine, const std::string &prefix, 
        const std::string &dir=0);
    
    void createGRB(HepRandomEngine *engine, const double duration, 
        const int npuls, const double flux, const double fraction, 
        const double alpha, const double beta, const double epeak, 
        const double specnorm, const bool flag);
    
protected:
    // data members
    std::pair<float,float>   m_grbdir;             
    double                   m_univFWHM;           
    std::vector<double>      m_specnorm;           
    long                     m_nphoton;            
    std::vector<TimeEnergy>  m_photonlist;         
    GlobalData               *m_globalData;        
    
    
    
    // Accessors
    std::vector<TimeEnergy> &photonlist()  { return m_photonlist; }
    
    virtual long calcNphoton(HepRandomEngine *engine)   { return m_nphoton; }

    void makeTimes(HepRandomEngine *engine, const double ethres);
    
private:
    std::string baseFilename(const std::string &prefix, const std::string &dir=0) const;
    
    std::string outputFilename(const std::string &base, const long isim) const;
    
    GRBurst *clone() const;
    
    std::pair<float,float> direction(HepRandomEngine *engine) const;
    
    void getTimes(HepRandomEngine *engine, const double ethres, 
        const long nphots, const long deltbinsleft, const long iphotoff, 
        const double tmax, const std::vector<double> &pulse);
    
    virtual void makeGRB(HepRandomEngine *engine)   {}
    
    void readGRB(const std::vector<std::string> &paramVector);
    
    void swap(GRBurst &other) throw();
};



class GlobalData
{
public:
    GlobalData()  {};
    
    inline void setDuration(const double duration)      { m_duration=duration; }
    inline void setFlux(const double flux)              { m_flux=flux; }
    inline void setFraction(const double fraction)      { m_fraction=fraction; }
    inline void setAlpha(const double alpha)            { m_alpha=alpha; }
    inline void setBeta(const double beta)                          { m_beta=beta; }
    inline void setEpeak(const double epeak)            { m_epeak=epeak; }
    inline void setSpecnorm(const double specnorm)      { m_specnorm=specnorm; }
    inline void setNpuls(const int npuls)               { m_npuls=npuls; }
    
    inline double duration()       { return m_duration; }
    inline double flux()           { return m_flux; }
    inline double fraction()       { return m_fraction; }
    inline double alpha()                  { return m_alpha; }
    inline double beta()                   { return m_beta; }
    inline double epeak()                  { return m_epeak; }
    inline double specnorm()       { return m_specnorm; }
    inline int npuls()             { return m_npuls; }
    
    GlobalData *clone() const  { return new GlobalData(*this); }
    
private:
    double m_duration;    
    double m_flux;        
    double m_fraction;    
    double m_alpha;       
    double m_beta;        
    double m_epeak;       
    double m_specnorm;    
    int    m_npuls;       
};



class TimeEnergy
{
public:
    TimeEnergy() { };
    
    inline void setTime(double time)   {m_time=time;}
    inline void setEnergy(double energy) {m_energy=energy;}
    
    inline double time() const   {return m_time;}
    inline double energy() const {return m_energy;}
    
private:
    double m_time;
    double m_energy;
};



class timeCmp
{
public:
    bool operator()(const TimeEnergy &data1, const TimeEnergy &data2)
    {
        return data1.time() < data2.time();    
    }
};


std::ofstream &operator<<(std::ofstream &os, const GRBurst &grb);


#endif // GRB_MAKER_H

---