Merge a39c7fa into sapling-pr-archive-ehellbar

Author: ehellbar

DataFormats/common/include/CommonDataFormat/BunchFilling.h

@@ -107,7 +107,6 @@ class BunchFilling
 
   ClassDefNV(BunchFilling, 2);
 };
-} // namespace o2
 
 namespace framework
 {
@@ -118,5 +117,6 @@ struct is_messageable<o2::BunchFilling> : std::true_type {
 };
 
 } // namespace framework
+} // namespace o2
 
 #endif

DataFormats/simulation/src/DigitizationContext.cxx

@@ -577,7 +577,7 @@ void DigitizationContext::applyMaxCollisionFilter(std::vector<std::tuple<int, in
     if (indices_old_to_new.find(lastindex) != indices_old_to_new.end()) {
       std::get<1>(tf_indices) = indices_old_to_new[lastindex]; // end;
     } else {
-      std::get<1>(tf_indices) = newrecords.size(); // end;
+      std::get<1>(tf_indices) = newrecords.size() - 1; // end; -1 since index inclusif
     }
     if (indices_old_to_new.find(previndex) != indices_old_to_new.end()) {
       std::get<2>(tf_indices) = indices_old_to_new[previndex]; // previous or "early" index
@@ -591,11 +591,6 @@ void DigitizationContext::applyMaxCollisionFilter(std::vector<std::tuple<int, in
 std::vector<std::tuple<int, int, int>> DigitizationContext::calcTimeframeIndices(long startOrbit, long orbitsPerTF, double orbitsEarly) const
 {
   auto timeframeindices = getTimeFrameBoundaries(mEventRecords, startOrbit, orbitsPerTF, orbitsEarly);
-  LOG(info) << "Fixed " << timeframeindices.size() << " timeframes ";
-  for (auto p : timeframeindices) {
-    LOG(info) << std::get<0>(p) << " " << std::get<1>(p) << " " << std::get<2>(p);
-  }
-
   return timeframeindices;
 }
 
@@ -708,7 +703,7 @@ DigitizationContext DigitizationContext::extractSingleTimeframe(int timeframeid,
     auto tf_ranges = timeframeindices.at(timeframeid);
 
     auto startindex = std::get<0>(tf_ranges);
-    auto endindex = std::get<1>(tf_ranges);
+    auto endindex = std::get<1>(tf_ranges) + 1;
     auto earlyindex = std::get<2>(tf_ranges);
 
     if (earlyindex >= 0) {

Detectors/AOD/CMakeLists.txt

@@ -19,6 +19,7 @@ target_link_libraries(
           O2::FDDWorkflow
           O2::FV0Workflow
           O2::Framework
+          O2::FrameworkAnalysisSupport
           O2::GlobalTracking
           O2::GlobalTrackingWorkflow
           O2::ITSMFTWorkflow
@@ -75,6 +76,7 @@ o2_add_executable(
         O2::DataFormatsFT0
         O2::Steer
         O2::ZDCBase
+        O2::FrameworkAnalysisSupport
         nlohmann_json::nlohmann_json
         )
 

Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h

@@ -93,6 +93,23 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   int getModule(int index) const;
   int getChip(int index) const;
 
+  void defineMLOTSensors();
+  int getBarrelLayer(int) const;
+
+  // sensor ref X and alpha for ML & OT
+  void extractSensorXAlphaMLOT(int, float&, float&);
+
+  // cache for tracking frames (ML & OT)
+  bool isTrackingFrameCachedMLOT() const { return !mCacheRefXMLOT.empty(); }
+  void fillTrackingFramesCacheMLOT();
+
+  float getSensorRefAlphaMLOT(int index) const { return mCacheRefAlphaMLOT[index]; }
+  float getSensorXMLOT(int index) const { return mCacheRefXMLOT[index]; }
+
+  // create matrix for tracking to local frame for MLOT
+  TGeoHMatrix& createT2LMatrixMLOT(int);
+
+  /// This routine computes the chip index number from the subDetID, petal, disk, layer, stave /// TODO: retrieve also from chip when chips will be available
   /// This routine computes the chip index number from the subDetID, petal, disk, layer, stave, half stave, module, chip
   /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
   /// \param int petalcase The petal case number for VD, from 0 to 3
@@ -200,10 +217,14 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
 
   bool mOwner = true; //! is it owned by the singleton?
 
+  std::vector<int> sensorsMLOT;
+  std::vector<float> mCacheRefXMLOT;     /// cache for X of ML and OT
+  std::vector<float> mCacheRefAlphaMLOT; /// cache for sensor ref alpha ML and OT
+
  private:
   static std::unique_ptr<o2::trk::GeometryTGeo> sInstance;
 };
 
 } // namespace trk
 } // namespace o2
-#endif
+#endif

Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx

@@ -12,6 +12,7 @@
 #include <TRKBase/GeometryTGeo.h>
 #include <TGeoManager.h>
 #include "TRKBase/SegmentationChip.h"
+#include <TMath.h>
 
 #include <limits>
 
@@ -123,6 +124,8 @@ void GeometryTGeo::Build(int loadTrans)
 
   setSize(numberOfChipsTotal);
   fillMatrixCache(loadTrans);
+  defineMLOTSensors();
+  fillTrackingFramesCacheMLOT();
 }
 
 //__________________________________________________________________________
@@ -466,6 +469,32 @@ TGeoHMatrix* GeometryTGeo::extractMatrixSensor(int index) const
   return &matTmp;
 }
 
+//__________________________________________________________________________
+void GeometryTGeo::defineMLOTSensors()
+{
+  for (int i = 0; i < mSize; i++) {
+    if (getSubDetID(i) == 0) {
+      continue;
+    }
+    sensorsMLOT.push_back(i);
+  }
+}
+
+//__________________________________________________________________________
+void GeometryTGeo::fillTrackingFramesCacheMLOT()
+{
+  // fill for every sensor of ML & OT its tracking frame parameters
+  if (!isTrackingFrameCachedMLOT() && !sensorsMLOT.empty()) {
+    size_t newSize = sensorsMLOT.size();
+    mCacheRefXMLOT.resize(newSize);
+    mCacheRefAlphaMLOT.resize(newSize);
+    for (int i = 0; i < newSize; i++) {
+      int sensorId = sensorsMLOT[i];
+      extractSensorXAlphaMLOT(sensorId, mCacheRefXMLOT[i], mCacheRefAlphaMLOT[i]);
+    }
+  }
+}
+
 //__________________________________________________________________________
 void GeometryTGeo::fillMatrixCache(int mask)
 {
@@ -488,6 +517,21 @@ void GeometryTGeo::fillMatrixCache(int mask)
     }
   }
 
+  // build T2L matrices for ML & OT !! VD is yet to be implemented once its geometry will be more refined
+  if ((mask & o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L)) && !getCacheT2L().isFilled()) {
+    LOGP(info, "Loading {} T2L matrices from TGeo for ML & OT", getName());
+    if (sensorsMLOT.size()) {
+      int m_Size = sensorsMLOT.size();
+      auto& cacheT2L = getCacheT2L();
+      cacheT2L.setSize(m_Size);
+      for (int i = 0; i < m_Size; i++) {
+        int sensorID = sensorsMLOT[i];
+        TGeoHMatrix& hm = createT2LMatrixMLOT(sensorID);
+        cacheT2L.setMatrix(Mat3D(hm), i); // here, sensorIDs from 0 to 374, sensorIDs shifted to 36 !
+      }
+    }
+  }
+
   // TODO: build matrices for the cases T2L, T2G and T2GRot when needed
 }
 
@@ -1109,5 +1153,87 @@ void GeometryTGeo::Print(Option_t*) const
   std::cout << "]" << std::endl;
 }
 
+//__________________________________________________________________________
+int GeometryTGeo::getBarrelLayer(int chipID) const
+{
+  // for barrel layers only,
+  // so it would be consistent with number of layers i.e. from 0 to 10,
+  // starting from VD0 to OT10;
+  // skip the disks;
+
+  int subDetID = getSubDetID(chipID);
+  int subLayerID = getLayer(chipID);
+
+  if (subDetID < 0 || subDetID > 1) {
+    LOG(error) << "getBarrelLayer(): Invalid subDetID for barrel: " << subDetID
+               << ". Expected values are 0 or 1.";
+    return -1;
+  }
+
+  if (subLayerID < 0 || subLayerID > 7) {
+    LOG(error) << "getBarrelLayer(): Invalid subLayerID for barrel: " << subDetID
+               << ". Expected values are between 0 and 7.";
+    return -1;
+  }
+
+  const int baseOffsets[] = {0, 3};
+
+  return baseOffsets[subDetID] + subLayerID;
+}
+
+//__________________________________________________________________________
+void GeometryTGeo::extractSensorXAlphaMLOT(int chipID, float& x, float& alp)
+{
+  // works for ML and OT only, a.k.a flat sensors !!!
+  double locA[3] = {-100., 0., 0.}, locB[3] = {100., 0., 0.}, gloA[3], gloB[3];
+  double xp{0}, yp{0};
+
+  if (getSubDetID(chipID) == 0) {
+
+    LOG(error) << "extractSensorXAlphaMLOT(): VD layers are not supported yet! chipID = " << chipID;
+    return;
+
+  } else { // flat sensors, ML and OT
+    const TGeoHMatrix* matL2G = extractMatrixSensor(chipID);
+    matL2G->LocalToMaster(locA, gloA);
+    matL2G->LocalToMaster(locB, gloB);
+    double dx = gloB[0] - gloA[0], dy = gloB[1] - gloA[1];
+    double t = (gloB[0] * dx + gloB[1] * dy) / (dx * dx + dy * dy);
+    xp = gloB[0] - dx * t;
+    yp = gloB[1] - dy * t;
+  }
+
+  alp = std::atan2(yp, xp);
+  x = std::hypot(xp, yp);
+  o2::math_utils::bringTo02Pi(alp);
+
+  /// TODO:
+  // once the VD segmentation is done, VD should be added
+}
+
+//__________________________________________________________________________
+TGeoHMatrix& GeometryTGeo::createT2LMatrixMLOT(int chipID)
+{
+  // works only for ML & OT
+  // for VD is yet to be implemented once we have more refined geometry
+  if (getSubDetID(chipID) == 0) {
+
+    LOG(error) << "createT2LMatrixMLOT(): VD layers are not supported yet! chipID = " << chipID
+               << "returning dummy values! ";
+    static TGeoHMatrix dummy;
+    return dummy;
+
+  } else {
+    static TGeoHMatrix t2l;
+    t2l.Clear();
+    float alpha = getSensorRefAlphaMLOT(chipID);
+    t2l.RotateZ(alpha * TMath::RadToDeg());
+    const TGeoHMatrix* matL2G = extractMatrixSensor(chipID);
+    const TGeoHMatrix& matL2Gi = matL2G->Inverse();
+    t2l.MultiplyLeft(&matL2Gi);
+    return t2l;
+  }
+}
+
 } // namespace trk
 } // namespace o2

Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx

@@ -94,7 +94,7 @@ TGeoVolume* TRKLayer::createMetalStack(std::string type)
   if (type == "cylinder") {
     metalStack = new TGeoTube(mInnerRadius + mSensorThickness, mInnerRadius + mChipThickness, mChipLength / 2); // TO BE CHECKED !!!
   } else if (type == "flat") {
-    metalStack = new TGeoBBox(mChipWidth / 2, mChipThickness - mSensorThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
+    metalStack = new TGeoBBox(mChipWidth / 2, (mChipThickness - mSensorThickness) / 2, mChipLength / 2); // TO BE CHECKED !!!
   } else {
     LOGP(fatal, "Metal stack of type '{}' is not implemented", type);
   }
@@ -198,6 +198,9 @@ TGeoVolume* TRKLayer::createModule(std::string type)
 
       TGeoCombiTrans* transLeft = new TGeoCombiTrans();
       transLeft->SetTranslation(xLeft, 0, zLeft); // TO BE CHECKED !!!
+      TGeoRotation* rot = new TGeoRotation();
+      rot->RotateY(180);
+      transLeft->SetRotation(rot);
       LOGP(info, "Inserting {} in {} ", chipVolLeft->GetName(), moduleVol->GetName());
       moduleVol->AddNode(chipVolLeft, iChip * 2, transLeft);
 
@@ -206,9 +209,6 @@ TGeoVolume* TRKLayer::createModule(std::string type)
 
       TGeoCombiTrans* transRight = new TGeoCombiTrans();
       transRight->SetTranslation(xRight, 0, zRight); // TO BE CHECKED !!!
-      TGeoRotation* rot = new TGeoRotation();
-      rot->RotateY(180);
-      transRight->SetRotation(rot);
       LOGP(info, "Inserting {} in {} ", chipVolRight->GetName(), moduleVol->GetName());
       moduleVol->AddNode(chipVolRight, iChip * 2 + 1, transRight);
     }

EventVisualisation/Base/src/DirectoryLoader.cxx

@@ -29,10 +29,15 @@ using namespace o2::event_visualisation;
 deque<string> DirectoryLoader::load(const std::string& path, const std::string& marker, const std::vector<std::string>& ext)
 {
   deque<string> result;
-  for (const auto& entry : std::filesystem::directory_iterator(path)) {
-    if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
-      result.push_back(entry.path().filename());
+  try {
+    for (const auto& entry : std::filesystem::directory_iterator(path)) {
+      if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
+        result.push_back(entry.path().filename());
+      }
     }
+  } catch (std::filesystem::filesystem_error const& ex) {
+    LOGF(error, "filesystem problem during DirectoryLoader::load: %s", ex.what());
+    return result;
   }
   // comparison with safety if marker not in the filename (-1+1 gives 0)
   std::sort(result.begin(), result.end(),
@@ -56,7 +61,8 @@ bool DirectoryLoader::canCreateNextFile(const std::vector<std::string>& paths, c
         }
       }
     } catch (std::filesystem::filesystem_error const& ex) {
-      LOGF(info, "filesystem problem: %s", ex.what());
+      LOGF(error, "filesystem problem during DirectoryLoader::canCreateNextFile: %s", ex.what());
+      return false;
     }
   }
 
@@ -87,12 +93,17 @@ bool DirectoryLoader::canCreateNextFile(const std::vector<std::string>& paths, c
 deque<string> DirectoryLoader::load(const std::vector<std::string>& paths, const std::string& marker, const std::vector<std::string>& ext)
 {
   deque<string> result;
-  for (const auto& path : paths) {
-    for (const auto& entry : std::filesystem::directory_iterator(path)) {
-      if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
-        result.push_back(entry.path().filename());
+  try {
+    for (const auto& path : paths) {
+      for (const auto& entry : std::filesystem::directory_iterator(path)) {
+        if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
+          result.push_back(entry.path().filename());
+        }
       }
     }
+  } catch (std::filesystem::filesystem_error const& ex) {
+    LOGF(error, "filesystem problem during DirectoryLoader::load: %s", ex.what());
+    return result;
   }
   // comparison with safety if marker not in the filename (-1+1 gives 0)
   std::sort(result.begin(), result.end(),
@@ -135,10 +146,14 @@ std::time_t to_time_t(TP tp)
 int DirectoryLoader::getNumberOfFiles(const std::string& path, std::vector<std::string>& ext)
 {
   int res = 0;
-  for (const auto& entry : std::filesystem::directory_iterator(path)) {
-    if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
-      res++;
+  try {
+    for (const auto& entry : std::filesystem::directory_iterator(path)) {
+      if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
+        res++;
+      }
     }
+  } catch (std::filesystem::filesystem_error const& ex) {
+    LOGF(error, "filesystem problem during DirectoryLoader::getNumberOfFiles: %s", ex.what());
   }
   return res;
 }
@@ -160,8 +175,12 @@ std::string DirectoryLoader::getLatestFile(const std::string& path, std::vector<
 
 void DirectoryLoader::removeOldestFiles(const std::string& path, std::vector<std::string>& ext, const int remaining)
 {
-  while (getNumberOfFiles(path, ext) > remaining) {
-    LOGF(info, "removing oldest file in folder: %s : %s", path, getLatestFile(path, ext));
-    filesystem::remove(path + "/" + getLatestFile(path, ext));
+  try {
+    while (getNumberOfFiles(path, ext) > remaining) {
+      LOGF(info, "removing oldest file in folder: %s : %s", path, getLatestFile(path, ext));
+      filesystem::remove(path + "/" + getLatestFile(path, ext));
+    }
+  } catch (std::filesystem::filesystem_error const& ex) {
+    LOGF(error, "filesystem problem during DirectoryLoader::removeOldestFiles: %s", ex.what());
   }
 }

EventVisualisation/DataConverter/src/VisualisationEventROOTSerializer.cxx

@@ -97,6 +97,10 @@ void VisualisationEventROOTSerializer::toFile(const VisualisationEvent& event, L
 {
   std::string fileName = location.fileName();
   TFile f(fileName.c_str(), "recreate");
+  if (f.IsZombie()) {
+    LOGF(error, "Could not create output file %s", fileName.c_str());
+    return;
+  }
 
   saveInt("runNumber", event.mRunNumber);
   saveInt("runType", event.mRunType);