diff --git a/PWGDQ/Core/CutsLibrary.cxx b/PWGDQ/Core/CutsLibrary.cxx index 426588fdb2b..d0e3f9110a2 100644 --- a/PWGDQ/Core/CutsLibrary.cxx +++ b/PWGDQ/Core/CutsLibrary.cxx @@ -362,6 +362,12 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) return cut; } + if (!nameStr.compare("pionPIDCut1")) { + cut->AddCut(GetAnalysisCut("pionQualityCut1")); + cut->AddCut(GetAnalysisCut("pionPIDnsigma")); + return cut; + } + if (!nameStr.compare("PIDCalibElectron")) { cut->AddCut(GetAnalysisCut("pidcalib_ele")); return cut; @@ -938,13 +944,13 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) } std::vector vecTypetrack; - vecTypetrack.emplace_back(""); // default TightGlobalTrackRun3 - vecTypetrack.emplace_back("_7ITSncls"); // default TightGlobalTrackRun3 but with 7 ITS clusters - vecTypetrack.emplace_back("_ITS"); // Ask only for ITS requirements - vecTypetrack.emplace_back("_ITSalone"); // Ask only for ITS requirements + ITSalone (no TPC matching) - vecTypetrack.emplace_back("_TPC"); // Ask only for TPC requirements - vecTypetrack.emplace_back("_TPCalone"); // Ask only for TPC requirements + TPCalone (no ITS matching) - vecTypetrack.emplace_back("_TPCnoTRD"); // Ask only for TPC requirements no TRD matching + vecTypetrack.emplace_back(""); // default TightGlobalTrackRun3 + vecTypetrack.emplace_back("_7ITSncls"); // default TightGlobalTrackRun3 but with 7 ITS clusters + vecTypetrack.emplace_back("_ITS"); // Ask only for ITS requirements + vecTypetrack.emplace_back("_ITSalone"); // Ask only for ITS requirements + ITSalone (no TPC matching) + vecTypetrack.emplace_back("_TPC"); // Ask only for TPC requirements + vecTypetrack.emplace_back("_TPCalone"); // Ask only for TPC requirements + TPCalone (no ITS matching) + vecTypetrack.emplace_back("_TPCnoTRD"); // Ask only for TPC requirements no TRD matching vecTypetrack.emplace_back("_TPCstrongncls"); // default TightGlobalTrackRun3 but with 130 TPC clusters // loop to define PID cuts with and without post calibration @@ -2402,6 +2408,11 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) return cut; } + if (!nameStr.compare("pairJpsi2")) { + cut->AddCut(GetAnalysisCut("pairJpsi2")); + return cut; + } + if (!nameStr.compare("pairPsi2S")) { cut->AddCut(GetAnalysisCut("pairPsi2S")); return cut; @@ -2412,6 +2423,16 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) return cut; } + if (!nameStr.compare("pairX3872Cut1")) { + cut->AddCut(GetAnalysisCut("pairX3872")); + return cut; + } + + if (!nameStr.compare("DipionPairCut1")) { + cut->AddCut(GetAnalysisCut("DipionMassCut1")); + return cut; + } + if (!nameStr.compare("pairRapidityForward")) { cut->AddCut(GetAnalysisCut("pairRapidityForward")); return cut; @@ -2912,13 +2933,13 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) } std::vector vecTypetrack; - vecTypetrack.emplace_back(""); // default TightGlobalTrackRun3 as above - vecTypetrack.emplace_back("_7ITSncls"); // default TightGlobalTrackRun3 but with 7 ITS clusters - vecTypetrack.emplace_back("_ITS"); // Ask only for ITS requirements - vecTypetrack.emplace_back("_ITSalone"); // Ask only for ITS requirements + ITSalone (no TPC matching) - vecTypetrack.emplace_back("_TPC"); // Ask only for TPC requirements - vecTypetrack.emplace_back("_TPCalone"); // Ask only for TPC requirements + TPCalone (no ITS matching) - vecTypetrack.emplace_back("_TPCnoTRD"); // Ask only for TPC requirements no TRD matching + vecTypetrack.emplace_back(""); // default TightGlobalTrackRun3 as above + vecTypetrack.emplace_back("_7ITSncls"); // default TightGlobalTrackRun3 but with 7 ITS clusters + vecTypetrack.emplace_back("_ITS"); // Ask only for ITS requirements + vecTypetrack.emplace_back("_ITSalone"); // Ask only for ITS requirements + ITSalone (no TPC matching) + vecTypetrack.emplace_back("_TPC"); // Ask only for TPC requirements + vecTypetrack.emplace_back("_TPCalone"); // Ask only for TPC requirements + TPCalone (no ITS matching) + vecTypetrack.emplace_back("_TPCnoTRD"); // Ask only for TPC requirements no TRD matching vecTypetrack.emplace_back("_TPCstrongncls"); // default TightGlobalTrackRun3 but with 130 TPC clusters // loop to define PID cuts with and without post calibration @@ -3068,6 +3089,15 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) return cut; } + if (!nameStr.compare("pionQualityCut1")) { + cut->AddCut(VarManager::kPt, 0.15, 1000.0); + cut->AddCut(VarManager::kIsITSibAny, 0.5, 1.5); + cut->AddCut(VarManager::kTPCncls, 100, 161); + cut->AddCut(VarManager::kTrackDCAxy, -0.05, 0.05); + cut->AddCut(VarManager::kTrackDCAz, -0.1, 0.1); + return cut; + } + if (!nameStr.compare("pidbasic")) { cut->AddCut(VarManager::kEta, -0.9, 0.9); cut->AddCut(VarManager::kTPCncls, 60, 161.); @@ -4343,6 +4373,11 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) return cut; } + if (!nameStr.compare("DipionMassCut1")) { + cut->AddCut(VarManager::kMass, 0.5, 1.0); + return cut; + } + if (!nameStr.compare("pairMassLow1")) { cut->AddCut(VarManager::kMass, 1.0, 1000.0); return cut; @@ -4438,6 +4473,11 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) return cut; } + if (!nameStr.compare("pairJpsi2")) { + cut->AddCut(VarManager::kMass, 2.72, 3.2); + return cut; + } + if (!nameStr.compare("pairPsi2S")) { cut->AddCut(VarManager::kMass, 3.4, 3.9); return cut; @@ -4448,6 +4488,11 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) return cut; } + if (!nameStr.compare("pairX3872")) { + cut->AddCut(VarManager::kCosthetaDileptonDitrack, 0.98, 1); + return cut; + } + if (!nameStr.compare("pairPtLow1")) { cut->AddCut(VarManager::kPt, 2.0, 1000.0); return cut; diff --git a/PWGDQ/Core/HistogramsLibrary.cxx b/PWGDQ/Core/HistogramsLibrary.cxx index c4fbf243bca..50d7f5b0a5d 100644 --- a/PWGDQ/Core/HistogramsLibrary.cxx +++ b/PWGDQ/Core/HistogramsLibrary.cxx @@ -1010,4 +1010,14 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h hm->AddHistogram(histClass, "hPhiVsPtVsBdtDmesonWithJPsi", "", false, 100, 0.f, 1.f, VarManager::kBdtCharmHadron, 100, 0.f, 50.f, VarManager::kPtCharmHadron, 180, 0., 2 * constants::math::PI, VarManager::kPhiCharmHadron); } } + if (groupStr.Contains("dilepton-dihadron")) { + if (subGroupStr.EqualTo("xtojpsipipi")) { + hm->AddHistogram(histClass, "hMass_X3872", "", false, 1000, 3.0, 5.0, VarManager::kQuadMass); + hm->AddHistogram(histClass, "hPt_X3872", "", false, 200, 0.0, 20.0, VarManager::kQuadPt); + hm->AddHistogram(histClass, "hMass_Pt_X3872", "", false, 1000, 3.0, 5.0, VarManager::kQuadMass, 150, 0.0, 15.0, VarManager::kQuadPt); + hm->AddHistogram(histClass, "hCostheta_Jpsi_Dihadron", "", false, 100, -1.0, 1.0, VarManager::kCosthetaDileptonDitrack); + hm->AddHistogram(histClass, "hPtDilepton_PtDihadron", "", false, 200, 0, 20, VarManager::kPairPt, 100, 0, 10, VarManager::kDitrackPt); + hm->AddHistogram(histClass, "hPtDilepton_MassDihadron", "", false, 200, 0, 20, VarManager::kPairPt, 100, 3.0, 5.0, VarManager::kDitrackMass); + } + } } diff --git a/PWGDQ/Core/VarManager.cxx b/PWGDQ/Core/VarManager.cxx index 35d061eff32..dc421e1753e 100644 --- a/PWGDQ/Core/VarManager.cxx +++ b/PWGDQ/Core/VarManager.cxx @@ -776,4 +776,18 @@ void VarManager::SetDefaultVarNames() fgVariableUnits[kIsSingleGapA] = ""; fgVariableNames[kIsSingleGapC] = "is single gap event side C"; fgVariableUnits[kIsSingleGapC] = ""; + fgVariableNames[kQuadMass] = "mass quadruplet"; + fgVariableUnits[kQuadMass] = "GeV/c2"; + fgVariableNames[kQuadPt] = "p_{T}"; + fgVariableUnits[kQuadPt] = "GeV/c"; + fgVariableNames[kQuadEta] = "#eta"; + fgVariableUnits[kQuadEta] = ""; + fgVariableNames[kQuadPhi] = "#varphi"; + fgVariableUnits[kQuadPhi] = "rad."; + fgVariableNames[kCosthetaDileptonDitrack] = "cos#it{#theta}_{dilepton-ditrack}"; + fgVariableUnits[kCosthetaDileptonDitrack] = ""; + fgVariableNames[kDitrackMass] = "mass di-track"; + fgVariableUnits[kDitrackMass] = "GeV/c2"; + fgVariableNames[kDitrackPt] = "p_{T}"; + fgVariableUnits[kDitrackPt] = "GeV/c"; } diff --git a/PWGDQ/Core/VarManager.h b/PWGDQ/Core/VarManager.h index 0f799763d7c..0b88d7c351d 100644 --- a/PWGDQ/Core/VarManager.h +++ b/PWGDQ/Core/VarManager.h @@ -126,6 +126,8 @@ class VarManager : public TObject kElectronMuon, // e.g. Electron - muon correlations kBcToThreeMuons, // e.g. Bc -> mu+ mu- mu+ kBtoJpsiEEK, // e.g. B+ -> e+ e- K+ + kXtoJpsiPiPi, // e.g. X(3872) -> J/psi pi+ pi- + kChictoJpsiEE, // e.g. Chi_c1 -> J/psi e+ e- kNMaxCandidateTypes }; @@ -529,6 +531,15 @@ class VarManager : public TObject kDeltaPhiSym, kNCorrelationVariables, + // Dilepton-track-track variables + kQuadMass, + kQuadPt, + kQuadEta, + kQuadPhi, + kCosthetaDileptonDitrack, + kDitrackMass, + kDitrackPt, + // DQ-HF correlation variables kMassCharmHadron, kPtCharmHadron, @@ -760,6 +771,8 @@ class VarManager : public TObject static void FillQVectorFromCentralFW(C const& collision, float* values = nullptr); template static void FillPairVn(T1 const& t1, T2 const& t2, float* values = nullptr); + template + static void FillDileptonTrackTrack(T1 const& dilepton, T2 const& hadron1, T3 const& hadron2, float* values = nullptr); static void SetCalibrationObject(CalibObjects calib, TObject* obj) { @@ -3030,4 +3043,44 @@ void VarManager::FillDileptonCharmHadron(DQ const& dilepton, HF const& charmHadr FillSingleDileptonCharmHadron(charmHadron, hfHelper, bdtScoreCharmHad, values); } +template +void VarManager::FillDileptonTrackTrack(T1 const& dilepton, T2 const& hadron1, T3 const& hadron2, float* values) +{ + if (!values) { + values = fgValues; + } + + double DefaultdileptonMass = 3.096; + double hadronMass1 = o2::constants::physics::MassPionCharged; + double hadronMass2 = o2::constants::physics::MassPionCharged; + if (candidateType == kXtoJpsiPiPi) { + DefaultdileptonMass = 3.096; + hadronMass1 = o2::constants::physics::MassPionCharged; + hadronMass2 = o2::constants::physics::MassPionCharged; + } + if (candidateType == kChictoJpsiEE) { + DefaultdileptonMass = 3.096; + hadronMass1 = o2::constants::physics::MassElectron; + hadronMass2 = o2::constants::physics::MassElectron; + } + + ROOT::Math::PtEtaPhiMVector v1(dilepton.pt(), dilepton.eta(), dilepton.phi(), dilepton.mass()); + ROOT::Math::PtEtaPhiMVector v2(hadron1.pt(), hadron1.eta(), hadron1.phi(), hadronMass1); + ROOT::Math::PtEtaPhiMVector v3(hadron2.pt(), hadron2.eta(), hadron2.phi(), hadronMass2); + ROOT::Math::PtEtaPhiMVector v123 = v1 + v2 + v3; + values[kQuadMass] = v123.M() - v1.M() + DefaultdileptonMass; + values[kQuadPt] = v123.Pt(); + values[kQuadEta] = v123.Eta(); + values[kQuadPhi] = v123.Phi(); + + if (fgUsedVars[kCosthetaDileptonDitrack] || fgUsedVars[kPairMass] || fgUsedVars[kPairPt] || fgUsedVars[kDitrackPt] || fgUsedVars[kDitrackMass]) { + ROOT::Math::PtEtaPhiMVector v23 = v2 + v3; + values[kPairMass] = v1.M(); + values[kPairPt] = v1.Pt(); + values[kDitrackMass] = v23.M(); + values[kDitrackPt] = v23.Pt(); + values[kCosthetaDileptonDitrack] = (v1.Px() * v123.Px() + v1.Py() * v123.Py() + v1.Pz() * v123.Pz()) / (v1.P() * v123.P()); + } +} + #endif // PWGDQ_CORE_VARMANAGER_H_ diff --git a/PWGDQ/Tasks/tableReader.cxx b/PWGDQ/Tasks/tableReader.cxx index 0245db2c2f9..3736d01890b 100644 --- a/PWGDQ/Tasks/tableReader.cxx +++ b/PWGDQ/Tasks/tableReader.cxx @@ -1571,6 +1571,180 @@ struct AnalysisDileptonHadron { PROCESS_SWITCH(AnalysisDileptonHadron, processDummy, "Dummy function", false); }; +struct AnalysisDileptonTrackTrack { + OutputObj fOutputList{"output"}; + + Configurable fConfigTrackCuts{"cfgTrackCuts", "jpsiO2MCdebugCuts2", "Comma separated list of barrel track cuts"}; // used for select the tracks from SelectedTracks + Configurable fConfigDileptonCut{"cfgDiLeptonCut", "pairJpsi", "Dilepton cut"}; + Configurable fConfigDitrackCut{"cfgDiTrackCut", "pairNoCut", "Track-Track cut"}; + Configurable fConfigQuadrupletCut{"cfgQuadrupletCut", "pairNoCut", "Dilepton-Track-Track cut"}; + Configurable fConfigAddDileptonHistogram{"cfgAddDileptonHistogram", "berral", "Comma separated list of histograms"}; + Configurable fConfigAddDitrackHistogram{"cfgAddDitrackHistogram", "berral", "Comma separated list of histograms"}; + Configurable fConfigAddQuadrupletHistogram{"cfgAddQuadrupletHistogram", "XtoJpsipipi", "Comma separated list of histograms"}; + + Filter eventFilter = aod::dqanalysisflags::isEventSelected == 1; + Filter dileptonFilter = aod::reducedpair::mass > 1.0f && aod::reducedpair::mass < 4.0f; + Filter filterBarrelTrackSelected = aod::dqanalysisflags::isBarrelSelected > 0; + + constexpr static uint32_t fgDileptonFillMap = VarManager::ObjTypes::ReducedTrack | VarManager::ObjTypes::Pair; // fill map + + // use some values array to avoid mixing up the quantities + float* fValuesDitrack; + float* fValuesQuadruplet; + HistogramManager* fHistMan; + + uint32_t fDileptonFilter = 0; + uint32_t fHadronFilter = 0; + int fIsUnlikeSignDilepton = 0; + int fIsUnlikeSignDitrack = 0; + AnalysisCompositeCut fDileptonCut; + AnalysisCompositeCut fDitrackCut; + AnalysisCompositeCut fQuadrupletCut; + std::vector fTrackCutNames; + + void init(o2::framework::InitContext& context) + { + fValuesDitrack = new float[VarManager::kNVars]; + fValuesQuadruplet = new float[VarManager::kNVars]; + VarManager::SetDefaultVarNames(); + fHistMan = new HistogramManager("analysisHistos", "aa", VarManager::kNVars); + fHistMan->SetUseDefaultVariableNames(kTRUE); + fHistMan->SetDefaultVarNames(VarManager::fgVariableNames, VarManager::fgVariableUnits); + + // define cuts + TString configTrackCutNamesStr = fConfigTrackCuts.value; + TString configDileptonCutNamesStr = fConfigDileptonCut.value; + fDileptonCut = *dqcuts::GetCompositeCut(configDileptonCutNamesStr.Data()); + TString configDitrackCutNamesStr = fConfigDitrackCut.value; + fDitrackCut = *dqcuts::GetCompositeCut(configDitrackCutNamesStr.Data()); + TString configQuadruletCutNamesStr = fConfigQuadrupletCut.value; + fQuadrupletCut = *dqcuts::GetCompositeCut(configQuadruletCutNamesStr.Data()); + + if (!context.mOptions.get("processDummy")) { + // define histograms for dilepton + DefineHistograms(fHistMan, Form("DileptonsSelectedUS_%s", configDileptonCutNamesStr.Data()), fConfigAddDileptonHistogram); + DefineHistograms(fHistMan, Form("DileptonsSelectedLS_%s", configDileptonCutNamesStr.Data()), fConfigAddDileptonHistogram); + if (!configTrackCutNamesStr.IsNull()) { + std::unique_ptr objArray(configTrackCutNamesStr.Tokenize(",")); + for (Int_t icut = 0; icut < objArray->GetEntries(); ++icut) { + TString cutName = objArray->At(icut)->GetName(); + fTrackCutNames.push_back(cutName); + DefineHistograms(fHistMan, Form("DitrackSelected_%s_%s", configDitrackCutNamesStr.Data(), cutName.Data()), fConfigAddDitrackHistogram); + DefineHistograms(fHistMan, Form("QuadrupletSEUSUS_%s_%s_%s", configDileptonCutNamesStr.Data(), configDitrackCutNamesStr.Data(), cutName.Data()), fConfigAddQuadrupletHistogram); + DefineHistograms(fHistMan, Form("QuadrupletSEUSLS_%s_%s_%s", configDileptonCutNamesStr.Data(), configDitrackCutNamesStr.Data(), cutName.Data()), fConfigAddQuadrupletHistogram); + DefineHistograms(fHistMan, Form("QuadrupletSELSUS_%s_%s_%s", configDileptonCutNamesStr.Data(), configDitrackCutNamesStr.Data(), cutName.Data()), fConfigAddQuadrupletHistogram); + DefineHistograms(fHistMan, Form("QuadrupletSELSLS_%s_%s_%s", configDileptonCutNamesStr.Data(), configDitrackCutNamesStr.Data(), cutName.Data()), fConfigAddQuadrupletHistogram); + } // loop over track cuts + } + } + + VarManager::SetUseVars(fHistMan->GetUsedVars()); + fOutputList.setObject(fHistMan->GetMainHistogramList()); + } + // Template function to run pair - track - track combinations + template + void runDileptonTrackTrack(TEvent const& event, TTracks const& tracks, soa::Filtered const& dileptons) + { + VarManager::ResetValues(0, VarManager::kNVars, fValuesDitrack); + VarManager::FillEvent(event, fValuesDitrack); + VarManager::ResetValues(0, VarManager::kNVars, fValuesQuadruplet); + VarManager::FillEvent(event, fValuesQuadruplet); + + // LOGF(info, "Number of dileptons: %d", dileptons.size()); + + // loop over dileptons + for (auto dilepton : dileptons) { + fDileptonFilter = 0; + fIsUnlikeSignDilepton = 0; + VarManager::FillTrack(dilepton, fValuesQuadruplet); + + // Check that the dilepton has zero charge + if (dilepton.sign() == 0) { + fIsUnlikeSignDilepton = 1; + } + + // apply the dilepton cut + if (fDileptonCut.IsSelected(fValuesQuadruplet)) { + fDileptonFilter = 1; + if (fIsUnlikeSignDilepton == 1) { + fHistMan->FillHistClass(Form("DileptonsSelectedUS_%s", fDileptonCut.GetName()), fValuesQuadruplet); + } else { + fHistMan->FillHistClass(Form("DileptonsSelectedLS_%s", fDileptonCut.GetName()), fValuesQuadruplet); + } + } + + // pass the dilepton without cut + if (fDileptonFilter == 0) { + continue; + } + + // get the index of the electron legs + int indexLepton1 = dilepton.index0Id(); + int indexLepton2 = dilepton.index1Id(); + + // loop over hadrons pairs + for (auto& [t1, t2] : combinations(tracks, tracks)) { + // avoid self-combinations + if (t1.globalIndex() == indexLepton1 || t1.globalIndex() == indexLepton2 || t2.globalIndex() == indexLepton1 || t2.globalIndex() == indexLepton2) { + continue; + } + + // fill variables + VarManager::FillPair(t1, t2, fValuesDitrack); + if constexpr (TCandidateType == VarManager::kChictoJpsiEE) { + VarManager::FillPair(t1, t2, fValuesDitrack); + } + VarManager::FillDileptonTrackTrack(dilepton, t1, t2, fValuesQuadruplet); + + if (t1.sign() * t2.sign() > 0) { + fIsUnlikeSignDitrack = 0; + } else { + fIsUnlikeSignDitrack = 1; + } + + int iTrackCut = 0; + for (auto cutname = fTrackCutNames.begin(); cutname != fTrackCutNames.end(); cutname++, iTrackCut++) { + // apply the DiTrack cut + if (fDitrackCut.IsSelected(fValuesDitrack)) { + // apply the Track cut + if (t1.isBarrelSelected() & (uint32_t(1) << (iTrackCut + 1)) && t2.isBarrelSelected() & (uint32_t(1) << (iTrackCut + 1))) { + fHistMan->FillHistClass(Form("DitrackSelected_%s_%s", fDitrackCut.GetName(), (*cutname).Data()), fValuesDitrack); + if (fQuadrupletCut.IsSelected(fValuesQuadruplet)) { + if (fIsUnlikeSignDilepton) { + if (fIsUnlikeSignDitrack) { + fHistMan->FillHistClass(Form("QuadrupletSEUSUS_%s_%s_%s", fDileptonCut.GetName(), fDitrackCut.GetName(), (*cutname).Data()), fValuesQuadruplet); + } else { + fHistMan->FillHistClass(Form("QuadrupletSEUSLS_%s_%s_%s", fDileptonCut.GetName(), fDitrackCut.GetName(), (*cutname).Data()), fValuesQuadruplet); + } + } else { + if (fIsUnlikeSignDitrack) { + fHistMan->FillHistClass(Form("QuadrupletSELSUS_%s_%s_%s", fDileptonCut.GetName(), fDitrackCut.GetName(), (*cutname).Data()), fValuesQuadruplet); + } else { + fHistMan->FillHistClass(Form("QuadrupletSELSLS_%s_%s_%s", fDileptonCut.GetName(), fDitrackCut.GetName(), (*cutname).Data()), fValuesQuadruplet); + } + } + } + } + } // check if the diTrack cut is selected + } // loop over hadron cuts + } + } + } + + void processJpsiPiPi(soa::Filtered::iterator const& event, MyBarrelTracksSelectedWithCov const& tracks, soa::Filtered const& dileptons) + { + runDileptonTrackTrack(event, tracks, dileptons); + } + + void processDummy(MyEvents&) + { + // do nothing + } + + PROCESS_SWITCH(AnalysisDileptonTrackTrack, processJpsiPiPi, "Run dilepton-dihadron pairing to study X(3872), using skimmed data", false); + PROCESS_SWITCH(AnalysisDileptonTrackTrack, processDummy, "Dummy function", false); +}; + WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ @@ -1581,7 +1755,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc), - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc)}; } void DefineHistograms(HistogramManager* histMan, TString histClasses, Configurable configVar) @@ -1639,5 +1814,14 @@ void DefineHistograms(HistogramManager* histMan, TString histClasses, Configurab if (classStr.Contains("DileptonHadronCorrelation")) { dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "dilepton-hadron-array-correlation"); } + + if (classStr.Contains("DitrackSelected")) { + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair", histName); + } + + if (classStr.Contains("Quadruplet")) { + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "dilepton-dihadron", histName); + } + } // end loop over histogram classes }