From 0688da53b4bc3ecb72f3af61eedce8ec6db69e25 Mon Sep 17 00:00:00 2001 From: Antonio Ortiz Date: Mon, 15 Nov 2021 14:14:12 -0600 Subject: [PATCH] adding hm triggers --- EventFiltering/CMakeLists.txt | 5 + EventFiltering/PWGMM/multFilter.cxx | 142 ++++++++++++++++++++++++++++ EventFiltering/filterTables.h | 19 +++- 3 files changed, 161 insertions(+), 5 deletions(-) create mode 100644 EventFiltering/PWGMM/multFilter.cxx diff --git a/EventFiltering/CMakeLists.txt b/EventFiltering/CMakeLists.txt index 7394c66d0b9..e7284c7e3ee 100644 --- a/EventFiltering/CMakeLists.txt +++ b/EventFiltering/CMakeLists.txt @@ -52,3 +52,8 @@ o2physics_add_dpl_workflow(lf-strangeness-filter SOURCES PWGLF/strangenessFilter.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(mult-filter + SOURCES PWGMM/multFilter.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) diff --git a/EventFiltering/PWGMM/multFilter.cxx b/EventFiltering/PWGMM/multFilter.cxx new file mode 100644 index 00000000000..2d6372b88dc --- /dev/null +++ b/EventFiltering/PWGMM/multFilter.cxx @@ -0,0 +1,142 @@ + +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +// O2 includes +// \file multFilter.cxx +// \brief task for selection of high multiplicity events +// +// \author Antonio Ortiz , ICN-UNAM + +#include "ReconstructionDataFormats/Track.h" +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" + +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/TrackSelectionTables.h" + +#include "../filterTables.h" + +#include "Framework/HistogramRegistry.h" + +#include +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +static const std::vector mmObjectsNames{"w/ high-#it{p}_{T}", "high track-mult event"}; + +struct multFilter { + enum { kLeadingPtTrack = 0, + kHighTrackMult, + kNtriggersMM }; + + //event selection cuts + Configurable selectionLeadingPtTrack{"selectionLeadingPtTrack", 8., "Minimum track pT leading threshold"}; + Configurable selectionHighTrackMult{"selectionHighTrackMult", 54., "Minimum charged particle multiplicity threshold"}; + + Produces tags; + + //acceptance cuts + Configurable cfgVertexCut{"cfgVertexCut", 10.0f, "Accepted z-vertex range"}; + + Configurable cfgTrackEtaCut{"cfgTrackEtaCut", 0.8f, "Eta range for tracks"}; + Configurable cfgTrackLowPtCut{"cfgTrackLowPtCut", 0.15f, "Minimum constituent pT"}; + + HistogramRegistry multiplicity{"multiplicity", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + void init(o2::framework::InitContext&) + { + + + multiplicity.add("fCollZpos", "collision z position", HistType::kTH1F, {{200, -20., +20., "#it{z}_{vtx} position (cm)"}}); + multiplicity.add("hdNdeta", "dNdeta", HistType::kTH1F, {{50,-2.5,2.5, " "}}); + multiplicity.add("fLeadingTrackPt", "pT of high pT tracks", HistType::kTH1F, {{150, 0., +150., "track #it{p}_{T} (GeV/#it{c})"}}); + multiplicity.add("fTrackMult", "charged particle multiplicity", HistType::kTH1F, {{200, -0.5, +199.5, "number of tracks (|#eta|<0.8)"}}); + + multiplicity.add("fLeadingTrackPtSelected", "pT of selected high pT tracks", HistType::kTH1F, {{150, 0., +150., "track #it{p}_{T} (GeV/#it{c})"}}); + multiplicity.add("fTrackMultSelected", "charged particle multiplicity of the selected events", HistType::kTH1F, {{200, -0.5, +199.5, "number of tracks (|#eta|<0.8)"}}); + std::array eventTitles = {"all", "rejected"}; + + auto scalers{std::get>(multiplicity.add("fProcessedEvents", "Multiplicity - event filtered;;events", HistType::kTH1F, {{kNtriggersMM+2, -0.5, kNtriggersMM + 2 - 0.5}}))}; + for (size_t iBin = 0; iBin < eventTitles.size()+mmObjectsNames.size(); iBin++) { + if(iBin<2) + scalers->GetXaxis()->SetBinLabel(iBin + 1, eventTitles[iBin].data()); + else + scalers->GetXaxis()->SetBinLabel(iBin + 1, mmObjectsNames[iBin-2].data()); + } + } + + //declare filters on tracks and charged jets + Filter collisionFilter = nabs(aod::collision::posZ) < cfgVertexCut; + Filter trackFilter = (nabs(aod::track::eta) < cfgTrackEtaCut) && (aod::track::isGlobalTrack == (uint8_t) true) && (aod::track::pt > cfgTrackLowPtCut); + + using TrackCandidates = soa::Filtered>; + void process(soa::Filtered>::iterator const& collision, TrackCandidates const& tracks) + { + multiplicity.fill(HIST("fProcessedEvents"), 0); + + //check if your trigger alias is fired + if (!collision.alias()[kINT7]) { + return; + } + + bool keepEvent[kNtriggersMM]{false}; + // + multiplicity.fill(HIST("fCollZpos"), collision.posZ()); + Int_t multTrack = 0; + Double_t flPt = 0;// leading pT + //Check whether there is a leading pT track + for (auto& track : tracks) { // start loop over tracks + multTrack++; + multiplicity.fill(HIST("hdNdeta"), track.eta()); + if (flPt= selectionLeadingPtTrack) { + multiplicity.fill(HIST("fLeadingTrackPtSelected"), flPt); //track pT which passed the cut + keepEvent[kLeadingPtTrack] = true; + } + + + //Check whether this is a high multiplicity event + if(multTrack>=selectionHighTrackMult){ + keepEvent[kHighTrackMult] = true; // accepted HM events + multiplicity.fill(HIST("fTrackMultSelected"), multTrack); + } + tags(keepEvent[kLeadingPtTrack], keepEvent[kHighTrackMult]); + + if (!keepEvent[kLeadingPtTrack] && !keepEvent[kHighTrackMult]) { + multiplicity.fill(HIST("fProcessedEvents"), 1); + } else { + for (int iTrigger{0}; iTrigger < kNtriggersMM; iTrigger++) { + if (keepEvent[iTrigger]) { + multiplicity.fill(HIST("fProcessedEvents"), iTrigger+2); + } + } + } + + + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfg) +{ + + return WorkflowSpec{ + adaptAnalysisTask(cfg)}; +} diff --git a/EventFiltering/filterTables.h b/EventFiltering/filterTables.h index 36271c4e72a..3f88f14c63c 100644 --- a/EventFiltering/filterTables.h +++ b/EventFiltering/filterTables.h @@ -49,6 +49,10 @@ DECLARE_SOA_COLUMN(TripleXi, hasTripleXi, bool); //! at least 3 Xi DECLARE_SOA_COLUMN(QuadrupleXi, hasQuadrupleXi, bool); //! at least 4 Xi DECLARE_SOA_COLUMN(SingleXiYN, hasSingleXiYN, bool); //! at least 1 Xi with R > 24.39 cm (YN interactions) +// multiplicity +DECLARE_SOA_COLUMN(LeadingPtTrack, hasLeadingPtTrack, bool); //! event contains high-pT track +DECLARE_SOA_COLUMN(HighTrackMult, hasHighTrackMult, bool); //! high muliplicity collision + } // namespace filtering // nuclei @@ -84,12 +88,17 @@ DECLARE_SOA_TABLE(StrangenessFilters, "AOD", "LF Filters", //! using StrangenessFilter = StrangenessFilters::iterator; +// multiplicity +DECLARE_SOA_TABLE(MultFilters, "AOD", "MM Filters", //! + filtering::LeadingPtTrack, filtering::HighTrackMult); +using MultFilter = MultFilters::iterator; + /// List of the available filters, the description of their tables and the name of the tasks -constexpr int NumberOfFilters{6}; -constexpr std::array AvailableFilters{"NucleiFilters", "DiffractionFilters", "HeavyFlavourFilters", "CorrelationFilters", "JetFilters", "StrangenessFilters"}; -constexpr std::array FilterDescriptions{"NucleiFilters", "DiffFilters", "HFFilters", "CFFilters", "JetFilters", "LFStrgFilters"}; -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"}; -constexpr o2::framework::pack FiltersPack; +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; static_assert(o2::framework::pack_size(FiltersPack) == NumberOfFilters); template