#include <Calibration/TkAlCaRecoProducers/plugins/NearbyPixelClustersAnalyzer.cc>

Inheritance diagram for NearbyPixelClustersAnalyzer:

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

	~NearbyPixelClustersAnalyzer () override=default

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources, edm::one::WatchRuns >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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 &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	beginRun (edm::Run const &, edm::EventSetup const &) override

std::map< uint32_t, TH2F * >	bookModuleHistograms (const TrackerTopology *tTopo)

void	countClusters (const edm::Handle< SiPixelClusterCollectionNew > &handle, unsigned int &nClusGlobal)

bool	detidIsOnPixel (const DetId &detid)

void	endJob () override

void	endRun (edm::Run const &, edm::EventSetup const &) override

void	fillClusterFrames (const edm::Handle< SiPixelClusterCollectionNew > &handle)

std::pair< float, float >	findClosestCluster (const edm::Handle< SiPixelClusterCollectionNew > &handle, const PixelClusterParameterEstimator pixelCPE_, const TrackerGeometry trackerGeometry_, uint32_t rawId, float traj_lx, float traj_ly)

TrajectoryStateOnSurface	getTrajectoryStateOnSurface (const TrajectoryMeasurement &measurement)

std::tuple< std::string, int, int, int >	setTopoInfo (uint32_t detId, const TrackerTopology *tTopo)

Private Attributes
edm::EDGetTokenT< SiPixelClusterCollectionNew >	clustersToken_

edm::EDGetTokenT< edm::ValueMap< std::vector< float > > >	distanceToken_

edm::Service< TFileService >	fs

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomEsToken_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomEsTokenBR_

TH1F *	h_distClosestInactive

TH1F *	h_distClosestMissing

TH1F *	h_distClosestTrack

TH1F *	h_distClosestValid

TH1I *	h_nALCARECOClusters

TH1I *	h_nCloseByClusters

std::map< uint32_t, TH2F * >	histoMap_

edm::EDGetTokenT< edm::View< reco::Track > >	muonTracksToken_

edm::EDGetTokenT< SiPixelClusterCollectionNew >	nearByClustersToken_

std::map< std::string, TFileDirectory >	outputFolders_

bool	phase_

const edm::ESGetToken< PixelClusterParameterEstimator, TkPixelCPERecord >	pixelCPEEsToken_

SiPixelDetInfoFileReader	reader_

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	topoEsTokenBR_

edm::EDGetTokenT< TrajTrackAssociationCollection >	trajTrackCollectionToken_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: Analysis of the closebyPixelClusters collections

Definition at line 58 of file NearbyPixelClustersAnalyzer.cc.

Constructor & Destructor Documentation

◆ NearbyPixelClustersAnalyzer()

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

explicit

Definition at line 119 of file NearbyPixelClustersAnalyzer.cc.

References TFileService::kSharedResource.

     : geomEsToken_(esConsumes()),
       pixelCPEEsToken_(esConsumes(edm::ESInputTag("", "PixelCPEGeneric"))),
       geomEsTokenBR_(esConsumes<edm::Transition::BeginRun>()),
       topoEsTokenBR_(esConsumes<edm::Transition::BeginRun>()),
       clustersToken_(consumes<SiPixelClusterCollectionNew>(iConfig.getParameter<edm::InputTag>("clusterCollection"))),
       nearByClustersToken_(
           consumes<SiPixelClusterCollectionNew>(iConfig.getParameter<edm::InputTag>("nearByClusterCollection"))),
       trajTrackCollectionToken_(
           consumes<TrajTrackAssociationCollection>(iConfig.getParameter<edm::InputTag>("trajectoryInput"))),
       distanceToken_(consumes<edm::ValueMap<std::vector<float>>>(iConfig.getParameter<edm::InputTag>("distToTrack"))),
       muonTracksToken_(consumes<edm::View<reco::Track>>(iConfig.getParameter<edm::InputTag>("muonTracks"))),
       reader_(edm::FileInPath(iConfig.getParameter<std::string>("skimmedGeometryPath")).fullPath()) {
   usesResource(TFileService::kSharedResource);
 }

◆ ~NearbyPixelClustersAnalyzer()

NearbyPixelClustersAnalyzer::~NearbyPixelClustersAnalyzer ( )

overridedefault

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 140 of file NearbyPixelClustersAnalyzer.cc.

References clustersToken_, countClusters(), detidIsOnPixel(), HLT_2022v14_cff::distance, distanceToken_, fillClusterFrames(), findClosestCluster(), geomEsToken_, edm::EventSetup::getData(), getTrajectoryStateOnSurface(), h_distClosestInactive, h_distClosestMissing, h_distClosestTrack, h_distClosestValid, h_nALCARECOClusters, h_nCloseByClusters, iEvent, TrackingRecHit::inactive, TrajectoryStateOnSurface::isValid(), edm::Ref< C, T, F >::key(), TrajectoryStateOnSurface::localPosition(), LogDebug, TrackingRecHit::missing, ALCARECOTkAlDQM_cff::muonTracks, muonTracksToken_, nearByClustersToken_, custom_jme_cff::nMuons, pixelCPEEsToken_, DetId::rawId(), rpcPointValidation_cfi::recHit, mathSSE::sqrt(), HLT_2022v14_cff::track, trajTrackCollectionToken_, TrackingRecHit::valid, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

                                                                                              {
   using namespace edm;
 
   // get the Tracker geometry from event setup
   const TrackerGeometry* trackerGeometry_ = &iSetup.getData(geomEsToken_);
 
   // get the Pixel CPE from event setup
   const PixelClusterParameterEstimator* pixelCPE_ = &iSetup.getData(pixelCPEEsToken_);
 
   // get the muon track collection
   const auto& muonTrackCollectionHandle = iEvent.getHandle(muonTracksToken_);
   auto const& muonTracks = *muonTrackCollectionHandle;
 
   // get the track distances
   const auto& distancesToTrack = iEvent.getHandle(distanceToken_);
 
   unsigned int nMuons = muonTracks.size();
   for (unsigned int ij = 0; ij < nMuons; ij++) {
     auto muon = muonTrackCollectionHandle->ptrAt(ij);
     edm::RefToBase<reco::Track> trackRef = muonTrackCollectionHandle->refAt(ij);
     const auto& distances = (*distancesToTrack)[trackRef];
 
     LogDebug("NearbyPixelClustersAnalyzer") << "distances size: " << distances.size() << std::endl;
 
     unsigned counter = 0;
     double closestDR = 999.;
     for (const auto& distance : distances) {
       counter++;
       LogDebug("NearbyPixelClustersAnalyzer")
           << "track: " << counter << " distance:" << std::sqrt(distance) << std::endl;
       if (distance < closestDR && distance > 0) {
         closestDR = distance;
       }
     }
 
     h_distClosestTrack->Fill(std::sqrt(closestDR));
   }
 
   // Get cluster collection
   const auto& clusterCollectionHandle = iEvent.getHandle(clustersToken_);
 
   unsigned int nClusGlobal = 0;
   countClusters(clusterCollectionHandle, nClusGlobal);
 
   h_nALCARECOClusters->Fill(nClusGlobal);
   edm::LogInfo("NearbyPixelClustersAnalyzer") << "total ALCARECO clusters: " << nClusGlobal << std::endl;
 
   // Get nearby cluster collection
   const auto& nearByClusterCollectionHandle = iEvent.getHandle(nearByClustersToken_);
 
   unsigned int nNearByClusGlobal = 0;
   countClusters(nearByClusterCollectionHandle, /*trackerGeometry_,*/ nNearByClusGlobal);
 
   h_nCloseByClusters->Fill(nNearByClusGlobal);
   edm::LogInfo("NearbyPixelClustersAnalyzer") << "total close-by clusters: " << nNearByClusGlobal << std::endl;
 
   // fill the detector frames
   fillClusterFrames(nearByClusterCollectionHandle);
 
   // Get Traj-Track Collection
   const auto& trajTrackCollectionHandle = iEvent.getHandle(trajTrackCollectionToken_);
 
   if (!trajTrackCollectionHandle.isValid())
     return;
 
   for (const auto& pair : *trajTrackCollectionHandle) {
     const edm::Ref<std::vector<Trajectory>> traj = pair.key;
     const reco::TrackRef track = pair.val;
 
     for (const TrajectoryMeasurement& measurement : traj->measurements()) {
       if (!measurement.updatedState().isValid())
         return;
 
       const TransientTrackingRecHit::ConstRecHitPointer& recHit = measurement.recHit();
 
       // Only looking for pixel hits
       DetId r_rawId = recHit->geographicalId();
 
       if (!this->detidIsOnPixel(r_rawId))
         continue;
 
       // Skipping hits with undeterminable positions
       TrajectoryStateOnSurface trajStateOnSurface = this->getTrajectoryStateOnSurface(measurement);
 
       if (!(trajStateOnSurface.isValid()))
         continue;
 
       // Position measurements
       // Looking for valid and missing hits
       LocalPoint localPosition = trajStateOnSurface.localPosition();
 
       const auto& traj_lx = localPosition.x();
       const auto& traj_ly = localPosition.y();
 
       const auto loc = this->findClosestCluster(
           nearByClusterCollectionHandle, pixelCPE_, trackerGeometry_, r_rawId.rawId(), traj_lx, traj_ly);
 
       float dist = (loc.first != -999.) ? std::sqrt(loc.first * loc.first + loc.second * loc.second) : -0.1;
 
       if (recHit->getType() == TrackingRecHit::valid) {
         edm::LogInfo("NearbyPixelClustersAnalyzer")
             << "RawID:" << r_rawId.rawId() << " (valid hit), distance: " << dist << std::endl;
         h_distClosestValid->Fill(dist);
       }
 
       if (recHit->getType() == TrackingRecHit::missing) {
         edm::LogInfo("NearbyPixelClustersAnalyzer")
             << "RawID:" << r_rawId.rawId() << " (missing hit), distance: " << dist << std::endl;
         h_distClosestMissing->Fill(dist);
       }
 
       if (recHit->getType() == TrackingRecHit::inactive) {
         edm::LogInfo("NearbyPixelClustersAnalyzer")
             << "RawID:" << r_rawId.rawId() << " (inactive hit), distance: " << dist << std::endl;
         h_distClosestInactive->Fill(dist);
       }
     }
   }
 }

◆ beginJob()

void NearbyPixelClustersAnalyzer::beginJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 261 of file NearbyPixelClustersAnalyzer.cc.

References fs, h_distClosestInactive, h_distClosestMissing, h_distClosestTrack, h_distClosestValid, h_nALCARECOClusters, h_nCloseByClusters, TFileDirectory::make(), and TFileService::mkdir().

                                            {
   TFileDirectory ClusterCounts = fs->mkdir("ClusterCounts");
   h_nALCARECOClusters = ClusterCounts.make<TH1I>(
       "h_nALCARECOClusters", "Number of Pixel clusters per event (ALCARECO) ;N_{clusters};events", 20, 0, 20);
   h_nCloseByClusters = ClusterCounts.make<TH1I>(
       "h_nCloseByClusters", "Number of Pixel clusters per event (close-by) ;N_{clusters};events", 20, 0, 20);
 
   TFileDirectory Distances = fs->mkdir("TrajDistance");
   h_distClosestValid = Distances.make<TH1F>(
       "h_distClosestValid",
       "Distance of Closest cluster to trajectory (valid);distance (cm); valid trajectory measurements",
       110,
       -0.105,
       0.995);
   h_distClosestMissing = Distances.make<TH1F>(
       "h_distClosestMissing",
       "Distance of Closest cluster to trajectory (missing);distance (cm);missing trajectory measurements",
       110,
       -0.105,
       0.995);
   h_distClosestInactive = Distances.make<TH1F>(
       "h_distClosestInactive",
       "Distance of Closest cluster to trajectory (inactive);distance (cm);inactive trajectory measurements",
       110,
       -0.105,
       0.995);
 
   TFileDirectory TkDistances = fs->mkdir("OtherTrackDistance");
   h_distClosestTrack = TkDistances.make<TH1F>(
       "h_distClosestTrack",
       "#DeltaR Distance of Closest track to the muon trajectory;#DeltaR distance; muon trajectories",
       100,
       0.,
       5.);
 }

◆ beginRun()

void NearbyPixelClustersAnalyzer::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivate

Definition at line 422 of file NearbyPixelClustersAnalyzer.cc.

References bookModuleHistograms(), runTheMatrix::const, TrackerGeometry::detUnits(), Exception, fs, geomEsTokenBR_, SiPixelDetInfoFileReader::getAllDetIds(), edm::EventSetup::getData(), histoMap_, TrackerGeometry::isThere(), LogDebug, TFileService::mkdir(), outputFolders_, GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, phase_, reader_, setTopoInfo(), AlCaHLTBitMon_QueryRunRegistry::string, and topoEsTokenBR_.

 {
   edm::LogInfo("NearbyPixelClustersAnalyzer")
       << "@SUB=NearbyPixelClustersAnalyzer::beginRun() before booking histoMap_.size(): " << histoMap_.size()
       << std::endl;
 
   const TrackerTopology* tTopo_ = &iSetup.getData(topoEsTokenBR_);
   const TrackerGeometry* pDD_ = &iSetup.getData(geomEsTokenBR_);
 
   if ((pDD_->isThere(GeomDetEnumerators::P1PXB)) || (pDD_->isThere(GeomDetEnumerators::P1PXEC))) {
     phase_ = true;
   } else {
     phase_ = false;
   }
 
   unsigned nPixelDets = 0;
   for (const auto& it : pDD_->detUnits()) {
     const PixelGeomDetUnit* mit = dynamic_cast<PixelGeomDetUnit const*>(it);
     if (mit != nullptr) {
       nPixelDets++;
     }
   }
 
   const auto& detIds = reader_.getAllDetIds();
   if (detIds.size() != nPixelDets) {
     throw cms::Exception("Inconsistent Data")
         << "The size of the detId list specified from file (" << detIds.size()
         << ") differs from the one in TrackerGeometry (" << nPixelDets << ")! Please cross-check" << std::endl;
   }
 
   for (const auto& it : detIds) {
     auto topolInfo = setTopoInfo(it, tTopo_);
 
     std::string thePart = std::get<0>(topolInfo);
 
     // book the TFileDirectory if it's not already done
     if (!outputFolders_.count(thePart)) {
       LogDebug("NearbyPixelClustersAnalyzer") << "booking " << thePart << std::endl;
       outputFolders_[thePart] = fs->mkdir(thePart);
     }
   }
 
   if (histoMap_.empty()) {
     histoMap_ = bookModuleHistograms(tTopo_);
   }
 
   edm::LogInfo("NearbyPixelClusterAnalyzer")
       << "@SUB=NearbyPixelClusterAnalyzer::beginRun() After booking histoMap_.size(): " << histoMap_.size()
       << std::endl;
 }

◆ bookModuleHistograms()

std::map< uint32_t, TH2F * > NearbyPixelClustersAnalyzer::bookModuleHistograms ( const TrackerTopology * tTopo )

private

Definition at line 504 of file NearbyPixelClustersAnalyzer.cc.

References SiPixelDetInfoFileReader::getAllDetIds(), SiPixelDetInfoFileReader::getDetUnitDimensions(), EcalCalibMonitorClient_cfi::moduleName, PixelBarrelName::name(), PixelEndcapName::name(), outputFolders_, phase_, PixelSubdetector::PixelBarrel, reader_, setTopoInfo(), AlCaHLTBitMon_QueryRunRegistry::string, and DetId::subdetId().

Referenced by beginRun().

 {
   std::map<uint32_t, TH2F*> hd;
 
   const auto& detIds = reader_.getAllDetIds();
   for (const auto& it : detIds) {
     // check if det id is correct and if it is actually cabled in the detector
     if (it == 0 || it == 0xFFFFFFFF) {
       edm::LogError("DetIdNotGood") << "@SUB=analyze"
                                     << "Wrong det id: " << it << "  ... neglecting!" << std::endl;
       continue;
     }
 
     auto topolInfo = setTopoInfo(it, tTopo_);
     std::string thePart = std::get<0>(topolInfo);
 
     unsigned int nCols = reader_.getDetUnitDimensions(it).first;
     unsigned int nRows = reader_.getDetUnitDimensions(it).second;
 
     int subdetId = DetId(it).subdetId();
 
     std::string moduleName = (subdetId == PixelSubdetector::PixelBarrel) ? PixelBarrelName(it, tTopo_, phase_).name()
                                                                          : PixelEndcapName(it, tTopo_, phase_).name();
 
     hd[it] = outputFolders_[thePart].make<TH2F>(
         Form("ClusterFrame_%s", moduleName.c_str()),
         Form("Cluster Map for module %s;n. cols;n. rows;pixel charge [ADC counts]", moduleName.c_str()),
         nCols,
         0,
         nCols,
         nRows,
         0,
         nRows);
   }
 
   return hd;
 }

◆ countClusters()

void NearbyPixelClustersAnalyzer::countClusters	(	const edm::Handle< SiPixelClusterCollectionNew > &	handle,
		unsigned int &	nClusGlobal
	)

private

Definition at line 341 of file NearbyPixelClustersAnalyzer.cc.

References patZpeak::handle, and LogDebug.

Referenced by analyze().

 {
   for (const auto& DSVItr : *handle) {
     uint32_t rawid(DSVItr.detId());
     DetId detId(rawid);
     LogDebug("NearbyPixelClustersAnalyzer") << "DetId: " << detId.rawId() << " size: " << DSVItr.size() << std::endl;
     nClusGlobal += DSVItr.size();
   }
 }

◆ detidIsOnPixel()

bool NearbyPixelClustersAnalyzer::detidIsOnPixel ( const DetId & detid )

private

Definition at line 303 of file NearbyPixelClustersAnalyzer.cc.

References DetId::det(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, DetId::subdetId(), and DetId::Tracker.

Referenced by analyze().

 {
   if (detid.det() != DetId::Tracker)
     return false;
   if (detid.subdetId() == PixelSubdetector::PixelBarrel)
     return true;
   if (detid.subdetId() == PixelSubdetector::PixelEndcap)
     return true;
   return false;
 }

◆ endJob()

void NearbyPixelClustersAnalyzer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 298 of file NearbyPixelClustersAnalyzer.cc.

Referenced by o2olib.O2ORunMgr::executeJob().

                                          {
   // please remove this method if not needed
 }

◆ endRun()

void NearbyPixelClustersAnalyzer::endRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

inlineoverrideprivate

Definition at line 69 of file NearbyPixelClustersAnalyzer.cc.

69 {};

◆ fillClusterFrames()

void NearbyPixelClustersAnalyzer::fillClusterFrames ( const edm::Handle< SiPixelClusterCollectionNew > & handle )

private

Definition at line 401 of file NearbyPixelClustersAnalyzer.cc.

References ALCARECOSiPixelCalSingleMuonDQM_cff::clusterCollection, patZpeak::handle, histoMap_, and mps_fire::i.

Referenced by analyze().

                                                                                                         {
   const SiPixelClusterCollectionNew& clusterCollection = *handle;
   SiPixelClusterCollectionNew::const_iterator itClusterSet = clusterCollection.begin();
 
   for (; itClusterSet != clusterCollection.end(); itClusterSet++) {
     DetId detId(itClusterSet->id());
 
     edmNew::DetSet<SiPixelCluster>::const_iterator itCluster = itClusterSet->begin();
     for (; itCluster != itClusterSet->end(); ++itCluster) {
       const std::vector<SiPixelCluster::Pixel> pixelsVec = (*itCluster).pixels();
       for (unsigned int i = 0; i < pixelsVec.size(); ++i) {
         float pixx = pixelsVec[i].x;  // index as float=iteger, row index
         float pixy = pixelsVec[i].y;  // same, col index
         float pixel_charge = pixelsVec[i].adc;
         histoMap_[detId.rawId()]->Fill(pixy, pixx, pixel_charge);
       }
     }
   }
 }

◆ fillDescriptions()

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

static

Definition at line 544 of file NearbyPixelClustersAnalyzer.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, HLT_2022v14_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                              {
   edm::ParameterSetDescription desc;
   desc.setComment("Analysis of the closebyPixelClusters collections");
   desc.add<edm::InputTag>("clusterCollection", edm::InputTag("ALCARECOSiPixelCalSingleMuonTight"));
   desc.add<edm::InputTag>("nearByClusterCollection", edm::InputTag("closebyPixelClusters"));
   desc.add<edm::InputTag>("trajectoryInput", edm::InputTag("refittedTracks"));
   desc.add<edm::InputTag>("muonTracks", edm::InputTag("ALCARECOSiPixelCalSingleMuonTight"));
   desc.add<edm::InputTag>("distToTrack", edm::InputTag("trackDistances"));
   desc.add<std::string>("skimmedGeometryPath",
                         "SLHCUpgradeSimulations/Geometry/data/PhaseI/PixelSkimmedGeometry_phase1.txt");
   descriptions.addWithDefaultLabel(desc);
 }

◆ findClosestCluster()

std::pair< float, float > NearbyPixelClustersAnalyzer::findClosestCluster	(	const edm::Handle< SiPixelClusterCollectionNew > &	handle,
		const PixelClusterParameterEstimator *	pixelCPE_,
		const TrackerGeometry *	trackerGeometry_,
		uint32_t	rawId,
		float	traj_lx,
		float	traj_ly
	)

private

Definition at line 355 of file NearbyPixelClustersAnalyzer.cc.

References ALCARECOSiPixelCalSingleMuonDQM_cff::clusterCollection, edmNew::DetSet< T >::end(), PixelClusterParameterEstimator::getParameters(), patZpeak::handle, TrackerGeometry::idToDetUnit(), submitPVValidationJobs::params, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, mathSSE::sqrt(), GeomDetEnumerators::subDetId, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by analyze().

 {
   const SiPixelClusterCollectionNew& clusterCollection = *handle;
   SiPixelClusterCollectionNew::const_iterator itClusterSet = clusterCollection.begin();
 
   float minD = 10000.;
 
   auto loc = std::make_pair(-999., -999.);
 
   for (; itClusterSet != clusterCollection.end(); itClusterSet++) {
     DetId detId(itClusterSet->id());
     if (detId.rawId() != rawId)
       continue;
 
     unsigned int subDetId = detId.subdetId();
     if (subDetId != PixelSubdetector::PixelBarrel && subDetId != PixelSubdetector::PixelEndcap) {
       edm::LogError("NearByPixelClustersAnalyzer")
           << "ERROR: not a pixel cluster!!!" << std::endl;  // should not happen
       continue;
     }
 
     const PixelGeomDetUnit* pixdet = (const PixelGeomDetUnit*)trackerGeometry_->idToDetUnit(detId);
     edmNew::DetSet<SiPixelCluster>::const_iterator itCluster = itClusterSet->begin();
     for (; itCluster != itClusterSet->end(); ++itCluster) {
       LocalPoint lp(itCluster->x(), itCluster->y(), 0.);
       PixelClusterParameterEstimator::ReturnType params = pixelCPE_->getParameters(*itCluster, *pixdet);
       lp = std::get<0>(params);
 
       float D = sqrt((lp.x() - traj_lx) * (lp.x() - traj_lx) + (lp.y() - traj_ly) * (lp.y() - traj_ly));
       if (D < minD) {
         minD = D;
         loc.first = (lp.x() - traj_lx);
         loc.second = (lp.y() - traj_ly);
       }
     }  // loop on cluster sets
   }
   return loc;
 }

◆ getTrajectoryStateOnSurface()

TrajectoryStateOnSurface NearbyPixelClustersAnalyzer::getTrajectoryStateOnSurface ( const TrajectoryMeasurement & measurement )

private

Definition at line 316 of file NearbyPixelClustersAnalyzer.cc.

References TrajectoryMeasurement::backwardPredictedState(), and TrajectoryMeasurement::forwardPredictedState().

Referenced by analyze().

 {
   const static TrajectoryStateCombiner trajStateCombiner;
 
   const auto& forwardPredictedState = measurement.forwardPredictedState();
   const auto& backwardPredictedState = measurement.backwardPredictedState();
 
   if (forwardPredictedState.isValid() && backwardPredictedState.isValid())
     return trajStateCombiner(forwardPredictedState, backwardPredictedState);
 
   else if (backwardPredictedState.isValid())
     return backwardPredictedState;
 
   else if (forwardPredictedState.isValid())
     return forwardPredictedState;
 
   edm::LogError("NearbyPixelClusterProducer") << "Error saving traj. measurement data."
                                               << " Trajectory state on surface cannot be determined." << std::endl;
 
   return TrajectoryStateOnSurface();
 }

◆ setTopoInfo()

std::tuple< std::string, int, int, int > NearbyPixelClustersAnalyzer::setTopoInfo	(	uint32_t	detId,
		const TrackerTopology *	tTopo
	)

private

Definition at line 475 of file NearbyPixelClustersAnalyzer.cc.

References sistrip::layer_, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, TrackerTopology::pxbLayer(), TrackerTopology::pxfDisk(), TrackerTopology::pxfSide(), runTheMatrix::ret, AlCaHLTBitMon_QueryRunRegistry::string, and DetId::subdetId().

Referenced by beginRun(), and bookModuleHistograms().

 {
   int subdetId_(-999), layer_(-999), side_(-999);
   std::string ret = "";
 
   subdetId_ = DetId(detId).subdetId();
   switch (subdetId_) {
     case PixelSubdetector::PixelBarrel:  // PXB
       layer_ = tTopo->pxbLayer(detId);
       side_ = 0;
       ret += Form("BPix_Layer%i", layer_);
       break;
     case PixelSubdetector::PixelEndcap:  //PXF
       side_ = tTopo->pxfSide(detId);
       layer_ = tTopo->pxfDisk(detId);
       ret += ("FPix_");
       ret += (side_ == 1) ? Form("P_disk%i", layer_) : Form("M_disk%i", layer_);
       break;
     default:
       edm::LogError("NearbyPixelClusterAnalyzer") << "we should never be here!" << std::endl;
       break;
   }
 
   return std::make_tuple(ret, subdetId_, layer_, side_);
 }