Merge branch 'dev' into pvec

Author: vkucera

Common/SimConfig/include/SimConfig/SimConfig.h

@@ -180,7 +180,7 @@ class SimConfig
   SimConfigData mConfigData; //!
 
   // adjust/overwrite some option settings when collision context is used
-  void adjustFromCollContext();
+  void adjustFromCollContext(std::string const& collcontextfile, std::string const& prefix);
 
   ClassDefNV(SimConfig, 1);
 };

Common/SimConfig/src/SimConfig.cxx

@@ -256,7 +256,17 @@ bool SimConfig::resetFromParsedMap(boost::program_options::variables_map const&
     mConfigData.mFilterNoHitEvents = true;
   }
   mConfigData.mFromCollisionContext = vm["fromCollContext"].as<std::string>();
-  adjustFromCollContext();
+  // we decompose the argument to fetch
+  // (a) collision contextfilename
+  // (b) sim prefix to use from the context
+  auto pos = mConfigData.mFromCollisionContext.find(':');
+  std::string collcontextfile{mConfigData.mFromCollisionContext};
+  std::string simprefix{mConfigData.mOutputPrefix};
+  if (pos != std::string::npos) {
+    collcontextfile = mConfigData.mFromCollisionContext.substr(0, pos);
+    simprefix = mConfigData.mFromCollisionContext.substr(pos + 1);
+  }
+  adjustFromCollContext(collcontextfile, simprefix);
 
   // analyse vertex options
   if (!parseVertexModeString(vm["vertexMode"].as<std::string>(), mConfigData.mVertexMode)) {
@@ -323,28 +333,28 @@ bool SimConfig::parseFieldString(std::string const& fieldstring, int& fieldvalue
   return true;
 }
 
-void SimConfig::adjustFromCollContext()
+void SimConfig::adjustFromCollContext(std::string const& collcontextfile, std::string const& prefix)
 {
   // When we use pregenerated collision contexts, some options
   // need to be auto-adjusted. Do so and inform about this in the logs.
-  if (mConfigData.mFromCollisionContext == "") {
+  if (collcontextfile == "") {
     return;
   }
 
-  auto context = o2::steer::DigitizationContext::loadFromFile(mConfigData.mFromCollisionContext);
+  auto context = o2::steer::DigitizationContext::loadFromFile(collcontextfile);
   if (context) {
     //  find the events belonging to a source that corresponds to a sim prefix
-    LOG(info) << "Looking up simprefixes " << mConfigData.mOutputPrefix;
-    int sourceid = context->findSimPrefix(mConfigData.mOutputPrefix);
+    LOG(info) << "Looking up simprefixes " << prefix;
+    int sourceid = context->findSimPrefix(prefix);
     if (sourceid == -1) {
-      LOG(error) << "Could not find collisions with sim prefix " << mConfigData.mOutputPrefix << " in the collision context. The collision contet specifies the following prefixes:";
-      for (auto& prefix : context->getSimPrefixes()) {
-        LOG(info) << prefix;
+      LOG(error) << "Could not find collisions with sim prefix " << prefix << " in the collision context. The collision context specifies the following prefixes:";
+      for (auto& sp : context->getSimPrefixes()) {
+        LOG(info) << sp;
       }
       LOG(fatal) << "Aborting due to prefix error";
     } else {
       auto collisionmap = context->getCollisionIndicesForSource(sourceid);
-      LOG(info) << "Found " << collisionmap.size() << " events in the collisioncontext for prefix " << mConfigData.mOutputPrefix;
+      LOG(info) << "Found " << collisionmap.size() << " events in the collisioncontext for prefix " << prefix;
 
       // check if collisionmap is dense (otherwise it will get screwed up with order/indexing in ROOT output)
       bool good = true;
@@ -368,7 +378,7 @@ void SimConfig::adjustFromCollContext()
       LOG(info) << "Setting number of events to simulate to " << mConfigData.mNEvents;
     }
   } else {
-    LOG(fatal) << "Could not open collision context file " << mConfigData.mFromCollisionContext;
+    LOG(fatal) << "Could not open collision context file " << collcontextfile;
   }
 }
 

Common/Utils/include/CommonUtils/RootSerializableKeyValueStore.h

@@ -144,13 +144,11 @@ class RootSerializableKeyValueStore
   /// print list of keys, values (and optionally type information)
   void print(bool includetypeinfo = false) const;
 
+  /// resets store to the store of another object
   void copyFrom(RootSerializableKeyValueStore const& other)
   {
-    for (auto& p : other.mStore) {
-      if (mStore.find(p.first) == mStore.end()) {
-        mStore.insert(std::pair<std::string, SerializedInfo>(p.first, SerializedInfo(p.second)));
-      }
-    }
+    mStore.clear();
+    mStore = other.mStore;
   }
 
  private:

DataFormats/Detectors/GlobalTracking/include/DataFormatsGlobalTracking/RecoContainer.h

@@ -340,6 +340,7 @@ struct RecoContainer {
   o2::ctp::LumiInfo mCTPLumi;
 
   gsl::span<const unsigned char> clusterShMapTPC; ///< externally set TPC clusters sharing map
+  gsl::span<const unsigned int> occupancyMapTPC;  ///< externally set TPC clusters occupancy map
 
   std::unique_ptr<o2::tpc::internal::getWorkflowTPCInput_ret> inputsTPCclusters; // special struct for TPC clusters access
   std::unique_ptr<o2::trd::RecoInputContainer> inputsTRD;                        // special struct for TRD tracklets, trigger records
@@ -371,7 +372,7 @@ struct RecoContainer {
 
   void addITSClusters(o2::framework::ProcessingContext& pc, bool mc);
   void addMFTClusters(o2::framework::ProcessingContext& pc, bool mc);
-  void addTPCClusters(o2::framework::ProcessingContext& pc, bool mc, bool shmap);
+  void addTPCClusters(o2::framework::ProcessingContext& pc, bool mc, bool shmap, bool occmap);
   void addTPCTriggers(o2::framework::ProcessingContext& pc);
   void addTOFClusters(o2::framework::ProcessingContext& pc, bool mc);
   void addHMPClusters(o2::framework::ProcessingContext& pc, bool mc);

DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx

@@ -119,6 +119,7 @@ void DataRequest::requestTPCTracks(bool mc)
   addInput({"trackTPCClRefs", "TPC", "CLUSREFS", 0, Lifetime::Timeframe});
   if (requestMap.find("clusTPC") != requestMap.end()) {
     addInput({"clusTPCshmap", "TPC", "CLSHAREDMAP", 0, Lifetime::Timeframe});
+    addInput({"clusTPCoccmap", "TPC", "TPCOCCUPANCYMAP", 0, Lifetime::Timeframe});
   }
   if (mc) {
     addInput({"trackTPCMCTR", "TPC", "TRACKSMCLBL", 0, Lifetime::Timeframe});
@@ -255,6 +256,7 @@ void DataRequest::requestTPCClusters(bool mc)
   }
   if (requestMap.find("trackTPC") != requestMap.end()) {
     addInput({"clusTPCshmap", "TPC", "CLSHAREDMAP", 0, Lifetime::Timeframe});
+    addInput({"clusTPCoccmap", "TPC", "TPCOCCUPANCYMAP", 0, Lifetime::Timeframe});
   }
   if (mc) {
     addInput({"clusTPCMC", ConcreteDataTypeMatcher{"TPC", "CLNATIVEMCLBL"}, Lifetime::Timeframe});
@@ -678,7 +680,8 @@ void RecoContainer::collectData(ProcessingContext& pc, const DataRequest& reques
 
   req = reqMap.find("clusTPC");
   if (req != reqMap.end()) {
-    addTPCClusters(pc, req->second, reqMap.find("trackTPC") != reqMap.end());
+    auto tracksON = reqMap.find("trackTPC") != reqMap.end();
+    addTPCClusters(pc, req->second, tracksON, tracksON);
   }
 
   req = reqMap.find("trigTPC");
@@ -1060,12 +1063,15 @@ void RecoContainer::addMFTClusters(ProcessingContext& pc, bool mc)
 }
 
 //__________________________________________________________
-void RecoContainer::addTPCClusters(ProcessingContext& pc, bool mc, bool shmap)
+void RecoContainer::addTPCClusters(ProcessingContext& pc, bool mc, bool shmap, bool occmap)
 {
   inputsTPCclusters = o2::tpc::getWorkflowTPCInput(pc, 0, mc);
   if (shmap) {
     clusterShMapTPC = pc.inputs().get<gsl::span<unsigned char>>("clusTPCshmap");
   }
+  if (occmap) {
+    occupancyMapTPC = pc.inputs().get<gsl::span<unsigned int>>("clusTPCoccmap");
+  }
 }
 
 //__________________________________________________________

DataFormats/simulation/include/SimulationDataFormat/MCEventHeader.h

@@ -142,6 +142,8 @@ class MCEventHeader : public FairMCEventHeader
     return ref;
   };
 
+  void print() const;
+
   /// prints a summary of info keys/types attached to this header
   void printInfo() const
   {

DataFormats/simulation/src/MCEventHeader.cxx

@@ -15,6 +15,7 @@
 #include "FairRootManager.h"
 #include <TFile.h>
 #include <TTree.h>
+#include <iostream>
 
 namespace o2
 {
@@ -61,6 +62,21 @@ void MCEventHeader::extractFileFromKinematics(std::string_view kinefilename, std
   }
 }
 
+void MCEventHeader::print() const
+{
+  // print some used parts from FairMCEventHeader
+  std::cout << "RunID " << fRunId << "\n";
+  std::cout << "EventID " << fEventId << "\n";
+  std::cout << "Vertex-X " << fX << "\n";
+  std::cout << "Vertex-Y " << fY << "\n";
+  std::cout << "Vertex-Z " << fZ << "\n";
+  std::cout << "Vertex-T " << fT << "\n";
+  std::cout << "Impact-B " << fB << "\n";
+  std::cout << "NPrim " << fNPrim << "\n";
+  // print meta-fields
+  printInfo();
+}
+
 /** alternative implementations below
 
 void MCEventHeader::extractFileFromKinematics(std::string_view kinefilename, std::string_view targetfilename) {

Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx

@@ -38,6 +38,7 @@
 #include "TPCCalibration/VDriftHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "GPUO2Interface.h"
+#include "GPUO2InterfaceUtils.h"
 #include "GPUParam.h"
 #include "Headers/DataHeader.h"
 #include "Framework/ConfigParamRegistry.h"

Detectors/Base/include/DetectorsBase/Detector.h

@@ -29,7 +29,6 @@
 #include <typeinfo>
 #include <type_traits>
 #include <string>
-#include <TMessage.h>
 #include "CommonUtils/ShmManager.h"
 #include "CommonUtils/ShmAllocator.h"
 #include <sys/shm.h>
@@ -42,9 +41,7 @@
 
 #include <fairmq/FwdDecls.h>
 
-namespace o2
-{
-namespace base
+namespace o2::base
 {
 
 /// This is the basic class for any AliceO2 detector module, whether it is
@@ -260,17 +257,12 @@ T decodeShmMessage(fair::mq::Parts& dataparts, int index, bool*& busy)
 }
 
 // this goes into the source
-void attachMessageBufferToParts(fair::mq::Parts& parts, fair::mq::Channel& channel,
-                                void* data, size_t size, void (*func_ptr)(void* data, void* hint), void* hint);
+void attachMessageBufferToParts(fair::mq::Parts& parts, fair::mq::Channel& channel, void* data, TClass* cl);
 
 template <typename Container>
 void attachTMessage(Container const& hits, fair::mq::Channel& channel, fair::mq::Parts& parts)
 {
-  TMessage* tmsg = new TMessage();
-  tmsg->WriteObjectAny((void*)&hits, TClass::GetClass(typeid(hits)));
-  attachMessageBufferToParts(
-    parts, channel, tmsg->Buffer(), tmsg->BufferSize(),
-    [](void* data, void* hint) { delete static_cast<TMessage*>(hint); }, tmsg);
+  attachMessageBufferToParts(parts, channel, (void*)&hits, TClass::GetClass(typeid(hits)));
 }
 
 void* decodeTMessageCore(fair::mq::Parts& dataparts, int index);
@@ -746,7 +738,6 @@ class DetImpl : public o2::base::Detector
 
   ClassDefOverride(DetImpl, 0);
 };
-} // namespace base
-} // namespace o2
+} // namespace o2::base
 
 #endif

Detectors/Base/src/Detector.cxx

@@ -17,6 +17,7 @@
 #include "DetectorsBase/MaterialManager.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "Field/MagneticField.h"
+#include "Framework/TMessageSerializer.h"
 #include "TString.h" // for TString
 #include "TGeoManager.h"
 
@@ -196,16 +197,19 @@ int Detector::registerSensitiveVolumeAndGetVolID(std::string const& name)
 #include <fairmq/Message.h>
 #include <fairmq/Parts.h>
 #include <fairmq/Channel.h>
-namespace o2
-{
-namespace base
+namespace o2::base
 {
 // this goes into the source
-void attachMessageBufferToParts(fair::mq::Parts& parts, fair::mq::Channel& channel, void* data, size_t size,
-                                void (*free_func)(void* data, void* hint), void* hint)
+void attachMessageBufferToParts(fair::mq::Parts& parts, fair::mq::Channel& channel, void* data, TClass* cl)
 {
-  std::unique_ptr<fair::mq::Message> message(channel.NewMessage(data, size, free_func, hint));
-  parts.AddPart(std::move(message));
+  auto msg = channel.Transport()->CreateMessage(4096, fair::mq::Alignment{64});
+  // This will serialize the data directly into the message buffer, without any further
+  // buffer or copying. Notice how the message will have 8 bytes of header and then
+  // the serialized data as TBufferFile. In principle one could construct a serialized TMessage payload
+  // however I did not manage to get it to work for every case.
+  o2::framework::FairOutputTBuffer buffer(*msg);
+  o2::framework::TMessageSerializer::serialize(buffer, data, cl);
+  parts.AddPart(std::move(msg));
 }
 void attachDetIDHeaderMessage(int id, fair::mq::Channel& channel, fair::mq::Parts& parts)
 {
@@ -246,17 +250,14 @@ void* decodeShmCore(fair::mq::Parts& dataparts, int index, bool*& busy)
 
 void* decodeTMessageCore(fair::mq::Parts& dataparts, int index)
 {
-  class TMessageWrapper : public TMessage
-  {
-   public:
-    TMessageWrapper(void* buf, Int_t len) : TMessage(buf, len) { ResetBit(kIsOwner); }
-    ~TMessageWrapper() override = default;
-  };
   auto rawmessage = std::move(dataparts.At(index));
-  auto message = std::make_unique<TMessageWrapper>(rawmessage->GetData(), rawmessage->GetSize());
-  return message.get()->ReadObjectAny(message.get()->GetClass());
+  o2::framework::FairInputTBuffer buffer((char*)rawmessage->GetData(), rawmessage->GetSize());
+  buffer.InitMap();
+  auto* cl = buffer.ReadClass();
+  buffer.SetBufferOffset(0);
+  buffer.ResetMap();
+  return buffer.ReadObjectAny(cl);
 }
 
-} // namespace base
-} // namespace o2
+} // namespace o2::base
 ClassImp(o2::base::Detector);