#include <PileupInformation.h>

Inheritance diagram for PileupInformation:

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

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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 41 of file PileupInformation.h.

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

private

Definition at line 42 of file PileupInformation.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 20 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 67 of file PileupInformation.cc.

References bunchSpacingToken_, DEFINE_FWK_MODULE, event_index_, Exception, 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, createfilelist::int, isPreMixed_, LookAtTrackingTruth_, eostools::move(), ntrks_highpT, ntrks_lowpT, PileupInfoLabel_, pileupSummaryToken_, PileupVtxLabel_, edm::Handle< T >::product(), pTcut_1_, pTcut_2_, muons2muons_cfi::pu, 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;
 
   const PileupMixingContent* MixInfo = MixingPileup.product();
 
   if(MixInfo) {  // extract information - way easier than counting vertices
 
     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);
 
     }
   }
   else{ // have to throw an exception..
 
     throw cms::Exception("PileupInformation") << " PileupMixingContent is missing from the event.\n" 
                                                  "There must be some breakdown in the Simulation Chain.\n"
                                                  "You must run the MixingModule before calling this routine."; 
 
   }
   
   // store information from pileup vertices, if it's in the event. Have to loop on interactions again.
 
   edm::Handle< PileupVertexContent > MixingPileupVtx;  // Get True pileup information from MixingModule
   event.getByToken(PileupVtxLabel_, MixingPileupVtx);
 
   const PileupVertexContent* MixVtxInfo = MixingPileupVtx.product();
 
   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;
 
   if(MixVtxInfo) {  // extract information - way easier than counting vertices
 
 
     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");
 
 }