Merge branch 'AliceO2Group:master' into master

Author: FDUEnrich

MC/bin/o2dpg_sim_workflow.py

@@ -2095,7 +2095,9 @@ def remove_json_prefix(path):
    TPCTStask['cmd'] += ' --primary-vertices '
    TPCTStask['cmd'] += ' | o2-tpc-time-series-workflow --enable-unbinned-root-output --sample-unbinned-tsallis --sampling-factor 0.01 '
    TPCTStask['cmd'] += putConfigValues() + ' ' + getDPL_global_options(bigshm=True)
-   workflow['stages'].append(TPCTStask)
+   if isActive('TOF') and isActive('TPC') and isActive('FT0'):
+      # could be relaxed or changed once the timerseries worklow is more reactive to input cluster- and track-types
+      workflow['stages'].append(TPCTStask)
 
   # cleanup
   # --------

MC/bin/o2dpg_sim_workflow_anchored.py

@@ -266,6 +266,21 @@ def retrieve_CTPScalers(ccdbreader, run_number, timestamp=None):
       return ctpscaler
     return None
 
+def retrieve_ITS_RampDuration(ccdbreader, timestamp):
+    """
+    Retrieves the ITS ramp-up duration for a given timestamp and
+    returns it in milliseconds.
+    ITS does not deliver digits during a certain ramp-up period so
+    the start of run is adjusted accordingly using this value.
+    """
+    _, ramp_duration = ccdbreader.fetch("ITS/Calib/RampDuration", "vector<float>", timestamp=timestamp)
+    if ramp_duration and len(ramp_duration) > 0:
+        # The vector contains the duration in seconds, convert to milliseconds
+        duration_ms = int(ramp_duration[0] * 1000)
+        return duration_ms
+    print("WARNING: ITS ramp duration vector is empty, using 0")
+    return 0
+
 def retrieve_MinBias_CTPScaler_Rate(ctpscaler, finaltime, trig_eff_arg, NBunches, ColSystem, eCM):
     """
     retrieves the CTP scalers object for a given timestamp
@@ -520,7 +535,11 @@ def main():
     run_start = GLOparams["SOR"]
     run_end = GLOparams["EOR"]
 
-    mid_run_timestamp = (run_start + run_end) // 2
+    # Adjust start of run using ITS ramp-up period
+    ITS_rampup = retrieve_ITS_RampDuration(ccdbreader, run_start)
+    print(f"ITS ramp-up time: {ITS_rampup} ms")
+    effective_run_start = run_start + ITS_rampup
+    mid_run_timestamp = (effective_run_start + run_end) // 2
 
     # --------
     # fetch other important global properties needed further below
@@ -580,16 +599,16 @@ def main():
     timestamp = 0
     prod_offset = 0
     if args.timeframeID != -1:
-      timestamp = determine_timestamp_from_timeframeID(run_start, run_end, args.timeframeID, GLOparams["OrbitsPerTF"])
+      timestamp = determine_timestamp_from_timeframeID(effective_run_start, run_end, args.timeframeID, GLOparams["OrbitsPerTF"])
       prod_offset = args.timeframeID
     else:
-      timestamp, prod_offset = determine_timestamp(run_start, run_end, [args.split_id - 1, args.prod_split], args.cycle, args.tf, GLOparams["OrbitsPerTF"])
+      timestamp, prod_offset = determine_timestamp(effective_run_start, run_end, [args.split_id - 1, args.prod_split], args.cycle, args.tf, GLOparams["OrbitsPerTF"])
 
     # determine orbit corresponding to timestamp (mainly used in exclude_timestamp function)
     orbit = GLOparams["FirstOrbit"] + int((timestamp - GLOparams["SOR"]) / ( LHCOrbitMUS / 1000))
 
     # this is anchored to
-    print ("Determined start-of-run to be: ", run_start)
+    print ("Determined start-of-run to be: ", effective_run_start)
     print ("Determined end-of-run to be: ", run_end)
     print ("Determined timestamp to be : ", timestamp)
     print ("Determined offset to be : ", prod_offset)
@@ -630,7 +649,7 @@ def main():
     # However, the last passed argument wins, so they would be overwritten. If this should not happen, the option
     # needs to be handled as further below:
     energyarg = (" -eCM " + str(eCM)) if A1 == A2 else (" -eA " + str(eA) + " -eB " + str(eB))
-    forwardargs += " -tf " + str(args.tf) + " --sor " + str(run_start) + " --timestamp " + str(timestamp) + " --production-offset " + str(prod_offset) + " -run " + str(args.run_number) + " --run-anchored --first-orbit "       \
+    forwardargs += " -tf " + str(args.tf) + " --sor " + str(effective_run_start) + " --timestamp " + str(timestamp) + " --production-offset " + str(prod_offset) + " -run " + str(args.run_number) + " --run-anchored --first-orbit "       \
                    + str(GLOparams["FirstOrbit"]) + " --orbitsPerTF " + str(GLOparams["OrbitsPerTF"]) + " -col " + str(ColSystem) + str(energyarg)
     # the following options can be overwritten/influence from the outside
     if not '--readoutDets' in forwardargs:

MC/config/PWGLF/ini/GeneratorLFDeuteronOOGap.ini

@@ -0,0 +1,6 @@
+[GeneratorExternal]
+fileName=${O2DPG_MC_CONFIG_ROOT}/MC/config/PWGLF/pythia8/generator_pythia8_longlived_gaptriggered.C
+funcName=generateLongLivedGapTriggered({1000010020}, 1, 4, 0.4, 8.0)
+
+[GeneratorPythia8]
+config=${O2DPG_MC_CONFIG_ROOT}/MC/config/common/pythia8/generator/pythia8_OO_536.cfg

MC/config/PWGLF/ini/tests/GeneratorLFDeuteronOOGap.C

@@ -0,0 +1,53 @@
+int External()
+{
+  std::string path{"o2sim_Kine.root"};
+  std::vector<int> possiblePDGs = {1000010020, -1000010020};
+
+  int nPossiblePDGs = possiblePDGs.size();
+
+  TFile file(path.c_str(), "READ");
+  if (file.IsZombie())
+  {
+    std::cerr << "Cannot open ROOT file " << path << "\n";
+    return 1;
+  }
+
+  auto tree = (TTree *)file.Get("o2sim");
+  if (!tree)
+  {
+    std::cerr << "Cannot find tree o2sim in file " << path << "\n";
+    return 1;
+  }
+  std::vector<o2::MCTrack> *tracks{};
+  tree->SetBranchAddress("MCTrack", &tracks);
+
+  std::vector<int> injectedPDGs;
+
+  auto nEvents = tree->GetEntries();
+  for (int i = 0; i < nEvents; i++)
+  {
+    auto check = tree->GetEntry(i);
+    for (int idxMCTrack = 0; idxMCTrack < tracks->size(); ++idxMCTrack)
+    {
+      auto track = tracks->at(idxMCTrack);
+      auto pdg = track.GetPdgCode();
+      auto it = std::find(possiblePDGs.begin(), possiblePDGs.end(), pdg);
+      if (it != possiblePDGs.end() && track.isPrimary())  // found
+      {
+        injectedPDGs.push_back(pdg);
+      }
+    }
+  }
+  std::cout << "--------------------------------\n";
+  std::cout << "# Events: " << nEvents << "\n";
+  if(injectedPDGs.empty()){
+    std::cerr << "No injected particles\n";
+    return 1; // At least one of the injected particles should be generated
+  }
+  for (int i = 0; i < nPossiblePDGs; i++)
+  {
+    std::cout << "# Injected nuclei \n";
+    std::cout << possiblePDGs[i] << ": " << std::count(injectedPDGs.begin(), injectedPDGs.end(), possiblePDGs[i]) << "\n";
+  }
+  return 0;
+}