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..28f2ce787a3 100644 --- a/PWGDQ/Core/CutsLibrary.h +++ b/PWGDQ/Core/CutsLibrary.h @@ -223,6 +223,18 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) 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; + } + if (!nameStr.compare("muonTightQualityCutsForTests")) { cut->AddCut(GetAnalysisCut("muonTightQualityCutsForTests")); return cut; @@ -490,6 +502,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..0d6ede57685 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" @@ -46,16 +47,29 @@ using namespace o2::framework::expressions; using namespace o2::aod; // Some definitions +namespace +{ +enum DQTriggers { + kSingleE = 0, + kSingleMuLow, + kSingleMuHigh, + kDiElectron, + kDiMuon, + kNTriggersDQ +}; +} // namespace namespace o2::aod { 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 +85,12 @@ using MyBarrelTracksSelected = 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; void DefineHistograms(HistogramManager* histMan, TString histClasses); @@ -142,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&) { @@ -167,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) { @@ -206,10 +223,86 @@ struct DQBarrelTrackSelectionTask { } }; +struct DQMuonsSelection { + Produces trackSel; + OutputObj fOutputList{"output"}; + HistogramManager* fHistMan; + std::vector fTrackCuts; + + float* fValues; + + Configurable fConfigCuts{"cfgMuonsCuts", "muonQualityCuts", "Comma separated list of ADDITIONAL 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 = "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) { + 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; @@ -218,17 +311,20 @@ 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 fConfigPairCuts{"cfgPairCuts", "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; int fNPairCuts; TObjArray* fTrkCutsNameArray; + TObjArray* fMuonCutsNameArray; 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) { @@ -255,40 +351,99 @@ 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 = "muonLowPt,muonHighPt," + 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 dielectron, last 32 for dimuons + //[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) { // 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 +453,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,22 +462,117 @@ 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 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); + } + 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); + } + } + } + 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 (pairsCount[j + i * fNPairCuts] > 0) { - filter |= (uint64_t(1) << (j + i * fNPairCuts)); - fStats->Fill(j, i); + 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); } } } - delete[] pairsCount; + + delete[] pairsBarrelCount; + delete[] pairsUnlikeMuonsCount; + delete[] pairsLikeMuonsCount; + delete[] singleMuonsCount; + delete[] singleBarrelCount; } eventFilter(filter); } @@ -333,6 +583,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) return WorkflowSpec{ adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; } @@ -363,7 +614,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"); + } } } }