TrackingMonitor Class Reference

#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)
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
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 DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final
virtual void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer (void)
virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
uint32_t	streamId () const
Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::stream::EDAnalyzerBase
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDAnalyzerBase ()
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
void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) 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_
StringCutObjectSelector < reco::Track, true >	denSelection_
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_
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
StringCutObjectSelector < reco::Track, true >	numSelection_
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::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T...>	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType
Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)
static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)
static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *, dqmDetails::NoCache *)
static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *, dqmDetails::NoCache *)
Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
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 47 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_, EnergyCorrector::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_.

    : 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()))
    , numSelection_       (conf_.getParameter<std::string>("numCut"))
    , denSelection_       (conf_.getParameter<std::string>("denCut"))
{

  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 135 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::stream::EDAnalyzerBase.

Definition at line 481 of file TrackingMonitor.cc.

References GenericTriggerEventFlag::accept(), allTrackToken_, TrackAnalyzer::analyze(), TrackBuildingAnalyzer::analyze(), bsSrcToken_, builderName, ClusterLabels, denSelection_, 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, numSelection_, GenericTriggerEventFlag::on(), MetAnalyzer::pv(), pvSrcToken_, runTrackBuildingAnalyzerForSeed, fileCollector::seed, 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;
    int numberOfTracks_den = 0;
    edm::Handle<reco::TrackCollection> allTrackHandle;
    iEvent.getByToken(allTrackToken_,allTrackHandle);
    if (allTrackHandle.isValid()) {
      //      numberOfAllTracks = allTrackHandle->size();
      for (reco::TrackCollection::const_iterator track = allTrackHandle->begin();
       track!=allTrackHandle->end(); ++track) {
    if ( denSelection_(*track) )
      numberOfTracks_den++;
      }
    }
      
    if (trackHandle.isValid()) {
      
      int numberOfTracks = trackHandle->size();
      int numberOfTracks_num = 0;

      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 ( numSelection_(*track) )
      numberOfTracks_num++;

    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 (numberOfTracks_den > 0) frac = static_cast<double>(numberOfTracks_num)/static_cast<double>(numberOfTracks_den);
      
      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

Definition at line 146 of file TrackingMonitor.cc.

{

    
}

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

virtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 467 of file TrackingMonitor.cc.

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

                                                                                                       {

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

void TrackingMonitor::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  iRun, edm::EventSetup const &  iSetup  )

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 152 of file TrackingMonitor.cc.

References AlgoName_, DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), ClusterLabels, compare_using_db::compare, conf_, doAllPlots, doAllSeedPlots, doFractionPlot_, doGeneralPropertiesPlots_, doLumiAnalysis, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doProfilesVsLS_, doPUmonitoring_, doSeedLumiAnalysis_, doSeedNumberPlot, doSeedVsClusterPlot, doTkCandPlots, doTrackerSpecific_, FractionOfGoodTracks, genTriggerEventFlag_, edm::ParameterSet::getParameter(), MonitorElement::getTH1(), GoodTracksFractionVsLS, histname, i, TrackAnalyzer::initHisto(), TrackBuildingAnalyzer::initHisto(), 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::IBooker::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";
   }

   ibooker.setCurrentFolder(MEFolderName);

   // book the General Property histograms
   // ---------------------------------------------------------------------------------//

   if (doGeneralPropertiesPlots_ || doAllPlots){
  
     ibooker.setCurrentFolder(MEFolderName+"/GeneralProperties");

     histname = "NumberOfTracks_" + CategoryName;
       // MODIFY by Mia in order to cope w/ high multiplicity
     NumberOfTracks = ibooker.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 = ibooker.book1D(histname, histname, MeanHitBin, MeanHitMin, MeanHitMax);
     NumberOfMeanRecHitsPerTrack->setAxisTitle("Mean number of valid RecHits per Track", 1);
     NumberOfMeanRecHitsPerTrack->setAxisTitle("Entries", 2);
  
     histname = "NumberOfMeanLayersPerTrack_" + CategoryName;
     NumberOfMeanLayersPerTrack = ibooker.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 = ibooker.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
     ibooker.setCurrentFolder(MEFolderName+"/LSanalysis");
  
     histname = "NumberOfTracks_lumiFlag_" + CategoryName;
     NumberOfTracks_lumiFlag = ibooker.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) {
  
     ibooker.setCurrentFolder(MEFolderName+"/GeneralProperties");
  
     histname = "NumberOfTracksVsLS_"+ CategoryName;
     NumberOfTracksVsLS = ibooker.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 = ibooker.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 = ibooker.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]->initHisto(ibooker);
  
     ibooker.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 = ibooker.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 = ibooker.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->initHisto(ibooker);

   // book the Seed Property histograms
   // ---------------------------------------------------------------------------------//

   ibooker.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){
     ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
     histname = "NumberOfSeeds_"+ seedProducer.label() + "_"+ CategoryName;
     NumberOfSeeds = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
     NumberOfSeeds->setAxisTitle("Number of Seeds per Event", 1);
     NumberOfSeeds->setAxisTitle("Number of Events", 2);
     
     if ( doSeedLumiAnalysis_ ) {
       ibooker.setCurrentFolder(MEFolderName+"/LSanalysis");
       histname = "NumberOfSeeds_lumiFlag_"+ seedProducer.label() + "_"+ CategoryName;
       NumberOfSeeds_lumiFlag = ibooker.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){
     ibooker.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*>(ibooker.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){
    ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
    
    edm::InputTag tcProducer     = conf_.getParameter<edm::InputTag>("TCProducer");
    
    histname = "NumberOfTrackCandidates_"+ tcProducer.label() + "_"+ CategoryName;
    NumberOfTrackCandidates = ibooker.book1D(histname, histname, TCNoBin, TCNoMin, TCNoMax);
    NumberOfTrackCandidates->setAxisTitle("Number of Track Candidates per Event", 1);
    NumberOfTrackCandidates->setAxisTitle("Number of Event", 2);
  }
  
  theTrackBuildingAnalyzer->initHisto(ibooker);
  
  
  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);
    
    ibooker.setCurrentFolder(MEFolderName+"/HitProperties");
    
    for (uint i=0; i<ClusterLabels.size(); i++){
      
      ibooker.setCurrentFolder(MEFolderName+"/HitProperties");
      histname = "TracksVs" + ClusterLabels[i] + "Cluster_" + CategoryName;
      NumberOfTrkVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.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::endRun ( const edm::Run &  , const edm::EventSetup &    )

virtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 697 of file TrackingMonitor.cc.

{
}

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 701 of file TrackingMonitor.cc.

References ClusterLabels, compare_using_db::compare, and i.

Referenced by bookHistograms().

{
  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 719 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 ;}
  }
    
}

Member Data Documentation

std::string TrackingMonitor::AlgoName_

private

Definition at line 93 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

edm::EDGetTokenT<reco::TrackCollection> TrackingMonitor::allTrackToken_

private

Definition at line 82 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

edm::InputTag TrackingMonitor::bsSrc_

private

Definition at line 77 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

edm::EDGetTokenT<reco::BeamSpot> TrackingMonitor::bsSrcToken_

private

Definition at line 79 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

std::string TrackingMonitor::builderName

private

Definition at line 137 of file TrackingMonitor.h.

Referenced by analyze().

std::vector<std::string> TrackingMonitor::ClusterLabels

private

Definition at line 113 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), setMaxMinBin(), and setNclus().

edm::ParameterSet TrackingMonitor::conf_

private

Definition at line 74 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

StringCutObjectSelector<reco::Track,true> TrackingMonitor::denSelection_

private

Definition at line 162 of file TrackingMonitor.h.

Referenced by analyze().

bool TrackingMonitor::doAllPlots

private

Definition at line 144 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doAllSeedPlots

private

Definition at line 143 of file TrackingMonitor.h.

Referenced by analyze(), beginLuminosityBlock(), and bookHistograms().

bool TrackingMonitor::doDCAPlots_

private

Definition at line 145 of file TrackingMonitor.h.

bool TrackingMonitor::doFractionPlot_

private

Definition at line 157 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

bool TrackingMonitor::doGeneralPropertiesPlots_

private

Definition at line 146 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doHitPropertiesPlots_

private

Definition at line 147 of file TrackingMonitor.h.

bool TrackingMonitor::doLumiAnalysis

private

Definition at line 141 of file TrackingMonitor.h.

Referenced by analyze(), beginLuminosityBlock(), and bookHistograms().

bool TrackingMonitor::doPlotsVsBXlumi_

private

Definition at line 155 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

bool TrackingMonitor::doPlotsVsGoodPVtx_

private

Definition at line 156 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

bool TrackingMonitor::doProfilesVsLS_

private

Definition at line 142 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doPUmonitoring_

private

Definition at line 154 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), TrackingMonitor(), and ~TrackingMonitor().

bool TrackingMonitor::doSeedLumiAnalysis_

private

Definition at line 150 of file TrackingMonitor.h.

Referenced by analyze(), beginLuminosityBlock(), and bookHistograms().

bool TrackingMonitor::doSeedNumberPlot

private

Definition at line 149 of file TrackingMonitor.h.

Referenced by analyze(), beginLuminosityBlock(), and bookHistograms().

bool TrackingMonitor::doSeedVsClusterPlot

private

Definition at line 151 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doTkCandPlots

private

Definition at line 148 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doTrackerSpecific_

private

Definition at line 140 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::FractionOfGoodTracks

private

Definition at line 107 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

GenericTriggerEventFlag* TrackingMonitor::genTriggerEventFlag_

private

Definition at line 159 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and ~TrackingMonitor().

MonitorElement* TrackingMonitor::GoodTracksFractionVsLS

private

Definition at line 127 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

std::string TrackingMonitor::histname

private

Definition at line 70 of file TrackingMonitor.h.

Referenced by bookHistograms().

MonitorElement* TrackingMonitor::NumberOfMeanLayersPerTrack

private

Definition at line 104 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfMeanRecHitsPerTrack

private

Definition at line 103 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsLS

private

Definition at line 128 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfSeeds

private

Definition at line 110 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfSeeds_lumiFlag

private

Definition at line 111 of file TrackingMonitor.h.

Referenced by analyze(), beginLuminosityBlock(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrackCandidates

private

Definition at line 117 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracks

private

Definition at line 102 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracks_lumiFlag

private

Definition at line 135 of file TrackingMonitor.h.

Referenced by analyze(), beginLuminosityBlock(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsBXlumi

private

Definition at line 132 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsGoodPVtx

private

Definition at line 131 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsLS

private

Definition at line 126 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrkVsClus

private

Definition at line 121 of file TrackingMonitor.h.

std::vector<MonitorElement*> TrackingMonitor::NumberOfTrkVsClusters

private

Definition at line 120 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrkVsPixelClus

private

Definition at line 123 of file TrackingMonitor.h.

MonitorElement* TrackingMonitor::NumberOfTrkVsStripClus

private

Definition at line 122 of file TrackingMonitor.h.

StringCutObjectSelector<reco::Track,true> TrackingMonitor::numSelection_

private

Definition at line 161 of file TrackingMonitor.h.

Referenced by analyze().

edm::InputTag TrackingMonitor::pixelClusterInputTag_

private

Definition at line 88 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 90 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

edm::InputTag TrackingMonitor::pvSrc_

private

Definition at line 78 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

edm::EDGetTokenT<reco::VertexCollection> TrackingMonitor::pvSrcToken_

private

Definition at line 80 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

std::string TrackingMonitor::Quality_

private

Definition at line 92 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

bool TrackingMonitor::runTrackBuildingAnalyzerForSeed

private

Definition at line 152 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

std::vector<MonitorElement *> TrackingMonitor::SeedsVsClusters

private

Definition at line 112 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

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

private

Definition at line 85 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

edm::InputTag TrackingMonitor::stripClusterInputTag_

private

Definition at line 87 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 89 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

GetLumi* TrackingMonitor::theLumiDetails_

private

Definition at line 99 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

TrackAnalyzer* TrackingMonitor::theTrackAnalyzer

private

Definition at line 96 of file TrackingMonitor.h.

Referenced by analyze(), beginLuminosityBlock(), bookHistograms(), TrackingMonitor(), and ~TrackingMonitor().

TrackBuildingAnalyzer* TrackingMonitor::theTrackBuildingAnalyzer

private

Definition at line 97 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and ~TrackingMonitor().

edm::ESHandle<TransientTrackingRecHitBuilder> TrackingMonitor::theTTRHBuilder

private

Definition at line 138 of file TrackingMonitor.h.

Referenced by analyze().

std::vector<VertexMonitor*> TrackingMonitor::theVertexMonitor

private

Definition at line 98 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), TrackingMonitor(), and ~TrackingMonitor().

edm::EDGetTokenT<TrackCandidateCollection> TrackingMonitor::trackCandidateToken_

private

Definition at line 84 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

edm::EDGetTokenT<reco::TrackCollection> TrackingMonitor::trackToken_

private

Definition at line 83 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().