Inheritance diagram for QualityCutsAnalyzer:

Classes
struct	histogram_element_t

class	histogram_t

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

	~QualityCutsAnalyzer () override=default

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

Private Types
typedef std::vector < std::vector < histogram_element_t > >	histogram_data_t

typedef std::vector< int >	vint

typedef std::vector< std::string >	vstring

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

void	beginJob () override

void	endJob () override

void	LoopOverJetTracksAssociation (const edm::ESHandle< TransientTrackBuilder > &, const edm::Handle< reco::VertexCollection > &, const edm::Handle< reco::JetTracksAssociationCollection > &)

Private Attributes
TrackClassifier	classifier_

histogram_data_t	histogram_data_

const edm::EDGetTokenT < reco::JetTracksAssociationCollection >	jtaToken_

double	maximumChiSquared_

int	minimumNumberOfHits_

int	minimumNumberOfPixelHits_

double	minimumTransverseMomentum_

std::string	rootFile_

reco::TrackBase::TrackQuality	trackQuality_

const edm::EDGetTokenT < edm::View< reco::Track > >	trkToken_

const edm::ESGetToken < TransientTrackBuilder, TransientTrackRecord >	ttrkToken_

bool	useAllQualities_

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

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

Definition at line 36 of file QualityCutsAnalyzer.cc.

Member Typedef Documentation

typedef std::vector<std::vector<histogram_element_t> > QualityCutsAnalyzer::histogram_data_t

private

Definition at line 106 of file QualityCutsAnalyzer.cc.

typedef std::vector<int> QualityCutsAnalyzer::vint

private

Definition at line 52 of file QualityCutsAnalyzer.cc.

typedef std::vector<std::string> QualityCutsAnalyzer::vstring

private

Definition at line 53 of file QualityCutsAnalyzer.cc.

Constructor & Destructor Documentation

QualityCutsAnalyzer::QualityCutsAnalyzer ( const edm::ParameterSet & config )

explicit

Definition at line 204 of file QualityCutsAnalyzer.cc.

References gather_cfg::cout, edm::ParameterSet::getUntrackedParameter(), maximumChiSquared_, minimumNumberOfHits_, minimumNumberOfPixelHits_, minimumTransverseMomentum_, reco::TrackBase::qualityByName(), rootFile_, AlCaHLTBitMon_QueryRunRegistry::string, trackQuality_, HcalDetIdTransform::transform(), and useAllQualities_.

     : ttrkToken_(esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))),
       trkToken_(consumes<edm::View<reco::Track>>(config.getUntrackedParameter<edm::InputTag>("trackProducer"))),
       vtxToken_(consumes<reco::VertexCollection>(config.getUntrackedParameter<edm::InputTag>("primaryVertexProducer"))),
       jtaToken_(consumes<reco::JetTracksAssociationCollection>(
           config.getUntrackedParameter<edm::InputTag>("jetTracksAssociation"))),
       classifier_(config, consumesCollector()) {
   rootFile_ = config.getUntrackedParameter<std::string>("rootFile");
 
   minimumNumberOfHits_ = config.getUntrackedParameter<int>("minimumNumberOfHits");
   minimumNumberOfPixelHits_ = config.getUntrackedParameter<int>("minimumNumberOfPixelHits");
   minimumTransverseMomentum_ = config.getUntrackedParameter<double>("minimumTransverseMomentum");
   maximumChiSquared_ = config.getUntrackedParameter<double>("maximumChiSquared");
 
   std::string trackQualityType = config.getUntrackedParameter<std::string>("trackQualityClass");  // used
   trackQuality_ = reco::TrackBase::qualityByName(trackQualityType);
   useAllQualities_ = false;
 
   std::transform(
       trackQualityType.begin(), trackQualityType.end(), trackQualityType.begin(), (int (*)(int))std::tolower);
   if (trackQualityType == "any") {
     std::cout << "Using any" << std::endl;
     useAllQualities_ = true;
   }
 }

QualityCutsAnalyzer::~QualityCutsAnalyzer ( )

overridedefault

Member Function Documentation

void QualityCutsAnalyzer::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 235 of file QualityCutsAnalyzer.cc.

References classifier_, edm::EventSetup::getHandle(), HLT_FULL_cff::jetTracks, jtaToken_, LoopOverJetTracksAssociation(), TrackClassifier::newEvent(), HLT_FULL_cff::trackCollection, trkToken_, ttrkToken_, and vtxToken_.

                                                                                    {
   // Track collection
   edm::Handle<edm::View<reco::Track>> trackCollection;
   event.getByToken(trkToken_, trackCollection);
   // Primary vertex
   edm::Handle<reco::VertexCollection> primaryVertexCollection;
   event.getByToken(vtxToken_, primaryVertexCollection);
   // Jet to tracks associator
   edm::Handle<reco::JetTracksAssociationCollection> jetTracks;
   event.getByToken(jtaToken_, jetTracks);
   // Trasient track builder
   const edm::ESHandle<TransientTrackBuilder> TTbuilder = setup.getHandle(ttrkToken_);
 
   // Setting up event information for the track categories.
   classifier_.newEvent(event, setup);
 
   LoopOverJetTracksAssociation(TTbuilder, primaryVertexCollection, jetTracks);
 }

void QualityCutsAnalyzer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 256 of file QualityCutsAnalyzer.cc.

References histogram_data_.

256 { histogram_data_.resize(6); }

QualityCutsAnalyzer::histogram_data_

histogram_data_t histogram_data_

Definition: QualityCutsAnalyzer.cc:107

void QualityCutsAnalyzer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 260 of file QualityCutsAnalyzer.cc.

References mergeVDriftHistosByStation::file, QualityCutsAnalyzer::histogram_t::Fill(), histogram_data_, mps_fire::i, dqmiolumiharvest::j, rootFile_, AlCaHLTBitMon_QueryRunRegistry::string, and QualityCutsAnalyzer::histogram_t::Write().

                                  {
   TFile file(rootFile_.c_str(), "RECREATE");
   file.cd();
 
   // saving the histograms
   for (std::size_t i = 0; i < 6; i++) {
     std::string particle;
     if (i == 0)
       particle = std::string("B_tracks");
     else if (i == 1)
       particle = std::string("C_tracks");
     else if (i == 2)
       particle = std::string("nonB_tracks");
     else if (i == 3)
       particle = std::string("displaced_tracks");
     else if (i == 4)
       particle = std::string("bad_tracks");
     else
       particle = std::string("fake_tracks");
 
     histogram_t histogram(particle);
 
     for (std::size_t j = 0; j < histogram_data_[i].size(); j++)
       histogram.Fill(histogram_data_[i][j]);
 
     histogram.Write();
   }
 
   file.Flush();
 }

void QualityCutsAnalyzer::LoopOverJetTracksAssociation	(	const edm::ESHandle< TransientTrackBuilder > &	TTbuilder,
		const edm::Handle< reco::VertexCollection > &	primaryVertexProducer_,
		const edm::Handle< reco::JetTracksAssociationCollection > &	jetTracksAssociation
	)

private

Definition at line 291 of file QualityCutsAnalyzer.cc.

References TrackCategories::Bad, TransientTrackBuilder::build(), TrackCategories::BWeakDecay, HLT_FULL_cff::chi2, classifier_, TrackCategories::CWeakDecay, d0, PVValHelper::dz, alignCSCRings::e, TrackClassifier::evaluate(), TrackCategories::Fake, histogram_data_, mps_fire::i, TrackCategories::is(), IPTools::jetTrackDistance(), HLT_FULL_cff::jetTracks, maximumChiSquared_, minimumNumberOfHits_, minimumNumberOfPixelHits_, minimumTransverseMomentum_, AlCaHLTBitMon_ParallelJobs::p, TrackCategories::PrimaryVertex, edm::Handle< T >::product(), edm::ESHandle< class >::product(), DiDispStaMuonMonitor_cfi::pt, push_back(), MetAnalyzer::pv(), quality, IPTools::signedDecayLength3D(), IPTools::signedImpactParameter3D(), IPTools::signedTransverseImpactParameter(), PrimaryVertexSorter< ParticlesCollection >::sortedList(), HLT_FULL_cff::track, trackQuality_, tracks, useAllQualities_, and reco::Vertex::z().

Referenced by analyze().

                                                                                {
   const TransientTrackBuilder *bproduct = TTbuilder.product();
 
   // getting the primary vertex
   // use first pv of the collection
   reco::Vertex pv;
 
   if (!primaryVertexProducer_->empty()) {
     PrimaryVertexSorter pvs;
     std::vector<reco::Vertex> sortedList = pvs.sortedList(*(primaryVertexProducer_.product()));
     pv = (sortedList.front());
   } else {  // create a dummy PV
     // cout << "NO PV FOUND" << endl;
     reco::Vertex::Error e;
     e(0, 0) = 0.0015 * 0.0015;
     e(1, 1) = 0.0015 * 0.0015;
     e(2, 2) = 15. * 15.;
     reco::Vertex::Point p(0, 0, 0);
     pv = reco::Vertex(p, e, 1, 1, 1);
   }
 
   reco::JetTracksAssociationCollection::const_iterator it = jetTracksAssociation->begin();
 
   int i = 0;
 
   for (; it != jetTracksAssociation->end(); it++, i++) {
     // get jetTracks object
     reco::JetTracksAssociationRef jetTracks(jetTracksAssociation, i);
 
     double pvZ = pv.z();
     GlobalVector direction(jetTracks->first->px(), jetTracks->first->py(), jetTracks->first->pz());
 
     // get the tracks associated to the jet
     reco::TrackRefVector tracks = jetTracks->second;
     for (std::size_t index = 0; index < tracks.size(); index++) {
       edm::RefToBase<reco::Track> track(tracks[index]);
 
       double pt = tracks[index]->pt();
       double chi2 = tracks[index]->normalizedChi2();
       int hits = tracks[index]->hitPattern().numberOfValidHits();
       int pixelHits = tracks[index]->hitPattern().numberOfValidPixelHits();
 
       if (hits < minimumNumberOfHits_ || pixelHits < minimumNumberOfPixelHits_ || pt < minimumTransverseMomentum_ ||
           chi2 > maximumChiSquared_ || (!useAllQualities_ && !tracks[index]->quality(trackQuality_)))
         continue;
 
       const reco::TransientTrack transientTrack = bproduct->build(&(*tracks[index]));
       double dta = -IPTools::jetTrackDistance(transientTrack, direction, pv).second.value();
       double sdl = IPTools::signedDecayLength3D(transientTrack, direction, pv).second.value();
       double ips = IPTools::signedImpactParameter3D(transientTrack, direction, pv).second.value();
       double d0 = IPTools::signedTransverseImpactParameter(transientTrack, direction, pv).second.value();
       double dz = tracks[index]->dz() - pvZ;
 
       // Classify the reco track;
       classifier_.evaluate(edm::RefToBase<reco::Track>(tracks[index]));
 
       // Check for the different categories
       if (classifier_.is(TrackClassifier::Fake))
         histogram_data_[5].push_back(histogram_element_t(sdl, dta, d0, dz, ips, pt, chi2, hits, pixelHits));
       else if (classifier_.is(TrackClassifier::BWeakDecay))
         histogram_data_[0].push_back(histogram_element_t(sdl, dta, d0, dz, ips, pt, chi2, hits, pixelHits));
       else if (classifier_.is(TrackClassifier::Bad))
         histogram_data_[4].push_back(histogram_element_t(sdl, dta, d0, dz, ips, pt, chi2, hits, pixelHits));
       else if (!classifier_.is(TrackClassifier::CWeakDecay) && !classifier_.is(TrackClassifier::PrimaryVertex))
         histogram_data_[3].push_back(histogram_element_t(sdl, dta, d0, dz, ips, pt, chi2, hits, pixelHits));
       else if (classifier_.is(TrackClassifier::CWeakDecay))
         histogram_data_[1].push_back(histogram_element_t(sdl, dta, d0, dz, ips, pt, chi2, hits, pixelHits));
       else
         histogram_data_[2].push_back(histogram_element_t(sdl, dta, d0, dz, ips, pt, chi2, hits, pixelHits));
     }
   }
 }