PileupInformation Class Reference

#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

EncodedEventIdToIndex

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

private

Definition at line 37 of file PileupInformation.h.

myindex

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

private

Definition at line 38 of file PileupInformation.h.

Constructor & Destructor Documentation

PileupInformation()

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

explicit

Definition at line 19 of file PileupInformation.cc.

                                                                  {
  // 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>();
}

References bunchSpacingToken_, distanceCut_, isPreMixed_, LookAtTrackingTruth_, MessageCategory_, PileupInfoLabel_, pileupSummaryToken_, PileupVtxLabel_, pTcut_1_, pTcut_2_, saveVtxTimes_, trackingTruthT_, trackingTruthV_, volumeRadius_, and volumeZ_.

Member Function Documentation

produce()

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

overrideprivate

Definition at line 66 of file PileupInformation.cc.

                                                                           {
  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");
}

References rctDigis_cfi::BunchCrossings, HLTEgPhaseIITestSequence_cff::bunchSpacing, bunchSpacingToken_, event_index_, 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_, callgrindSwitch_cfi::lastEvent, 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.

Member Data Documentation

bunchSpacingToken_

edm::EDGetTokenT<int> PileupInformation::bunchSpacingToken_

private

Definition at line 57 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

conf_

edm::ParameterSet PileupInformation::conf_

private

Definition at line 35 of file PileupInformation.h.

distanceCut_

double PileupInformation::distanceCut_

private

Definition at line 47 of file PileupInformation.h.

Referenced by PileupInformation().

event_index_

myindex PileupInformation::event_index_

private

Definition at line 39 of file PileupInformation.h.

Referenced by produce().

isPreMixed_

bool PileupInformation::isPreMixed_

private

Definition at line 52 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

LookAtTrackingTruth_

bool PileupInformation::LookAtTrackingTruth_

private

Definition at line 61 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

MessageCategory_

std::string PileupInformation::MessageCategory_

private

Definition at line 65 of file PileupInformation.h.

Referenced by PileupInformation().

ntrks_highpT

std::vector<int> PileupInformation::ntrks_highpT

private

Definition at line 45 of file PileupInformation.h.

Referenced by produce().

ntrks_lowpT

std::vector<int> PileupInformation::ntrks_lowpT

private

Definition at line 44 of file PileupInformation.h.

Referenced by produce().

PileupInfoLabel_

edm::EDGetTokenT<PileupMixingContent> PileupInformation::PileupInfoLabel_

private

Definition at line 56 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

pileupSummaryToken_

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

private

Definition at line 58 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

PileupVtxLabel_

edm::EDGetTokenT<PileupVertexContent> PileupInformation::PileupVtxLabel_

private

Definition at line 59 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

pTcut_1_

double PileupInformation::pTcut_1_

private

Definition at line 50 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

pTcut_2_

double PileupInformation::pTcut_2_

private

Definition at line 51 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

saveVtxTimes_

bool PileupInformation::saveVtxTimes_

private

Definition at line 63 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

sumpT_highpT

std::vector<float> PileupInformation::sumpT_highpT

private

Definition at line 43 of file PileupInformation.h.

Referenced by produce().

sumpT_lowpT

std::vector<float> PileupInformation::sumpT_lowpT

private

Definition at line 42 of file PileupInformation.h.

Referenced by produce().

trackingTruthT_

edm::EDGetTokenT<TrackingParticleCollection> PileupInformation::trackingTruthT_

private

Definition at line 54 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

trackingTruthV_

edm::EDGetTokenT<TrackingVertexCollection> PileupInformation::trackingTruthV_

private

Definition at line 55 of file PileupInformation.h.

Referenced by PileupInformation(), and produce().

volumeRadius_

double PileupInformation::volumeRadius_

private

Definition at line 48 of file PileupInformation.h.

Referenced by PileupInformation().

volumeZ_

double PileupInformation::volumeZ_

private

Definition at line 49 of file PileupInformation.h.

Referenced by PileupInformation().

zpositions

std::vector<float> PileupInformation::zpositions

private

Definition at line 41 of file PileupInformation.h.

Referenced by produce().