AtRanluxGenSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATRANLUXGENSVC_H
#define ATRANLUXGENSVC_H
 
#include <map>
 
//base classes
#include "AthenaKernel/IAtRndmGenSvc.h"
#include "GaudiKernel/IIncidentListener.h"
#include "AthenaBaseComps/AthService.h"
#include "Gaudi/Property.h"
 
#include "CLHEP/Random/Ranlux64Engine.h"
 
class AtRanluxGenSvc : 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;
    bool CreateStream(const std::vector<uint32_t>& seeds,
                  const std::string& streamName);
 
 
    typedef std::map<std::string, CLHEP::Ranlux64Engine*> 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;
    void createStream(uint32_t seed1, uint32_t seed2,
              const std::string& streamName, short luxLevel);
 
    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:
 
    StringArrayProperty m_streams_seeds{this,"Seeds",{},
    "seeds for the engines, a string of the form ['SequenceName [LUXURY luxLevel (range 0:2 default 1)()] " \
      "[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 AtRanLuxGenSvc itself at the end of a job, " \
    "containing the information to fully set/restore the status of Ranlux64"
    }; 
    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)"};
 
    Gaudi::Property<bool> m_useOldBrokenSeeding{this,"UseOldBrokenSeeding",false}; 
 
    
    std::map<std::string, uint32_t> m_reseedingOffsets;
 
    engineMap   m_engines;
    std::map<std::string, std::vector<uint32_t> >   m_engines_copy;
    short m_defaultLuxLevel; 
 
 
 
    uint32_t m_default_seed1;
    uint32_t m_default_seed2;
    uint32_t m_PYTHIA_default_seed1;
    uint32_t m_PYTHIA_default_seed2;
    uint32_t m_HERWIG_default_seed1;
    uint32_t m_HERWIG_default_seed2;
 
    void SetStreamSeeds( const std::string& streamName );
    
public:
    
    AtRanluxGenSvc(const std::string& name, ISvcLocator* svc);
        
    virtual ~AtRanluxGenSvc();
 
};
 
inline  AtRanluxGenSvc::engineConstIter
AtRanluxGenSvc::begin           (void)  const
{ return m_engines.begin(); }
 
inline  AtRanluxGenSvc::engineConstIter
AtRanluxGenSvc::end         (void)  const
{ return m_engines.end(); }
 
inline  unsigned int
AtRanluxGenSvc::number_of_streams       (void)  const
{ return m_engines.size(); }
 
#endif // ATRANLUXGENSVC_H