RndmGenerators.h

Go to the documentation of this file.

#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)  { }
    ~Gauss() override = default;
    double mean()  const                      {   return m_mean; }
    double sigma()  const                     {   return m_sigma; }
    static const InterfaceID& typeID()        {   return IID_IRndmGauss; }
    Gauss* clone() const override { 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)  { }
    ~Exponential() override = default;
    double mean()  const                   { return m_mean; }
    static const InterfaceID& typeID()     { return IID_IRndmExponential; }
    Exponential* clone() const override { 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) { }
    ~Chi2() override = default;
    long nDOF()  const                        { return m_nDOF; }
    static const InterfaceID& typeID()        { return IID_IRndmChi2; }
    Chi2* clone()  const override   { 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) { }
    ~BreitWigner() override = default;
    double mean()  const                      { return m_mean;                }
    double gamma()  const                     { return m_gamma;               }
    static const InterfaceID& typeID()        { return IID_IRndmBreitWigner;  }
    BreitWigner* clone()  const  override  { 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) { }
    ~Landau() override = default;
    double mean()  const                      { return m_mean;                }
    double sigma()  const                     { return m_sigma;               }
    static const InterfaceID& typeID()        { return IID_IRndmLandau;       }
    Landau* clone() const  override   { 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) {  }
    ~BreitWignerCutOff() override = default;
    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;}
    BreitWignerCutOff* clone() const  override{ 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) { }
    ~StudentT() override = default;
    double aValue()  const                    { return m_aValue;              }
    static const InterfaceID& typeID()        { return IID_IRndmStudentT;     }
    StudentT* clone()  const override   { 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) { }
    ~Gamma() override = default;
    double kValue()  const                    { return m_kValue;              }
    double lambda()  const                    { return m_lambda;              }
    static const InterfaceID& typeID()        { return IID_IRndmGamma;        }
    Gamma* clone() const override     { 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) { }
    ~Poisson() override = default;
    double mean()  const                      { return m_mean;                }
    static const InterfaceID& typeID()        { return IID_IRndmPoisson;      }
    Poisson* clone() const override           { 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) { }
    ~Binomial() override = default;
    long nEvent()  const                      { return m_nEvent;              }
    double probability()  const               { return m_probability;         }
    static const InterfaceID& typeID()        { return IID_IRndmBinomial;     }
    Binomial* clone() const override { 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) { }
    ~Flat() override = default;
    double minimum()  const                   { return m_minimum;             }
    double maximum()  const                   { return m_maximum;             }
    static const InterfaceID& typeID()        { return IID_IRndmFlat;         }
    Flat* clone()  const override  { return new Flat(m_minimum, m_maximum); }
  };

  class GAUDI_API Bit: public IRndmGen::Param {
  public:
    Bit() : IRndmGen::Param(IID_IRndmBit)     {  }
    ~Bit() override = default;
    static const InterfaceID& typeID()        { return IID_IRndmBit; }
    Bit* clone() const override   { 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)  {     }
    ~DefinedPdf() override = default;
    std::vector<double>& pdf()                { return m_pdf;                 }
    long interpolation()  const               { return m_interpolation;       }
    static const InterfaceID& typeID()        { return IID_IRndmDefinedPdf;   }
    DefinedPdf* clone()  const override { 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)  { }
    ~GaussianTail() override = default;
    double cut()  const { return m_cut; }
    double sigma()  const { return m_sigma; }
    static const InterfaceID& typeID() { return IID_IRndmGaussianTail; }
    GaussianTail* clone() const override { return new GaussianTail(m_cut, m_sigma); }
  };


  class GAUDI_API Numbers   {
  protected:
    SmartIF<IRndmGen>     m_generator;
  public:
    Numbers() = default;
    Numbers(const Numbers& ) = default;
    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;
    }
    double operator() ()   {
      return this->shoot();
    }
    double pop()    {
      return this->shoot();
    }
    double shoot()    {
      return m_generator ? m_generator->shoot() 
                         : -1;
    }
    StatusCode shootArray(std::vector<double>& array, long num, long start=0)  {
      return  m_generator ? m_generator->shootArray(array, num, start) 
                          : StatusCode::FAILURE;
    }
  };
}
#endif    // GAUDIKERNEL_RNDMGENGENERATORS_H