#include <DQM/TrackerMonitorTrack/src/TrackingMonitor.cc>

Inheritance diagram for TrackingMonitor:

Public Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)

virtual void	beginJob (void)

virtual void	beginLuminosityBlock (const edm::LuminosityBlock &lumi, const edm::EventSetup &eSetup)

virtual void	beginRun (const edm::Run &, const edm::EventSetup &)

virtual void	endJob (void)

virtual void	endRun (const edm::Run &, const edm::EventSetup &)

virtual void	setMaxMinBin (std::vector< double > &, std::vector< double > &, std::vector< int > &, double, double, int, double, double, int)

virtual void	setNclus (const edm::Event &, std::vector< int > &)

	TrackingMonitor (const edm::ParameterSet &)

	~TrackingMonitor ()

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
void	doProfileX (TH2 th2, MonitorElement me)

void	doProfileX (MonitorElement th2m, MonitorElement me)

Private Attributes
std::string	AlgoName_

edm::EDGetTokenT < reco::TrackCollection >	allTrackToken_

edm::InputTag	bsSrc_

edm::EDGetTokenT< reco::BeamSpot >	bsSrcToken_

std::string	builderName

std::vector< std::string >	ClusterLabels

edm::ParameterSet	conf_

bool	doAllPlots

bool	doAllSeedPlots

bool	doDCAPlots_

bool	doFractionPlot_

bool	doGeneralPropertiesPlots_

bool	doHitPropertiesPlots_

bool	doLumiAnalysis

bool	doPlotsVsBXlumi_

bool	doPlotsVsGoodPVtx_

bool	doProfilesVsLS_

bool	doPUmonitoring_

bool	doSeedLumiAnalysis_

bool	doSeedNumberPlot

bool	doSeedVsClusterPlot

bool	doTkCandPlots

bool	doTrackerSpecific_

DQMStore *	dqmStore_

MonitorElement *	FractionOfGoodTracks

GenericTriggerEventFlag *	genTriggerEventFlag_

MonitorElement *	GoodTracksFractionVsLS

std::string	histname

MonitorElement *	NumberOfMeanLayersPerTrack

MonitorElement *	NumberOfMeanRecHitsPerTrack

MonitorElement *	NumberOfRecHitsPerTrackVsLS

MonitorElement *	NumberOfSeeds

MonitorElement *	NumberOfSeeds_lumiFlag

MonitorElement *	NumberOfTrackCandidates

MonitorElement *	NumberOfTracks

MonitorElement *	NumberOfTracks_lumiFlag

MonitorElement *	NumberOfTracksVsBXlumi

MonitorElement *	NumberOfTracksVsGoodPVtx

MonitorElement *	NumberOfTracksVsLS

MonitorElement *	NumberOfTrkVsClus

std::vector< MonitorElement * >	NumberOfTrkVsClusters

MonitorElement *	NumberOfTrkVsPixelClus

MonitorElement *	NumberOfTrkVsStripClus

edm::InputTag	pixelClusterInputTag_

edm::EDGetTokenT < edmNew::DetSetVector < SiPixelCluster > >	pixelClustersToken_

edm::InputTag	pvSrc_

edm::EDGetTokenT < reco::VertexCollection >	pvSrcToken_

std::string	Quality_

bool	runTrackBuildingAnalyzerForSeed

std::vector< MonitorElement * >	SeedsVsClusters

edm::EDGetTokenT< edm::View < TrajectorySeed > >	seedToken_

edm::InputTag	stripClusterInputTag_

edm::EDGetTokenT < edmNew::DetSetVector < SiStripCluster > >	stripClustersToken_

GetLumi *	theLumiDetails_

TrackAnalyzer *	theTrackAnalyzer

TrackBuildingAnalyzer *	theTrackBuildingAnalyzer

edm::ESHandle < TransientTrackingRecHitBuilder >	theTTRHBuilder

std::vector< VertexMonitor * >	theVertexMonitor

edm::EDGetTokenT < TrackCandidateCollection >	trackCandidateToken_

edm::EDGetTokenT < reco::TrackCollection >	trackToken_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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

Monitoring source for general quantities related to tracks.

Definition at line 45 of file TrackingMonitor.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 40 of file TrackingMonitor.cc.

References AlgoName_, allTrackToken_, bsSrc_, bsSrcToken_, trackerHits::c, conf_, edm::EDConsumerBase::consumesCollector(), doFractionPlot_, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doPUmonitoring_, edm::ParameterSet::getParameter(), i, pixelClusterInputTag_, pixelClustersToken_, pvSrc_, pvSrcToken_, Quality_, seedToken_, AlCaHLTBitMon_QueryRunRegistry::string, stripClusterInputTag_, stripClustersToken_, theLumiDetails_, theTrackAnalyzer, theVertexMonitor, trackCandidateToken_, and trackToken_.

     : dqmStore_( edm::Service<DQMStore>().operator->() )
     , conf_ ( iConfig )
     , theTrackBuildingAnalyzer( new TrackBuildingAnalyzer(conf_) )
     , NumberOfTracks(NULL)
     , NumberOfMeanRecHitsPerTrack(NULL)
     , NumberOfMeanLayersPerTrack(NULL)
                 //    , NumberOfGoodTracks(NULL)
     , FractionOfGoodTracks(NULL)
     , NumberOfSeeds(NULL)
     , NumberOfSeeds_lumiFlag(NULL)
     , NumberOfTrackCandidates(NULL)
                 //    , NumberOfGoodTrkVsClus(NULL)
     , NumberOfTracksVsLS(NULL)
                 //    , NumberOfGoodTracksVsLS(NULL)
     , GoodTracksFractionVsLS(NULL)
                 //    , GoodTracksNumberOfRecHitsPerTrackVsLS(NULL)
                 // ADD by Mia for PU monitoring
                 // vertex plots to be moved in ad hoc class
     , NumberOfTracksVsGoodPVtx(NULL)
     , NumberOfTracksVsBXlumi(NULL)
 
     , NumberOfTracks_lumiFlag(NULL)
                 //    , NumberOfGoodTracks_lumiFlag(NULL)
 
     , builderName              ( conf_.getParameter<std::string>("TTRHBuilder"))
     , doTrackerSpecific_       ( conf_.getParameter<bool>("doTrackerSpecific") )
     , doLumiAnalysis           ( conf_.getParameter<bool>("doLumiAnalysis"))
     , doProfilesVsLS_          ( conf_.getParameter<bool>("doProfilesVsLS"))
     , doAllPlots               ( conf_.getParameter<bool>("doAllPlots"))
     , doGeneralPropertiesPlots_( conf_.getParameter<bool>("doGeneralPropertiesPlots"))
     , doHitPropertiesPlots_    ( conf_.getParameter<bool>("doHitPropertiesPlots"))
     , doPUmonitoring_          ( conf_.getParameter<bool>("doPUmonitoring") )
     , genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig,consumesCollector()))
 {
 
   edm::ConsumesCollector c{ consumesCollector() };
   theTrackAnalyzer = new TrackAnalyzer( conf_,c );
 
   // input tags for collections from the configuration
   bsSrc_ = conf_.getParameter<edm::InputTag>("beamSpot");
   pvSrc_ = conf_.getParameter<edm::InputTag>("primaryVertex");
   bsSrcToken_ = consumes<reco::BeamSpot>(bsSrc_);
   pvSrcToken_ = mayConsume<reco::VertexCollection>(pvSrc_);
 
   edm::InputTag alltrackProducer = conf_.getParameter<edm::InputTag>("allTrackProducer");
   edm::InputTag trackProducer    = conf_.getParameter<edm::InputTag>("TrackProducer");
   edm::InputTag tcProducer       = conf_.getParameter<edm::InputTag>("TCProducer");
   edm::InputTag seedProducer     = conf_.getParameter<edm::InputTag>("SeedProducer");
   allTrackToken_       = consumes<reco::TrackCollection>(alltrackProducer);
   trackToken_          = consumes<reco::TrackCollection>(trackProducer);
   trackCandidateToken_ = consumes<TrackCandidateCollection>(tcProducer); 
   seedToken_           = consumes<edm::View<TrajectorySeed> >(seedProducer);
 
   edm::InputTag stripClusterInputTag_ = conf_.getParameter<edm::InputTag>("stripCluster");
   edm::InputTag pixelClusterInputTag_ = conf_.getParameter<edm::InputTag>("pixelCluster");
   stripClustersToken_ = mayConsume<edmNew::DetSetVector<SiStripCluster> > (stripClusterInputTag_);
   pixelClustersToken_ = mayConsume<edmNew::DetSetVector<SiPixelCluster> > (pixelClusterInputTag_);
 
   doFractionPlot_ = true;
   if (alltrackProducer.label()==trackProducer.label()) doFractionPlot_ = false;
   
   Quality_  = conf_.getParameter<std::string>("Quality");
   AlgoName_ = conf_.getParameter<std::string>("AlgoName");
   
 
   if ( doPUmonitoring_ ) {
     
     // get flag from the configuration
     doPlotsVsBXlumi_   = conf_.getParameter<bool>("doPlotsVsBXlumi");
     doPlotsVsGoodPVtx_ = conf_.getParameter<bool>("doPlotsVsGoodPVtx");
     
     if ( doPlotsVsBXlumi_ )
       theLumiDetails_ = new GetLumi( iConfig.getParameter<edm::ParameterSet>("BXlumiSetup"), c );
     
     std::vector<edm::InputTag> primaryVertexInputTags    = conf_.getParameter<std::vector<edm::InputTag> >("primaryVertexInputTags");
     std::vector<edm::InputTag> selPrimaryVertexInputTags = conf_.getParameter<std::vector<edm::InputTag> >("selPrimaryVertexInputTags");
     std::vector<std::string>   pvLabels                  = conf_.getParameter<std::vector<std::string> >  ("pvLabels");
      
     if (primaryVertexInputTags.size()==pvLabels.size() and primaryVertexInputTags.size()==selPrimaryVertexInputTags.size()) {
       //      for (auto const& tag : primaryVertexInputTags) {
       for (size_t i=0; i<primaryVertexInputTags.size(); i++) {
     edm::InputTag iPVinputTag    = primaryVertexInputTags[i];
     edm::InputTag iSelPVinputTag = selPrimaryVertexInputTags[i];
     std::string   iPVlabel       = pvLabels[i];
     
     theVertexMonitor.push_back(new VertexMonitor(conf_,iPVinputTag,iSelPVinputTag,iPVlabel,c) );
       }
     }
   }
   
 }

TrackingMonitor::~TrackingMonitor ( )

Definition at line 134 of file TrackingMonitor.cc.

References doPUmonitoring_, genTriggerEventFlag_, i, theTrackAnalyzer, theTrackBuildingAnalyzer, and theVertexMonitor.

 {
   if (theTrackAnalyzer)          delete theTrackAnalyzer;
   if (theTrackBuildingAnalyzer)  delete theTrackBuildingAnalyzer;
   if ( doPUmonitoring_ )
     for (size_t i=0; i<theVertexMonitor.size(); i++)
       if (theVertexMonitor[i]) delete theVertexMonitor[i];
   if (genTriggerEventFlag_)      delete genTriggerEventFlag_;
 }

Member Function Documentation

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

virtual

Implements edm::EDAnalyzer.

Definition at line 471 of file TrackingMonitor.cc.

References GenericTriggerEventFlag::accept(), allTrackToken_, TrackBuildingAnalyzer::analyze(), TrackAnalyzer::analyze(), bsSrcToken_, builderName, ClusterLabels, doAllPlots, doAllSeedPlots, doFractionPlot_, doGeneralPropertiesPlots_, doLumiAnalysis, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doProfilesVsLS_, doPUmonitoring_, doSeedLumiAnalysis_, doSeedNumberPlot, doSeedVsClusterPlot, doTkCandPlots, doTrackerSpecific_, MonitorElement::Fill(), HcalObjRepresent::Fill(), cropTnPTrees::frac, FractionOfGoodTracks, genTriggerEventFlag_, edm::EventSetup::get(), edm::Event::getByToken(), GetLumi::getValue(), GoodTracksFractionVsLS, i, edm::EventBase::id(), edm::HandleBase::isValid(), edm::EventID::luminosityBlock(), NumberOfMeanLayersPerTrack, NumberOfMeanRecHitsPerTrack, NumberOfRecHitsPerTrackVsLS, NumberOfSeeds, NumberOfSeeds_lumiFlag, NumberOfTrackCandidates, NumberOfTracks, NumberOfTracks_lumiFlag, NumberOfTracksVsBXlumi, NumberOfTracksVsGoodPVtx, NumberOfTracksVsLS, NumberOfTrkVsClusters, GenericTriggerEventFlag::on(), pvSrcToken_, runTrackBuildingAnalyzerForSeed, SeedsVsClusters, seedToken_, setNclus(), edm::View< T >::size(), theLumiDetails_, theTrackAnalyzer, theTrackBuildingAnalyzer, theTTRHBuilder, theVertexMonitor, trackCandidateToken_, and trackToken_.

 {
     // Filter out events if Trigger Filtering is requested
     if (genTriggerEventFlag_->on()&& ! genTriggerEventFlag_->accept( iEvent, iSetup) ) return;
 
     //  Analyse the tracks
     //  if the collection is empty, do not fill anything
     // ---------------------------------------------------------------------------------//
 
     // get the track collection
     edm::Handle<reco::TrackCollection> trackHandle;
     iEvent.getByToken(trackToken_, trackHandle);
 
     int numberOfAllTracks = 0;
     edm::Handle<reco::TrackCollection> allTrackHandle;
     iEvent.getByToken(allTrackToken_,allTrackHandle);
     if (allTrackHandle.isValid()) {
       numberOfAllTracks = allTrackHandle->size();
     }
       
     if (trackHandle.isValid()) {
       
       int numberOfTracks = trackHandle->size();
 
       reco::TrackCollection trackCollection = *trackHandle;
       // calculate the mean # rechits and layers
       int totalRecHits = 0, totalLayers = 0;
       
       for (reco::TrackCollection::const_iterator track = trackCollection.begin();
        track!=trackCollection.end(); ++track) {
     
     if ( doProfilesVsLS_ || doAllPlots)
       NumberOfRecHitsPerTrackVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),track->recHitsSize());
 
     totalRecHits    += track->numberOfValidHits();
     totalLayers     += track->hitPattern().trackerLayersWithMeasurement();
     
     // do analysis per track
     theTrackAnalyzer->analyze(iEvent, iSetup, *track);
       }
 
       double frac = -1.;
       if (numberOfAllTracks > 0) frac = static_cast<double>(numberOfTracks)/static_cast<double>(numberOfAllTracks);
       
       if (doGeneralPropertiesPlots_ || doAllPlots){
     NumberOfTracks       -> Fill(numberOfTracks);
     if (doFractionPlot_)
       FractionOfGoodTracks -> Fill(frac);
 
     if( numberOfTracks > 0 ) {
       double meanRecHits = static_cast<double>(totalRecHits) / static_cast<double>(numberOfTracks);
       double meanLayers  = static_cast<double>(totalLayers)  / static_cast<double>(numberOfTracks);
       NumberOfMeanRecHitsPerTrack -> Fill(meanRecHits);
       NumberOfMeanLayersPerTrack  -> Fill(meanLayers);
     }
       }
       
       if ( doProfilesVsLS_ || doAllPlots) {
     NumberOfTracksVsLS    ->Fill(static_cast<double>(iEvent.id().luminosityBlock()),numberOfTracks);
     if (doFractionPlot_) 
       GoodTracksFractionVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),frac);
       }
       
       if ( doLumiAnalysis ) {
     NumberOfTracks_lumiFlag       -> Fill(numberOfTracks);
       }
       
       
       //  Analyse the Track Building variables 
       //  if the collection is empty, do not fill anything
       // ---------------------------------------------------------------------------------//
       
       
       // fill the TrackCandidate info
       if (doTkCandPlots) {
     // magnetic field
     edm::ESHandle<MagneticField> theMF;
     iSetup.get<IdealMagneticFieldRecord>().get(theMF);  
     
     // get the candidate collection
     edm::Handle<TrackCandidateCollection> theTCHandle;
     iEvent.getByToken( trackCandidateToken_, theTCHandle );
     const TrackCandidateCollection& theTCCollection = *theTCHandle;
     
     if (theTCHandle.isValid()) {
       
       // get the beam spot
       edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
       iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle );
       const reco::BeamSpot& bs = *recoBeamSpotHandle;      
       
       NumberOfTrackCandidates->Fill(theTCCollection.size());
       iSetup.get<TransientRecHitRecord>().get(builderName,theTTRHBuilder);
       for( TrackCandidateCollection::const_iterator cand = theTCCollection.begin(); cand != theTCCollection.end(); ++cand) {
         
         theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *cand, bs, theMF, theTTRHBuilder);
       }
     } else {
       edm::LogWarning("TrackingMonitor") << "No Track Candidates in the event.  Not filling associated histograms";
     }
       }
       
       //plots for trajectory seeds
       
       if (doAllSeedPlots || doSeedNumberPlot || doSeedVsClusterPlot || runTrackBuildingAnalyzerForSeed) {
     
     // get the seed collection
     edm::Handle<edm::View<TrajectorySeed> > seedHandle;
     iEvent.getByToken(seedToken_, seedHandle );
     const edm::View<TrajectorySeed>& seedCollection = *seedHandle;
     
     // fill the seed info
     if (seedHandle.isValid()) {
       
       if(doAllSeedPlots || doSeedNumberPlot) {
         NumberOfSeeds->Fill(seedCollection.size());
         if ( doSeedLumiAnalysis_ )
           NumberOfSeeds_lumiFlag->Fill(seedCollection.size());             
       }
       
       if(doAllSeedPlots || doSeedVsClusterPlot){
         
         std::vector<int> NClus;
         setNclus(iEvent,NClus);
         for (uint  i=0; i< ClusterLabels.size(); i++){
           SeedsVsClusters[i]->Fill(NClus[i],seedCollection.size());
         }
       }
       
       if (doAllSeedPlots || runTrackBuildingAnalyzerForSeed){
         
         //here duplication of mag field and be informations is needed to allow seed and track cand histos to be independent
         // magnetic field
         edm::ESHandle<MagneticField> theMF;
         iSetup.get<IdealMagneticFieldRecord>().get(theMF);  
         
         // get the beam spot
         edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
         iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle );
         const reco::BeamSpot& bs = *recoBeamSpotHandle;      
         
         iSetup.get<TransientRecHitRecord>().get(builderName,theTTRHBuilder);
         for(size_t i=0; i < seedHandle->size(); ++i) {
           
           edm::RefToBase<TrajectorySeed> seed(seedHandle, i);
           theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *seed, bs, theMF, theTTRHBuilder);
         }
       }
       
     } else {
       edm::LogWarning("TrackingMonitor") << "No Trajectory seeds in the event.  Not filling associated histograms";
     }
       }
       
       
       if (doTrackerSpecific_ || doAllPlots) {
     
     std::vector<int> NClus;
     setNclus(iEvent,NClus);
     for (uint  i=0; i< ClusterLabels.size(); i++) {
       NumberOfTrkVsClusters[i]->Fill(NClus[i],numberOfTracks);
     }
       }
       
       if ( doPUmonitoring_ ) {
     
     // do vertex monitoring
     for (size_t i=0; i<theVertexMonitor.size(); i++)
       theVertexMonitor[i]->analyze(iEvent, iSetup);
     
     if ( doPlotsVsGoodPVtx_ ) {
       
       size_t totalNumGoodPV = 0;
       edm::Handle< reco::VertexCollection > pvHandle;
       iEvent.getByToken(pvSrcToken_, pvHandle );
       if (pvHandle.isValid()) {
         
         for (reco::VertexCollection::const_iterator pv = pvHandle->begin();
          pv != pvHandle->end(); ++pv) {
           
           //--- pv fake (the pv collection should have size==1 and the pv==beam spot) 
           if (pv->isFake() || pv->tracksSize()==0) continue;
           
           // definition of goodOfflinePrimaryVertex
           if (pv->ndof() < 4. || pv->z() > 24.)  continue;
           totalNumGoodPV++;
         }
         
         NumberOfTracksVsGoodPVtx       -> Fill( totalNumGoodPV, numberOfTracks      );
       }
     }
     
     if ( doPlotsVsBXlumi_ ) {
       double bxlumi = theLumiDetails_->getValue(iEvent);
       NumberOfTracksVsBXlumi       -> Fill( bxlumi, numberOfTracks      );
     }
     
       } // PU monitoring
       
     } // trackHandle is valid
     
 }

void TrackingMonitor::beginJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 145 of file TrackingMonitor.cc.

Referenced by beginRun().

 {
 
 }

void TrackingMonitor::beginLuminosityBlock	(	const edm::LuminosityBlock &	lumi,
		const edm::EventSetup &	eSetup
	)

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 457 of file TrackingMonitor.cc.

References doAllSeedPlots, doLumiAnalysis, TrackAnalyzer::doReset(), doSeedLumiAnalysis_, doSeedNumberPlot, dqmStore_, NumberOfSeeds_lumiFlag, NumberOfTracks_lumiFlag, MonitorElement::Reset(), HcalObjRepresent::Reset(), and theTrackAnalyzer.

                                                                                                        {
 
   if (doLumiAnalysis) {
     if ( NumberOfTracks_lumiFlag ) NumberOfTracks_lumiFlag -> Reset();
     theTrackAnalyzer->doReset(dqmStore_);    
   }
   if(doAllSeedPlots || doSeedNumberPlot) {
     if ( doSeedLumiAnalysis_ )
       NumberOfSeeds_lumiFlag->Reset();
   }
 }

void TrackingMonitor::beginRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 153 of file TrackingMonitor.cc.

References AlgoName_, beginJob(), TrackAnalyzer::beginRun(), TrackBuildingAnalyzer::beginRun(), DQMStore::book1D(), DQMStore::book2D(), DQMStore::bookProfile(), ClusterLabels, compare_using_db::compare, conf_, doAllPlots, doAllSeedPlots, doFractionPlot_, doGeneralPropertiesPlots_, doLumiAnalysis, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doProfilesVsLS_, doPUmonitoring_, doSeedLumiAnalysis_, doSeedNumberPlot, doSeedVsClusterPlot, doTkCandPlots, doTrackerSpecific_, dqmStore_, FractionOfGoodTracks, genTriggerEventFlag_, edm::ParameterSet::getParameter(), MonitorElement::getTH1(), GoodTracksFractionVsLS, histname, i, GenericTriggerEventFlag::initRun(), edm::InputTag::label(), NumberOfMeanLayersPerTrack, NumberOfMeanRecHitsPerTrack, NumberOfRecHitsPerTrackVsLS, NumberOfSeeds, NumberOfSeeds_lumiFlag, NumberOfTrackCandidates, NumberOfTracks, NumberOfTracks_lumiFlag, NumberOfTracksVsBXlumi, NumberOfTracksVsGoodPVtx, NumberOfTracksVsLS, NumberOfTrkVsClusters, GenericTriggerEventFlag::on(), Quality_, runTrackBuildingAnalyzerForSeed, SeedsVsClusters, MonitorElement::setAxisTitle(), DQMStore::setCurrentFolder(), TrackAnalyzer::setLumiFlag(), MonitorElement::setLumiFlag(), setMaxMinBin(), AlCaHLTBitMon_QueryRunRegistry::string, theTrackAnalyzer, theTrackBuildingAnalyzer, theVertexMonitor, and indexGen::title.

 {
   
    // parameters from the configuration
    std::string Quality      = conf_.getParameter<std::string>("Quality");
    std::string AlgoName     = conf_.getParameter<std::string>("AlgoName");
    std::string MEFolderName = conf_.getParameter<std::string>("FolderName"); 
 
    // test for the Quality veriable validity
    if( Quality_ != "") {
      if( Quality_ != "highPurity" && Quality_ != "tight" && Quality_ != "loose") {
        edm::LogWarning("TrackingMonitor")  << "Qualty Name is invalid, using no quality criterea by default";
        Quality_ = "";
      }
    }
 
    // use the AlgoName and Quality Name
    std::string CategoryName = Quality_ != "" ? AlgoName_ + "_" + Quality_ : AlgoName_;
 
    // get binning from the configuration
    int    TKNoBin     = conf_.getParameter<int>(   "TkSizeBin");
    double TKNoMin     = conf_.getParameter<double>("TkSizeMin");
    double TKNoMax     = conf_.getParameter<double>("TkSizeMax");
 
    int    TCNoBin     = conf_.getParameter<int>(   "TCSizeBin");
    double TCNoMin     = conf_.getParameter<double>("TCSizeMin");
    double TCNoMax     = conf_.getParameter<double>("TCSizeMax");
 
    int    TKNoSeedBin = conf_.getParameter<int>(   "TkSeedSizeBin");
    double TKNoSeedMin = conf_.getParameter<double>("TkSeedSizeMin");
    double TKNoSeedMax = conf_.getParameter<double>("TkSeedSizeMax");
 
    int    MeanHitBin  = conf_.getParameter<int>(   "MeanHitBin");
    double MeanHitMin  = conf_.getParameter<double>("MeanHitMin");
    double MeanHitMax  = conf_.getParameter<double>("MeanHitMax");
 
    int    MeanLayBin  = conf_.getParameter<int>(   "MeanLayBin");
    double MeanLayMin  = conf_.getParameter<double>("MeanLayMin");
    double MeanLayMax  = conf_.getParameter<double>("MeanLayMax");
 
    int LSBin = conf_.getParameter<int>(   "LSBin");
    int LSMin = conf_.getParameter<double>("LSMin");
    int LSMax = conf_.getParameter<double>("LSMax");
 
    std::string StateName = conf_.getParameter<std::string>("MeasurementState");
    if (
        StateName != "OuterSurface" &&
        StateName != "InnerSurface" &&
        StateName != "ImpactPoint"  &&
        StateName != "default"      &&
        StateName != "All"
        ) {
      // print warning
      edm::LogWarning("TrackingMonitor")  << "State Name is invalid, using 'ImpactPoint' by default";
    }
 
    dqmStore_->setCurrentFolder(MEFolderName);
 
    // book the General Property histograms
    // ---------------------------------------------------------------------------------//
 
    if (doGeneralPropertiesPlots_ || doAllPlots){
   
      dqmStore_->setCurrentFolder(MEFolderName+"/GeneralProperties");
 
      histname = "NumberOfTracks_" + CategoryName;
        // MODIFY by Mia in order to cope w/ high multiplicity
      NumberOfTracks = dqmStore_->book1D(histname, histname, 3*TKNoBin, TKNoMin, (TKNoMax+0.5)*3.-0.5);
      NumberOfTracks->setAxisTitle("Number of Tracks per Event", 1);
      NumberOfTracks->setAxisTitle("Number of Events", 2);
   
      histname = "NumberOfMeanRecHitsPerTrack_" + CategoryName;
      NumberOfMeanRecHitsPerTrack = dqmStore_->book1D(histname, histname, MeanHitBin, MeanHitMin, MeanHitMax);
      NumberOfMeanRecHitsPerTrack->setAxisTitle("Mean number of valid RecHits per Track", 1);
      NumberOfMeanRecHitsPerTrack->setAxisTitle("Entries", 2);
   
      histname = "NumberOfMeanLayersPerTrack_" + CategoryName;
      NumberOfMeanLayersPerTrack = dqmStore_->book1D(histname, histname, MeanLayBin, MeanLayMin, MeanLayMax);
      NumberOfMeanLayersPerTrack->setAxisTitle("Mean number of Layers per Track", 1);
      NumberOfMeanLayersPerTrack->setAxisTitle("Entries", 2);
   
      if (doFractionPlot_) {
        histname = "FractionOfGoodTracks_" + CategoryName;
        FractionOfGoodTracks = dqmStore_->book1D(histname, histname, 101, -0.005, 1.005);
        FractionOfGoodTracks->setAxisTitle("Fraction of Tracks (w.r.t. generalTracks)", 1);
        FractionOfGoodTracks->setAxisTitle("Entries", 2);
      }
    }
 
    if ( doLumiAnalysis ) {
      // add by Mia in order to deal with LS transitions
      dqmStore_->setCurrentFolder(MEFolderName+"/LSanalysis");
   
      histname = "NumberOfTracks_lumiFlag_" + CategoryName;
      NumberOfTracks_lumiFlag = dqmStore_->book1D(histname, histname, 3*TKNoBin, TKNoMin, (TKNoMax+0.5)*3.-0.5);
      NumberOfTracks_lumiFlag->setAxisTitle("Number of Tracks per Event", 1);
      NumberOfTracks_lumiFlag->setAxisTitle("Number of Events", 2);
   
    }
 
    // book profile plots vs LS :  
    //---------------------------  
 
 
    if ( doProfilesVsLS_ || doAllPlots) {
   
      dqmStore_->setCurrentFolder(MEFolderName+"/GeneralProperties");
   
      histname = "NumberOfTracksVsLS_"+ CategoryName;
      NumberOfTracksVsLS = dqmStore_->bookProfile(histname,histname, LSBin,LSMin,LSMax, TKNoMin, (TKNoMax+0.5)*3.-0.5,"");
      NumberOfTracksVsLS->getTH1()->SetBit(TH1::kCanRebin);
      NumberOfTracksVsLS->setAxisTitle("#Lumi section",1);
      NumberOfTracksVsLS->setAxisTitle("Number of  Tracks",2);
   
      histname = "NumberOfRecHitsPerTrackVsLS_" + CategoryName;
      NumberOfRecHitsPerTrackVsLS = dqmStore_->bookProfile(histname,histname, LSBin,LSMin,LSMax,0.,40.,"");
      NumberOfRecHitsPerTrackVsLS->getTH1()->SetBit(TH1::kCanRebin);
      NumberOfRecHitsPerTrackVsLS->setAxisTitle("#Lumi section",1);
      NumberOfRecHitsPerTrackVsLS->setAxisTitle("Mean number of RecHits per track",2);
   
      if (doFractionPlot_) {
        histname = "GoodTracksFractionVsLS_"+ CategoryName;
        GoodTracksFractionVsLS = dqmStore_->bookProfile(histname,histname, LSBin,LSMin,LSMax,0,1.1,"");
        GoodTracksFractionVsLS->getTH1()->SetBit(TH1::kCanRebin);
        GoodTracksFractionVsLS->setAxisTitle("#Lumi section",1);
        GoodTracksFractionVsLS->setAxisTitle("Fraction of Good Tracks",2);
      }
    }
 
    // book PU monitoring plots :  
    //---------------------------  
 
    if ( doPUmonitoring_ ) {
   
      for (size_t i=0; i<theVertexMonitor.size(); i++)
        theVertexMonitor[i]->beginJob(dqmStore_);
   
      dqmStore_->setCurrentFolder(MEFolderName+"/PUmonitoring");
   
      if ( doPlotsVsGoodPVtx_ ) {
        // get binning from the configuration
        int    GoodPVtxBin   = conf_.getParameter<int>("GoodPVtxBin");
        double GoodPVtxMin   = conf_.getParameter<double>("GoodPVtxMin");
        double GoodPVtxMax   = conf_.getParameter<double>("GoodPVtxMax");
     
        histname = "NumberOfTracksVsGoodPVtx";
        NumberOfTracksVsGoodPVtx = dqmStore_->bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,TKNoMin, (TKNoMax+0.5)*3.-0.5,"");
        NumberOfTracksVsGoodPVtx->getTH1()->SetBit(TH1::kCanRebin);
        NumberOfTracksVsGoodPVtx->setAxisTitle("Number of PV",1);
        NumberOfTracksVsGoodPVtx->setAxisTitle("Mean number of Tracks per Event",2);
     
      }
   
      if ( doPlotsVsBXlumi_ ) {
        // get binning from the configuration
        edm::ParameterSet BXlumiParameters = conf_.getParameter<edm::ParameterSet>("BXlumiSetup");
        int    BXlumiBin   = BXlumiParameters.getParameter<int>("BXlumiBin");
        double BXlumiMin   = BXlumiParameters.getParameter<double>("BXlumiMin");
        double BXlumiMax   = BXlumiParameters.getParameter<double>("BXlumiMax");
     
        histname = "NumberOfTracksVsBXlumi_"+ CategoryName;
        NumberOfTracksVsBXlumi = dqmStore_->bookProfile(histname,histname, BXlumiBin,BXlumiMin,BXlumiMax, TKNoMin, TKNoMax,"");
        NumberOfTracksVsBXlumi->getTH1()->SetBit(TH1::kCanRebin);
        NumberOfTracksVsBXlumi->setAxisTitle("lumi BX [10^{30}Hzcm^{-2}]",1);
        NumberOfTracksVsBXlumi->setAxisTitle("Mean number of Tracks",2);
     
      }
    }
 
    theTrackAnalyzer->beginRun(dqmStore_);
 
    // book the Seed Property histograms
    // ---------------------------------------------------------------------------------//
 
    dqmStore_->setCurrentFolder(MEFolderName+"/TrackBuilding");
 
    doAllSeedPlots      = conf_.getParameter<bool>("doSeedParameterHistos");
    doSeedNumberPlot    = conf_.getParameter<bool>("doSeedNumberHisto");
    doSeedLumiAnalysis_ = conf_.getParameter<bool>("doSeedLumiAnalysis");
    doSeedVsClusterPlot = conf_.getParameter<bool>("doSeedVsClusterHisto");
    //    if (doAllPlots) doAllSeedPlots=true;
 
    runTrackBuildingAnalyzerForSeed=(doAllSeedPlots || conf_.getParameter<bool>("doSeedPTHisto") ||conf_.getParameter<bool>("doSeedETAHisto") || conf_.getParameter<bool>("doSeedPHIHisto") || conf_.getParameter<bool>("doSeedPHIVsETAHisto") || conf_.getParameter<bool>("doSeedThetaHisto") || conf_.getParameter<bool>("doSeedQHisto") || conf_.getParameter<bool>("doSeedDxyHisto") || conf_.getParameter<bool>("doSeedDzHisto") || conf_.getParameter<bool>("doSeedNRecHitsHisto") || conf_.getParameter<bool>("doSeedNVsPhiProf")|| conf_.getParameter<bool>("doSeedNVsEtaProf"));
 
    edm::InputTag seedProducer   = conf_.getParameter<edm::InputTag>("SeedProducer");
 
    if (doAllSeedPlots || doSeedNumberPlot){
      dqmStore_->setCurrentFolder(MEFolderName+"/TrackBuilding");
      histname = "NumberOfSeeds_"+ seedProducer.label() + "_"+ CategoryName;
      NumberOfSeeds = dqmStore_->book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
      NumberOfSeeds->setAxisTitle("Number of Seeds per Event", 1);
      NumberOfSeeds->setAxisTitle("Number of Events", 2);
      
      if ( doSeedLumiAnalysis_ ) {
        dqmStore_->setCurrentFolder(MEFolderName+"/LSanalysis");
        histname = "NumberOfSeeds_lumiFlag_"+ seedProducer.label() + "_"+ CategoryName;
        NumberOfSeeds_lumiFlag = dqmStore_->book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
        NumberOfSeeds_lumiFlag->setAxisTitle("Number of Seeds per Event", 1);
        NumberOfSeeds_lumiFlag->setAxisTitle("Number of Events", 2);
      }
 
    }
 
    if (doAllSeedPlots || doSeedVsClusterPlot){
      dqmStore_->setCurrentFolder(MEFolderName+"/TrackBuilding");
 
      ClusterLabels=  conf_.getParameter<std::vector<std::string> >("ClusterLabels");
   
      std::vector<double> histoMin,histoMax;
      std::vector<int> histoBin; //these vectors are for max min and nbins in histograms 
   
      int    NClusPxBin = conf_.getParameter<int>(   "NClusPxBin");
      double NClusPxMin = conf_.getParameter<double>("NClusPxMin");
      double NClusPxMax = conf_.getParameter<double>("NClusPxMax");
   
      int    NClusStrBin = conf_.getParameter<int>(   "NClusStrBin");
      double NClusStrMin = conf_.getParameter<double>("NClusStrMin");
      double NClusStrMax = conf_.getParameter<double>("NClusStrMax");
   
      setMaxMinBin(histoMin,histoMax,histoBin,NClusStrMin,NClusStrMax,NClusStrBin,NClusPxMin,NClusPxMax,NClusPxBin);
   
      for (uint i=0; i<ClusterLabels.size(); i++){
        histname = "SeedsVsClusters_" + seedProducer.label() + "_Vs_" + ClusterLabels[i] + "_" + CategoryName;
        SeedsVsClusters.push_back(dynamic_cast<MonitorElement*>(dqmStore_->book2D(histname, histname, histoBin[i], histoMin[i], histoMax[i],
                                          TKNoSeedBin, TKNoSeedMin, TKNoSeedMax)));
        SeedsVsClusters[i]->setAxisTitle("Number of Clusters", 1);
        SeedsVsClusters[i]->setAxisTitle("Number of Seeds", 2);
      }
    }
   
    doTkCandPlots=conf_.getParameter<bool>("doTrackCandHistos");
   //    if (doAllPlots) doTkCandPlots=true;
   
   if (doTkCandPlots){
     dqmStore_->setCurrentFolder(MEFolderName+"/TrackBuilding");
     
     edm::InputTag tcProducer     = conf_.getParameter<edm::InputTag>("TCProducer");
     
     histname = "NumberOfTrackCandidates_"+ tcProducer.label() + "_"+ CategoryName;
     NumberOfTrackCandidates = dqmStore_->book1D(histname, histname, TCNoBin, TCNoMin, TCNoMax);
     NumberOfTrackCandidates->setAxisTitle("Number of Track Candidates per Event", 1);
     NumberOfTrackCandidates->setAxisTitle("Number of Event", 2);
   }
   
   theTrackBuildingAnalyzer->beginRun(dqmStore_);
   
   
   if (doLumiAnalysis) {
     if ( NumberOfTracks_lumiFlag ) NumberOfTracks_lumiFlag -> setLumiFlag();
     theTrackAnalyzer->setLumiFlag();    
   }
 
   if(doAllSeedPlots || doSeedNumberPlot){
     if ( doSeedLumiAnalysis_ )
       NumberOfSeeds_lumiFlag->setLumiFlag();
   }
   
   if (doTrackerSpecific_ || doAllPlots) {
     
     ClusterLabels=  conf_.getParameter<std::vector<std::string> >("ClusterLabels");
     
     std::vector<double> histoMin,histoMax;
     std::vector<int> histoBin; //these vectors are for max min and nbins in histograms 
     
     int    NClusStrBin = conf_.getParameter<int>(   "NClusStrBin");
     double NClusStrMin = conf_.getParameter<double>("NClusStrMin");
     double NClusStrMax = conf_.getParameter<double>("NClusStrMax");
     
     int    NClusPxBin = conf_.getParameter<int>(   "NClusPxBin");
     double NClusPxMin = conf_.getParameter<double>("NClusPxMin");
     double NClusPxMax = conf_.getParameter<double>("NClusPxMax");
     
     int    NTrk2DBin     = conf_.getParameter<int>(   "NTrk2DBin");
     double NTrk2DMin     = conf_.getParameter<double>("NTrk2DMin");
     double NTrk2DMax     = conf_.getParameter<double>("NTrk2DMax");
     
     setMaxMinBin(histoMin,histoMax,histoBin,
          NClusStrMin,NClusStrMax,NClusStrBin,
          NClusPxMin,  NClusPxMax,  NClusPxBin);
     
     dqmStore_->setCurrentFolder(MEFolderName+"/HitProperties");
     
     for (uint i=0; i<ClusterLabels.size(); i++){
       
       dqmStore_->setCurrentFolder(MEFolderName+"/HitProperties");
       histname = "TracksVs" + ClusterLabels[i] + "Cluster_" + CategoryName;
       NumberOfTrkVsClusters.push_back(dynamic_cast<MonitorElement*>(dqmStore_->book2D(histname, histname,
                                               histoBin[i], histoMin[i], histoMax[i],
                                               NTrk2DBin,NTrk2DMin,NTrk2DMax
                                               )));
       std::string title = "Number of " + ClusterLabels[i] + " Clusters";
       if(ClusterLabels[i].compare("Tot")==0)
     title = "# of Clusters in (Pixel+Strip) Detectors";
       NumberOfTrkVsClusters[i]->setAxisTitle(title, 1);
       NumberOfTrkVsClusters[i]->setAxisTitle("Number of Tracks", 2);
     }
   }
   
   // Initialize the GenericTriggerEventFlag
   if ( genTriggerEventFlag_->on() ) genTriggerEventFlag_->initRun( iRun, iSetup );
 }

void TrackingMonitor::doProfileX	(	TH2 *	th2,
		MonitorElement *	me
	)

private

void TrackingMonitor::doProfileX	(	MonitorElement *	th2m,
		MonitorElement *	me
	)

private

void TrackingMonitor::endJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 679 of file TrackingMonitor.cc.

References conf_, dqmStore_, edm::ParameterSet::getParameter(), dumpDBToFile_GT_ttrig_cfg::outputFileName, DQMStore::save(), DQMStore::showDirStructure(), and AlCaHLTBitMon_QueryRunRegistry::string.

 {
     bool outputMEsInRootFile   = conf_.getParameter<bool>("OutputMEsInRootFile");
     std::string outputFileName = conf_.getParameter<std::string>("OutputFileName");
     if(outputMEsInRootFile)
     {
         dqmStore_->showDirStructure();
         dqmStore_->save(outputFileName);
     }
 }

void TrackingMonitor::endRun	(	const edm::Run &	,
		const edm::EventSetup &
	)

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 675 of file TrackingMonitor.cc.

676 {

677 }

void TrackingMonitor::setMaxMinBin	(	std::vector< double > &	arrayMin,
		std::vector< double > &	arrayMax,
		std::vector< int > &	arrayBin,
		double	smin,
		double	smax,
		int	sbin,
		double	pmin,
		double	pmax,
		int	pbin
	)

virtual

Definition at line 690 of file TrackingMonitor.cc.

References ClusterLabels, compare_using_db::compare, and i.

Referenced by beginRun().

 {
   arrayMin.resize(ClusterLabels.size());
   arrayMax.resize(ClusterLabels.size());
   arrayBin.resize(ClusterLabels.size());
 
   for (uint i=0; i<ClusterLabels.size(); ++i) {
 
     if     (ClusterLabels[i].compare("Pix")==0  ) {arrayMin[i]=pmin; arrayMax[i]=pmax;      arrayBin[i]=pbin;}
     else if(ClusterLabels[i].compare("Strip")==0) {arrayMin[i]=smin; arrayMax[i]=smax;      arrayBin[i]=sbin;}
     else if(ClusterLabels[i].compare("Tot")==0  ) {arrayMin[i]=smin; arrayMax[i]=smax+pmax; arrayBin[i]=sbin;}
     else {edm::LogWarning("TrackingMonitor")  << "Cluster Label " << ClusterLabels[i] << " not defined, using strip parameters "; 
       arrayMin[i]=smin; arrayMax[i]=smax; arrayBin[i]=sbin;}
 
   }
     
 }

void TrackingMonitor::setNclus	(	const edm::Event &	iEvent,
		std::vector< int > &	arrayNclus
	)

virtual

Definition at line 708 of file TrackingMonitor.cc.

References ClusterLabels, compare_using_db::compare, edm::Event::getByToken(), i, edm::HandleBase::isValid(), pixelClustersToken_, and stripClustersToken_.

Referenced by analyze().

 {
 
   int ncluster_pix=-1;
   int ncluster_strip=-1;
 
   edm::Handle< edmNew::DetSetVector<SiStripCluster> > strip_clusters;
   iEvent.getByToken(stripClustersToken_, strip_clusters );
   edm::Handle< edmNew::DetSetVector<SiPixelCluster> > pixel_clusters;
   iEvent.getByToken(pixelClustersToken_, pixel_clusters );
 
   if (strip_clusters.isValid() && pixel_clusters.isValid()) {
     ncluster_pix   = (*pixel_clusters).dataSize(); 
     ncluster_strip = (*strip_clusters).dataSize(); 
   }
 
   arrayNclus.resize(ClusterLabels.size());
   for (uint i=0; i<ClusterLabels.size(); ++i){
     
     if     (ClusterLabels[i].compare("Pix")==0  ) arrayNclus[i]=ncluster_pix ;
     else if(ClusterLabels[i].compare("Strip")==0) arrayNclus[i]=ncluster_strip;
     else if(ClusterLabels[i].compare("Tot")==0  ) arrayNclus[i]=ncluster_pix+ncluster_strip;
     else {edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i] << " not defined using stri parametrs ";
       arrayNclus[i]=ncluster_strip ;}
   }
     
 }