#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 noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept 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 noexcept

bool	wantsStreamRuns () const noexcept

	~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

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

std::vector< ESResolverIndex > 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

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices 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 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_2024v14_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(), isotrackTrainRegressor::loc, TrajectoryStateOnSurface::localPosition(), LogDebug, TrackingRecHit::missing, DiMuonV_cfg::muonTracks, muonTracksToken_, nearByClustersToken_, custom_jme_cff::nMuons, pixelCPEEsToken_, DetId::rawId(), rpcPointValidation_cfi::recHit, mathSSE::sqrt(), HLT_2024v14_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(), Options::const, TrackerGeometry::detUnits(), Exception, fs, geomEsTokenBR_, SiPixelDetInfoFileReader::getAllDetIds(), edm::EventSetup::getData(), histoMap_, TrackerGeometry::isThere(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, 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(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, 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 hcalRecHitTable_cff::detId, 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 ALCARECOPPSCalTrackBasedSel_cff::detid, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, 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, hcalRecHitTable_cff::detId, 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, ProducerED_cfi::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, hcalRecHitTable_cff::detId, edmNew::DetSet< T >::end(), PixelClusterParameterEstimator::getParameters(), patZpeak::handle, TrackerGeometry::idToDetUnit(), isotrackTrainRegressor::loc, submitPVValidationJobs::params, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, nano_mu_digi_cff::rawId, 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 hcalRecHitTable_cff::detId, 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_);
 }