#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 26 of file MuonTruth.h.

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

Definition at line 28 of file MuonTruth.h.

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

Definition at line 29 of file MuonTruth.h.

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

Definition at line 27 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 206 of file MuonTruth.cc.

References edm::DetSet< T >::begin(), RecoTauCleanerPlugins::charge, edm::DetSet< T >::end(), theChargeMap, theTotalCharge, and histoStyle::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 156 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(), relativeConstraints::geometry, CSCGeometry::layer(), CSCRecHit2D::nStrips(), DetId::rawId(), theChargeMap, theDetId, theDigiSimLinks, theTotalCharge, and histoStyle::weight.

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 179 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 190 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 130 of file MuonTruth.cc.

References newFWLiteAna::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 42 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< class >::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 89 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 117 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 147 of file MuonTruth.cc.

References 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 105 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;
 }