[PWGEM/PhotonMeson] Enable cut on time since start of fill for EMC pi0 (#11852)

Co-authored-by: Nicolas Strangmann <nicolas.strangmann@.cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>

Author: 3 people

PWGEM/PhotonMeson/DataModel/bcWiseTables.h

@@ -41,23 +41,25 @@ enum Observable {
   kFT0Amp,
   kpT,
   kMu,
+  kTimeSinceSOF,
   nObservables
 };
 
 // Values in tables are stored in downscaled format to save disk space
 const float downscalingFactors[nObservables]{
-  1E0,  // Cluster definition
-  1E3,  // Cluster energy
-  1E4,  // Cluster eta
-  1E4,  // Cluster phi
-  1E0,  // Number of cells
-  1E4,  // M02
-  1E2,  // Cluster time
-  2E0,  // FT0M centrality
-  1E3,  // Z-vertex position
-  1E-1, // FT0M amplitude
-  1E3,  // MC pi0 pt
-  1E5}; // Mu
+  1E0,   // Cluster definition
+  1E3,   // Cluster energy
+  1E4,   // Cluster eta
+  1E4,   // Cluster phi
+  1E0,   // Number of cells
+  1E4,   // M02
+  1E2,   // Cluster time
+  2E0,   // FT0M centrality
+  1E3,   // Z-vertex position
+  1E-1,  // FT0M amplitude
+  1E3,   // MC pi0 pt
+  1E5,   // Mu
+  5E-1}; // Time since start of fill (since ADJUST decleration)
 } // namespace emdownscaling
 
 namespace bcwisebc
@@ -66,18 +68,19 @@ DECLARE_SOA_COLUMN(HasFT0, hasFT0, bool);                               //! has_
 DECLARE_SOA_COLUMN(HasTVX, hasTVX, bool);                               //! has the TVX trigger flag
 DECLARE_SOA_COLUMN(HaskTVXinEMC, haskTVXinEMC, bool);                   //! kTVXinEMC
 DECLARE_SOA_COLUMN(HasEMCCell, hasEMCCell, bool);                       //! at least one EMCal cell in the BC
-DECLARE_SOA_COLUMN(HasNoTFROFBorder, hasNoTFROFBorder, bool);           //! not in the TF border or ITS ROF border region
 DECLARE_SOA_COLUMN(StoredCentrality, storedCentrality, uint8_t);        //! FT0M centrality (0-100) (x2)
 DECLARE_SOA_COLUMN(StoredFT0MAmplitude, storedFT0MAmplitude, uint16_t); //! ft0a+c amplitude
 DECLARE_SOA_COLUMN(StoredMu, storedMu, uint16_t);                       //! probability of TVX collision per BC (x1000)
+DECLARE_SOA_COLUMN(StoredTimeSinceSOF, storedTimeSinceSOF, uint16_t);   //! time since decreation of ADJUST in seconds (x2)
 
 DECLARE_SOA_DYNAMIC_COLUMN(Centrality, centrality, [](uint8_t storedcentrality) -> float { return std::nextafter(storedcentrality / emdownscaling::downscalingFactors[emdownscaling::kFT0MCent], std::numeric_limits<float>::infinity()); });           //! Centrality (0-100)
 DECLARE_SOA_DYNAMIC_COLUMN(FT0MAmplitude, ft0Amplitude, [](uint16_t storedFT0MAmplitude) -> float { return std::nextafter(storedFT0MAmplitude / emdownscaling::downscalingFactors[emdownscaling::kFT0Amp], std::numeric_limits<float>::infinity()); }); //! FT0M amplitude
 DECLARE_SOA_DYNAMIC_COLUMN(Mu, mu, [](uint16_t storedMu) -> float { return std::nextafter(storedMu / emdownscaling::downscalingFactors[emdownscaling::kMu], std::numeric_limits<float>::infinity()); });                                                //! probability of TVX collision per BC
+DECLARE_SOA_DYNAMIC_COLUMN(TimeSinceSOF, timeSinceSOF, [](uint16_t storedTimeSinceSOF) -> float { return std::nextafter(storedTimeSinceSOF / emdownscaling::downscalingFactors[emdownscaling::kTimeSinceSOF], std::numeric_limits<float>::infinity()); }); //! probability of TVX collision per BC
 } // namespace bcwisebc
 DECLARE_SOA_TABLE(BCWiseBCs, "AOD", "BCWISEBC", //! table of bc wise centrality estimation and event selection input
-                  o2::soa::Index<>, bcwisebc::HasFT0, bcwisebc::HasTVX, bcwisebc::HaskTVXinEMC, bcwisebc::HasEMCCell, bcwisebc::HasNoTFROFBorder, bcwisebc::StoredCentrality,
-                  bcwisebc::StoredFT0MAmplitude, bcwisebc::StoredMu, bcwisebc::Centrality<bcwisebc::StoredCentrality>, bcwisebc::FT0MAmplitude<bcwisebc::StoredFT0MAmplitude>, bcwisebc::Mu<bcwisebc::StoredMu>);
+                  o2::soa::Index<>, bcwisebc::HasFT0, bcwisebc::HasTVX, bcwisebc::HaskTVXinEMC, bcwisebc::HasEMCCell, bcwisebc::StoredCentrality,
+                  bcwisebc::StoredFT0MAmplitude, bcwisebc::StoredMu, bcwisebc::StoredTimeSinceSOF, bcwisebc::Centrality<bcwisebc::StoredCentrality>, bcwisebc::FT0MAmplitude<bcwisebc::StoredFT0MAmplitude>, bcwisebc::Mu<bcwisebc::StoredMu>, bcwisebc::TimeSinceSOF<bcwisebc::StoredTimeSinceSOF>);
 
 DECLARE_SOA_INDEX_COLUMN(BCWiseBC, bcWiseBC); //! bunch crossing ID used as index
 

PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx

@@ -76,6 +76,7 @@ struct bcWiseClusterSkimmer {
   Configurable<bool> cfgRequirekTVXinEMC{"cfgRequirekTVXinEMC", false, "Only store kTVXinEMC triggered BCs"};
   Configurable<bool> cfgRequireGoodRCTQuality{"cfgRequireGoodRCTQuality", false, "Only store BCs with good quality of T0 and EMC in RCT"};
   Configurable<bool> cfgStoreMu{"cfgStoreMu", false, "Calculate and store mu (probablity of a TVX collision in the BC) per BC. Otherwise fill with 0"};
+  Configurable<bool> cfgStoreTime{"cfgStoreTime", false, "Calculate and store time since the start of fill. Otherwise fill with 0"};
   ConfigurableAxis cfgMultiplicityBinning{"cfgMultiplicityBinning", {1000, 0, 10000}, "Binning used for the binning of the number of particles in the event"};
 
   aod::rctsel::RCTFlagsChecker isFT0EMCGoodRCTChecker{aod::rctsel::kFT0Bad, aod::rctsel::kEMCBad};
@@ -198,25 +199,32 @@ struct bcWiseClusterSkimmer {
     return true;
   }
 
-  double calculateMu(const auto& bc)
+  void setLHCIFData(const auto& bc)
   {
+    if (mRunNumber == bc.runNumber())
+      return;
+
     auto& ccdbMgr = o2::ccdb::BasicCCDBManager::instance();
     uint64_t timeStamp = bc.timestamp();
 
-    if (mRunNumber != bc.runNumber()) {
-      std::map<std::string, std::string> metadata;
-      mLHCIFdata = ccdbMgr.getSpecific<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF", timeStamp, metadata);
-      if (mLHCIFdata == nullptr)
-        LOG(fatal) << "GRPLHCIFData not in database, timestamp:" << timeStamp;
-      mRunNumber = bc.runNumber();
-      LOG(info) << "LHCIF data fetched for run " << mRunNumber << " and timestamp " << timeStamp;
-    }
+    std::map<std::string, std::string> metadata;
+    mLHCIFdata = ccdbMgr.getSpecific<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF", timeStamp, metadata);
+    if (mLHCIFdata == nullptr)
+      LOG(fatal) << "GRPLHCIFData not in database, timestamp:" << timeStamp;
+    mRunNumber = bc.runNumber();
+    LOG(info) << "LHCIF data fetched for run " << mRunNumber << " and timestamp " << timeStamp;
+
+    return;
+  }
+
+  double calculateMu(const auto& bc)
+  {
+    auto& ccdbMgr = o2::ccdb::BasicCCDBManager::instance();
+    uint64_t timeStamp = bc.timestamp();
 
     auto bfilling = mLHCIFdata->getBunchFilling();
     double nbc = bfilling.getFilledBCs().size();
-
     double tvxRate = mRateFetcher.fetch(&ccdbMgr, timeStamp, bc.runNumber(), "T0VTX");
-
     double nTriggersPerFilledBC = tvxRate / nbc / o2::constants::lhc::LHCRevFreq;
     double mu = -std::log(1 - nTriggersPerFilledBC);
 
@@ -231,7 +239,6 @@ struct bcWiseClusterSkimmer {
     bool hasTVX = bc.selection_bit(aod::evsel::kIsTriggerTVX);
     bool haskTVXinEMC = bc.alias_bit(kTVXinEMC);
     bool hasEMCCell = cellsInBC.size() > 0;
-    bool hasNoTFROFBorder = bc.selection_bit(aod::evsel::kNoTimeFrameBorder) && bc.selection_bit(aod::evsel::kNoITSROFrameBorder);
     mHistManager.fill(HIST("nBCs"), 0);
     if (hasFT0)
       mHistManager.fill(HIST("nBCs"), 1);
@@ -241,10 +248,11 @@ struct bcWiseClusterSkimmer {
       mHistManager.fill(HIST("nBCs"), 3);
     if (hasEMCCell)
       mHistManager.fill(HIST("nBCs"), 4);
-    if (hasNoTFROFBorder)
-      mHistManager.fill(HIST("nBCs"), 5);
 
+    if (cfgStoreMu || cfgStoreTime)
+      setLHCIFData(bc);
     double mu = cfgStoreMu ? calculateMu(bc) : 0.;
+    float timeSinceSOF = cfgStoreTime ? (bc.timestamp() - mLHCIFdata->getFillNumberTime()) / 1e3 : 0.; // Convert to seconds
     float ft0Amp = hasFT0 ? bc.foundFT0().sumAmpA() + bc.foundFT0().sumAmpC() : 0.;
     double centralityOfCollision = 101.5;
     if (collisionsInBC.size() > 0)
@@ -253,7 +261,7 @@ struct bcWiseClusterSkimmer {
 
     mHistManager.fill(HIST("BCCentVsCollCent"), centralityOfBC, centralityOfCollision);
 
-    bcTable(hasFT0, hasTVX, haskTVXinEMC, hasEMCCell, hasNoTFROFBorder, convertForStorage<uint8_t>(centralityOfBC, kFT0MCent), convertForStorage<uint16_t>(ft0Amp, kFT0Amp), convertForStorage<uint16_t>(mu, kMu));
+    bcTable(hasFT0, hasTVX, haskTVXinEMC, hasEMCCell, convertForStorage<uint8_t>(centralityOfBC, kFT0MCent), convertForStorage<uint16_t>(ft0Amp, kFT0Amp), convertForStorage<uint16_t>(mu, kMu), convertForStorage<uint16_t>(timeSinceSOF, kTimeSinceSOF));
 
     for (const auto& collision : collisionsInBC)
       collisionTable(bcTable.lastIndex(), convertForStorage<uint8_t>(collision.centFT0M(), kFT0MCent), convertForStorage<int16_t>(collision.posZ(), kZVtx));

PWGEM/PhotonMeson/Tasks/emcalBcWiseGammaGamma.cxx

@@ -55,6 +55,8 @@ struct EmcalBcWiseGammaGamma {
   Configurable<float> cfgMinOpenAngle{"cfgMinOpenAngle", 0.0202, "Minimum opening angle between photons"};
   Configurable<int> cfgDistanceToEdge{"cfgDistanceToEdge", 1, "Distance to edge in cells required for rotated cluster to be accepted"};
   Configurable<int> cfgBGEventDownsampling{"cfgBGEventDownsampling", 1, "Only calculate background for every n-th event (performance reasons in PbPb)"};
+  Configurable<int> cfgMinTimeSinceSOF{"cfgMinTimeSinceSOF", -1, "Only analyze events with a time since start of fill larger than this value (in minutes)"};
+  Configurable<int> cfgMaxTimeSinceSOF{"cfgMaxTimeSinceSOF", 100000, "Only analyze events with a time since start of fill smaller than this value (in minutes)"};
 
   ConfigurableAxis cfgCentralityBinning{"cfgCentralityBinning", {VARIABLE_WIDTH, 0.f, 5.f, 10.f, 20.f, 30.f, 40.f, 50.f, 60.f, 70.f, 80.f, 90.f, 100.f, 101.f, 102.f}, "FT0M centrality (%)"};
 
@@ -83,6 +85,7 @@ struct EmcalBcWiseGammaGamma {
     mHistManager.add("Event/Z1VsZ2", "Z vertex positions for BCs with two collisions;#bf{#it{z}_{vtx}^{1} (cm)};#bf{#it{z}_{vtx}^{2} (cm)}", HistType::kTH2F, {{150, -15, 15}, {150, -15, 15}});
     mHistManager.add("Event/dZ", "Distance between vertices for BCs with two collisions;#bf{#Delta #it{z}_{vtx} (cm)};#bf{#it{N}_{BC}}", HistType::kTH1F, {{600, -30, 30}});
     mHistManager.add("Event/Mu", "Probablity of a collision in the BC;#bf{#mu};#bf{#it{N}_{BC}}", HistType::kTH1F, {{1000, 0., 0.1}});
+    mHistManager.add("Event/TimeSinceSOF", "Time of BC since the start of fill;#bf{t-t_{SOF} (min)};#bf{#it{N}_{BC}}", HistType::kTH1F, {{1200, 0., 600}});
 
     mHistManager.add("Event/Centrality", "FT0M centrality;FT0M centrality (%);#bf{#it{N}_{BC}}", HistType::kTH1F, {cfgCentralityBinning});
     mHistManager.add("Event/CentralityVsAmplitude", "FT0M AmplitudeVsCentrality;FT0M Centrality;FT0M Amplitude", HistType::kTH2F, {cfgCentralityBinning, {600, 0, 300000}});
@@ -140,6 +143,7 @@ struct EmcalBcWiseGammaGamma {
     mHistManager.fill(HIST("Event/nBCs"), 0, bc.centrality());
     float mu = bc.mu();
     mHistManager.fill(HIST("Event/Mu"), mu);
+    mHistManager.fill(HIST("Event/TimeSinceSOF"), bc.timeSinceSOF() / 60.);
     double p = mu > 0.001 ? mu / (1 - std::exp(-mu)) : 1.; // No pile-up for small mu (protection against division by zero)
     mHistManager.fill(HIST("Event/nCollisions"), 0, bc.centrality(), p);
     if (bc.hasFT0()) {
@@ -289,6 +293,8 @@ struct EmcalBcWiseGammaGamma {
       return false;
     if (cfgSelectOnlyUniqueAmbiguous == 2 && collisions.size() == 1)
       return false;
+    if (cfgMinTimeSinceSOF > bc.timeSinceSOF() / 60 || cfgMaxTimeSinceSOF < bc.timeSinceSOF() / 60)
+      return false;
     return true;
   }