AtRndmGenSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATRNDMGENSVC_H
#define ATRNDMGENSVC_H
 
#include <map>
 
//base classes
#include "AthenaKernel/IAtRndmGenSvc.h"
#include "GaudiKernel/IIncidentListener.h"
#include "AthenaBaseComps/AthService.h"
 
#include "CLHEP/Random/RandomEngine.h"
#include "CLHEP/Random/RanecuEngine.h"
 
class IAlgorithm; 
class ISvcLocator;
class IIncident;
 
 
class AtRndmGenSvc : public extends<AthService, IAtRndmGenSvc, IIncidentListener>
{
public:
 
    virtual CLHEP::HepRandomEngine* GetEngine   ( const std::string& streamName ) override;
    virtual void    CreateStream    ( uint32_t seed1, uint32_t seed2, 
                      const std::string& streamName ) override;
 
    typedef std::map<std::string, CLHEP::RanecuEngine*> engineMap;
    typedef engineMap::iterator             engineIter;
    typedef engineMap::const_iterator       engineConstIter;  
    typedef engineMap::value_type           engineValType;
 
 
    engineConstIter begin           (void)  const;
    engineConstIter end         (void)  const;
    unsigned int    number_of_streams   (void)  const;    
    virtual void    print       ( const std::string& streamName ) override;
    virtual void    print       ( void ) override;
 
    virtual CLHEP::HepRandomEngine* setOnDefinedSeeds (uint32_t theSeed,
                        const std::string& streamName) override;
    virtual CLHEP::HepRandomEngine* setOnDefinedSeeds (uint32_t eventNumber, 
                        uint32_t runNumber,
                        const std::string& streamName) override;
    CLHEP::HepRandomEngine* oldSetOnDefinedSeeds (uint32_t theSeed,
                       const std::string& streamName);
    CLHEP::HepRandomEngine* oldSetOnDefinedSeeds (uint32_t eventNumber, 
                       uint32_t runNumber,
                       const std::string& streamName);
    virtual bool setAllOnDefinedSeeds (uint32_t theSeed) override;
    virtual bool setAllOnDefinedSeeds (uint32_t eventNumber, uint32_t runNumber) override;
 
    virtual StatusCode initialize() override;
    virtual StatusCode finalize() override;
 
    virtual void handle(const Incident&) override;
 
 
private:
 
 
    Gaudi::Property<bool> m_useOldBrokenSeeding{this,"UseOldBrokenSeeding",false}; 
    StringArrayProperty m_streams_seeds{this,"Seeds",{},
    "seeds for the engines, this is a vector of strings of the form ['SequenceName [OFFSET num] Seed1 Seed2', ...] "\
      "where OFFSET is an optional integer that allows to change the sequence of randoms for a given run/event no " \
      "and SequenceName combination. Notice that Seed1/Seed2 are dummy when EventReseeding is used",
      "OrderedSet<std::string>"};
 
 
      Gaudi::Property<bool> m_read_from_file{this,"ReadFromFile",false,"set/restore the status of the engine from file"};  
      Gaudi::Property<std::string>  m_file_to_read{this,"FileToRead",this->name()+".out",
      "name of a ASCII file, usually produced by AtRndmGenSvc itself at the end of a job, "\
      "containing the information to fully set/restore the status of Ranecu",
      }; 
      Gaudi::Property<bool> m_save_to_file{this,"SaveToFile", true,"save the status of the engine to file"}; 
      Gaudi::Property<std::string> m_file_to_write{this,"FileToWrite",this->name()+".out",
      "name of an ASCII file which will be produced on finalize, containing the information to fully set/restore the status"}; 
 
      Gaudi::Property<bool> m_eventReseed{this,"EventReseeding",true,"reseed every event using a hash of run and event numbers"}; 
      StringArrayProperty m_reseedStreamNames{this,"ReseedStreamNames",{}, "the streams we are going to set the seeds of (default: all streams)"};
 
 
    std::map<std::string, uint32_t> m_reseedingOffsets;
 
    engineMap   m_engines;
    std::map<std::string, std::vector<long int> >   m_engines_copy;
 
 
 
    long m_default_seed1;
    long m_default_seed2;
    long m_PYTHIA_default_seed1;
    long m_PYTHIA_default_seed2;
    long m_HERWIG_default_seed1;
    long m_HERWIG_default_seed2;
 
    void SetStreamSeeds( const std::string& streamName );
    
public:
    
    // Standard Constructor
    AtRndmGenSvc(const std::string& name, ISvcLocator* svc);
        
    // Standard Destructor
    virtual ~AtRndmGenSvc();
 
};
 
inline  AtRndmGenSvc::engineConstIter
AtRndmGenSvc::begin         (void)  const
{ return m_engines.begin(); }
 
inline  AtRndmGenSvc::engineConstIter
AtRndmGenSvc::end           (void)  const
{ return m_engines.end(); }
 
inline  unsigned int
AtRndmGenSvc::number_of_streams     (void)  const
{ return m_engines.size(); }
 
#endif // ATRNDMGENSVC_H