de/d05/TrackBuildingAnalyzer_8cc_source.html

 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"

 #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"

 #include "TrackingTools/Records/interface/TransientRecHitRecord.h"

 #include "TrackingTools/Records/interface/TransientTrackRecord.h"

 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"

 #include "TrackingTools/PatternTools/interface/TSCBLBuilderNoMaterial.h"

 #include "TrackingTools/PatternTools/interface/TSCPBuilderNoMaterial.h"

 #include "DataFormats/BeamSpot/interface/BeamSpot.h"

 #include "MagneticField/Engine/interface/MagneticField.h"


 #include "FWCore/MessageLogger/interface/MessageLogger.h"

 #include "FWCore/Utilities/interface/InputTag.h"

 #include "DQMServices/Core/interface/DQMStore.h"

 #include "DQM/TrackingMonitor/interface/TrackBuildingAnalyzer.h"

 #include <string>

 #include "TMath.h"


 #include <iostream>


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

     : conf_( iConfig )

     , SeedPt(NULL)

     , SeedEta(NULL)

     , SeedPhi(NULL)

     , SeedPhiVsEta(NULL)

     , SeedTheta(NULL)

     , SeedQ(NULL)

     , SeedDxy(NULL)

     , SeedDz(NULL)

     , NumberOfRecHitsPerSeed(NULL)

     , NumberOfRecHitsPerSeedVsPhiProfile(NULL)

     , NumberOfRecHitsPerSeedVsEtaProfile(NULL)

 {

 }


 TrackBuildingAnalyzer::~TrackBuildingAnalyzer()

 {

 }


 void TrackBuildingAnalyzer::initHisto(DQMStore::IBooker & ibooker)

 {


   // parameters from the configuration

   std::string AlgoName       = conf_.getParameter<std::string>("AlgoName");

   std::string MEFolderName   = conf_.getParameter<std::string>("FolderName");


   //  std::cout << "[TrackBuildingAnalyzer::beginRun] AlgoName: " << AlgoName << std::endl;


   // use the AlgoName and Quality Name

   std::string CatagoryName = AlgoName;


   // get binning from the configuration

   int    TrackPtBin = conf_.getParameter<int>(   "TrackPtBin");

   double TrackPtMin = conf_.getParameter<double>("TrackPtMin");

   double TrackPtMax = conf_.getParameter<double>("TrackPtMax");


   int    PhiBin     = conf_.getParameter<int>(   "PhiBin");

   double PhiMin     = conf_.getParameter<double>("PhiMin");

   double PhiMax     = conf_.getParameter<double>("PhiMax");


   int    EtaBin     = conf_.getParameter<int>(   "EtaBin");

   double EtaMin     = conf_.getParameter<double>("EtaMin");

   double EtaMax     = conf_.getParameter<double>("EtaMax");


   int    ThetaBin   = conf_.getParameter<int>(   "ThetaBin");

   double ThetaMin   = conf_.getParameter<double>("ThetaMin");

   double ThetaMax   = conf_.getParameter<double>("ThetaMax");


   int    TrackQBin  = conf_.getParameter<int>(   "TrackQBin");

   double TrackQMin  = conf_.getParameter<double>("TrackQMin");

   double TrackQMax  = conf_.getParameter<double>("TrackQMax");


   int    SeedDxyBin = conf_.getParameter<int>(   "SeedDxyBin");

   double SeedDxyMin = conf_.getParameter<double>("SeedDxyMin");

   double SeedDxyMax = conf_.getParameter<double>("SeedDxyMax");


   int    SeedDzBin  = conf_.getParameter<int>(   "SeedDzBin");

   double SeedDzMin  = conf_.getParameter<double>("SeedDzMin");

   double SeedDzMax  = conf_.getParameter<double>("SeedDzMax");


   int    SeedHitBin = conf_.getParameter<int>(   "SeedHitBin");

   double SeedHitMin = conf_.getParameter<double>("SeedHitMin");

   double SeedHitMax = conf_.getParameter<double>("SeedHitMax");


   int    TCDxyBin   = conf_.getParameter<int>(   "TCDxyBin");

   double TCDxyMin   = conf_.getParameter<double>("TCDxyMin");

   double TCDxyMax   = conf_.getParameter<double>("TCDxyMax");


   int    TCDzBin    = conf_.getParameter<int>(   "TCDzBin");

   double TCDzMin    = conf_.getParameter<double>("TCDzMin");

   double TCDzMax    = conf_.getParameter<double>("TCDzMax");


   int    TCHitBin   = conf_.getParameter<int>(   "TCHitBin");

   double TCHitMin   = conf_.getParameter<double>("TCHitMin");

   double TCHitMax   = conf_.getParameter<double>("TCHitMax");


   edm::InputTag seedProducer   = conf_.getParameter<edm::InputTag>("SeedProducer");

   edm::InputTag tcProducer     = conf_.getParameter<edm::InputTag>("TCProducer");


   doAllPlots     = conf_.getParameter<bool>("doAllPlots");

   doAllSeedPlots = conf_.getParameter<bool>("doSeedParameterHistos");

   doTCPlots      = conf_.getParameter<bool>("doTrackCandHistos");

   doPT           = conf_.getParameter<bool>("doSeedPTHisto");

   doETA          = conf_.getParameter<bool>("doSeedETAHisto");

   doPHI          = conf_.getParameter<bool>("doSeedPHIHisto");

   doPHIVsETA     = conf_.getParameter<bool>("doSeedPHIVsETAHisto");

   doTheta        = conf_.getParameter<bool>("doSeedThetaHisto");

   doQ            = conf_.getParameter<bool>("doSeedQHisto");

   doDxy          = conf_.getParameter<bool>("doSeedDxyHisto");

   doDz           = conf_.getParameter<bool>("doSeedDzHisto");

   doNRecHits     = conf_.getParameter<bool>("doSeedNRecHitsHisto");

   doProfPHI      = conf_.getParameter<bool>("doSeedNVsPhiProf");

   doProfETA      = conf_.getParameter<bool>("doSeedNVsEtaProf");


   //    if (doAllPlots){doAllSeedPlots=true; doTCPlots=true;}


   ibooker.setCurrentFolder(MEFolderName);


   // book the Seed histograms

   // ---------------------------------------------------------------------------------//

   //  std::cout << "[TrackBuildingAnalyzer::beginRun] MEFolderName: " << MEFolderName << std::endl;

   ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");


   if (doAllSeedPlots || doPT) {

     histname = "SeedPt_"+seedProducer.label() + "_";

     SeedPt = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, TrackPtBin, TrackPtMin, TrackPtMax);

     SeedPt->setAxisTitle("Seed p_{T} (GeV/c)", 1);

     SeedPt->setAxisTitle("Number of Seeds", 2);

   }


   if (doAllSeedPlots || doETA) {

     histname = "SeedEta_"+seedProducer.label() + "_";

     SeedEta = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, EtaBin, EtaMin, EtaMax);

       SeedEta->setAxisTitle("Seed #eta", 1);

       SeedEta->setAxisTitle("Number of Seeds", 2);

   }


   if (doAllSeedPlots || doPHI) {

     histname = "SeedPhi_"+seedProducer.label() + "_";

     SeedPhi = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, PhiBin, PhiMin, PhiMax);

     SeedPhi->setAxisTitle("Seed #phi", 1);

     SeedPhi->setAxisTitle("Number of Seed", 2);

   }


   if (doAllSeedPlots || doPHIVsETA) {

     histname = "SeedPhiVsEta_"+seedProducer.label() + "_";

     SeedPhiVsEta = ibooker.book2D(histname+CatagoryName, histname+CatagoryName, EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax);

     SeedPhiVsEta->setAxisTitle("Seed #eta", 1);

     SeedPhiVsEta->setAxisTitle("Seed #phi", 2);

   }


   if (doAllSeedPlots || doTheta){

     histname = "SeedTheta_"+seedProducer.label() + "_";

     SeedTheta = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, ThetaBin, ThetaMin, ThetaMax);

     SeedTheta->setAxisTitle("Seed #theta", 1);

     SeedTheta->setAxisTitle("Number of Seeds", 2);

   }


   if (doAllSeedPlots || doQ){

     histname = "SeedQ_"+seedProducer.label() + "_";

     SeedQ = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, TrackQBin, TrackQMin, TrackQMax);

     SeedQ->setAxisTitle("Seed Charge", 1);

     SeedQ->setAxisTitle("Number of Seeds",2);

   }


   if (doAllSeedPlots || doDxy){

     histname = "SeedDxy_"+seedProducer.label() + "_";

     SeedDxy = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, SeedDxyBin, SeedDxyMin, SeedDxyMax);

     SeedDxy->setAxisTitle("Seed d_{xy} (cm)", 1);

     SeedDxy->setAxisTitle("Number of Seeds",2);

   }


   if (doAllSeedPlots || doDz){

     histname = "SeedDz_"+seedProducer.label() + "_";

     SeedDz = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, SeedDzBin, SeedDzMin, SeedDzMax);

     SeedDz->setAxisTitle("Seed d_{z} (cm)", 1);

     SeedDz->setAxisTitle("Number of Seeds",2);

   }


   if (doAllSeedPlots || doNRecHits){

     histname = "NumberOfRecHitsPerSeed_"+seedProducer.label() + "_";

     NumberOfRecHitsPerSeed = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, SeedHitBin, SeedHitMin, SeedHitMax);

     NumberOfRecHitsPerSeed->setAxisTitle("Number of RecHits per Seed", 1);

     NumberOfRecHitsPerSeed->setAxisTitle("Number of Seeds",2);

   }


   if (doAllSeedPlots || doProfPHI){

     histname = "NumberOfRecHitsPerSeedVsPhiProfile_"+seedProducer.label() + "_";

     NumberOfRecHitsPerSeedVsPhiProfile = ibooker.bookProfile(histname+CatagoryName, histname+CatagoryName, PhiBin, PhiMin, PhiMax, SeedHitBin, SeedHitMin, SeedHitMax,"s");

     NumberOfRecHitsPerSeedVsPhiProfile->setAxisTitle("Seed #phi",1);

     NumberOfRecHitsPerSeedVsPhiProfile->setAxisTitle("Number of RecHits of each Seed",2);

   }


   if (doAllSeedPlots || doProfETA){

     histname = "NumberOfRecHitsPerSeedVsEtaProfile_"+seedProducer.label() + "_";

     NumberOfRecHitsPerSeedVsEtaProfile = ibooker.bookProfile(histname+CatagoryName, histname+CatagoryName, EtaBin, EtaMin, EtaMax, SeedHitBin, SeedHitMin, SeedHitMax,"s");

     NumberOfRecHitsPerSeedVsEtaProfile->setAxisTitle("Seed #eta",1);

     NumberOfRecHitsPerSeedVsEtaProfile->setAxisTitle("Number of RecHits of each Seed",2);

   }


   // book the TrackCandidate histograms

   // ---------------------------------------------------------------------------------//


   if (doTCPlots){


     ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");


     histname = "TrackCandPt_"+tcProducer.label() + "_";

     TrackCandPt = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, TrackPtBin, TrackPtMin, TrackPtMax);

     TrackCandPt->setAxisTitle("Track Candidate p_{T} (GeV/c)", 1);

     TrackCandPt->setAxisTitle("Number of Track Candidates", 2);


     histname = "TrackCandEta_"+tcProducer.label() + "_";

     TrackCandEta = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, EtaBin, EtaMin, EtaMax);

     TrackCandEta->setAxisTitle("Track Candidate #eta", 1);

     TrackCandEta->setAxisTitle("Number of Track Candidates", 2);


     histname = "TrackCandPhi_"+tcProducer.label() + "_";

     TrackCandPhi = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, PhiBin, PhiMin, PhiMax);

     TrackCandPhi->setAxisTitle("Track Candidate #phi", 1);

     TrackCandPhi->setAxisTitle("Number of Track Candidates", 2);


     histname = "TrackCandTheta_"+tcProducer.label() + "_";

     TrackCandTheta = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, ThetaBin, ThetaMin, ThetaMax);

     TrackCandTheta->setAxisTitle("Track Candidate #theta", 1);

     TrackCandTheta->setAxisTitle("Number of Track Candidates", 2);


     histname = "TrackCandQ_"+tcProducer.label() + "_";

     TrackCandQ = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, TrackQBin, TrackQMin, TrackQMax);

     TrackCandQ->setAxisTitle("Track Candidate Charge", 1);

     TrackCandQ->setAxisTitle("Number of Track Candidates",2);


     histname = "TrackCandDxy_"+tcProducer.label() + "_";

     TrackCandDxy = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, TCDxyBin, TCDxyMin, TCDxyMax);

     TrackCandDxy->setAxisTitle("Track Candidate d_{xy} (cm)", 1);

     TrackCandDxy->setAxisTitle("Number of Track Candidates",2);


     histname = "TrackCandDz_"+tcProducer.label() + "_";

     TrackCandDz = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, TCDzBin, TCDzMin, TCDzMax);

     TrackCandDz->setAxisTitle("Track Candidate d_{z} (cm)", 1);

     TrackCandDz->setAxisTitle("Number of Track Candidates",2);


     histname = "NumberOfRecHitsPerTrackCand_"+tcProducer.label() + "_";

     NumberOfRecHitsPerTrackCand = ibooker.book1D(histname+CatagoryName, histname+CatagoryName, TCHitBin, TCHitMin, TCHitMax);

     NumberOfRecHitsPerTrackCand->setAxisTitle("Number of RecHits per Track Candidate", 1);

     NumberOfRecHitsPerTrackCand->setAxisTitle("Number of Track Candidates",2);


     histname = "NumberOfRecHitsPerTrackCandVsPhiProfile_"+tcProducer.label() + "_";

     NumberOfRecHitsPerTrackCandVsPhiProfile = ibooker.bookProfile(histname+CatagoryName, histname+CatagoryName, PhiBin, PhiMin, PhiMax, TCHitBin, TCHitMin, TCHitMax,"s");

     NumberOfRecHitsPerTrackCandVsPhiProfile->setAxisTitle("Track Candidate #phi",1);

     NumberOfRecHitsPerTrackCandVsPhiProfile->setAxisTitle("Number of RecHits of each Track Candidate",2);


     histname = "NumberOfRecHitsPerTrackCandVsEtaProfile_"+tcProducer.label() + "_";

     NumberOfRecHitsPerTrackCandVsEtaProfile = ibooker.bookProfile(histname+CatagoryName, histname+CatagoryName, EtaBin, EtaMin, EtaMax, TCHitBin, TCHitMin, TCHitMax,"s");

     NumberOfRecHitsPerTrackCandVsEtaProfile->setAxisTitle("Track Candidate #eta",1);

     NumberOfRecHitsPerTrackCandVsEtaProfile->setAxisTitle("Number of RecHits of each Track Candidate",2);

   }


 }


 // -- Analyse

 // ---------------------------------------------------------------------------------//

 void TrackBuildingAnalyzer::analyze

 (

     const edm::Event& iEvent,

     const edm::EventSetup& iSetup,

     const TrajectorySeed& candidate,

     const reco::BeamSpot& bs,

     const edm::ESHandle<MagneticField>& theMF,

     const edm::ESHandle<TransientTrackingRecHitBuilder>& theTTRHBuilder

 )

 {

   TSCBLBuilderNoMaterial tscblBuilder;


   //get parameters and errors from the candidate state

   TransientTrackingRecHit::RecHitPointer recHit = theTTRHBuilder->build(&*(candidate.recHits().second-1));

   TrajectoryStateOnSurface state = trajectoryStateTransform::transientState( candidate.startingState(), recHit->surface(), theMF.product());

   TrajectoryStateClosestToBeamLine tsAtClosestApproachSeed = tscblBuilder(*state.freeState(),bs);//as in TrackProducerAlgorithm

   if(!(tsAtClosestApproachSeed.isValid())) {

     edm::LogVerbatim("TrackBuilding") << "TrajectoryStateClosestToBeamLine not valid";

     return;

   }

   GlobalPoint  v0 = tsAtClosestApproachSeed.trackStateAtPCA().position();

   GlobalVector p = tsAtClosestApproachSeed.trackStateAtPCA().momentum();

   GlobalPoint  v(v0.x()-bs.x0(),v0.y()-bs.y0(),v0.z()-bs.z0());


   double pt           = sqrt(state.globalMomentum().perp2());

   double eta          = state.globalMomentum().eta();

   double phi          = state.globalMomentum().phi();

   double theta        = state.globalMomentum().theta();

   //double pm           = sqrt(state.globalMomentum().mag2());

   //double pz           = state.globalMomentum().z();

   //double qoverp       = tsAtClosestApproachSeed.trackStateAtPCA().charge()/p.mag();

   //double theta        = p.theta();

   //double lambda       = M_PI/2-p.theta();

   double numberOfHits = candidate.recHits().second-candidate.recHits().first;

   double dxy          = (-v.x()*sin(p.phi())+v.y()*cos(p.phi()));

   double dz           = v.z() - (v.x()*p.x()+v.y()*p.y())/p.perp() * p.z()/p.perp();


   // fill the ME's

   if (doAllSeedPlots || doQ)SeedQ->Fill( state.charge() );

   if (doAllSeedPlots || doPT) SeedPt->Fill( pt );

   if (doAllSeedPlots || doETA) SeedEta->Fill( eta );

   if (doAllSeedPlots || doPHI) SeedPhi->Fill( phi );

   if (doAllSeedPlots || doPHIVsETA) SeedPhiVsEta->Fill( eta, phi);

   if (doAllSeedPlots || doTheta) SeedTheta->Fill( theta );

   if (doAllSeedPlots || doDxy) SeedDxy->Fill( dxy );

   if (doAllSeedPlots || doDz) SeedDz->Fill( dz );

   if (doAllSeedPlots || doNRecHits) NumberOfRecHitsPerSeed->Fill( numberOfHits );

   if (doAllSeedPlots || doProfETA) NumberOfRecHitsPerSeedVsEtaProfile->Fill( eta, numberOfHits );

   if (doAllSeedPlots || doProfPHI) NumberOfRecHitsPerSeedVsPhiProfile->Fill( phi, numberOfHits );


 }


 // -- Analyse

 // ---------------------------------------------------------------------------------//

 void TrackBuildingAnalyzer::analyze

 (

     const edm::Event& iEvent,

     const edm::EventSetup& iSetup,

     const TrackCandidate& candidate,

     const reco::BeamSpot& bs,

     const edm::ESHandle<MagneticField>& theMF,

     const edm::ESHandle<TransientTrackingRecHitBuilder>& theTTRHBuilder

 )

 {

   TSCBLBuilderNoMaterial tscblBuilder;


   //get parameters and errors from the candidate state

   TransientTrackingRecHit::RecHitPointer recHit = theTTRHBuilder->build(&*(candidate.recHits().second-1));

   TrajectoryStateOnSurface state = trajectoryStateTransform::transientState( candidate.trajectoryStateOnDet(), recHit->surface(), theMF.product());

   TrajectoryStateClosestToBeamLine tsAtClosestApproachTrackCand = tscblBuilder(*state.freeState(),bs);//as in TrackProducerAlgorithm

   if(!(tsAtClosestApproachTrackCand.isValid())) {

     edm::LogVerbatim("TrackBuilding") << "TrajectoryStateClosestToBeamLine not valid";

     return;

   }

   GlobalPoint  v0 = tsAtClosestApproachTrackCand.trackStateAtPCA().position();

   GlobalVector p = tsAtClosestApproachTrackCand.trackStateAtPCA().momentum();

   GlobalPoint  v(v0.x()-bs.x0(),v0.y()-bs.y0(),v0.z()-bs.z0());


   double pt           = sqrt(state.globalMomentum().perp2());

   double eta          = state.globalMomentum().eta();

   double phi          = state.globalMomentum().phi();

   double theta        = state.globalMomentum().theta();

   //double pm           = sqrt(state.globalMomentum().mag2());

   //double pz           = state.globalMomentum().z();

   //double qoverp       = tsAtClosestApproachTrackCand.trackStateAtPCA().charge()/p.mag();

   //double theta        = p.theta();

   //double lambda       = M_PI/2-p.theta();

   double numberOfHits = candidate.recHits().second-candidate.recHits().first;

   double dxy          = (-v.x()*sin(p.phi())+v.y()*cos(p.phi()));


   double dz           = v.z() - (v.x()*p.x()+v.y()*p.y())/p.perp() * p.z()/p.perp();


   if (doTCPlots){

     // fill the ME's

     TrackCandQ->Fill( state.charge() );

     TrackCandPt->Fill( pt );

     TrackCandEta->Fill( eta );

     TrackCandPhi->Fill( phi );

     TrackCandTheta->Fill( theta );

     TrackCandDxy->Fill( dxy );

     TrackCandDz->Fill( dz );

     NumberOfRecHitsPerTrackCand->Fill( numberOfHits );

     NumberOfRecHitsPerTrackCandVsEtaProfile->Fill( eta, numberOfHits );

     NumberOfRecHitsPerTrackCandVsPhiProfile->Fill( phi, numberOfHits );

   }

 }

TrackBuildingAnalyzer::SeedDz
MonitorElement * SeedDz
Definition: TrackBuildingAnalyzer.h:76

TrackBuildingAnalyzer::NumberOfRecHitsPerTrackCandVsPhiProfile
MonitorElement * NumberOfRecHitsPerTrackCandVsPhiProfile
Definition: TrackBuildingAnalyzer.h:90

TrackBuildingAnalyzer::TrackCandPt
MonitorElement * TrackCandPt
Definition: TrackBuildingAnalyzer.h:82

edm::ParameterSet::getParameter
T getParameter(std::string const &) const

reco::BeamSpot::z0
double z0() const
z coordinate
Definition: BeamSpot.h:68

TransientTrackBuilder.h

MessageLogger.h

TrackBuildingAnalyzer::SeedPhi
MonitorElement * SeedPhi
Definition: TrackBuildingAnalyzer.h:71

TrackBuildingAnalyzer::~TrackBuildingAnalyzer
virtual ~TrackBuildingAnalyzer()
Definition: TrackBuildingAnalyzer.cc:36

PV3DBase::perp
T perp() const
Definition: PV3DBase.h:72

TrajectoryStateOnSurface::charge
TrackCharge charge() const
Definition: TrajectoryStateOnSurface.h:98

TrackCandidate::recHits
range recHits() const
Definition: TrackCandidate.h:51

TrackBuildingAnalyzer::doProfPHI
bool doProfPHI
Definition: TrackBuildingAnalyzer.h:108

DQMStore::IBooker::bookProfile
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157

TrackBuildingAnalyzer::TrackCandDz
MonitorElement * TrackCandDz
Definition: TrackBuildingAnalyzer.h:88

TrackBuildingAnalyzer::doAllPlots
bool doAllPlots
Definition: TrackBuildingAnalyzer.h:96

TrackBuildingAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackBuildingAnalyzer.h:66

Vector3DBase< float, GlobalTag >

TrackBuildingAnalyzer::SeedQ
MonitorElement * SeedQ
Definition: TrackBuildingAnalyzer.h:74

TrackBuildingAnalyzer::doNRecHits
bool doNRecHits
Definition: TrackBuildingAnalyzer.h:107

TrackBuildingAnalyzer::doTheta
bool doTheta
Definition: TrackBuildingAnalyzer.h:103

TransientTrack.h

TrackBuildingAnalyzer::doPHIVsETA
bool doPHIVsETA
Definition: TrackBuildingAnalyzer.h:102

funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22

PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:69

TrackBuildingAnalyzer::doProfETA
bool doProfETA
Definition: TrackBuildingAnalyzer.h:109

theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:170

PV3DBase::y
T y() const
Definition: PV3DBase.h:63

TrackBuildingAnalyzer::doETA
bool doETA
Definition: TrackBuildingAnalyzer.h:100

TrajectoryStateTransform.h

NULL
#define NULL
Definition: scimark2.h:8

TrackBuildingAnalyzer::SeedDxy
MonitorElement * SeedDxy
Definition: TrackBuildingAnalyzer.h:75

PV3DBase::perp2
T perp2() const
Definition: PV3DBase.h:71

findQualityFiles.v
v
Definition: findQualityFiles.py:177

TrackBuildingAnalyzer::TrackCandPhi
MonitorElement * TrackCandPhi
Definition: TrackBuildingAnalyzer.h:84

TrajectoryStateClosestToBeamLine
Definition: TrajectoryStateClosestToBeamLine.h:15

TrajectoryStateOnSurface
Definition: TrajectoryStateOnSurface.h:17

TrackBuildingAnalyzer::SeedPt
MonitorElement * SeedPt
Definition: TrackBuildingAnalyzer.h:69

AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

TrackBuildingAnalyzer::histname
std::string histname
Definition: TrackBuildingAnalyzer.h:93

TrackBuildingAnalyzer::SeedTheta
MonitorElement * SeedTheta
Definition: TrackBuildingAnalyzer.h:73

PV3DBase::theta
Geom::Theta< T > theta() const
Definition: PV3DBase.h:75

MagneticField.h

TrackBuildingAnalyzer::NumberOfRecHitsPerTrackCandVsEtaProfile
MonitorElement * NumberOfRecHitsPerTrackCandVsEtaProfile
Definition: TrackBuildingAnalyzer.h:91

TrackCandidate::trajectoryStateOnDet
PTrajectoryStateOnDet const & trajectoryStateOnDet() const
Definition: TrackCandidate.h:49

TrackBuildingAnalyzer::NumberOfRecHitsPerSeed
MonitorElement * NumberOfRecHitsPerSeed
Definition: TrackBuildingAnalyzer.h:77

TrackBuildingAnalyzer::analyze
virtual void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const TrajectorySeed &seed, const reco::BeamSpot &bs, const edm::ESHandle< MagneticField > &theMF, const edm::ESHandle< TransientTrackingRecHitBuilder > &theTTRHBuilder)
Definition: TrackBuildingAnalyzer.cc:265

iEvent
int iEvent
Definition: GenABIO.cc:230

TrackBuildingAnalyzer::NumberOfRecHitsPerSeedVsPhiProfile
MonitorElement * NumberOfRecHitsPerSeedVsPhiProfile
Definition: TrackBuildingAnalyzer.h:78

TrackBuildingAnalyzer::TrackCandDxy
MonitorElement * TrackCandDxy
Definition: TrackBuildingAnalyzer.h:87

DQMStore.h

mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48

edm::ESHandle< MagneticField >

TrajectoryStateOnSurface::freeState
FreeTrajectoryState const * freeState(bool withErrors=true) const
Definition: TrajectoryStateOnSurface.h:76

TrackBuildingAnalyzer::doQ
bool doQ
Definition: TrackBuildingAnalyzer.h:104

PV3DBase::z
T z() const
Definition: PV3DBase.h:64

TrackBuildingAnalyzer::initHisto
virtual void initHisto(DQMStore::IBooker &ibooker)
Definition: TrackBuildingAnalyzer.cc:40

funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22

TrackBuildingAnalyzer::TrackCandEta
MonitorElement * TrackCandEta
Definition: TrackBuildingAnalyzer.h:83

DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115

TrackBuildingAnalyzer::doAllSeedPlots
bool doAllSeedPlots
Definition: TrackBuildingAnalyzer.h:97

TransientRecHitRecord.h

Gflash::EtaMin
const double EtaMin[kNumberCalorimeter]
Definition: GflashNameSpace.h:32

edm::EventSetup
Definition: EventSetup.h:44

edm::LogVerbatim
Definition: MessageLogger.h:240

TrackBuildingAnalyzer::TrackBuildingAnalyzer
TrackBuildingAnalyzer(const edm::ParameterSet &)
Definition: TrackBuildingAnalyzer.cc:20

TSCBLBuilderNoMaterial.h

TrackBuildingAnalyzer.h

TSCPBuilderNoMaterial.h

TrackingRecHit::RecHitPointer
std::shared_ptr< TrackingRecHit const  > RecHitPointer
Definition: TrackingRecHit.h:27

eta
Definition: HIMultiTrackSelector.h:42

EnergyCorrector.pt
int pt
Definition: EnergyCorrector.py:45

TrackBuildingAnalyzer::doTCPlots
bool doTCPlots
Definition: TrackBuildingAnalyzer.h:98

TrajectorySeed::startingState
PTrajectoryStateOnDet const & startingState() const
Definition: TrajectorySeed.h:80

TrackBuildingAnalyzer::doDxy
bool doDxy
Definition: TrackBuildingAnalyzer.h:105

DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274

trajectoryStateTransform::transientState
TrajectoryStateOnSurface transientState(const PTrajectoryStateOnDet &ts, const Surface *surface, const MagneticField *field)
Definition: TrajectoryStateTransform.cc:44

DQMStore::IBooker::book2D
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133

TrackBuildingAnalyzer::doDz
bool doDz
Definition: TrackBuildingAnalyzer.h:106

HLT_25ns14e33_v1_cff.AlgoName
tuple AlgoName
Definition: HLT_25ns14e33_v1_cff.py:1043

edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86

TrajectorySeed::recHits
range recHits() const
Definition: TrajectorySeed.h:75

TrackBuildingAnalyzer::TrackCandTheta
MonitorElement * TrackCandTheta
Definition: TrackBuildingAnalyzer.h:85

TrackBuildingAnalyzer::TrackCandQ
MonitorElement * TrackCandQ
Definition: TrackBuildingAnalyzer.h:86

TrackBuildingAnalyzer::doPT
bool doPT
Definition: TrackBuildingAnalyzer.h:99

TrackBuildingAnalyzer::SeedPhiVsEta
MonitorElement * SeedPhiVsEta
Definition: TrackBuildingAnalyzer.h:72

phi
Geom::Phi< T > phi() const
Definition: Basic3DVectorLD.h:163

PV3DBase::eta
T eta() const
Definition: PV3DBase.h:76

AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152

Point3DBase< float, GlobalTag >

TransientTrackRecord.h

edm::InputTag
Definition: InputTag.h:18

TrajectoryStateOnSurface::globalMomentum
GlobalVector globalMomentum() const
Definition: TrajectoryStateOnSurface.h:92

TrackCandidate
Definition: TrackCandidate.h:23

HLT_25ns14e33_v3_cff.EtaMax
tuple EtaMax
Definition: HLT_25ns14e33_v3_cff.py:1747

InputTag.h

BeamSpot.h

TrackBuildingAnalyzer::doPHI
bool doPHI
Definition: TrackBuildingAnalyzer.h:101

reco::BeamSpot::y0
double y0() const
y coordinate
Definition: BeamSpot.h:66

TrackBuildingAnalyzer::SeedEta
MonitorElement * SeedEta
Definition: TrackBuildingAnalyzer.h:70

edm::ParameterSet
Definition: ParameterSet.h:36

TrackBuildingAnalyzer::NumberOfRecHitsPerSeedVsEtaProfile
MonitorElement * NumberOfRecHitsPerSeedVsEtaProfile
Definition: TrackBuildingAnalyzer.h:79

TrajectorySeed
Definition: TrajectorySeed.h:18

edm::Event
Definition: Event.h:61

DQMStore::IBooker
Definition: DQMStore.h:90

PV3DBase::x
T x() const
Definition: PV3DBase.h:62

MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947

reco::BeamSpot
Definition: BeamSpot.h:22

TrackBuildingAnalyzer::NumberOfRecHitsPerTrackCand
MonitorElement * NumberOfRecHitsPerTrackCand
Definition: TrackBuildingAnalyzer.h:89

TSCBLBuilderNoMaterial
Definition: TSCBLBuilderNoMaterial.h:13

reco::BeamSpot::x0
double x0() const
x coordinate
Definition: BeamSpot.h:64