[PWGDQ] Add ReducedFIT table for UPC analysis

PWGDQ/Core/VarManager.cxx

@@ -13,7 +13,7 @@
 #include "Tools/KFparticle/KFUtilities.h"
 
 #include <cmath>
 #include <iostream>
 #include <map>
 #include <vector>
 
@@ -167,8 +167,8 @@
   // TO Do: add more systems
 
   // set the beam 4-momentum vectors
   float beamAEnergy = energy / 2.0 * sqrt(NumberOfProtonsA * NumberOfProtonsC / NumberOfProtonsC / NumberOfProtonsA); // GeV
   float beamCEnergy = energy / 2.0 * sqrt(NumberOfProtonsC * NumberOfProtonsA / NumberOfProtonsA / NumberOfProtonsC); // GeV
   float beamAMomentum = std::sqrt(beamAEnergy * beamAEnergy - NumberOfNucleonsA * NumberOfNucleonsA * MassProton * MassProton);
   float beamCMomentum = std::sqrt(beamCEnergy * beamCEnergy - NumberOfNucleonsC * NumberOfNucleonsC * MassProton * MassProton);
   fgBeamA.SetPxPyPzE(0, 0, beamAMomentum, beamAEnergy);
@@ -267,7 +267,7 @@
     double mean = calibMeanHist->GetBinContent(binTPCncls, binPin, binEta);
     double sigma = calibSigmaHist->GetBinContent(binTPCncls, binPin, binEta);
     return (nSigmaValue - mean) / sigma; // Return the calibrated nSigma value
   } else if (fgCalibrationType == 2) {
     // get the calibration histograms
     CalibObjects calibMean, calibSigma, calibStatus;
     switch (species) {
@@ -1970,4 +1970,56 @@
   fgVarNamesMap["kBdtBackground"] = kBdtBackground;
   fgVarNamesMap["kBdtPrompt"] = kBdtPrompt;
   fgVarNamesMap["kBdtNonprompt"] = kBdtNonprompt;
+  fgVariableNames[kAmplitudeFT0A] = "FT0A amplitude";
+  fgVariableUnits[kAmplitudeFT0A] = "a.u.";
+  fgVariableNames[kAmplitudeFT0C] = "FT0C amplitude";
+  fgVariableUnits[kAmplitudeFT0C] = "a.u.";
+  fgVariableNames[kTimeFT0A] = "FT0A time";
+  fgVariableUnits[kTimeFT0A] = "ns";
+  fgVariableNames[kTimeFT0C] = "FT0C time";
+  fgVariableUnits[kTimeFT0C] = "ns";
+  fgVariableNames[kTriggerMaskFT0] = "FT0 trigger mask";
+  fgVariableUnits[kTriggerMaskFT0] = "";
+  fgVariableNames[kNFiredChannelsFT0A] = "FT0A fired channels";
+  fgVariableUnits[kNFiredChannelsFT0A] = "";
+  fgVariableNames[kNFiredChannelsFT0C] = "FT0C fired channels";
+  fgVariableUnits[kNFiredChannelsFT0C] = "";
+  fgVariableNames[kAmplitudeFDDA] = "FDDA amplitude";
+  fgVariableUnits[kAmplitudeFDDA] = "a.u.";
+  fgVariableNames[kAmplitudeFDDC] = "FDDC amplitude";
+  fgVariableUnits[kAmplitudeFDDC] = "a.u.";
+  fgVariableNames[kTimeFDDA] = "FDDA time";
+  fgVariableUnits[kTimeFDDA] = "ns";
+  fgVariableNames[kTimeFDDC] = "FDDC time";
+  fgVariableUnits[kTimeFDDC] = "ns";
+  fgVariableNames[kTriggerMaskFDD] = "FDD trigger mask";
+  fgVariableUnits[kTriggerMaskFDD] = "";
+  fgVariableNames[kAmplitudeFV0A] = "FV0A amplitude";
+  fgVariableUnits[kAmplitudeFV0A] = "a.u.";
+  fgVariableNames[kTimeFV0A] = "FV0A time";
+  fgVariableUnits[kTimeFV0A] = "ns";
+  fgVariableNames[kTriggerMaskFV0A] = "FV0A trigger mask";
+  fgVariableUnits[kTriggerMaskFV0A] = "";
+  fgVariableNames[kNFiredChannelsFV0A] = "FV0A fired channels";
+  fgVariableUnits[kNFiredChannelsFV0A] = "";
+  fgVariableNames[kBBFT0Apf] = "FT0A BB pileup flag";
+  fgVariableUnits[kBBFT0Apf] = "";
+  fgVariableNames[kBGFT0Apf] = "FT0A BG pileup flag";
+  fgVariableUnits[kBGFT0Apf] = "";
+  fgVariableNames[kBBFT0Cpf] = "FT0C BB pileup flag";
+  fgVariableUnits[kBBFT0Cpf] = "";
+  fgVariableNames[kBGFT0Cpf] = "FT0C BG pileup flag";
+  fgVariableUnits[kBGFT0Cpf] = "";
+  fgVariableNames[kBBFV0Apf] = "FV0A BB pileup flag";
+  fgVariableUnits[kBBFV0Apf] = "";
+  fgVariableNames[kBGFV0Apf] = "FV0A BG pileup flag";
+  fgVariableUnits[kBGFV0Apf] = "";
+  fgVariableNames[kBBFDDApf] = "FDDA BB pileup flag";
+  fgVariableUnits[kBBFDDApf] = "";
+  fgVariableNames[kBGFDDApf] = "FDDA BG pileup flag";
+  fgVariableUnits[kBGFDDApf] = "";
+  fgVariableNames[kBBFDDCpf] = "FDDC BB pileup flag";
+  fgVariableUnits[kBBFDDCpf] = "";
+  fgVariableNames[kBGFDDCpf] = "FDDC BG pileup flag";
+  fgVariableUnits[kBGFDDCpf] = "";
 }

PWGDQ/Core/VarManager.h

@@ -21,6 +21,8 @@
 #define HomogeneousField
 #endif
 
+#include "PWGUD/Core/UDHelpers.h"
+
 #include "Common/CCDB/EventSelectionParams.h"
 #include "Common/CCDB/TriggerAliases.h"
 #include "Common/Core/CollisionTypeHelper.h"
@@ -65,14 +67,14 @@
 #include <cmath>
 #include <complex>
 #include <cstdint>
 #include <iostream>
 #include <map>
 #include <utility>
 #include <vector>
 
 using std::complex;
 using std::cout;
 using std::endl;
 
 using SMatrix55 = ROOT::Math::SMatrix<double, 5, 5, ROOT::Math::MatRepSym<double, 5>>;
 using SMatrix5 = ROOT::Math::SVector<double, 5>;
@@ -108,6 +110,7 @@
     ReducedEventMultExtra = BIT(19),
     CollisionQvectCentr = BIT(20),
     RapidityGapFilter = BIT(21),
+    ReducedFit = BIT(22),
     Track = BIT(0),
     TrackCov = BIT(1),
     TrackExtra = BIT(2),
@@ -912,6 +915,34 @@
     kBdtPrompt,
     kBdtNonprompt,
 
+    // FIT detector variables
+    kAmplitudeFT0A,
+    kAmplitudeFT0C,
+    kTimeFT0A,
+    kTimeFT0C,
+    kTriggerMaskFT0,
+    kAmplitudeFDDA,
+    kAmplitudeFDDC,
+    kTimeFDDA,
+    kTimeFDDC,
+    kTriggerMaskFDD,
+    kAmplitudeFV0A,
+    kTimeFV0A,
+    kTriggerMaskFV0A,
+    kBBFT0Apf,
+    kBGFT0Apf,
+    kBBFT0Cpf,
+    kBGFT0Cpf,
+    kBBFV0Apf,
+    kBGFV0Apf,
+    kBBFDDApf,
+    kBGFDDApf,
+    kBBFDDCpf,
+    kBGFDDCpf,
+    kNFiredChannelsFT0A,
+    kNFiredChannelsFT0C,
+    kNFiredChannelsFV0A,
+
     kNVars
   }; // end of Variables enumeration
 
@@ -1210,6 +1241,8 @@
   static void FillZDC(const T& zdc, float* values = nullptr);
   template <typename T>
   static void FillBdtScore(const T& bdtScore, float* values = nullptr);
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  static void FillFIT(const T1& bc, const T2& bcs, const T3& ft0s, const T4& fv0as, const T5& fdds, float* values = nullptr);
 
   static void SetCalibrationObject(CalibObjects calib, TObject* obj)
   {
@@ -1557,8 +1590,8 @@
   }
   if constexpr ((fillMap & MuonCov) > 0 || (fillMap & ReducedMuonCov) > 0) {
     o2::dataformats::GlobalFwdTrack propmuon = PropagateMuon(muontrack, collision);
     double px = propmuon.getP() * sin(M_PI / 2 - atan(mfttrack.tgl())) * cos(mfttrack.phi());
     double py = propmuon.getP() * sin(M_PI / 2 - atan(mfttrack.tgl())) * sin(mfttrack.phi());
     double pz = propmuon.getP() * cos(M_PI / 2 - atan(mfttrack.tgl()));
     double pt = std::sqrt(std::pow(px, 2) + std::pow(py, 2));
     values[kX] = mfttrack.x();
@@ -5858,5 +5891,60 @@
   }
   return value;
 }
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+void VarManager::FillFIT(T1 const& bc, T2 const& bcs, T3 const& ft0s, T4 const& fv0as, T5 const& fdds, float* values)
+{
+  if (!values) {
+    values = fgValues;
+  }
 
+  // Initialize FIT info structure
+  upchelpers::FITInfo fitInfo{};
+  udhelpers::getFITinfo(fitInfo, bc, bcs, ft0s, fv0as, fdds);
+
+  // Fill FT0 information
+  values[kAmplitudeFT0A] = fitInfo.ampFT0A;
+  values[kAmplitudeFT0C] = fitInfo.ampFT0C;
+  values[kTimeFT0A] = fitInfo.timeFT0A;
+  values[kTimeFT0C] = fitInfo.timeFT0C;
+  values[kTriggerMaskFT0] = static_cast<float>(fitInfo.triggerMaskFT0);
+  const auto ft0Index = bc.ft0Id();
+  if (ft0Index < 0 || ft0Index >= ft0s.size()) {
+    values[kNFiredChannelsFT0A] = -1;
+    values[kNFiredChannelsFT0C] = -1;
+  } else {
+    const auto ft0 = ft0s.iteratorAt(ft0Index);
+    values[kNFiredChannelsFT0A] = ft0.channelA().size();
+    values[kNFiredChannelsFT0C] = ft0.channelC().size();
+  }
+  // Fill FDD information
+  values[kAmplitudeFDDA] = fitInfo.ampFDDA;
+  values[kAmplitudeFDDC] = fitInfo.ampFDDC;
+  values[kTimeFDDA] = fitInfo.timeFDDA;
+  values[kTimeFDDC] = fitInfo.timeFDDC;
+  values[kTriggerMaskFDD] = static_cast<float>(fitInfo.triggerMaskFDD);
+
+  // Fill FV0A information
+  values[kAmplitudeFV0A] = fitInfo.ampFV0A;
+  values[kTimeFV0A] = fitInfo.timeFV0A;
+  values[kTriggerMaskFV0A] = static_cast<float>(fitInfo.triggerMaskFV0A);
+  const auto fv0aIndex = bc.fv0aId();
+  if (fv0aIndex < 0 || fv0aIndex >= fv0as.size()) {
+    values[kNFiredChannelsFV0A] = -1;
+  } else {
+    const auto fv0a = fv0as.iteratorAt(fv0aIndex);
+    values[kNFiredChannelsFV0A] = fv0a.channel().size();
+  }
+  // Fill pileup flags
+  values[kBBFT0Apf] = static_cast<float>(fitInfo.BBFT0Apf);
+  values[kBGFT0Apf] = static_cast<float>(fitInfo.BGFT0Apf);
+  values[kBBFT0Cpf] = static_cast<float>(fitInfo.BBFT0Cpf);
+  values[kBGFT0Cpf] = static_cast<float>(fitInfo.BGFT0Cpf);
+  values[kBBFV0Apf] = static_cast<float>(fitInfo.BBFV0Apf);
+  values[kBGFV0Apf] = static_cast<float>(fitInfo.BGFV0Apf);
+  values[kBBFDDApf] = static_cast<float>(fitInfo.BBFDDApf);
+  values[kBGFDDApf] = static_cast<float>(fitInfo.BGFDDApf);
+  values[kBBFDDCpf] = static_cast<float>(fitInfo.BBFDDCpf);
+  values[kBGFDDCpf] = static_cast<float>(fitInfo.BGFDDCpf);
+}
 #endif // PWGDQ_CORE_VARMANAGER_H_

PWGDQ/DataModel/ReducedInfoTables.h

@@ -35,8 +35,8 @@ namespace o2::aod
 
 namespace dqppfilter
 {
-DECLARE_SOA_COLUMN(EventFilter, eventFilter, uint64_t);  //! Bit-field used for the high level event triggering
-DECLARE_SOA_COLUMN(NewBcIndex, newBcIndex, uint64_t);    //! globalIndex of the new BC determined in filterPbPb
+DECLARE_SOA_COLUMN(EventFilter, eventFilter, uint64_t); //! Bit-field used for the high level event triggering
+DECLARE_SOA_COLUMN(NewBcIndex, newBcIndex, uint64_t);   //! globalIndex of the new BC determined in filterPbPb
 } // namespace dqppfilter
 
 DECLARE_SOA_TABLE(DQEventFilter, "AOD", "EVENTFILTER", //! Store event-level decisions (DQ high level triggers)
@@ -273,6 +273,56 @@ DECLARE_SOA_TABLE(ReducedZdcsExtra, "AOD", "REDUCEDZDCEXTRA", //!   Event ZDC ex
 using ReducedZdc = ReducedZdcs::iterator;
 using ReducedZdcExtra = ReducedZdcsExtra::iterator;
 
+namespace reducedfit
+{
+// FIT detector information (based on upchelpers::FITInfo structure)
+DECLARE_SOA_COLUMN(AmplitudeFT0A, amplitudeFT0A, float);         //! FT0A total amplitude
+DECLARE_SOA_COLUMN(AmplitudeFT0C, amplitudeFT0C, float);         //! FT0C total amplitude
+DECLARE_SOA_COLUMN(TimeFT0A, timeFT0A, float);                   //! FT0A time
+DECLARE_SOA_COLUMN(TimeFT0C, timeFT0C, float);                   //! FT0C time
+DECLARE_SOA_COLUMN(TriggerMaskFT0, triggerMaskFT0, uint8_t);     //! FT0 trigger mask
+DECLARE_SOA_COLUMN(NFiredChannelsFT0A, nFiredChannelsFT0A, int); //! Number of fired channels in FT0A
+DECLARE_SOA_COLUMN(NFiredChannelsFT0C, nFiredChannelsFT0C, int); //! Number of fired channels in FT0C
+DECLARE_SOA_COLUMN(AmplitudeFDDA, amplitudeFDDA, float);         //! FDDA total amplitude
+DECLARE_SOA_COLUMN(AmplitudeFDDC, amplitudeFDDC, float);         //! FDDC total amplitude
+DECLARE_SOA_COLUMN(TimeFDDA, timeFDDA, float);                   //! FDDA time
+DECLARE_SOA_COLUMN(TimeFDDC, timeFDDC, float);                   //! FDDC time
+DECLARE_SOA_COLUMN(TriggerMaskFDD, triggerMaskFDD, uint8_t);     //! FDD trigger mask
+DECLARE_SOA_COLUMN(AmplitudeFV0A, amplitudeFV0A, float);         //! FV0A total amplitude
+DECLARE_SOA_COLUMN(TimeFV0A, timeFV0A, float);                   //! FV0A time
+DECLARE_SOA_COLUMN(TriggerMaskFV0A, triggerMaskFV0A, uint8_t);   //! FV0A trigger mask
+DECLARE_SOA_COLUMN(NFiredChannelsFV0A, nFiredChannelsFV0A, int); //! Number of fired channels in FV0A
+DECLARE_SOA_COLUMN(BBFT0Apf, bbFT0Apf, int32_t);                 //! Beam-beam flags for FT0A
+DECLARE_SOA_COLUMN(BGFT0Apf, bgFT0Apf, int32_t);                 //! Beam-gas flags for FT0A
+DECLARE_SOA_COLUMN(BBFT0Cpf, bbFT0Cpf, int32_t);                 //! Beam-beam flags for FT0C
+DECLARE_SOA_COLUMN(BGFT0Cpf, bgFT0Cpf, int32_t);                 //! Beam-gas flags for FT0C
+DECLARE_SOA_COLUMN(BBFV0Apf, bbFV0Apf, int32_t);                 //! Beam-beam flags for FV0A
+DECLARE_SOA_COLUMN(BGFV0Apf, bgFV0Apf, int32_t);                 //! Beam-gas flags for FV0A
+DECLARE_SOA_COLUMN(BBFDDApf, bbFDDApf, int32_t);                 //! Beam-beam flags for FDDA
+DECLARE_SOA_COLUMN(BGFDDApf, bgFDDApf, int32_t);                 //! Beam-gas flags for FDDA
+DECLARE_SOA_COLUMN(BBFDDCpf, bbFDDCpf, int32_t);                 //! Beam-beam flags for FDDC
+DECLARE_SOA_COLUMN(BGFDDCpf, bgFDDCpf, int32_t);                 //! Beam-gas flags for FDDC
+} // namespace reducedfit
+
+DECLARE_SOA_TABLE(ReducedFITs, "AOD", "REDUCEDFIT", //! FIT detector information
+                  reducedfit::AmplitudeFT0A, reducedfit::AmplitudeFT0C,
+                  reducedfit::TimeFT0A, reducedfit::TimeFT0C,
+                  reducedfit::TriggerMaskFT0,
+                  reducedfit::NFiredChannelsFT0A, reducedfit::NFiredChannelsFT0C,
+                  reducedfit::AmplitudeFDDA, reducedfit::AmplitudeFDDC,
+                  reducedfit::TimeFDDA, reducedfit::TimeFDDC,
+                  reducedfit::TriggerMaskFDD,
+                  reducedfit::AmplitudeFV0A, reducedfit::TimeFV0A,
+                  reducedfit::TriggerMaskFV0A,
+                  reducedfit::NFiredChannelsFV0A,
+                  reducedfit::BBFT0Apf, reducedfit::BGFT0Apf,
+                  reducedfit::BBFT0Cpf, reducedfit::BGFT0Cpf,
+                  reducedfit::BBFV0Apf, reducedfit::BGFV0Apf,
+                  reducedfit::BBFDDApf, reducedfit::BGFDDApf,
+                  reducedfit::BBFDDCpf, reducedfit::BGFDDCpf);
+
+using ReducedFIT = ReducedFITs::iterator;
+
 namespace reducedtrack
 {
 // basic track information