#include <PileupInformation.h>

Inheritance diagram for PileupInformation:

Public Member Functions
	PileupInformation (const edm::ParameterSet &)

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Types
typedef std::map < EncodedEventId, unsigned int >	EncodedEventIdToIndex

typedef std::map< int, int >	myindex

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
edm::EDGetTokenT< int >	bunchSpacingToken_

edm::ParameterSet	conf_

double	distanceCut_

myindex	event_index_

bool	isPreMixed_

bool	LookAtTrackingTruth_

std::string	MessageCategory_

std::vector< int >	ntrks_highpT

std::vector< int >	ntrks_lowpT

edm::EDGetTokenT < PileupMixingContent >	PileupInfoLabel_

edm::EDGetTokenT< std::vector < PileupSummaryInfo > >	pileupSummaryToken_

edm::EDGetTokenT < PileupVertexContent >	PileupVtxLabel_

double	pTcut_1_

double	pTcut_2_

bool	saveVtxTimes_

std::vector< float >	sumpT_highpT

std::vector< float >	sumpT_lowpT

edm::EDGetTokenT < TrackingParticleCollection >	trackingTruthT_

edm::EDGetTokenT < TrackingVertexCollection >	trackingTruthV_

double	volumeRadius_

double	volumeZ_

std::vector< float >	zpositions

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 28 of file PileupInformation.h.

Member Typedef Documentation

typedef std::map<EncodedEventId, unsigned int> PileupInformation::EncodedEventIdToIndex

private

Definition at line 37 of file PileupInformation.h.

typedef std::map<int, int> PileupInformation::myindex

private

Definition at line 38 of file PileupInformation.h.

Constructor & Destructor Documentation

PileupInformation::PileupInformation ( const edm::ParameterSet & config )

explicit

Definition at line 19 of file PileupInformation.cc.

References bunchSpacingToken_, distanceCut_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), isPreMixed_, LookAtTrackingTruth_, MessageCategory_, PileupInfoLabel_, pileupSummaryToken_, PileupVtxLabel_, pTcut_1_, pTcut_2_, saveVtxTimes_, trackingTruthT_, trackingTruthV_, volumeRadius_, and volumeZ_.

                                                                   {
   // Initialize global parameters
 
   pTcut_1_ = 0.1;
   pTcut_2_ = 0.5;  // defaults
   isPreMixed_ = config.getParameter<bool>("isPreMixed");
 
   if (!isPreMixed_) {
     distanceCut_ = config.getParameter<double>("vertexDistanceCut");
     volumeRadius_ = config.getParameter<double>("volumeRadius");
     volumeZ_ = config.getParameter<double>("volumeZ");
     pTcut_1_ = config.getParameter<double>("pTcut_1");
     pTcut_2_ = config.getParameter<double>("pTcut_2");
 
     PileupInfoLabel_ = consumes<PileupMixingContent>(config.getParameter<edm::InputTag>("PileupMixingLabel"));
 
     PileupVtxLabel_ = consumes<PileupVertexContent>(config.getParameter<edm::InputTag>("PileupMixingLabel"));
 
     LookAtTrackingTruth_ = config.getUntrackedParameter<bool>("doTrackTruth");
 
     trackingTruthT_ =
         mayConsume<TrackingParticleCollection>(config.getParameter<edm::InputTag>("TrackingParticlesLabel"));
     trackingTruthV_ =
         mayConsume<TrackingVertexCollection>(config.getParameter<edm::InputTag>("TrackingParticlesLabel"));
 
     saveVtxTimes_ = config.getParameter<bool>("saveVtxTimes");
 
     MessageCategory_ = "PileupInformation";
 
     edm::LogInfo(MessageCategory_) << "Setting up PileupInformation";
     edm::LogInfo(MessageCategory_) << "Vertex distance cut set to " << distanceCut_ << " mm";
     edm::LogInfo(MessageCategory_) << "Volume radius set to " << volumeRadius_ << " mm";
     edm::LogInfo(MessageCategory_) << "Volume Z      set to " << volumeZ_ << " mm";
     edm::LogInfo(MessageCategory_) << "Lower pT Threshold set to " << pTcut_1_ << " GeV";
     edm::LogInfo(MessageCategory_) << "Upper pT Threshold set to " << pTcut_2_ << " GeV";
   } else {
     pileupSummaryToken_ =
         consumes<std::vector<PileupSummaryInfo> >(config.getParameter<edm::InputTag>("PileupSummaryInfoInputTag"));
     bunchSpacingToken_ = consumes<int>(config.getParameter<edm::InputTag>("BunchSpacingInputTag"));
   }
 
   produces<std::vector<PileupSummaryInfo> >();
   produces<int>("bunchSpacing");
 
   //produces<PileupSummaryInfo>();
 }

Member Function Documentation

void PileupInformation::produce	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

overrideprivate

Definition at line 66 of file PileupInformation.cc.

References bunchSpacingToken_, event_index_, edm::Event::getByToken(), PileupMixingContent::getMix_bunchCrossing(), PileupMixingContent::getMix_bunchSpacing(), PileupMixingContent::getMix_eventInfo(), PileupMixingContent::getMix_Ninteractions(), PileupVertexContent::getMix_pT_hats(), PileupVertexContent::getMix_t_Vtxs(), PileupMixingContent::getMix_TrueInteractions(), PileupVertexContent::getMix_z_Vtxs(), cuy::ib, isPreMixed_, LookAtTrackingTruth_, eostools::move(), ntrks_highpT, ntrks_lowpT, PileupInfoLabel_, pileupSummaryToken_, PileupVtxLabel_, edm::Handle< T >::product(), pTcut_1_, pTcut_2_, saveVtxTimes_, mathSSE::sqrt(), sumpT_highpT, sumpT_lowpT, trackingTruthT_, trackingTruthV_, and zpositions.

                                                                            {
   std::unique_ptr<std::vector<PileupSummaryInfo> > PSIVector(new std::vector<PileupSummaryInfo>);
 
   if (isPreMixed_) {
     edm::Handle<std::vector<PileupSummaryInfo> > psiInput;
     event.getByToken(pileupSummaryToken_, psiInput);
 
     std::vector<PileupSummaryInfo>::const_iterator PSiter;
 
     for (PSiter = psiInput.product()->begin(); PSiter != psiInput.product()->end(); PSiter++) {
       PSIVector->push_back(*PSiter);
     }
 
     edm::Handle<int> bsInput;
     event.getByToken(bunchSpacingToken_, bsInput);
     int bunchSpacing = *(bsInput.product());
 
     event.put(std::move(PSIVector));
 
     //add bunch spacing to the event as a seperate integer for use by downstream modules
     std::unique_ptr<int> bunchSpacingP(new int(bunchSpacing));
     event.put(std::move(bunchSpacingP), "bunchSpacing");
 
     return;
   }
 
   edm::Handle<PileupMixingContent> MixingPileup;  // Get True pileup information from MixingModule
   event.getByToken(PileupInfoLabel_, MixingPileup);
 
   std::vector<int> BunchCrossings;
   std::vector<int> Interactions_Xing;
   std::vector<float> TrueInteractions_Xing;
   std::vector<std::vector<edm::EventID> > eventInfoList_Xing;
 
   int bunchSpacing;
 
   // extract information - way easier than counting vertices
   const PileupMixingContent* MixInfo = MixingPileup.product();
   const std::vector<int>& bunchCrossing = MixInfo->getMix_bunchCrossing();
   const std::vector<int>& interactions = MixInfo->getMix_Ninteractions();
   const std::vector<float>& TrueInteractions = MixInfo->getMix_TrueInteractions();
   const std::vector<edm::EventID> eventInfoList = MixInfo->getMix_eventInfo();
 
   bunchSpacing = MixInfo->getMix_bunchSpacing();
   unsigned int totalIntPU = 0;
 
   for (int ib = 0; ib < (int)bunchCrossing.size(); ++ib) {
     //      std::cout << " bcr, nint " << bunchCrossing[ib] << " " << interactions[ib] << std::endl;
     BunchCrossings.push_back(bunchCrossing[ib]);
     Interactions_Xing.push_back(interactions[ib]);
     TrueInteractions_Xing.push_back(TrueInteractions[ib]);
 
     std::vector<edm::EventID> eventInfos;
     eventInfos.reserve(interactions[ib]);
     for (int pu = 0; pu < interactions[ib]; pu++) {
       eventInfos.push_back(eventInfoList[totalIntPU + pu]);
     }
     totalIntPU += (interactions[ib]);
     eventInfoList_Xing.push_back(eventInfos);
   }
 
   // store information from pileup vertices, if it's in the event. Have to loop on interactions again.
   std::vector<std::vector<float> > ptHatList_Xing;
   std::vector<std::vector<float> > zPosList_Xing;
   std::vector<std::vector<float> > tPosList_Xing;
 
   bool Have_pThats = false;
 
   edm::Handle<PileupVertexContent> MixingPileupVtx;          // Get True pileup information from MixingModule
   if (event.getByToken(PileupVtxLabel_, MixingPileupVtx)) {  // extract information - way easier than counting vertices
     const PileupVertexContent* MixVtxInfo = MixingPileupVtx.product();
 
     Have_pThats = true;
 
     const std::vector<int>& bunchCrossing = MixInfo->getMix_bunchCrossing();
     const std::vector<int>& interactions = MixInfo->getMix_Ninteractions();
 
     const std::vector<float>& PtHatInput = MixVtxInfo->getMix_pT_hats();
     const std::vector<float>& ZposInput = MixVtxInfo->getMix_z_Vtxs();
     const std::vector<float>& TposInput = MixVtxInfo->getMix_t_Vtxs();
 
     // store information from pileup vertices, if it's in the event:
 
     unsigned int totalIntPU = 0;
 
     for (int ib = 0; ib < (int)bunchCrossing.size(); ++ib) {
       //      std::cout << " bcr, nint " << bunchCrossing[ib] << " " << interactions[ib] << std::endl;
 
       std::vector<float> zposBX, tposBX;
       std::vector<float> pthatBX;
       zposBX.reserve(interactions[ib]);
       if (saveVtxTimes_)
         tposBX.reserve(interactions[ib]);
       pthatBX.reserve(interactions[ib]);
       for (int pu = 0; pu < interactions[ib]; pu++) {
         zposBX.push_back(ZposInput[totalIntPU + pu]);
         if (saveVtxTimes_)
           tposBX.push_back(TposInput[totalIntPU + pu]);
         pthatBX.push_back(PtHatInput[totalIntPU + pu]);
       }
       totalIntPU += (interactions[ib]);
       zPosList_Xing.push_back(zposBX);
       tPosList_Xing.push_back(tposBX);
       ptHatList_Xing.push_back(pthatBX);
     }
   }  // end of VertexInfo block
 
   //Now, get information on valid particles that look like they could be in the tracking volume
 
   zpositions.clear();
   sumpT_lowpT.clear();
   sumpT_highpT.clear();
   ntrks_lowpT.clear();
   ntrks_highpT.clear();
   event_index_.clear();
 
   int lastEvent = 0;  // zero is the true MC hard-scatter event
 
   // int lastBunchCrossing = 0; // 0 is the true bunch crossing, should always come first.
 
   bool HaveTrackingParticles = false;
 
   edm::Handle<TrackingParticleCollection> mergedPH;
   edm::Handle<TrackingVertexCollection> mergedVH;
 
   TrackingVertexCollection::const_iterator iVtx;
   TrackingVertexCollection::const_iterator iVtxTest;
   TrackingParticleCollection::const_iterator iTrackTest;
 
   if (LookAtTrackingTruth_) {
     if (event.getByToken(trackingTruthT_, mergedPH) && event.getByToken(trackingTruthV_, mergedVH)) {
       HaveTrackingParticles = true;
 
       iVtxTest = mergedVH->begin();
       iTrackTest = mergedPH->begin();
     }
   }
 
   int nminb_vtx = 0;
   //  bool First = true;
   //  bool flag_new = false;
 
   std::vector<int>::iterator BXIter;
   std::vector<int>::iterator InteractionsIter = Interactions_Xing.begin();
   std::vector<float>::iterator TInteractionsIter = TrueInteractions_Xing.begin();
   std::vector<std::vector<edm::EventID> >::iterator TEventInfoIter = eventInfoList_Xing.begin();
 
   std::vector<std::vector<float> >::iterator zPosIter;
   std::vector<std::vector<float> >::iterator tPosIter;
   std::vector<std::vector<float> >::iterator pThatIter;
 
   if (Have_pThats) {
     zPosIter = zPosList_Xing.begin();
     tPosIter = tPosList_Xing.begin();
     pThatIter = ptHatList_Xing.begin();
   }
 
   // loop over the bunch crossings and interactions we have extracted
 
   for (BXIter = BunchCrossings.begin(); BXIter != BunchCrossings.end();
        ++BXIter, ++InteractionsIter, ++TInteractionsIter, ++TEventInfoIter) {
     //std::cout << "looking for BX: " << (*BXIter) << std::endl;
 
     if (HaveTrackingParticles) {  // leave open the option of not producing TrackingParticles and just keeping # interactions
 
       for (iVtx = iVtxTest; iVtx != mergedVH->end(); ++iVtx) {
         if (iVtx->eventId().bunchCrossing() == (*BXIter)) {  // found first vertex in this bunch crossing
 
           if (iVtx->eventId().event() != lastEvent) {
             //std::cout << "BX,event " << iVtx->eventId().bunchCrossing() << " " << iVtx->eventId().event() << std::endl;
 
             float zpos = 0.;
             zpos = iVtx->position().z();
             zpositions.push_back(zpos);  //save z position of each vertex
             sumpT_lowpT.push_back(0.);
             sumpT_highpT.push_back(0.);
             ntrks_lowpT.push_back(0);
             ntrks_highpT.push_back(0);
 
             lastEvent = iVtx->eventId().event();
             iVtxTest = --iVtx;  // just for security
 
             // turns out events aren't sequential... save map of indices
 
             event_index_.insert(myindex::value_type(lastEvent, nminb_vtx));
 
             ++nminb_vtx;
 
             continue;
           }
         }
       }
 
       // next loop over tracks to get information
 
       for (TrackingParticleCollection::const_iterator iTrack = iTrackTest; iTrack != mergedPH->end(); ++iTrack) {
         bool FoundTrk = false;
 
         float zpos = 0.;
 
         if (iTrack->eventId().bunchCrossing() == (*BXIter) && iTrack->eventId().event() > 0) {
           FoundTrk = true;
           int correct_index = event_index_[iTrack->eventId().event()];
 
           //std::cout << " track index, correct index " << iTrack->eventId().event() << " " << correct_index << std::endl;
 
           zpos = zpositions[correct_index];
           if (iTrack->matchedHit() > 0) {
             if (fabs(iTrack->parentVertex()->position().z() - zpos) <
                 0.1) {  //make sure track really comes from this vertex
               //std::cout << *iTrack << std::endl;
               float Tpx = iTrack->p4().px();
               float Tpy = iTrack->p4().py();
               float TpT = sqrt(Tpx * Tpx + Tpy * Tpy);
               if (TpT > pTcut_1_) {
                 sumpT_lowpT[correct_index] += TpT;
                 ++ntrks_lowpT[correct_index];
               }
               if (TpT > pTcut_2_) {
                 sumpT_highpT[correct_index] += TpT;
                 ++ntrks_highpT[correct_index];
               }
             }
           }
         } else {
           if (FoundTrk) {
             iTrackTest = --iTrack;  // reset so we can start over next time
             --iTrackTest;           // just to be sure
             break;
           }
         }
 
       }  // end of track loop
 
     }  // end of check that we have TrackingParticles to begin with...
 
     // now that we have all of the track information for a given bunch crossing,
     // make PileupSummary for this one and move on
 
     //    std::cout << "Making PSI for bunch " << lastBunchCrossing << std::endl;
 
     if (!HaveTrackingParticles) {  // stick in one value so we don't have empty vectors
 
       zpositions.push_back(-999.);
       sumpT_lowpT.push_back(0.);
       sumpT_highpT.push_back(0.);
       ntrks_lowpT.push_back(0);
       ntrks_highpT.push_back(0);
     }
 
     if (Have_pThats) {
       PileupSummaryInfo PSI_bunch = PileupSummaryInfo((*InteractionsIter),
                                                       (*zPosIter),
                                                       (*tPosIter),
                                                       sumpT_lowpT,
                                                       sumpT_highpT,
                                                       ntrks_lowpT,
                                                       ntrks_highpT,
                                                       (*TEventInfoIter),
                                                       (*pThatIter),
                                                       (*BXIter),
                                                       (*TInteractionsIter),
                                                       bunchSpacing);
       PSIVector->push_back(PSI_bunch);
 
       zPosIter++;
       tPosIter++;
       pThatIter++;
     } else {
       std::vector<float> zposZeros((*TEventInfoIter).size(), 0);
       std::vector<float> tposZeros((*TEventInfoIter).size(), 0);
       std::vector<float> pThatZeros((*TEventInfoIter).size(), 0);
 
       PileupSummaryInfo PSI_bunch = PileupSummaryInfo((*InteractionsIter),
                                                       zposZeros,
                                                       tposZeros,
                                                       sumpT_lowpT,
                                                       sumpT_highpT,
                                                       ntrks_lowpT,
                                                       ntrks_highpT,
                                                       (*TEventInfoIter),
                                                       pThatZeros,
                                                       (*BXIter),
                                                       (*TInteractionsIter),
                                                       bunchSpacing);
 
       PSIVector->push_back(PSI_bunch);
     }
     //std::cout << " " << std::endl;
     //std::cout << "Adding Bunch Crossing, nint " << (*BXIter) << " " <<  (*InteractionsIter) << std::endl;
 
     //for(int iv = 0; iv<(*InteractionsIter); ++iv){
 
     // std::cout << "Z position " << zpositions[iv] << std::endl;
     // std::cout << "ntrks_lowpT " << ntrks_lowpT[iv] << std::endl;
     // std::cout << "sumpT_lowpT " << sumpT_lowpT[iv] << std::endl;
     // std::cout << "ntrks_highpT " << ntrks_highpT[iv] << std::endl;
     // std::cout << "sumpT_highpT " << sumpT_highpT[iv] << std::endl;
     //std::cout << iv << " " << PSI_bunch.getPU_EventID()[iv] << std::endl;
     //}
 
     // if(HaveTrackingParticles) lastBunchCrossing = iVtx->eventId().bunchCrossing();
 
     event_index_.clear();
     zpositions.clear();
     sumpT_lowpT.clear();
     sumpT_highpT.clear();
     ntrks_lowpT.clear();
     ntrks_highpT.clear();
     nminb_vtx = 0;
     lastEvent = 0;
 
   }  // end of loop over bunch crossings
 
   // put our vector of PileupSummaryInfo objects into the event.
 
   event.put(std::move(PSIVector));
 
   //add bunch spacing to the event as a seperate integer for use by downstream modules
   std::unique_ptr<int> bunchSpacingP(new int(bunchSpacing));
   event.put(std::move(bunchSpacingP), "bunchSpacing");
 }