Inheritance diagram for ShortenedTrackValidation:

Classes
class	trackComparator

class	trackingMon

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

	~ShortenedTrackValidation () override=default

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
	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

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 (edm::Event const &iEvent, edm::EventSetup const &iSetup) override

void	beginJob () override

template<typename T , typename... Args>
T *	book (const TFileDirectory &dir, const Args &...args) const

Private Attributes
const edm::InputTag	BeamSpotTag_

const edm::EDGetTokenT< reco::BeamSpot >	beamspotToken_

std::vector< trackComparator * >	comparators_

const std::string	folderName_

edm::Service< TFileService >	fs_

std::vector< TH1F * >	histsDeltaPtOverPtAll_

std::vector< TH1F * >	histsDeltaRAll_

std::vector< TH1F * >	histsEtaDiffAll_

std::vector< TH1F * >	histsNhitsAll_

std::vector< TH1F * >	histsPhiDiffAll_

std::vector< TH1F * >	histsPtAll_

std::vector< TH1F * >	histsPtDiffAll_

std::vector< TH1F * >	histsPtRatioAll_

std::vector< TH2F * >	histsPtRatioVsDeltaRAll_

const std::vector< std::string >	hitsRemain_

const double	maxDr_

const double	maxTracksEta_

const double	maxTracksPt_

const double	minTracksEta_

const double	minTracksPt_

trackingMon	originalTrack

const std::vector< edm::InputTag >	tracksRerecoTag_

const std::vector< edm::EDGetTokenT< std::vector< reco::Track > > >	tracksRerecoToken_

const edm::InputTag	tracksTag_

const edm::EDGetTokenT< std::vector< reco::Track > >	tracksToken_

const edm::EDGetTokenT< reco::VertexCollection >	vertexToken_

const edm::InputTag	VerticesTag_

Static Private Attributes
static constexpr double	muMass = 0.105658

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

Definition at line 57 of file ShortenedTrackValidation.cc.

Constructor & Destructor Documentation

◆ ShortenedTrackValidation()

ShortenedTrackValidation::ShortenedTrackValidation ( const edm::ParameterSet & ps )

explicit

Definition at line 362 of file ShortenedTrackValidation.cc.

References makeGlobalPositionRcd_cfg::tag.

     : folderName_(ps.getUntrackedParameter<std::string>("folderName", "TrackRefitting")),
       hitsRemain_(ps.getUntrackedParameter<std::vector<std::string>>("hitsRemainInput")),
       minTracksEta_(ps.getUntrackedParameter<double>("minTracksEtaInput", 0.0)),
       maxTracksEta_(ps.getUntrackedParameter<double>("maxTracksEtaInput", 2.2)),
       minTracksPt_(ps.getUntrackedParameter<double>("minTracksPtInput", 15.0)),
       maxTracksPt_(ps.getUntrackedParameter<double>("maxTracksPtInput", 99999.9)),
       maxDr_(ps.getUntrackedParameter<double>("maxDrInput", 0.01)),
       tracksTag_(ps.getUntrackedParameter<edm::InputTag>("tracksInputTag", edm::InputTag("generalTracks", "", "DQM"))),
       tracksRerecoTag_(ps.getUntrackedParameter<std::vector<edm::InputTag>>("tracksRerecoInputTag")),
       BeamSpotTag_(ps.getUntrackedParameter<edm::InputTag>("BeamSpotTag", edm::InputTag("offlineBeamSpot"))),
       VerticesTag_(ps.getUntrackedParameter<edm::InputTag>("VerticesTag", edm::InputTag("offlinePrimaryVertices"))),
       tracksToken_(consumes<std::vector<reco::Track>>(tracksTag_)),
       tracksRerecoToken_(edm::vector_transform(
           tracksRerecoTag_, [this](edm::InputTag const &tag) { return consumes<std::vector<reco::Track>>(tag); })),
       beamspotToken_(consumes<reco::BeamSpot>(BeamSpotTag_)),
       vertexToken_(consumes<reco::VertexCollection>(VerticesTag_)) {
   usesResource(TFileService::kSharedResource);
   histsPtRatioAll_.clear();
   histsPtDiffAll_.clear();
   histsEtaDiffAll_.clear();
   histsPhiDiffAll_.clear();
   histsPtRatioVsDeltaRAll_.clear();
   histsDeltaPtOverPtAll_.clear();
   histsPtAll_.clear();
   histsNhitsAll_.clear();
   histsDeltaRAll_.clear();
   comparators_.clear();
 
   comparators_.reserve(hitsRemain_.size());
   for (unsigned int i = 0; i < hitsRemain_.size(); ++i) {
     comparators_.push_back(new trackComparator());
   }
 }

◆ ~ShortenedTrackValidation()

ShortenedTrackValidation::~ShortenedTrackValidation ( )

overridedefault

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 511 of file ShortenedTrackValidation.cc.

References funct::abs(), pwdgSkimBPark_cfi::beamSpot, align::BeamSpot, beamspotToken_, comparators_, PbPb_ZMuSkimMuonDPG_cff::deltaR, edm::InputTag::encode(), ShortenedTrackValidation::trackingMon::fill(), histsDeltaPtOverPtAll_, histsDeltaRAll_, histsEtaDiffAll_, histsNhitsAll_, histsPhiDiffAll_, histsPtAll_, histsPtDiffAll_, histsPtRatioAll_, histsPtRatioVsDeltaRAll_, trackingPlots::hp, mps_fire::i, iEvent, edm::HandleBase::isValid(), maxDr_, maxTracksEta_, maxTracksPt_, minTracksEta_, minTracksPt_, muMass, originalTrack, unpackBuffers-CaloStage2::token, HLT_2024v14_cff::track, reco::HitPattern::TRACK_HITS, DiMuonV_cfg::tracks, tracksRerecoToken_, tracksTag_, tracksToken_, HltBtagValidation_cff::Vertex, and vertexToken_.

                                                                                           {
   const auto &tracks = iEvent.getHandle(tracksToken_);
 
   if (!tracks.isValid()) {
     edm::LogError("ShortenedTrackValidation") << "Missing input track collection " << tracksTag_.encode() << std::endl;
     return;
   }
 
   reco::BeamSpot beamSpot;
   edm::Handle<reco::BeamSpot> beamSpotHandle = iEvent.getHandle(beamspotToken_);
   if (beamSpotHandle.isValid()) {
     beamSpot = *beamSpotHandle;
   } else {
     beamSpot = reco::BeamSpot();
   }
 
   reco::Vertex pvtx;
   edm::Handle<reco::VertexCollection> vertexHandle = iEvent.getHandle(vertexToken_);
   if (vertexHandle.isValid()) {
     pvtx = (*vertexHandle).at(0);
   } else {
     pvtx = reco::Vertex();
   }
 
   // the original long track
   for (const auto &track : *tracks) {
     const reco::HitPattern &hp = track.hitPattern();
     if (int(int(hp.numberOfValidHits()) - int(hp.numberOfAllHits(reco::HitPattern::TRACK_HITS))) != 0) {
       break;
     }
 
     // fill the original track properties monitoring
     originalTrack.fill(track, beamSpot, pvtx);
 
     TLorentzVector tvec;
     tvec.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), muMass);
 
     int i = 0;  // token index
     // loop on the re-recoed shortened track collections
     for (const auto &token : tracksRerecoToken_) {
       const auto &tracks_rereco = iEvent.getHandle(token);
 
       for (const auto &track_rereco : *tracks_rereco) {
         TLorentzVector trerecovec;
         trerecovec.SetPtEtaPhiM(track_rereco.pt(), track_rereco.eta(), track_rereco.phi(), 0.0);
         double deltaR = tvec.DeltaR(trerecovec);
 
         if (deltaR < maxDr_) {
           if (track_rereco.pt() >= minTracksPt_ && track_rereco.pt() <= maxTracksPt_ &&
               std::abs(track_rereco.eta()) >= minTracksEta_ && std::abs(track_rereco.eta()) <= maxTracksEta_) {
             // fill the 2D comparisons per track
             comparators_[i]->fill(track, track_rereco);
 
             histsPtRatioAll_[i]->Fill(1.0 * track_rereco.pt() / track.pt());
             histsPtDiffAll_[i]->Fill(track_rereco.pt() - track.pt());
             histsDeltaPtOverPtAll_[i]->Fill((track_rereco.pt() - track.pt()) / track.pt());
             histsEtaDiffAll_[i]->Fill(track_rereco.eta() - track.eta());
             histsPhiDiffAll_[i]->Fill(track_rereco.phi() - track.phi());
             histsPtRatioVsDeltaRAll_[i]->Fill(deltaR, track_rereco.pt() / track.pt());
             histsPtAll_[i]->Fill(track_rereco.pt());
             histsNhitsAll_[i]->Fill(track_rereco.numberOfValidHits());
             histsDeltaRAll_[i]->Fill(deltaR);
           }
         }
       }
       ++i;
     }
   }
 }

◆ beginJob()

void ShortenedTrackValidation::beginJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 405 of file ShortenedTrackValidation.cc.

References ShortenedTrackValidation::trackingMon::book(), comparators_, folderName_, fs_, histsDeltaPtOverPtAll_, histsDeltaRAll_, histsEtaDiffAll_, histsNhitsAll_, histsPhiDiffAll_, histsPtAll_, histsPtDiffAll_, histsPtRatioAll_, histsPtRatioVsDeltaRAll_, hitsRemain_, mps_fire::i, TFileService::mkdir(), definitions::original, originalTrack, and AlCaHLTBitMon_QueryRunRegistry::string.

                                         {
   std::string currentFolder = folderName_ + "/Resolutions";
   TFileDirectory ShortTrackResolution = fs_->mkdir(currentFolder);
   currentFolder = folderName_ + "/Tracks";
   TFileDirectory TrackQuals = fs_->mkdir(currentFolder);
 
   for (unsigned int i = 0; i < hitsRemain_.size(); ++i) {
     histsPtRatioAll_.push_back(
         book<TH1F>(ShortTrackResolution,
                    fmt::sprintf("trackPtRatio_%s", hitsRemain_[i]).c_str(),
                    fmt::sprintf("Short Track p_{T} / Full Track p_{T} - %s layers;p_{T}^{short}/p_{T}^{full};n. tracks",
                                 hitsRemain_[i])
                        .c_str(),
                    100,
                    0.5,
                    1.5));
 
     histsPtDiffAll_.push_back(book<TH1F>(
         ShortTrackResolution,
         fmt::sprintf("trackPtDiff_%s", hitsRemain_[i]).c_str(),
         fmt::sprintf("Short Track p_{T} - Full Track p_{T} - %s layers;p_{T}^{short} - p_{T}^{full} [GeV];n. tracks",
                      hitsRemain_[i])
             .c_str(),
         100,
         -10.,
         10.));
 
     histsEtaDiffAll_.push_back(
         book<TH1F>(ShortTrackResolution,
                    fmt::sprintf("trackEtaDiff_%s", hitsRemain_[i]).c_str(),
                    fmt::sprintf("Short Track #eta - Full Track #eta - %s layers;#eta^{short} - #eta^{full};n. tracks",
                                 hitsRemain_[i])
                        .c_str(),
                    100,
                    -0.001,
                    0.001));
 
     histsPhiDiffAll_.push_back(
         book<TH1F>(ShortTrackResolution,
                    fmt::sprintf("trackPhiDiff_%s", hitsRemain_[i]).c_str(),
                    fmt::sprintf("Short Track #phi - Full Track #phi - %s layers;#phi^{short} - #phi^{full};n. tracks",
                                 hitsRemain_[i])
                        .c_str(),
                    100,
                    -0.001,
                    0.001));
 
     histsPtRatioVsDeltaRAll_.push_back(
         book<TH2F>(ShortTrackResolution,
                    fmt::sprintf("trackPtRatioVsDeltaR_%s", hitsRemain_[i]).c_str(),
                    fmt::sprintf("Short Track p_{T} / Full Track p_{T} - %s layers vs "
                                 "#DeltaR;#DeltaR(short,full);p_{T}^{short}/p_{T}^{full} [GeV];n. tracks",
                                 hitsRemain_[i])
                        .c_str(),
                    100,
                    0.,
                    0.01,
                    101,
                    -0.05,
                    2.05));
 
     histsDeltaPtOverPtAll_.push_back(
         book<TH1F>(ShortTrackResolution,
                    fmt::sprintf("trackDeltaPtOverPt_%s", hitsRemain_[i]).c_str(),
                    fmt::sprintf("Short Track p_{T} - Full Track p_{T} / Full Track p_{T} - %s layers;p_{T}^{short} - "
                                 "p_{T}^{full} / p^{full}_{T};n. tracks",
                                 hitsRemain_[i])
                        .c_str(),
                    101,
                    -5.,
                    5.));
 
     histsPtAll_.push_back(
         book<TH1F>(TrackQuals,
                    fmt::sprintf("trackPt_%s", hitsRemain_[i]).c_str(),
                    fmt::sprintf("Short Track p_{T} - %s layers;p_{T}^{short} [GeV];n. tracks", hitsRemain_[i]).c_str(),
                    100,
                    0.,
                    100.));
 
     histsNhitsAll_.push_back(
         book<TH1F>(TrackQuals,
                    fmt::sprintf("trackNhits_%s", hitsRemain_[i]).c_str(),
                    fmt::sprintf("Short Track n. hits - %s layers; n. hits per track;n. tracks", hitsRemain_[i]).c_str(),
                    20,
                    -0.5,
                    19.5));
 
     histsDeltaRAll_.push_back(book<TH1F>(
         TrackQuals,
         fmt::sprintf("trackDeltaR_%s", hitsRemain_[i]).c_str(),
         fmt::sprintf("Short Track / Long Track #DeltaR %s layers;#DeltaR(short,long);n. tracks", hitsRemain_[i]).c_str(),
         100,
         0.,
         0.005));
 
     currentFolder = fmt::sprintf("%s/Compare_%sHit", folderName_, hitsRemain_[i]);
     comparators_[i]->book(fs_->mkdir(currentFolder));
   }
 
   currentFolder = folderName_ + "/OriginalTrack";
   TFileDirectory original = fs_->mkdir(currentFolder);
   originalTrack.book(original);
 }

◆ book()

template<typename T , typename... Args>

T * ShortenedTrackValidation::book	(	const TFileDirectory &	dir,
		const Args &...	args
	)		const

private

Definition at line 399 of file ShortenedTrackValidation.cc.

References writedatasetfile::args, DeadROC_duringRun::dir, and submitPVValidationJobs::t.

                                                                                       {
   T *t = dir.make<T>(args...);
   return t;
 }

◆ fillDescriptions()

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

static

Definition at line 582 of file ShortenedTrackValidation.cc.

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

                                                                                           {
   edm::ParameterSetDescription desc;
   desc.addUntracked<std::string>("folderName", "TrackRefitting");
   desc.addUntracked<std::vector<std::string>>("hitsRemainInput", {});
   desc.addUntracked<double>("minTracksEtaInput", 0.0);
   desc.addUntracked<double>("maxTracksEtaInput", 2.2);
   desc.addUntracked<double>("minTracksPtInput", 15.0);
   desc.addUntracked<double>("maxTracksPtInput", 99999.9);
   desc.addUntracked<double>("maxDrInput", 0.01);
   desc.addUntracked<edm::InputTag>("tracksInputTag", edm::InputTag("generalTracks", "", "DQM"));
   desc.addUntracked<std::vector<edm::InputTag>>("tracksRerecoInputTag", {});
   desc.addUntracked<edm::InputTag>("BeamSpotTag", edm::InputTag("offlineBeamSpot"));
   desc.addUntracked<edm::InputTag>("VerticesTag", edm::InputTag("offlinePrimaryVertices"));
   descriptions.addWithDefaultLabel(desc);
 }