Inheritance diagram for HIPTwoBodyDecayAnalyzer:

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

	~HIPTwoBodyDecayAnalyzer () override

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

	EDConsumerBase (EDConsumerBase &&)=default

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, 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::ESRecordsToProxyIndices 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)

Public Attributes
edm::EDGetTokenT< reco::TrackCollection >	alcareco_trackCollToken_

edm::EDGetTokenT< reco::TrackCollection >	ctf_trackCollToken_

edm::EDGetTokenT< reco::TrackCollection >	final_trackCollToken_

std::vector< std::pair< std::string, float * > >	floatBranches

std::vector< std::pair< std::string, int * > >	intBranches

edm::EDGetTokenT< reco::TrackCollection >	refit1_trackCollToken_

std::vector< std::pair< std::string, short * > >	shortBranches

TTree *	tree

Private Types
enum	BranchType { BranchType_short_t, BranchType_int_t, BranchType_float_t, BranchType_unknown_t }

Private Member Functions
bool	actuateBranches ()

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

void	analyzeTrackCollection (std::string strTrackType, const TransientTrackBuilder &theTTBuilder, edm::Handle< reco::TrackCollection > &hTrackColl, bool verbose=false)

void	beginJob () override

void	bookAllBranches ()

bool	bookBranch (std::string bname, BranchType btype)

void	cleanBranches ()

void	endJob () override

reco::Vertex	fitDimuonVertex (const TransientTrackBuilder &theTTBuilder, edm::Handle< reco::TrackCollection > &hTrackColl, bool &fitOk)

void	initializeBranches ()

BranchType	searchArray (std::string branchname, int &position)

template<typename varType >
void	setVal (std::string bname, varType value)

Private Attributes
const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	ttkbuilderToken_

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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

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

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

template<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 32 of file HIPTwoBodyDecayAnalyzer.cc.

Member Enumeration Documentation

◆ BranchType

enum HIPTwoBodyDecayAnalyzer::BranchType

private

Enumerator
BranchType_short_t
BranchType_int_t
BranchType_float_t
BranchType_unknown_t

Definition at line 53 of file HIPTwoBodyDecayAnalyzer.cc.

53 { BranchType_short_t, BranchType_int_t, BranchType_float_t, BranchType_unknown_t };

HIPTwoBodyDecayAnalyzer::BranchType_float_t

Definition: HIPTwoBodyDecayAnalyzer.cc:53

HIPTwoBodyDecayAnalyzer::BranchType_int_t

Definition: HIPTwoBodyDecayAnalyzer.cc:53

HIPTwoBodyDecayAnalyzer::BranchType_short_t

Definition: HIPTwoBodyDecayAnalyzer.cc:53

HIPTwoBodyDecayAnalyzer::BranchType_unknown_t

Definition: HIPTwoBodyDecayAnalyzer.cc:53

Constructor & Destructor Documentation

◆ HIPTwoBodyDecayAnalyzer()

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

explicit

Definition at line 91 of file HIPTwoBodyDecayAnalyzer.cc.

References alcareco_trackCollToken_, bookAllBranches(), ctf_trackCollToken_, final_trackCollToken_, compareTotals::fs, edm::ParameterSet::getParameter(), TFileService::kSharedResource, and refit1_trackCollToken_.

     : ttkbuilderToken_(esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))) {
   usesResource(TFileService::kSharedResource);
 
   alcareco_trackCollToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("alcarecotracks"));
   refit1_trackCollToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("refit1tracks"));
   ctf_trackCollToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("refit2tracks"));
   final_trackCollToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("finaltracks"));
 
   edm::Service<TFileService> fs;
 
   tree = fs->make<TTree>("TestTree", "");
   bookAllBranches();
 }

◆ ~HIPTwoBodyDecayAnalyzer()

HIPTwoBodyDecayAnalyzer::~HIPTwoBodyDecayAnalyzer ( )

override

Definition at line 258 of file HIPTwoBodyDecayAnalyzer.cc.

References cleanBranches().

258 { cleanBranches(); }

HIPTwoBodyDecayAnalyzer::cleanBranches

void cleanBranches()

Definition: HIPTwoBodyDecayAnalyzer.cc:127

Member Function Documentation

◆ actuateBranches()

bool HIPTwoBodyDecayAnalyzer::actuateBranches ( )

private

Definition at line 221 of file HIPTwoBodyDecayAnalyzer.cc.

References EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, gather_cfg::cout, floatBranches, intBranches, shortBranches, and summarizeEdmComparisonLogfiles::success.

Referenced by bookAllBranches().

                                               {
   bool success = true;
   std::cout << "Begin HIPTwoBodyDecayAnalyzer::actuateBranches" << std::endl;
   std::cout << "Number of short branches: " << shortBranches.size() << std::endl;
   std::cout << "Number of int branches: " << intBranches.size() << std::endl;
   std::cout << "Number of float branches: " << floatBranches.size() << std::endl;
   if (tree != nullptr) {
     for (unsigned short el = 0; el < shortBranches.size(); el++) {
       std::cout << "Actuating branch " << shortBranches.at(el).first << " at address " << shortBranches.at(el).second
                 << std::endl;
       if (!tree->GetBranchStatus(shortBranches.at(el).first.c_str()))
         tree->Branch(shortBranches.at(el).first.c_str(), shortBranches.at(el).second);
       else
         std::cout << "Failed!" << std::endl;
     }
     for (unsigned int el = 0; el < intBranches.size(); el++) {
       std::cout << "Actuating branch " << intBranches.at(el).first.c_str() << " at address "
                 << intBranches.at(el).second << std::endl;
       if (!tree->GetBranchStatus(intBranches.at(el).first.c_str()))
         tree->Branch(intBranches.at(el).first.c_str(), intBranches.at(el).second);
       else
         std::cout << "Failed!" << std::endl;
     }
     for (unsigned int el = 0; el < floatBranches.size(); el++) {
       std::cout << "Actuating branch " << floatBranches.at(el).first.c_str() << " at address "
                 << floatBranches.at(el).second << std::endl;
       if (!tree->GetBranchStatus(floatBranches.at(el).first.c_str()))
         tree->Branch(floatBranches.at(el).first.c_str(), floatBranches.at(el).second);
       else
         std::cout << "Failed!" << std::endl;
     }
   } else
     success = false;
   if (!success)
     std::cerr << "HIPTwoBodyDecayAnalyzer::actuateBranch: Failed to actuate the branches!" << std::endl;
   return success;
 }

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 260 of file HIPTwoBodyDecayAnalyzer.cc.

References alcareco_trackCollToken_, analyzeTrackCollection(), ctf_trackCollToken_, final_trackCollToken_, edm::EventSetup::getData(), iEvent, initializeBranches(), refit1_trackCollToken_, and ttkbuilderToken_.

                                                                                          {
   using namespace edm;
   using namespace reco;
   using reco::TrackCollection;
 
   edm::Handle<reco::TrackCollection> alcarecotracks;
   iEvent.getByToken(alcareco_trackCollToken_, alcarecotracks);
   edm::Handle<reco::TrackCollection> refit1tracks;
   iEvent.getByToken(refit1_trackCollToken_, refit1tracks);
   edm::Handle<reco::TrackCollection> ctftracks;
   iEvent.getByToken(ctf_trackCollToken_, ctftracks);
   edm::Handle<reco::TrackCollection> finaltracks;
   iEvent.getByToken(final_trackCollToken_, finaltracks);
 
   const auto& theTTBuilder = iSetup.getData(ttkbuilderToken_);
   initializeBranches();
 
   analyzeTrackCollection("alcareco", theTTBuilder, alcarecotracks);
   analyzeTrackCollection("refit1", theTTBuilder, refit1tracks);
   analyzeTrackCollection("refit2", theTTBuilder, ctftracks);
   analyzeTrackCollection("final", theTTBuilder, finaltracks);
 
   tree->Fill();
 }

◆ analyzeTrackCollection()

void HIPTwoBodyDecayAnalyzer::analyzeTrackCollection	(	std::string	strTrackType,
		const TransientTrackBuilder &	theTTBuilder,
		edm::Handle< reco::TrackCollection > &	hTrackColl,
		bool	verbose = `false`
	)

private

Definition at line 294 of file HIPTwoBodyDecayAnalyzer.cc.

References TransientTrackBuilder::build(), EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, ALCARECOTkAlJpsiMuMu_cff::charge, RecoVertex::convertPos(), gather_cfg::cout, reco::TransientTrack::field(), fitDimuonVertex(), reco::TransientTrack::impactPointState(), edm::HandleBase::isValid(), dqmiolumiharvest::j, PV3DBase< T, PVType, FrameType >::mag(), VtxSmearedParameters_cfi::Phi, funct::pow(), setVal(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, HLT_2022v12_cff::track, verbose, X, PV3DBase< T, PVType, FrameType >::x(), BeamSpotPI::Y, PV3DBase< T, PVType, FrameType >::y(), BeamSpotPI::Z, and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

                                                                    {
   if (verbose)
     std::cout << "Starting to process the track collection for " << strTrackType << std::endl;
 
   using namespace edm;
   using namespace reco;
   using reco::TrackCollection;
 
   if (!hTrackColl.isValid()) {
     if (verbose)
       std::cout << "Track collection is invalid." << std::endl;
     return;
   }
   if (hTrackColl->size() < 2) {
     if (verbose)
       std::cout << "Track collection size<2." << std::endl;
     return;
   }
 
   unsigned int itrk = 0;
   unsigned int j = 0;
   int totalcharge = 0;
   bool isValidPair = true;
   bool ZVtxOk = false;
   TLorentzVector trackMom[2];
   TLorentzVector trackMomAfterZVtxFit[2];
   TVector3 trackVtx[2];
 
   for (unsigned int jtrk = 0; jtrk < 2; jtrk++) {
     trackMom[jtrk].SetXYZT(0, 0, 0, 0);
     trackVtx[jtrk].SetXYZ(0, 0, 0);
   }
   for (reco::TrackCollection::const_iterator track = hTrackColl->begin(); track != hTrackColl->end(); ++track) {
     int charge = track->charge();
     totalcharge += charge;
     if (j == 0) {
       itrk = (charge > 0 ? 1 : 0);
     } else
       itrk = 1 - itrk;
     trackMom[itrk].SetPtEtaPhiM(track->pt(), track->eta(), track->phi(), 0.105);
     trackVtx[itrk].SetXYZ(track->vx(), track->vy(), track->vz());
     j++;
     if (j == 2)
       break;
   }
 
   isValidPair = (totalcharge == 0 && trackMom[0].P() != 0. && trackMom[1].P() != 0.);
   if (verbose && !isValidPair)
     std::cout << "Track collection does not contain a valid std::pair." << std::endl;
   setVal(strTrackType + "_present", (isValidPair ? (short)1 : (short)0));
   if (isValidPair) {
     TLorentzVector ZMom = trackMom[0] + trackMom[1];
     setVal(strTrackType + "_ZPt", (float)ZMom.Pt());
     setVal(strTrackType + "_ZPz", (float)ZMom.Pz());
     setVal(strTrackType + "_ZPhi", (float)ZMom.Phi());
     setVal(strTrackType + "_ZMass", (float)ZMom.M());
 
     reco::Vertex ZVtx = fitDimuonVertex(theTTBuilder, hTrackColl, ZVtxOk);
     if (ZVtxOk) {
       setVal(strTrackType + "_ZVertex_x", (float)ZVtx.x());
       setVal(strTrackType + "_ZVertex_y", (float)ZVtx.y());
       setVal(strTrackType + "_ZVertex_z", (float)ZVtx.z());
       setVal(strTrackType + "_ZVertex_NormChi2", (float)ZVtx.normalizedChi2());
 
       // Recalculate track momenta with this vertex as reference
       j = 0;
       for (reco::TrackCollection::const_iterator track = hTrackColl->begin(); track != hTrackColl->end(); ++track) {
         TransientTrack t_track = theTTBuilder.build(&(*track));
         AnalyticalImpactPointExtrapolator extrapolator(t_track.field());
         TrajectoryStateOnSurface closestIn3DSpaceState =
             extrapolator.extrapolate(t_track.impactPointState(), RecoVertex::convertPos(ZVtx.position()));
         GlobalVector mom = closestIn3DSpaceState.globalMomentum();
         int charge = track->charge();
         totalcharge += charge;
         if (j == 0) {
           itrk = (charge > 0 ? 1 : 0);
         } else
           itrk = 1 - itrk;
         trackMomAfterZVtxFit[itrk].SetXYZT(mom.x(), mom.y(), mom.z(), sqrt(pow(0.105, 2) + pow(mom.mag(), 2)));
         j++;
         if (j == 2)
           break;
       }
       if (totalcharge != 0)
         std::cerr
             << "HIPTwoBodyDecayAnalyzer::analyzeTrackCollection: Something went wrong! The total charge is no longer 0!"
             << std::endl;
       for (unsigned int jtrk = 0; jtrk < 2; jtrk++) {
         std::string strMuCore = (jtrk == 0 ? "MuMinus" : "MuPlus");
         setVal(strTrackType + "_" + strMuCore + "Pt_AfterZVtxFit", (float)trackMomAfterZVtxFit[jtrk].Pt());
         setVal(strTrackType + "_" + strMuCore + "Pz_AfterZVtxFit", (float)trackMomAfterZVtxFit[jtrk].Pz());
         setVal(strTrackType + "_" + strMuCore + "Phi_AfterZVtxFit", (float)trackMomAfterZVtxFit[jtrk].Phi());
       }
       TLorentzVector ZMom_AfterZVtxFit = trackMomAfterZVtxFit[0] + trackMomAfterZVtxFit[1];
       setVal(strTrackType + "_ZPt_AfterZVtxFit", (float)ZMom_AfterZVtxFit.Pt());
       setVal(strTrackType + "_ZPz_AfterZVtxFit", (float)ZMom_AfterZVtxFit.Pz());
       setVal(strTrackType + "_ZPhi_AfterZVtxFit", (float)ZMom_AfterZVtxFit.Phi());
       setVal(strTrackType + "_ZMass_AfterZVtxFit", (float)ZMom_AfterZVtxFit.M());
     } else
       std::cerr << "HIPTwoBodyDecayAnalyzer::analyzeTrackCollection: Z vertex fit failed for track collection "
                 << strTrackType << std::endl;
   }
   setVal(strTrackType + "_ZVtxFitOk", (ZVtxOk ? (short)1 : (short)0));
   for (unsigned int jtrk = 0; jtrk < 2; jtrk++) {
     std::string strMuCore = (jtrk == 0 ? "MuMinus" : "MuPlus");
     setVal(strTrackType + "_" + strMuCore + "Pt", (float)trackMom[jtrk].Pt());
     setVal(strTrackType + "_" + strMuCore + "Pz", (float)trackMom[jtrk].Pz());
     setVal(strTrackType + "_" + strMuCore + "Phi", (float)trackMom[jtrk].Phi());
     setVal(strTrackType + "_" + strMuCore + "Vertex_x", (float)trackVtx[jtrk].X());
     setVal(strTrackType + "_" + strMuCore + "Vertex_y", (float)trackVtx[jtrk].Y());
     setVal(strTrackType + "_" + strMuCore + "Vertex_z", (float)trackVtx[jtrk].Z());
   }
 }

◆ beginJob()

void HIPTwoBodyDecayAnalyzer::beginJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 285 of file HIPTwoBodyDecayAnalyzer.cc.

285 {}

◆ bookAllBranches()

void HIPTwoBodyDecayAnalyzer::bookAllBranches ( )

private

Definition at line 162 of file HIPTwoBodyDecayAnalyzer.cc.

References actuateBranches(), bookBranch(), BranchType_float_t, BranchType_short_t, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by HIPTwoBodyDecayAnalyzer().

                                               {
   const int nTrackTypes = 4;
   std::vector<std::string> strTrackTypes;
   strTrackTypes.reserve(nTrackTypes);
   strTrackTypes.push_back("alcareco");
   strTrackTypes.push_back("refit1");
   strTrackTypes.push_back("refit2");
   strTrackTypes.push_back("final");
   for (unsigned int it = 0; it < nTrackTypes; it++) {
     std::string& strTrackType = strTrackTypes[it];
     bookBranch(strTrackType + "_present", BranchType_short_t);
     bookBranch(strTrackType + "_ZVtxFitOk", BranchType_short_t);
     bookBranch(strTrackType + "_ZMass", BranchType_float_t);
     bookBranch(strTrackType + "_ZPt", BranchType_float_t);
     bookBranch(strTrackType + "_ZPz", BranchType_float_t);
     bookBranch(strTrackType + "_ZPhi", BranchType_float_t);
     bookBranch(strTrackType + "_ZVertex_x", BranchType_float_t);
     bookBranch(strTrackType + "_ZVertex_y", BranchType_float_t);
     bookBranch(strTrackType + "_ZVertex_z", BranchType_float_t);
     bookBranch(strTrackType + "_ZVertex_NormChi2", BranchType_float_t);
     bookBranch(strTrackType + "_MuPlusVertex_x", BranchType_float_t);
     bookBranch(strTrackType + "_MuPlusVertex_y", BranchType_float_t);
     bookBranch(strTrackType + "_MuPlusVertex_z", BranchType_float_t);
     bookBranch(strTrackType + "_MuMinusPt_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_MuMinusPz_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_MuMinusPhi_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_MuPlusPt_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_MuPlusPz_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_MuPlusPhi_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_ZMass_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_ZPt_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_ZPz_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_ZPhi_AfterZVtxFit", BranchType_float_t);
     bookBranch(strTrackType + "_MuMinusPt", BranchType_float_t);
     bookBranch(strTrackType + "_MuMinusPz", BranchType_float_t);
     bookBranch(strTrackType + "_MuMinusPhi", BranchType_float_t);
     bookBranch(strTrackType + "_MuMinusVertex_x", BranchType_float_t);
     bookBranch(strTrackType + "_MuMinusVertex_y", BranchType_float_t);
     bookBranch(strTrackType + "_MuMinusVertex_z", BranchType_float_t);
     bookBranch(strTrackType + "_MuPlusPt", BranchType_float_t);
     bookBranch(strTrackType + "_MuPlusPz", BranchType_float_t);
     bookBranch(strTrackType + "_MuPlusPhi", BranchType_float_t);
   }
   actuateBranches();
 }

◆ bookBranch()

bool HIPTwoBodyDecayAnalyzer::bookBranch	(	std::string	bname,
		BranchType	btype
	)

private

Definition at line 207 of file HIPTwoBodyDecayAnalyzer.cc.

References BranchType_float_t, BranchType_int_t, BranchType_short_t, CalibrationSummaryClient_cfi::btype, EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, floatBranches, intBranches, and shortBranches.

Referenced by bookAllBranches().

                                                                           {
   if (btype == BranchType_float_t)
     floatBranches.emplace_back(bname, new float);
   else if (btype == BranchType_int_t)
     intBranches.emplace_back(bname, new int);
   else if (btype == BranchType_short_t)
     shortBranches.emplace_back(bname, new short);
   else {
     std::cerr << "HIPTwoBodyDecayAnalyzer::bookBranch: No support for type " << btype << " for the branch " << bname
               << " is available." << std::endl;
     return false;
   }
   return true;
 }

◆ cleanBranches()

void HIPTwoBodyDecayAnalyzer::cleanBranches ( )

private

Definition at line 127 of file HIPTwoBodyDecayAnalyzer.cc.

References floatBranches, intBranches, and shortBranches.

Referenced by ~HIPTwoBodyDecayAnalyzer().

                                             {
   for (unsigned short el = 0; el < shortBranches.size(); el++) {
     if (shortBranches.at(el).second != nullptr)
       delete shortBranches.at(el).second;
     shortBranches.at(el).second = nullptr;
   }
   shortBranches.clear();
   for (unsigned int el = 0; el < intBranches.size(); el++) {
     if (intBranches.at(el).second != nullptr)
       delete intBranches.at(el).second;
     intBranches.at(el).second = nullptr;
   }
   intBranches.clear();
   for (unsigned int el = 0; el < floatBranches.size(); el++) {
     if (floatBranches.at(el).second != nullptr)
       delete floatBranches.at(el).second;
     floatBranches.at(el).second = nullptr;
   }
   floatBranches.clear();
 }

◆ endJob()

void HIPTwoBodyDecayAnalyzer::endJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 286 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by o2olib.O2ORunMgr::executeJob().

286 {}

◆ fillDescriptions()

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

static

Definition at line 288 of file HIPTwoBodyDecayAnalyzer.cc.

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

                                                                                          {
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

◆ fitDimuonVertex()

reco::Vertex HIPTwoBodyDecayAnalyzer::fitDimuonVertex	(	const TransientTrackBuilder &	theTTBuilder,
		edm::Handle< reco::TrackCollection > &	hTrackColl,
		bool &	fitOk
	)

private

Definition at line 411 of file HIPTwoBodyDecayAnalyzer.cc.

References TransientTrackBuilder::build(), TransientVertex::degreesOfFreedom(), TransientVertex::isValid(), GlobalErrorBase< T, ErrorWeightType >::matrix(), TransientVertex::position(), TransientVertex::positionError(), TransientVertex::totalChiSquared(), HLT_2022v12_cff::track, groupFilesInBlocks::tt, and KalmanVertexFitter::vertex().

Referenced by analyzeTrackCollection().

                                                                    {
   using namespace edm;
   using namespace reco;
 
   std::vector<TransientTrack> t_tks;
   for (TrackCollection::const_iterator track = hTrackColl->begin(); track != hTrackColl->end(); ++track) {
     TransientTrack tt = theTTBuilder.build(&(*track));
     t_tks.push_back(tt);
   }
 
   // Kalman vertex fit without constraint
   KalmanVertexFitter vtxFitter;
   TransientVertex stdVertex = vtxFitter.vertex(t_tks);
   fitOk = stdVertex.isValid();
   if (fitOk) {
     reco::Vertex stdRecoVertex(Vertex::Point(stdVertex.position()),
                                stdVertex.positionError().matrix(),
                                stdVertex.totalChiSquared(),
                                stdVertex.degreesOfFreedom(),
                                0);
     return stdRecoVertex;
   } else {
     reco::Vertex stdRecoVertex;
     return stdRecoVertex;
   }
 }

◆ initializeBranches()

void HIPTwoBodyDecayAnalyzer::initializeBranches ( )

private

Definition at line 147 of file HIPTwoBodyDecayAnalyzer.cc.

References floatBranches, intBranches, and shortBranches.

Referenced by analyze().

                                                  {
   for (unsigned short el = 0; el < shortBranches.size(); el++) {
     if (shortBranches.at(el).second != nullptr)
       *(shortBranches.at(el).second) = 0;
   }
   for (unsigned int el = 0; el < intBranches.size(); el++) {
     if (intBranches.at(el).second != nullptr)
       *(intBranches.at(el).second) = 0;
   }
   for (unsigned int el = 0; el < floatBranches.size(); el++) {
     if (floatBranches.at(el).second != nullptr)
       *(floatBranches.at(el).second) = 0;
   }
 }

◆ searchArray()

HIPTwoBodyDecayAnalyzer::BranchType HIPTwoBodyDecayAnalyzer::searchArray	(	std::string	branchname,
		int &	position
	)

private

Definition at line 106 of file HIPTwoBodyDecayAnalyzer.cc.

References BranchType_float_t, BranchType_int_t, BranchType_short_t, BranchType_unknown_t, floatBranches, intBranches, position, and shortBranches.

Referenced by setVal().

                                                                                                           {
   for (unsigned short el = 0; el < shortBranches.size(); el++) {
     if (branchname == shortBranches.at(el).first) {
       position = el;
       return BranchType_short_t;
     }
   }
   for (unsigned int el = 0; el < intBranches.size(); el++) {
     if (branchname == intBranches.at(el).first) {
       position = el;
       return BranchType_int_t;
     }
   }
   for (unsigned int el = 0; el < floatBranches.size(); el++) {
     if (branchname == floatBranches.at(el).first) {
       position = el;
       return BranchType_float_t;
     }
   }
   return BranchType_unknown_t;
 }

◆ setVal()

template<typename varType >

void HIPTwoBodyDecayAnalyzer::setVal	(	std::string	bname,
		varType	value
	)

inlineprivate

Definition at line 63 of file HIPTwoBodyDecayAnalyzer.cc.

References BranchType_float_t, BranchType_int_t, BranchType_short_t, EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, floatBranches, intBranches, searchArray(), and shortBranches.

Referenced by analyzeTrackCollection().

                                               {
     int varposition = -1;
     BranchType varbranchtype = searchArray(bname, varposition);
     if (varposition == -1)
       std::cerr << "HIPTwoBodyDecayAnalyzer::setVal -> Could not find the branch called " << bname << "!" << std::endl;
     else if (varbranchtype == BranchType_short_t)
       *(shortBranches.at(varposition).second) = value;
     else if (varbranchtype == BranchType_int_t)
       *(intBranches.at(varposition).second) = value;
     else if (varbranchtype == BranchType_float_t)
       *(floatBranches.at(varposition).second) = value;
     else
       std::cerr << "HIPTwoBodyDecayAnalyzer::setVal -> Could not find the type " << varbranchtype
                 << " for branch called " << bname << "!" << std::endl;
   }

Member Data Documentation

◆ alcareco_trackCollToken_

edm::EDGetTokenT<reco::TrackCollection> HIPTwoBodyDecayAnalyzer::alcareco_trackCollToken_

Definition at line 37 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by analyze(), and HIPTwoBodyDecayAnalyzer().

◆ ctf_trackCollToken_

edm::EDGetTokenT<reco::TrackCollection> HIPTwoBodyDecayAnalyzer::ctf_trackCollToken_

Definition at line 39 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by analyze(), and HIPTwoBodyDecayAnalyzer().

◆ final_trackCollToken_

edm::EDGetTokenT<reco::TrackCollection> HIPTwoBodyDecayAnalyzer::final_trackCollToken_

Definition at line 40 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by analyze(), and HIPTwoBodyDecayAnalyzer().

◆ floatBranches

std::vector<std::pair<std::string, float*> > HIPTwoBodyDecayAnalyzer::floatBranches

Definition at line 45 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by actuateBranches(), bookBranch(), cleanBranches(), initializeBranches(), searchArray(), and setVal().

◆ intBranches

std::vector<std::pair<std::string, int*> > HIPTwoBodyDecayAnalyzer::intBranches

Definition at line 46 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by actuateBranches(), bookBranch(), cleanBranches(), initializeBranches(), searchArray(), and setVal().

◆ refit1_trackCollToken_

edm::EDGetTokenT<reco::TrackCollection> HIPTwoBodyDecayAnalyzer::refit1_trackCollToken_

Definition at line 38 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by analyze(), and HIPTwoBodyDecayAnalyzer().

◆ shortBranches

std::vector<std::pair<std::string, short*> > HIPTwoBodyDecayAnalyzer::shortBranches

Definition at line 47 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by actuateBranches(), bookBranch(), cleanBranches(), initializeBranches(), searchArray(), and setVal().

◆ tree

TTree* HIPTwoBodyDecayAnalyzer::tree

Definition at line 44 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by eventstfile.Events::__iter__(), svgfig.SVG::__str__(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::beginLoop(), tree.Tree::branch_(), MetTreeProducer.MetTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::declareVariables(), TkAlMap.TkAlMap::detect_tracker_version(), core.AutoFillTreeProducer.AutoFillTreeProducer::fillTree(), SimpleTreeProducer.SimpleTreeProducer::process(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::process(), MetTreeProducer.MetTreeProducer::process(), python.cmstools.EventTree::SetAlias(), eventstfile.Events::size(), eventstfile.Events::to(), tree.Tree::var(), and tree.Tree::vector().

◆ ttkbuilderToken_

const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> HIPTwoBodyDecayAnalyzer::ttkbuilderToken_

private

Definition at line 51 of file HIPTwoBodyDecayAnalyzer.cc.

Referenced by analyze().

Public Member Functions

Static Public Member Functions

Public Attributes

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ BranchType

Constructor & Destructor Documentation

◆ HIPTwoBodyDecayAnalyzer()

◆ ~HIPTwoBodyDecayAnalyzer()

Member Function Documentation

◆ actuateBranches()

◆ analyze()

◆ analyzeTrackCollection()

◆ beginJob()

◆ bookAllBranches()

◆ bookBranch()

◆ cleanBranches()

◆ endJob()

◆ fillDescriptions()

◆ fitDimuonVertex()

◆ initializeBranches()

◆ searchArray()

◆ setVal()

Member Data Documentation

◆ alcareco_trackCollToken_

◆ ctf_trackCollToken_

◆ final_trackCollToken_

◆ floatBranches

◆ intBranches

◆ refit1_trackCollToken_

◆ shortBranches

◆ tree

◆ ttkbuilderToken_