Inheritance diagram for TkAlV0sAnalyzer:

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

	~TkAlV0sAnalyzer () override=default

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

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept 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 noexcept

bool	wantsStreamRuns () const noexcept

	~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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

std::vector< ESResolverIndex > 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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

void	beginJob () override

template<typename T , typename... Args>
T *	book (const Args &... args) const

TH1F *	bookHisto1D (std::string name, std::string title, std::string xaxis, std::string yaxis, MEbinning binning)

TH2F *	bookHisto2D (std::string name, std::string title, std::string xaxis, std::string yaxis, MEbinning xbinning, MEbinning ybinning)

TProfile *	bookProfile (std::string name, std::string title, std::string xaxis, std::string yaxis, MEbinning xbinning, MEbinning ybinning)

void	fillMonitoringHistos (const edm::Event &iEvent)

void	getHistoPSet (edm::ParameterSet pset, MEbinning &mebinning)

Private Attributes
const edm::EDGetTokenT< reco::BeamSpot >	bsToken_

MEbinning	chi2oNDF_binning_

MEbinning	eta_binning_

const bool	forceSCAL_

edm::Service< TFileService >	fs_

TH1F *	h_diTrackMass

TH1F *	h_V0Mass

MEbinning	ls_binning_

MEbinning	lumi_binning_

const edm::EDGetTokenT< LumiScalersCollection >	lumiscalersToken_

MEbinning	Lxy_binning_

MEbinning	mass_binning_

const edm::EDGetTokenT< OnlineLuminosityRecord >	metaDataToken_

TH1F *	n_vs_BX_

TH1F *	n_vs_LS_

TH1F *	n_vs_lumi_

TH1F *	n_vs_PU_

MEbinning	pt_binning_

MEbinning	pu_binning_

const int	pvNDOF_

const edm::EDGetTokenT< reco::VertexCollection >	pvToken_

const edm::EDGetTokenT< TrackCollection >	tracksToken_

TH1F *	v0_chi2oNDF_

TH1F *	v0_deltaMass_

TProfile *	v0_deltaMass_vs_BX_

TProfile *	v0_deltaMass_vs_eta_

TProfile *	v0_deltaMass_vs_lumi_

TProfile *	v0_deltaMass_vs_pt_

TProfile *	v0_deltaMass_vs_PU_

TH1F *	v0_eta_

TH1F *	v0_Lxy_

TProfile *	v0_Lxy_vs_BX_

TProfile *	v0_Lxy_vs_deltaMass_

TProfile *	v0_Lxy_vs_eta_

TProfile *	v0_Lxy_vs_lumi_

TProfile *	v0_Lxy_vs_pt_

TProfile *	v0_Lxy_vs_PU_

TH1F *	v0_Lxy_wrtBS_

TH1F *	v0_mass_

TProfile *	v0_mass_vs_BX_

TProfile *	v0_mass_vs_eta_

TProfile *	v0_mass_vs_lumi_

TProfile *	v0_mass_vs_p_

TProfile *	v0_mass_vs_pt_

TProfile *	v0_mass_vs_PU_

TH1F *	v0_N_

TProfile *	v0_N_vs_BX_

TProfile *	v0_N_vs_LS_

TProfile *	v0_N_vs_lumi_

TProfile *	v0_N_vs_PU_

TH1F *	v0_phi_

TH1F *	v0_pt_

const edm::EDGetTokenT< reco::VertexCompositeCandidateCollection >	vccToken_

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
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

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

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

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

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

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

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 63 of file TkAlV0sAnalyzer.cc.

Constructor & Destructor Documentation

◆ TkAlV0sAnalyzer()

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

explicit

Definition at line 170 of file TkAlV0sAnalyzer.cc.

References chi2oNDF_binning_, eta_binning_, getHistoPSet(), edm::ParameterSet::getParameter(), V0Monitor_cff::histoPSet, TFileService::kSharedResource, ls_binning_, lumi_binning_, Lxy_binning_, mass_binning_, n_vs_BX_, n_vs_LS_, n_vs_lumi_, n_vs_PU_, pt_binning_, pu_binning_, v0_chi2oNDF_, v0_deltaMass_, v0_deltaMass_vs_BX_, v0_deltaMass_vs_eta_, v0_deltaMass_vs_lumi_, v0_deltaMass_vs_pt_, v0_deltaMass_vs_PU_, v0_eta_, v0_Lxy_, v0_Lxy_vs_BX_, v0_Lxy_vs_deltaMass_, v0_Lxy_vs_eta_, v0_Lxy_vs_lumi_, v0_Lxy_vs_pt_, v0_Lxy_vs_PU_, v0_Lxy_wrtBS_, v0_mass_, v0_mass_vs_BX_, v0_mass_vs_eta_, v0_mass_vs_lumi_, v0_mass_vs_p_, v0_mass_vs_pt_, v0_mass_vs_PU_, v0_N_, v0_N_vs_BX_, v0_N_vs_LS_, v0_N_vs_lumi_, v0_N_vs_PU_, v0_phi_, and v0_pt_.

     : tracksToken_(consumes<TrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"))),
       vccToken_(consumes<reco::VertexCompositeCandidateCollection>(
           iConfig.getParameter<edm::InputTag>("vertexCompositeCandidates"))),
       bsToken_(consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpot"))),
       pvToken_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("primaryVertex"))),
       lumiscalersToken_(consumes<LumiScalersCollection>(iConfig.getParameter<edm::InputTag>("lumiScalers"))),
       metaDataToken_(consumes<OnlineLuminosityRecord>(iConfig.getParameter<edm::InputTag>("metadata"))),
       forceSCAL_(iConfig.getParameter<bool>("forceSCAL")),
       pvNDOF_(iConfig.getParameter<int>("pvNDOF")) {
   usesResource(TFileService::kSharedResource);
 
   v0_N_ = nullptr;
   v0_mass_ = nullptr;
   v0_pt_ = nullptr;
   v0_eta_ = nullptr;
   v0_phi_ = nullptr;
   v0_Lxy_ = nullptr;
   v0_Lxy_wrtBS_ = nullptr;
   v0_chi2oNDF_ = nullptr;
   v0_mass_vs_p_ = nullptr;
   v0_mass_vs_pt_ = nullptr;
   v0_mass_vs_eta_ = nullptr;
   v0_deltaMass_ = nullptr;
   v0_deltaMass_vs_pt_ = nullptr;
   v0_deltaMass_vs_eta_ = nullptr;
 
   v0_Lxy_vs_deltaMass_ = nullptr;
   v0_Lxy_vs_pt_ = nullptr;
   v0_Lxy_vs_eta_ = nullptr;
 
   n_vs_BX_ = nullptr;
   v0_N_vs_BX_ = nullptr;
   v0_mass_vs_BX_ = nullptr;
   v0_Lxy_vs_BX_ = nullptr;
   v0_deltaMass_vs_BX_ = nullptr;
 
   n_vs_lumi_ = nullptr;
   v0_N_vs_lumi_ = nullptr;
   v0_mass_vs_lumi_ = nullptr;
   v0_Lxy_vs_lumi_ = nullptr;
   v0_deltaMass_vs_lumi_ = nullptr;
 
   n_vs_PU_ = nullptr;
   v0_N_vs_PU_ = nullptr;
   v0_mass_vs_PU_ = nullptr;
   v0_Lxy_vs_PU_ = nullptr;
   v0_deltaMass_vs_PU_ = nullptr;
 
   n_vs_LS_ = nullptr;
   v0_N_vs_LS_ = nullptr;
 
   edm::ParameterSet histoPSet = iConfig.getParameter<edm::ParameterSet>("histoPSet");
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("massPSet"), mass_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("ptPSet"), pt_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("etaPSet"), eta_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("LxyPSet"), Lxy_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("chi2oNDFPSet"), chi2oNDF_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("lumiPSet"), lumi_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("puPSet"), pu_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("lsPSet"), ls_binning_);
 }

◆ ~TkAlV0sAnalyzer()

TkAlV0sAnalyzer::~TkAlV0sAnalyzer ( )

overridedefault

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 275 of file TkAlV0sAnalyzer.cc.

References fillMonitoringHistos(), h_diTrackMass, h_V0Mass, mps_fire::i, iEvent, edm::Ref< C, T, F >::isNonnull(), EgHLTOffHistBins_cfi::mass, piMass2, edm::Handle< T >::product(), mathSSE::sqrt(), reco::RecoChargedCandidate::track(), HLT_2024v14_cff::track, tracksToken_, V0Monitor_cff::v0, and vccToken_.

                                                                                  {
   using namespace edm;
 
   std::vector<const reco::Track*> myTracks;
 
   edm::Handle<reco::VertexCompositeCandidateCollection> vccHandle;
   iEvent.getByToken(vccToken_, vccHandle);
 
   if (vccHandle->empty())
     return;
 
   reco::VertexCompositeCandidateCollection v0s = *vccHandle.product();
 
   for (const auto& track : iEvent.get(tracksToken_)) {
     myTracks.emplace_back(&track);
   }
 
   // exclude multiple candidates
   if (myTracks.size() != 2)
     return;
 
   for (const auto& v0 : v0s) {
     float mass = v0.mass();
     h_V0Mass->Fill(mass);
 
     for (size_t i = 0; i < v0.numberOfDaughters(); ++i) {
       //LogPrint("AlignmentTrackFromVertexCompositeCandidateSelector") << "daughter: " << i << std::endl;
       const reco::Candidate* daughter = v0.daughter(i);
       const reco::RecoChargedCandidate* chargedDaughter = dynamic_cast<const reco::RecoChargedCandidate*>(daughter);
       if (chargedDaughter) {
         //LogPrint("AlignmentTrackFromVertexCompositeCandidateSelector") << "charged daughter: " << i << std::endl;
         const reco::TrackRef trackRef = chargedDaughter->track();
         if (trackRef.isNonnull()) {
           // LogPrint("AlignmentTrackFromVertexCompositeCandidateSelector")
           // << "charged daughter has non-null trackref: " << i << std::endl;
         }
       }
     }
   }
 
   const auto& tplus = myTracks[0]->charge() > 0 ? myTracks[0] : myTracks[1];
   const auto& tminus = myTracks[0]->charge() < 0 ? myTracks[0] : myTracks[1];
 
   TLorentzVector p4_tplus(tplus->px(), tplus->py(), tplus->pz(), sqrt((tplus->p() * tplus->p()) + piMass2));
   TLorentzVector p4_tminus(tminus->px(), tminus->py(), tminus->pz(), sqrt((tminus->p() * tminus->p()) + piMass2));
 
   const auto& V0p4 = p4_tplus + p4_tminus;
   float track_invMass = V0p4.M();
   h_diTrackMass->Fill(track_invMass);
 
   fillMonitoringHistos(iEvent);
 }

◆ beginJob()

void TkAlV0sAnalyzer::beginJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 460 of file TkAlV0sAnalyzer.cc.

References bookHisto1D(), bookProfile(), chi2oNDF_binning_, eta_binning_, h_diTrackMass, h_V0Mass, ls_binning_, lumi_binning_, Lxy_binning_, mass_binning_, n_vs_BX_, n_vs_LS_, n_vs_lumi_, n_vs_PU_, MEbinning::nbins, pt_binning_, pu_binning_, v0_chi2oNDF_, v0_deltaMass_, v0_deltaMass_vs_BX_, v0_deltaMass_vs_eta_, v0_deltaMass_vs_lumi_, v0_deltaMass_vs_pt_, v0_deltaMass_vs_PU_, v0_eta_, v0_Lxy_, v0_Lxy_vs_BX_, v0_Lxy_vs_deltaMass_, v0_Lxy_vs_eta_, v0_Lxy_vs_lumi_, v0_Lxy_vs_pt_, v0_Lxy_vs_PU_, v0_Lxy_wrtBS_, v0_mass_, v0_mass_vs_BX_, v0_mass_vs_eta_, v0_mass_vs_lumi_, v0_mass_vs_p_, v0_mass_vs_pt_, v0_mass_vs_PU_, v0_N_, v0_N_vs_BX_, v0_N_vs_LS_, v0_N_vs_lumi_, v0_N_vs_PU_, v0_phi_, v0_pt_, MEbinning::xmax, and MEbinning::xmin.

                                {
   h_diTrackMass = book<TH1F>(
       "diTrackMass", "V0 mass from tracks in Event", mass_binning_.nbins, mass_binning_.xmin, mass_binning_.xmax);
   h_V0Mass = book<TH1F>(
       "V0kMass", "Reconstructed V0 mass in Event", mass_binning_.nbins, mass_binning_.xmin, mass_binning_.xmax);
 
   MEbinning N_binning;
   N_binning.nbins = 15;
   N_binning.xmin = -0.5;
   N_binning.xmax = 14.5;
   v0_N_ = bookHisto1D("v0_N", "# v0", "# v0", "events", N_binning);
   v0_mass_ = bookHisto1D("v0_mass", "mass", "mass [GeV]", "events", mass_binning_);
   v0_pt_ = bookHisto1D("v0_pt", "pt", "p_{T} [GeV]", "events", pt_binning_);
   v0_eta_ = bookHisto1D("v0_eta", "eta", "#eta", "events", eta_binning_);
   MEbinning phi_binning;
   phi_binning.nbins = 34;
   phi_binning.xmin = -3.2;
   phi_binning.xmax = 3.2;
   v0_phi_ = bookHisto1D("v0_phi", "phi", "#phi [rad]", "events", phi_binning);
   v0_Lxy_ = bookHisto1D("v0_Lxy", "Lxy", "L_{xy} w.r.t. PV [cm]", "events", Lxy_binning_);
   v0_Lxy_wrtBS_ = bookHisto1D("v0_Lxy_wrtBS", "Lxy", "L_{xy} w.r.t. BS [cm]", "events", Lxy_binning_);
   v0_chi2oNDF_ = bookHisto1D("v0_chi2oNDF", "chi2oNDF", "vertex normalized #chi^{2}", "events", chi2oNDF_binning_);
 
   v0_mass_vs_p_ = bookProfile("v0_mass_vs_p", "mass vs p", "p [GeV]", "mass [GeV]", pt_binning_, mass_binning_);
   v0_mass_vs_pt_ = bookProfile("v0_mass_vs_pt", "mass vs pt", "p_{T} [GeV]", "mass [GeV]", pt_binning_, mass_binning_);
   v0_mass_vs_eta_ = bookProfile("v0_mass_vs_eta", "mass vs eta", "#eta", "mass [GeV]", eta_binning_, mass_binning_);
 
   MEbinning delta_binning;
   delta_binning.nbins = 150;
   delta_binning.xmin = -0.15;
   delta_binning.xmax = 0.15;
   v0_deltaMass_ = bookHisto1D("v0_deltaMass", "deltaMass", "m-m_{PDG}/m_{DPG}", "events", delta_binning);
   v0_deltaMass_vs_pt_ = bookProfile(
       "v0_deltaMass_vs_pt", "deltaMass vs pt", "p_{T} [GeV]", "m-m_{PDG}/m_{DPG}", pt_binning_, delta_binning);
   v0_deltaMass_vs_eta_ =
       bookProfile("v0_deltaMass_vs_eta", "deltaMass vs eta", "#eta", "m-m_{PDG}/m_{DPG}", eta_binning_, delta_binning);
 
   v0_Lxy_vs_deltaMass_ = bookProfile(
       "v0_Lxy_vs_deltaMass", "L_{xy} vs deltaMass", "m-m_{PDG}/m_{DPG}", "L_{xy} [cm]", delta_binning, Lxy_binning_);
   v0_Lxy_vs_pt_ =
       bookProfile("v0_Lxy_vs_pt", "L_{xy} vs p_{T}", "p_{T} [GeV]", "L_{xy} [cm]", pt_binning_, Lxy_binning_);
   v0_Lxy_vs_eta_ = bookProfile("v0_Lxy_vs_eta", "L_{xy} vs #eta", "#eta", "L_{xy} [cm]", eta_binning_, Lxy_binning_);
 
   MEbinning bx_binning;
   bx_binning.nbins = 3564;
   bx_binning.xmin = 0.5;
   bx_binning.xmax = 3564.5;
   n_vs_BX_ = bookHisto1D("n_vs_BX", "# events vs BX", "BX", "# events", bx_binning);
   v0_N_vs_BX_ = bookProfile("v0_N_vs_BX", "# v0 vs BX", "BX", "# v0", bx_binning, N_binning);
   v0_mass_vs_BX_ = bookProfile("v0_mass_vs_BX", "mass vs BX", "BX", "mass [GeV]", bx_binning, mass_binning_);
   v0_Lxy_vs_BX_ = bookProfile("v0_Lxy_vs_BX", "L_{xy} vs BX", "BX", "L_{xy} [cm]", bx_binning, Lxy_binning_);
   v0_deltaMass_vs_BX_ =
       bookProfile("v0_deltaMass_vs_BX", "deltaMass vs BX", "BX", "m-m_{PDG}/m_{DPG}", bx_binning, delta_binning);
 
   n_vs_lumi_ =
       bookHisto1D("n_vs_lumi", "# events vs lumi", "inst. lumi x10^{30} [Hz cm^{-2}]", "# events", lumi_binning_);
 
   v0_N_vs_lumi_ =
       bookProfile("v0_N_vs_lumi", "# v0 vs lumi", "inst. lumi x10^{30} [Hz cm^{-2}]", "# v0", lumi_binning_, N_binning);
 
   v0_mass_vs_lumi_ = bookProfile(
       "v0_mass_vs_lumi", "mass vs lumi", "inst. lumi x10^{30} [Hz cm^{-2}]", "mass [GeV]", lumi_binning_, mass_binning_);
 
   v0_Lxy_vs_lumi_ = bookProfile("v0_Lxy_vs_lumi",
                                 "L_{xy} vs lumi",
                                 "inst. lumi x10^{30} [Hz cm^{-2}]",
                                 "L_{xy} [cm]",
                                 lumi_binning_,
                                 Lxy_binning_);
 
   v0_deltaMass_vs_lumi_ = bookProfile("v0_deltaMass_vs_lumi",
                                       "deltaMass vs lumi",
                                       "inst. lumi x10^{30} [Hz cm^{-2}]",
                                       "m-m_{PDG}/m_{DPG}",
                                       lumi_binning_,
                                       delta_binning);
 
   n_vs_PU_ = bookHisto1D("n_vs_PU", "# events vs PU", "# good PV", "# events", pu_binning_);
   v0_N_vs_PU_ = bookProfile("v0_N_vs_PU", "# v0 vs PU", "# good PV", "# v0", pu_binning_, N_binning);
   v0_mass_vs_PU_ = bookProfile("v0_mass_vs_PU", "mass vs PU", "# good PV", "mass [GeV]", pu_binning_, mass_binning_);
   v0_Lxy_vs_PU_ = bookProfile("v0_Lxy_vs_PU", "L_{xy} vs PU", "# good PV", "L_{xy} [cm]", pu_binning_, Lxy_binning_);
   v0_deltaMass_vs_PU_ = bookProfile(
       "v0_deltaMass_vs_PU", "deltaMass vs PU", "# good PV", "m-m_{PDG}/m_{DPG}", pu_binning_, delta_binning);
 
   n_vs_LS_ = bookHisto1D("n_vs_LS", "# events vs LS", "LS", "# events", ls_binning_);
   v0_N_vs_LS_ = bookProfile("v0_N_vs_LS", "# v0 vs LS", "LS", "# v0", ls_binning_, N_binning);
 }

◆ book()

template<typename T , typename... Args>

T * TkAlV0sAnalyzer::book ( const Args &... args ) const

private

Definition at line 234 of file TkAlV0sAnalyzer.cc.

References writedatasetfile::args, fs_, TFileService::make(), and submitPVValidationJobs::t.

                                                   {
   T* t = fs_->make<T>(args...);
   return t;
 }

◆ bookHisto1D()

TH1F * TkAlV0sAnalyzer::bookHisto1D	(	std::string	name,
		std::string	title,
		std::string	xaxis,
		std::string	yaxis,
		MEbinning	binning
	)

private

Definition at line 245 of file TkAlV0sAnalyzer.cc.

References pileupCalc::binning, mergeVDriftHistosByStation::name, AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, LaserClient_cfi::xaxis, and TimingClient_cfi::yaxis.

Referenced by beginJob().

                                                                                           {
   std::string title_w_axes = title + ";" + xaxis + ";" + yaxis;
   return book<TH1F>(name.c_str(), title_w_axes.c_str(), binning.nbins, binning.xmin, binning.xmax);
 }

◆ bookHisto2D()

TH2F * TkAlV0sAnalyzer::bookHisto2D	(	std::string	name,
		std::string	title,
		std::string	xaxis,
		std::string	yaxis,
		MEbinning	xbinning,
		MEbinning	ybinning
	)

private

Definition at line 251 of file TkAlV0sAnalyzer.cc.

References mergeVDriftHistosByStation::name, MEbinning::nbins, AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, LaserClient_cfi::xaxis, MEbinning::xmax, MEbinning::xmin, and TimingClient_cfi::yaxis.

                                                                                                                {
   std::string title_w_axes = title + ";" + xaxis + ";" + yaxis;
   return book<TH2F>(name.c_str(),
                     title_w_axes.c_str(),
                     xbinning.nbins,
                     xbinning.xmin,
                     xbinning.xmax,
                     ybinning.nbins,
                     ybinning.xmin,
                     ybinning.xmax);
 }

◆ bookProfile()

TProfile * TkAlV0sAnalyzer::bookProfile	(	std::string	name,
		std::string	title,
		std::string	xaxis,
		std::string	yaxis,
		MEbinning	xbinning,
		MEbinning	ybinning
	)

private

Definition at line 264 of file TkAlV0sAnalyzer.cc.

References mergeVDriftHistosByStation::name, MEbinning::nbins, AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, LaserClient_cfi::xaxis, MEbinning::xmax, MEbinning::xmin, and TimingClient_cfi::yaxis.

Referenced by beginJob().

                                                                                                                {
   std::string title_w_axes = title + ";" + xaxis + ";" + yaxis;
   return book<TProfile>(
       name.c_str(), title_w_axes.c_str(), xbinning.nbins, xbinning.xmin, xbinning.xmax, ybinning.xmin, ybinning.xmax);
 }

◆ fillDescriptions()

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

static

Definition at line 549 of file TkAlV0sAnalyzer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                  {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("vertexCompositeCandidates", edm::InputTag("generalV0Candidates:Kshort"));
   desc.add<edm::InputTag>("tracks", edm::InputTag("ALCARECOTkAlKShortTracks"));
   desc.add<edm::InputTag>("beamSpot", edm::InputTag("offlineBeamSpot"));
   desc.add<edm::InputTag>("primaryVertex", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("lumiScalers", edm::InputTag("scalersRawToDigi"));
   desc.add<edm::InputTag>("metadata", edm::InputTag("onlineMetaDataDigis"));
   desc.add<bool>("forceSCAL", false);
   desc.add<int>("pvNDOF", 4);
 
   {
     edm::ParameterSetDescription psd0;
     {
       edm::ParameterSetDescription psd1;
       psd1.add<int>("nbins", 3700);
       psd1.add<double>("xmin", 0.);
       psd1.add<double>("xmax", 14000.);
       psd0.add<edm::ParameterSetDescription>("lumiPSet", psd1);
     }
     {
       edm::ParameterSetDescription psd2;
       psd2.add<int>("nbins", 100);
       psd2.add<double>("xmin", 0.400);
       psd2.add<double>("xmax", 0.600);
       psd0.add<edm::ParameterSetDescription>("massPSet", psd2);
     }
     {
       edm::ParameterSetDescription psd3;
       psd3.add<int>("nbins", 100);
       psd3.add<double>("xmin", 0.);
       psd3.add<double>("xmax", 50.);
       psd0.add<edm::ParameterSetDescription>("ptPSet", psd3);
     }
     {
       edm::ParameterSetDescription psd4;
       psd4.add<int>("nbins", 60);
       psd4.add<double>("xmin", -3.);
       psd4.add<double>("xmax", 3.);
       psd0.add<edm::ParameterSetDescription>("etaPSet", psd4);
     }
     {
       edm::ParameterSetDescription psd5;
       psd5.add<int>("nbins", 350);
       psd5.add<double>("xmin", 0.);
       psd5.add<double>("xmax", 70.);
       psd0.add<edm::ParameterSetDescription>("LxyPSet", psd5);
     }
     {
       edm::ParameterSetDescription psd6;
       psd6.add<int>("nbins", 100);
       psd6.add<double>("xmin", 0.);
       psd6.add<double>("xmax", 30.);
       psd0.add<edm::ParameterSetDescription>("chi2oNDFPSet", psd6);
     }
     {
       edm::ParameterSetDescription psd7;
       psd7.add<int>("nbins", 100);
       psd7.add<double>("xmin", -0.5);
       psd7.add<double>("xmax", 99.5);
       psd0.add<edm::ParameterSetDescription>("puPSet", psd7);
     }
     {
       edm::ParameterSetDescription psd8;
       psd8.add<int>("nbins", 2000);
       psd8.add<double>("xmin", 0.);
       psd8.add<double>("xmax", 2000.);
       psd0.add<edm::ParameterSetDescription>("lsPSet", psd8);
     }
     desc.add<edm::ParameterSetDescription>("histoPSet", psd0);
   }
   descriptions.addWithDefaultLabel(desc);
 }

◆ fillMonitoringHistos()

void TkAlV0sAnalyzer::fillMonitoringHistos ( const edm::Event & iEvent )

private

Definition at line 328 of file TkAlV0sAnalyzer.cc.

References cms::cuda::bs, bsToken_, nano_mu_digi_cff::bx, dumpMFGeometry_cfg::delta, PVValHelper::eta, forceSCAL_, iEvent, OnlineLuminosityRecord::instLumi(), edm::HandleBase::isValid(), V0Monitor_cfi::lumiScalers, lumiscalersToken_, EgHLTOffHistBins_cfi::mass, metaDataToken_, create_idmaps::n, n_vs_BX_, n_vs_LS_, n_vs_lumi_, n_vs_PU_, nPV, or, AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::perp(), phi, edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, pvNDOF_, pvToken_, findQualityFiles::v, V0Monitor_cff::v0, v0_chi2oNDF_, v0_deltaMass_, v0_deltaMass_vs_BX_, v0_deltaMass_vs_eta_, v0_deltaMass_vs_lumi_, v0_deltaMass_vs_pt_, v0_deltaMass_vs_PU_, v0_eta_, v0_Lxy_, v0_Lxy_vs_BX_, v0_Lxy_vs_deltaMass_, v0_Lxy_vs_eta_, v0_Lxy_vs_lumi_, v0_Lxy_vs_pt_, v0_Lxy_vs_PU_, v0_Lxy_wrtBS_, v0_mass_, v0_mass_vs_BX_, v0_mass_vs_eta_, v0_mass_vs_lumi_, v0_mass_vs_p_, v0_mass_vs_pt_, v0_mass_vs_PU_, v0_N_, v0_N_vs_BX_, v0_N_vs_LS_, v0_N_vs_lumi_, v0_N_vs_PU_, v0_phi_, v0_pt_, and vccToken_.

Referenced by analyze().

                                                                  {
   size_t bx = iEvent.bunchCrossing();
   n_vs_BX_->Fill(bx);
 
   float lumi = -1.;
   if (forceSCAL_) {
     edm::Handle<LumiScalersCollection> lumiScalers = iEvent.getHandle(lumiscalersToken_);
     if (lumiScalers.isValid() && !lumiScalers->empty()) {
       LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
       lumi = scalit->instantLumi();
     }
   } else {
     edm::Handle<OnlineLuminosityRecord> metaData = iEvent.getHandle(metaDataToken_);
     if (metaData.isValid())
       lumi = metaData->instLumi();
   }
 
   n_vs_lumi_->Fill(lumi);
 
   edm::Handle<reco::BeamSpot> beamspotHandle = iEvent.getHandle(bsToken_);
   reco::BeamSpot const* bs = nullptr;
   if (beamspotHandle.isValid())
     bs = &(*beamspotHandle);
 
   edm::Handle<reco::VertexCollection> pvHandle = iEvent.getHandle(pvToken_);
   reco::Vertex const* pv = nullptr;
   size_t nPV = 0;
   if (pvHandle.isValid()) {
     pv = &pvHandle->front();
     //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
     if (pv->isFake() ||
         pv->tracksSize() == 0
         // definition of goodOfflinePrimaryVertex
         || pv->ndof() < pvNDOF_ || pv->z() > 24.)
       pv = nullptr;
 
     for (const auto& v : *pvHandle) {
       if (v.isFake())
         continue;
       if (v.ndof() < pvNDOF_)
         continue;
       if (v.z() > 24.)
         continue;
       ++nPV;
     }
   }
   n_vs_PU_->Fill(nPV);
 
   float nLS = static_cast<float>(iEvent.id().luminosityBlock());
   n_vs_LS_->Fill(nLS);
 
   edm::Handle<reco::VertexCompositeCandidateCollection> v0Handle = iEvent.getHandle(vccToken_);
   int n = (v0Handle.isValid() ? v0Handle->size() : -1);
   v0_N_->Fill(n);
   v0_N_vs_BX_->Fill(bx, n);
   v0_N_vs_lumi_->Fill(lumi, n);
   v0_N_vs_PU_->Fill(nPV, n);
   v0_N_vs_LS_->Fill(nLS, n);
 
   if (!v0Handle.isValid() or n == 0)
     return;
 
   reco::VertexCompositeCandidateCollection v0s = *v0Handle.product();
   for (const auto& v0 : v0s) {
     float mass = v0.mass();
     float pt = v0.pt();
     float p = v0.p();
     float eta = v0.eta();
     float phi = v0.phi();
     int pdgID = v0.pdgId();
     float chi2oNDF = v0.vertexNormalizedChi2();
     GlobalPoint displacementFromPV =
         (pv == nullptr ? GlobalPoint(-9., -9., 0) : GlobalPoint((pv->x() - v0.vx()), (pv->y() - v0.vy()), 0.));
     GlobalPoint displacementFromBS =
         (bs == nullptr
              ? GlobalPoint(-9., -9., 0.)
              : GlobalPoint(-1 * ((bs->position().x() - v0.vx()) + (v0.vz() - bs->position().z()) * bs->dxdz()),
                            -1 * ((bs->position().y() - v0.vy()) + (v0.vz() - bs->position().z()) * bs->dydz()),
                            0));
     float lxy = (pv == nullptr ? -9. : displacementFromPV.perp());
     float lxyWRTbs = (bs == nullptr ? -9. : displacementFromBS.perp());
 
     v0_mass_->Fill(mass);
     v0_pt_->Fill(pt);
     v0_eta_->Fill(eta);
     v0_phi_->Fill(phi);
     v0_Lxy_->Fill(lxy);
     v0_Lxy_wrtBS_->Fill(lxyWRTbs);
     v0_chi2oNDF_->Fill(chi2oNDF);
 
     v0_mass_vs_p_->Fill(p, mass);
     v0_mass_vs_pt_->Fill(pt, mass);
     v0_mass_vs_eta_->Fill(eta, mass);
     v0_mass_vs_BX_->Fill(bx, mass);
     v0_mass_vs_lumi_->Fill(lumi, mass);
     v0_mass_vs_PU_->Fill(nPV, mass);
 
     v0_Lxy_vs_BX_->Fill(bx, lxy);
     v0_Lxy_vs_lumi_->Fill(lumi, lxy);
     v0_Lxy_vs_PU_->Fill(nPV, lxy);
 
     float PDGmass = -9999.;
     switch (pdgID) {
       case 130:              // K_s
       case 310:              // K_L
         PDGmass = 0.497614;  // GeV
         break;
       case 3122:             // Lambda
       case -3122:            // Lambda
         PDGmass = 1.115683;  // GeV
         break;
       case 4122:   // Lambda_c
       case -4122:  // Lambda_c
       case 5122:   // Lambda_b
       case -5122:  // Lambda_b
       default:
         break;
     }
     float delta = (PDGmass > 0. ? (mass - PDGmass) / PDGmass : -9.);
     v0_deltaMass_->Fill(delta);
     v0_deltaMass_vs_pt_->Fill(pt, delta);
     v0_deltaMass_vs_eta_->Fill(eta, delta);
     v0_deltaMass_vs_BX_->Fill(bx, delta);
     v0_deltaMass_vs_lumi_->Fill(lumi, delta);
     v0_deltaMass_vs_PU_->Fill(nPV, delta);
 
     v0_Lxy_vs_deltaMass_->Fill(delta, lxy);
     v0_Lxy_vs_pt_->Fill(pt, lxy);
     v0_Lxy_vs_eta_->Fill(eta, lxy);
   }
 }

◆ getHistoPSet()

void TkAlV0sAnalyzer::getHistoPSet	(	edm::ParameterSet	pset,
		MEbinning &	mebinning
	)

private

Definition at line 239 of file TkAlV0sAnalyzer.cc.

References MEbinning::nbins, muonDTDigis_cfi::pset, MEbinning::xmax, and MEbinning::xmin.

Referenced by TkAlV0sAnalyzer().

                                                                              {
   mebinning.nbins = pset.getParameter<int32_t>("nbins");
   mebinning.xmin = pset.getParameter<double>("xmin");
   mebinning.xmax = pset.getParameter<double>("xmax");
 }