#include <MuonTruth.h>

Public Types
typedef edm::DetSetVector< StripDigiSimLink >	DigiSimLinks

typedef edm::DetSet< StripDigiSimLink >	LayerLinks

typedef std::pair< uint32_t, EncodedEventId >	SimHitIdpr

typedef edm::DetSetVector< StripDigiSimLink >	WireDigiSimLinks

Public Member Functions
void	analyze (const CSCRecHit2D &recHit)

void	analyze (const CSCStripDigi &stripDigi, int rawDetIdCorrespondingToCSCLayer)

void	analyze (const CSCWireDigi &wireDigi, int rawDetIdCorrespondingToCSCLayer)

void	initEvent (const edm::Event &, const edm::EventSetup &)

float	muonFraction ()
	analyze() must be called before any of the following More...

std::vector< PSimHit >	muonHits ()

	MuonTruth (const edm::Event &, const edm::EventSetup &, const edm::ParameterSet &)

	MuonTruth (const edm::ParameterSet &, edm::ConsumesCollector &&iC)

std::vector< PSimHit >	simHits ()

Public Attributes
const CSCBadChambers *	cscBadChambers

Private Member Functions
void	addChannel (const LayerLinks &layerLinks, int channel, float weight=1.)

std::vector< PSimHit >	hitsFromSimTrack (SimHitIdpr truthId)

int	particleType (SimHitIdpr truthId)

Private Attributes
bool	crossingframe

const CSCGeometry *	cscgeom

edm::InputTag	CSCsimHitsTag

edm::InputTag	CSCsimHitsXFTag

edm::InputTag	linksTag

std::map< SimHitIdpr, float >	theChargeMap

unsigned int	theDetId

const DigiSimLinks *	theDigiSimLinks

std::map< unsigned int, edm::PSimHitContainer >	theSimHitMap

float	theTotalCharge

const DigiSimLinks *	theWireDigiSimLinks

edm::InputTag	wireLinksTag

Detailed Description

Definition at line 24 of file MuonTruth.h.

Member Typedef Documentation

typedef edm::DetSetVector<StripDigiSimLink> MuonTruth::DigiSimLinks

Definition at line 27 of file MuonTruth.h.

typedef edm::DetSet<StripDigiSimLink> MuonTruth::LayerLinks

Definition at line 29 of file MuonTruth.h.

typedef std::pair<uint32_t, EncodedEventId> MuonTruth::SimHitIdpr

Definition at line 30 of file MuonTruth.h.

typedef edm::DetSetVector<StripDigiSimLink> MuonTruth::WireDigiSimLinks

Definition at line 28 of file MuonTruth.h.

Constructor & Destructor Documentation

MuonTruth::MuonTruth	(	const edm::Event &	event,
		const edm::EventSetup &	setup,
		const edm::ParameterSet &	conf
	)

Definition at line 8 of file MuonTruth.cc.

References initEvent().

                                                                                                   : 
   theDigiSimLinks(nullptr),
   theWireDigiSimLinks(nullptr),
   linksTag(conf.getParameter<edm::InputTag>("CSClinksTag")),
   wireLinksTag(conf.getParameter<edm::InputTag>("CSCwireLinksTag")),
   // CrossingFrame used or not ?
   crossingframe(conf.getParameter<bool>("crossingframe")),
   CSCsimHitsTag(conf.getParameter<edm::InputTag>("CSCsimHitsTag")),
   CSCsimHitsXFTag(conf.getParameter<edm::InputTag>("CSCsimHitsXFTag"))
 
 {
   initEvent(event,setup);
 }

MuonTruth::MuonTruth	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &&	iC
	)

Definition at line 22 of file MuonTruth.cc.

References crossingframe, CSCsimHitsTag, CSCsimHitsXFTag, edm::InputTag::label(), linksTag, and wireLinksTag.

                                                                              : 
   theDigiSimLinks(nullptr),
   theWireDigiSimLinks(nullptr),
   linksTag(conf.getParameter<edm::InputTag>("CSClinksTag")),
   wireLinksTag(conf.getParameter<edm::InputTag>("CSCwireLinksTag")),
   // CrossingFrame used or not ?
   crossingframe(conf.getParameter<bool>("crossingframe")),
   CSCsimHitsTag(conf.getParameter<edm::InputTag>("CSCsimHitsTag")),
   CSCsimHitsXFTag(conf.getParameter<edm::InputTag>("CSCsimHitsXFTag"))
 
 {
   iC.consumes<DigiSimLinks>(linksTag);
   iC.consumes<DigiSimLinks>(wireLinksTag);
   if ( crossingframe ) {
     iC.consumes<CrossingFrame<PSimHit> >(CSCsimHitsXFTag);
   } else if (!CSCsimHitsTag.label().empty()){
     iC.consumes<edm::PSimHitContainer>(CSCsimHitsTag);
   }
 
 }

Member Function Documentation

void MuonTruth::addChannel	(	const LayerLinks &	layerLinks,
		int	channel,
		float	weight = `1.`
	)

private

Definition at line 240 of file MuonTruth.cc.

References edm::DetSet< T >::begin(), ALCARECOTkAlJpsiMuMu_cff::charge, edm::DetSet< T >::end(), theChargeMap, theTotalCharge, and mps_merge::weight.

Referenced by analyze().

 {
   LayerLinks::const_iterator linkItr = layerLinks.begin(), 
                              lastLayerLink = layerLinks.end();
 
   for ( ; linkItr != lastLayerLink; ++linkItr)
   {
     int linkChannel = linkItr->channel();
     if(linkChannel == channel)
     {
       float charge = linkItr->fraction() * weight;
       theTotalCharge += charge;
       // see if it's in the map
       SimHitIdpr truthId(linkItr->SimTrackId(),linkItr->eventId());
       std::map<SimHitIdpr, float>::const_iterator chargeMapItr = theChargeMap.find(truthId);
       if(chargeMapItr == theChargeMap.end())
       {
     theChargeMap[truthId] = charge;
       }
       else
       {
     theChargeMap[truthId] += charge;
       }
     }
   }
 }

void MuonTruth::analyze ( const CSCRecHit2D & recHit )

Definition at line 182 of file MuonTruth.cc.

References CSCRecHit2D::adcs(), addChannel(), CSCLayerGeometry::channel(), CSCRecHit2D::channels(), CSCRecHit2D::cscDetId(), cscgeom, edm::DetSetVector< T >::end(), edm::DetSetVector< T >::find(), TrackingRecHit::geographicalId(), geometry, CSCGeometry::layer(), CSCRecHit2D::nStrips(), DetId::rawId(), theChargeMap, theDetId, theDigiSimLinks, and theTotalCharge.

Referenced by CSCTruthTest::analyze().

 {
   theChargeMap.clear();
   theTotalCharge = 0.;
   theDetId = recHit.geographicalId().rawId();
 
   int nchannels = recHit.nStrips();
   const CSCLayerGeometry * laygeom = cscgeom->layer(recHit.cscDetId())->geometry();
 
   for(int idigi = 0; idigi < nchannels; ++idigi)
   {
     // strip and readout channel numbers may differ in ME1/1A
     int istrip = recHit.channels(idigi);
     int channel = laygeom->channel(istrip);
     float weight = recHit.adcs(idigi,0);//DL: I think this is wrong before and after...seems to assume one time binadcContainer[idigi];
 
     DigiSimLinks::const_iterator layerLinks = theDigiSimLinks->find(theDetId);
 
     if(layerLinks != theDigiSimLinks->end())
     {
       addChannel(*layerLinks, channel, weight);
     }
   }
 }

void MuonTruth::analyze	(	const CSCStripDigi &	stripDigi,
		int	rawDetIdCorrespondingToCSCLayer
	)

Definition at line 208 of file MuonTruth.cc.

References addChannel(), edm::DetSetVector< T >::end(), edm::DetSetVector< T >::find(), CSCStripDigi::getStrip(), theChargeMap, theDetId, theDigiSimLinks, and theTotalCharge.

 {
   theDetId = rawDetIdCorrespondingToCSCLayer;
   theChargeMap.clear();
   theTotalCharge = 0.;
 
   DigiSimLinks::const_iterator layerLinks = theDigiSimLinks->find(theDetId);
   if(layerLinks != theDigiSimLinks->end())
   {
     addChannel(*layerLinks, stripDigi.getStrip(), 1.);
   }
 }

void MuonTruth::analyze	(	const CSCWireDigi &	wireDigi,
		int	rawDetIdCorrespondingToCSCLayer
	)

Definition at line 222 of file MuonTruth.cc.

References addChannel(), edm::DetSetVector< T >::end(), edm::DetSetVector< T >::find(), CSCWireDigi::getWireGroup(), theChargeMap, theDetId, theDigiSimLinks, theTotalCharge, and theWireDigiSimLinks.

 {
   theDetId = rawDetIdCorrespondingToCSCLayer;
   theChargeMap.clear();
   theTotalCharge = 0.;
 
   WireDigiSimLinks::const_iterator layerLinks = theWireDigiSimLinks->find(theDetId);
 
   if(layerLinks != theDigiSimLinks->end()) 
   {
     // In the simulation digis, the channel labels for wires and strips must be distinct, therefore:
     int wireDigiInSimulation = wireDigi.getWireGroup() + 100;
     //
     addChannel(*layerLinks, wireDigiInSimulation, 1.);
   }
 }

std::vector< PSimHit > MuonTruth::hitsFromSimTrack ( MuonTruth::SimHitIdpr truthId )

private

Definition at line 148 of file MuonTruth.cc.

References runEdmFileComparison::found, mps_fire::result, theDetId, and theSimHitMap.

Referenced by particleType(), and simHits().

 {
   std::vector<PSimHit> result;
 
   auto found = theSimHitMap.find(theDetId);
   if (found != theSimHitMap.end()) {
 
     for(auto const& hit: found->second)
       {
         unsigned int hitTrack = hit.trackId();
         EncodedEventId hitEvId = hit.eventId();
         
         if(hitTrack == truthId.first && hitEvId == truthId.second) 
           {
             result.push_back(hit);
           }
       }
   }
   return result;
 }

void MuonTruth::initEvent	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

Definition at line 43 of file MuonTruth.cc.

References crossingframe, cscBadChambers, cscgeom, CSCsimHitsTag, CSCsimHitsXFTag, TTClusterAssociation_cfi::digiSimLinks, edm::EventSetup::get(), edm::InputTag::label(), linksTag, LogTrace, edm::Handle< T >::product(), edm::ESHandle< T >::product(), theDigiSimLinks, theSimHitMap, theWireDigiSimLinks, and wireLinksTag.

Referenced by MuonTruth().

                                                                            {
 
   edm::Handle<DigiSimLinks> digiSimLinks;
   LogTrace("MuonTruth") <<"getting CSC Strip DigiSimLink collection - "<<linksTag;
   event.getByLabel(linksTag, digiSimLinks);
   theDigiSimLinks = digiSimLinks.product();
 
   edm::Handle<DigiSimLinks> wireDigiSimLinks;
   LogTrace("MuonTruth") <<"getting CSC Wire DigiSimLink collection - "<<wireLinksTag;
   event.getByLabel(wireLinksTag, wireDigiSimLinks);
   theWireDigiSimLinks = wireDigiSimLinks.product();
 
   // get CSC Geometry to use CSCLayer methods
   edm::ESHandle<CSCGeometry> mugeom;
   setup.get<MuonGeometryRecord>().get( mugeom );
   cscgeom = &*mugeom;
 
   // get CSC Bad Chambers (ME4/2)
   edm::ESHandle<CSCBadChambers> badChambers;
   setup.get<CSCBadChambersRcd>().get(badChambers);
   cscBadChambers = badChambers.product();
 
   theSimHitMap.clear();
 
   if (crossingframe) {
     
     edm::Handle<CrossingFrame<PSimHit> > cf;
     LogTrace("MuonTruth") <<"getting CrossingFrame<PSimHit> collection - "<<CSCsimHitsXFTag;
     event.getByLabel(CSCsimHitsXFTag, cf);
     
     std::unique_ptr<MixCollection<PSimHit> > 
       CSCsimhits( new MixCollection<PSimHit>(cf.product()) );
     LogTrace("MuonTruth") <<"... size = "<<CSCsimhits->size();
 
     for(MixCollection<PSimHit>::MixItr hitItr = CSCsimhits->begin();
     hitItr != CSCsimhits->end(); ++hitItr) 
       {
     theSimHitMap[hitItr->detUnitId()].push_back(*hitItr);
       }
     
   } else if (!CSCsimHitsTag.label().empty()){
 
     edm::Handle<edm::PSimHitContainer> CSCsimhits;
     LogTrace("MuonTruth") <<"getting PSimHit collection - "<<CSCsimHitsTag;
     event.getByLabel(CSCsimHitsTag, CSCsimhits);    
     LogTrace("MuonTruth") <<"... size = "<<CSCsimhits->size();
     
     for(edm::PSimHitContainer::const_iterator hitItr = CSCsimhits->begin();
     hitItr != CSCsimhits->end(); ++hitItr)
       {
     theSimHitMap[hitItr->detUnitId()].push_back(*hitItr);
       }
   }
 }

float MuonTruth::muonFraction ( )

analyze() must be called before any of the following

Definition at line 98 of file MuonTruth.cc.

References funct::abs(), particleType(), theChargeMap, and theTotalCharge.

Referenced by CSCTruthTest::analyze().

 {
   if(theChargeMap.empty()) return 0.;
 
   float muonCharge = 0.;
   for(std::map<SimHitIdpr, float>::const_iterator chargeMapItr = theChargeMap.begin();
       chargeMapItr != theChargeMap.end(); ++chargeMapItr)
   {
     if( abs(particleType(chargeMapItr->first)) == 13)
     {
       muonCharge += chargeMapItr->second;
     }
   }
 
   return muonCharge / theTotalCharge;
 }

std::vector< PSimHit > MuonTruth::muonHits ( )

Definition at line 130 of file MuonTruth.cc.

References funct::abs(), mps_fire::result, and simHits().

 {
   std::vector<PSimHit> result;
   std::vector<PSimHit> allHits = simHits();
   std::vector<PSimHit>::const_iterator hitItr = allHits.begin(), lastHit = allHits.end();
 
   for( ; hitItr != lastHit; ++hitItr)
   {
     if(abs((*hitItr).particleType()) == 13)
     {
       result.push_back(*hitItr);
     }
   }
   return result;
 }

int MuonTruth::particleType ( MuonTruth::SimHitIdpr truthId )

private

Definition at line 170 of file MuonTruth.cc.

References hfClusterShapes_cfi::hits, hitsFromSimTrack(), and mps_fire::result.

Referenced by muonFraction().

 {
   int result = 0;
   const std::vector<PSimHit>& hits = hitsFromSimTrack(truthId);
   if(!hits.empty())
   {
     result = hits[0].particleType();
   }
   return result;
 }

std::vector< PSimHit > MuonTruth::simHits ( )

Definition at line 116 of file MuonTruth.cc.

References hitsFromSimTrack(), mps_fire::result, and theChargeMap.

Referenced by ntupleDataFormat.TrackingParticle::bestMatchingTrack(), and muonHits().

 {
   std::vector<PSimHit> result;
   for(std::map<SimHitIdpr, float>::const_iterator chargeMapItr = theChargeMap.begin();
       chargeMapItr != theChargeMap.end(); ++chargeMapItr)
   {
     std::vector<PSimHit> trackHits = hitsFromSimTrack(chargeMapItr->first);
     result.insert(result.end(), trackHits.begin(), trackHits.end());
   }
   
   return result;
 }