HectorProducer.cc

Go to the documentation of this file.

// Framework headers
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/PluginManager/interface/ModuleDef.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Utilities/interface/RandomNumberGenerator.h"
#include "IOMC/RandomEngine/src/TRandomAdaptor.h"
 
// SimpleConfigurable replacement
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
// HepMC headers
#include "HepMC/GenEvent.h"
 
// Hector headers
#include "SimTransport/HectorProducer/interface/Hector.h"
#include "SimTransport/HectorProducer/interface/HectorProducer.h"
 
// SimDataFormats headers
#include "SimDataFormats/Forward/interface/LHCTransportLinkContainer.h"
#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
 
#include <CLHEP/Random/RandomEngine.h>
 
#include <iostream>
#include <memory>
#include <string>
 
class TRandom3;
 
HectorProducer::HectorProducer(edm::ParameterSet const &p)
    : m_HepMC(consumes<edm::HepMCProduct>(p.getParameter<edm::InputTag>("HepMCProductLabel"))) {
  m_verbosity = p.getParameter<bool>("Verbosity");
  m_FP420Transport = p.getParameter<bool>("FP420Transport");
  m_ZDCTransport = p.getParameter<bool>("ZDCTransport");
  m_evtAnalysed = 0;
 
  produces<edm::HepMCProduct>();
  produces<edm::LHCTransportLinkContainer>();
 
  m_Hector = new Hector(p, m_verbosity, m_FP420Transport, m_ZDCTransport);
 
  edm::Service<edm::RandomNumberGenerator> rng;
  if (!rng.isAvailable()) {
    throw cms::Exception("Configuration") << "LHCTransport (HectorProducer) 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.";
  }
  edm::LogInfo("SimTransportHectorProducer") << "Hector is created";
}
 
HectorProducer::~HectorProducer() {}
 
void HectorProducer::beginRun(const edm::Run &r, const edm::EventSetup &c) {}
 
void HectorProducer::endRun(const edm::Run &r, const edm::EventSetup &c) {}
 
void HectorProducer::produce(edm::Event &iEvent, const edm::EventSetup &es) {
  edm::Service<edm::RandomNumberGenerator> rng;
  CLHEP::HepRandomEngine *engine = &rng->getEngine(iEvent.streamID());
  if (engine->name() != "TRandom3") {
    throw cms::Exception("Configuration") << "The TRandom3 engine type must be used with HectorProducer, "
                                          << "Random Number Generator Service not correctly configured!";
  }
  TRandom3 *rootEngine = ((edm::TRandomAdaptor *)engine)->getRootEngine();
 
  ++m_evtAnalysed;
 
  edm::LogInfo("SimTransportHectorProducer") << "produce evt " << m_evtAnalysed;
 
  edm::Handle<edm::HepMCProduct> HepMCEvt;
  iEvent.getByToken(m_HepMC, HepMCEvt);
 
  if (!HepMCEvt.isValid()) {
    throw cms::Exception("InvalidReference") << "Invalid reference to HepMCProduct\n";
  }
 
  if (HepMCEvt.provenance()->moduleLabel() == "LHCTransport") {
    throw cms::Exception("LogicError") << "HectorTrasported HepMCProduce already exists\n";
  }
 
  evt_ = new HepMC::GenEvent(*HepMCEvt->GetEvent());
  m_Hector->clearApertureFlags();
  if (m_FP420Transport) {
    m_Hector->clear();
    m_Hector->add(evt_, es);
    m_Hector->filterFP420(rootEngine);
  }
  if (m_ZDCTransport) {
    m_Hector->clear();
    m_Hector->add(evt_, es);
    m_Hector->filterZDC(rootEngine);
 
    m_Hector->clear();
    m_Hector->add(evt_, es);
    m_Hector->filterD1(rootEngine);
  }
  evt_ = m_Hector->addPartToHepMC(evt_);
  if (m_verbosity) {
    evt_->print();
  }
 
  edm::LogInfo("SimTransportHectorProducer") << "new HepMC product ";
 
  unique_ptr<edm::HepMCProduct> NewProduct(new edm::HepMCProduct());
  NewProduct->addHepMCData(evt_);
 
  iEvent.put(std::move(NewProduct));
 
  edm::LogInfo("SimTransportHectorProducer") << "new LHCTransportLinkContainer ";
  unique_ptr<edm::LHCTransportLinkContainer> NewCorrespondenceMap(new edm::LHCTransportLinkContainer());
  edm::LHCTransportLinkContainer thisLink(m_Hector->getCorrespondenceMap());
  (*NewCorrespondenceMap).swap(thisLink);
 
  if (m_verbosity) {
    for (unsigned int i = 0; i < (*NewCorrespondenceMap).size(); i++)
      LogDebug("HectorEventProcessing") << "Hector correspondence table: " << (*NewCorrespondenceMap)[i];
  }
 
  iEvent.put(std::move(NewCorrespondenceMap));
  edm::LogInfo("SimTransportHectorProducer") << "produce end ";
}
 
DEFINE_FWK_MODULE(HectorProducer);