CLHEP/Random/RandPoisson.h

// $Id: RandPoisson.h,v 1.10 2000/04/17 23:00:16 mf Exp $
// -*- C++ -*-
//
// -----------------------------------------------------------------------
//                             HEP Random
//                         --- RandPoisson ---
//                          class header file
// -----------------------------------------------------------------------
// This file is part of Geant4 (simulation toolkit for HEP).

// Class defining methods for shooting numbers according to the Poisson
// distribution, given a mean (Algorithm taken from "W.H.Press et al.,
// Numerical Recipes in C, Second Edition".
// Default mean value is set to 1, value used for operator()().

// =======================================================================
// Gabriele Cosmo - Created: 5th September 1995
//                - Added not static Shoot() method: 17th May 1996
//                - Algorithm now operates on doubles : 31st Oct 1996
//                - Added methods to shoot arrays: 28th July 1997
// J.Marraffino   - Added default mean as attribute and
//                  operator() with mean: 16th Feb 1998
// Gabriele Cosmo - Relocated static data from HepRandom: 5th Jan 1999
// M. Fischler    - Moved meanMax and defaultMean from private to protected
//		    to accomodate derived classes RandPoissonQ & RandPoissonT
// =======================================================================

#ifndef RandPoisson_h
#define RandPoisson_h 1

#include "CLHEP/Random/Random.h"

class RandPoisson : public HepRandom {

public:

  inline RandPoisson ( HepRandomEngine& anEngine, HepDouble m=1.0 );
  inline RandPoisson ( HepRandomEngine* anEngine, HepDouble m=1.0 );
  // These constructors should be used to instantiate a RandPoisson
  // distribution object defining a local engine for it.
  // The static generator will be skipped using the non-static methods
  // defined below.
  // If the engine is passed by pointer the corresponding engine object
  // will be deleted by the RandPoisson destructor.
  // If the engine is passed by reference the corresponding engine object
  // will not be deleted by the RandPoisson destructor.

  virtual ~RandPoisson();
  // Destructor

  // Static methods to shoot random values using the static generator

  static  long shoot( HepDouble m=1.0 );

  static  void shootArray ( const HepInt size, long* vect, HepDouble m=1.0 );

  //  Static methods to shoot random values using a given engine
  //  by-passing the static generator.

  static  long shoot( HepRandomEngine* anEngine, HepDouble m=1.0 );

  static  void shootArray ( HepRandomEngine* anEngine,
                            const HepInt size, long* vect, HepDouble m=1.0 );

  //  Methods using the localEngine to shoot random values, by-passing
  //  the static generator.

  long  fire();
  long  fire( HepDouble m );

  void fireArray ( const HepInt size, long* vect );
  void fireArray ( const HepInt size, long* vect, HepDouble m);

  HepDouble operator()();
  HepDouble operator()( HepDouble m );
  

protected:

  // Protected copy constructor. Defining it here disallows user use.
  RandPoisson(const RandPoisson& d);

  const HepDouble meanMax;
  const HepDouble defaultMean;

  static  HepDouble getOldMean() {return oldm_st;}

  static  HepDouble getMaxMean() {return meanMax_st;}

  static  void setOldMean( HepDouble val ){oldm_st = val;}

  static  HepDouble* getPStatus() {return status_st;}

  static void setPStatus(HepDouble sq, HepDouble alxm, HepDouble g) {
    status_st[0] = sq; status_st[1] = alxm; status_st[2] = g;
  }

  inline HepRandomEngine* getLocalEngine();
  
private:

  HepRandomEngine* localEngine;
  HepBoolean deleteEngine;
  HepDouble status[3], oldm;

  // static data
  static HepDouble status_st[3];
  static HepDouble oldm_st;
  static const HepDouble meanMax_st;

};

#include "CLHEP/Random/RandPoisson.icc"

#endif