RndmGenerators.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/IRndmGen.h>
#include <GaudiKernel/SmartIF.h>
#include <vector>
 
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 ) {}
    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 ) {}
    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 ) {}
    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 ) {}
    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 ) {}
    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 ) {}

    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 ) {}
    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 ) {}
    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 ) {}
    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 ) {}
    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 ) {}
    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 ) {}
    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 ) {}

    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 ) {}
    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 );
    virtual StatusCode finalize();
    operator bool() const { return m_generator; }
    double operator()() const { return this->shoot(); }
    double pop() const { return this->shoot(); }
    double shoot() const { return m_generator ? m_generator->shoot() : -1; }
    StatusCode shootArray( std::vector<double>& array, long num, long start = 0 ) const {
      return m_generator ? m_generator->shootArray( array, num, start ) : StatusCode::FAILURE;
    }
  };
} // namespace Rndm