---

GrbGlobalData.h

#ifndef GRB_GLOBAL_DATA_H
#define GRB_GLOBAL_DATA_H

#include <vector>
#include <string>
#include <functional>  // for unary_function

class HepRandomEngine;



class GrbGlobalData
{
public:
    static GrbGlobalData        *instance(HepRandomEngine *engine);

    static void            kill ();
    
    
    
    // Accessors
    const std::vector<double> duration() const      { return m_duration; }
    const std::vector<double> flux() const          { return m_flux; }
    const std::vector<double> fraction() const      { return m_fraction; };
    const std::vector<double> alpha() const                 { return m_alpha; }
    const std::vector<double> beta() const                      { return m_beta; }
    const std::vector<double> epeak() const                 { return m_epeak; }
    
    
protected:
    GrbGlobalData(HepRandomEngine *engine);
    virtual ~GrbGlobalData();
    
    
private:
    static GrbGlobalData* s_instance;
    
    
    double computeFlux(HepRandomEngine *engine, const long diff, 
        const long minval, const std::vector<long> &in,
        const std::vector<double> &v) const;
    
    double evaluate(HepRandomEngine *engine, const long diff, const long minval,
        const std::vector<long> &in, const std::vector<double> &v) const;
    
    void grbGlobal(HepRandomEngine *engine);
    
    long index(HepRandomEngine *engine, const long diff, const long minval, 
        const std::vector<long> &in) const;
    
    void getDuration(HepRandomEngine *engine, long &nlong);
    
    void getFlux(HepRandomEngine *engine, long nlong);
    
    void getPowerLawIndex(HepRandomEngine *engine);
    
    //void powerLawIndex(HepRandomEngine *engine, const std::vector<int> &histpl, 
    //    const std::vector<double> &loEdges,
    //    const double factor, std::vector<double> &vect);
    void powerLawIndex(HepRandomEngine *engine, const std::vector<int> &histpl, const double factor, std::vector<double> &vect);
    
    
    
    // data members
    std::vector<double>   m_duration;
    std::vector<double>   m_flux;
    std::vector<double>   m_fraction;
    std::vector<double>   m_alpha;
    std::vector<double>   m_beta;
    std::vector<double>   m_epeak;
    
    
    struct calcEpeak : public std::unary_function<double, double>
    {
        calcEpeak(HepRandomEngine *engine) : m_engine(engine) {}
        double operator() (double x); 
        
        HepRandomEngine *m_engine;
    };
};



#endif // GRB_GLOBAL_DATA_H

---