Migrate Sim Code to New Random Service Interface

Migrate most simulation code to use the new interface
of the random number generator service designed to work
with the multithreaded Framework. The main interface
change is to require a StreamID or LuminosityBlockIndex
argument to the getEngine function. In most cases,
this required moving code from the constructor to
the event or beginLuminosityBlock method. Then a pointer
to the engine was percolated or passed in some way
to the point where it was used.

Note OscarProducer was migrated earlier and there are a
few pieces of code I skipped over that will be migrated
in the near future. This pull request takes care of most
of the digitizers and the mixing modules.

Author: wddgit

FWCore/Sources/interface/VectorInputSource.h

@@ -11,6 +11,10 @@ VectorInputSource: Abstract interface for vector input sources.
 #include <string>
 #include <vector>
 
+namespace CLHEP {
+  class HepRandomEngine;
+}
+
 namespace edm {
   class EventPrincipal;
   struct InputSourceDescription;
@@ -22,11 +26,11 @@ namespace edm {
     virtual ~VectorInputSource();
 
     template<typename T>
-    size_t loopRandom(EventPrincipal& cache, size_t number, T eventOperator);
+    size_t loopRandom(EventPrincipal& cache, size_t number, T eventOperator, CLHEP::HepRandomEngine*);
     template<typename T>
     size_t loopSequential(EventPrincipal& cache, size_t number, T eventOperator);
     template<typename T>
-    size_t loopRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id, size_t number, T eventOperator);
+    size_t loopRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id, size_t number, T eventOperator, CLHEP::HepRandomEngine*);
     template<typename T>
     size_t loopSequentialWithID(EventPrincipal& cache, LuminosityBlockID const& id, size_t number, T eventOperator);
     template<typename T, typename Collection>
@@ -37,8 +41,8 @@ namespace edm {
   private:
 
     void clearEventPrincipal(EventPrincipal& cache);
-    virtual void readOneRandom(EventPrincipal& cache) = 0;
-    virtual bool readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id) = 0;
+    virtual void readOneRandom(EventPrincipal& cache, CLHEP::HepRandomEngine*) = 0;
+    virtual bool readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id, CLHEP::HepRandomEngine*) = 0;
     virtual bool readOneSequential(EventPrincipal& cache) = 0;
     virtual bool readOneSequentialWithID(EventPrincipal& cache, LuminosityBlockID const& id) = 0;
     virtual void readOneSpecified(EventPrincipal& cache, EventID const& event) = 0;
@@ -47,11 +51,11 @@ namespace edm {
   };
 
   template<typename T>
-  size_t VectorInputSource::loopRandom(EventPrincipal& cache, size_t number, T eventOperator) {
+  size_t VectorInputSource::loopRandom(EventPrincipal& cache, size_t number, T eventOperator, CLHEP::HepRandomEngine* engine) {
     size_t i = 0U;
     for(; i < number; ++i) {
       clearEventPrincipal(cache);
-      readOneRandom(cache);
+      readOneRandom(cache, engine);
       eventOperator(cache);
     }
     return i;
@@ -70,11 +74,11 @@ namespace edm {
   }
 
   template<typename T>
-  size_t VectorInputSource::loopRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id, size_t number, T eventOperator) {
+  size_t VectorInputSource::loopRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id, size_t number, T eventOperator, CLHEP::HepRandomEngine* engine) {
     size_t i = 0U;
     for(; i < number; ++i) {
       clearEventPrincipal(cache);
-      bool found = readOneRandomWithID(cache, id);
+      bool found = readOneRandomWithID(cache, id, engine);
       if(!found) break;
       eventOperator(cache);
     }

FastSimulation/Tracking/plugins/RecoTrackAccumulator.cc

@@ -50,8 +50,7 @@ void RecoTrackAccumulator::accumulate(edm::Event const& e, edm::EventSetup const
 
 }
 
-
-void RecoTrackAccumulator::accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& iSetup) {
+void RecoTrackAccumulator::accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& iSetup, edm::StreamID const&) {
 
   if (e.bunchCrossing()==0) {
     edm::Handle<reco::TrackCollection> tracks;

FastSimulation/Tracking/plugins/RecoTrackAccumulator.h

@@ -30,6 +30,7 @@ namespace edm {
   namespace one {
     class EDProducerBase;
   }
+  class StreamID;
 }
 
 
@@ -41,7 +42,7 @@ class RecoTrackAccumulator : public DigiAccumulatorMixMod
 
   virtual void initializeEvent(edm::Event const& e, edm::EventSetup const& c);
   virtual void accumulate(edm::Event const& e, edm::EventSetup const& c);
-  virtual void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c);
+  virtual void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override;
   virtual void finalizeEvent(edm::Event& e, edm::EventSetup const& c);
 
  private:

IOPool/Input/src/PoolSource.cc

@@ -260,15 +260,15 @@ namespace edm {
   }
 
   void
-  PoolSource::readOneRandom(EventPrincipal& cache) {
+  PoolSource::readOneRandom(EventPrincipal& cache, CLHEP::HepRandomEngine* engine) {
     assert(!secondaryFileSequence_);
-    primaryFileSequence_->readOneRandom(cache);
+    primaryFileSequence_->readOneRandom(cache, engine);
   }
 
   bool
-  PoolSource::readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& lumiID) {
+  PoolSource::readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& lumiID, CLHEP::HepRandomEngine* engine) {
     assert(!secondaryFileSequence_);
-    return primaryFileSequence_->readOneRandomWithID(cache, lumiID);
+    return primaryFileSequence_->readOneRandomWithID(cache, lumiID, engine);
   }
 
   bool

IOPool/Input/src/PoolSource.h

@@ -20,6 +20,10 @@ PoolSource: This is an InputSource
 #include <string>
 #include <vector>
 
+namespace CLHEP {
+  class HepRandomEngine;
+}
+
 namespace edm {
 
   class ConfigurationDescriptions;
@@ -49,8 +53,8 @@ namespace edm {
     virtual void skip(int offset);
     virtual bool goToEvent_(EventID const& eventID);
     virtual void rewind_();
-    virtual void readOneRandom(EventPrincipal& cache);
-    virtual bool readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& lumiID);
+    virtual void readOneRandom(EventPrincipal& cache, CLHEP::HepRandomEngine*) override;
+    virtual bool readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& lumiID, CLHEP::HepRandomEngine*) override;
     virtual bool readOneSequential(EventPrincipal& cache);
     virtual bool readOneSequentialWithID(EventPrincipal& cache, LuminosityBlockID const& lumiID);
     virtual void readOneSpecified(EventPrincipal& cache, EventID const& id);

IOPool/Input/src/RootInputFileSequence.cc

@@ -17,7 +17,6 @@
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 #include "FWCore/ServiceRegistry/interface/Service.h"
-#include "FWCore/Utilities/interface/RandomNumberGenerator.h"
 #include "Utilities/StorageFactory/interface/StorageFactory.h"
 
 #include "CLHEP/Random/RandFlat.h"
@@ -42,7 +41,6 @@ namespace edm {
     fileIterLastOpened_(fileIterEnd_),
     rootFile_(),
     branchesMustMatch_(BranchDescription::Permissive),
-    flatDistribution_(),
     indexesIntoFiles_(fileCatalogItems().size()),
     orderedProcessHistoryIDs_(),
     nStreams_(nStreams),
@@ -701,20 +699,16 @@ namespace edm {
   }
 
   void
-  RootInputFileSequence::readOneRandom(EventPrincipal& cache) {
+  RootInputFileSequence::readOneRandom(EventPrincipal& cache, CLHEP::HepRandomEngine* engine) {
     if(fileIterEnd_ == fileIterBegin_) {
       throw Exception(errors::Configuration) << "RootInputFileSequence::readOneRandom(): no input files specified.\n";
     }
-    if(!flatDistribution_) {
-      Service<RandomNumberGenerator> rng;
-      CLHEP::HepRandomEngine& engine = rng->getEngine();
-      flatDistribution_.reset(new CLHEP::RandFlat(engine));
-    }
     assert(rootFile_);
     skipBadFiles_ = false;
     unsigned int currentSeqNumber = fileIter_ - fileIterBegin_;
     while(eventsRemainingInFile_ == 0) {
-      fileIter_ = fileIterBegin_ + flatDistribution_->fireInt(fileCatalogItems().size());
+
+      fileIter_ = fileIterBegin_ + CLHEP::RandFlat::shootInt(engine, fileCatalogItems().size());
       unsigned int newSeqNumber = fileIter_ - fileIterBegin_;
       if(newSeqNumber != currentSeqNumber) {
         initFile(false);
@@ -725,7 +719,7 @@ namespace edm {
         throw Exception(errors::NotFound) <<
            "RootInputFileSequence::readOneRandom(): Secondary Input file " << fileIter_->fileName() << " contains no events.\n";
       }
-      rootFile_->setAtEventEntry(flatDistribution_->fireInt(eventsRemainingInFile_) - 1);
+      rootFile_->setAtEventEntry(CLHEP::RandFlat::shootInt(engine, eventsRemainingInFile_) - 1);
     }
     rootFile_->nextEventEntry();
 
@@ -741,15 +735,10 @@ namespace edm {
   // bool RootFile::setEntryAtNextEventInLumi(RunNumber_t run, LuminosityBlockNumber_t lumi) {
 
   bool
-  RootInputFileSequence::readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id) {
+  RootInputFileSequence::readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id, CLHEP::HepRandomEngine* engine) {
     if(fileIterEnd_ == fileIterBegin_) {
       throw Exception(errors::Configuration) << "RootInputFileSequence::readOneRandomWithID(): no input files specified.\n";
     }
-    if(!flatDistribution_) {
-      Service<RandomNumberGenerator> rng;
-      CLHEP::HepRandomEngine& engine = rng->getEngine();
-      flatDistribution_.reset(new CLHEP::RandFlat(engine));
-    }
     skipBadFiles_ = false;
     if(fileIter_ == fileIterEnd_ || !rootFile_ ||
         rootFile_->indexIntoFileIter().run() != id.run() ||
@@ -763,7 +752,7 @@ namespace edm {
       while(rootFile_->setEntryAtNextEventInLumi(id.run(), id.luminosityBlock())) ++eventsInLumi;
       found = skipToItem(id.run(), id.luminosityBlock(), 0);
       assert(found);
-      int eventInLumi = flatDistribution_->fireInt(eventsInLumi);
+      int eventInLumi = CLHEP::RandFlat::shootInt(engine, eventsInLumi);
       for(int i = 0; i < eventInLumi; ++i) {
         bool found = rootFile_->setEntryAtNextEventInLumi(id.run(), id.luminosityBlock());
         assert(found);
@@ -779,7 +768,7 @@ namespace edm {
       if(!found) {
         return false;
       }
-      return readOneRandomWithID(cache, id);
+      return readOneRandomWithID(cache, id, engine);
     }
     return true;
   }

IOPool/Input/src/RootInputFileSequence.h

@@ -22,7 +22,7 @@ RootInputFileSequence: This is an InputSource
 #include <vector>
 
 namespace CLHEP {
-  class RandFlat;
+  class HepRandomEngine;
 }
 
 namespace edm {
@@ -62,8 +62,8 @@ namespace edm {
     bool skipToItem(RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event, bool currentFileFirst = true);
     bool skipToItemInNewFile(RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event);
     void rewind_();
-    void readOneRandom(EventPrincipal& cache);
-    bool readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id);
+    void readOneRandom(EventPrincipal& cache, CLHEP::HepRandomEngine*);
+    bool readOneRandomWithID(EventPrincipal& cache, LuminosityBlockID const& id, CLHEP::HepRandomEngine*);
     bool readOneSequential(EventPrincipal& cache);
     bool readOneSequentialWithID(EventPrincipal& cache, LuminosityBlockID const& id);
     void readOneSpecified(EventPrincipal& cache, EventID const& id);
@@ -101,7 +101,6 @@ namespace edm {
     RootFileSharedPtr rootFile_;
     BranchDescription::MatchMode branchesMustMatch_;
 
-    std::unique_ptr<CLHEP::RandFlat> flatDistribution_;
     std::vector<boost::shared_ptr<IndexIntoFile> > indexesIntoFiles_;
     std::vector<ProcessHistoryID> orderedProcessHistoryIDs_;
 

IOPool/SecondaryInput/test/SecondaryProducer.cc

@@ -31,11 +31,19 @@
 #include "FWCore/Utilities/interface/TypeID.h"
 #include "FWCore/Version/interface/GetReleaseVersion.h"
 
+#include "FWCore/ServiceRegistry/interface/Service.h"
+#include "FWCore/Utilities/interface/RandomNumberGenerator.h"
+#include "FWCore/Utilities/interface/Exception.h"
+
 #include "boost/bind.hpp"
 
 #include <memory>
 #include <string>
 
+namespace CLHEP {
+  class HepRandomEngine;
+}
+
 namespace edm {
 
   // Constructor
@@ -74,6 +82,7 @@ namespace edm {
 
   // Functions that get called by framework every event
   void SecondaryProducer::produce(Event& e, EventSetup const&) {
+
     if(sequential_) {
       if(lumiSpecified_) {
         // Just for simplicity, we use the luminosity block ID from the primary to read the secondary.
@@ -86,11 +95,23 @@ namespace edm {
       std::vector<EventID> events(1, e.id());
       secInput_->loopSpecified(*eventPrincipal_, events, boost::bind(&SecondaryProducer::processOneEvent, this, _1, boost::ref(e)));
     } else {
+
+      edm::Service<edm::RandomNumberGenerator> rng;
+      if ( ! rng.isAvailable()) {
+        throw cms::Exception("Configuration")
+          << "SecondaryProducer in its random mode requires the RandomNumberGeneratorService\n"
+             "which is not present in the configuration file.  You must add the service\n"
+             "in the configuration file or remove the modules that require it.";
+      }
+      CLHEP::HepRandomEngine* engine = &rng->getEngine(e.streamID());
+
       if(lumiSpecified_) {
         // Just for simplicity, we use the luminosity block ID from the primary to read the secondary.
-        secInput_->loopRandomWithID(*eventPrincipal_, LuminosityBlockID(e.id().run(), e.id().luminosityBlock()), 1, boost::bind(&SecondaryProducer::processOneEvent, this, _1, boost::ref(e)));
+        secInput_->loopRandomWithID(*eventPrincipal_, LuminosityBlockID(e.id().run(), e.id().luminosityBlock()), 1,
+                                    boost::bind(&SecondaryProducer::processOneEvent, this, _1, boost::ref(e)),
+                                    engine);
       } else {
-        secInput_->loopRandom(*eventPrincipal_, 1, boost::bind(&SecondaryProducer::processOneEvent, this, _1, boost::ref(e)));
+        secInput_->loopRandom(*eventPrincipal_, 1, boost::bind(&SecondaryProducer::processOneEvent, this, _1, boost::ref(e)), engine);
       }
     }
   }

Mixing/Base/interface/PileUp.h

@@ -11,9 +11,6 @@
 #include "FWCore/Framework/interface/EventPrincipal.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 
-#include "CLHEP/Random/RandPoissonQ.h"
-#include "CLHEP/Random/RandFlat.h"
-
 #include "boost/shared_ptr.hpp"
 
 #include "TRandom.h"
@@ -26,20 +23,20 @@ class TH1F;
 namespace CLHEP {
   class RandPoissonQ;
   class RandPoisson;
+  class HepRandomEngine;
 }
 
-
-
 namespace edm {
   class SecondaryEventProvider;
+  class StreamID;
 
   class PileUp {
   public:
     explicit PileUp(ParameterSet const& pset, double averageNumber, TH1F* const histo, const bool playback);
     ~PileUp();
 
     template<typename T>
-      void readPileUp(edm::EventID const & signal, std::vector<edm::EventID> &ids, T eventOperator, const int NumPU );
+      void readPileUp(edm::EventID const & signal, std::vector<edm::EventID> &ids, T eventOperator, const int NumPU, StreamID const&);
 
     template<typename T>
       void playPileUp(const std::vector<edm::EventID> &ids, T eventOperator);
@@ -63,7 +60,7 @@ namespace edm {
 
     void reload(const edm::EventSetup & setup);
 
-    void CalculatePileup(int MinBunch, int MaxBunch, std::vector<int>& PileupSelection, std::vector<float>& TrueNumInteractions);
+    void CalculatePileup(int MinBunch, int MaxBunch, std::vector<int>& PileupSelection, std::vector<float>& TrueNumInteractions, StreamID const&);
 
     //template<typename T>
     // void recordEventForPlayback(EventPrincipal const& eventPrincipal,
@@ -73,6 +70,11 @@ namespace edm {
     void input(unsigned int s){inputType_=s;}
 
   private:
+
+    std::unique_ptr<CLHEP::RandPoissonQ> const& poissonDistribution(StreamID const& streamID);
+    std::unique_ptr<CLHEP::RandPoisson> const& poissonDistr_OOT(StreamID const& streamID);
+    CLHEP::HepRandomEngine* randomEngine(StreamID const& streamID);
+
     unsigned int  inputType_;
     std::string type_;
     double averageNumber_;
@@ -100,9 +102,9 @@ namespace edm {
     boost::shared_ptr<LuminosityBlockPrincipal> lumiPrincipal_;
     boost::shared_ptr<RunPrincipal> runPrincipal_;
     std::unique_ptr<SecondaryEventProvider> provider_;
-    std::unique_ptr<CLHEP::RandPoissonQ> poissonDistribution_;
-    std::unique_ptr<CLHEP::RandPoisson>  poissonDistr_OOT_;
-
+    std::vector<std::unique_ptr<CLHEP::RandPoissonQ> > vPoissonDistribution_;
+    std::vector<std::unique_ptr<CLHEP::RandPoisson> > vPoissonDistr_OOT_;
+    std::vector<CLHEP::HepRandomEngine*> randomEngines_;
 
     TH1F *h1f;
     TH1F *hprobFunction;
@@ -152,7 +154,8 @@ namespace edm {
    */
   template<typename T>
   void
-    PileUp::readPileUp(edm::EventID const & signal, std::vector<edm::EventID> &ids, T eventOperator, const int pileEventCnt) {
+    PileUp::readPileUp(edm::EventID const & signal, std::vector<edm::EventID> &ids, T eventOperator,
+                       const int pileEventCnt, StreamID const& streamID) {
 
     // One reason PileUp is responsible for recording event IDs is
     // that it is the one that knows how many events will be read.
@@ -164,7 +167,7 @@ namespace edm {
       if (sequential_)
         read = input_->loopSequentialWithID(*eventPrincipal_, lumi, pileEventCnt, recorder);
       else
-        read = input_->loopRandomWithID(*eventPrincipal_, lumi, pileEventCnt, recorder);
+        read = input_->loopRandomWithID(*eventPrincipal_, lumi, pileEventCnt, recorder, randomEngine(streamID));
     } else {
       if (sequential_) {
         // boost::bind creates a functor from recordEventForPlayback
@@ -178,7 +181,7 @@ namespace edm {
         //  );
 
       } else  {
-        read = input_->loopRandom(*eventPrincipal_, pileEventCnt, recorder);
+        read = input_->loopRandom(*eventPrincipal_, pileEventCnt, recorder, randomEngine(streamID));
         //               boost::bind(&PileUp::recordEventForPlayback<T>,
         //                             boost::ref(*this), _1, boost::ref(ids),
         //                             boost::ref(eventOperator))