RndmGenerators.h

Go to the documentation of this file.

// $Id: RndmGenerators.h,v 1.8 2005/07/21 14:35:31 hmd Exp $
#ifndef GAUDIKERNEL_RNDMGENGENERATORS_H
#define GAUDIKERNEL_RNDMGENGENERATORS_H

// STL include files
#include <vector>

// Framework include files
#include "GaudiKernel/IRndmGen.h"
#include "GaudiKernel/SmartIF.h"

// Forward declarations
class IRndmGen;
class IRndmGenSvc;

namespace Rndm   {

  template <class TYPE> class Generator;

  class GAUDI_API Gauss: public IRndmGen::Param {
  protected:
    friend class Generator<Gauss>;
    double m_mean;
    double m_sigma;
  public:
    Gauss(double m, double s)
    : IRndmGen::Param(IID_IRndmGauss), m_mean(m), m_sigma(s)  { }
    virtual ~Gauss()                          {  }
    double mean()  const                      {   return m_mean; }
    double sigma()  const                     {   return m_sigma; }
    static const InterfaceID& typeID()        {   return IID_IRndmGauss; }
    virtual IRndmGen::Param* clone() const {
      return new Gauss(m_mean, m_sigma);
    }
  };

  class GAUDI_API Exponential: public IRndmGen::Param  {
  protected:
    double m_mean;
  public:
    Exponential(double m)
    : IRndmGen::Param(IID_IRndmExponential), m_mean(m)  { }
    virtual ~Exponential()                 {  }
    double mean()  const                   { return m_mean; }
    static const InterfaceID& typeID()     { return IID_IRndmExponential; }
    virtual IRndmGen::Param* clone() const { return new Exponential(m_mean); }
  };

  class GAUDI_API Chi2: public IRndmGen::Param {
    friend class Generator<Chi2>;
  protected:
    long m_nDOF;
  public:
    Chi2(long   n_dof) : IRndmGen::Param(IID_IRndmChi2), m_nDOF(n_dof) { }
    virtual ~Chi2()                           { }
    long nDOF()  const                        { return m_nDOF; }
    static const InterfaceID& typeID()        { return IID_IRndmChi2; }
    virtual IRndmGen::Param* clone()  const   { return new Chi2(m_nDOF); }
  };

  class GAUDI_API BreitWigner : public IRndmGen::Param {
    friend class Generator<BreitWigner>;
  protected:
    double m_mean, m_gamma;
  public:
    BreitWigner(double m, double g)
    : IRndmGen::Param(IID_IRndmBreitWigner), m_mean(m), m_gamma(g) { }
    virtual ~BreitWigner()                    { }
    double mean()  const                      { return m_mean;                }
    double gamma()  const                     { return m_gamma;               }
    static const InterfaceID& typeID()        { return IID_IRndmBreitWigner;  }
    virtual IRndmGen::Param* clone()  const   {
      return new BreitWigner(m_mean, m_gamma);
    }
  };

  class GAUDI_API Landau : public IRndmGen::Param {
    friend class Generator<Landau>;
  protected:
    double m_mean, m_sigma;
  public:
    Landau(double m, double s)
    : IRndmGen::Param(IID_IRndmLandau), m_mean(m), m_sigma(s) { }
    virtual ~Landau()                         { }
    double mean()  const                      { return m_mean;                }
    double sigma()  const                     { return m_sigma;               }
    static const InterfaceID& typeID()        { return IID_IRndmLandau;       }
    virtual IRndmGen::Param* clone() const    {
      return new Landau(m_mean, m_sigma);
    }
  };

  class GAUDI_API BreitWignerCutOff : public IRndmGen::Param {
    friend class Generator<BreitWignerCutOff>;
  protected:
    double m_mean, m_gamma, m_cut;
  public:
    BreitWignerCutOff(double m, double g, double c)
    : IRndmGen::Param(IID_IRndmBreitWignerCutOff),
      m_mean(m),
      m_gamma(g),
      m_cut(c) {  }
    virtual ~BreitWignerCutOff()              { }
    double mean()  const                      { return m_mean; }
    double gamma()  const                     { return m_gamma; }
    double cutOff()  const                    { return m_cut; }
    static const InterfaceID& typeID()        { return IID_IRndmBreitWignerCutOff;}
    virtual IRndmGen::Param* clone() const {
      return new BreitWignerCutOff(m_mean, m_gamma, m_cut);
    }
  };

  class GAUDI_API StudentT: public IRndmGen::Param {
    friend class Generator<StudentT>;
  protected:
    double m_aValue;
  public:
    StudentT(double a) : IRndmGen::Param(IID_IRndmStudentT), m_aValue(a) { }
    virtual ~StudentT()                       { }
    double aValue()  const                    { return m_aValue;              }
    static const InterfaceID& typeID()        { return IID_IRndmStudentT;     }
    virtual IRndmGen::Param* clone()  const   { return new StudentT(m_aValue);}
  };

  class GAUDI_API Gamma: public IRndmGen::Param {
    friend class Generator<Gamma>;
  protected:
    double m_kValue;
    double m_lambda;
  public:
    Gamma(double k, double l)
    : IRndmGen::Param(IID_IRndmGamma), m_kValue(k), m_lambda(l) { }
    virtual ~Gamma()                          {  }
    double kValue()  const                    { return m_kValue;              }
    double lambda()  const                    { return m_lambda;              }
    static const InterfaceID& typeID()        { return IID_IRndmGamma;        }
    virtual IRndmGen::Param* clone()  const   {
      return new Gamma(m_kValue, m_lambda);
    }
  };

  class GAUDI_API Poisson: public IRndmGen::Param {
    friend class Generator<Poisson>;
  protected:
    double m_mean;
  public:
    Poisson(double m) : IRndmGen::Param(IID_IRndmPoisson), m_mean(m) { }
    virtual ~Poisson()                        {  }
    double mean()  const                      { return m_mean;                }
    static const InterfaceID& typeID()        { return IID_IRndmPoisson;      }
    virtual IRndmGen::Param* clone()  const   { return new Poisson(m_mean);   }
  };

  class GAUDI_API Binomial: public IRndmGen::Param {
  protected:
    long m_nEvent;
    double m_probability;
  public:
    Binomial(long n, double p)
    : IRndmGen::Param(IID_IRndmBinomial), m_nEvent(n), m_probability(p) { }
    virtual ~Binomial()                       {  }
    long nEvent()  const                      { return m_nEvent;              }
    double probability()  const               { return m_probability;         }
    static const InterfaceID& typeID()        { return IID_IRndmBinomial;     }
    virtual IRndmGen::Param* clone()  const   {
      return new Binomial(m_nEvent, m_probability);
    }
  };

  class GAUDI_API Flat: public IRndmGen::Param {
  protected:
    double m_minimum;
    double m_maximum;
  public:
    Flat(double mi, double ma)
    : IRndmGen::Param(IID_IRndmFlat), m_minimum(mi), m_maximum(ma) { }
    virtual ~Flat()                           {  }
    double minimum()  const                   { return m_minimum;             }
    double maximum()  const                   { return m_maximum;             }
    static const InterfaceID& typeID()        { return IID_IRndmFlat;         }
    virtual IRndmGen::Param* clone()  const   {
      return new Flat(m_minimum, m_maximum);
    }
  };

  class GAUDI_API Bit: public IRndmGen::Param {
  public:
    Bit() : IRndmGen::Param(IID_IRndmBit)     {  }
    virtual ~Bit()                            {  }
    static const InterfaceID& typeID()        { return IID_IRndmBit; }
    virtual IRndmGen::Param* clone()  const   { return new Bit(); }
  };

  class GAUDI_API DefinedPdf: public IRndmGen::Param {
  protected:
    std::vector<double> m_pdf;
    long m_interpolation;
  public:
    DefinedPdf(const std::vector<double>& pdf, long intpol)
    : IRndmGen::Param(IID_IRndmDefinedPdf),
      m_pdf(pdf),
      m_interpolation(intpol)  {     }
    virtual ~DefinedPdf()                     {  }
    std::vector<double>& pdf()                { return m_pdf;                 }
    long interpolation()  const               { return m_interpolation;       }
    static const InterfaceID& typeID()        { return IID_IRndmDefinedPdf;   }
    virtual IRndmGen::Param* clone()  const   {
      return new DefinedPdf(m_pdf,m_interpolation);
    }
  };

  class GAUDI_API GaussianTail: public IRndmGen::Param {
  protected:
    double m_cut;
    double m_sigma;
  public:
    GaussianTail(double a, double s)
      : IRndmGen::Param(IID_IRndmGaussianTail), m_cut(a), m_sigma(s)  { }
    virtual ~GaussianTail() { }
    double cut()  const { return m_cut; }
    double sigma()  const { return m_sigma; }
    static const InterfaceID& typeID() { return IID_IRndmGaussianTail; }
    virtual IRndmGen::Param* clone() const {
      return new GaussianTail(m_cut, m_sigma);
    }
  };


  class GAUDI_API Numbers   {
  protected:
    IRndmGen*           m_generator;
  public:
    Numbers();
    Numbers(const Numbers& copy );
    Numbers(const SmartIF<IRndmGenSvc>& svc, const IRndmGen::Param& par);
    virtual ~Numbers();
    virtual StatusCode initialize(const SmartIF<IRndmGenSvc>& svc, const IRndmGen::Param& par);
#if !defined(GAUDI_V22_API) || defined(G22_NEW_SVCLOCATOR)

    Numbers(IRndmGenSvc* svc, const IRndmGen::Param& par);
    virtual StatusCode initialize(IRndmGenSvc* svc, const IRndmGen::Param& par);
#endif

    virtual StatusCode finalize();
    operator bool  ()  const  {
      return m_generator != 0;
    }
    double operator() ()   {
      return this->shoot();
    }
    double pop()    {
      return this->shoot();
    }
    double shoot()    {
      if ( 0 != m_generator )   {
        return m_generator->shoot();
      }
      return -1;
    }
    StatusCode shootArray(std::vector<double>& array, long num, long start=0)  {
      if ( 0 != m_generator )   {
        return m_generator->shootArray(array, num, start);
      }
      return StatusCode::FAILURE;
    }
  };
}
#endif    // GAUDIKERNEL_RNDMGENGENERATORS_H