HIPTwoBodyDecayAnalyzer Class Reference

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
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)

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 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.

{ BranchType_short_t, BranchType_int_t, BranchType_float_t, BranchType_unknown_t };

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().

{ cleanBranches(); }

Member Function Documentation

actuateBranches()

bool HIPTwoBodyDecayAnalyzer::actuateBranches ( )

private

Definition at line 221 of file HIPTwoBodyDecayAnalyzer.cc.

References DMR_cfg::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(), DMR_cfg::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_2024v13_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.

{}

bookAllBranches()

void HIPTwoBodyDecayAnalyzer::bookAllBranches ( )

private

Definition at line 162 of file HIPTwoBodyDecayAnalyzer.cc.

References actuateBranches(), bookBranch(), BranchType_float_t, BranchType_short_t, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, 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, DMR_cfg::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().

{}

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_2024v13_cff::track, 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, DMR_cfg::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().