RNGWrapper.h

Go to the documentation of this file.

// -*- c++ -*-
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHENAKERNEL_RNGWRAPPER_H
#define ATHENAKERNEL_RNGWRAPPER_H
 
#include <string>
#include <cstdint>
#include <vector>
#include <functional>
 
#include "GaudiKernel/EventContext.h"
#include "GaudiKernel/ThreadLocalContext.h"
 
namespace CLHEP{
  class HepRandomEngine;
}
 
namespace ATHRNG{


  size_t calculateSeedMC16(const std::string& algName, uint64_t ev, uint64_t run, uint32_t offset=0);

  size_t calculateSeedMC20(const std::string& algName, uint64_t ev, uint64_t run);

 void calculateSeedsMC21(long* seeds, const std::string& algName, uint64_t ev, uint64_t run, uint64_t offset=0);
 
 long calculateSeedsPython(const std::string& algName, uint64_t ev, uint64_t run, uint64_t offset=0);
  class RNGWrapper
  {
 
    typedef std::function<CLHEP::HepRandomEngine*(void)> factoryFunc;
 
  public:

    RNGWrapper(const factoryFunc& genFact, size_t nSlots);
    ~RNGWrapper();

    inline void setSeed(const std::string& algName, const EventContext& ctx);

    inline void setSeed(const std::string& algName, size_t slot, uint64_t ev, uint64_t run,
                        EventContext::ContextEvt_t evt = EventContext::INVALID_CONTEXT_EVT);

    enum SeedingOptionType {
      MC20Seeding=0,
      MC16Seeding=1,
      MC21Seeding=2,
      SeedingDefault=MC21Seeding
    };    
    static constexpr std::initializer_list<SeedingOptionType> all_SeedingOptions = {MC20Seeding, MC16Seeding, MC21Seeding};
    
    void setSeedLegacy(const std::string& algName, const EventContext& ctx, uint32_t offset, SeedingOptionType seeding,
                        EventContext::ContextEvt_t evt = EventContext::INVALID_CONTEXT_EVT);

    void setSeed(size_t slot, size_t seed,
                 EventContext::ContextEvt_t evt = EventContext::INVALID_CONTEXT_EVT);

    void setSeeds(size_t slot, const long * seeds,
                  EventContext::ContextEvt_t evt = EventContext::INVALID_CONTEXT_EVT);

    operator CLHEP::HepRandomEngine*() const {
      return m_engines[Gaudi::Hive::currentContext().slot()];
    }

    CLHEP::HepRandomEngine* getEngine(const EventContext &ctx) const {
      return m_engines[ctx.slot()];
    }

    EventContext::ContextEvt_t evtSeeded(const EventContext &ctx) const
    {
      return m_evtSeeded[ctx.slot()];
    }
 
  private:

    void setSeedMC16(const std::string& algName, size_t slot, uint64_t ev, uint64_t run, uint32_t offset=0,
                     EventContext::ContextEvt_t evt = EventContext::INVALID_CONTEXT_EVT);

    void setSeedMC20(const std::string& algName, size_t slot, uint64_t ev, uint64_t run,
                     EventContext::ContextEvt_t evt = EventContext::INVALID_CONTEXT_EVT);

    void setSeedMC21(const std::string& algName, size_t slot, uint64_t ev, uint64_t run, uint64_t offset=0,
                     EventContext::ContextEvt_t evt = EventContext::INVALID_CONTEXT_EVT);

    std::vector<CLHEP::HepRandomEngine*> m_engines;

    std::vector<EventContext::ContextEvt_t>  m_evtSeeded;
 
  };
 
}
 
//Default to MC21 seeding for now
inline void ATHRNG::RNGWrapper::setSeed(const std::string& algName, size_t slot, uint64_t ev, uint64_t run,
                                        EventContext::ContextEvt_t evt /*= EventContext::INVALID_CONTEXT_EVT*/)
{
  setSeedMC21(algName,slot,ev,run,0,evt);
}
 
inline void ATHRNG::RNGWrapper::setSeed(const std::string& algName, const EventContext& ctx)
{
  setSeed( algName, ctx.slot(),
           ctx.eventID().event_number(),
           ctx.eventID().run_number(),
           ctx.evt() );
}
 
 
#endif