[PWGCF] adding generic pair tasks (#13130)

Author: ariedel-cern

PWGCF/Femto/Core/cascadeBuilder.h

@@ -92,7 +92,7 @@ struct ConfOmegaBits : o2::framework::ConfigurableGroup {
 
 #define CASCADE_DEFAULT_SELECTION(defaultMassMin, defaultMassMax, defaultPdgCode)                              \
   o2::framework::Configurable<int> pdgCode{"pdgCode", defaultPdgCode, "Track PDG code"};                       \
-  o2::framework::Configurable<int> sign{"sign", 1, "Sign of the Lambda (+1 for Lambda and -1 for Antilambda"}; \
+  o2::framework::Configurable<int> sign{"sign", 1, "Sign of the charge of the Cascade "};                      \
   o2::framework::Configurable<float> ptMin{"ptMin", 0.f, "Minimum pT"};                                        \
   o2::framework::Configurable<float> ptMax{"ptMax", 999.f, "Maximum pT"};                                      \
   o2::framework::Configurable<float> etaMin{"etaMin", -10.f, "Minimum eta"};                                   \
@@ -105,7 +105,7 @@ struct ConfOmegaBits : o2::framework::ConfigurableGroup {
 
 struct ConfXiSelection : o2::framework::ConfigurableGroup {
   std::string prefix = std::string("XiSelection");
-  CASCADE_DEFAULT_SELECTION(1.22, 1.42, 3212)
+  CASCADE_DEFAULT_SELECTION(1.22, 1.42, 3312)
 };
 
 struct ConfOmegaSelection : o2::framework::ConfigurableGroup {

PWGCF/Femto/Core/cascadeHistManager.h

@@ -113,7 +113,7 @@ constexpr std::array<histmanager::HistInfo<CascadeHist>, kCascadeHistLast> HistT
    {kMassXiVsMassOmega, o2::framework::kTH2F, "hMassXiVsMassOmega", "mass #Xi vs mass #Omega; m_{#Lambda#pi} (GeV/#it{c}^{2}); m_{#LambdaK} (GeV/#it{c}^{2})"}}};
 
 template <typename T>
-auto makeCascadeAnalysisHistSpecMap(const T& confBinningAnalysis)
+auto makeCascadeHistSpecMap(const T& confBinningAnalysis)
 {
   return std::map<CascadeHist, std::vector<framework::AxisSpec>>{
     {kPt, {confBinningAnalysis.pt}},

PWGCF/Femto/Core/closePairRejection.h

@@ -58,13 +58,17 @@ struct ConfCpr : o2::framework::ConfigurableGroup {
 
 // tpc radii for computing phistar
 constexpr int kNradii = 9;
-constexpr std::array<float, kNradii> kTpcRadius = {85., 105., 125., 145., 165., 185., 205., 225., 245.};
+constexpr std::array<float, kNradii> kTpcRadius = {85., 105., 125., 145., 165., 185., 205., 225., 245.}; // in cm
 
 // directory names
 constexpr char PrefixTrackTrackSe[] = "CPR_TrackTrack/SE/";
 constexpr char PrefixTrackTrackMe[] = "CPR_TrackTrack/ME/";
-constexpr char PrefixTrackV0Se[] = "CPR_TrackV0/SE/";
-constexpr char PrefixTrackV0Me[] = "CPR_TrackV0/ME/";
+constexpr char PrefixTrackV0Se[] = "CPR_TrackV0Daughter/SE/";
+constexpr char PrefixTrackV0Me[] = "CPR_TrackV0Daughter/ME/";
+constexpr char PrefixTrackTwoTrackResonanceSe[] = "CPR_TrackResonanceDaughter/SE/";
+constexpr char PrefixTrackTwoTrackResonnaceMe[] = "CPR_TrackResonanceDaughter/ME/";
+constexpr char PrefixTrackCascadeSe[] = "CPR_TrackCascadeBachelor/SE/";
+constexpr char PrefixTrackCascadeMe[] = "CPR_TrackCascadeBachelor/ME/";
 constexpr char PrefixTrackKinkSe[] = "CPR_TrackKink/SE/";
 constexpr char PrefixTrackKinkMe[] = "CPR_TrackKink/ME/";
 
@@ -117,7 +121,7 @@ class CloseTrackRejection
     mChargeTrack2 = chargeTrack2;
 
     if (utils::sign(mChargeTrack1) != utils::sign(mChargeTrack2)) {
-      LOG(warn) << "CPR is truned on for tracks with opposite charge. Is this intended?";
+      LOG(warn) << "CPR is turned on for tracks with opposite charge. Is this intended?";
     }
 
     mHistogramRegistry = registry;
@@ -196,10 +200,12 @@ template <const char* prefix>
 class ClosePairRejectionTrackTrack
 {
  public:
-  void init(o2::framework::HistogramRegistry* registry, std::map<CprHist, std::vector<o2::framework::AxisSpec>>& specs, float detaMax, float dphistarMax, int signTrack1, int absChargeTrack1, int signTrack2, int AbsChargeTrack2, bool isActivated)
+  void init(o2::framework::HistogramRegistry* registry, std::map<CprHist, std::vector<o2::framework::AxisSpec>>& specs, float detaMax, float dphistarMax, int chargeTrack1, int chargeTrack2, bool isActivated)
   {
     mIsActivated = isActivated;
-    mCtr.init(registry, specs, detaMax, dphistarMax, signTrack1 * absChargeTrack1, signTrack2 * AbsChargeTrack2);
+    if (mIsActivated) {
+      mCtr.init(registry, specs, detaMax, dphistarMax, chargeTrack1, chargeTrack2);
+    }
   }
 
   void setMagField(float magField) { mCtr.setMagField(magField); }
@@ -221,14 +227,16 @@ template <const char* prefix>
 class ClosePairRejectionTrackV0 // can also be used for any particle type that has pos/neg daughters, like resonances
 {
  public:
-  void init(o2::framework::HistogramRegistry* registry, std::map<CprHist, std::vector<o2::framework::AxisSpec>>& specs, float detaMax, float dphistarMax, int signTrack, int absChargeTrack, bool isActivated)
+  void init(o2::framework::HistogramRegistry* registry, std::map<CprHist, std::vector<o2::framework::AxisSpec>>& specs, float detaMax, float dphistarMax, int chargeTrack, bool isActivated)
   {
     mIsActivated = isActivated;
-    mSignTrack = signTrack;
+    mChargeTrack = chargeTrack;
 
     // initialize CPR with charge of the track and the same charge for the daughter particle
-    // absolute charge of the daughter track will be 1, so we can pass the sign directly
-    mCtr.init(registry, specs, detaMax, dphistarMax, signTrack * absChargeTrack, signTrack);
+    // absolute charge of the daughter track will be 1, so we just pass the sign
+    if (mIsActivated) {
+      mCtr.init(registry, specs, detaMax, dphistarMax, mChargeTrack, utils::sign(mChargeTrack));
+    }
   }
 
   void setMagField(float magField)
@@ -238,14 +246,14 @@ class ClosePairRejectionTrackV0 // can also be used for any particle type that h
   template <typename T1, typename T2, typename T3>
   void setPair(const T1& track, const T2& v0, const T3 /*trackTable*/)
   {
-    if (mSignTrack == 1) {
+    if (mChargeTrack > 0) {
       auto daughter = v0.template posDau_as<T3>();
       mCtr.compute(track, daughter);
-    } else if (mSignTrack == -1) {
+    } else if (mChargeTrack < 0) {
       auto daughter = v0.template negDau_as<T3>();
       mCtr.compute(track, daughter);
     } else {
-      LOG(fatal) << "CPR Track-V0: Wrong track sign";
+      LOG(fatal) << "CPR Track-V0: Sign of the track is 0!";
     }
   }
 
@@ -258,23 +266,58 @@ class ClosePairRejectionTrackV0 // can also be used for any particle type that h
 
  private:
   CloseTrackRejection<prefix> mCtr;
-  int mSignTrack = 0;
+  int mChargeTrack = 0;
   bool mIsActivated = true;
 };
 
 template <const char* prefix>
-class ClosePairRejectionTrackKink
+class ClosePairRejectionTrackCascade // can also be used for any particle type that has pos/neg daughters, like resonances
 {
  public:
-  void init(o2::framework::HistogramRegistry* registry, std::map<CprHist, std::vector<o2::framework::AxisSpec>>& specs, float detaMax, float dphistarMax, int signTrack, int absChargeTrack, bool isActivated)
+  void init(o2::framework::HistogramRegistry* registry, std::map<CprHist, std::vector<o2::framework::AxisSpec>>& specs, float detaMax, float dphistarMax, int chargeTrack, int chargeCascade, bool isActivated)
   {
     mIsActivated = isActivated;
-    mSignTrack = signTrack;
+    if (mIsActivated) {
+      mCtr.init(registry, specs, detaMax, dphistarMax, chargeTrack, chargeCascade);
+    }
+  }
+
+  void setMagField(float magField)
+  {
+    mCtr.setMagField(magField);
+  }
+  template <typename T1, typename T2, typename T3>
+  void setPair(const T1& track, const T2& cascade, const T3 /*trackTable*/)
+  {
+    auto bachelor = cascade.template posDau_as<T3>();
+    mCtr.compute(track, bachelor);
+  }
 
+  bool isClosePair() const { return mCtr.isClosePair(); }
+  void fill()
+  {
+    mCtr.fill();
+  }
+  bool isActivated() const { return mIsActivated; }
+
+ private:
+  CloseTrackRejection<prefix> mCtr;
+  bool mIsActivated = true;
+};
+
+template <const char* prefix>
+class ClosePairRejectionTrackKink
+{
+ public:
+  void init(o2::framework::HistogramRegistry* registry, std::map<CprHist, std::vector<o2::framework::AxisSpec>>& specs, float detaMax, float dphistarMax, int chargeTrack, int signKinkCandidate, bool isActivated)
+  {
+    mIsActivated = isActivated;
     // initialize CPR with charge of the track and the charged daughter particle
     // For kinks, we compare the primary track with the charged daughter
     // The charged daughter has absolute charge of 1, so we can pass the sign directly
-    mCtr.init(registry, specs, detaMax, dphistarMax, signTrack * absChargeTrack, mSignTrack);
+    if (mIsActivated) {
+      mCtr.init(registry, specs, detaMax, dphistarMax, chargeTrack, signKinkCandidate);
+    }
   }
 
   void setMagField(float magField)
@@ -285,12 +328,8 @@ class ClosePairRejectionTrackKink
   template <typename T1, typename T2, typename T3>
   void setPair(const T1& track, const T2& kink, const T3 /*trackTable*/)
   {
-    if (mSignTrack == 1 || mSignTrack == -1) {
-      auto daughter = kink.template chaDau_as<T3>();
-      mCtr.compute(track, daughter);
-    } else {
-      LOG(warn) << "CPR Track-Kink: Wrong track sign";
-    }
+    auto daughter = kink.template chaDau_as<T3>();
+    mCtr.compute(track, daughter);
   }
 
   bool isClosePair() const { return mCtr.isClosePair(); }
@@ -302,7 +341,6 @@ class ClosePairRejectionTrackKink
 
  private:
   CloseTrackRejection<prefix> mCtr;
-  int mSignTrack = 0;
   bool mIsActivated = true;
 };
 

PWGCF/Femto/Core/collisionBuilder.h

@@ -80,6 +80,14 @@ struct ConfCollisionTriggers : o2::framework::ConfigurableGroup {
   o2::framework::Configurable<std::string> triggers{"triggers", std::string("fPPP,fPPL"), "Comma seperated list of all triggers to be used"};
 };
 
+struct ConfCollisionRctFlags : o2::framework::ConfigurableGroup {
+  std::string prefix = std::string("CollisionRctFlags");
+  o2::framework::Configurable<bool> useRctFlags{"useRctFlags", true, "Set to true to use RCT flags"};
+  o2::framework::Configurable<std::string> label{"label", std::string("CBT_hadronPID"), "Which RCT flag to check"};
+  o2::framework::Configurable<bool> useZdc{"useZdc", false, "Whether to use ZDC (only use for PbPb)"};
+  o2::framework::Configurable<bool> treatLimitedAcceptanceAsBad{"treatLimitedAcceptanceAsBad", false, "Whether to treat limited acceptance as bad or not"};
+};
+
 // configurables for collision selection
 struct ConfCollisionSelection : o2::framework::ConfigurableGroup {
   std::string prefix = std::string("CollisionSelection");
@@ -309,22 +317,27 @@ class CollisionBuilder
   CollisionBuilder() {}
   virtual ~CollisionBuilder() = default;
 
-  template <typename T1, typename T2, typename T3, typename T4, typename T5>
-  void init(T1& filter, T2& config, T3& table, T4& trigger, T5& initContext)
+  template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+  void init(T1& confFilter, T2& confBits, T3& confRct, T4& confTrigger, T5& confTable, T6& initContext)
   {
-    mCollisionSelection.configure(filter, config);
-    if (trigger.useTrigger.value) {
+    mCollisionSelection.configure(confFilter, confBits);
+    if (confTrigger.useTrigger.value) {
       mUseTrigger = true;
-      mTriggerNames = trigger.triggers.value;
-      mZorro.setBaseCCDBPath(trigger.ccdbPath.value);
+      mTriggerNames = confTrigger.triggers.value;
+      mZorro.setBaseCCDBPath(confTrigger.ccdbPath.value);
+    }
+    if (confRct.useRctFlags.value) {
+      mUseRctFlags = true;
+      mRctFlagsChecker.init(confRct.label.value, confRct.useZdc.value, confRct.treatLimitedAcceptanceAsBad.value);
     }
+
     LOG(info) << "Initialize femto collision builder...";
-    mProducedCollisions = utils::enableTable("FCols_001", table.produceCollisions.value, initContext);
-    mProducedCollisionMasks = utils::enableTable("FColMasks_001", table.produceCollisionMasks.value, initContext);
-    mProduceQns = utils::enableTable("FColQnBins_001", table.produceQns.value, initContext);
-    mProducedPositions = utils::enableTable("FColPos_001", table.producePositions.value, initContext);
-    mProducedMultiplicities = utils::enableTable("FColMults_001", table.produceMults.value, initContext);
-    mProducedCentralities = utils::enableTable("FColCents_001", table.produceCents.value, initContext);
+    mProducedCollisions = utils::enableTable("FCols_001", confTable.produceCollisions.value, initContext);
+    mProducedCollisionMasks = utils::enableTable("FColMasks_001", confTable.produceCollisionMasks.value, initContext);
+    mProduceQns = utils::enableTable("FColQnBins_001", confTable.produceQns.value, initContext);
+    mProducedPositions = utils::enableTable("FColPos_001", confTable.producePositions.value, initContext);
+    mProducedMultiplicities = utils::enableTable("FColMults_001", confTable.produceMults.value, initContext);
+    mProducedCentralities = utils::enableTable("FColCents_001", confTable.produceCents.value, initContext);
     if (mProducedCollisions || mProducedCollisionMasks || mProducedPositions || mProducedMultiplicities || mProducedCentralities) {
       mFillAnyTable = true;
       mCollisionSelection.printSelections(colSelsName, colSelsToString);
@@ -351,12 +364,17 @@ class CollisionBuilder
   template <typename T1, typename T2>
   bool checkCollision(T1 const& bc, T2 const& col)
   {
-    if (mUseTrigger) {
-      return mZorro.isSelected(bc.globalBC()) && mCollisionSelection.checkFilters(col) && mCollisionSelection.passesAllRequiredSelections();
-    } else {
-
-      return mCollisionSelection.checkFilters(col) && mCollisionSelection.passesAllRequiredSelections();
+    // First: if triggers are enabled, the object must be selected
+    if (mUseTrigger && !mZorro.isSelected(bc.globalBC())) {
+      return false;
+    }
+    // Then: if RCT flags are enabled, check them
+    if (mUseRctFlags && !mRctFlagsChecker(col)) {
+      return false;
     }
+    // Finally: do the expensive checks
+    return mCollisionSelection.checkFilters(col) &&
+           mCollisionSelection.passesAllRequiredSelections();
   }
 
   template <modes::System system, typename T1, typename T2>
@@ -406,6 +424,8 @@ class CollisionBuilder
   CollisionSelection mCollisionSelection;
   Zorro mZorro;
   bool mUseTrigger = false;
+  aod::rctsel::RCTFlagsChecker mRctFlagsChecker;
+  bool mUseRctFlags = false;
   std::string mTriggerNames = std::string("");
   bool mFillAnyTable = false;
   bool mProducedCollisions = false;

PWGCF/Femto/Core/dataTypes.h

@@ -25,6 +25,7 @@ namespace femtodatatypes
 // Note: Length of the bitmask is the limit of how many selections can be configured
 
 // datatypes for collsions
+using CollisionTagType = uint64_t;
 using CollisionMaskType = uint16_t;
 
 // datatypes for tracks

PWGCF/Femto/Core/femtoUtils.h

@@ -148,6 +148,12 @@ inline float getMass(int pdgCode)
     case kSigmaMinus:
       mass = o2::constants::physics::MassSigmaMinus;
       break;
+    case kXiMinus:
+      mass = o2::constants::physics::MassXiMinus;
+      break;
+    case kOmegaMinus:
+      mass = o2::constants::physics::MassOmegaMinus;
+      break;
     default:
       LOG(fatal) << "PDG code is not suppored";
   }