AtDSFMTGenSvc.h

Go to the documentation of this file.

//Dear emacs, this is -*-c++-*-
/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATDSFMTGENSVC_H
#define ATDSFMTGENSVC_H
 
#include <map>
 
//base classes
#include "AthenaKernel/IAtRndmGenSvc.h"
#include "GaudiKernel/IIncidentListener.h"
#include "AthenaBaseComps/AthService.h"
 
#include "CLHEP/Random/RandomEngine.h"
#include "Gaudi/Property.h"
 
class IAlgorithm; 
class ISvcLocator;
class IIncident;
 
 
class AtDSFMTGenSvc : 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::HepRandomEngine*>  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;
    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, 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 AtDSFMTGenSvc itself at the end of a job, containing the information to fully set/restore the status"
    }; 
    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<uint32_t> >   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
    AtDSFMTGenSvc(const std::string& name, ISvcLocator* svc);
        
    // Standard Destructor
    virtual ~AtDSFMTGenSvc();
 
};
 
inline  AtDSFMTGenSvc::engineConstIter
AtDSFMTGenSvc::begin            (void)  const
{ return m_engines.begin(); }
 
inline  AtDSFMTGenSvc::engineConstIter
AtDSFMTGenSvc::end          (void)  const
{ return m_engines.end(); }
 
inline  unsigned int
AtDSFMTGenSvc::number_of_streams        (void)  const
{ return m_engines.size(); }
 
#endif // ATDSFMTGENSVC_H