#include <Phase2OTValidateTrackingRecHit.cc>

Inheritance diagram for Phase2OTValidateTrackingRecHit:

Public Member Functions
void	analyze (const edm::Event &iEvent, const edm::EventSetup &iSetup) override

	Phase2OTValidateTrackingRecHit (const edm::ParameterSet &)

	~Phase2OTValidateTrackingRecHit () override

Public Member Functions inherited from Phase2OTValidateRecHitBase
void	bookHistograms (DQMStore::IBooker &ibooker, edm::Run const &iRun, edm::EventSetup const &iSetup) override

void	bookLayerHistos (DQMStore::IBooker &ibooker, unsigned int det_id, std::string &subdir)

void	dqmBeginRun (const edm::Run &iRun, const edm::EventSetup &iSetup) override

void	fillOTRecHitHistos (const PSimHit simhitClosest, const Phase2TrackerRecHit1D rechit, const std::map< unsigned int, SimTrack > &selectedSimTrackMap, std::map< std::string, unsigned int > &nrechitLayerMapP_primary, std::map< std::string, unsigned int > &nrechitLayerMapS_primary)

	Phase2OTValidateRecHitBase (const edm::ParameterSet &)

	~Phase2OTValidateRecHitBase () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from Phase2OTValidateRecHitBase
static void	fillPSetDescription (edm::ParameterSetDescription &desc)

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr < DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Private Member Functions
void	fillOTHistos (const edm::Event &iEvent, const TrackerHitAssociator &associateRecHit, const std::vector< edm::Handle< edm::PSimHitContainer >> &simHits, const std::map< unsigned int, SimTrack > &selectedSimTrackMap)

Private Attributes
edm::ParameterSet	config_

std::vector< edm::EDGetTokenT < edm::PSimHitContainer > >	simHitTokens_

const double	simtrackminpt_

const edm::EDGetTokenT < edm::SimTrackContainer >	simTracksToken_

const edm::EDGetTokenT < reco::TrackCollection >	tokenTracks_

TrackerHitAssociator::Config	trackerHitAssociatorConfig_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
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

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from Phase2OTValidateRecHitBase
edm::ParameterSet	config_

const edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

std::string	geomType_

std::map< std::string, RecHitME >	layerMEs_

const TrackerGeometry *	tkGeom_ = nullptr

const edm::ESGetToken < TrackerTopology, TrackerTopologyRcd >	topoToken_

const TrackerTopology *	tTopo_ = nullptr

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Description: Standalone Plugin for Phase2 RecHit validation

Definition at line 51 of file Phase2OTValidateTrackingRecHit.cc.

Constructor & Destructor Documentation

Phase2OTValidateTrackingRecHit::Phase2OTValidateTrackingRecHit ( const edm::ParameterSet & iConfig )

explicit

Definition at line 76 of file Phase2OTValidateTrackingRecHit.cc.

References config_, edm::ParameterSet::getParameter(), and simHitTokens_.

     : Phase2OTValidateRecHitBase(iConfig),
       config_(iConfig),
       trackerHitAssociatorConfig_(iConfig, consumesCollector()),
       simtrackminpt_(iConfig.getParameter<double>("SimTrackMinPt")),
       tokenTracks_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracksSrc"))),
       simTracksToken_(consumes<edm::SimTrackContainer>(iConfig.getParameter<edm::InputTag>("simTracksSrc"))) {
   edm::LogInfo("Phase2OTValidateTrackingRecHit") << ">>> Construct Phase2OTValidateTrackingRecHit ";
   for (const auto& itag : config_.getParameter<std::vector<edm::InputTag>>("PSimHitSource"))
     simHitTokens_.push_back(consumes<edm::PSimHitContainer>(itag));
 }

Phase2OTValidateTrackingRecHit::~Phase2OTValidateTrackingRecHit ( )

override

Definition at line 91 of file Phase2OTValidateTrackingRecHit.cc.

                                                                 {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
   edm::LogInfo("Phase2OTValidateTrackingRecHit") << ">>> Destroy Phase2OTValidateTrackingRecHit ";
 }

Member Function Documentation

void Phase2OTValidateTrackingRecHit::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 100 of file Phase2OTValidateTrackingRecHit.cc.

References fillOTHistos(), edm::Event::getHandle(), trackerHits::simHits, simHitTokens_, simtrackminpt_, simTracksToken_, and trackerHitAssociatorConfig_.

                                                                                                 {
   std::vector<edm::Handle<edm::PSimHitContainer>> simHits;
   for (const auto& itoken : simHitTokens_) {
     const auto& simHitHandle = iEvent.getHandle(itoken);
     if (!simHitHandle.isValid())
       continue;
     simHits.emplace_back(simHitHandle);
   }
   // Get the SimTracks and push them in a map of id, SimTrack
   const auto& simTracks = iEvent.getHandle(simTracksToken_);
   std::map<unsigned int, SimTrack> selectedSimTrackMap;
   for (edm::SimTrackContainer::const_iterator simTrackIt(simTracks->begin()); simTrackIt != simTracks->end();
        ++simTrackIt) {
     if (simTrackIt->momentum().pt() > simtrackminpt_) {
       selectedSimTrackMap.insert(std::make_pair(simTrackIt->trackId(), *simTrackIt));
     }
   }
   TrackerHitAssociator associateRecHit(iEvent, trackerHitAssociatorConfig_);
   fillOTHistos(iEvent, associateRecHit, simHits, selectedSimTrackMap);
 }

void Phase2OTValidateTrackingRecHit::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 204 of file Phase2OTValidateTrackingRecHit.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, Phase2OTValidateRecHitBase::fillPSetDescription(), HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                 {
   edm::ParameterSetDescription desc;
   // call the base fillPsetDescription for the plots bookings
   Phase2OTValidateRecHitBase::fillPSetDescription(desc);
 
   //for macro-pixel sensors
   desc.add<edm::InputTag>("SimVertexSource", edm::InputTag("g4SimHits"));
   desc.add<bool>("associatePixel", false);
   desc.add<bool>("associateHitbySimTrack", true);
   desc.add<bool>("Verbosity", false);
   desc.add<bool>("associateStrip", true);
   desc.add<edm::InputTag>("phase2TrackerSimLinkSrc", edm::InputTag("simSiPixelDigis", "Tracker"));
   desc.add<bool>("associateRecoTracks", false);
   desc.add<edm::InputTag>("pixelSimLinkSrc", edm::InputTag("simSiPixelDigis", "Pixel"));
   desc.add<bool>("usePhase2Tracker", true);
   desc.add<edm::InputTag>("rechitsSrc", edm::InputTag("siPhase2RecHits"));
   desc.add<edm::InputTag>("simTracksSrc", edm::InputTag("g4SimHits"));
   desc.add<double>("SimTrackMinPt", 2.0);
   desc.add<std::vector<edm::InputTag>>("PSimHitSource",
                                        {
                                            edm::InputTag("g4SimHits:TrackerHitsTIBLowTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsTIBHighTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsTIDLowTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsTIDHighTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsTOBLowTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsTOBHighTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsTECLowTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsTECHighTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsPixelBarrelLowTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsPixelBarrelHighTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsPixelEndcapLowTof"),
                                            edm::InputTag("g4SimHits:TrackerHitsPixelEndcapHighTof"),
                                        });
 
   desc.add<std::vector<std::string>>("ROUList",
                                      {"TrackerHitsPixelBarrelLowTof",
                                       "TrackerHitsPixelBarrelHighTof",
                                       "TrackerHitsTIBLowTof",
                                       "TrackerHitsTIBHighTof",
                                       "TrackerHitsTIDLowTof",
                                       "TrackerHitsTIDHighTof",
                                       "TrackerHitsTOBLowTof",
                                       "TrackerHitsTOBHighTof",
                                       "TrackerHitsPixelEndcapLowTof",
                                       "TrackerHitsPixelEndcapHighTof",
                                       "TrackerHitsTECLowTof",
                                       "TrackerHitsTECHighTof"});
   desc.add<edm::InputTag>("tracksSrc", edm::InputTag("generalTracks"));
   desc.add<std::string>("TopFolderName", "TrackerPhase2OTTrackingRecHitV");
   descriptions.add("Phase2OTValidateTrackingRecHit", desc);
 }

void Phase2OTValidateTrackingRecHit::fillOTHistos	(	const edm::Event &	iEvent,
		const TrackerHitAssociator &	associateRecHit,
		const std::vector< edm::Handle< edm::PSimHitContainer >> &	simHits,
		const std::map< unsigned int, SimTrack > &	selectedSimTrackMap
	)

private

Definition at line 121 of file Phase2OTValidateTrackingRecHit.cc.

References TrackerHitAssociator::associateHitId(), PVValHelper::dx, PVValHelper::dy, Phase2OTValidateRecHitBase::fillOTRecHitHistos(), TrackerGeometry::getDetectorType(), edm::Event::getHandle(), phase2tkutil::getOTHistoId(), submitPVResolutionJobs::key, Phase2OTValidateRecHitBase::layerMEs_, BaseTrackerRecHit::localPosition(), TrackerGeometry::Ph2PSP, TrackerGeometry::Ph2PSS, TrackerGeometry::Ph2SS, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, trackerHits::simHits, AlCaHLTBitMon_QueryRunRegistry::string, Phase2OTValidateRecHitBase::tkGeom_, tokenTracks_, HLT_FULL_cff::track, tracks, Phase2OTValidateRecHitBase::tTopo_, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by analyze().

                                                                                                              {
   const auto& tracks = iEvent.getHandle(tokenTracks_);
   if (!tracks.isValid())
     return;
   std::map<std::string, unsigned int> nrechitLayerMapP_primary;
   std::map<std::string, unsigned int> nrechitLayerMapS_primary;
   // Loop over tracks
   for (const auto& track : *tracks) {
     for (const auto& hit : track.recHits()) {
       // Get the detector unit's id
       if (!hit->isValid())
         continue;
       auto detId = hit->geographicalId();
       // check that we are in the pixel
       auto subdetid = (detId.subdetId());
       if (subdetid == PixelSubdetector::PixelBarrel || subdetid == PixelSubdetector::PixelEndcap)
         continue;
 
       // determine the detector we are in
       TrackerGeometry::ModuleType mType = tkGeom_->getDetectorType(detId);
       std::string key = phase2tkutil::getOTHistoId(detId.rawId(), tTopo_);
       if (mType == TrackerGeometry::ModuleType::Ph2PSP) {
         if (nrechitLayerMapP_primary.find(key) == nrechitLayerMapP_primary.end()) {
           nrechitLayerMapP_primary.emplace(key, 1);
         } else {
           nrechitLayerMapP_primary[key] += 1;
         }
       } else if (mType == TrackerGeometry::ModuleType::Ph2PSS || mType == TrackerGeometry::ModuleType::Ph2SS) {
         if (nrechitLayerMapS_primary.find(key) == nrechitLayerMapS_primary.end()) {
           nrechitLayerMapS_primary.emplace(key, 1);
         } else {
           nrechitLayerMapS_primary[key] += 1;
         }
       }
       //GetSimHits
       const Phase2TrackerRecHit1D* rechit = dynamic_cast<const Phase2TrackerRecHit1D*>(hit);
       if (!rechit) {
         edm::LogError("Phase2OTValidateTrackingRecHit")
             << "Cannot cast tracking rechit to Phase2TrackerRecHit1D!" << std::endl;
         continue;
       }
       const std::vector<SimHitIdpr>& matchedId = associateRecHit.associateHitId(*rechit);
       const PSimHit* simhitClosest = nullptr;
       LocalPoint lp = rechit->localPosition();
       float mind = 1e4;
       for (const auto& simHitCol : simHits) {
         for (const auto& simhitIt : *simHitCol) {
           if (detId.rawId() != simhitIt.detUnitId())
             continue;
           for (auto& mId : matchedId) {
             if (simhitIt.trackId() == mId.first) {
               float dx = simhitIt.localPosition().x() - lp.x();
               float dy = simhitIt.localPosition().y() - lp.y();
               float dist = dx * dx + dy * dy;
               if (!simhitClosest || dist < mind) {
                 mind = dist;
                 simhitClosest = &simhitIt;
               }
             }
           }
         }  //end loop over PSimhitcontainers
       }    //end loop over simHits
       if (!simhitClosest)
         continue;
       fillOTRecHitHistos(
           simhitClosest, rechit, selectedSimTrackMap, nrechitLayerMapP_primary, nrechitLayerMapS_primary);
 
     }  //end loop over rechits of a track
   }    //End loop over tracks
 
   //fill nRecHits per event
   //fill nRecHit counter per layer
   for (auto& lme : nrechitLayerMapP_primary) {
     layerMEs_[lme.first].numberRecHitsprimary_P->Fill(nrechitLayerMapP_primary[lme.first]);
   }
   for (auto& lme : nrechitLayerMapS_primary) {
     layerMEs_[lme.first].numberRecHitsprimary_S->Fill(nrechitLayerMapS_primary[lme.first]);
   }
 }