From a1481d43a8337a4b05d61d6fced9a9053591b348 Mon Sep 17 00:00:00 2001 From: Victor Feuillard Date: Tue, 16 Nov 2021 12:33:55 +0100 Subject: [PATCH 1/7] Solving Merging conflicts --- EventFiltering/filterTables.h | 22 ++- PWGDQ/Core/CutsLibrary.h | 43 +++--- PWGDQ/Tasks/filterPP.cxx | 283 +++++++++++++++++++++++++++++++--- 3 files changed, 300 insertions(+), 48 deletions(-) diff --git a/EventFiltering/filterTables.h b/EventFiltering/filterTables.h index 7538b94f729..244ab639cec 100644 --- a/EventFiltering/filterTables.h +++ b/EventFiltering/filterTables.h @@ -26,6 +26,13 @@ DECLARE_SOA_COLUMN(He4, hasHe4, bool); //! // diffraction DECLARE_SOA_COLUMN(DG, hasDG, bool); //! Double Gap events, DG +// Dileptons & Quarkonia +DECLARE_SOA_COLUMN(SingleE, hasSingleE, bool); //! single electron trigger +DECLARE_SOA_COLUMN(SingleMuLow, hasSingleMuLow, bool); //! single muon with low pT trigger +DECLARE_SOA_COLUMN(SingleMuHigh, hasSingleMuHigh, bool); //! single muon with high pT trigger +DECLARE_SOA_COLUMN(DiElectron, hasDiElectron, bool); //! dielectron trigger +DECLARE_SOA_COLUMN(DiMuon, hasDiMuon, bool); //! dimuon trigger with low pT on muons + // heavy flavours DECLARE_SOA_COLUMN(HfHighPt, hasHfHighPt, bool); //! high-pT charm hadron DECLARE_SOA_COLUMN(HfBeauty, hasHfBeauty, bool); //! beauty hadron @@ -64,6 +71,11 @@ DECLARE_SOA_TABLE(DiffractionFilters, "AOD", "DiffFilters", //! Diffraction filt filtering::DG); using DiffractionFilter = DiffractionFilters::iterator; +// Dileptons & Quarkonia +DECLARE_SOA_TABLE(DqFilters, "AOD", "DQ Filters", //! + filtering::SingleE, filtering::SingleMuLow, filtering::SingleMuHigh, filtering::DiElectron, filtering::DiMuon); +using DqFilter = DqFilters::iterator; + // heavy flavours DECLARE_SOA_TABLE(HfFilters, "AOD", "HF Filters", //! filtering::HfHighPt, filtering::HfBeauty, filtering::HfFemto); @@ -93,11 +105,11 @@ DECLARE_SOA_TABLE(MultFilters, "AOD", "MM Filters", //! using MultFilter = MultFilters::iterator; /// List of the available filters, the description of their tables and the name of the tasks -constexpr int NumberOfFilters{7}; -constexpr std::array AvailableFilters{"NucleiFilters", "DiffractionFilters", "HeavyFlavourFilters", "CorrelationFilters", "JetFilters", "StrangenessFilters", "MultFilters"}; -constexpr std::array FilterDescriptions{"NucleiFilters", "DiffFilters", "HFFilters", "CFFilters", "JetFilters", "LFStrgFilters", "MultFilters"}; -constexpr std::array FilteringTaskNames{"o2-analysis-nuclei-filter", "o2-analysis-diffraction-filter", "o2-analysis-hf-filter", "o2-analysis-cf-filter", "o2-analysis-je-filter", "o2-analysis-lf-strangeness-filter", "o2-analysis-mult-filter"}; -constexpr o2::framework::pack FiltersPack; +constexpr int NumberOfFilters{8}; +constexpr std::array AvailableFilters{"NucleiFilters", "DiffractionFilters", "DileptonQuarkoniaFilters", "HeavyFlavourFilters", "CorrelationFilters", "JetFilters", "StrangenessFilters", "MultFilters"}; +constexpr std::array FilterDescriptions{"NucleiFilters", "DiffFilters", "DQFilters", "HFFilters", "CFFilters", "JetFilters", "LFStrgFilters", "MultFilters"}; +constexpr std::array FilteringTaskNames{"o2-analysis-nuclei-filter", "o2-analysis-diffraction-filter", "o2-analysis-dq-filter-pp", "o2-analysis-hf-filter", "o2-analysis-cf-filter", "o2-analysis-je-filter", "o2-analysis-lf-strangeness-filter", "o2-analysis-mult-filter"}; +constexpr o2::framework::pack FiltersPack; static_assert(o2::framework::pack_size(FiltersPack) == NumberOfFilters); template diff --git a/PWGDQ/Core/CutsLibrary.h b/PWGDQ/Core/CutsLibrary.h index 5ba0f6e4148..2e04d86dff6 100644 --- a/PWGDQ/Core/CutsLibrary.h +++ b/PWGDQ/Core/CutsLibrary.h @@ -87,20 +87,6 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) return cut; } - if (!nameStr.compare("kaonPID")) { - cut->AddCut(GetAnalysisCut("PIDStandardKine")); // standard kine cuts usually are applied via Filter in the task - cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug")); - cut->AddCut(GetAnalysisCut("kaonPIDnsigma")); - return cut; - } - - if (!nameStr.compare("kaonPID")) { - cut->AddCut(GetAnalysisCut("PIDStandardKine")); // standard kine cuts usually are applied via Filter in the task - cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug")); - cut->AddCut(GetAnalysisCut("kaonPIDnsigma")); - return cut; - } - //--------------------------------------------------------------------------------------- // NOTE: Below there are several TPC pid cuts used for studies of the dE/dx degradation // and its impact on the high lumi pp quarkonia triggers @@ -225,6 +211,17 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) if (!nameStr.compare("muonTightQualityCutsForTests")) { cut->AddCut(GetAnalysisCut("muonTightQualityCutsForTests")); + return cut; + } + if (!nameStr.compare("muonLowPt")) { + cut->AddCut(GetAnalysisCut("muonLowPt")); + cut->AddCut(GetAnalysisCut("muonQualityCuts")); + return cut; + } + + if (!nameStr.compare("muonHighPt")) { + cut->AddCut(GetAnalysisCut("muonHighPt")); + cut->AddCut(GetAnalysisCut("muonQualityCuts")); return cut; } @@ -411,16 +408,6 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) return cut; } - if (!nameStr.compare("kaonPIDnsigma")) { - cut->AddCut(VarManager::kTPCnSigmaKa, -3.0, 3.0); - return cut; - } - - if (!nameStr.compare("kaonPIDnsigma")) { - cut->AddCut(VarManager::kTPCnSigmaKa, -3.0, 3.0); - return cut; - } - if (!nameStr.compare("electronPIDnsigmaRandomized")) { cut->AddCut(VarManager::kTPCnSigmaElRandomized, -3.0, 3.0); cut->AddCut(VarManager::kTPCnSigmaPrRandomized, 3.0, 3000.0); @@ -490,6 +477,14 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) cut->AddCut(VarManager::kMuonChi2, 0.0, 1e6); return cut; } + if (!nameStr.compare("muonLowPt")) { + cut->AddCut(VarManager::kPt, 0.5, 1000.0); + return cut; + } + if (!nameStr.compare("muonHighPt")) { + cut->AddCut(VarManager::kPt, 4.0, 1000.0); + return cut; + } if (!nameStr.compare("muonTightQualityCutsForTests")) { cut->AddCut(VarManager::kEta, -4.0, -2.5); diff --git a/PWGDQ/Tasks/filterPP.cxx b/PWGDQ/Tasks/filterPP.cxx index f8ee618592f..8ba6fd93573 100644 --- a/PWGDQ/Tasks/filterPP.cxx +++ b/PWGDQ/Tasks/filterPP.cxx @@ -19,6 +19,7 @@ #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/Centrality.h" #include "Common/CCDB/TriggerAliases.h" +#include "EventFiltering/filterTables.h" #include "PWGDQ/DataModel/ReducedInfoTables.h" #include "PWGDQ/Core/VarManager.h" #include "PWGDQ/Core/HistogramManager.h" @@ -52,10 +53,12 @@ namespace dqppfilter { DECLARE_SOA_COLUMN(IsDQEventSelected, isDQEventSelected, int); DECLARE_SOA_COLUMN(IsBarrelSelected, isBarrelSelected, uint8_t); +DECLARE_SOA_COLUMN(IsMuonSelected, isMuonSelected, uint8_t); } // namespace dqppfilter DECLARE_SOA_TABLE(DQEventCuts, "AOD", "DQEVENTCUTS", dqppfilter::IsDQEventSelected); DECLARE_SOA_TABLE(DQBarrelTrackCuts, "AOD", "DQBARRELCUTS", dqppfilter::IsBarrelSelected); +DECLARE_SOA_TABLE(DQMuonsCuts, "AOD", "DQMUONCUTS", dqppfilter::IsMuonSelected); } // namespace o2::aod using MyEvents = soa::Join; @@ -71,9 +74,12 @@ using MyBarrelTracksSelected = soa::Join; +using MyMuons = soa::Join; +using MyMuonsSelected = soa::Join; constexpr static uint32_t gkEventFillMap = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision; constexpr static uint32_t gkTrackFillMap = VarManager::ObjTypes::Track | VarManager::ObjTypes::TrackExtra | VarManager::ObjTypes::TrackDCA | VarManager::ObjTypes::TrackSelection | VarManager::ObjTypes::TrackCov | VarManager::ObjTypes::TrackPID; +constexpr static uint32_t gkMuonFillMap = VarManager::ObjTypes::Muon | VarManager::ObjTypes::MuonCov; void DefineHistograms(HistogramManager* histMan, TString histClasses); @@ -206,10 +212,86 @@ struct DQBarrelTrackSelectionTask { } }; +struct DQMuonsSelection { + Produces trackSel; + OutputObj fOutputList{"output"}; + HistogramManager* fHistMan; + std::vector fTrackCuts; + + float* fValues; + + Configurable fConfigCuts{"cfgMuonsCuts", "muonQualityCuts,muonLowPt,muonHighPt", "Comma separated list of muon track cuts"}; + + void init(o2::framework::InitContext&) + { + DefineCuts(); + + fValues = new float[VarManager::kNVars]; + VarManager::SetDefaultVarNames(); + fHistMan = new HistogramManager("analysisHistos", "aa", VarManager::kNVars); + fHistMan->SetUseDefaultVariableNames(kTRUE); + fHistMan->SetDefaultVarNames(VarManager::fgVariableNames, VarManager::fgVariableUnits); + + TString cutNames = "TrackMuons_BeforeCuts;"; + for (int i = 0; i < fTrackCuts.size(); i++) { + cutNames += Form("TrackMuons_%s;", fTrackCuts[i].GetName()); + } + + DefineHistograms(fHistMan, cutNames.Data()); // define all histograms + VarManager::SetUseVars(fHistMan->GetUsedVars()); // provide the list of required variables so that VarManager knows what to fill + fOutputList.setObject(fHistMan->GetMainHistogramList()); + } + + void DefineCuts() + { + // available cuts: muonQualityCuts + TString cutNamesStr = fConfigCuts.value; + if (!cutNamesStr.IsNull()) { + std::unique_ptr objArray(cutNamesStr.Tokenize(",")); + for (int icut = 0; icut < objArray->GetEntries(); ++icut) { + fTrackCuts.push_back(*dqcuts::GetCompositeCut(objArray->At(icut)->GetName())); + } + } + + // NOTE: Additional cuts to those specified via the Configurable may still be added + + VarManager::SetUseVars(AnalysisCut::fgUsedVars); // provide the list of required variables so that VarManager knows what to fill + } + + void process(MyEvents::iterator const& event, MyMuons const& muons, aod::BCs const& bcs) + { + uint8_t filterMap = uint8_t(0); + trackSel.reserve(muons.size()); + + VarManager::ResetValues(0, VarManager::kNMuonTrackVariables, fValues); + // fill event information which might be needed in histograms that combine track and event properties + VarManager::FillEvent(event, fValues); + + for (auto& muon : muons) { + filterMap = uint8_t(0); + // TODO: if a condition on the event selection is applied, the histogram output is missing + VarManager::FillTrack(muon, fValues); + fHistMan->FillHistClass("TrackMuons_BeforeCuts", fValues); + int i = 0; + for (auto cut = fTrackCuts.begin(); cut != fTrackCuts.end(); ++cut, ++i) { + if ((*cut).IsSelected(fValues)) { + filterMap |= (uint8_t(1) << i); + fHistMan->FillHistClass(Form("TrackMuons_%s", (*cut).GetName()), fValues); + } + } + trackSel(filterMap); + } + } +}; + struct DQFilterPPTask { Produces eventFilter; + Produces dqtable; OutputObj fOutputList{"output"}; - OutputObj fStats{"stats"}; + OutputObj fStatsSingleBarrel{"statsSingleBarrel"}; + OutputObj fStatsSingleMuon{"statsSingleMuon"}; + OutputObj fStatsBarrel{"statsBarrel"}; + OutputObj fStatsMuon{"statsMuon"}; HistogramManager* fHistMan; std::vector fPairCuts; @@ -219,11 +301,14 @@ struct DQFilterPPTask { Partition negTracks = aod::track::signed1Pt < 0.0f && aod::dqppfilter::isBarrelSelected > uint8_t(0); Configurable fConfigTrackCuts{"cfgBarrelTrackCuts", "jpsiPID1", "Comma separated list of barrel track cuts"}; - Configurable fConfigPairCuts{"cfgPairCuts", "pairMassLow", "Comma separated list of pair cuts"}; + Configurable fConfigMuonCuts{"cfgMuonCuts", "muonQualityCuts,muonLowPt,muonHighPt", "Comma separated list of muon track cuts"}; + Configurable fConfigPairCuts{"cfgPairCuts", "pairNoCut,pairMassLow", "Comma separated list of pair cuts"}; int fNTrackCuts; + int fNMuonCuts; int fNPairCuts; TObjArray* fTrkCutsNameArray; + TObjArray* fMuonCutsNameArray; void DefineCuts() { @@ -258,37 +343,96 @@ struct DQFilterPPTask { TString trackCutNamesStr = fConfigTrackCuts.value; fTrkCutsNameArray = trackCutNamesStr.Tokenize(","); fNTrackCuts = fTrkCutsNameArray->GetEntries(); + TString muonCutNamesStr = fConfigMuonCuts.value; + fMuonCutsNameArray = muonCutNamesStr.Tokenize(","); + fNMuonCuts = fMuonCutsNameArray->GetEntries(); TString histNames = ""; for (int i = 0; i < fNTrackCuts; i++) { - histNames += Form("PairsBarrelPM_%s;", fTrkCutsNameArray->At(i)->GetName()); + histNames += Form("TrackBarrel_%s;PairsBarrelPM_%s;", fTrkCutsNameArray->At(i)->GetName(), fTrkCutsNameArray->At(i)->GetName()); + } + for (int i = 0; i < fNMuonCuts; i++) { + histNames += Form("TrackMuons_%s;PairsMuonsPM_%s;PairsMuonsPP_%s;PairsMuonsMM_%s;", fMuonCutsNameArray->At(i)->GetName(), fMuonCutsNameArray->At(i)->GetName(), fMuonCutsNameArray->At(i)->GetName(), fMuonCutsNameArray->At(i)->GetName()); } DefineHistograms(fHistMan, histNames.Data()); // define all histograms VarManager::SetUseVars(fHistMan->GetUsedVars()); // provide the list of required variables so that VarManager knows what to fill fOutputList.setObject(fHistMan->GetMainHistogramList()); // configure the stats histogram - fStats.setObject(new TH2I("stats", "stats", fNPairCuts, -0.5, -0.5 + fNPairCuts, fNTrackCuts, -0.5, -0.5 + fNTrackCuts)); + fStatsSingleBarrel.setObject(new TH1I("statsSingleBarrel", "statsSingleBarrel", fNTrackCuts, -0.5, -0.5 + fNTrackCuts)); + for (int i = 0; i < fNTrackCuts; ++i) { + fStatsSingleBarrel->GetXaxis()->SetBinLabel(i + 1, fTrkCutsNameArray->At(i)->GetName()); + } + + fStatsSingleMuon.setObject(new TH1I("statsSingleMuon", "statsSingleMuon", fNMuonCuts, -0.5, -0.5 + fNMuonCuts)); + for (int i = 0; i < fNMuonCuts; ++i) { + fStatsSingleMuon->GetXaxis()->SetBinLabel(i + 1, fMuonCutsNameArray->At(i)->GetName()); + } + + fStatsBarrel.setObject(new TH2I("statsBarrel", "statsBarrel", fNPairCuts, -0.5, -0.5 + fNPairCuts, fNTrackCuts, -0.5, -0.5 + fNTrackCuts)); for (int i = 0; i < fNPairCuts; ++i) { - fStats->GetXaxis()->SetBinLabel(i + 1, fPairCuts[i].GetName()); + fStatsBarrel->GetXaxis()->SetBinLabel(i + 1, fPairCuts[i].GetName()); } for (int i = 0; i < fNTrackCuts; ++i) { - fStats->GetYaxis()->SetBinLabel(i + 1, fTrkCutsNameArray->At(i)->GetName()); + fStatsBarrel->GetYaxis()->SetBinLabel(i + 1, fTrkCutsNameArray->At(i)->GetName()); + } + + fStatsMuon.setObject(new TH2I("statsMuon", "statsMuon", fNPairCuts, -0.5, -0.5 + fNPairCuts, fNMuonCuts, -0.5, -0.5 + fNMuonCuts)); + for (int i = 0; i < fNPairCuts; ++i) { + fStatsMuon->GetXaxis()->SetBinLabel(i + 1, fPairCuts[i].GetName()); + } + for (int i = 0; i < fNMuonCuts; ++i) { + fStatsMuon->GetYaxis()->SetBinLabel(i + 1, fMuonCutsNameArray->At(i)->GetName()); } } - void process(MyEventsSelected::iterator const& event, MyBarrelTracksSelected const& tracks, aod::BCs const& bcs) + void + process(MyEventsSelected::iterator const& event, MyBarrelTracksSelected const& tracks, MyMuonsSelected const& muons, aod::BCs const& bcs) { - uint64_t filter = 0; - constexpr int pairType = VarManager::kJpsiToEE; - + uint64_t filter = 0; // first 32 bits for dielectrin, last 32 for dimuons + + //Is event good? [0] = SingleE, [1] = SingleMulow, [2] = SingleMuHigh, [3] = DiElectron, [4] = DiMuon + bool keepEvent[5]{false}; + + constexpr int pairTypeEE = VarManager::kJpsiToEE; + constexpr int pairTypeMuMu = VarManager::kJpsiToMuMu; if (event.isDQEventSelected() == 1) { // Reset the fValues array VarManager::ResetValues(0, VarManager::kNVars, fValues); VarManager::FillEvent(event, fValues); + uint8_t* singleBarrelCount = new uint8_t[fNTrackCuts]; // single electron trigger + uint8_t* singleMuonsCount = new uint8_t[fNMuonCuts]; // single muon trigger + uint8_t* pairsBarrelCount = new uint8_t[fNPairCuts * fNTrackCuts]; // dielectron trigger + uint8_t* pairsUnlikeMuonsCount = new uint8_t[fNPairCuts * fNMuonCuts]; // dimuon trigger Unlike + uint8_t* pairsLikeMuonsCount = new uint8_t[fNPairCuts * fNMuonCuts]; // dimuon trigger like - uint8_t* pairsCount = new uint8_t[fNPairCuts * fNTrackCuts]; for (int i = 0; i < fNPairCuts * fNTrackCuts; i++) { - pairsCount[i] = 0; + pairsBarrelCount[i] = 0; + } + for (int i = 0; i < fNPairCuts * fNMuonCuts; i++) { + pairsUnlikeMuonsCount[i] = 0; + pairsLikeMuonsCount[i] = 0; + } + for (int i = 0; i < fNMuonCuts; i++) { + singleMuonsCount[i] = 0; + } + for (int i = 0; i < fNTrackCuts; i++) { + singleBarrelCount[i] = 0; + } + + uint8_t cutSingleFilter = 0; + for (auto track : tracks) { + cutSingleFilter = track.isBarrelSelected(); + if (!cutSingleFilter) { + continue; + } + for (int i = 0; i < fNTrackCuts; ++i) { + if (!(cutSingleFilter & (uint8_t(1) << i))) { + continue; + } + VarManager::FillTrack(track, fValues); + fHistMan->FillHistClass(Form("TrackBarrel_%s", fTrkCutsNameArray->At(i)->GetName()), fValues); + singleBarrelCount[i] += 1; + } } uint8_t cutFilter = 0; @@ -298,7 +442,7 @@ struct DQFilterPPTask { if (!cutFilter) { // the tracks must have at least one filter bit in common to continue continue; } - VarManager::FillPair(tpos, tneg, fValues); // compute pair quantities + VarManager::FillPair(tpos, tneg, fValues); // compute pair quantities for (int i = 0; i < fNTrackCuts; ++i) { if (!(cutFilter & (uint8_t(1) << i))) { continue; @@ -307,24 +451,119 @@ struct DQFilterPPTask { int j = 0; for (auto cut = fPairCuts.begin(); cut != fPairCuts.end(); cut++, j++) { if ((*cut).IsSelected(fValues)) { - pairsCount[j + i * fNPairCuts] += 1; + pairsBarrelCount[j + i * fNPairCuts] += 1; } } } } } + uint8_t cutSingleMuonFilter = 0; + for (auto muon1 : muons) { + cutSingleMuonFilter = muon1.isMuonSelected(); + if (!cutSingleMuonFilter) { + continue; + } + for (int i = 0; i < fNMuonCuts; ++i) { + if (!(cutSingleMuonFilter & (uint8_t(1) << i))) { + continue; + } + VarManager::FillTrack(muon1, fValues); + fHistMan->FillHistClass(Form("TrackMuons_%s", fMuonCutsNameArray->At(i)->GetName()), fValues); + singleMuonsCount[i] += 1; + } + } + + uint8_t cutMuonFilter = 0; + for (auto& [muon1, muon2] : combinations(muons, muons)) { + cutMuonFilter = muon1.isMuonSelected() & muon2.isMuonSelected(); + if (!cutMuonFilter) { // the tracks must have at least one filter bit in common to continue + continue; + } + VarManager::FillPair(muon1, muon2, fValues); // compute pair quantities + for (int i = 0; i < fNMuonCuts; ++i) { + if (!(cutMuonFilter & (uint8_t(1) << i))) { + continue; + } + if (muon1.sign() * muon2.sign() < 0) { + fHistMan->FillHistClass(Form("PairsMuonsPM_%s", fMuonCutsNameArray->At(i)->GetName()), fValues); + } else { + if (muon1.sign() > 0) { + fHistMan->FillHistClass(Form("PairsMuonsPP_%s", fMuonCutsNameArray->At(i)->GetName()), fValues); + } else { + fHistMan->FillHistClass(Form("PairsMuonsMM_%s", fMuonCutsNameArray->At(i)->GetName()), fValues); + } + } + + int j = 0; + for (auto cut = fPairCuts.begin(); cut != fPairCuts.end(); cut++, j++) { + if ((*cut).IsSelected(fValues)) { + if (muon1.sign() * muon2.sign() < 0) { + pairsUnlikeMuonsCount[j + i * fNPairCuts] += 1; + } else { + pairsLikeMuonsCount[j + i * fNPairCuts] += 1; + } + } + } + } + } + + // Fill DQ bit map for (int i = 0; i < fNTrackCuts; i++) { + if (singleBarrelCount[i] > 0) { + filter |= (uint64_t(1) << i); + fStatsSingleBarrel->Fill(i); + } for (int j = 0; j < fNPairCuts; j++) { - if (pairsCount[j + i * fNPairCuts] > 0) { - filter |= (uint64_t(1) << (j + i * fNPairCuts)); - fStats->Fill(j, i); + if (pairsBarrelCount[j + i * fNPairCuts] > 0) { + filter |= (uint64_t(1) << (8 + j + i * fNPairCuts)); + fStatsBarrel->Fill(j, i); } } } - delete[] pairsCount; + for (int i = 0; i < fNMuonCuts; i++) { + if (singleMuonsCount[i] > 0) { + filter |= (uint64_t(1) << (32 + i)); + fStatsSingleMuon->Fill(i); + } + for (int j = 0; j < fNPairCuts; j++) { + if (pairsUnlikeMuonsCount[j + i * fNPairCuts] > 0) { + filter |= (uint64_t(1) << (40 + j + i * fNPairCuts)); + fStatsMuon->Fill(j, i); + } + if (pairsLikeMuonsCount[j + i * fNPairCuts] > 0) { + filter |= (uint64_t(1) << (52 + j + i * fNPairCuts)); + // fStatsMuon->Fill(j, i); + } + } + } + +// // Fill event selections tag for central event filtering +// if (singleBarrelCount[0] > 0) { +// keepEvent[0] = true; +// } +// if (singleMuonsCount[1] > 0) { +// keepEvent[1] = true; +// } +// if (singleMuonsCount[2] > 0) { +// keepEvent[2] = true; +// } +// if (pairsBarrelCount[0] > 0) { +// keepEvent[3] = true; +// } +// if (pairsUnlikeMuonsCount[fNPairCuts] > 0) { +// keepEvent[4] = true; +// } + + delete[] pairsBarrelCount; + delete[] pairsUnlikeMuonsCount; + delete[] pairsLikeMuonsCount; + delete[] singleMuonsCount; + delete[] singleBarrelCount; } eventFilter(filter); + //Filling the table + dqtable(keepEvent[0], keepEvent[1], keepEvent[2], keepEvent[3], keepEvent[4]); } }; @@ -333,6 +572,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) return WorkflowSpec{ adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; } @@ -363,7 +603,12 @@ void DefineHistograms(HistogramManager* histMan, TString histClasses) } if (classStr.Contains("Pairs")) { - dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair_barrel", "vertexing-barrel"); + if (classStr.Contains("Barrel")) { + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair_barrel", "vertexing-barrel"); + } + if (classStr.Contains("Muon")) { + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair_dimuon"); + } } } } From 0873a936c9afb247c0b337a00aca5d3d57051d3a Mon Sep 17 00:00:00 2001 From: Victor Feuillard Date: Tue, 16 Nov 2021 14:26:43 +0100 Subject: [PATCH 2/7] Addition of the Dilepton and quarkonia triggers (FINISHED) --- PWGDQ/Tasks/filterPP.cxx | 59 +++++++++++++++++++++++++--------------- 1 file changed, 37 insertions(+), 22 deletions(-) diff --git a/PWGDQ/Tasks/filterPP.cxx b/PWGDQ/Tasks/filterPP.cxx index 8ba6fd93573..fad3ae7be2b 100644 --- a/PWGDQ/Tasks/filterPP.cxx +++ b/PWGDQ/Tasks/filterPP.cxx @@ -47,6 +47,17 @@ using namespace o2::framework::expressions; using namespace o2::aod; // Some definitions +namespace +{ +enum HfTriggers { + kSingleE = 0, + kSingleMuLow, + kSingleMuHigh, + kDiElectron, + kDiMuon, + kNTriggersDQ +}; +} // namespace namespace o2::aod { namespace dqppfilter @@ -389,10 +400,10 @@ struct DQFilterPPTask { process(MyEventsSelected::iterator const& event, MyBarrelTracksSelected const& tracks, MyMuonsSelected const& muons, aod::BCs const& bcs) { uint64_t filter = 0; // first 32 bits for dielectrin, last 32 for dimuons - - //Is event good? [0] = SingleE, [1] = SingleMulow, [2] = SingleMuHigh, [3] = DiElectron, [4] = DiMuon - bool keepEvent[5]{false}; - + + //[0] = SingleE, [1] = SingleMulow, [2] = SingleMuHigh, [3] = DiElectron, [4] = DiMuon + bool keepEvent[kNTriggersDQ]{false}; + constexpr int pairTypeEE = VarManager::kJpsiToEE; constexpr int pairTypeMuMu = VarManager::kJpsiToMuMu; if (event.isDQEventSelected() == 1) { @@ -513,11 +524,20 @@ struct DQFilterPPTask { if (singleBarrelCount[i] > 0) { filter |= (uint64_t(1) << i); fStatsSingleBarrel->Fill(i); + std::string nameTrkStr = fTrkCutsNameArray->At(i)->GetName(); + if (!nameTrkStr.compare("jpsiKineAndQuality")) { + keepEvent[kSingleE] = true; // Single Electron trigger + } } for (int j = 0; j < fNPairCuts; j++) { if (pairsBarrelCount[j + i * fNPairCuts] > 0) { filter |= (uint64_t(1) << (8 + j + i * fNPairCuts)); fStatsBarrel->Fill(j, i); + std::string nameTrkStr = fTrkCutsNameArray->At(i)->GetName(); + std::string namePairStr = fPairCuts[j].GetName(); + if (!namePairStr.compare("pairNoCut") && !nameTrkStr.compare("jpsiKineAndQuality")) { + keepEvent[kDiElectron] = true; // Di-Electron trigger + } } } } @@ -525,11 +545,23 @@ struct DQFilterPPTask { if (singleMuonsCount[i] > 0) { filter |= (uint64_t(1) << (32 + i)); fStatsSingleMuon->Fill(i); + std::string nameMuStr = fMuonCutsNameArray->At(i)->GetName(); + if (!nameMuStr.compare("muonLowPt")) { + keepEvent[kSingleMuLow] = true; // Single Low pT Muon trigger + } + if (!nameMuStr.compare("muonHighPt")) { + keepEvent[kSingleMuHigh] = true; // Single High pT Muon trigger + } } for (int j = 0; j < fNPairCuts; j++) { if (pairsUnlikeMuonsCount[j + i * fNPairCuts] > 0) { filter |= (uint64_t(1) << (40 + j + i * fNPairCuts)); fStatsMuon->Fill(j, i); + std::string nameMuStr = fMuonCutsNameArray->At(i)->GetName(); + std::string namePairStr = fPairCuts[j].GetName(); + if (!namePairStr.compare("pairNoCut") && !nameMuStr.compare("muonLowPt")) { + keepEvent[kDiMuon] = true; // Di-Muon low pT trigger + } } if (pairsLikeMuonsCount[j + i * fNPairCuts] > 0) { filter |= (uint64_t(1) << (52 + j + i * fNPairCuts)); @@ -538,23 +570,6 @@ struct DQFilterPPTask { } } -// // Fill event selections tag for central event filtering -// if (singleBarrelCount[0] > 0) { -// keepEvent[0] = true; -// } -// if (singleMuonsCount[1] > 0) { -// keepEvent[1] = true; -// } -// if (singleMuonsCount[2] > 0) { -// keepEvent[2] = true; -// } -// if (pairsBarrelCount[0] > 0) { -// keepEvent[3] = true; -// } -// if (pairsUnlikeMuonsCount[fNPairCuts] > 0) { -// keepEvent[4] = true; -// } - delete[] pairsBarrelCount; delete[] pairsUnlikeMuonsCount; delete[] pairsLikeMuonsCount; @@ -563,7 +578,7 @@ struct DQFilterPPTask { } eventFilter(filter); //Filling the table - dqtable(keepEvent[0], keepEvent[1], keepEvent[2], keepEvent[3], keepEvent[4]); + dqtable(keepEvent[kSingleE], keepEvent[kSingleMuLow], keepEvent[kSingleMuHigh], keepEvent[kDiElectron], keepEvent[kDiMuon]); } }; From dbea30347492154e7e4ccf320bfd697f8a4bedaa Mon Sep 17 00:00:00 2001 From: Victor Feuillard Date: Tue, 16 Nov 2021 14:42:15 +0100 Subject: [PATCH 3/7] Addition of a cut condition for barrel tracks as default --- PWGDQ/Tasks/filterPP.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGDQ/Tasks/filterPP.cxx b/PWGDQ/Tasks/filterPP.cxx index fad3ae7be2b..5640b9240c9 100644 --- a/PWGDQ/Tasks/filterPP.cxx +++ b/PWGDQ/Tasks/filterPP.cxx @@ -159,7 +159,7 @@ struct DQBarrelTrackSelectionTask { float* fValues; // array to be used by the VarManager - Configurable fConfigCuts{"cfgBarrelTrackCuts", "jpsiPID1", "Comma separated list of barrel track cuts"}; + Configurable fConfigCuts{"cfgBarrelTrackCuts", "jpsiKineAndQuality,jpsiPID1", "Comma separated list of barrel track cuts"}; void init(o2::framework::InitContext&) { @@ -311,7 +311,7 @@ struct DQFilterPPTask { Partition posTracks = aod::track::signed1Pt > 0.0f && aod::dqppfilter::isBarrelSelected > uint8_t(0); Partition negTracks = aod::track::signed1Pt < 0.0f && aod::dqppfilter::isBarrelSelected > uint8_t(0); - Configurable fConfigTrackCuts{"cfgBarrelTrackCuts", "jpsiPID1", "Comma separated list of barrel track cuts"}; + Configurable fConfigTrackCuts{"cfgBarrelTrackCuts", "jpsiKineAndQuality,jpsiPID1", "Comma separated list of barrel track cuts"}; Configurable fConfigMuonCuts{"cfgMuonCuts", "muonQualityCuts,muonLowPt,muonHighPt", "Comma separated list of muon track cuts"}; Configurable fConfigPairCuts{"cfgPairCuts", "pairNoCut,pairMassLow", "Comma separated list of pair cuts"}; From 6c9b51ef2aef38f21f4913b9a6f4ab230224451f Mon Sep 17 00:00:00 2001 From: Victor Feuillard Date: Tue, 16 Nov 2021 14:53:31 +0100 Subject: [PATCH 4/7] Cleaning Clang format errors --- PWGDQ/Core/CutsLibrary.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGDQ/Core/CutsLibrary.h b/PWGDQ/Core/CutsLibrary.h index 2e04d86dff6..21aa6b2ad6d 100644 --- a/PWGDQ/Core/CutsLibrary.h +++ b/PWGDQ/Core/CutsLibrary.h @@ -211,7 +211,7 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) if (!nameStr.compare("muonTightQualityCutsForTests")) { cut->AddCut(GetAnalysisCut("muonTightQualityCutsForTests")); - return cut; + return cut; } if (!nameStr.compare("muonLowPt")) { cut->AddCut(GetAnalysisCut("muonLowPt")); From 9903fe6abfdf0484ed8f22c6b9e392ae1ed8e2c4 Mon Sep 17 00:00:00 2001 From: Victor Feuillard Date: Tue, 16 Nov 2021 15:55:17 +0100 Subject: [PATCH 5/7] Correction of small mistakes --- PWGDQ/Core/CutsLibrary.h | 33 +++++++++++++++++++++++++++++---- PWGDQ/Tasks/filterPP.cxx | 16 ++++++++-------- 2 files changed, 37 insertions(+), 12 deletions(-) diff --git a/PWGDQ/Core/CutsLibrary.h b/PWGDQ/Core/CutsLibrary.h index 21aa6b2ad6d..28f2ce787a3 100644 --- a/PWGDQ/Core/CutsLibrary.h +++ b/PWGDQ/Core/CutsLibrary.h @@ -87,6 +87,20 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) return cut; } + if (!nameStr.compare("kaonPID")) { + cut->AddCut(GetAnalysisCut("PIDStandardKine")); // standard kine cuts usually are applied via Filter in the task + cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug")); + cut->AddCut(GetAnalysisCut("kaonPIDnsigma")); + return cut; + } + + if (!nameStr.compare("kaonPID")) { + cut->AddCut(GetAnalysisCut("PIDStandardKine")); // standard kine cuts usually are applied via Filter in the task + cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug")); + cut->AddCut(GetAnalysisCut("kaonPIDnsigma")); + return cut; + } + //--------------------------------------------------------------------------------------- // NOTE: Below there are several TPC pid cuts used for studies of the dE/dx degradation // and its impact on the high lumi pp quarkonia triggers @@ -209,10 +223,6 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) return cut; } - if (!nameStr.compare("muonTightQualityCutsForTests")) { - cut->AddCut(GetAnalysisCut("muonTightQualityCutsForTests")); - return cut; - } if (!nameStr.compare("muonLowPt")) { cut->AddCut(GetAnalysisCut("muonLowPt")); cut->AddCut(GetAnalysisCut("muonQualityCuts")); @@ -225,6 +235,11 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) return cut; } + if (!nameStr.compare("muonTightQualityCutsForTests")) { + cut->AddCut(GetAnalysisCut("muonTightQualityCutsForTests")); + return cut; + } + if (!nameStr.compare("pairNoCut")) { cut->AddCut(GetAnalysisCut("pairNoCut")); return cut; @@ -408,6 +423,16 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) return cut; } + if (!nameStr.compare("kaonPIDnsigma")) { + cut->AddCut(VarManager::kTPCnSigmaKa, -3.0, 3.0); + return cut; + } + + if (!nameStr.compare("kaonPIDnsigma")) { + cut->AddCut(VarManager::kTPCnSigmaKa, -3.0, 3.0); + return cut; + } + if (!nameStr.compare("electronPIDnsigmaRandomized")) { cut->AddCut(VarManager::kTPCnSigmaElRandomized, -3.0, 3.0); cut->AddCut(VarManager::kTPCnSigmaPrRandomized, 3.0, 3000.0); diff --git a/PWGDQ/Tasks/filterPP.cxx b/PWGDQ/Tasks/filterPP.cxx index 5640b9240c9..bbe90245db2 100644 --- a/PWGDQ/Tasks/filterPP.cxx +++ b/PWGDQ/Tasks/filterPP.cxx @@ -49,7 +49,7 @@ using namespace o2::aod; // Some definitions namespace { -enum HfTriggers { +enum DQTriggers { kSingleE = 0, kSingleMuLow, kSingleMuHigh, @@ -85,12 +85,12 @@ using MyBarrelTracksSelected = soa::Join; -using MyMuons = soa::Join; -using MyMuonsSelected = soa::Join; +using MyMuons = aod::FwdTracks; +using MyMuonsSelected = soa::Join; constexpr static uint32_t gkEventFillMap = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision; constexpr static uint32_t gkTrackFillMap = VarManager::ObjTypes::Track | VarManager::ObjTypes::TrackExtra | VarManager::ObjTypes::TrackDCA | VarManager::ObjTypes::TrackSelection | VarManager::ObjTypes::TrackCov | VarManager::ObjTypes::TrackPID; -constexpr static uint32_t gkMuonFillMap = VarManager::ObjTypes::Muon | VarManager::ObjTypes::MuonCov; +constexpr static uint32_t gkMuonFillMap = VarManager::ObjTypes::Muon; void DefineHistograms(HistogramManager* histMan, TString histClasses); @@ -159,7 +159,7 @@ struct DQBarrelTrackSelectionTask { float* fValues; // array to be used by the VarManager - Configurable fConfigCuts{"cfgBarrelTrackCuts", "jpsiKineAndQuality,jpsiPID1", "Comma separated list of barrel track cuts"}; + Configurable fConfigCuts{"cfgBarrelTrackCuts", "jpsiPID1", "Comma separated list of barrel track cuts"}; void init(o2::framework::InitContext&) { @@ -231,7 +231,7 @@ struct DQMuonsSelection { float* fValues; - Configurable fConfigCuts{"cfgMuonsCuts", "muonQualityCuts,muonLowPt,muonHighPt", "Comma separated list of muon track cuts"}; + Configurable fConfigCuts{"cfgMuonsCuts", "muonLowPt,muonHighPt", "Comma separated list of muon track cuts"}; void init(o2::framework::InitContext&) { @@ -311,8 +311,8 @@ struct DQFilterPPTask { Partition posTracks = aod::track::signed1Pt > 0.0f && aod::dqppfilter::isBarrelSelected > uint8_t(0); Partition negTracks = aod::track::signed1Pt < 0.0f && aod::dqppfilter::isBarrelSelected > uint8_t(0); - Configurable fConfigTrackCuts{"cfgBarrelTrackCuts", "jpsiKineAndQuality,jpsiPID1", "Comma separated list of barrel track cuts"}; - Configurable fConfigMuonCuts{"cfgMuonCuts", "muonQualityCuts,muonLowPt,muonHighPt", "Comma separated list of muon track cuts"}; + Configurable fConfigTrackCuts{"cfgBarrelTrackCuts", "jpsiPID1", "Comma separated list of barrel track cuts"}; + Configurable fConfigMuonCuts{"cfgMuonCuts", "muonLowPt,muonHighPt", "Comma separated list of muon track cuts"}; Configurable fConfigPairCuts{"cfgPairCuts", "pairNoCut,pairMassLow", "Comma separated list of pair cuts"}; int fNTrackCuts; From f285bbe1424c324bb47ed95f6f290e8424ded6a0 Mon Sep 17 00:00:00 2001 From: Victor Feuillard Date: Wed, 17 Nov 2021 12:26:13 +0100 Subject: [PATCH 6/7] Separate the CEF Tables from the internal bitmap in the filterPP task --- PWGDQ/Tasks/filterPP.cxx | 64 +++++++++++++++++++--------------------- 1 file changed, 30 insertions(+), 34 deletions(-) diff --git a/PWGDQ/Tasks/filterPP.cxx b/PWGDQ/Tasks/filterPP.cxx index bbe90245db2..5f712daa6c5 100644 --- a/PWGDQ/Tasks/filterPP.cxx +++ b/PWGDQ/Tasks/filterPP.cxx @@ -159,7 +159,7 @@ struct DQBarrelTrackSelectionTask { float* fValues; // array to be used by the VarManager - Configurable fConfigCuts{"cfgBarrelTrackCuts", "jpsiPID1", "Comma separated list of barrel track cuts"}; + Configurable fConfigCuts{"cfgBarrelTrackCuts", "jpsiPID2", "Comma separated list of ADDITIONAL barrel track cuts"}; void init(o2::framework::InitContext&) { @@ -184,7 +184,7 @@ struct DQBarrelTrackSelectionTask { void DefineCuts() { // available cuts: jpsiKineAndQuality, jpsiPID1, jpsiPID2 - TString cutNamesStr = fConfigCuts.value; + TString cutNamesStr = "jpsiPID1," + fConfigCuts.value; // "jpsiPID1" is the fixed standard cut provided to the Central Event Filtering task if (!cutNamesStr.IsNull()) { std::unique_ptr objArray(cutNamesStr.Tokenize(",")); for (int icut = 0; icut < objArray->GetEntries(); ++icut) { @@ -231,7 +231,7 @@ struct DQMuonsSelection { float* fValues; - Configurable fConfigCuts{"cfgMuonsCuts", "muonLowPt,muonHighPt", "Comma separated list of muon track cuts"}; + Configurable fConfigCuts{"cfgMuonsCuts", "muonQualityCuts", "Comma separated list of ADDITIONAL muon track cuts"}; void init(o2::framework::InitContext&) { @@ -256,7 +256,7 @@ struct DQMuonsSelection { void DefineCuts() { // available cuts: muonQualityCuts - TString cutNamesStr = fConfigCuts.value; + TString cutNamesStr = "muonLowPt,muonHighPt," + fConfigCuts.value; // "muonLowPt" & "muonHighPt" are the fixed standard cut provided to the Central Event Filtering task if (!cutNamesStr.IsNull()) { std::unique_ptr objArray(cutNamesStr.Tokenize(",")); for (int icut = 0; icut < objArray->GetEntries(); ++icut) { @@ -311,9 +311,9 @@ struct DQFilterPPTask { Partition posTracks = aod::track::signed1Pt > 0.0f && aod::dqppfilter::isBarrelSelected > uint8_t(0); Partition negTracks = aod::track::signed1Pt < 0.0f && aod::dqppfilter::isBarrelSelected > uint8_t(0); - Configurable fConfigTrackCuts{"cfgBarrelTrackCuts", "jpsiPID1", "Comma separated list of barrel track cuts"}; - Configurable fConfigMuonCuts{"cfgMuonCuts", "muonLowPt,muonHighPt", "Comma separated list of muon track cuts"}; - Configurable fConfigPairCuts{"cfgPairCuts", "pairNoCut,pairMassLow", "Comma separated list of pair cuts"}; + Configurable fConfigTrackCuts{"cfgBarrelTrackCuts", "jpsiPID2", "Comma separated list of ADDITIONAL barrel track cuts"}; + Configurable fConfigMuonCuts{"cfgMuonCuts", "muonQualityCuts", "Comma separated list of ADDITIONAL muon track cuts"}; + Configurable fConfigPairCuts{"cfgPairCuts", "pairMassLow,pairJpsi", "Comma separated list of ADDITIONAL pair cuts"}; int fNTrackCuts; int fNMuonCuts; @@ -324,7 +324,7 @@ struct DQFilterPPTask { void DefineCuts() { // available pair cuts in CutsLibrary: pairNoCut,pairMassLow,pairJpsi,pairPsi2S,pairUpsilon,pairJpsiPtLow1, pairJpsiPtLow2 - TString pairCutNamesStr = fConfigPairCuts.value; + TString pairCutNamesStr = "pairNoCut," + fConfigPairCuts.value; // "pairNoCut" is the fixed standard cut provided to the Central Event Filtering task std::unique_ptr objArray(pairCutNamesStr.Tokenize(",")); fNPairCuts = objArray->GetEntries(); if (fNPairCuts) { @@ -351,10 +351,10 @@ struct DQFilterPPTask { fHistMan->SetDefaultVarNames(VarManager::fgVariableNames, VarManager::fgVariableUnits); // configure histograms - TString trackCutNamesStr = fConfigTrackCuts.value; + TString trackCutNamesStr = "jpsiPID1," + fConfigTrackCuts.value; fTrkCutsNameArray = trackCutNamesStr.Tokenize(","); fNTrackCuts = fTrkCutsNameArray->GetEntries(); - TString muonCutNamesStr = fConfigMuonCuts.value; + TString muonCutNamesStr = "muonLowPt,muonHighPt," + fConfigMuonCuts.value; fMuonCutsNameArray = muonCutNamesStr.Tokenize(","); fNMuonCuts = fMuonCutsNameArray->GetEntries(); TString histNames = ""; @@ -399,7 +399,7 @@ struct DQFilterPPTask { void process(MyEventsSelected::iterator const& event, MyBarrelTracksSelected const& tracks, MyMuonsSelected const& muons, aod::BCs const& bcs) { - uint64_t filter = 0; // first 32 bits for dielectrin, last 32 for dimuons + uint64_t filter = 0; // first 32 bits for dielectron, last 32 for dimuons //[0] = SingleE, [1] = SingleMulow, [2] = SingleMuHigh, [3] = DiElectron, [4] = DiMuon bool keepEvent[kNTriggersDQ]{false}; @@ -519,25 +519,35 @@ struct DQFilterPPTask { } } + // Fill event selections tag for central event filtering + if (singleBarrelCount[0] > 0) { // Single Barrel count : bit 0 corresponds to "jpsiPID1" cut + keepEvent[0] = true; + } + if (singleMuonsCount[0] > 0) { // Single Muon count : bit 0 corresponds to "muonLowPt" cut + keepEvent[1] = true; + } + if (singleMuonsCount[1] > 0) { // Single Muon count : bit 1 corresponds to "muonHighPt" cut + keepEvent[2] = true; + } + if (pairsBarrelCount[0] > 0) { // Pair Barrel count : bit 0 corresponds "jpsiPID1" & "pairNoCut" [jPaircut + iTrackCut * fNPairCuts] + keepEvent[3] = true; + } + if (pairsUnlikeMuonsCount[0] > 0) { // Pair Muon count : bit 0 corresponds "muonLowPt" & "pairNoCut" [jPaircut + iMuonCut * fNPairCuts] + keepEvent[4] = true; + } + //Filling the table + dqtable(keepEvent[kSingleE], keepEvent[kSingleMuLow], keepEvent[kSingleMuHigh], keepEvent[kDiElectron], keepEvent[kDiMuon]); + // Fill DQ bit map for (int i = 0; i < fNTrackCuts; i++) { if (singleBarrelCount[i] > 0) { filter |= (uint64_t(1) << i); fStatsSingleBarrel->Fill(i); - std::string nameTrkStr = fTrkCutsNameArray->At(i)->GetName(); - if (!nameTrkStr.compare("jpsiKineAndQuality")) { - keepEvent[kSingleE] = true; // Single Electron trigger - } } for (int j = 0; j < fNPairCuts; j++) { if (pairsBarrelCount[j + i * fNPairCuts] > 0) { filter |= (uint64_t(1) << (8 + j + i * fNPairCuts)); fStatsBarrel->Fill(j, i); - std::string nameTrkStr = fTrkCutsNameArray->At(i)->GetName(); - std::string namePairStr = fPairCuts[j].GetName(); - if (!namePairStr.compare("pairNoCut") && !nameTrkStr.compare("jpsiKineAndQuality")) { - keepEvent[kDiElectron] = true; // Di-Electron trigger - } } } } @@ -545,23 +555,11 @@ struct DQFilterPPTask { if (singleMuonsCount[i] > 0) { filter |= (uint64_t(1) << (32 + i)); fStatsSingleMuon->Fill(i); - std::string nameMuStr = fMuonCutsNameArray->At(i)->GetName(); - if (!nameMuStr.compare("muonLowPt")) { - keepEvent[kSingleMuLow] = true; // Single Low pT Muon trigger - } - if (!nameMuStr.compare("muonHighPt")) { - keepEvent[kSingleMuHigh] = true; // Single High pT Muon trigger - } } for (int j = 0; j < fNPairCuts; j++) { if (pairsUnlikeMuonsCount[j + i * fNPairCuts] > 0) { filter |= (uint64_t(1) << (40 + j + i * fNPairCuts)); fStatsMuon->Fill(j, i); - std::string nameMuStr = fMuonCutsNameArray->At(i)->GetName(); - std::string namePairStr = fPairCuts[j].GetName(); - if (!namePairStr.compare("pairNoCut") && !nameMuStr.compare("muonLowPt")) { - keepEvent[kDiMuon] = true; // Di-Muon low pT trigger - } } if (pairsLikeMuonsCount[j + i * fNPairCuts] > 0) { filter |= (uint64_t(1) << (52 + j + i * fNPairCuts)); @@ -577,8 +575,6 @@ struct DQFilterPPTask { delete[] singleBarrelCount; } eventFilter(filter); - //Filling the table - dqtable(keepEvent[kSingleE], keepEvent[kSingleMuLow], keepEvent[kSingleMuHigh], keepEvent[kDiElectron], keepEvent[kDiMuon]); } }; From bf06951d886ca2869d5b9227e5bd615176652157 Mon Sep 17 00:00:00 2001 From: Victor Feuillard Date: Wed, 17 Nov 2021 12:31:52 +0100 Subject: [PATCH 7/7] Clanf formating --- PWGDQ/Tasks/filterPP.cxx | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/PWGDQ/Tasks/filterPP.cxx b/PWGDQ/Tasks/filterPP.cxx index 5f712daa6c5..0d6ede57685 100644 --- a/PWGDQ/Tasks/filterPP.cxx +++ b/PWGDQ/Tasks/filterPP.cxx @@ -184,7 +184,7 @@ struct DQBarrelTrackSelectionTask { void DefineCuts() { // available cuts: jpsiKineAndQuality, jpsiPID1, jpsiPID2 - TString cutNamesStr = "jpsiPID1," + fConfigCuts.value; // "jpsiPID1" is the fixed standard cut provided to the Central Event Filtering task + TString cutNamesStr = "jpsiPID1," + fConfigCuts.value; // "jpsiPID1" is the fixed standard cut provided to the Central Event Filtering task if (!cutNamesStr.IsNull()) { std::unique_ptr objArray(cutNamesStr.Tokenize(",")); for (int icut = 0; icut < objArray->GetEntries(); ++icut) { @@ -519,24 +519,24 @@ struct DQFilterPPTask { } } - // Fill event selections tag for central event filtering - if (singleBarrelCount[0] > 0) { // Single Barrel count : bit 0 corresponds to "jpsiPID1" cut - keepEvent[0] = true; - } - if (singleMuonsCount[0] > 0) { // Single Muon count : bit 0 corresponds to "muonLowPt" cut - keepEvent[1] = true; - } - if (singleMuonsCount[1] > 0) { // Single Muon count : bit 1 corresponds to "muonHighPt" cut - keepEvent[2] = true; - } - if (pairsBarrelCount[0] > 0) { // Pair Barrel count : bit 0 corresponds "jpsiPID1" & "pairNoCut" [jPaircut + iTrackCut * fNPairCuts] - keepEvent[3] = true; - } - if (pairsUnlikeMuonsCount[0] > 0) { // Pair Muon count : bit 0 corresponds "muonLowPt" & "pairNoCut" [jPaircut + iMuonCut * fNPairCuts] - keepEvent[4] = true; - } - //Filling the table - dqtable(keepEvent[kSingleE], keepEvent[kSingleMuLow], keepEvent[kSingleMuHigh], keepEvent[kDiElectron], keepEvent[kDiMuon]); + // Fill event selections tag for central event filtering + if (singleBarrelCount[0] > 0) { // Single Barrel count : bit 0 corresponds to "jpsiPID1" cut + keepEvent[0] = true; + } + if (singleMuonsCount[0] > 0) { // Single Muon count : bit 0 corresponds to "muonLowPt" cut + keepEvent[1] = true; + } + if (singleMuonsCount[1] > 0) { // Single Muon count : bit 1 corresponds to "muonHighPt" cut + keepEvent[2] = true; + } + if (pairsBarrelCount[0] > 0) { // Pair Barrel count : bit 0 corresponds "jpsiPID1" & "pairNoCut" [jPaircut + iTrackCut * fNPairCuts] + keepEvent[3] = true; + } + if (pairsUnlikeMuonsCount[0] > 0) { // Pair Muon count : bit 0 corresponds "muonLowPt" & "pairNoCut" [jPaircut + iMuonCut * fNPairCuts] + keepEvent[4] = true; + } + //Filling the table + dqtable(keepEvent[kSingleE], keepEvent[kSingleMuLow], keepEvent[kSingleMuHigh], keepEvent[kDiElectron], keepEvent[kDiMuon]); // Fill DQ bit map for (int i = 0; i < fNTrackCuts; i++) {