Inheritance diagram for QualityCutsAnalyzer:

Classes
struct	histogram_element_t

class	histogram_t

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

	~QualityCutsAnalyzer () override

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

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () 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

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::vector< ModuleDescription const * > &modules, 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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

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_

edm::InputTag	jetTracksAssociation_

double	maximumChiSquared_

int	minimumNumberOfHits_

int	minimumNumberOfPixelHits_

double	minimumTransverseMomentum_

edm::InputTag	primaryVertexProducer_

std::string	rootFile_

edm::InputTag	trackProducer_

reco::TrackBase::TrackQuality	trackQuality_

bool	useAllQualities_

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)

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 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)

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 115 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 222 of file QualityCutsAnalyzer.cc.

References gather_cfg::cout, edm::ParameterSet::getUntrackedParameter(), createfilelist::int, jetTracksAssociation_, maximumChiSquared_, minimumNumberOfHits_, minimumNumberOfPixelHits_, minimumTransverseMomentum_, primaryVertexProducer_, reco::TrackBase::qualityByName(), rootFile_, AlCaHLTBitMon_QueryRunRegistry::string, trackProducer_, trackQuality_, create_public_lumi_plots::transform, and useAllQualities_.

                                                                       : classifier_(config,consumesCollector())
 {
     trackProducer_         = config.getUntrackedParameter<edm::InputTag> ( "trackProducer" );
     consumes<edm::View<reco::Track>>(trackProducer_);
     primaryVertexProducer_ = config.getUntrackedParameter<edm::InputTag> ( "primaryVertexProducer" );
     consumes<reco::VertexCollection>(primaryVertexProducer_);
     jetTracksAssociation_  = config.getUntrackedParameter<edm::InputTag> ( "jetTracksAssociation" );
     consumes<reco::JetTracksAssociationCollection>(jetTracksAssociation_);
 
     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 ( )

override

Definition at line 250 of file QualityCutsAnalyzer.cc.

250 {}

Member Function Documentation

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

overrideprivate

Definition at line 258 of file QualityCutsAnalyzer.cc.

References classifier_, edm::EventSetup::get(), impactParameterTagInfos_cfi::jetTracks, jetTracksAssociation_, LoopOverJetTracksAssociation(), TrackClassifier::newEvent(), primaryVertexProducer_, findElectronsInSiStrips_cfi::trackCollection, and trackProducer_.

 {
     // Track collection
     edm::Handle<edm::View<reco::Track> > trackCollection;
     event.getByLabel(trackProducer_,trackCollection);
     // Primary vertex
     edm::Handle<reco::VertexCollection> primaryVertexCollection;
     event.getByLabel(primaryVertexProducer_, primaryVertexCollection);
     // Jet to tracks associator
     edm::Handle<reco::JetTracksAssociationCollection> jetTracks;
     event.getByLabel(jetTracksAssociation_, jetTracks);
     // Trasient track builder
     edm::ESHandle<TransientTrackBuilder> TTbuilder;
     setup.get<TransientTrackRecord>().get("TransientTrackBuilder", TTbuilder);
 
     // 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 286 of file QualityCutsAnalyzer.cc.

References histogram_data_.

 {
     histogram_data_.resize(6);
 }

void QualityCutsAnalyzer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 294 of file QualityCutsAnalyzer.cc.

References FrontierConditions_GlobalTag_cff::file, QualityCutsAnalyzer::histogram_t::Fill(), histogram_data_, mps_fire::i, 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 329 of file QualityCutsAnalyzer.cc.

References TrackCategories::Bad, edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::begin(), TransientTrackBuilder::build(), TrackCategories::BWeakDecay, vertices_cff::chi2, classifier_, TrackCategories::CWeakDecay, allConversions_cfi::d0, DEFINE_FWK_MODULE, PVValHelper::dz, MillePedeFileConverter_cfg::e, edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::end(), TrackClassifier::evaluate(), TrackCategories::Fake, histogram_data_, hfClusterShapes_cfi::hits, mps_fire::i, diffTreeTool::index, TrackCategories::is(), IPTools::jetTrackDistance(), impactParameterTagInfos_cfi::jetTracks, maximumChiSquared_, minimumNumberOfHits_, minimumNumberOfPixelHits_, minimumTransverseMomentum_, AlCaHLTBitMon_ParallelJobs::p, NuclearInteractionSecond_cff::pixelHits, TrackCategories::PrimaryVertex, edm::Handle< T >::product(), edm::ESHandle< T >::product(), EnergyCorrector::pt, MetAnalyzer::pv(), jets_cff::quality, IPTools::signedDecayLength3D(), IPTools::signedImpactParameter3D(), IPTools::signedTransverseImpactParameter(), PrimaryVertexSorter< ParticlesCollection >::sortedList(), HiIsolationCommonParameters_cff::track, trackQuality_, l1t::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));
 
         }
     }
 }