Merge branch 'AliceO2Group:master' into A2-PR

Author: ypwangg

ALICE3/DataModel/OTFStrangeness.h

@@ -37,6 +37,8 @@ DECLARE_SOA_INDEX_COLUMN_FULL(PosTrack, posTrack, int, Tracks, "_Pos");
 DECLARE_SOA_INDEX_COLUMN_FULL(NegTrack, negTrack, int, Tracks, "_Neg");             //!
 DECLARE_SOA_INDEX_COLUMN_FULL(BachTrack, bachTrack, int, Tracks, "_Bach");          //!
 
+DECLARE_SOA_INDEX_COLUMN(McParticle, mcParticle);
+
 // topo vars
 DECLARE_SOA_COLUMN(DcaV0Daughters, dcaV0Daughters, float);
 DECLARE_SOA_COLUMN(DcaCascadeDaughters, dcaCascadeDaughters, float);
@@ -70,6 +72,9 @@ DECLARE_SOA_TABLE(UpgradeCascades, "AOD", "UPGRADECASCADES",
 
 using UpgradeCascade = UpgradeCascades::iterator;
 
+DECLARE_SOA_TABLE(A3CascadeMcLabels, "AOD", "A3CASCADEMCLABELS",
+                  o2::soa::Index<>, otfcascade::McParticleId);
+
 namespace otfv0
 {
 DECLARE_SOA_INDEX_COLUMN(Collision, collision);                         //!

ALICE3/TableProducer/alice3strangenessFinder.cxx

@@ -27,12 +27,11 @@
 
 bool TrackSelection::FulfillsITSHitRequirements(uint8_t itsClusterMap) const
 {
-  constexpr uint8_t bit = 1;
-  for (auto& itsRequirement : mRequiredITSHits) {
-    auto hits = std::count_if(itsRequirement.second.begin(), itsRequirement.second.end(), [&](auto&& requiredLayer) { return itsClusterMap & (bit << requiredLayer); });
-    if ((itsRequirement.first == -1) && (hits > 0)) {
+  for (const auto& [minHits, layerMask] : mRequiredITSHits) {
+    int hits = __builtin_popcount(itsClusterMap & layerMask);
+    if ((minHits == -1) && (hits > 0)) {
       return false; // no hits were required in specified layers
-    } else if (hits < itsRequirement.first) {
+    } else if (hits < minHits) {
       return false; // not enough hits found in specified layers
     }
   }
@@ -128,12 +127,20 @@ void TrackSelection::SetMaxDcaXYPtDep(std::function<float(float)> ptDepCut)
 void TrackSelection::SetRequireHitsInITSLayers(int8_t minNRequiredHits, std::set<uint8_t> requiredLayers)
 {
   // layer 0 corresponds to the the innermost ITS layer
-  mRequiredITSHits.push_back(std::make_pair(minNRequiredHits, requiredLayers));
+  uint8_t mask = 0;
+  for (const auto& layer : requiredLayers) {
+    mask |= (1u << layer);
+  }
+  mRequiredITSHits.push_back(std::make_pair(minNRequiredHits, mask));
   LOG(info) << "Track selection, set require hits in ITS layers: " << static_cast<int>(minNRequiredHits);
 }
 void TrackSelection::SetRequireNoHitsInITSLayers(std::set<uint8_t> excludedLayers)
 {
-  mRequiredITSHits.push_back(std::make_pair(-1, excludedLayers));
+  uint8_t mask = 0;
+  for (const auto& layer : excludedLayers) {
+    mask |= (1u << layer);
+  }
+  mRequiredITSHits.push_back(std::make_pair(-1, mask));
   LOG(info) << "Track selection, set require no hits in ITS layers";
 }
 

ALICE3/Tasks/alice3Strangeness.cxx

@@ -268,10 +268,10 @@ class TrackSelection
   bool mRequireTPCRefit{false};   // require refit in TPC
   bool mRequireGoldenChi2{false}; // require golden chi2 cut (Run 2 only)
 
-  // vector of ITS requirements (minNRequiredHits in specific requiredLayers)
-  std::vector<std::pair<int8_t, std::set<uint8_t>>> mRequiredITSHits{};
+  // vector of ITS requirements (minNRequiredHits, bitmask of requiredLayers)
+  std::vector<std::pair<int8_t, uint8_t>> mRequiredITSHits{};
 
-  ClassDefNV(TrackSelection, 1);
+  ClassDefNV(TrackSelection, 2);
 };
 
 #endif // COMMON_CORE_TRACKSELECTION_H_

Common/Core/TrackSelection.cxx

@@ -100,8 +100,9 @@ DECLARE_SOA_COLUMN(TimeToNext, timeToNext, float);               //!
 DECLARE_SOA_COLUMN(TimeToNeNext, timeToNeNext, float);           //!
 
 // Extra information from FIT detectors
-DECLARE_SOA_COLUMN(MultFV0AOuter, multFV0AOuter, float);     //! FV0 without innermost ring
 DECLARE_SOA_COLUMN(FT0TriggerMask, ft0TriggerMask, uint8_t); //!
+DECLARE_SOA_COLUMN(MultFV0AOuter, multFV0AOuter, float);     //! FV0 without innermost ring
+DECLARE_SOA_COLUMN(MultFT0AOuter, multFT0AOuter, float);     //! FT0A without innermost ring
 
 } // namespace mult
 DECLARE_SOA_TABLE(FV0Mults, "AOD", "FV0MULT", //! Multiplicity with the FV0 detector
@@ -260,7 +261,7 @@ DECLARE_SOA_COLUMN(MultCollidingBC, multCollidingBC, bool);          //! CTP tri
 DECLARE_SOA_COLUMN(MultFT0PosZ, multFT0PosZ, float);          //! Position along Z computed with the FT0 information within the BC
 DECLARE_SOA_COLUMN(MultFT0PosZValid, multFT0PosZValid, bool); //! Validity of the position along Z computed with the FT0 information
 } // namespace mult
-DECLARE_SOA_TABLE(MultBCs, "AOD", "MULTBC", //!
+DECLARE_SOA_TABLE(MultBCs_000, "AOD", "MULTBC", //!
                   mult::MultFT0A,
                   mult::MultFT0C,
                   mult::MultFT0PosZ,
@@ -283,11 +284,44 @@ DECLARE_SOA_TABLE(MultBCs, "AOD", "MULTBC", //!
                   mult::MultCollidingBC,
                   timestamp::Timestamp,
                   bc::Flags);
-using MultBC = MultBCs::iterator;
 
-DECLARE_SOA_TABLE(MultBcSel, "AOD", "MULTBCSEL", //! BC selection bits joinable with multBCs
+DECLARE_SOA_TABLE_VERSIONED(MultBCs_001, "AOD", "MULTBC", 1, //!
+                            mult::MultFT0A,
+                            mult::MultFT0C,
+                            mult::MultFV0A,
+                            mult::MultFDDA,
+                            mult::MultFDDC,
+                            mult::MultZNA,
+                            mult::MultZNC,
+                            mult::MultZEM1,
+                            mult::MultZEM2,
+                            mult::MultZPA,
+                            mult::MultZPC,
+                            mult::MultFV0AOuter,
+                            mult::MultFT0AOuter);
+
+DECLARE_SOA_TABLE(MultBcSel_000, "AOD", "MULTBCSEL", //! BC selection bits joinable with multBCs
                   evsel::Selection);
 
+DECLARE_SOA_TABLE_VERSIONED(MultBcSel_001, "AOD", "MULTBCSEL", 1, //! BC selection bits joinable with multBCs
+                            evsel::Selection,
+                            evsel::Rct,
+                            bc::Flags,
+                            timestamp::Timestamp,
+                            mult::MultFT0PosZ,
+                            mult::MultFT0PosZValid,
+                            mult::MultV0triggerBits,
+                            mult::MultT0triggerBits,
+                            mult::MultFDDtriggerBits,
+                            mult::MultTriggerMask,
+                            mult::MultCollidingBC,
+                            mult::MultTVX,
+                            mult::MultFV0OrA);
+
+using MultBCs = MultBCs_001;
+using MultBcSel = MultBcSel_001;
+using MultBC = MultBCs::iterator;
+
 // crosslinks
 namespace mult
 {

Common/Core/TrackSelection.h

@@ -113,3 +113,8 @@ o2physics_add_dpl_workflow(run2-tiny-to-full-pid
                     SOURCES run2TinyToFullPID.cxx
                     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
                     COMPONENT_NAME Analysis)
+
+o2physics_add_dpl_workflow(mult-bcs-converter
+                    SOURCES multBCsConverter.cxx
+                    PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
+                    COMPONENT_NAME Analysis)

Common/DataModel/Multiplicity.h

@@ -0,0 +1,74 @@
+// 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.
+
+/// \file multBCsConverter.cxx
+/// \brief Converts MultBCs and MultBcSel table from version 000 to 001
+/// \author Jesper Karlsson Gumrpecht
+
+#include "Common/DataModel/Multiplicity.h"
+
+#include <Framework/AnalysisDataModel.h>
+#include <Framework/AnalysisHelpers.h>
+#include <Framework/AnalysisTask.h>
+#include <Framework/runDataProcessing.h>
+
+using namespace o2;
+using namespace o2::framework;
+
+struct MultBCsConverter {
+  Produces<aod::MultBCs_001> multBC;
+  Produces<aod::MultBcSel_001> multBcSel;
+
+  static constexpr float DummyValue = -1.f;
+  static constexpr int DummyRct = 0;
+  void process(soa::Join<aod::MultBCs_000, aod::MultBcSel_000> const& multBCs)
+  {
+    multBC.reserve(multBCs.size());
+    multBcSel.reserve(multBCs.size());
+    for (const auto& multbc : multBCs) {
+      multBC(
+        multbc.multFT0A(),
+        multbc.multFT0C(),
+        multbc.multFV0A(),
+        multbc.multFDDA(),
+        multbc.multFDDC(),
+        multbc.multZNA(),
+        multbc.multZNC(),
+        multbc.multZEM1(),
+        multbc.multZEM2(),
+        multbc.multZPA(),
+        multbc.multZPC(),
+        DummyValue,  // dummy amplitude for FV0A Outer
+        DummyValue); // dummy amplitude for FT0A Outer
+
+      multBcSel(
+        multbc.selection_raw(),
+        DummyRct, // all flags to false
+        multbc.flags(),
+        multbc.timestamp(),
+        multbc.multFT0PosZ(),
+        multbc.multFT0PosZValid(),
+        multbc.multV0triggerBits(),
+        multbc.multT0triggerBits(),
+        multbc.multFDDtriggerBits(),
+        multbc.multTriggerMask(),
+        multbc.multCollidingBC(),
+        multbc.multTVX(),
+        multbc.multFV0OrA());
+    }
+  }
+};
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
+{
+  return WorkflowSpec{
+    adaptAnalysisTask<MultBCsConverter>(cfgc)};
+}

Common/TableProducer/Converters/CMakeLists.txt

@@ -155,6 +155,8 @@ struct MultiplicityExtraTable {
       float multFV0A = 0.f;
       float multFDDA = 0.f;
       float multFDDC = 0.f;
+      float multFT0AOuter = 0.f;
+      float multFV0AOuter = 0.f;
 
       // ZDC amplitudes
       float multZEM1 = -1.f;
@@ -195,8 +197,11 @@ struct MultiplicityExtraTable {
         multFT0TriggerBits = static_cast<uint8_t>(triggers.to_ulong());
 
         // calculate T0 charge
-        for (auto amplitude : ft0.amplitudeA()) {
-          multFT0A += amplitude;
+        for (size_t ii = 0; ii < ft0.amplitudeA().size(); ++ii) {
+          multFT0A += ft0.amplitudeA()[ii];
+          if (ft0.channelA()[ii] > 31) {
+            multFT0AOuter += ft0.amplitudeA()[ii];
+          }
         }
         for (auto amplitude : ft0.amplitudeC()) {
           multFT0C += amplitude;
@@ -212,8 +217,13 @@ struct MultiplicityExtraTable {
         std::bitset<8> fV0Triggers = fv0.triggerMask();
         multFV0TriggerBits = static_cast<uint8_t>(fV0Triggers.to_ulong());
 
-        for (auto amplitude : fv0.amplitude()) {
+        for (size_t ii = 0; ii < fv0.amplitude().size(); ii++) {
+          auto amplitude = fv0.amplitude()[ii];
+          auto channel = fv0.channel()[ii];
           multFV0A += amplitude;
+          if (channel > 7) {
+            multFV0AOuter += amplitude;
+          }
         }
         isFV0OrA = fV0Triggers[o2::fit::Triggers::bitA];
       } else {
@@ -254,15 +264,34 @@ struct MultiplicityExtraTable {
 
       bc2mult(bc2multArray[bc.globalIndex()]);
       multBC(
-        tru(multFT0A), tru(multFT0C),
-        tru(posZFT0), posZFT0valid, tru(multFV0A),
-        tru(multFDDA), tru(multFDDC), tru(multZNA), tru(multZNC), tru(multZEM1),
-        tru(multZEM2), tru(multZPA), tru(multZPC), Tvx, isFV0OrA,
-        multFV0TriggerBits, multFT0TriggerBits, multFDDTriggerBits, multBCTriggerMask, collidingBC,
+        tru(multFT0A),
+        tru(multFT0C),
+        tru(multFV0A),
+        tru(multFDDA),
+        tru(multFDDC),
+        tru(multZNA),
+        tru(multZNC),
+        tru(multZEM1),
+        tru(multZEM2),
+        tru(multZPA),
+        tru(multZPC),
+        tru(multFV0AOuter),
+        tru(multFT0AOuter));
+
+      multBcSel(
+        bc.selection_raw(),
+        bc.rct_raw(),
+        bc.flags(),
         bc.timestamp(),
-        bc.flags());
-
-      multBcSel(bc.selection_raw());
+        tru(posZFT0),
+        posZFT0valid,
+        multFV0TriggerBits,
+        multFT0TriggerBits,
+        multFDDTriggerBits,
+        multBCTriggerMask,
+        collidingBC,
+        Tvx,
+        isFV0OrA);
     }
   }