Merge branch 'AliceO2Group:master' into jethadronBranch

Author: yhou-git

PWGCF/Femto3D/TableProducer/singleTrackSelector.cxx

@@ -74,9 +74,12 @@ struct singleTrackSelector {
   Configurable<std::vector<float>> rejectWithinNsigmaTOF{"rejectWithinNsigmaTOF", std::vector<float>{-5.0f, 5.0f}, "TOF rejection Nsigma range for particles specified with PDG to be rejected"};
 
   Configurable<float> _pRemoveTofOutOfRange{"pRemoveTofOutOfRange", 100.f, "momentum starting from which request TOF nSigma to be within the stored range (-10 < Nsigma < 10)"};
+  Configurable<std::array<float, 3>> _ptRemoveTofOutOfRange{"ptRemoveTofOutOfRange", {100.f, -10.f, 10.f}, "transverse momentum starting from which request TOF nSigma to be within the stored range (-10 < Nsigma < 10)"};
 
   Configurable<float> _min_P{"min_P", 0.f, "lower mometum limit"};
   Configurable<float> _max_P{"max_P", 100.f, "upper mometum limit"};
+  Configurable<float> _min_Pt{"min_Pt", 0.f, "lower trasnverse mometum limit"};
+  Configurable<float> _max_Pt{"max_Pt", 100.f, "upper trasnverse mometum limit"};
   Configurable<float> _eta{"eta", 100.f, "abs eta value limit"};
   Configurable<float> _dcaXY{"dcaXY", 1000.f, "Maximum dca of track in xy"};
   Configurable<float> _dcaZ{"dcaZ", 1000.f, "Maximum dca of track in xy"};
@@ -120,6 +123,7 @@ struct singleTrackSelector {
   Filter trackFilter = ((o2::aod::track::itsChi2NCl <= 36.f) && (o2::aod::track::itsChi2NCl >= 0.f) && (o2::aod::track::tpcChi2NCl >= 0.f) && (o2::aod::track::tpcChi2NCl <= 4.f));
 
   Filter pFilter = o2::aod::track::p > _min_P&& o2::aod::track::p < _max_P;
+  Filter ptFilter = o2::aod::track::pt > _min_Pt&& o2::aod::track::pt < _max_Pt;
   Filter etaFilter = nabs(o2::aod::track::eta) < _eta;
   Filter dcaFilter = ((nabs(o2::aod::track::dcaXY) <= _dcaXY) && (nabs(o2::aod::track::dcaZ) <= _dcaZ)) &&
                      ((nabs(o2::aod::track::dcaXY) >= _dcaXYmin) && (nabs(o2::aod::track::dcaZ) >= _dcaZmin));
@@ -238,6 +242,8 @@ struct singleTrackSelector {
         if (o2::aod::singletrackselector::TPCselection<false>(track, std::make_pair(ii, keepWithinNsigmaTPC))) {
           if (track.p() > _pRemoveTofOutOfRange && !o2::aod::singletrackselector::TOFselection(track, std::make_pair(ii, std::vector<float>{-10.0, 10.0}), std::vector<float>{-10.0, 10.0}))
             continue;
+          if (track.pt() > _ptRemoveTofOutOfRange.value[0] && !o2::aod::singletrackselector::TOFselection(track, std::make_pair(ii, std::vector<float>{_ptRemoveTofOutOfRange.value[1], _ptRemoveTofOutOfRange.value[2]}), std::vector<float>{-10.f, +10.f}))
+            continue;
 
           tableRow(tableRowColl.lastIndex(),
                    track.p(),

PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx

@@ -20,6 +20,7 @@
 #include "PWGCF/DataModel/CorrelationsDerived.h"
 #include "PWGCF/TwoParticleCorrelations/DataModel/LongRangeDerived.h"
 #include "PWGMM/Mult/DataModel/bestCollisionTable.h"
+#include "PWGUD/Core/SGSelector.h"
 
 #include "Common/Core/RecoDecay.h"
 #include "Common/Core/TrackSelection.h"
@@ -77,12 +78,19 @@ using namespace o2::constants::math;
 struct LongrangecorrDerived {
 
   SliceCache cache;
+  SGSelector sgSelector;
   HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject};
   Configurable<int> cfgNmixedevent{"cfgNmixedevent", 5, "how many events are mixed"};
   Configurable<int> cfgPidMask{"cfgPidMask", 0, "Selection bitmask for the TPC particle"};
   Configurable<int> cfgV0Mask{"cfgV0Mask", 0, "Selection bitmask for the V0 particle"};
   Configurable<float> cfgVtxCut{"cfgVtxCut", 10.0f, "Vertex Z range to consider"};
 
+  Configurable<float> cfgFv0Cut{"cfgFv0Cut", 50.0f, "FV0A threshold"};
+  Configurable<float> cfgFt0aCut{"cfgFt0aCut", 100.0f, "FT0A threshold"};
+  Configurable<float> cfgFt0cCut{"cfgFt0cCut", 50.0f, "FT0C threshold"};
+  Configurable<float> cfgZdcCut{"cfgZdcCut", 0.1f, "ZDC threshold"};
+  Configurable<int> cfgGapSideCut{"cfgGapSideCut", 0, "Gap-side A=0, C=1, AC = 2, No Gap = -1, All events = 3"};
+
   ConfigurableAxis axisMultiplicity{"axisMultiplicity", {VARIABLE_WIDTH, 0, 10, 15, 25, 50, 60, 1000}, "multiplicity axis"};
   ConfigurableAxis axisPhi{"axisPhi", {96, 0, TwoPI}, "#phi axis"};
   ConfigurableAxis axisEtaTrig{"axisEtaTrig", {40, -1., 1.}, "#eta trig axis"};
@@ -111,13 +119,28 @@ struct LongrangecorrDerived {
   using MftbestTrksTable = aod::MftBestTrkLRTables;
   using V0TrksTable = aod::V0TrkLRTables;
 
+  using UpcCollsTable = soa::Join<aod::UpcCollLRTables, aod::UpcSgCollLRTables, aod::ZdcLRTables>;
+  using TrksUpcTable = aod::TrkLRUpcTables;
+  using MftTrksUpcTable = aod::MftTrkLRUpcTables;
+  using Ft0aTrksUpcTable = aod::Ft0aLRUpcTables;
+  using Ft0cTrksUpcTable = aod::Ft0cLRUpcTables;
+  using MftbestTrksUpcTable = aod::MftBestTrkLRUpcTables;
+  using V0TrksUpcTable = aod::V0TrkLRUpcTables;
+
   Preslice<TrksTable> perColTpc = aod::lrcorrtrktable::collLRTableId;
   Preslice<MftTrksTable> perColMft = aod::lrcorrtrktable::collLRTableId;
   Preslice<MftbestTrksTable> perColMftbest = aod::lrcorrtrktable::collLRTableId;
   Preslice<Ft0aTrksTable> perColFt0a = aod::lrcorrtrktable::collLRTableId;
   Preslice<Ft0cTrksTable> perColFt0c = aod::lrcorrtrktable::collLRTableId;
   Preslice<V0TrksTable> perColV0 = aod::lrcorrtrktable::collLRTableId;
 
+  Preslice<TrksUpcTable> perUpcColTpc = aod::lrcorrtrktable::upcCollLRTableId;
+  Preslice<MftTrksUpcTable> perUpcColMft = aod::lrcorrtrktable::upcCollLRTableId;
+  Preslice<MftbestTrksUpcTable> perUpcColMftbest = aod::lrcorrtrktable::upcCollLRTableId;
+  Preslice<Ft0aTrksUpcTable> perUpcColFt0a = aod::lrcorrtrktable::upcCollLRTableId;
+  Preslice<Ft0cTrksUpcTable> perUpcColFt0c = aod::lrcorrtrktable::upcCollLRTableId;
+  Preslice<V0TrksUpcTable> perUpcColV0 = aod::lrcorrtrktable::upcCollLRTableId;
+
   void init(InitContext const&)
   {
     std::vector<AxisSpec> corrAxis = {{axisVtxZ, "z-vtx (cm)"},
@@ -135,9 +158,12 @@ struct LongrangecorrDerived {
     mixed.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, userAxis));
 
     histos.add("hMultiplicity", "hMultiplicity", kTH1D, {axisMultiplicity});
-    histos.add("hCentrality", "hCentrality", kTH1D, {axisMultiplicity});
     histos.add("hVertexZ", "hVertexZ", kTH1D, {axisVtxZ});
 
+    histos.add("hGapSide", "hGapSide", kTH1I, {{5, -0.5, 4.5}});
+    histos.add("hTrueGapSide", "hTrueGapSide", kTH1I, {{6, -1.5, 4.5}});
+    histos.add("hTrueGapSide_AfterSel", "hTrueGapSide_AfterSel", kTH1I, {{6, -1.5, 4.5}});
+
     histos.add("Trig_eta", "Trig_eta", kTH1D, {axisEtaTrig});
     histos.add("Trig_phi", "Trig_phi", kTH1D, {axisPhi});
     histos.add("Trig_etavsphi", "Trig_etavsphi", kTH2D, {axisPhi, axisEtaTrig});
@@ -157,7 +183,6 @@ struct LongrangecorrDerived {
   void fillCollQA(TCollision const& col)
   {
     histos.fill(HIST("hMultiplicity"), col.multiplicity());
-    histos.fill(HIST("hCentrality"), col.centrality());
     histos.fill(HIST("hVertexZ"), col.zvtx());
   }
 
@@ -178,12 +203,32 @@ struct LongrangecorrDerived {
     histos.fill(HIST("Assoc_phi"), track.phi());
   }
 
+  template <bool fillHist = true, typename CheckCol>
+  bool isUpcEventSelected(CheckCol const& col)
+  {
+    if constexpr (fillHist) {
+      histos.fill(HIST("hGapSide"), col.gapSide());
+    }
+    int truegapSide = sgSelector.trueGap(col, cfgFv0Cut, cfgFt0aCut, cfgFt0cCut, cfgZdcCut);
+    if constexpr (fillHist) {
+      histos.fill(HIST("hTrueGapSide"), truegapSide);
+    }
+    if (truegapSide != cfgGapSideCut)
+      return false;
+    if constexpr (fillHist) {
+      histos.fill(HIST("hTrueGapSide_AfterSel"), truegapSide);
+    }
+    return true;
+  }
+
   template <class T>
   using HasTpcTrack = decltype(std::declval<T&>().trackType());
   template <class T>
   using HasV0Track = decltype(std::declval<T&>().v0Type());
   template <class T>
   using HasInvMass = decltype(std::declval<T&>().invMass());
+  template <class T>
+  using HasUpc = decltype(std::declval<T&>().gapSide());
 
   template <CorrelationContainer::CFStep step, typename TTarget, typename TTriggers, typename TAssocs>
   void fillCorrHist(TTarget target, TTriggers const& triggers, TAssocs const& assocs, bool mixing, float vz, float multiplicity, float eventWeight)
@@ -233,20 +278,31 @@ struct LongrangecorrDerived {
   } // process same
 
   template <typename TCollision, typename... TrackTypes>
-  void processMixed(TCollision const& col, TrackTypes&&... tracks)
+  void processMixed(TCollision const& cols, TrackTypes&&... tracks)
   {
-    auto getMultiplicity = [this](auto& collision) {
-      (void)this;
-      return collision.multiplicity();
+    auto getMultiplicity = [this](auto& col) {
+      if constexpr (std::experimental::is_detected<HasUpc, TCollision>::value) {
+        if (!isUpcEventSelected<false>(col)) {
+          return -1.0f;
+        }
+      } else {
+        (void)this;
+      }
+      return col.multiplicity();
     };
     using MixedBinning = FlexibleBinningPolicy<std::tuple<decltype(getMultiplicity)>, aod::lrcorrcolltable::Zvtx, decltype(getMultiplicity)>;
     MixedBinning binningOnVtxAndMult{{getMultiplicity}, {axisVtxZME, axisMultME}, true};
     auto tracksTuple = std::make_tuple(std::forward<TrackTypes>(tracks)...);
     using TupleAtrack = std::tuple_element<0, decltype(tracksTuple)>::type;
     using TupleBtrack = std::tuple_element<std::tuple_size_v<decltype(tracksTuple)> - 1, decltype(tracksTuple)>::type;
-    Pair<TCollision, TupleAtrack, TupleBtrack, MixedBinning> pairs{binningOnVtxAndMult, cfgNmixedevent, -1, col, tracksTuple, &cache};
+    Pair<TCollision, TupleAtrack, TupleBtrack, MixedBinning> pairs{binningOnVtxAndMult, cfgNmixedevent, -1, cols, tracksTuple, &cache};
     for (auto it = pairs.begin(); it != pairs.end(); it++) {
       auto& [col1, tracks1, col2, tracks2] = *it;
+      if constexpr (std::experimental::is_detected<HasUpc, TCollision>::value) {
+        if (!isUpcEventSelected<false>(col1) || !isUpcEventSelected<false>(col2)) {
+          continue;
+        }
+      }
       float eventweight = 1.0f / it.currentWindowNeighbours();
       fillCorrHist<CorrelationContainer::kCFStepReconstructed>(mixed, tracks1, tracks2, true, col1.zvtx(), col1.multiplicity(), eventweight);
     } // pair loop
@@ -342,6 +398,123 @@ struct LongrangecorrDerived {
     processMixed(cols, tracks, mfts);
   }
 
+  void processUpcTpcft0aSE(UpcCollsTable::iterator const& col, TrksUpcTable const& tracks, Ft0aTrksUpcTable const& ft0as)
+  {
+    if (!isUpcEventSelected<true>(col)) {
+      return;
+    }
+    processSame(col, tracks, ft0as);
+  }
+
+  void processUpcTpcft0cSE(UpcCollsTable::iterator const& col, TrksUpcTable const& tracks, Ft0cTrksUpcTable const& ft0cs)
+  {
+    if (!isUpcEventSelected<true>(col)) {
+      return;
+    }
+    processSame(col, tracks, ft0cs);
+  }
+
+  void processUpcTpcmftSE(UpcCollsTable::iterator const& col, TrksUpcTable const& tracks, MftTrksUpcTable const& mfts)
+  {
+    if (!isUpcEventSelected<true>(col)) {
+      return;
+    }
+    processSame(col, tracks, mfts);
+  }
+
+  void processUpcMftft0aSE(UpcCollsTable::iterator const& col, MftTrksUpcTable const& mfts, Ft0aTrksUpcTable const& ft0as)
+  {
+    if (!isUpcEventSelected<true>(col)) {
+      return;
+    }
+    processSame(col, mfts, ft0as);
+  }
+
+  void processUpcV0ft0aSE(UpcCollsTable::iterator const& col, V0TrksUpcTable const& tracks, Ft0aTrksUpcTable const& ft0as)
+  {
+    if (!isUpcEventSelected<true>(col)) {
+      return;
+    }
+    processSame(col, tracks, ft0as);
+  }
+
+  void processUpcV0mftSE(UpcCollsTable::iterator const& col, V0TrksUpcTable const& tracks, MftTrksUpcTable const& mfts)
+  {
+    if (!isUpcEventSelected<true>(col)) {
+      return;
+    }
+    processSame(col, tracks, mfts);
+  }
+
+  void processUpcTpcmftbestSE(UpcCollsTable::iterator const& col, TrksUpcTable const& tracks, MftbestTrksUpcTable const& mfts)
+  {
+    if (!isUpcEventSelected<true>(col)) {
+      return;
+    }
+    processSame(col, tracks, mfts);
+  }
+
+  void processUpcMftbestft0aSE(UpcCollsTable::iterator const& col, MftbestTrksUpcTable const& mfts, Ft0aTrksUpcTable const& ft0as)
+  {
+    if (!isUpcEventSelected<true>(col)) {
+      return;
+    }
+    processSame(col, mfts, ft0as);
+  }
+
+  void processUpcV0mftbestSE(UpcCollsTable::iterator const& col, V0TrksUpcTable const& tracks, MftbestTrksUpcTable const& mfts)
+  {
+    if (!isUpcEventSelected<true>(col)) {
+      return;
+    }
+    processSame(col, tracks, mfts);
+  }
+
+  void processUpcTpcft0aME(UpcCollsTable const& cols, TrksUpcTable const& tracks, Ft0aTrksUpcTable const& ft0as)
+  {
+    processMixed(cols, tracks, ft0as);
+  }
+
+  void processUpcTpcft0cME(UpcCollsTable const& cols, TrksUpcTable const& tracks, Ft0cTrksUpcTable const& ft0cs)
+  {
+    processMixed(cols, tracks, ft0cs);
+  }
+
+  void processUpcTpcmftME(UpcCollsTable const& cols, TrksUpcTable const& tracks, MftTrksUpcTable const& mfts)
+  {
+    processMixed(cols, tracks, mfts);
+  }
+
+  void processUpcMftft0aME(UpcCollsTable const& cols, MftTrksUpcTable const& mfts, Ft0aTrksUpcTable const& ft0as)
+  {
+    processMixed(cols, mfts, ft0as);
+  }
+
+  void processUpcV0ft0aME(UpcCollsTable const& cols, V0TrksUpcTable const& tracks, Ft0aTrksUpcTable const& ft0as)
+  {
+    processMixed(cols, tracks, ft0as);
+  }
+
+  void processUpcV0mftME(UpcCollsTable const& cols, V0TrksUpcTable const& tracks, MftTrksUpcTable const& mfts)
+  {
+    processMixed(cols, tracks, mfts);
+  }
+
+  void processUpcTpcmftbestME(UpcCollsTable const& cols, TrksUpcTable const& tracks, MftbestTrksUpcTable const& mfts)
+  {
+    processMixed(cols, tracks, mfts);
+  }
+
+  void processUpcMftbestft0aME(UpcCollsTable const& cols, MftbestTrksUpcTable const& mfts, Ft0aTrksUpcTable const& ft0as)
+  {
+    processMixed(cols, mfts, ft0as);
+  }
+
+  void processUpcV0mftbestME(UpcCollsTable const& cols, V0TrksUpcTable const& tracks, MftbestTrksUpcTable const& mfts)
+  {
+    processMixed(cols, tracks, mfts);
+  }
+
   PROCESS_SWITCH(LongrangecorrDerived, processTpcft0aSE, "same event TPC vs FT0A", false);
   PROCESS_SWITCH(LongrangecorrDerived, processTpcft0aME, "mixed event TPC vs FT0A", false);
   PROCESS_SWITCH(LongrangecorrDerived, processTpcft0cSE, "same event TPC vs FT0C", false);
@@ -360,6 +533,24 @@ struct LongrangecorrDerived {
   PROCESS_SWITCH(LongrangecorrDerived, processMftbestft0aME, "mixed event best MFT vs FT0A", false);
   PROCESS_SWITCH(LongrangecorrDerived, processV0mftbestSE, "same event V0 vs best MFT", false);
   PROCESS_SWITCH(LongrangecorrDerived, processV0mftbestME, "mixed event V0 vs best MFT", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcft0aSE, "same UPC event TPC vs FT0A", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcft0aME, "mixed UPC event TPC vs FT0A", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcft0cSE, "same UPC event TPC vs FT0C", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcft0cME, "mixed UPC event TPC vs FT0C", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcmftSE, "same UPC event TPC vs MFT", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcmftME, "mixed UPC event TPC vs MFT", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcMftft0aSE, "same UPC event MFT vs FT0A", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcMftft0aME, "mixed UPC event MFT vs FT0A", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcV0ft0aSE, "same UPC event V0 vs FT0A", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcV0ft0aME, "mixed UPC event V0 vs FT0A", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcV0mftSE, "same UPC event V0 vs MFT", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcV0mftME, "mixed UPC event V0 vs MFT", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcmftbestSE, "same UPC event TPC vs best MFT", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcmftbestME, "mixed UPC event TPC vs best MFT", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcMftbestft0aSE, "same UPC event best MFT vs FT0A", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcMftbestft0aME, "mixed UPC event best MFT vs FT0A", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcV0mftbestSE, "same UPC event V0 vs best MFT", false);
+  PROCESS_SWITCH(LongrangecorrDerived, processUpcV0mftbestME, "mixed UPC event V0 vs best MFT", false);
 };
 
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)

PWGJE/Tasks/bjetTreeCreator.cxx

@@ -245,6 +245,7 @@ struct BJetTreeCreator {
 
   Configurable<std::vector<double>> jetRadii{"jetRadii", std::vector<double>{0.4}, "jet resolution parameters"};
 
+  Configurable<bool> produceSVTree{"produceSVTree", true, "produce the SV-correlated jet TTree”"};
   Configurable<bool> produceTree{"produceTree", true, "produce the jet TTree"};
 
   Configurable<float> vtxRes{"vtxRes", 0.01, "Vertex position resolution (cluster size) for GNN vertex predictions (cm)"};
@@ -415,7 +416,7 @@ struct BJetTreeCreator {
       double energySV = candSV.e();
 
       if (svIndices.size() < (svReductionFactor * myJet.template tracks_as<AnyTracks>().size()) && svIndices.size() < maxConstSV) {
-        if (produceTree) {
+        if (produceSVTree) {
           bjetSVParamsTable(bjetParamsTable.lastIndex() + 1, candSV.pt(), deltaRJetSV, massSV, energySV / myJet.energy(), candSV.impactParameterXY(), candSV.cpa(), candSV.chi2PCA(), candSV.dispersion(), candSV.decayLengthXY(), candSV.errorDecayLengthXY(), candSV.decayLength(), candSV.errorDecayLength());
         }
         svIndices.push_back(bjetSVParamsTable.lastIndex());
@@ -755,6 +756,7 @@ struct BJetTreeCreator {
       }
 
       std::vector<int> indicesTracks;
+      std::vector<int> indicesSVs;
 
       int16_t jetFlavor = analysisJet.origin();
 
@@ -791,7 +793,6 @@ struct BJetTreeCreator {
       }
 
       if (produceTree) {
-        std::vector<int> indicesSVs;
         bjetConstituentsTable(bjetParamsTable.lastIndex() + 1, indicesTracks, indicesSVs);
         bjetParamsTable(analysisJet.pt(), analysisJet.eta(), analysisJet.phi(), indicesTracks.size(), nVertices, analysisJet.mass(), jetFlavor, analysisJet.r());
       }