#include <SiPixelDigitizer.h>

Inheritance diagram for cms::SiPixelDigitizer:

Public Member Functions
void	accumulate (edm::Event const &e, edm::EventSetup const &c) override

void	accumulate (PileUpEventPrincipal const &e, edm::EventSetup const &c, edm::StreamID const &) override

virtual void	beginJob ()

void	finalizeEvent (edm::Event &e, edm::EventSetup const &c) override

PileupMixingContent *	getEventPileupInfo () override

void	initializeEvent (edm::Event const &e, edm::EventSetup const &c) override

	SiPixelDigitizer (const edm::ParameterSet &conf, edm::ProducerBase &mixMod, edm::ConsumesCollector &iC)

void	StorePileupInformation (std::vector< int > &numInteractionList, std::vector< int > &bunchCrossingList, std::vector< float > &TrueInteractionList, std::vector< edm::EventID > &eventInfoList, int bunchSpacing) override

	~SiPixelDigitizer () override

Public Member Functions inherited from DigiAccumulatorMixMod
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)

virtual void	beginRun (edm::Run const &run, edm::EventSetup const &setup)

	DigiAccumulatorMixMod ()

virtual void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)

virtual void	endRun (edm::Run const &run, edm::EventSetup const &setup)

virtual void	finalizeBunchCrossing (edm::Event &event, edm::EventSetup const &setup, int bunchCrossing)

virtual void	initializeBunchCrossing (edm::Event const &event, edm::EventSetup const &setup, int bunchCrossing)

virtual	~DigiAccumulatorMixMod ()

Private Types
typedef std::vector< std::string >	vstring

Private Member Functions
void	accumulatePixelHits (edm::Handle< std::vector< PSimHit > >, size_t globalSimHitIndex, const unsigned int tofBin, CLHEP::HepRandomEngine *, edm::EventSetup const &c)

CLHEP::HepRandomEngine *	randomEngine (edm::StreamID const &streamID)

Private Attributes
std::unique_ptr< SiPixelDigitizerAlgorithm >	_pixeldigialgo

std::map< std::string, size_t >	crossingSimHitIndexOffset_
	Offset to add to the index of each sim hit to account for which crossing it's in. More...

std::map< unsigned int, PixelGeomDetUnit const * >	detectorUnits

bool	firstFinalizeEvent_

bool	firstInitializeEvent_

const std::string	geometryType

const std::string	hitsProducer

const int	NumberOfEndcapDisks

edm::ESHandle< TrackerGeometry >	pDD

PileupMixingContent *	PileupInfo_

const bool	pilotBlades

edm::ESHandle< MagneticField >	pSetup

std::vector< CLHEP::HepRandomEngine * >	randomEngines_

const vstring	trackerContainers

Detailed Description

Definition at line 47 of file SiPixelDigitizer.h.

Member Typedef Documentation

typedef std::vector<std::string> cms::SiPixelDigitizer::vstring

private

Definition at line 91 of file SiPixelDigitizer.h.

Constructor & Destructor Documentation

SiPixelDigitizer::SiPixelDigitizer	(	const edm::ParameterSet &	conf,
		edm::ProducerBase &	mixMod,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 94 of file SiPixelDigitizer.cc.

References _pixeldigialgo, met_cff::alias, edm::ConsumesCollector::consumes(), Exception, hitsProducer, edm::ProductRegistryHelper::produces(), AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, and trackerContainers.

                                                                                                                      :
     firstInitializeEvent_(true),
     firstFinalizeEvent_(true),
     _pixeldigialgo(),
     hitsProducer(iConfig.getParameter<std::string>("hitsProducer")),
     trackerContainers(iConfig.getParameter<std::vector<std::string> >("RoutList")),
     geometryType(iConfig.getParameter<std::string>("PixGeometryType")),
     pilotBlades(iConfig.exists("enablePilotBlades")?iConfig.getParameter<bool>("enablePilotBlades"):false),
     NumberOfEndcapDisks(iConfig.exists("NumPixelEndcap")?iConfig.getParameter<int>("NumPixelEndcap"):2)
   {
     edm::LogInfo ("PixelDigitizer ") <<"Enter the Pixel Digitizer";
     
     const std::string alias ("simSiPixelDigis"); 
     
     mixMod.produces<edm::DetSetVector<PixelDigi> >().setBranchAlias(alias);
     mixMod.produces<edm::DetSetVector<PixelDigiSimLink> >().setBranchAlias(alias + "siPixelDigiSimLink");
     for(auto const& trackerContainer : trackerContainers) {
       edm::InputTag tag(hitsProducer, trackerContainer);
       iC.consumes<std::vector<PSimHit> >(edm::InputTag(hitsProducer, trackerContainer));
     }
     edm::Service<edm::RandomNumberGenerator> rng;
     if ( ! rng.isAvailable()) {
       throw cms::Exception("Configuration")
         << "SiPixelDigitizer 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.";
     }
 
     _pixeldigialgo.reset(new SiPixelDigitizerAlgorithm(iConfig));
   }

SiPixelDigitizer::~SiPixelDigitizer ( )

override

Definition at line 125 of file SiPixelDigitizer.cc.

                                      {  
     edm::LogInfo ("PixelDigitizer ") <<"Destruct the Pixel Digitizer";
   }

Member Function Documentation

void SiPixelDigitizer::accumulate	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 207 of file SiPixelDigitizer.cc.

References accumulatePixelHits(), crossingSimHitIndexOffset_, edm::InputTag::encode(), edm::Event::getByLabel(), PixelDigiSimLink::HighTof, hitsProducer, mps_fire::i, edm::HandleBase::isValid(), PixelDigiSimLink::LowTof, randomEngine(), trackerHits::simHits, edm::Event::streamID(), AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, and trackerContainers.

                                                                                   {
     // Step A: Get Inputs
     for(vstring::const_iterator i = trackerContainers.begin(), iEnd = trackerContainers.end(); i != iEnd; ++i) {
       edm::Handle<std::vector<PSimHit> > simHits;
       edm::InputTag tag(hitsProducer, *i);
 
       iEvent.getByLabel(tag, simHits);
       unsigned int tofBin = PixelDigiSimLink::LowTof;
       if ((*i).find(std::string("HighTof")) != std::string::npos) tofBin = PixelDigiSimLink::HighTof;
       accumulatePixelHits(simHits, crossingSimHitIndexOffset_[tag.encode()], tofBin, randomEngine(iEvent.streamID()), iSetup);
       // Now that the hits have been processed, I'll add the amount of hits in this crossing on to
       // the global counter. Next time accumulateStripHits() is called it will count the sim hits
       // as though they were on the end of this collection.
       // Note that this is only used for creating digi-sim links (if configured to do so).
 //       std::cout << "index offset, current hit count = " << crossingSimHitIndexOffset_[tag.encode()] << ", " << simHits->size() << std::endl;
       if( simHits.isValid() ) crossingSimHitIndexOffset_[tag.encode()]+=simHits->size();
     }
   }

void SiPixelDigitizer::accumulate	(	PileUpEventPrincipal const &	e,
		edm::EventSetup const &	c,
		edm::StreamID const &	streamID
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 227 of file SiPixelDigitizer.cc.

References accumulatePixelHits(), crossingSimHitIndexOffset_, edm::InputTag::encode(), PileUpEventPrincipal::getByLabel(), PixelDigiSimLink::HighTof, hitsProducer, mps_fire::i, edm::HandleBase::isValid(), PixelDigiSimLink::LowTof, randomEngine(), trackerHits::simHits, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, and trackerContainers.

                                                                                                                            {
     // Step A: Get Inputs
     for(vstring::const_iterator i = trackerContainers.begin(), iEnd = trackerContainers.end(); i != iEnd; ++i) {
       edm::Handle<std::vector<PSimHit> > simHits;
       edm::InputTag tag(hitsProducer, *i);
 
       iEvent.getByLabel(tag, simHits);
       unsigned int tofBin = PixelDigiSimLink::LowTof;
       if ((*i).find(std::string("HighTof")) != std::string::npos) tofBin = PixelDigiSimLink::HighTof;
       accumulatePixelHits(simHits, crossingSimHitIndexOffset_[tag.encode()], tofBin, randomEngine(streamID), iSetup);
       // Now that the hits have been processed, I'll add the amount of hits in this crossing on to
       // the global counter. Next time accumulateStripHits() is called it will count the sim hits
       // as though they were on the end of this collection.
       // Note that this is only used for creating digi-sim links (if configured to do so).
 //       std::cout << "index offset, current hit count = " << crossingSimHitIndexOffset_[tag.encode()] << ", " << simHits->size() << std::endl;
       if( simHits.isValid() ) crossingSimHitIndexOffset_[tag.encode()]+=simHits->size();
     }
   }

void SiPixelDigitizer::accumulatePixelHits	(	edm::Handle< std::vector< PSimHit > >	hSimHits,
		size_t	globalSimHitIndex,
		const unsigned int	tofBin,
		CLHEP::HepRandomEngine *	engine,
		edm::EventSetup const &	c
	)

private

Definition at line 135 of file SiPixelDigitizer.cc.

References _pixeldigialgo, detectorUnits, edm::EventSetup::get(), MagneticField::inTesla(), GeomDetEnumerators::isTrackerPixel(), LogDebug, edm::ESHandle< T >::product(), pSetup, and trackerHits::simHits.

Referenced by accumulate().

                                                  {
     if(hSimHits.isValid()) {
        std::set<unsigned int> detIds;
        std::vector<PSimHit> const& simHits = *hSimHits.product();
        edm::ESHandle<TrackerTopology> tTopoHand;
        iSetup.get<TrackerTopologyRcd>().get(tTopoHand);
        const TrackerTopology *tTopo=tTopoHand.product();
        for(std::vector<PSimHit>::const_iterator it = simHits.begin(), itEnd = simHits.end(); it != itEnd; ++it, ++globalSimHitIndex) {
          unsigned int detId = (*it).detUnitId();
          if(detIds.insert(detId).second) {
            // The insert succeeded, so this detector element has not yet been processed.
        assert(detectorUnits[detId]);
        if(detectorUnits[detId] && detectorUnits[detId]->type().isTrackerPixel()) { // this test could be avoided and changed into a check of pixdet!=0
          std::map<unsigned int, PixelGeomDetUnit const *>::iterator itDet = detectorUnits.find(detId);       
          if (itDet == detectorUnits.end()) continue;
              auto pixdet = itDet->second;
          assert(pixdet !=nullptr);
              //access to magnetic field in global coordinates
              GlobalVector bfield = pSetup->inTesla(pixdet->surface().position());
              LogDebug ("PixelDigitizer ") << "B-field(T) at " << pixdet->surface().position() << "(cm): " 
                                           << pSetup->inTesla(pixdet->surface().position());
              _pixeldigialgo->accumulateSimHits(it, itEnd, globalSimHitIndex, tofBin, pixdet, bfield, tTopo, engine);
            }
          }
        }
     }
   }

virtual void cms::SiPixelDigitizer::beginJob ( void )

inlinevirtual

Definition at line 59 of file SiPixelDigitizer.h.

59 {}

void SiPixelDigitizer::finalizeEvent	(	edm::Event &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 248 of file SiPixelDigitizer.cc.

References _pixeldigialgo, DigiHGCalTB160_cff::bunchspace, TrackerGeometry::detUnits(), firstFinalizeEvent_, edm::EventSetup::get(), edm::RandomNumberGenerator::getEngine(), getEventPileupInfo(), PileupMixingContent::getMix_bunchSpacing(), eostools::move(), convertSQLitetoXML_cfg::output, pDD, PileupInfo_, edm::ESHandle< T >::product(), edm::Event::put(), and edm::Event::streamID().

                                                                                {
 
     edm::Service<edm::RandomNumberGenerator> rng;
     CLHEP::HepRandomEngine* engine = &rng->getEngine(iEvent.streamID());
 
     edm::ESHandle<TrackerTopology> tTopoHand;
     iSetup.get<TrackerTopologyRcd>().get(tTopoHand);
     const TrackerTopology *tTopo=tTopoHand.product();
 
     std::vector<edm::DetSet<PixelDigi> > theDigiVector;
     std::vector<edm::DetSet<PixelDigiSimLink> > theDigiLinkVector;
  
     PileupInfo_ = getEventPileupInfo();
     if (firstFinalizeEvent_) {
       const unsigned int bunchspace = PileupInfo_->getMix_bunchSpacing();
       _pixeldigialgo->init_DynIneffDB(iSetup, bunchspace);
       firstFinalizeEvent_ = false;
     }
     _pixeldigialgo->calculateInstlumiFactor(PileupInfo_);   
 
     for( const auto& iu : pDD->detUnits()) {
       
       if(iu->type().isTrackerPixel()) {
 
     //
 
         edm::DetSet<PixelDigi> collector(iu->geographicalId().rawId());
         edm::DetSet<PixelDigiSimLink> linkcollector(iu->geographicalId().rawId());
         
         
         _pixeldigialgo->digitize(dynamic_cast<const PixelGeomDetUnit*>(iu),
                                  collector.data,
                                  linkcollector.data,
                  tTopo,
                                  engine);
         if(!collector.data.empty()) {
           theDigiVector.push_back(std::move(collector));
         }
         if(!linkcollector.data.empty()) {
           theDigiLinkVector.push_back(std::move(linkcollector));
         }
       }
     }
     
     // Step C: create collection with the cache vector of DetSet 
     std::unique_ptr<edm::DetSetVector<PixelDigi> > 
       output(new edm::DetSetVector<PixelDigi>(theDigiVector) );
     std::unique_ptr<edm::DetSetVector<PixelDigiSimLink> > 
       outputlink(new edm::DetSetVector<PixelDigiSimLink>(theDigiLinkVector) );
 
     // Step D: write output to file 
     iEvent.put(std::move(output));
     iEvent.put(std::move(outputlink));
   }

PileupMixingContent* cms::SiPixelDigitizer::getEventPileupInfo ( )

inlineoverridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 68 of file SiPixelDigitizer.h.

References randomEngine.

Referenced by finalizeEvent().

68 { return PileupInfo_; }

cms::SiPixelDigitizer::PileupInfo_

PileupMixingContent * PileupInfo_

Definition: SiPixelDigitizer.h:100

void SiPixelDigitizer::initializeEvent	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 168 of file SiPixelDigitizer.cc.

References _pixeldigialgo, crossingSimHitIndexOffset_, detectorUnits, TrackerGeometry::detUnits(), firstInitializeEvent_, geometryType, edm::EventSetup::get(), TrackerTopology::layer(), NumberOfEndcapDisks, pDD, pilotBlades, GeomDetEnumerators::PixelEndcap, edm::ESHandle< T >::product(), and pSetup.

                                                                                   {
     if(firstInitializeEvent_){
       _pixeldigialgo->init(iSetup);
       firstInitializeEvent_ = false;
     }
 
     // Make sure that the first crossing processed starts indexing the sim hits from zero.
     // This variable is used so that the sim hits from all crossing frames have sequential
     // indices used to create the digi-sim link (if configured to do so) rather than starting
     // from zero for each crossing.
     crossingSimHitIndexOffset_.clear();
 
     _pixeldigialgo->initializeEvent();
     iSetup.get<TrackerDigiGeometryRecord>().get(geometryType, pDD);
     iSetup.get<IdealMagneticFieldRecord>().get(pSetup);
     edm::ESHandle<TrackerTopology> tTopoHand;
     iSetup.get<TrackerTopologyRcd>().get(tTopoHand);
     const TrackerTopology *tTopo=tTopoHand.product();
 
     // FIX THIS! We only need to clear and (re)fill this map when the geometry type IOV changes.  Use ESWatcher to determine this.
     if(true) { // Replace with ESWatcher 
       detectorUnits.clear();
       for( const auto& iu : pDD->detUnits()) {
         unsigned int detId = iu->geographicalId().rawId();
     if(iu->type().isTrackerPixel()) {
           auto pixdet = dynamic_cast<const PixelGeomDetUnit*>(iu);
           assert(pixdet != nullptr);
       if (iu->subDetector()==GeomDetEnumerators::SubDetector::PixelEndcap) { // true ONLY for the phase 0 pixel deetctor
         unsigned int disk = tTopo->layer(detId); // using the generic layer method
         //if using pilot blades, then allowing it for current detector only
         if ((disk == 3)&&((!pilotBlades)&&(NumberOfEndcapDisks == 2))) continue;
       }
           detectorUnits.insert(std::make_pair(detId, pixdet));
         }
       }
     }
   }

CLHEP::HepRandomEngine * SiPixelDigitizer::randomEngine ( edm::StreamID const & streamID )

private

Definition at line 303 of file SiPixelDigitizer.cc.

References edm::RandomNumberGenerator::getEngine(), randomEngines_, and edm::StreamID::value().

Referenced by accumulate().

                                                                                   {
     unsigned int index = streamID.value();
     if(index >= randomEngines_.size()) {
       randomEngines_.resize(index + 1, nullptr);
     }
     CLHEP::HepRandomEngine* ptr = randomEngines_[index];
     if(!ptr) {
       edm::Service<edm::RandomNumberGenerator> rng;
       ptr = &rng->getEngine(streamID);
       randomEngines_[index] = ptr;
     }
     return ptr;
   }

void cms::SiPixelDigitizer::StorePileupInformation	(	std::vector< int > &	numInteractionList,
		std::vector< int > &	bunchCrossingList,
		std::vector< float > &	TrueInteractionList,
		std::vector< edm::EventID > &	eventInfoList,
		int	bunchSpacing
	)

inlineoverridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 61 of file SiPixelDigitizer.h.

                                                                                      {
       PileupInfo_ = new PileupMixingContent(numInteractionList, bunchCrossingList, TrueInteractionList, eventInfoList, bunchSpacing);
     }

Member Data Documentation

std::unique_ptr<SiPixelDigitizerAlgorithm> cms::SiPixelDigitizer::_pixeldigialgo

private

Definition at line 80 of file SiPixelDigitizer.h.

Referenced by accumulatePixelHits(), finalizeEvent(), initializeEvent(), and SiPixelDigitizer().

std::map<std::string,size_t> cms::SiPixelDigitizer::crossingSimHitIndexOffset_

private

Offset to add to the index of each sim hit to account for which crossing it's in.

I need to know what each sim hit index will be when the hits from all crossing frames are merged into one collection (assuming the MixingModule is configured to create the crossing frame for all sim hits). To do this I'll record how many hits were in each crossing, and then add that on to the index for a given hit in a given crossing. This assumes that the crossings are processed in the same order here as they are put into the crossing frame, which I'm pretty sure is true.
The key is the name of the sim hit collection.

Definition at line 89 of file SiPixelDigitizer.h.

Referenced by accumulate(), and initializeEvent().

std::map<unsigned int, PixelGeomDetUnit const *> cms::SiPixelDigitizer::detectorUnits

private

Definition at line 97 of file SiPixelDigitizer.h.

Referenced by accumulatePixelHits(), and initializeEvent().

bool cms::SiPixelDigitizer::firstFinalizeEvent_

private

Definition at line 79 of file SiPixelDigitizer.h.

Referenced by finalizeEvent().

bool cms::SiPixelDigitizer::firstInitializeEvent_

private