#include <Alignment/OfflineValidation/plugins/SplitVertexResolution.cc>

Inheritance diagram for SplitVertexResolution:

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

	~SplitVertexResolution () override

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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

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

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

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (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::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

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)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

static bool	mysorter (reco::Track i, reco::Track j)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

virtual void	beginEvent () final

void	beginJob () override

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

std::vector< TH1F * >	bookResidualsHistogram (TFileDirectory dir, unsigned int theNOfBins, TString resType, TString varType)

template<std::size_t SIZE>
bool	checkBinOrdering (std::array< float, SIZE > &bins)

void	endJob () override

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

void	fillTrendPlotByIndex (TH1F trendPlot, std::vector< TH1F > &h, PVValHelper::estimator fitPar_)

statmode::fitParams	fitResiduals (TH1 *hist, bool singleTime=false)

statmode::fitParams	fitResiduals_v0 (TH1 *hist)

std::pair< long long, long long >	getRunTime (const edm::EventSetup &iSetup) const

Private Attributes
const int	compressionSettings_

bool	debug_

std::mt19937	engine_

pvEvent	event_

TH1D *	evtsByTrigger_

TH1F *	h_avgSumPt

TH1F *	h_diffX

TH1F *	h_diffY

TH1F *	h_diffZ

TH1F *	h_errX

TH1F *	h_errY

TH1F *	h_errZ

TH1F *	h_lumiFromConfig

TH1F *	h_minWTrks1

TH1F *	h_minWTrks2

TH1I *	h_nFinalVertices

TH1I *	h_nNonFakeVertices

TH1I *	h_nOfflineVertices

TH1F *	h_ntrks

TH1I *	h_nVertices

TH1F *	h_OrigVertexErrX

TH1F *	h_OrigVertexErrY

TH1F *	h_OrigVertexErrZ

TH1F *	h_pullX

std::vector< TH1F * >	h_pullX_Ntracks_

std::vector< TH1F * >	h_pullX_Nvtx_

std::vector< TH1F * >	h_pullX_sumPt_

TH1F *	h_pullY

std::vector< TH1F * >	h_pullY_Ntracks_

std::vector< TH1F * >	h_pullY_Nvtx_

std::vector< TH1F * >	h_pullY_sumPt_

TH1F *	h_pullZ

std::vector< TH1F * >	h_pullZ_Ntracks_

std::vector< TH1F * >	h_pullZ_Nvtx_

std::vector< TH1F * >	h_pullZ_sumPt_

TH1F *	h_PVCL_subVtx1

TH1F *	h_PVCL_subVtx2

std::vector< TH1F * >	h_resolX_Ntracks_

std::vector< TH1F * >	h_resolX_Nvtx_

std::vector< TH1F * >	h_resolX_sumPt_

std::vector< TH1F * >	h_resolY_Ntracks_

std::vector< TH1F * >	h_resolY_Nvtx_

std::vector< TH1F * >	h_resolY_sumPt_

std::vector< TH1F * >	h_resolZ_Ntracks_

std::vector< TH1F * >	h_resolZ_Nvtx_

std::vector< TH1F * >	h_resolZ_sumPt_

TH1I *	h_runEndTimes

TH1I *	h_runFromConfig

TH1F *	h_runNumber

TH1I *	h_runStartTimes

TH1F *	h_sumPt

TH1F *	h_sumPt1

TH1F *	h_sumPt2

TH1F *	h_wTrks1

TH1F *	h_wTrks2

int	ievt

double	intLumi_

int	itrks

double	minVtxNdf_

double	minVtxWgt_

std::array< float, nTrackBins_+1 >	myNTrack_bins_

std::array< float, nVtxBins_+1 >	myNVtx_bins_

std::array< float, nPtBins_+1 >	mypT_bins_ = PVValHelper::makeLogBins<float, nPtBins_>(1., 1e3)

edm::Service< TFileService >	outfile_

TH1F *	p_pullX_vsNtracks

TH1F *	p_pullX_vsNvtx

TH1F *	p_pullX_vsSumPt

TH1F *	p_pullY_vsNtracks

TH1F *	p_pullY_vsNvtx

TH1F *	p_pullY_vsSumPt

TH1F *	p_pullZ_vsNtracks

TH1F *	p_pullZ_vsNvtx

TH1F *	p_pullZ_vsSumPt

TH1F *	p_resolX_vsNtracks

TH1F *	p_resolX_vsNvtx

TH1F *	p_resolX_vsSumPt

TH1F *	p_resolY_vsNtracks

TH1F *	p_resolY_vsNvtx

TH1F *	p_resolY_vsSumPt

TH1F *	p_resolZ_vsNtracks

TH1F *	p_resolZ_vsNvtx

TH1F *	p_resolZ_vsSumPt

edm::InputTag	pvsTag_

edm::EDGetTokenT< reco::VertexCollection >	pvsToken_

bool	runControl_

std::vector< unsigned int >	runControlNumbers_

edm::ESGetToken< RunInfo, RunInfoRcd >	runInfoToken_

std::map< unsigned int, std::pair< long long, long long > >	runNumbersTimesLog_

bool	storeNtuple_

TH1D *	tksByTrigger_

edm::InputTag	tracksTag_

edm::EDGetTokenT< reco::TrackCollection >	tracksToken_

edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	transientTrackBuilderToken_

TTree *	tree_

std::map< std::string, std::pair< int, int > >	triggerMap_

edm::InputTag	triggerResultsTag_ = edm::InputTag("TriggerResults", "", "HLT")

edm::EDGetTokenT< edm::TriggerResults >	triggerResultsToken_

Static Private Attributes
static constexpr double	cmToUm = 10000.

static const int	nPtBins_ = 30

static const int	nTrackBins_ = 60

static const int	nVtxBins_ = 40

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

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

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 75 of file SplitVertexResolution.cc.

Constructor & Destructor Documentation

◆ SplitVertexResolution()

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

explicit

Definition at line 263 of file SplitVertexResolution.cc.

     : compressionSettings_(iConfig.getUntrackedParameter<int>("compressionSettings", -1)),
       storeNtuple_(iConfig.getParameter<bool>("storeNtuple")),
       intLumi_(iConfig.getUntrackedParameter<double>("intLumi", 0.)),
       debug_(iConfig.getUntrackedParameter<bool>("Debug", false)),
       pvsTag_(iConfig.getParameter<edm::InputTag>("vtxCollection")),
       pvsToken_(consumes<reco::VertexCollection>(pvsTag_)),
       tracksTag_(iConfig.getParameter<edm::InputTag>("trackCollection")),
       tracksToken_(consumes<reco::TrackCollection>(tracksTag_)),
       triggerResultsToken_(consumes<edm::TriggerResults>(triggerResultsTag_)),
       transientTrackBuilderToken_(
           esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"))),
       runInfoToken_(esConsumes<RunInfo, RunInfoRcd, edm::Transition::BeginRun>()),
       minVtxNdf_(iConfig.getUntrackedParameter<double>("minVertexNdf")),
       minVtxWgt_(iConfig.getUntrackedParameter<double>("minVertexMeanWeight")),
       runControl_(iConfig.getUntrackedParameter<bool>("runControl", false)) {
   usesResource(TFileService::kSharedResource);
  
   std::vector<unsigned int> defaultRuns;
   defaultRuns.push_back(0);
   runControlNumbers_ = iConfig.getUntrackedParameter<std::vector<unsigned int> >("runControlNumber", defaultRuns);
  
   std::vector<float> vect = PVValHelper::generateBins(nTrackBins_ + 1, -0.5, 120.);
   std::copy(vect.begin(), vect.begin() + nTrackBins_ + 1, myNTrack_bins_.begin());
  
   vect.clear();
   vect = PVValHelper::generateBins(nVtxBins_ + 1, 1., 40.);
   std::copy(vect.begin(), vect.begin() + nVtxBins_ + 1, myNVtx_bins_.begin());
 }

References filterCSVwithJSON::copy, PVValHelper::generateBins(), edm::ParameterSet::getUntrackedParameter(), TFileService::kSharedResource, myNTrack_bins_, myNVtx_bins_, nTrackBins_, nVtxBins_, and runControlNumbers_.

◆ ~SplitVertexResolution()

SplitVertexResolution::~SplitVertexResolution ( )

override

Definition at line 293 of file SplitVertexResolution.cc.

293 {}

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 296 of file SplitVertexResolution.cc.

                                                                                        {
   using namespace edm;
  
   // deterministic seed from the event number
   // should not bias the result as the event number is already
   // assigned randomly-enough
   engine_.seed(iEvent.id().event() + (iEvent.id().luminosityBlock() << 10) + (iEvent.id().run() << 20));
  
   // first check if the event passes the run control
   bool passesRunControl = false;
  
   if (runControl_) {
     for (const auto& runControlNumber : runControlNumbers_) {
       if (iEvent.eventAuxiliary().run() == runControlNumber) {
         if (debug_) {
           edm::LogInfo("SplitVertexResolution")
               << " run number: " << iEvent.eventAuxiliary().run() << " keeping run:" << runControlNumber;
         }
         passesRunControl = true;
         break;
       }
     }
     if (!passesRunControl)
       return;
   }
  
   // Fill general info
   h_runNumber->Fill(iEvent.id().run());
  
   ievt++;
   edm::Handle<edm::TriggerResults> hltresults;
   iEvent.getByToken(triggerResultsToken_, hltresults);
  
   const edm::TriggerNames& triggerNames_ = iEvent.triggerNames(*hltresults);
   int ntrigs = hltresults->size();
   //const std::vector<std::string>& triggernames = triggerNames_.triggerNames();
  
   beginEvent();
  
   // Fill general info
   event_.runNumber = iEvent.id().run();
   event_.luminosityBlockNumber = iEvent.id().luminosityBlock();
   event_.eventNumber = iEvent.id().event();
  
   TransientTrackBuilder const& theB = iSetup.getData(transientTrackBuilderToken_);
  
   edm::Handle<reco::VertexCollection> vertices;
   iEvent.getByToken(pvsToken_, vertices);
   const reco::VertexCollection pvtx = *(vertices.product());
  
   event_.nVtx = pvtx.size();
   int nOfflineVtx = pvtx.size();
   h_nOfflineVertices->Fill(nOfflineVtx);
  
   edm::Handle<reco::TrackCollection> tracks;
   iEvent.getByToken(tracksToken_, tracks);
   itrks += tracks.product()->size();
  
   for (int itrig = 0; itrig != ntrigs; ++itrig) {
     const std::string& trigName = triggerNames_.triggerName(itrig);
     bool accept = hltresults->accept(itrig);
     if (accept == 1) {
       triggerMap_[trigName].first += 1;
       triggerMap_[trigName].second += tracks.product()->size();
       // triggerInfo.push_back(pair <string, int> (trigName, accept));
     }
   }
  
   int counter = 0;
   int noFakecounter = 0;
   int goodcounter = 0;
  
   for (auto pvIt = pvtx.cbegin(); pvIt != pvtx.cend(); ++pvIt) {
     reco::Vertex iPV = *pvIt;
     counter++;
     if (iPV.isFake())
       continue;
     noFakecounter++;
  
     // vertex selection as in bs code
     if (iPV.ndof() < minVtxNdf_ || (iPV.ndof() + 3.) / iPV.tracksSize() < 2 * minVtxWgt_)
       continue;
  
     goodcounter++;
     reco::TrackCollection allTracks;
     reco::TrackCollection groupOne, groupTwo;
     for (auto trki = iPV.tracks_begin(); trki != iPV.tracks_end(); ++trki) {
       if (trki->isNonnull()) {
         reco::TrackRef trk_now(tracks, (*trki).key());
         allTracks.push_back(*trk_now);
       }
     }
  
     if (goodcounter > 1)
       continue;
  
     // order with decreasing pt
     std::sort(allTracks.begin(), allTracks.end(), mysorter);
  
     int ntrks = allTracks.size();
     h_ntrks->Fill(ntrks);
  
     // discard lowest pt track
     uint even_ntrks;
     ntrks % 2 == 0 ? even_ntrks = ntrks : even_ntrks = ntrks - 1;
  
     // split into two sets equally populated
     for (uint tracksIt = 0; tracksIt < even_ntrks; tracksIt = tracksIt + 2) {
       reco::Track firstTrk = allTracks.at(tracksIt);
       reco::Track secondTrk = allTracks.at(tracksIt + 1);
       auto dis = std::uniform_int_distribution<>(0, 1);  // [0, 1]
  
       if (dis(engine_) > 0.5) {
         groupOne.push_back(firstTrk);
         groupTwo.push_back(secondTrk);
       } else {
         groupOne.push_back(secondTrk);
         groupTwo.push_back(firstTrk);
       }
     }
  
     if (!(groupOne.size() >= 2 && groupTwo.size() >= 2))
       continue;
  
     h_OrigVertexErrX->Fill(iPV.xError() * cmToUm);
     h_OrigVertexErrY->Fill(iPV.yError() * cmToUm);
     h_OrigVertexErrZ->Fill(iPV.zError() * cmToUm);
  
     float sumPt = 0, sumPt1 = 0, sumPt2 = 0, avgSumPt = 0;
  
     // refit the two sets of tracks
     std::vector<reco::TransientTrack> groupOne_ttks;
     groupOne_ttks.clear();
     for (auto itrk = groupOne.cbegin(); itrk != groupOne.cend(); itrk++) {
       reco::TransientTrack tmpTransientTrack = theB.build(*itrk);
       groupOne_ttks.push_back(tmpTransientTrack);
       sumPt1 += itrk->pt();
       sumPt += itrk->pt();
     }
  
     AdaptiveVertexFitter pvFitter;
     TransientVertex pvOne = pvFitter.vertex(groupOne_ttks);
     if (!pvOne.isValid())
       continue;
  
     reco::Vertex onePV = pvOne;
  
     std::vector<reco::TransientTrack> groupTwo_ttks;
     groupTwo_ttks.clear();
     for (auto itrk = groupTwo.cbegin(); itrk != groupTwo.cend(); itrk++) {
       reco::TransientTrack tmpTransientTrack = theB.build(*itrk);
       groupTwo_ttks.push_back(tmpTransientTrack);
       sumPt2 += itrk->pt();
       sumPt += itrk->pt();
     }
  
     // average sumPt
     avgSumPt = (sumPt1 + sumPt2) / 2.;
     h_avgSumPt->Fill(avgSumPt);
  
     TransientVertex pvTwo = pvFitter.vertex(groupTwo_ttks);
     if (!pvTwo.isValid())
       continue;
  
     reco::Vertex twoPV = pvTwo;
  
     float theminW1 = 1.;
     float theminW2 = 1.;
     for (auto otrk = pvOne.originalTracks().cbegin(); otrk != pvOne.originalTracks().cend(); ++otrk) {
       h_wTrks1->Fill(pvOne.trackWeight(*otrk));
       if (pvOne.trackWeight(*otrk) < theminW1) {
         theminW1 = pvOne.trackWeight(*otrk);
       }
     }
     for (auto otrk = pvTwo.originalTracks().cbegin(); otrk != pvTwo.originalTracks().end(); ++otrk) {
       h_wTrks2->Fill(pvTwo.trackWeight(*otrk));
       if (pvTwo.trackWeight(*otrk) < theminW2) {
         theminW2 = pvTwo.trackWeight(*otrk);
       }
     }
  
     h_sumPt->Fill(sumPt);
  
     int half_trks = twoPV.nTracks();
  
     const double invSqrt2 = 1. / std::sqrt(2.);
  
     double deltaX = (twoPV.x() - onePV.x());
     double deltaY = (twoPV.y() - onePV.y());
     double deltaZ = (twoPV.z() - onePV.z());
  
     double resX = deltaX * invSqrt2;
     double resY = deltaY * invSqrt2;
     double resZ = deltaZ * invSqrt2;
  
     h_diffX->Fill(resX * cmToUm);
     h_diffY->Fill(resY * cmToUm);
     h_diffZ->Fill(resZ * cmToUm);
  
     double errX = sqrt(pow(twoPV.xError(), 2) + pow(onePV.xError(), 2));
     double errY = sqrt(pow(twoPV.yError(), 2) + pow(onePV.yError(), 2));
     double errZ = sqrt(pow(twoPV.zError(), 2) + pow(onePV.zError(), 2));
  
     h_errX->Fill(errX * cmToUm);
     h_errY->Fill(errY * cmToUm);
     h_errZ->Fill(errZ * cmToUm);
  
     h_pullX->Fill(deltaX / errX);
     h_pullY->Fill(deltaY / errY);
     h_pullZ->Fill(deltaZ / errZ);
  
     // filling the pT-binned distributions
  
     for (int ipTBin = 0; ipTBin < nPtBins_; ipTBin++) {
       float pTF = mypT_bins_[ipTBin];
       float pTL = mypT_bins_[ipTBin + 1];
  
       if (avgSumPt >= pTF && avgSumPt < pTL) {
         PVValHelper::fillByIndex(h_resolX_sumPt_, ipTBin, resX * cmToUm, "1");
         PVValHelper::fillByIndex(h_resolY_sumPt_, ipTBin, resY * cmToUm, "2");
         PVValHelper::fillByIndex(h_resolZ_sumPt_, ipTBin, resZ * cmToUm, "3");
  
         PVValHelper::fillByIndex(h_pullX_sumPt_, ipTBin, deltaX / errX, "4");
         PVValHelper::fillByIndex(h_pullY_sumPt_, ipTBin, deltaY / errY, "5");
         PVValHelper::fillByIndex(h_pullZ_sumPt_, ipTBin, deltaZ / errZ, "6");
       }
     }
  
     // filling the track multeplicity binned distributions
  
     for (int inTrackBin = 0; inTrackBin < nTrackBins_; inTrackBin++) {
       float nTrackF = myNTrack_bins_[inTrackBin];
       float nTrackL = myNTrack_bins_[inTrackBin + 1];
  
       if (ntrks >= nTrackF && ntrks < nTrackL) {
         PVValHelper::fillByIndex(h_resolX_Ntracks_, inTrackBin, resX * cmToUm, "7");
         PVValHelper::fillByIndex(h_resolY_Ntracks_, inTrackBin, resY * cmToUm, "8");
         PVValHelper::fillByIndex(h_resolZ_Ntracks_, inTrackBin, resZ * cmToUm, "9");
  
         PVValHelper::fillByIndex(h_pullX_Ntracks_, inTrackBin, deltaX / errX, "10");
         PVValHelper::fillByIndex(h_pullY_Ntracks_, inTrackBin, deltaY / errY, "11");
         PVValHelper::fillByIndex(h_pullZ_Ntracks_, inTrackBin, deltaZ / errZ, "12");
       }
     }
  
     // filling the vertex multeplicity binned distributions
  
     for (int inVtxBin = 0; inVtxBin < nVtxBins_; inVtxBin++) {
       /*
     float nVtxF = myNVtx_bins_[inVtxBin];
     float nVtxL = myNVtx_bins_[inVtxBin+1];
     if(nOfflineVtx >= nVtxF && nOfflineVtx < nVtxL){
       */
  
       if (nOfflineVtx == inVtxBin) {
         PVValHelper::fillByIndex(h_resolX_Nvtx_, inVtxBin, deltaX * cmToUm, "7");
         PVValHelper::fillByIndex(h_resolY_Nvtx_, inVtxBin, deltaY * cmToUm, "8");
         PVValHelper::fillByIndex(h_resolZ_Nvtx_, inVtxBin, deltaZ * cmToUm, "9");
  
         PVValHelper::fillByIndex(h_pullX_Nvtx_, inVtxBin, deltaX / errX, "10");
         PVValHelper::fillByIndex(h_pullY_Nvtx_, inVtxBin, deltaY / errY, "11");
         PVValHelper::fillByIndex(h_pullZ_Nvtx_, inVtxBin, deltaZ / errZ, "12");
       }
     }
  
     h_sumPt1->Fill(sumPt1);
     h_sumPt2->Fill(sumPt2);
  
     h_minWTrks1->Fill(theminW1);
     h_minWTrks2->Fill(theminW2);
  
     h_PVCL_subVtx1->Fill(TMath::Prob(pvOne.totalChiSquared(), (int)(pvOne.degreesOfFreedom())));
     h_PVCL_subVtx2->Fill(TMath::Prob(pvTwo.totalChiSquared(), (int)(pvTwo.degreesOfFreedom())));
  
     // fill ntuples
     pvCand thePV;
     thePV.ipos = counter;
     thePV.nTrks = ntrks;
  
     thePV.x_origVtx = iPV.x();
     thePV.y_origVtx = iPV.y();
     thePV.z_origVtx = iPV.z();
  
     thePV.xErr_origVtx = iPV.xError();
     thePV.yErr_origVtx = iPV.yError();
     thePV.zErr_origVtx = iPV.zError();
  
     thePV.n_subVtx1 = half_trks;
     thePV.x_subVtx1 = onePV.x();
     thePV.y_subVtx1 = onePV.y();
     thePV.z_subVtx1 = onePV.z();
  
     thePV.xErr_subVtx1 = onePV.xError();
     thePV.yErr_subVtx1 = onePV.yError();
     thePV.zErr_subVtx1 = onePV.zError();
     thePV.sumPt_subVtx1 = sumPt1;
  
     thePV.n_subVtx2 = half_trks;
     thePV.x_subVtx2 = twoPV.x();
     thePV.y_subVtx2 = twoPV.y();
     thePV.z_subVtx2 = twoPV.z();
  
     thePV.xErr_subVtx2 = twoPV.xError();
     thePV.yErr_subVtx2 = twoPV.yError();
     thePV.zErr_subVtx2 = twoPV.zError();
     thePV.sumPt_subVtx2 = sumPt2;
  
     thePV.CL_subVtx1 = TMath::Prob(pvOne.totalChiSquared(), (int)(pvOne.degreesOfFreedom()));
     thePV.CL_subVtx2 = TMath::Prob(pvTwo.totalChiSquared(), (int)(pvTwo.degreesOfFreedom()));
  
     thePV.minW_subVtx1 = theminW1;
     thePV.minW_subVtx2 = theminW2;
  
     event_.pvs.push_back(thePV);
  
   }  // loop on the vertices
  
   // fill the histogram of vertices per event
   h_nVertices->Fill(counter);
   h_nNonFakeVertices->Fill(noFakecounter);
   h_nFinalVertices->Fill(goodcounter);
  
   if (storeNtuple_) {
     tree_->Fill();
   }
 }

References accept(), muonTagProbeFilters_cff::allTracks, beginEvent(), TransientTrackBuilder::build(), pvCand::CL_subVtx1, pvCand::CL_subVtx2, cmToUm, counter, debug_, engine_, fftjetvertexadder_cfi::errX, fftjetvertexadder_cfi::errY, fftjetvertexadder_cfi::errZ, event_, pvEvent::eventNumber, PVValHelper::fillByIndex(), edm::EventSetup::getData(), h_avgSumPt, h_diffX, h_diffY, h_diffZ, h_errX, h_errY, h_errZ, h_minWTrks1, h_minWTrks2, h_nFinalVertices, h_nNonFakeVertices, h_nOfflineVertices, h_ntrks, h_nVertices, h_OrigVertexErrX, h_OrigVertexErrY, h_OrigVertexErrZ, h_pullX, h_pullX_Ntracks_, h_pullX_Nvtx_, h_pullX_sumPt_, h_pullY, h_pullY_Ntracks_, h_pullY_Nvtx_, h_pullY_sumPt_, h_pullZ, h_pullZ_Ntracks_, h_pullZ_Nvtx_, h_pullZ_sumPt_, h_PVCL_subVtx1, h_PVCL_subVtx2, h_resolX_Ntracks_, h_resolX_Nvtx_, h_resolX_sumPt_, h_resolY_Ntracks_, h_resolY_Nvtx_, h_resolY_sumPt_, h_resolZ_Ntracks_, h_resolZ_Nvtx_, h_resolZ_sumPt_, h_runNumber, h_sumPt, h_sumPt1, h_sumPt2, h_wTrks1, h_wTrks2, HLTBitAnalyser_cfi::hltresults, iEvent, ievt, createfilelist::int, pvCand::ipos, reco::Vertex::isFake(), TransientVertex::isValid(), itrks, pvEvent::luminosityBlockNumber, minVtxNdf_, minVtxWgt_, pvCand::minW_subVtx1, pvCand::minW_subVtx2, myNTrack_bins_, mypT_bins_, mysorter(), pvCand::n_subVtx1, pvCand::n_subVtx2, reco::Vertex::ndof(), nPtBins_, nTrackBins_, reco::Vertex::nTracks(), pvCand::nTrks, pvEvent::nVtx, nVtxBins_, TransientVertex::originalTracks(), funct::pow(), pvEvent::pvs, pvsToken_, runControl_, runControlNumbers_, pvEvent::runNumber, jetUpdater_cfi::sort, mathSSE::sqrt(), storeNtuple_, AlCaHLTBitMon_QueryRunRegistry::string, TtFullHadEvtBuilder_cfi::sumPt, pvCand::sumPt_subVtx1, pvCand::sumPt_subVtx2, tracks, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::tracksSize(), tracksToken_, TransientVertex::trackWeight(), transientTrackBuilderToken_, tree_, triggerMap_, edm::TriggerNames::triggerName(), triggerResultsToken_, EgHLTOffTrigSelection_cfi::trigName, parallelization::uint, AdaptiveVertexFitter::vertex(), pwdgSkimBPark_cfi::vertices, reco::Vertex::x(), pvCand::x_origVtx, pvCand::x_subVtx1, pvCand::x_subVtx2, pvCand::xErr_origVtx, pvCand::xErr_subVtx1, pvCand::xErr_subVtx2, reco::Vertex::xError(), reco::Vertex::y(), pvCand::y_origVtx, pvCand::y_subVtx1, pvCand::y_subVtx2, pvCand::yErr_origVtx, pvCand::yErr_subVtx1, pvCand::yErr_subVtx2, reco::Vertex::yError(), reco::Vertex::z(), pvCand::z_origVtx, pvCand::z_subVtx1, pvCand::z_subVtx2, pvCand::zErr_origVtx, pvCand::zErr_subVtx1, pvCand::zErr_subVtx2, and reco::Vertex::zError().

◆ beginEvent()

void SplitVertexResolution::beginEvent ( )

finalprivatevirtual

Definition at line 623 of file SplitVertexResolution.cc.

                                        {
   event_.pvs.clear();
   event_.nVtx = -1;
 }

References event_, pvEvent::nVtx, and pvEvent::pvs.

Referenced by analyze().

◆ beginJob()

void SplitVertexResolution::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 646 of file SplitVertexResolution.cc.

                                      {
   ievt = 0;
   itrks = 0;
  
   if (compressionSettings_ > 0) {
     outfile_->file().SetCompressionSettings(compressionSettings_);
   }
  
   // luminosity histo
   TFileDirectory EventFeatures = outfile_->mkdir("EventFeatures");
   h_lumiFromConfig =
       EventFeatures.make<TH1F>("h_lumiFromConfig", "luminosity from config;;luminosity of present run", 1, -0.5, 0.5);
   h_lumiFromConfig->SetBinContent(1, intLumi_);
  
   h_runFromConfig = EventFeatures.make<TH1I>("h_runFromConfig",
                                              "run number from config;;run number (from configuration)",
                                              runControlNumbers_.size(),
                                              0.,
                                              runControlNumbers_.size());
  
   for (const auto& run : runControlNumbers_ | boost::adaptors::indexed(1)) {
     h_runFromConfig->SetBinContent(run.index(), run.value());
   }
  
   // resolutions
  
   if (!checkBinOrdering(mypT_bins_)) {
     edm::LogError("SplitVertexResolution") << " Warning - the vector of pT bins is not ordered " << std::endl;
   }
  
   if (!checkBinOrdering(myNTrack_bins_)) {
     edm::LogError("SplitVertexResolution") << " Warning -the vector of n. tracks bins is not ordered " << std::endl;
   }
  
   if (!checkBinOrdering(myNVtx_bins_)) {
     edm::LogError("SplitVertexResolution") << " Warning -the vector of n. vertices bins is not ordered " << std::endl;
   }
  
   TFileDirectory xResolSumPt = outfile_->mkdir("xResolSumPt");
   h_resolX_sumPt_ = bookResidualsHistogram(xResolSumPt, nPtBins_, "resolX", "sumPt");
  
   TFileDirectory yResolSumPt = outfile_->mkdir("yResolSumPt");
   h_resolY_sumPt_ = bookResidualsHistogram(yResolSumPt, nPtBins_, "resolY", "sumPt");
  
   TFileDirectory zResolSumPt = outfile_->mkdir("zResolSumPt");
   h_resolZ_sumPt_ = bookResidualsHistogram(zResolSumPt, nPtBins_, "resolZ", "sumPt");
  
   TFileDirectory xResolNtracks_ = outfile_->mkdir("xResolNtracks");
   h_resolX_Ntracks_ = bookResidualsHistogram(xResolNtracks_, nTrackBins_, "resolX", "Ntracks");
  
   TFileDirectory yResolNtracks_ = outfile_->mkdir("yResolNtracks");
   h_resolY_Ntracks_ = bookResidualsHistogram(yResolNtracks_, nTrackBins_, "resolY", "Ntracks");
  
   TFileDirectory zResolNtracks_ = outfile_->mkdir("zResolNtracks");
   h_resolZ_Ntracks_ = bookResidualsHistogram(zResolNtracks_, nTrackBins_, "resolZ", "Ntracks");
  
   TFileDirectory xResolNvtx_ = outfile_->mkdir("xResolNvtx");
   h_resolX_Nvtx_ = bookResidualsHistogram(xResolNvtx_, nVtxBins_, "resolX", "Nvtx");
  
   TFileDirectory yResolNvtx_ = outfile_->mkdir("yResolNvtx");
   h_resolY_Nvtx_ = bookResidualsHistogram(yResolNvtx_, nVtxBins_, "resolY", "Nvtx");
  
   TFileDirectory zResolNvtx_ = outfile_->mkdir("zResolNvtx");
   h_resolZ_Nvtx_ = bookResidualsHistogram(zResolNvtx_, nVtxBins_, "resolZ", "Nvtx");
  
   // pulls
  
   TFileDirectory xPullSumPt = outfile_->mkdir("xPullSumPt");
   h_pullX_sumPt_ = bookResidualsHistogram(xPullSumPt, nPtBins_, "pullX", "sumPt");
  
   TFileDirectory yPullSumPt = outfile_->mkdir("yPullSumPt");
   h_pullY_sumPt_ = bookResidualsHistogram(yPullSumPt, nPtBins_, "pullY", "sumPt");
  
   TFileDirectory zPullSumPt = outfile_->mkdir("zPullSumPt");
   h_pullZ_sumPt_ = bookResidualsHistogram(zPullSumPt, nPtBins_, "pullZ", "sumPt");
  
   TFileDirectory xPullNtracks_ = outfile_->mkdir("xPullNtracks");
   h_pullX_Ntracks_ = bookResidualsHistogram(xPullNtracks_, nTrackBins_, "pullX", "Ntracks");
  
   TFileDirectory yPullNtracks_ = outfile_->mkdir("yPullNtracks");
   h_pullY_Ntracks_ = bookResidualsHistogram(yPullNtracks_, nTrackBins_, "pullY", "Ntracks");
  
   TFileDirectory zPullNtracks_ = outfile_->mkdir("zPullNtracks");
   h_pullZ_Ntracks_ = bookResidualsHistogram(zPullNtracks_, nTrackBins_, "pullZ", "Ntracks");
  
   TFileDirectory xPullNvtx_ = outfile_->mkdir("xPullNvtx");
   h_pullX_Nvtx_ = bookResidualsHistogram(xPullNvtx_, nVtxBins_, "pullX", "Nvtx");
  
   TFileDirectory yPullNvtx_ = outfile_->mkdir("yPullNvtx");
   h_pullY_Nvtx_ = bookResidualsHistogram(yPullNvtx_, nVtxBins_, "pullY", "Nvtx");
  
   TFileDirectory zPullNvtx_ = outfile_->mkdir("zPullNvtx");
   h_pullZ_Nvtx_ = bookResidualsHistogram(zPullNvtx_, nVtxBins_, "pullZ", "Nvtx");
  
   // control plots
   h_runNumber = outfile_->make<TH1F>("h_runNumber", "run number;run number;n_{events}", 100000, 250000., 350000.);
  
   h_nOfflineVertices = outfile_->make<TH1I>("h_nOfflineVertices", "n. of vertices;n. vertices; events", 100, 0, 100);
   h_nVertices = outfile_->make<TH1I>("h_nVertices", "n. of vertices;n. vertices; events", 100, 0, 100);
   h_nNonFakeVertices =
       outfile_->make<TH1I>("h_nRealVertices", "n. of non-fake vertices;n. vertices; events", 100, 0, 100);
   h_nFinalVertices =
       outfile_->make<TH1I>("h_nSelectedVertices", "n. of selected vertices vertices;n. vertices; events", 100, 0, 100);
  
   h_diffX = outfile_->make<TH1F>(
       "h_diffX", "x-coordinate vertex resolution;vertex resolution (x) [#mum];vertices", 100, -300, 300.);
   h_diffY = outfile_->make<TH1F>(
       "h_diffY", "y-coordinate vertex resolution;vertex resolution (y) [#mum];vertices", 100, -300, 300.);
   h_diffZ = outfile_->make<TH1F>(
       "h_diffZ", "z-coordinate vertex resolution;vertex resolution (z) [#mum];vertices", 100, -500, 500.);
  
   h_OrigVertexErrX = outfile_->make<TH1F>(
       "h_OrigVertexErrX", "x-coordinate vertex error;vertex error (x) [#mum];vertices", 300, 0., 300.);
   h_OrigVertexErrY = outfile_->make<TH1F>(
       "h_OrigVertexErrY", "y-coordinate vertex error;vertex error (y) [#mum];vertices", 300, 0., 300.);
   h_OrigVertexErrZ = outfile_->make<TH1F>(
       "h_OrigVertexErrZ", "z-coordinate vertex error;vertex error (z) [#mum];vertices", 500, 0., 500.);
  
   h_errX = outfile_->make<TH1F>(
       "h_errX", "x-coordinate vertex resolution error;vertex resoltuion error (x) [#mum];vertices", 300, 0., 300.);
   h_errY = outfile_->make<TH1F>(
       "h_errY", "y-coordinate vertex resolution error;vertex resolution error (y) [#mum];vertices", 300, 0., 300.);
   h_errZ = outfile_->make<TH1F>(
       "h_errZ", "z-coordinate vertex resolution error;vertex resolution error (z) [#mum];vertices", 500, 0., 500.);
  
   h_pullX = outfile_->make<TH1F>("h_pullX", "x-coordinate vertex pull;vertex pull (x);vertices", 500, -10, 10.);
   h_pullY = outfile_->make<TH1F>("h_pullY", "y-coordinate vertex pull;vertex pull (y);vertices", 500, -10, 10.);
   h_pullZ = outfile_->make<TH1F>("h_pullZ", "z-coordinate vertex pull;vertex pull (z);vertices", 500, -10, 10.);
  
   h_ntrks = outfile_->make<TH1F>("h_ntrks",
                                  "number of tracks in vertex;vertex multeplicity;vertices",
                                  myNTrack_bins_.size() - 1,
                                  myNTrack_bins_.data());
  
   h_sumPt = outfile_->make<TH1F>(
       "h_sumPt", "#Sigma p_{T};#sum p_{T} [GeV];vertices", mypT_bins_.size() - 1, mypT_bins_.data());
  
   h_avgSumPt = outfile_->make<TH1F>(
       "h_avgSumPt", "#LT #Sigma p_{T} #GT;#LT #sum p_{T} #GT [GeV];vertices", mypT_bins_.size() - 1, mypT_bins_.data());
  
   h_sumPt1 = outfile_->make<TH1F>("h_sumPt1",
                                   "#Sigma p_{T} sub-vertex 1;#sum p_{T} sub-vertex 1 [GeV];subvertices",
                                   mypT_bins_.size() - 1,
                                   mypT_bins_.data());
   h_sumPt2 = outfile_->make<TH1F>("h_sumPt2",
                                   "#Sigma p_{T} sub-vertex 2;#sum p_{T} sub-vertex 2 [GeV];subvertices",
                                   mypT_bins_.size() - 1,
                                   mypT_bins_.data());
  
   h_wTrks1 = outfile_->make<TH1F>("h_wTrks1", "weight of track for sub-vertex 1;track weight;subvertices", 500, 0., 1.);
   h_wTrks2 = outfile_->make<TH1F>("h_wTrks2", "weithg of track for sub-vertex 2;track weight;subvertices", 500, 0., 1.);
  
   h_minWTrks1 = outfile_->make<TH1F>(
       "h_minWTrks1", "minimum weight of track for sub-vertex 1;minimum track weight;subvertices", 500, 0., 1.);
   h_minWTrks2 = outfile_->make<TH1F>(
       "h_minWTrks2", "minimum weithg of track for sub-vertex 2;minimum track weight;subvertices", 500, 0., 1.);
  
   h_PVCL_subVtx1 =
       outfile_->make<TH1F>("h_PVCL_subVtx1",
                            "#chi^{2} probability for sub-vertex 1;Prob(#chi^{2},ndof) for sub-vertex 1;subvertices",
                            100,
                            0.,
                            1);
   h_PVCL_subVtx2 =
       outfile_->make<TH1F>("h_PVCL_subVtx2",
                            "#chi^{2} probability for sub-vertex 2;Prob(#chi^{2},ndof) for sub-vertex 2;subvertices",
                            100,
                            0.,
                            1);
  
   // resolutions
  
   p_resolX_vsSumPt = outfile_->make<TH1F>("p_resolX_vsSumPt",
                                           "x-resolution vs #Sigma p_{T};#sum p_{T}; x vertex resolution [#mum]",
                                           mypT_bins_.size() - 1,
                                           mypT_bins_.data());
   p_resolY_vsSumPt = outfile_->make<TH1F>("p_resolY_vsSumPt",
                                           "y-resolution vs #Sigma p_{T};#sum p_{T}; y vertex resolution [#mum]",
                                           mypT_bins_.size() - 1,
                                           mypT_bins_.data());
   p_resolZ_vsSumPt = outfile_->make<TH1F>("p_resolZ_vsSumPt",
                                           "z-resolution vs #Sigma p_{T};#sum p_{T}; z vertex resolution [#mum]",
                                           mypT_bins_.size() - 1,
                                           mypT_bins_.data());
  
   p_resolX_vsNtracks = outfile_->make<TH1F>("p_resolX_vsNtracks",
                                             "x-resolution vs n_{tracks};n_{tracks}; x vertex resolution [#mum]",
                                             myNTrack_bins_.size() - 1,
                                             myNTrack_bins_.data());
   p_resolY_vsNtracks = outfile_->make<TH1F>("p_resolY_vsNtracks",
                                             "y-resolution vs n_{tracks};n_{tracks}; y vertex resolution [#mum]",
                                             myNTrack_bins_.size() - 1,
                                             myNTrack_bins_.data());
   p_resolZ_vsNtracks = outfile_->make<TH1F>("p_resolZ_vsNtracks",
                                             "z-resolution vs n_{tracks};n_{tracks}; z vertex resolution [#mum]",
                                             myNTrack_bins_.size() - 1,
                                             myNTrack_bins_.data());
  
   p_resolX_vsNvtx = outfile_->make<TH1F>("p_resolX_vsNvtx",
                                          "x-resolution vs n_{vertices};n_{vertices}; x vertex resolution [#mum]",
                                          myNVtx_bins_.size() - 1,
                                          myNVtx_bins_.data());
   p_resolY_vsNvtx = outfile_->make<TH1F>("p_resolY_vsNvtx",
                                          "y-resolution vs n_{vertices};n_{vertices}; y vertex resolution [#mum]",
                                          myNVtx_bins_.size() - 1,
                                          myNVtx_bins_.data());
   p_resolZ_vsNvtx = outfile_->make<TH1F>("p_resolZ_vsNvtx",
                                          "z-resolution vs n_{vertices};n_{vertices}; z vertex resolution [#mum]",
                                          myNVtx_bins_.size() - 1,
                                          myNVtx_bins_.data());
  
   // pulls
  
   p_pullX_vsSumPt = outfile_->make<TH1F>(
       "p_pullX_vsSumPt", "x-pull vs #Sigma p_{T};#sum p_{T}; x vertex pull", mypT_bins_.size() - 1, mypT_bins_.data());
   p_pullY_vsSumPt = outfile_->make<TH1F>(
       "p_pullY_vsSumPt", "y-pull vs #Sigma p_{T};#sum p_{T}; y vertex pull", mypT_bins_.size() - 1, mypT_bins_.data());
   p_pullZ_vsSumPt = outfile_->make<TH1F>(
       "p_pullZ_vsSumPt", "z-pull vs #Sigma p_{T};#sum p_{T}; z vertex pull", mypT_bins_.size() - 1, mypT_bins_.data());
  
   p_pullX_vsNtracks = outfile_->make<TH1F>("p_pullX_vsNtracks",
                                            "x-pull vs n_{tracks};n_{tracks}; x vertex pull",
                                            myNTrack_bins_.size() - 1,
                                            myNTrack_bins_.data());
   p_pullY_vsNtracks = outfile_->make<TH1F>("p_pullY_vsNtracks",
                                            "y-pull vs n_{tracks};n_{tracks}; y vertex pull",
                                            myNTrack_bins_.size() - 1,
                                            myNTrack_bins_.data());
   p_pullZ_vsNtracks = outfile_->make<TH1F>("p_pullZ_vsNtracks",
                                            "z-pull vs n_{tracks};n_{tracks}; z vertex pull",
                                            myNTrack_bins_.size() - 1,
                                            myNTrack_bins_.data());
  
   p_pullX_vsNvtx = outfile_->make<TH1F>("p_pullX_vsNvtx",
                                         "x-pull vs n_{vertices};n_{vertices}; x vertex pull",
                                         myNVtx_bins_.size() - 1,
                                         myNVtx_bins_.data());
   p_pullY_vsNvtx = outfile_->make<TH1F>("p_pullY_vsNvtx",
                                         "y-pull vs n_{vertices};n_{vertices}; y vertex pull",
                                         myNVtx_bins_.size() - 1,
                                         myNVtx_bins_.data());
   p_pullZ_vsNvtx = outfile_->make<TH1F>("p_pullZ_vsNvtx",
                                         "z-pull vs n_{vertices};n_{vertices}; z vertex pull",
                                         myNVtx_bins_.size() - 1,
                                         myNVtx_bins_.data());
  
   tree_ = outfile_->make<TTree>("pvTree", "pvTree");
   tree_->Branch("event", &event_, 64000, 2);
 }

References bookResidualsHistogram(), checkBinOrdering(), compressionSettings_, event_, TFileService::file(), h_avgSumPt, h_diffX, h_diffY, h_diffZ, h_errX, h_errY, h_errZ, h_lumiFromConfig, h_minWTrks1, h_minWTrks2, h_nFinalVertices, h_nNonFakeVertices, h_nOfflineVertices, h_ntrks, h_nVertices, h_OrigVertexErrX, h_OrigVertexErrY, h_OrigVertexErrZ, h_pullX, h_pullX_Ntracks_, h_pullX_Nvtx_, h_pullX_sumPt_, h_pullY, h_pullY_Ntracks_, h_pullY_Nvtx_, h_pullY_sumPt_, h_pullZ, h_pullZ_Ntracks_, h_pullZ_Nvtx_, h_pullZ_sumPt_, h_PVCL_subVtx1, h_PVCL_subVtx2, h_resolX_Ntracks_, h_resolX_Nvtx_, h_resolX_sumPt_, h_resolY_Ntracks_, h_resolY_Nvtx_, h_resolY_sumPt_, h_resolZ_Ntracks_, h_resolZ_Nvtx_, h_resolZ_sumPt_, h_runFromConfig, h_runNumber, h_sumPt, h_sumPt1, h_sumPt2, h_wTrks1, h_wTrks2, ievt, intLumi_, itrks, TFileDirectory::make(), TFileService::make(), TFileService::mkdir(), myNTrack_bins_, myNVtx_bins_, mypT_bins_, nPtBins_, nTrackBins_, nVtxBins_, outfile_, p_pullX_vsNtracks, p_pullX_vsNvtx, p_pullX_vsSumPt, p_pullY_vsNtracks, p_pullY_vsNvtx, p_pullY_vsSumPt, p_pullZ_vsNtracks, p_pullZ_vsNvtx, p_pullZ_vsSumPt, p_resolX_vsNtracks, p_resolX_vsNvtx, p_resolX_vsSumPt, p_resolY_vsNtracks, p_resolY_vsNvtx, p_resolY_vsSumPt, p_resolZ_vsNtracks, p_resolZ_vsNvtx, p_resolZ_vsSumPt, writedatasetfile::run, runControlNumbers_, and tree_.

◆ beginRun()

void SplitVertexResolution::beginRun	(	edm::Run const &	iEvent,
		edm::EventSetup const &	iSetup
	)

overrideprivate

Definition at line 628 of file SplitVertexResolution.cc.

                                                                                    {
   unsigned int RunNumber_ = run.run();
  
   if (!runNumbersTimesLog_.count(RunNumber_)) {
     auto times = getRunTime(iSetup);
  
     if (debug_) {
       const time_t start_time = times.first / 1.0e+6;
       edm::LogInfo("SplitVertexResolution")
           << RunNumber_ << " has start time: " << times.first << " - " << times.second << std::endl;
       edm::LogInfo("SplitVertexResolution")
           << "human readable time: " << std::asctime(std::gmtime(&start_time)) << std::endl;
     }
     runNumbersTimesLog_[RunNumber_] = times;
   }
 }

References debug_, getRunTime(), writedatasetfile::run, and runNumbersTimesLog_.

◆ bookResidualsHistogram()

std::vector< TH1F * > SplitVertexResolution::bookResidualsHistogram	(	TFileDirectory	dir,
		unsigned int	theNOfBins,
		TString	resType,
		TString	varType
	)

private

Definition at line 899 of file SplitVertexResolution.cc.

                                                                                   {
   TH1F::SetDefaultSumw2(kTRUE);
  
   double up = 500.;
   double down = -500.;
  
   if (resType.Contains("pull")) {
     up *= 0.01;
     down *= 0.01;
   }
  
   std::vector<TH1F*> h;
   h.reserve(theNOfBins);
  
   const char* auxResType = (resType.ReplaceAll("_", "")).Data();
  
   for (unsigned int i = 0; i < theNOfBins; i++) {
     TH1F* htemp = dir.make<TH1F>(Form("histo_%s_%s_plot%i", resType.Data(), varType.Data(), i),
                                  Form("%s vs %s - bin %i;%s;vertices", auxResType, varType.Data(), i, auxResType),
                                  250,
                                  down,
                                  up);
     h.push_back(htemp);
   }
  
   return h;
 }

References DeadROC_duringRun::dir, down, h, mps_fire::i, up, and dumpRecoGeometry_cfg::varType.

Referenced by beginJob().

◆ checkBinOrdering()

template<std::size_t SIZE>

bool SplitVertexResolution::checkBinOrdering ( std::array< float, SIZE > & bins )

private

Definition at line 1168 of file SplitVertexResolution.cc.

 {
   int i = 1;
  
   if (std::is_sorted(bins.begin(), bins.end())) {
     return true;
   } else {
     for (const auto& bin : bins) {
       edm::LogInfo("SplitVertexResolution") << "bin: " << i << " : " << bin << std::endl;
       i++;
     }
     edm::LogInfo("SplitVertexResolution") << "--------------------------------" << std::endl;
     return false;
   }
 }

References newFWLiteAna::bin, trigObjTnPSource_cfi::bins, and mps_fire::i.

Referenced by beginJob().

◆ endJob()

void SplitVertexResolution::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 931 of file SplitVertexResolution.cc.

                                    {
   edm::LogVerbatim("SplitVertexResolution") << "*******************************" << std::endl;
   edm::LogVerbatim("SplitVertexResolution") << "Events run in total: " << ievt << std::endl;
   edm::LogVerbatim("SplitVertexResolution") << "n. tracks: " << itrks << std::endl;
   edm::LogVerbatim("SplitVertexResolution") << "*******************************" << std::endl;
  
   int nFiringTriggers = triggerMap_.size();
   edm::LogVerbatim("SplitVertexResolution") << "firing triggers: " << nFiringTriggers << std::endl;
   edm::LogVerbatim("SplitVertexResolution") << "*******************************" << std::endl;
  
   tksByTrigger_ = outfile_->make<TH1D>(
       "tksByTrigger", "tracks by HLT path;;% of # traks", nFiringTriggers, -0.5, nFiringTriggers - 0.5);
   evtsByTrigger_ = outfile_->make<TH1D>(
       "evtsByTrigger", "events by HLT path;;% of # events", nFiringTriggers, -0.5, nFiringTriggers - 0.5);
  
   int i = 0;
   for (std::map<std::string, std::pair<int, int> >::iterator it = triggerMap_.begin(); it != triggerMap_.end(); ++it) {
     i++;
  
     double trkpercent = ((it->second).second) * 100. / double(itrks);
     double evtpercent = ((it->second).first) * 100. / double(ievt);
  
     edm::LogVerbatim("SplitVertexResolution")
         << "HLT path: " << std::setw(60) << std::left << it->first << " | events firing: " << std::right << std::setw(8)
         << (it->second).first << " (" << std::setw(8) << std::fixed << std::setprecision(4) << evtpercent << "%)"
         << " | tracks collected: " << std::setw(8) << (it->second).second << " (" << std::setw(8) << std::fixed
         << std::setprecision(4) << trkpercent << "%)";
  
     tksByTrigger_->SetBinContent(i, trkpercent);
     tksByTrigger_->GetXaxis()->SetBinLabel(i, (it->first).c_str());
  
     evtsByTrigger_->SetBinContent(i, evtpercent);
     evtsByTrigger_->GetXaxis()->SetBinLabel(i, (it->first).c_str());
   }
  
   TFileDirectory RunFeatures = outfile_->mkdir("RunFeatures");
   h_runStartTimes = RunFeatures.make<TH1I>(
       "runStartTimes", "run start times", runNumbersTimesLog_.size(), 0, runNumbersTimesLog_.size());
   h_runEndTimes =
       RunFeatures.make<TH1I>("runEndTimes", "run end times", runNumbersTimesLog_.size(), 0, runNumbersTimesLog_.size());
  
   unsigned int count = 1;
   for (const auto& run : runNumbersTimesLog_) {
     // strip down the microseconds
     h_runStartTimes->SetBinContent(count, run.second.first / 10e6);
     h_runStartTimes->GetXaxis()->SetBinLabel(count, (std::to_string(run.first)).c_str());
  
     h_runEndTimes->SetBinContent(count, run.second.second / 10e6);
     h_runEndTimes->GetXaxis()->SetBinLabel(count, (std::to_string(run.first)).c_str());
  
     count++;
   }
  
   // resolutions
  
   fillTrendPlotByIndex(p_resolX_vsSumPt, h_resolX_sumPt_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_resolY_vsSumPt, h_resolY_sumPt_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_resolZ_vsSumPt, h_resolZ_sumPt_, PVValHelper::WIDTH);
  
   fillTrendPlotByIndex(p_resolX_vsNtracks, h_resolX_Ntracks_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_resolY_vsNtracks, h_resolY_Ntracks_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_resolZ_vsNtracks, h_resolZ_Ntracks_, PVValHelper::WIDTH);
  
   fillTrendPlotByIndex(p_resolX_vsNvtx, h_resolX_Nvtx_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_resolY_vsNvtx, h_resolY_Nvtx_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_resolZ_vsNvtx, h_resolZ_Nvtx_, PVValHelper::WIDTH);
  
   // pulls
  
   fillTrendPlotByIndex(p_pullX_vsSumPt, h_pullX_sumPt_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_pullY_vsSumPt, h_pullY_sumPt_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_pullZ_vsSumPt, h_pullZ_sumPt_, PVValHelper::WIDTH);
  
   fillTrendPlotByIndex(p_pullX_vsNtracks, h_pullX_Ntracks_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_pullY_vsNtracks, h_pullY_Ntracks_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_pullZ_vsNtracks, h_pullZ_Ntracks_, PVValHelper::WIDTH);
  
   fillTrendPlotByIndex(p_pullX_vsNvtx, h_pullX_Nvtx_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_pullY_vsNvtx, h_pullY_Nvtx_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(p_pullZ_vsNvtx, h_pullZ_Nvtx_, PVValHelper::WIDTH);
 }

References submitPVResolutionJobs::count, evtsByTrigger_, fillTrendPlotByIndex(), first, alignBH_cfg::fixed, h_pullX_Ntracks_, h_pullX_Nvtx_, h_pullX_sumPt_, h_pullY_Ntracks_, h_pullY_Nvtx_, h_pullY_sumPt_, h_pullZ_Ntracks_, h_pullZ_Nvtx_, h_pullZ_sumPt_, h_resolX_Ntracks_, h_resolX_Nvtx_, h_resolX_sumPt_, h_resolY_Ntracks_, h_resolY_Nvtx_, h_resolY_sumPt_, h_resolZ_Ntracks_, h_resolZ_Nvtx_, h_resolZ_sumPt_, h_runEndTimes, h_runStartTimes, mps_fire::i, ievt, itrks, TFileDirectory::make(), TFileService::make(), genParticles_cff::map, TFileService::mkdir(), outfile_, p_pullX_vsNtracks, p_pullX_vsNvtx, p_pullX_vsSumPt, p_pullY_vsNtracks, p_pullY_vsNvtx, p_pullY_vsSumPt, p_pullZ_vsNtracks, p_pullZ_vsNvtx, p_pullZ_vsSumPt, p_resolX_vsNtracks, p_resolX_vsNvtx, p_resolX_vsSumPt, p_resolY_vsNtracks, p_resolY_vsNvtx, p_resolY_vsSumPt, p_resolZ_vsNtracks, p_resolZ_vsNvtx, p_resolZ_vsSumPt, writedatasetfile::run, runNumbersTimesLog_, edm::second(), AlCaHLTBitMon_QueryRunRegistry::string, tksByTrigger_, triggerMap_, and PVValHelper::WIDTH.

Referenced by o2olib.O2ORunMgr::executeJob().

◆ endRun()

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

inlineoverrideprivate

Definition at line 89 of file SplitVertexResolution.cc.

89 {};

◆ fillDescriptions()

void SplitVertexResolution::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 1014 of file SplitVertexResolution.cc.

                                                                                        {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

References edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

◆ fillTrendPlotByIndex()

void SplitVertexResolution::fillTrendPlotByIndex	(	TH1F *	trendPlot,
		std::vector< TH1F * > &	h,
		PVValHelper::estimator	fitPar_
	)

private

Definition at line 1034 of file SplitVertexResolution.cc.

 {
   for (auto iterator = h.begin(); iterator != h.end(); iterator++) {
     unsigned int bin = std::distance(h.begin(), iterator) + 1;
     statmode::fitParams myFit = fitResiduals((*iterator));
  
     switch (fitPar_) {
       case PVValHelper::MEAN: {
         float mean_ = myFit.first.value();
         float meanErr_ = myFit.first.error();
         trendPlot->SetBinContent(bin, mean_);
         trendPlot->SetBinError(bin, meanErr_);
         break;
       }
       case PVValHelper::WIDTH: {
         float width_ = myFit.second.value();
         float widthErr_ = myFit.second.error();
         trendPlot->SetBinContent(bin, width_);
         trendPlot->SetBinError(bin, widthErr_);
         break;
       }
       case PVValHelper::MEDIAN: {
         float median_ = PVValHelper::getMedian((*iterator)).value();
         float medianErr_ = PVValHelper::getMedian((*iterator)).error();
         trendPlot->SetBinContent(bin, median_);
         trendPlot->SetBinError(bin, medianErr_);
         break;
       }
       case PVValHelper::MAD: {
         float mad_ = PVValHelper::getMAD((*iterator)).value();
         float madErr_ = PVValHelper::getMAD((*iterator)).error();
         trendPlot->SetBinContent(bin, mad_);
         trendPlot->SetBinError(bin, madErr_);
         break;
       }
       default:
         edm::LogWarning("SplitVertexResolution")
             << "fillTrendPlotByIndex() " << fitPar_ << " unknown estimator!" << std::endl;
         break;
     }
   }
 }

References newFWLiteAna::bin, HLT_FULL_cff::distance, Measurement1D::error(), fitResiduals(), PVValHelper::getMAD(), PVValHelper::getMedian(), PVValHelper::MAD, PVValHelper::MEAN, PVValHelper::MEDIAN, Measurement1D::value(), and PVValHelper::WIDTH.

Referenced by endJob().

◆ fitResiduals()

statmode::fitParams SplitVertexResolution::fitResiduals	(	TH1 *	hist,
		bool	singleTime = `false`
	)

private

Definition at line 1079 of file SplitVertexResolution.cc.

 {
   if (hist->GetEntries() < 10) {
     LogDebug("SplitVertexResolution") << "hist name: " << hist->GetName() << " has less than 10 entries" << std::endl;
     return std::make_pair(Measurement1D(0., 0.), Measurement1D(0., 0.));
   }
  
   float maxHist = hist->GetXaxis()->GetXmax();
   float minHist = hist->GetXaxis()->GetXmin();
   float mean = hist->GetMean();
   float sigma = hist->GetRMS();
  
   if (edm::isNotFinite(mean) || edm::isNotFinite(sigma)) {
     mean = 0;
     //sigma= - hist->GetXaxis()->GetBinLowEdge(1) + hist->GetXaxis()->GetBinLowEdge(hist->GetNbinsX()+1);
     sigma = -minHist + maxHist;
     edm::LogWarning("SplitVertexResolution")
         << "FitPVResiduals::fitResiduals(): histogram" << hist->GetName() << " mean or sigma are NaN!!" << std::endl;
   }
  
   TF1 func("tmp", "gaus", mean - 2. * sigma, mean + 2. * sigma);
   if (0 == hist->Fit(&func, "QNR")) {  // N: do not blow up file by storing fit!
     mean = func.GetParameter(1);
     sigma = func.GetParameter(2);
  
     if (!singleTime) {
       // second fit: three sigma of first fit around mean of first fit
       func.SetRange(std::max(mean - 3 * sigma, minHist), std::min(mean + 3 * sigma, maxHist));
       // I: integral gives more correct results if binning is too wide
       // L: Likelihood can treat empty bins correctly (if hist not weighted...)
       if (0 == hist->Fit(&func, "Q0LR")) {
         if (hist->GetFunction(func.GetName())) {  // Take care that it is later on drawn:
           hist->GetFunction(func.GetName())->ResetBit(TF1::kNotDraw);
         }
       }
     }
   }
  
   float res_mean = func.GetParameter(1);
   float res_width = func.GetParameter(2);
  
   float res_mean_err = func.GetParError(1);
   float res_width_err = func.GetParError(2);
  
   Measurement1D resultM(res_mean, res_mean_err);
   Measurement1D resultW(res_width, res_width_err);
  
   statmode::fitParams result = std::make_pair(resultM, resultW);
   return result;
 }

References TrackCollections2monitor_cff::func, gpuVertexFinder::hist, edm::isNotFinite(), LogDebug, SiStripPI::max, SiStripPI::mean, min(), and mps_fire::result.

Referenced by fillTrendPlotByIndex().

◆ fitResiduals_v0()

statmode::fitParams SplitVertexResolution::fitResiduals_v0 ( TH1 * hist )

private

Definition at line 1132 of file SplitVertexResolution.cc.

 {
   float mean = hist->GetMean();
   float sigma = hist->GetRMS();
  
   TF1 func("tmp", "gaus", mean - 1.5 * sigma, mean + 1.5 * sigma);
   if (0 == hist->Fit(&func, "QNR")) {  // N: do not blow up file by storing fit!
     mean = func.GetParameter(1);
     sigma = func.GetParameter(2);
     // second fit: three sigma of first fit around mean of first fit
     func.SetRange(mean - 2 * sigma, mean + 2 * sigma);
     // I: integral gives more correct results if binning is too wide
     // L: Likelihood can treat empty bins correctly (if hist not weighted...)
     if (0 == hist->Fit(&func, "Q0LR")) {
       if (hist->GetFunction(func.GetName())) {  // Take care that it is later on drawn:
         hist->GetFunction(func.GetName())->ResetBit(TF1::kNotDraw);
       }
     }
   }
  
   float res_mean = func.GetParameter(1);
   float res_width = func.GetParameter(2);
  
   float res_mean_err = func.GetParError(1);
   float res_width_err = func.GetParError(2);
  
   Measurement1D resultM(res_mean, res_mean_err);
   Measurement1D resultW(res_width, res_width_err);
  
   statmode::fitParams result = std::make_pair(resultM, resultW);
   return result;
 }

References TrackCollections2monitor_cff::func, gpuVertexFinder::hist, SiStripPI::mean, and mps_fire::result.

◆ getRunTime()

std::pair< long long, long long > SplitVertexResolution::getRunTime ( const edm::EventSetup & iSetup ) const

private

Definition at line 1023 of file SplitVertexResolution.cc.

 {
   const auto& runInfo = iSetup.getData(runInfoToken_);
   if (debug_) {
     edm::LogInfo("SplitVertexResolution") << runInfo.m_start_time_str << " " << runInfo.m_stop_time_str << std::endl;
   }
   return std::make_pair(runInfo.m_start_time_ll, runInfo.m_stop_time_ll);
 }

References debug_, submitPVValidationJobs::runInfo, and runInfoToken_.

Referenced by beginRun().

◆ mysorter()

static bool SplitVertexResolution::mysorter	(	reco::Track	i,
		reco::Track	j
	)

inlinestatic

Definition at line 81 of file SplitVertexResolution.cc.

81 { return (i.pt() > j.pt()); }

References mps_fire::i, and dqmiolumiharvest::j.

Referenced by analyze().

Member Data Documentation

◆ cmToUm

constexpr double SplitVertexResolution::cmToUm = 10000.

staticconstexprprivate

Definition at line 139 of file SplitVertexResolution.cc.

Referenced by analyze().

◆ compressionSettings_

const int SplitVertexResolution::compressionSettings_

private

Definition at line 109 of file SplitVertexResolution.cc.

Referenced by beginJob().

◆ debug_

bool SplitVertexResolution::debug_

private

Definition at line 116 of file SplitVertexResolution.cc.

Referenced by analyze(), beginRun(), and getRunTime().

◆ engine_

std::mt19937 SplitVertexResolution::engine_

private

Definition at line 245 of file SplitVertexResolution.cc.

Referenced by analyze().

◆ event_

pvEvent SplitVertexResolution::event_

private

Definition at line 247 of file SplitVertexResolution.cc.

Referenced by analyze(), beginEvent(), and beginJob().

◆ evtsByTrigger_

TH1D* SplitVertexResolution::evtsByTrigger_

private

Definition at line 192 of file SplitVertexResolution.cc.

Referenced by endJob().

◆ h_avgSumPt

TH1F* SplitVertexResolution::h_avgSumPt

private

Definition at line 168 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_diffX

TH1F* SplitVertexResolution::h_diffX

private

Definition at line 150 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_diffY

TH1F* SplitVertexResolution::h_diffY

private

Definition at line 151 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_diffZ

TH1F* SplitVertexResolution::h_diffZ

private

Definition at line 152 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_errX

TH1F* SplitVertexResolution::h_errX

private

Definition at line 158 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_errY

TH1F* SplitVertexResolution::h_errY

private

Definition at line 159 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_errZ

TH1F* SplitVertexResolution::h_errZ

private

Definition at line 160 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_lumiFromConfig

TH1F* SplitVertexResolution::h_lumiFromConfig

private

Definition at line 143 of file SplitVertexResolution.cc.

Referenced by beginJob().

◆ h_minWTrks1

TH1F* SplitVertexResolution::h_minWTrks1

private

Definition at line 176 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_minWTrks2

TH1F* SplitVertexResolution::h_minWTrks2

private

Definition at line 177 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_nFinalVertices

TH1I* SplitVertexResolution::h_nFinalVertices

private

Definition at line 187 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_nNonFakeVertices

TH1I* SplitVertexResolution::h_nNonFakeVertices

private

Definition at line 186 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_nOfflineVertices

TH1I* SplitVertexResolution::h_nOfflineVertices

private

Definition at line 184 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_ntrks

TH1F* SplitVertexResolution::h_ntrks

private

Definition at line 166 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_nVertices

TH1I* SplitVertexResolution::h_nVertices

private

Definition at line 185 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_OrigVertexErrX

TH1F* SplitVertexResolution::h_OrigVertexErrX

private

Definition at line 154 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_OrigVertexErrY

TH1F* SplitVertexResolution::h_OrigVertexErrY

private

Definition at line 155 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_OrigVertexErrZ

TH1F* SplitVertexResolution::h_OrigVertexErrZ

private

Definition at line 156 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_pullX

TH1F* SplitVertexResolution::h_pullX

private

Definition at line 162 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_pullX_Ntracks_

std::vector<TH1F*> SplitVertexResolution::h_pullX_Ntracks_

private

Definition at line 225 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_pullX_Nvtx_

std::vector<TH1F*> SplitVertexResolution::h_pullX_Nvtx_

private

Definition at line 229 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_pullX_sumPt_

std::vector<TH1F*> SplitVertexResolution::h_pullX_sumPt_

private

Definition at line 221 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_pullY

TH1F* SplitVertexResolution::h_pullY

private

Definition at line 163 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_pullY_Ntracks_

std::vector<TH1F*> SplitVertexResolution::h_pullY_Ntracks_

private

Definition at line 226 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_pullY_Nvtx_

std::vector<TH1F*> SplitVertexResolution::h_pullY_Nvtx_

private

Definition at line 230 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_pullY_sumPt_

std::vector<TH1F*> SplitVertexResolution::h_pullY_sumPt_

private

Definition at line 222 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_pullZ

TH1F* SplitVertexResolution::h_pullZ

private

Definition at line 164 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_pullZ_Ntracks_

std::vector<TH1F*> SplitVertexResolution::h_pullZ_Ntracks_

private

Definition at line 227 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_pullZ_Nvtx_

std::vector<TH1F*> SplitVertexResolution::h_pullZ_Nvtx_

private

Definition at line 231 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_pullZ_sumPt_

std::vector<TH1F*> SplitVertexResolution::h_pullZ_sumPt_

private

Definition at line 223 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_PVCL_subVtx1

TH1F* SplitVertexResolution::h_PVCL_subVtx1

private

Definition at line 179 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_PVCL_subVtx2

TH1F* SplitVertexResolution::h_PVCL_subVtx2

private

Definition at line 180 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_resolX_Ntracks_

std::vector<TH1F*> SplitVertexResolution::h_resolX_Ntracks_

private

Definition at line 200 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_resolX_Nvtx_

std::vector<TH1F*> SplitVertexResolution::h_resolX_Nvtx_

private

Definition at line 204 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_resolX_sumPt_

std::vector<TH1F*> SplitVertexResolution::h_resolX_sumPt_

private

Definition at line 196 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_resolY_Ntracks_

std::vector<TH1F*> SplitVertexResolution::h_resolY_Ntracks_

private

Definition at line 201 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_resolY_Nvtx_

std::vector<TH1F*> SplitVertexResolution::h_resolY_Nvtx_

private

Definition at line 205 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_resolY_sumPt_

std::vector<TH1F*> SplitVertexResolution::h_resolY_sumPt_

private

Definition at line 197 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_resolZ_Ntracks_

std::vector<TH1F*> SplitVertexResolution::h_resolZ_Ntracks_

private

Definition at line 202 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_resolZ_Nvtx_

std::vector<TH1F*> SplitVertexResolution::h_resolZ_Nvtx_

private

Definition at line 206 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_resolZ_sumPt_

std::vector<TH1F*> SplitVertexResolution::h_resolZ_sumPt_

private

Definition at line 198 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ h_runEndTimes

TH1I* SplitVertexResolution::h_runEndTimes

private

Definition at line 148 of file SplitVertexResolution.cc.

Referenced by endJob().

◆ h_runFromConfig

TH1I* SplitVertexResolution::h_runFromConfig

private

Definition at line 144 of file SplitVertexResolution.cc.

Referenced by beginJob().

◆ h_runNumber

TH1F* SplitVertexResolution::h_runNumber

private

Definition at line 182 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_runStartTimes

TH1I* SplitVertexResolution::h_runStartTimes

private

Definition at line 147 of file SplitVertexResolution.cc.

Referenced by endJob().

◆ h_sumPt

TH1F* SplitVertexResolution::h_sumPt

private

Definition at line 167 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_sumPt1

TH1F* SplitVertexResolution::h_sumPt1

private

Definition at line 170 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_sumPt2

TH1F* SplitVertexResolution::h_sumPt2

private

Definition at line 171 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_wTrks1

TH1F* SplitVertexResolution::h_wTrks1

private

Definition at line 173 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ h_wTrks2

TH1F* SplitVertexResolution::h_wTrks2

private

Definition at line 174 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ ievt

int SplitVertexResolution::ievt

private

Definition at line 105 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ intLumi_

double SplitVertexResolution::intLumi_

private

Definition at line 115 of file SplitVertexResolution.cc.

Referenced by beginJob().

◆ itrks

int SplitVertexResolution::itrks

private

Definition at line 106 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ minVtxNdf_

double SplitVertexResolution::minVtxNdf_

private

Definition at line 131 of file SplitVertexResolution.cc.

Referenced by analyze().

◆ minVtxWgt_

double SplitVertexResolution::minVtxWgt_

private

Definition at line 132 of file SplitVertexResolution.cc.

Referenced by analyze().

◆ myNTrack_bins_

std::array<float, nTrackBins_ + 1> SplitVertexResolution::myNTrack_bins_

private

Definition at line 255 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and SplitVertexResolution().

◆ myNVtx_bins_

std::array<float, nVtxBins_ + 1> SplitVertexResolution::myNVtx_bins_

private

Definition at line 258 of file SplitVertexResolution.cc.

Referenced by beginJob(), and SplitVertexResolution().

◆ mypT_bins_

std::array<float, nPtBins_ + 1> SplitVertexResolution::mypT_bins_ = PVValHelper::makeLogBins<float, nPtBins_>(1., 1e3)

private

Definition at line 252 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ nPtBins_

const int SplitVertexResolution::nPtBins_ = 30

staticprivate

Definition at line 251 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ nTrackBins_

const int SplitVertexResolution::nTrackBins_ = 60

staticprivate

Definition at line 254 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and SplitVertexResolution().

◆ nVtxBins_

const int SplitVertexResolution::nVtxBins_ = 40

staticprivate

Definition at line 257 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and SplitVertexResolution().

◆ outfile_

edm::Service<TFileService> SplitVertexResolution::outfile_

private

Definition at line 141 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_pullX_vsNtracks

TH1F* SplitVertexResolution::p_pullX_vsNtracks

private

Definition at line 237 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_pullX_vsNvtx

TH1F* SplitVertexResolution::p_pullX_vsNvtx

private

Definition at line 241 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_pullX_vsSumPt

TH1F* SplitVertexResolution::p_pullX_vsSumPt

private

Definition at line 233 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_pullY_vsNtracks

TH1F* SplitVertexResolution::p_pullY_vsNtracks

private

Definition at line 238 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_pullY_vsNvtx

TH1F* SplitVertexResolution::p_pullY_vsNvtx

private

Definition at line 242 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_pullY_vsSumPt

TH1F* SplitVertexResolution::p_pullY_vsSumPt

private

Definition at line 234 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_pullZ_vsNtracks

TH1F* SplitVertexResolution::p_pullZ_vsNtracks

private

Definition at line 239 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_pullZ_vsNvtx

TH1F* SplitVertexResolution::p_pullZ_vsNvtx

private

Definition at line 243 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_pullZ_vsSumPt

TH1F* SplitVertexResolution::p_pullZ_vsSumPt

private

Definition at line 235 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_resolX_vsNtracks

TH1F* SplitVertexResolution::p_resolX_vsNtracks

private

Definition at line 212 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_resolX_vsNvtx

TH1F* SplitVertexResolution::p_resolX_vsNvtx

private

Definition at line 216 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_resolX_vsSumPt

TH1F* SplitVertexResolution::p_resolX_vsSumPt

private

Definition at line 208 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_resolY_vsNtracks

TH1F* SplitVertexResolution::p_resolY_vsNtracks

private

Definition at line 213 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_resolY_vsNvtx

TH1F* SplitVertexResolution::p_resolY_vsNvtx

private

Definition at line 217 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_resolY_vsSumPt

TH1F* SplitVertexResolution::p_resolY_vsSumPt

private

Definition at line 209 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_resolZ_vsNtracks

TH1F* SplitVertexResolution::p_resolZ_vsNtracks

private

Definition at line 214 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_resolZ_vsNvtx

TH1F* SplitVertexResolution::p_resolZ_vsNvtx

private

Definition at line 218 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ p_resolZ_vsSumPt

TH1F* SplitVertexResolution::p_resolZ_vsSumPt

private

Definition at line 210 of file SplitVertexResolution.cc.

Referenced by beginJob(), and endJob().

◆ pvsTag_

edm::InputTag SplitVertexResolution::pvsTag_

private

Definition at line 118 of file SplitVertexResolution.cc.

◆ pvsToken_

edm::EDGetTokenT<reco::VertexCollection> SplitVertexResolution::pvsToken_

private

Definition at line 119 of file SplitVertexResolution.cc.

Referenced by analyze().

◆ runControl_

bool SplitVertexResolution::runControl_

private

Definition at line 136 of file SplitVertexResolution.cc.

Referenced by analyze().

◆ runControlNumbers_

std::vector<unsigned int> SplitVertexResolution::runControlNumbers_

private

Definition at line 137 of file SplitVertexResolution.cc.

Referenced by analyze(), beginJob(), and SplitVertexResolution().

◆ runInfoToken_

edm::ESGetToken<RunInfo, RunInfoRcd> SplitVertexResolution::runInfoToken_

private

Definition at line 129 of file SplitVertexResolution.cc.

Referenced by getRunTime().

◆ runNumbersTimesLog_

std::map<unsigned int, std::pair<long long, long long> > SplitVertexResolution::runNumbersTimesLog_

private

Definition at line 146 of file SplitVertexResolution.cc.

Referenced by beginRun(), and endJob().

◆ storeNtuple_

bool SplitVertexResolution::storeNtuple_

private

Definition at line 112 of file SplitVertexResolution.cc.

Referenced by analyze().

◆ tksByTrigger_

TH1D* SplitVertexResolution::tksByTrigger_

private

Definition at line 191 of file SplitVertexResolution.cc.

Referenced by endJob().

◆ tracksTag_

edm::InputTag SplitVertexResolution::tracksTag_

private

Definition at line 121 of file SplitVertexResolution.cc.

◆ tracksToken_

edm::EDGetTokenT<reco::TrackCollection> SplitVertexResolution::tracksToken_

private

Definition at line 122 of file SplitVertexResolution.cc.

Referenced by analyze().

◆ transientTrackBuilderToken_

edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> SplitVertexResolution::transientTrackBuilderToken_

private

Definition at line 128 of file SplitVertexResolution.cc.

Referenced by analyze().

◆ tree_

TTree* SplitVertexResolution::tree_

private

Definition at line 248 of file SplitVertexResolution.cc.

Referenced by analyze(), and beginJob().

◆ triggerMap_

std::map<std::string, std::pair<int, int> > SplitVertexResolution::triggerMap_

private

Definition at line 260 of file SplitVertexResolution.cc.

Referenced by analyze(), and endJob().

◆ triggerResultsTag_

edm::InputTag SplitVertexResolution::triggerResultsTag_ = edm::InputTag("TriggerResults", "", "HLT")

private

Definition at line 124 of file SplitVertexResolution.cc.

◆ triggerResultsToken_

edm::EDGetTokenT<edm::TriggerResults> SplitVertexResolution::triggerResultsToken_

private

Definition at line 125 of file SplitVertexResolution.cc.

Referenced by analyze().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SplitVertexResolution()

◆ ~SplitVertexResolution()

Member Function Documentation

◆ analyze()

◆ beginEvent()

◆ beginJob()

◆ beginRun()

◆ bookResidualsHistogram()

◆ checkBinOrdering()

◆ endJob()

◆ endRun()

◆ fillDescriptions()

◆ fillTrendPlotByIndex()

◆ fitResiduals()

◆ fitResiduals_v0()

◆ getRunTime()

◆ mysorter()

Member Data Documentation

◆ cmToUm

◆ compressionSettings_

◆ debug_

◆ engine_

◆ event_

◆ evtsByTrigger_

◆ h_avgSumPt

◆ h_diffX

◆ h_diffY

◆ h_diffZ

◆ h_errX

◆ h_errY

◆ h_errZ

◆ h_lumiFromConfig

◆ h_minWTrks1

◆ h_minWTrks2

◆ h_nFinalVertices

◆ h_nNonFakeVertices

◆ h_nOfflineVertices

◆ h_ntrks

◆ h_nVertices

◆ h_OrigVertexErrX

◆ h_OrigVertexErrY

◆ h_OrigVertexErrZ

◆ h_pullX

◆ h_pullX_Ntracks_

◆ h_pullX_Nvtx_

◆ h_pullX_sumPt_

◆ h_pullY

◆ h_pullY_Ntracks_

◆ h_pullY_Nvtx_

◆ h_pullY_sumPt_

◆ h_pullZ

◆ h_pullZ_Ntracks_

◆ h_pullZ_Nvtx_

◆ h_pullZ_sumPt_

◆ h_PVCL_subVtx1

◆ h_PVCL_subVtx2

◆ h_resolX_Ntracks_

◆ h_resolX_Nvtx_

◆ h_resolX_sumPt_

◆ h_resolY_Ntracks_

◆ h_resolY_Nvtx_

◆ h_resolY_sumPt_

◆ h_resolZ_Ntracks_

◆ h_resolZ_Nvtx_

◆ h_resolZ_sumPt_

◆ h_runEndTimes

◆ h_runFromConfig

◆ h_runNumber

◆ h_runStartTimes

◆ h_sumPt

◆ h_sumPt1

◆ h_sumPt2