o2-eve: fixes (event creation time, GID from old root files)

jmyrcha · shahor02 · commit 300fa70293d6 · 2024-08-02T21:43:13.000+02:00
diff --git a/EventVisualisation/Base/include/EventVisualisationBase/ConfigurationManager.h b/EventVisualisation/Base/include/EventVisualisationBase/ConfigurationManager.h
@@ -25,7 +25,7 @@ namespace o2
 namespace event_visualisation
 {
 /// Version of the software
-const static int o2_eve_version = 171;
+const static int o2_eve_version = 172;
 
 /// Configuration Manager allows an easy access to the config file.
 ///
diff --git a/EventVisualisation/Base/include/EventVisualisationBase/DirectoryLoader.h b/EventVisualisation/Base/include/EventVisualisationBase/DirectoryLoader.h
@@ -28,16 +28,16 @@ namespace event_visualisation
 class DirectoryLoader
 {
  private:
-  static int getNumberOfFiles(std::string& path, std::vector<std::string>& ext);
-  static std::string getLatestFile(std::string& path, std::vector<std::string>& ext);
+  static int getNumberOfFiles(const std::string& path, std::vector<std::string>& ext);
+  static std::string getLatestFile(const std::string& path, std::vector<std::string>& ext);
 
  public:
   static std::deque<std::string> load(const std::string& path, const std::string& marker, const std::vector<std::string>& ext);
   static std::deque<std::string> load(const std::vector<std::string>& paths, const std::string& marker, const std::vector<std::string>& ext);
   static std::vector<std::string> allFolders(const std::string& location);
   static bool canCreateNextFile(const std::vector<std::string>& paths, const std::string& marker, const std::vector<std::string>& ext, long long millisec, long capacityAllowed);
   static void reduceNumberOfFiles(const std::string& path, const std::deque<std::string>& files, std::size_t filesInFolder);
-  static void removeOldestFiles(std::string& path, std::vector<std::string>& ext, int remaining);
+  static void removeOldestFiles(const std::string& path, std::vector<std::string>& ext, int remaining);
 };
 
 } // namespace event_visualisation
diff --git a/EventVisualisation/Base/src/DataSource.cxx b/EventVisualisation/Base/src/DataSource.cxx
@@ -24,7 +24,7 @@ namespace o2::event_visualisation
 std::string DataSource::getCreationTimeAsString() const
 {
   char buffer[90];
-  time_t time = this->mCreationTime;
+  time_t time = this->mCreationTime / 1000;
   const char* format = "%a %b %-d %H:%M:%S %Y";
   struct tm* timeinfo = localtime(&time);
   strftime(buffer, sizeof(buffer), format, timeinfo);
diff --git a/EventVisualisation/Base/src/DirectoryLoader.cxx b/EventVisualisation/Base/src/DirectoryLoader.cxx
@@ -36,7 +36,7 @@ deque<string> DirectoryLoader::load(const std::string& path, const std::string&
   }
   // comparison with safety if marker not in the filename (-1+1 gives 0)
   std::sort(result.begin(), result.end(),
-            [marker](std::string a, std::string b) {
+            [marker](const std::string& a, const std::string& b) {
               return a.substr(a.find_first_of(marker) + 1) < b.substr(b.find_first_of(marker) + 1);
             });
 
@@ -118,7 +118,7 @@ void DirectoryLoader::reduceNumberOfFiles(const std::string& path, const std::de
   if (filesInFolder == -1) {
     return; // do not reduce
   }
-  int items = files.size() - std::min(files.size(), filesInFolder);
+  const auto items = files.size() - std::min(files.size(), filesInFolder);
   for (int i = 0; i < items; i++) {
     std::remove((path + "/" + files[i]).c_str()); // delete file
   }
@@ -132,7 +132,7 @@ std::time_t to_time_t(TP tp)
   return system_clock::to_time_t(sctp);
 }
 
-int DirectoryLoader::getNumberOfFiles(std::string& path, std::vector<std::string>& ext)
+int DirectoryLoader::getNumberOfFiles(const std::string& path, std::vector<std::string>& ext)
 {
   int res = 0;
   for (const auto& entry : std::filesystem::directory_iterator(path)) {
@@ -142,24 +142,23 @@ int DirectoryLoader::getNumberOfFiles(std::string& path, std::vector<std::string
   }
   return res;
 }
-std::string DirectoryLoader::getLatestFile(std::string& path, std::vector<std::string>& ext)
+std::string DirectoryLoader::getLatestFile(const std::string& path, std::vector<std::string>& ext)
 {
   std::string oldest_file_name = "";
   std::time_t oldest_file_time = LONG_MAX;
   for (const auto& entry : std::filesystem::directory_iterator(path)) {
     if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
-      auto file_time = entry.last_write_time();
-      std::time_t tt = to_time_t(file_time);
-      if (tt < oldest_file_time) {
+      const auto file_time = entry.last_write_time();
+      if (const std::time_t tt = to_time_t(file_time); tt < oldest_file_time) {
         oldest_file_time = tt;
-        oldest_file_name = entry.path().filename();
+        oldest_file_name = entry.path().filename().string();
       }
     }
   }
   return oldest_file_name;
 }
 
-void DirectoryLoader::removeOldestFiles(std::string& path, std::vector<std::string>& ext, const int remaining)
+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));
diff --git a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventOpenGLSerializer.h b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventOpenGLSerializer.h
@@ -33,7 +33,7 @@ class VisualisationEventOpenGLSerializer : public VisualisationEventSerializer
   static float* asFloat(void* chunk) { return (float*)((char*)chunk + 8); }
   static unsigned char* asByte(void* chunk) { return (unsigned char*)((char*)chunk + 8); }
   static signed char* asSignedByte(void* chunk) { return (signed char*)((char*)chunk + 8); }
-  unsigned chunkSize(void* chunk);
+  static unsigned chunkSize(void* chunk);
 
  public:
   const std::string serializerName() const override { return std::string("VisualisationEventOpenGLSerializer"); }
diff --git a/EventVisualisation/DataConverter/src/VisualisationEventOpenGLSerializer.cxx b/EventVisualisation/DataConverter/src/VisualisationEventOpenGLSerializer.cxx
@@ -21,15 +21,13 @@
 #include <fstream>
 #include <filesystem>
 
-namespace o2
-{
-namespace event_visualisation
+namespace o2::event_visualisation
 {
 
 enum Header : uint8_t {
   version,
   runNumber,
-  creationTime,
+  creationTimeUnused,
   firstTForbit,
   runType,
   trkMask,
@@ -40,6 +38,8 @@ enum Header : uint8_t {
   emcCount,
   primaryVertex,
   tfCounter,
+  creationTimeLow,
+  creationTimeHigh,
   last // number of fields
 };
 
@@ -89,7 +89,7 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
     "TPC-TOF", "TPC-TRD", "MFT-MCH", "ITS-TPC-TRD", "ITS-TPC-TOF", "TPC-TRD-TOF", "MFT-MCH-MID", "ITS-TPC-TRD-TOF", "ITS-AB", "CTP",
     "MCH-MID"};
   std::ostringstream buf;
-  const auto SIGSIZE = 512;
+  constexpr auto SIGSIZE = 512;
   unsigned char data[SIGSIZE];
   std::ofstream out(fileName, std::ios::out | std::ios::binary);
   // head --bytes 512 fileName.eve
@@ -126,7 +126,10 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
     const auto head = asUnsigned(chunkHEAD);
     head[Header::version] = event.mEveVersion;
     head[Header::runNumber] = event.getRunNumber();
-    head[Header::creationTime] = event.getCreationTime();
+    unsigned long creationTime = event.getCreationTime();
+    head[Header::creationTimeLow] = creationTime;
+    head[Header::creationTimeHigh] = creationTime / (1L << 32);
+    ;
     head[Header::firstTForbit] = event.getFirstTForbit();
     head[Header::runType] = event.getRunType();
     head[Header::trkMask] = event.getTrkMask();
@@ -137,7 +140,7 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
     head[Header::emcCount] = emcCount;
     head[Header::primaryVertex] = event.getPrimaryVertex();
     head[Header::tfCounter] = event.getTfCounter();
-    out.write((char*)chunkHEAD, chunkSize(chunkHEAD)); // <----1 HEAD
+    out.write(static_cast<char*>(chunkHEAD), chunkSize(chunkHEAD)); // <----1 HEAD
     free(chunkHEAD);
   }
 
@@ -168,15 +171,15 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
       celm[index] = track.getClusterCount();
       index++;
     }
-    out.write((char*)chunkTTYP, chunkSize(chunkTTYP)); // <----2 TTYP
+    out.write(static_cast<char*>(chunkTTYP), chunkSize(chunkTTYP)); // <----2 TTYP
     free(chunkTTYP);
-    out.write((char*)chunkTELM, chunkSize(chunkTELM)); // <----3 TELM
+    out.write(static_cast<char*>(chunkTELM), chunkSize(chunkTELM)); // <----3 TELM
     free(chunkTELM);
-    out.write((char*)chunkCELM, chunkSize(chunkCELM)); // <----3 CELM
+    out.write(static_cast<char*>(chunkCELM), chunkSize(chunkCELM)); // <----3 CELM
     free(chunkCELM);
-    out.write((char*)chunkTGID, chunkSize(chunkTGID)); // <----3 GIND
+    out.write(static_cast<char*>(chunkTGID), chunkSize(chunkTGID)); // <----3 GIND
     free(chunkTGID);
-    out.write((char*)chunkTPID, chunkSize(chunkTPID)); // <----3 TPID (tracks pid)
+    out.write(static_cast<char*>(chunkTPID), chunkSize(chunkTPID)); // <----3 TPID (tracks pid)
     free(chunkTPID);
   }
 
@@ -206,7 +209,7 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
 
     for (const auto& track : event.getTracksSpan()) {
       time[tno] = track.getTime();
-      crge[tno] = track.getCharge();
+      crge[tno] = static_cast<signed char>(track.getCharge());
       tno++;
       sxyz[sxyzidx++] = track.getStartCoordinates()[0];
       sxyz[sxyzidx++] = track.getStartCoordinates()[1];
@@ -227,17 +230,17 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
         cxyz[cidx++] = track.getClustersSpan()[i].Z();
       }
     }
-    out.write((char*)chunkTXYZ, chunkSize(chunkTXYZ)); // <----4 TXYZ
+    out.write(static_cast<char*>(chunkTXYZ), chunkSize(chunkTXYZ)); // <----4 TXYZ
     free(chunkTXYZ);
-    out.write((char*)chunkCXYZ, chunkSize(chunkCXYZ)); // <----4 CXYZ
+    out.write(static_cast<char*>(chunkCXYZ), chunkSize(chunkCXYZ)); // <----4 CXYZ
     free(chunkCXYZ);
-    out.write((char*)chunkTIME, chunkSize(chunkTIME)); // <----4 TIME
+    out.write(static_cast<char*>(chunkTIME), chunkSize(chunkTIME)); // <----4 TIME
     free(chunkTIME);
-    out.write((char*)chunkSXYZ, chunkSize(chunkSXYZ)); // <----4 SXYZ
+    out.write(static_cast<char*>(chunkSXYZ), chunkSize(chunkSXYZ)); // <----4 SXYZ
     free(chunkSXYZ);
-    out.write((char*)chunkCRGE, chunkSize(chunkCRGE)); // <----4 CRGE
+    out.write(static_cast<char*>(chunkCRGE), chunkSize(chunkCRGE)); // <----4 CRGE
     free(chunkCRGE);
-    out.write((char*)chunkATPE, chunkSize(chunkATPE)); // <----4 CRGE
+    out.write(static_cast<char*>(chunkATPE), chunkSize(chunkATPE)); // <----4 CRGE
     free(chunkATPE);
   }
 
@@ -257,11 +260,11 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
       uxyz[idx++] = c.Y();
       uxyz[idx++] = c.Z();
     }
-    out.write((char*)chunkUGID, chunkSize(chunkUGID)); //
+    out.write(static_cast<char*>(chunkUGID), chunkSize(chunkUGID)); //
     free(chunkUGID);
-    out.write((char*)chunkUTIM, chunkSize(chunkUTIM)); //
+    out.write(static_cast<char*>(chunkUTIM), chunkSize(chunkUTIM)); //
     free(chunkUTIM);
-    out.write((char*)chunkUXYZ, chunkSize(chunkUXYZ)); //
+    out.write(static_cast<char*>(chunkUXYZ), chunkSize(chunkUXYZ)); //
     free(chunkUXYZ);
   }
 
@@ -309,33 +312,48 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
 
   {
     const auto chunkFINE = createChunk(FINE, 0);
-    out.write((char*)chunkFINE, chunkSize(chunkFINE)); // <----5 FINE
+    out.write(static_cast<char*>(chunkFINE), chunkSize(chunkFINE)); // <----5 FINE
     free(chunkFINE);
   }
   out.close();
 }
 
 void* VisualisationEventOpenGLSerializer::createChunk(const char* lbl, unsigned size)
 {
-  auto result = (unsigned char*)calloc(4 * ((size + 3) / 4) + 8, 1);
+  const auto result = static_cast<unsigned char*>(calloc(4 * ((size + 3) / 4) + 8, 1));
   result[0] = lbl[0];
   result[1] = lbl[1];
   result[2] = lbl[2];
   result[3] = lbl[3];
-  auto uResult = (unsigned*)&result[4];
+  const auto uResult = (unsigned*)&result[4];
   *uResult = 4 * ((size + 3) / 4);
   return result;
 }
 
 unsigned VisualisationEventOpenGLSerializer::chunkSize(void* chunk)
 {
-  auto uResult = (unsigned*)((char*)chunk + 4);
+  const auto uResult = (unsigned*)((char*)chunk + 4);
   return *uResult + 8;
 }
 
-bool VisualisationEventOpenGLSerializer::fromFile(VisualisationEvent& event, std::string fileName)
+long timestamp_from_filename(const std::string& s)
 {
+  const auto pos1 = s.find("tracks_");
+  if (pos1 == std::string::npos) {
+    return 0;
+  }
+  const auto pos2 = s.find('_', pos1 + 7);
+  if (pos2 == std::string::npos) {
+    return 0;
+  }
+  std::string::size_type sz; // alias of size_t
+  const auto str_dec = s.substr(pos1 + 7, pos2 - pos1 - 7);
+  const long li_dec = std::strtol(str_dec.c_str(), nullptr, 10);
+  return li_dec;
+}
 
+bool VisualisationEventOpenGLSerializer::fromFile(VisualisationEvent& event, std::string fileName)
+{
   std::filesystem::path inputFilePath{fileName};
   auto length = (long)std::filesystem::file_size(inputFilePath);
   if (length == 0) {
@@ -389,7 +407,8 @@ bool VisualisationEventOpenGLSerializer::fromFile(VisualisationEvent& event, std
       auto head = words;
       event.mEveVersion = head[Header::version];
       event.setRunNumber(head[Header::runNumber]);
-      event.setCreationTime(head[Header::creationTime]);
+      // event.setCreationTime(head[Header::creationTimeLow]+head[Header::creationTimeHigh]*(1L<<32));
+      event.setCreationTime(timestamp_from_filename(fileName));
       event.setFirstTForbit(head[Header::firstTForbit]);
       event.setRunType((parameters::GRPECS::RunType)head[Header::runType]);
       event.setTrkMask((int)head[Header::trkMask]);
@@ -513,5 +532,4 @@ bool VisualisationEventOpenGLSerializer::fromFile(VisualisationEvent& event, std
   return false;
 }
 
-} // namespace event_visualisation
-} // namespace o2
+} // namespace o2::event_visualisation
diff --git a/EventVisualisation/DataConverter/src/VisualisationEventSerializer.cxx b/EventVisualisation/DataConverter/src/VisualisationEventSerializer.cxx
@@ -87,10 +87,17 @@ o2::dataformats::GlobalTrackID VisualisationEventSerializer::gidFromString(const
     {"ITSAB", 24},           // ITS AfterBurner tracklets
     {"CTP", 25}};
   const auto first = gid.find('/');
-  const auto second = gid.find('/', first + 1);
-  auto source = sources[gid.substr(1, first - 1)];
-  auto index = std::stoi(gid.substr(first + 1, second - 1));
-  auto flags = std::stoi(gid.substr(second + 1, gid.size() - 1));
+  int source = 0;
+  int index = 0;
+  int flags = 0;
+  if (first == -1) {
+    source = sources[gid];
+  } else {
+    const auto second = gid.find('/', first + 1);
+    source = sources[gid.substr(1, first - 1)];
+    index = std::stoi(gid.substr(first + 1, second - 1));
+    flags = std::stoi(gid.substr(second + 1, gid.size() - 1));
+  }
   return index + source * (1 << 25) + flags * (1 << 30);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ namespace o2`
`25`	`25`	`namespace event_visualisation`
`26`	`26`	`{`
`27`	`27`	`/// Version of the software`
`28`		`-const static int o2_eve_version = 171;`
	`28`	`+const static int o2_eve_version = 172;`
`29`	`29`
`30`	`30`	`/// Configuration Manager allows an easy access to the config file.`
`31`	`31`	`///`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ namespace o2::event_visualisation`
`24`	`24`	`std::string DataSource::getCreationTimeAsString() const`
`25`	`25`	`{`
`26`	`26`	`char buffer[90];`
`27`		`- time_t time = this->mCreationTime;`
	`27`	`+ time_t time = this->mCreationTime / 1000;`
`28`	`28`	`const char* format = "%a %b %-d %H:%M:%S %Y";`
`29`	`29`	`struct tm* timeinfo = localtime(&time);`
`30`	`30`	`strftime(buffer, sizeof(buffer), format, timeinfo);`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ deque<string> DirectoryLoader::load(const std::string& path, const std::string&`
`36`	`36`	`}`
`37`	`37`	`// comparison with safety if marker not in the filename (-1+1 gives 0)`
`38`	`38`	`std::sort(result.begin(), result.end(),`
`39`		`- [marker](std::string a, std::string b) {`
	`39`	`+ [marker](const std::string& a, const std::string& b) {`
`40`	`40`	`return a.substr(a.find_first_of(marker) + 1) < b.substr(b.find_first_of(marker) + 1);`
`41`	`41`	`});`
`42`	`42`
`@@ -118,7 +118,7 @@ void DirectoryLoader::reduceNumberOfFiles(const std::string& path, const std::de`
`118`	`118`	`if (filesInFolder == -1) {`
`119`	`119`	`return; // do not reduce`
`120`	`120`	`}`
`121`		`- int items = files.size() - std::min(files.size(), filesInFolder);`
	`121`	`+ const auto items = files.size() - std::min(files.size(), filesInFolder);`
`122`	`122`	`for (int i = 0; i < items; i++) {`
`123`	`123`	`std::remove((path + "/" + files[i]).c_str()); // delete file`
`124`	`124`	`}`
`@@ -132,7 +132,7 @@ std::time_t to_time_t(TP tp)`
`132`	`132`	`return system_clock::to_time_t(sctp);`
`133`	`133`	`}`
`134`	`134`
`135`		`-int DirectoryLoader::getNumberOfFiles(std::string& path, std::vector<std::string>& ext)`
	`135`	`+int DirectoryLoader::getNumberOfFiles(const std::string& path, std::vector<std::string>& ext)`
`136`	`136`	`{`
`137`	`137`	`int res = 0;`
`138`	`138`	`for (const auto& entry : std::filesystem::directory_iterator(path)) {`
`@@ -142,24 +142,23 @@ int DirectoryLoader::getNumberOfFiles(std::string& path, std::vector<std::string`
`142`	`142`	`}`
`143`	`143`	`return res;`
`144`	`144`	`}`
`145`		`-std::string DirectoryLoader::getLatestFile(std::string& path, std::vector<std::string>& ext)`
	`145`	`+std::string DirectoryLoader::getLatestFile(const std::string& path, std::vector<std::string>& ext)`
`146`	`146`	`{`
`147`	`147`	`std::string oldest_file_name = "";`
`148`	`148`	`std::time_t oldest_file_time = LONG_MAX;`
`149`	`149`	`for (const auto& entry : std::filesystem::directory_iterator(path)) {`
`150`	`150`	`if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {`
`151`		`- auto file_time = entry.last_write_time();`
`152`		`- std::time_t tt = to_time_t(file_time);`
`153`		`- if (tt < oldest_file_time) {`
	`151`	`+ const auto file_time = entry.last_write_time();`
	`152`	`+ if (const std::time_t tt = to_time_t(file_time); tt < oldest_file_time) {`
`154`	`153`	`oldest_file_time = tt;`
`155`		`- oldest_file_name = entry.path().filename();`
	`154`	`+ oldest_file_name = entry.path().filename().string();`
`156`	`155`	`}`
`157`	`156`	`}`
`158`	`157`	`}`
`159`	`158`	`return oldest_file_name;`
`160`	`159`	`}`
`161`	`160`
`162`		`-void DirectoryLoader::removeOldestFiles(std::string& path, std::vector<std::string>& ext, const int remaining)`
	`161`	`+void DirectoryLoader::removeOldestFiles(const std::string& path, std::vector<std::string>& ext, const int remaining)`
`163`	`162`	`{`
`164`	`163`	`while (getNumberOfFiles(path, ext) > remaining) {`
`165`	`164`	`LOGF(info, "removing oldest file in folder: %s : %s", path, getLatestFile(path, ext));`