Merge c693d09 into sapling-pr-archive-ktf

Author: ktf

DataFormats/Reconstruction/include/ReconstructionDataFormats/MatchInfoTOF.h

@@ -86,6 +86,14 @@ class MatchInfoTOF
                       hasT0_1BCbefore = 0x1 << 8,
                       hasT0_2BCbefore = 0x1 << 9 };
 
+  void setFT0Best(double val, float res = 200.)
+  {
+    mFT0Best = val;
+    mFT0BestRes = res;
+  }
+  double getFT0Best() const { return mFT0Best; }
+  float getFT0BestRes() const { return mFT0BestRes; }
+
  private:
   int mIdLocal;                      // track id in sector of the pair track-TOFcluster
   float mChi2;                       // chi2 of the pair track-TOFcluster
@@ -106,7 +114,10 @@ class MatchInfoTOF
   float mTgeant = 0.0;        ///< geant time in MC
   double mT0true = 0.0;       ///< t0true
 
-  ClassDefNV(MatchInfoTOF, 8);
+  double mFT0Best = 0.0;     //< best info for collision time
+  float mFT0BestRes = 200.0; //< resolution (in ps) of the best info for collision time
+
+  ClassDefNV(MatchInfoTOF, 9);
 };
 } // namespace dataformats
 } // namespace o2

Detectors/GlobalTracking/src/MatchTOF.cxx

@@ -1581,6 +1581,8 @@ void MatchTOF::doMatchingForTPC(int sec)
 //______________________________________________
 int MatchTOF::findFITIndex(int bc, const gsl::span<const o2::ft0::RecPoints>& FITRecPoints, unsigned long firstOrbit)
 {
+  const auto& FT0Params = o2::ft0::InteractionTag::Instance();
+
   if ((!mHasFillScheme) && o2::tof::Utils::hasFillScheme()) {
     mHasFillScheme = true;
     for (int ibc = 0; ibc < o2::tof::Utils::getNinteractionBC(); ibc++) {
@@ -1598,6 +1600,10 @@ int MatchTOF::findFITIndex(int bc, const gsl::span<const o2::ft0::RecPoints>& FI
   const int distThr = 8;
 
   for (unsigned int i = 0; i < FITRecPoints.size(); i++) {
+    const auto& ft = FITRecPoints[i];
+    if (!FT0Params.isSelected(ft)) {
+      continue;
+    }
     const o2::InteractionRecord ir = FITRecPoints[i].getInteractionRecord();
     if (mHasFillScheme && !mFillScheme[ir.bc]) {
       continue;
@@ -1702,8 +1708,8 @@ void MatchTOF::BestMatches(std::vector<o2::dataformats::MatchInfoTOFReco>& match
     matchingPair.setT0true(TOFClusWork[matchingPair.getTOFClIndex()].getT0true());
 
     // let's check if cluster has multiple-hits (noferini)
-    if (TOFClusWork[matchingPair.getTOFClIndex()].getNumOfContributingChannels() > 1) {
-      const auto& tofcl = TOFClusWork[matchingPair.getTOFClIndex()];
+    const auto& tofcl = TOFClusWork[matchingPair.getTOFClIndex()];
+    if (tofcl.getNumOfContributingChannels() > 1) {
       // has an additional hit Up or Down (Z-dir)
       matchingPair.setHitPatternUpDown(tofcl.isAdditionalChannelSet(o2::tof::Cluster::kUp) ||
                                        tofcl.isAdditionalChannelSet(o2::tof::Cluster::kUpLeft) ||
@@ -1719,6 +1725,19 @@ void MatchTOF::BestMatches(std::vector<o2::dataformats::MatchInfoTOFReco>& match
                                           tofcl.isAdditionalChannelSet(o2::tof::Cluster::kDownRight) ||
                                           tofcl.isAdditionalChannelSet(o2::tof::Cluster::kUpRight));
     }
+
+    // estimate collision time using FT0 info if available
+    ULong64_t bclongtofCal = (matchingPair.getSignal() - 10000) * o2::tof::Geo::BC_TIME_INPS_INV;
+    double t0Best = bclongtofCal * o2::tof::Geo::BC_TIME_INPS; // here just BC
+    float t0BestRes = 200;
+    if (FITRecPoints.size() > 0) {
+      int index = findFITIndex(bclongtofCal, FITRecPoints, mFirstTForbit);
+      if (index > -1 && FITRecPoints[index].isValidTime(1) && FITRecPoints[index].isValidTime(2)) { // require A and C
+        t0Best += FITRecPoints[index].getCollisionTime(0);
+        t0BestRes = 15;
+      }
+    }
+    matchingPair.setFT0Best(t0Best, t0BestRes);
     matchedTracks[trkTypeSplitted].push_back(matchingPair); // array of MatchInfoTOF
 
     // get fit info

Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx

@@ -114,9 +114,9 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     }
   }
 
-  if (!writecalib) {
-    useFIT = false;
-  }
+  //  if (!writecalib) {
+  //    useFIT = false;
+  //  }
 
   LOG(debug) << "TOF MATCHER WORKFLOW configuration";
   LOG(debug) << "TOF track inputs = " << configcontext.options().get<std::string>("track-sources");

Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx

@@ -99,7 +99,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   irFrames.reserve(trackROFvec.size());
   int nBCPerTF = alpParams.roFrameLengthInBC;
 
-  LOGP(info, "ITSTracker pulled {} clusters, {} RO frames", compClusters.size(), trackROFvec.size());
+  LOGP(info, "ITSTracker pulled {} clusters, {} RO frames {}", compClusters.size(), trackROFvec.size(), compClusters.empty() ? " -> received no processable data will skip" : "");
   const dataformats::MCTruthContainer<MCCompLabel>* labels = nullptr;
   gsl::span<itsmft::MC2ROFRecord const> mc2rofs;
   if (mIsMC) {
@@ -157,7 +157,9 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   if (mRunVertexer) {
     vertROFvec.reserve(trackROFvec.size());
     // Run seeding vertexer
-    vertexerElapsedTime = mVertexer->clustersToVertices(logger);
+    if (!compClusters.empty()) {
+      vertexerElapsedTime = mVertexer->clustersToVertices(logger);
+    }
   } else { // cosmics
     mTimeFrame->resetRofPV();
   }
@@ -226,7 +228,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       mTimeFrame->addPrimaryVertices(vtxVecLoc, 0);
     }
   }
-  if (mRunVertexer) {
+  if (mRunVertexer && !compClusters.empty()) {
     LOG(info) << fmt::format(" - Vertex seeding total elapsed time: {} ms for {} ({} + {}) vertices found in {}/{} ROFs",
                              vertexerElapsedTime,
                              mTimeFrame->getPrimaryVerticesNum(),
@@ -244,14 +246,15 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   if (mCosmicsProcessing && compClusters.size() > 1500 * trackROFspan.size()) {
     LOG(error) << "Cosmics processing was requested with an average detector occupancy exceeding 1.e-7, skipping TF processing.";
   } else {
-
-    mTimeFrame->setMultiplicityCutMask(processingMask);
-    mTimeFrame->setROFMask(processUPCMask);
-    // Run CA tracker
-    if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
-      mTracker->clustersToTracks(logger, fatalLogger);
-    } else {
-      mTracker->clustersToTracks(logger, errorLogger);
+    if (!compClusters.empty()) {
+      mTimeFrame->setMultiplicityCutMask(processingMask);
+      mTimeFrame->setROFMask(processUPCMask);
+      // Run CA tracker
+      if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
+        mTracker->clustersToTracks(logger, fatalLogger);
+      } else {
+        mTracker->clustersToTracks(logger, errorLogger);
+      }
     }
     size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
     if (totTracks) {

Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx

@@ -378,8 +378,8 @@ void NoiseCalibratorSpec::sendOutputDcs(DataAllocator& output)
             << " : " << infoDcs.getEndValidityTimestamp();
 
   using clbUtilsDcs = o2::calibration::Utils;
-  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 0}, *imageDcs.get());
-  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 0}, infoDcs);
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 1}, *imageDcs.get());
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 1}, infoDcs);
 }
 
 void NoiseCalibratorSpec::sendOutputDcsMerge(DataAllocator& output)
@@ -447,8 +447,8 @@ void NoiseCalibratorSpec::sendOutputDcsMerge(DataAllocator& output)
             << " : " << infoDcs.getEndValidityTimestamp();
 
   using clbUtilsDcs = o2::calibration::Utils;
-  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 0}, *imageDcs.get());
-  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 0}, infoDcs);
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 1}, *imageDcs.get());
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 1}, infoDcs);
 }
 
 void NoiseCalibratorSpec::endOfStream(o2::framework::EndOfStreamContext& ec)

Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx

@@ -235,7 +235,7 @@ DataProcessorSpec getCalibratordEdxSpec(const o2::base::Propagator::MatCorrType
     Options{
       {"tf-per-slot", VariantType::UInt32, 6000u, {"number of TFs per calibration time slot, is overwritten by seconds-per-slot if > 0"}},
       {"seconds-per-slot", VariantType::Int, 180, {"seconds per calibration time slot, overwrites tf-per-slot if > 0"}},
-      {"max-delay", VariantType::UInt32, 10u, {"number of slots in past to consider"}},
+      {"max-delay", VariantType::UInt32, 1u, {"number of slots in past to consider"}},
       {"min-entries", VariantType::Int, 10000, {"minimum entries per stack to fit a single time slot"}},
       {"calib-interval-extension", VariantType::UInt32, 3600u, {"seconds by which to extend the calibration interval beyond the end of the time slot"}},
 

Framework/AnalysisSupport/src/AODWriterHelpers.cxx

@@ -21,7 +21,9 @@
 #include "Framework/TableConsumer.h"
 #include "Framework/DataOutputDirector.h"
 #include "Framework/TableTreeHelpers.h"
+#include "Framework/Monitoring.h"
 
+#include <Monitoring/Monitoring.h>
 #include <TFile.h>
 #include <TFile.h>
 #include <TTree.h>
@@ -235,6 +237,7 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
 
 AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 {
+  using namespace monitoring;
   auto& ac = ctx.services().get<AnalysisContext>();
   auto tskmap = ac.outTskMap;
   auto objmap = ac.outObjHistMap;
@@ -269,7 +272,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 
     callbacks.set<CallbackService::Id::EndOfStream>(endofdatacb);
     return [inputObjects, objmap, tskmap](ProcessingContext& pc) mutable -> void {
-      auto mergePart = [&inputObjects, &objmap, &tskmap](DataRef const& ref) {
+      auto mergePart = [&inputObjects, &objmap, &tskmap, &pc](DataRef const& ref) {
         if (!ref.header) {
           LOG(error) << "Header not found";
           return;
@@ -381,7 +384,13 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
             if (object->InheritsFrom(TList::Class())) {
               writeListToFile(static_cast<TList*>(object), parentDir->mkdir(object->GetName(), object->GetName(), true));
             } else {
-              parentDir->WriteObjectAny(object, object->Class(), object->GetName());
+              int objSize = parentDir->WriteObjectAny(object, object->Class(), object->GetName());
+              static int maxSizeWritten = 0;
+              if (objSize > maxSizeWritten) {
+                auto& monitoring = pc.services().get<Monitoring>();
+                maxSizeWritten = objSize;
+                monitoring.send(Metric{fmt::format("{}/{}:{}", object->ClassName(), object->GetName(), objSize), "aod-largest-object-written"}.addTag(tags::Key::Subsystem, tags::Value::DPL));
+              }
               auto* written = list->Remove(object);
               delete written;
             }

Framework/Core/src/runDataProcessing.cxx

@@ -1233,6 +1233,7 @@ std::vector<std::regex> getDumpableMetrics()
   dumpableMetrics.emplace_back("^aod-bytes-read-uncompressed$");
   dumpableMetrics.emplace_back("^aod-bytes-read-compressed$");
   dumpableMetrics.emplace_back("^aod-file-read-info$");
+  dumpableMetrics.emplace_back("^aod-largest-object-written$");
   dumpableMetrics.emplace_back("^table-bytes-.*");
   dumpableMetrics.emplace_back("^total-timeframes.*");
   dumpableMetrics.emplace_back("^device_state.*");