#include <trackCount/TrackCount/src/TrackCount.cc>

Inheritance diagram for TrackCount:

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

	~TrackCount () override

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

Private Attributes
const bool	m_2dhistos

TH1F *	m_chisq

TH1F *	m_chisqnorm

TH2F *	m_chisqnormvseta

TH2F *	m_chisqvseta

const bool	m_dump

TH1D *	m_halgo

TH1F *	m_hcos

TH1F *	m_heta

TH1F *	m_hhpfrac

TProfile2D *	m_hnhitphieta

TProfile2D *	m_hnlayerphieta

TH1D *	m_hnlayers

TH1D *	m_hnlosthits

TH1D *	m_hnlostlayers

TH1D *	m_hnpixellayers

TH1D *	m_hnpixelrhits

TH1D *	m_hnrhits

TH1D *	m_hnstriplayers

TH1D *	m_hnstriprhits

TH1F *	m_hphi

TH2D *	m_hphieta

TH1F *	m_hpt

TProfile2D *	m_hptphieta

TH1F *	m_hsqsumptsq

const unsigned int	m_LSfrac

edm::EDGetTokenT< LumiDetails >	m_lumiProducerToken

const unsigned int	m_maxLS

TH1F *	m_ndof

TH2F *	m_ndofvseta

TH1F *	m_nhptrk

const unsigned int	m_nptbin

TH1F *	m_ntrk

TProfile *	m_ntrkvslumi

TH2D *	m_ntrkvslumi2D

TProfile **	m_ntrkvsorbrun

const double	m_ptmax

const double	m_ptmin

RunHistogramManager	m_rhm

const bool	m_runHisto

edm::EDGetTokenT< reco::TrackCollection >	m_trkcollToken

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 64 of file TrackCount.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 132 of file TrackCount.cc.

References reco::TrackBase::algoSize, muonTiming_cfi::etamax, muonTiming_cfi::etamin, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), label, m_2dhistos, m_chisq, m_chisqnorm, m_chisqnormvseta, m_chisqvseta, m_halgo, m_hcos, m_heta, m_hhpfrac, m_hnhitphieta, m_hnlayerphieta, m_hnlayers, m_hnlosthits, m_hnlostlayers, m_hnpixellayers, m_hnpixelrhits, m_hnrhits, m_hnstriplayers, m_hnstriprhits, m_hphi, m_hphieta, m_hpt, m_hptphieta, m_hsqsumptsq, m_LSfrac, m_maxLS, m_ndof, m_ndofvseta, m_nhptrk, m_nptbin, m_ntrk, m_ntrkvslumi, m_ntrkvslumi2D, m_ntrkvsorbrun, M_PI, m_ptmax, m_ptmin, m_rhm, m_runHisto, TFileService::make(), and RunHistogramManager::makeTProfile().

     : m_rhm(consumesCollector()),
       m_maxLS(100),
       m_LSfrac(16),
       m_2dhistos(iConfig.getUntrackedParameter<bool>("wanted2DHistos", false)),
       m_runHisto(iConfig.getUntrackedParameter<bool>("runHisto", false)),
       m_dump(iConfig.getUntrackedParameter<bool>("dumpTracks", false)),
       m_trkcollToken(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("trackCollection"))),
       m_lumiProducerToken(consumes<LumiDetails, edm::InLumi>(edm::InputTag("lumiProducer"))),
       m_nptbin(iConfig.getUntrackedParameter<unsigned int>("numberPtBins", 200)),
       m_ptmin(iConfig.getUntrackedParameter<double>("ptMin", 0.)),
       m_ptmax(iConfig.getUntrackedParameter<double>("ptMax", 20.))
 
 {
   //now do what ever initialization is needed
 
   // histogram parameters
 
   const unsigned int netabin1d = iConfig.getUntrackedParameter<unsigned int>("netabin1D", 120);
   const unsigned int netabin2d = iConfig.getUntrackedParameter<unsigned int>("netabin2D", 40);
   const float etamin = iConfig.getUntrackedParameter<double>("etaMin", -3.);
   const float etamax = iConfig.getUntrackedParameter<double>("etaMax", 3.);
   const unsigned int nchisqbin1d = iConfig.getUntrackedParameter<unsigned int>("nchi2bin1D", 50);
   const unsigned int nndofbin1d = iConfig.getUntrackedParameter<unsigned int>("nndofbin1D", 50);
   const unsigned int nchisqbin2d = iConfig.getUntrackedParameter<unsigned int>("nchi2bin2D", 50);
   const unsigned int nndofbin2d = iConfig.getUntrackedParameter<unsigned int>("nndofbin2D", 50);
 
   edm::LogInfo("TrackCollection") << "Using collection "
                                   << iConfig.getParameter<edm::InputTag>("trackCollection").label().c_str();
 
   edm::Service<TFileService> tfserv;
 
   m_ntrk = tfserv->make<TH1F>("ntrk", "Number of Tracks", 2500, -0.5, 2499.5);
   m_ntrk->GetXaxis()->SetTitle("Tracks");
   m_ntrk->GetYaxis()->SetTitle("Events");
   m_ntrkvslumi = tfserv->make<TProfile>("ntrkvslumi", "Number of Tracks vs Luminosity", 250, 0., 10.);
   m_ntrkvslumi->GetXaxis()->SetTitle("BX lumi [10^{30}cm^{-2}s^{-1}]");
   m_ntrkvslumi->GetYaxis()->SetTitle("Ntracks");
   m_ntrkvslumi2D = tfserv->make<TH2D>("ntrkvslumi2D", "Number of Tracks vs Luminosity", 80, 0., 10., 125, -0.5, 2499.5);
   m_ntrkvslumi2D->GetXaxis()->SetTitle("BX lumi [10^{30}cm^{-2}s^{-1}]");
   m_ntrkvslumi2D->GetYaxis()->SetTitle("Ntracks");
 
   m_nhptrk = tfserv->make<TH1F>("nhptrk", "Number of High Purity Tracks", 2500, -0.5, 2499.5);
   m_nhptrk->GetXaxis()->SetTitle("Tracks");
   m_nhptrk->GetYaxis()->SetTitle("Events");
   m_hhpfrac = tfserv->make<TH1F>("hhpfrac", "Fraction of High Purity Tracks", 51, 0., 1.02);
   m_hhpfrac->GetXaxis()->SetTitle("hp/all");
   m_hhpfrac->GetYaxis()->SetTitle("Events");
   m_hsqsumptsq = tfserv->make<TH1F>("hsqsumptsq", "Sqrt(Sum pt**2)", 1000, 0., 200.);
   m_hsqsumptsq->GetXaxis()->SetTitle("#sqrt(#Sigma pt^2) (GeV)");
   m_hsqsumptsq->GetYaxis()->SetTitle("Events");
 
   m_hphi = tfserv->make<TH1F>("phi", "Track azimuth", 40, -M_PI, M_PI);
   m_hphi->GetXaxis()->SetTitle("#phi (rad)");
   m_hphi->GetYaxis()->SetTitle("Tracks");
   m_heta = tfserv->make<TH1F>("eta", "Track pseudorapidity", netabin1d, etamin, etamax);
   m_heta->GetXaxis()->SetTitle("#eta");
   m_heta->GetYaxis()->SetTitle("Tracks");
   m_hcos = tfserv->make<TH1F>("cos", "Track polar angle", 50, -1., 1.);
   m_hcos->GetXaxis()->SetTitle("cos(#theta)");
   m_hcos->GetYaxis()->SetTitle("Tracks");
   m_hpt = tfserv->make<TH1F>("pt", "Track pt", m_nptbin, m_ptmin, m_ptmax);
   m_hpt->GetXaxis()->SetTitle("pt (GeV)");
   m_hpt->GetYaxis()->SetTitle("Tracks");
 
   m_chisq = tfserv->make<TH1F>("chisq", "Track Chi2", nchisqbin1d, 0., 100.);
   m_chisq->GetXaxis()->SetTitle("chi2");
   m_chisq->GetYaxis()->SetTitle("Tracks");
   m_chisqnorm = tfserv->make<TH1F>("chisqnorm", "Track normalized Chi2", nchisqbin1d, 0., 10.);
   m_chisqnorm->GetXaxis()->SetTitle("normalized chi2");
   m_chisqnorm->GetYaxis()->SetTitle("Tracks");
   m_ndof = tfserv->make<TH1F>("ndof", "Track ndof", nndofbin1d, 0., 100.);
   m_ndof->GetXaxis()->SetTitle("ndof");
   m_ndof->GetYaxis()->SetTitle("Tracks");
   if (m_2dhistos) {
     m_chisqvseta =
         tfserv->make<TH2F>("chisqvseta", "Track Chi2 vs #eta", netabin2d, etamin, etamax, nchisqbin2d, 0., 100.);
     m_chisqvseta->GetXaxis()->SetTitle("#eta");
     m_chisqvseta->GetYaxis()->SetTitle("#chi2");
     m_chisqnormvseta = tfserv->make<TH2F>(
         "chisqnormvseta", "Track normalized Chi2 vs #eta", netabin2d, etamin, etamax, nchisqbin2d, 0., 10.);
     m_chisqnormvseta->GetXaxis()->SetTitle("#eta");
     m_chisqnormvseta->GetYaxis()->SetTitle("normalized #chi2");
     m_ndofvseta =
         tfserv->make<TH2F>("ndofvseta", "Track ndof vs #eta", netabin2d, etamin, etamax, nndofbin2d, 0., 100.);
     m_ndofvseta->GetXaxis()->SetTitle("#eta");
     m_ndofvseta->GetYaxis()->SetTitle("ndof");
   }
 
   m_hptphieta =
       tfserv->make<TProfile2D>("ptphivseta", "Average pt vs #phi vs #eta", netabin2d, etamin, etamax, 40, -M_PI, M_PI);
   m_hptphieta->GetXaxis()->SetTitle("#eta");
   m_hptphieta->GetYaxis()->SetTitle("#phi");
 
   m_hnlosthits = tfserv->make<TH1D>("nlosthits", "Number of Lost Hits", 10, -0.5, 9.5);
   m_hnlosthits->GetXaxis()->SetTitle("Nlost");
   m_hnlosthits->GetYaxis()->SetTitle("Tracks");
 
   m_hnrhits = tfserv->make<TH1D>("nrhits", "Number of Valid Hits", 55, -0.5, 54.5);
   m_hnrhits->GetXaxis()->SetTitle("Nvalid");
   m_hnrhits->GetYaxis()->SetTitle("Tracks");
   m_hnpixelrhits = tfserv->make<TH1D>("npixelrhits", "Number of Valid Pixel Hits", 20, -0.5, 19.5);
   m_hnpixelrhits->GetXaxis()->SetTitle("Nvalid");
   m_hnpixelrhits->GetYaxis()->SetTitle("Tracks");
   m_hnstriprhits = tfserv->make<TH1D>("nstriprhits", "Number of Valid Strip Hits", 45, -0.5, 44.5);
   m_hnstriprhits->GetXaxis()->SetTitle("Nvalid");
   m_hnstriprhits->GetYaxis()->SetTitle("Tracks");
 
   m_hnlostlayers = tfserv->make<TH1D>("nlostlayers", "Number of Layers w/o measurement", 10, -0.5, 9.5);
   m_hnlostlayers->GetXaxis()->SetTitle("Nlostlay");
   m_hnlostlayers->GetYaxis()->SetTitle("Tracks");
 
   m_hnlayers = tfserv->make<TH1D>("nlayers", "Number of Layers", 20, -0.5, 19.5);
   m_hnlayers->GetXaxis()->SetTitle("Nlayers");
   m_hnlayers->GetYaxis()->SetTitle("Tracks");
   m_hnpixellayers = tfserv->make<TH1D>("npixellayers", "Number of Pixel Layers", 10, -0.5, 9.5);
   m_hnpixellayers->GetXaxis()->SetTitle("Nlayers");
   m_hnpixellayers->GetYaxis()->SetTitle("Tracks");
   m_hnstriplayers = tfserv->make<TH1D>("nstriplayers", "Number of Strip Layers", 20, -0.5, 19.5);
   m_hnstriplayers->GetXaxis()->SetTitle("Nlayers");
   m_hnstriplayers->GetYaxis()->SetTitle("Tracks");
 
   m_hnhitphieta = tfserv->make<TProfile2D>(
       "nhitphivseta", "N valid hits vs #phi vs #eta", netabin2d, etamin, etamax, 40, -M_PI, M_PI);
   m_hnhitphieta->GetXaxis()->SetTitle("#eta");
   m_hnhitphieta->GetYaxis()->SetTitle("#phi");
   m_hnlayerphieta = tfserv->make<TProfile2D>(
       "nlayerphivseta", "N layers vs #phi vs #eta", netabin2d, etamin, etamax, 40, -M_PI, M_PI);
   m_hnlayerphieta->GetXaxis()->SetTitle("#eta");
   m_hnlayerphieta->GetYaxis()->SetTitle("#phi");
 
   m_halgo =
       tfserv->make<TH1D>("algo", "Algorithm number", reco::TrackBase::algoSize, -0.5, reco::TrackBase::algoSize - 0.5);
   m_halgo->GetXaxis()->SetTitle("algorithm");
   m_halgo->GetYaxis()->SetTitle("Tracks");
   m_hphieta = tfserv->make<TH2D>("phivseta", "#phi vs #eta", netabin2d, etamin, etamax, 40, -M_PI, M_PI);
   m_hphieta->GetXaxis()->SetTitle("#eta");
   m_hphieta->GetYaxis()->SetTitle("#phi");
 
   if (m_runHisto) {
     m_ntrkvsorbrun =
         m_rhm.makeTProfile("ntrkvsorbrun", "Number of tracks vs orbit number", m_maxLS * m_LSfrac, 0, m_maxLS * 262144);
   }
 }

TrackCount::~TrackCount ( )

override

Definition at line 277 of file TrackCount.cc.

                         {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

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

overrideprivate

Definition at line 287 of file TrackCount.cc.

References edm::EventBase::bunchCrossing(), edm::LuminosityBlock::getByToken(), edm::Event::getByToken(), edm::Event::getLuminosityBlock(), LumiDetails::isValid(), edm::HandleBase::isValid(), LumiDetails::kOCC1, LumiDetails::lumiValue(), m_2dhistos, m_chisq, m_chisqnorm, m_chisqnormvseta, m_chisqvseta, m_dump, m_halgo, m_hcos, m_heta, m_hhpfrac, m_hnhitphieta, m_hnlayerphieta, m_hnlayers, m_hnlosthits, m_hnlostlayers, m_hnpixellayers, m_hnpixelrhits, m_hnrhits, m_hnstriplayers, m_hnstriprhits, m_hphi, m_hphieta, m_hpt, m_hptphieta, m_hsqsumptsq, m_lumiProducerToken, m_ndof, m_ndofvseta, m_nhptrk, m_ntrk, m_ntrkvslumi, m_ntrkvslumi2D, m_ntrkvsorbrun, m_runHisto, m_trkcollToken, edm::EventBase::orbitNumber(), DiDispStaMuonMonitor_cfi::pt, qcdUeDQM_cfi::quality, reco::TrackBase::qualityByName(), mathSSE::sqrt(), reco::HitPattern::TRACK_HITS, and PDWG_EXOHSCP_cff::tracks.

                                                                             {
   using namespace edm;
   edm::Service<TFileService> tfserv;
 
   Handle<reco::TrackCollection> tracks;
   iEvent.getByToken(m_trkcollToken, tracks);
 
   //
 
   m_ntrk->Fill(tracks->size());
 
   // get luminosity
 
   edm::Handle<LumiDetails> ld;
   iEvent.getLuminosityBlock().getByToken(m_lumiProducerToken, ld);
 
   if (ld.isValid()) {
     if (ld->isValid()) {
       float lumi = ld->lumiValue(LumiDetails::kOCC1, iEvent.bunchCrossing()) * 6.37;
       m_ntrkvslumi->Fill(lumi, tracks->size());
       m_ntrkvslumi2D->Fill(lumi, tracks->size());
     }
   }
 
   if (m_runHisto) {
     if (m_ntrkvsorbrun && *m_ntrkvsorbrun)
       (*m_ntrkvsorbrun)->Fill(iEvent.orbitNumber(), tracks->size());
   }
 
   unsigned int nhptrk = 0;
   double sumptsq = 0.;
 
   reco::TrackBase::TrackQuality quality = reco::TrackBase::qualityByName("highPurity");
 
   if (m_dump)
     edm::LogInfo("TrackDump") << " isHP algo pt eta phi chi2N chi2 ndof nlay npxl n3dl nlost ";
 
   for (reco::TrackCollection::const_iterator it = tracks->begin(); it != tracks->end(); it++) {
     if (m_dump) {
       edm::LogVerbatim("TrackDump") << it->quality(quality) << " " << it->algo() << " " << it->pt() << " " << it->eta()
                                     << " " << it->phi() << " " << it->normalizedChi2() << " " << it->chi2() << " "
                                     << it->ndof() << " " << it->hitPattern().trackerLayersWithMeasurement() << " "
                                     << it->hitPattern().pixelLayersWithMeasurement() << " "
                                     << it->hitPattern().numberOfValidStripLayersWithMonoAndStereo() << " "
                                     << it->hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS)
                                     << " ";
     }
 
     m_hnlosthits->Fill(it->hitPattern().numberOfLostTrackerHits(reco::HitPattern::TRACK_HITS));
 
     m_hnrhits->Fill(it->hitPattern().numberOfValidTrackerHits());
     m_hnpixelrhits->Fill(it->hitPattern().numberOfValidPixelHits());
     m_hnstriprhits->Fill(it->hitPattern().numberOfValidStripHits());
     m_hnhitphieta->Fill(it->eta(), it->phi(), it->hitPattern().numberOfValidTrackerHits());
 
     m_hnlostlayers->Fill(it->hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS));
 
     m_hnlayers->Fill(it->hitPattern().trackerLayersWithMeasurement());
     m_hnpixellayers->Fill(it->hitPattern().pixelLayersWithMeasurement());
     m_hnstriplayers->Fill(it->hitPattern().stripLayersWithMeasurement());
     m_hnlayerphieta->Fill(it->eta(), it->phi(), it->hitPattern().trackerLayersWithMeasurement());
 
     m_halgo->Fill(it->algo());
 
     m_hphi->Fill(it->phi());
     m_heta->Fill(it->eta());
     m_hphieta->Fill(it->eta(), it->phi());
 
     double pt = it->pt();
     m_hpt->Fill(pt);
     m_chisq->Fill(it->chi2());
     m_chisqnorm->Fill(it->normalizedChi2());
     m_ndof->Fill(it->ndof());
     if (m_2dhistos) {
       m_chisqvseta->Fill(it->eta(), it->chi2());
       m_chisqnormvseta->Fill(it->eta(), it->normalizedChi2());
       m_ndofvseta->Fill(it->eta(), it->ndof());
     }
     m_hptphieta->Fill(it->eta(), it->phi(), pt);
     sumptsq += pt * pt;
     if (it->p())
       m_hcos->Fill(it->pz() / it->p());
     if (it->quality(quality))
       nhptrk++;
   }
 
   m_nhptrk->Fill(nhptrk);
 
   const double hpfrac = !tracks->empty() ? double(nhptrk) / double(tracks->size()) : 0.;
   m_hhpfrac->Fill(hpfrac);
   m_hsqsumptsq->Fill(sqrt(sumptsq));
 }

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

overrideprivate

Definition at line 380 of file TrackCount.cc.

References RunHistogramManager::beginRun(), DEFINE_FWK_MODULE, m_rhm, and m_runHisto.

                                                                   {
   m_rhm.beginRun(iRun);
 
   if (m_runHisto) {
     (*m_ntrkvsorbrun)->GetXaxis()->SetTitle("time [orbit#]");
     (*m_ntrkvsorbrun)->GetYaxis()->SetTitle("Ntracks");
     (*m_ntrkvsorbrun)->SetCanExtend(TH1::kXaxis);
   }
 }