Fix NanoAODRNTupleOutputModule

PhysicsTools/NanoAOD/plugins/BuildFile.xml

@@ -38,9 +38,7 @@
   <use name="roottmva"/>
   <flags EDM_PLUGIN="1"/>
 </library>
-<!-- Disable RNuple plugin: https://github.com/cms-sw/cmsdist/pull/9451#issuecomment-2393861542
 <library file="rntuple/*.cc" name="PhysicsToolsNanoAODRNuplePlugins">
   <use name="rootntuple"/>
   <flags EDM_PLUGIN="1"/>
 </library>
--->

PhysicsTools/NanoAOD/plugins/rntuple/EventStringOutputFields.h

@@ -6,7 +6,7 @@
 #include "FWCore/Utilities/interface/EDGetToken.h"
 
 #include <ROOT/RNTupleModel.hxx>
-using ROOT::Experimental::RNTupleModel;
+using ROOT::RNTupleModel;
 
 #include "RNTupleFieldPtr.h"
 

PhysicsTools/NanoAOD/plugins/rntuple/NanoAODRNTupleOutputModule.cc

@@ -15,19 +15,9 @@
 
 #include <ROOT/RNTuple.hxx>
 #include <ROOT/RNTupleModel.hxx>
-#include <ROOT/RPageStorageFile.hxx>
-using ROOT::Experimental::RNTupleModel;
-#if ROOT_VERSION_CODE < ROOT_VERSION(6, 31, 0)
-using ROOT::Experimental::RNTupleWriter;
-using ROOT::Experimental::Detail::RPageSinkFile;
-#define MakeRNTupleWriter std::make_unique<RNTupleWriter>
-#include <ROOT/RNTupleOptions.hxx>
-#else
-using ROOT::Experimental::Internal::RPageSinkFile;
-#define MakeRNTupleWriter ROOT::Experimental::Internal::CreateRNTupleWriter
+using ROOT::RNTupleModel;
 #include <ROOT/RNTupleWriteOptions.hxx>
-#endif
-using ROOT::Experimental::RNTupleWriteOptions;
+using ROOT::RNTupleWriteOptions;
 
 #include "TObjString.h"
 
@@ -173,13 +163,15 @@ void NanoAODRNTupleOutputModule::openFile(edm::FileBlock const&) {
   const auto& keeps = keptProducts();
   for (const auto& keep : keeps[edm::InRun]) {
     if (keep.first->className() == "nanoaod::MergeableCounterTable") {
-      m_run.registerToken(keep.second);
+      m_run.registerCounterTableToken(keep.second);
     } else if (keep.first->className() == "nanoaod::UniqueString" && keep.first->moduleLabel() == "nanoMetadata") {
       m_nanoMetadata.emplace_back(keep.first->productInstanceName(), keep.second);
+    } else if (keep.first->className() == "nanoaod::FlatTable") {
+      m_run.registerFlatTableToken(keep.second);
     } else {
       throw cms::Exception(
           "Configuration",
-          "NanoAODRNTupleOutputModule cannot handle class " + keep.first->className() + " in Run branch");
+          "NanoAODRNTupleOutputModule cannot handle class " + keep.first->className() + " in Run RNTuple");
     }
   }
 }
@@ -210,10 +202,15 @@ void NanoAODRNTupleOutputModule::initializeNTuple(edm::EventForOutput const& iEv
     trigger.createFields(iEvent, *model);
   }
   m_evstrings.createFields(*model);
-  // TODO use Append
+
+  // Model needs to be frozen before we bind buffers
+  model->Freeze();
+
+  m_tables.bindBuffers(*model);
+
   RNTupleWriteOptions options;
   options.SetCompression(m_file->GetCompressionSettings());
-  m_ntuple = MakeRNTupleWriter(std::move(model), std::make_unique<RPageSinkFile>("Events", *m_file, options));
+  m_ntuple = RNTupleWriter::Append(std::move(model), "Events", *m_file, options);
 }
 
 void NanoAODRNTupleOutputModule::write(edm::EventForOutput const& iEvent) {

PhysicsTools/NanoAOD/plugins/rntuple/NanoAODRNTuples.cc

@@ -3,21 +3,10 @@
 #include "DataFormats/NanoAOD/interface/MergeableCounterTable.h"
 #include "FWCore/Framework/interface/RunForOutput.h"
 
-#include <ROOT/RNTuple.hxx>
 #include <ROOT/RNTupleModel.hxx>
-#include <ROOT/RPageStorageFile.hxx>
-using ROOT::Experimental::RNTupleModel;
-#if ROOT_VERSION_CODE < ROOT_VERSION(6, 31, 0)
-using ROOT::Experimental::RNTupleWriter;
-using ROOT::Experimental::Detail::RPageSinkFile;
-#define MakeRNTupleWriter std::make_unique<RNTupleWriter>
-#include <ROOT/RNTupleOptions.hxx>
-#else
-using ROOT::Experimental::Internal::RPageSinkFile;
-#define MakeRNTupleWriter ROOT::Experimental::Internal::CreateRNTupleWriter
+using ROOT::RNTupleModel;
 #include <ROOT/RNTupleWriteOptions.hxx>
-#endif
-using ROOT::Experimental::RNTupleWriteOptions;
+using ROOT::RNTupleWriteOptions;
 
 #include "RNTupleFieldPtr.h"
 #include "SummaryTableOutputFields.h"
@@ -26,11 +15,9 @@ void LumiNTuple::createFields(const edm::LuminosityBlockID& id, TFile& file) {
   auto model = RNTupleModel::Create();
   m_run = RNTupleFieldPtr<UInt_t>("run", "", *model);
   m_luminosityBlock = RNTupleFieldPtr<UInt_t>("luminosityBlock", "", *model);
-  // TODO use Append when we bump our RNTuple version:
-  // m_ntuple = RNTupleWriter::Append(std::move(model), "LuminosityBlocks", file);
   RNTupleWriteOptions options;
   options.SetCompression(file.GetCompressionSettings());
-  m_ntuple = MakeRNTupleWriter(std::move(model), std::make_unique<RPageSinkFile>("LuminosityBlocks", file, options));
+  m_ntuple = RNTupleWriter::Append(std::move(model), "LuminosityBlocks", file, options);
 }
 
 void LumiNTuple::fill(const edm::LuminosityBlockID& id, TFile& file) {
@@ -44,53 +31,60 @@ void LumiNTuple::fill(const edm::LuminosityBlockID& id, TFile& file) {
 
 void LumiNTuple::finalizeWrite() { m_ntuple.reset(); }
 
-void RunNTuple::registerToken(const edm::EDGetToken& token) { m_tokens.push_back(token); }
+void RunNTuple::registerCounterTableToken(const edm::EDGetToken& token) { m_counterTableTokens.push_back(token); }
+
+void RunNTuple::registerFlatTableToken(const edm::EDGetToken& token) { m_flatTableTokens.push_back(token); }
 
 void RunNTuple::createFields(const edm::RunForOutput& iRun, TFile& file) {
   auto model = RNTupleModel::Create();
   m_run = RNTupleFieldPtr<UInt_t>("run", "", *model);
 
-  edm::Handle<nanoaod::MergeableCounterTable> handle;
-  for (const auto& token : m_tokens) {
-    iRun.getByToken(token, handle);
-    const nanoaod::MergeableCounterTable& tab = *handle;
-    m_tables.push_back(SummaryTableOutputFields(tab, *model));
+  edm::Handle<nanoaod::MergeableCounterTable> counterTableHandle;
+  for (const auto& token : m_counterTableTokens) {
+    iRun.getByToken(token, counterTableHandle);
+    const nanoaod::MergeableCounterTable& tab = *counterTableHandle;
+    m_counterTables.push_back(SummaryTableOutputFields(tab, *model));
+  }
+
+  edm::Handle<nanoaod::FlatTable> flatTableHandle;
+  for (const auto& token : m_flatTableTokens) {
+    iRun.getByToken(token, flatTableHandle);
+    m_flatTables.add(token, *flatTableHandle);
   }
+  m_flatTables.createFields(iRun, *model);
 
-  // TODO use Append when we bump our RNTuple version
   RNTupleWriteOptions options;
   options.SetCompression(file.GetCompressionSettings());
-  m_ntuple = MakeRNTupleWriter(std::move(model), std::make_unique<RPageSinkFile>("Runs", file, options));
+  m_ntuple = RNTupleWriter::Append(std::move(model), "Runs", file, options);
 }
 
 void RunNTuple::fill(const edm::RunForOutput& iRun, TFile& file) {
   if (!m_ntuple) {
     createFields(iRun, file);
   }
   m_run.fill(iRun.id().run());
-  edm::Handle<nanoaod::MergeableCounterTable> handle;
-  for (std::size_t i = 0; i < m_tokens.size(); i++) {
-    iRun.getByToken(m_tokens.at(i), handle);
-    const nanoaod::MergeableCounterTable& tab = *handle;
-    m_tables.at(i).fill(tab);
+
+  edm::Handle<nanoaod::MergeableCounterTable> counterTableHandle;
+  for (std::size_t i = 0; i < m_counterTableTokens.size(); i++) {
+    iRun.getByToken(m_counterTableTokens.at(i), counterTableHandle);
+    const nanoaod::MergeableCounterTable& tab = *counterTableHandle;
+    m_counterTables.at(i).fill(tab);
   }
+
+  m_flatTables.fill(iRun);
+
   m_ntuple->Fill();
 }
 
 void RunNTuple::finalizeWrite() { m_ntuple.reset(); }
 
 void PSetNTuple::createFields(TFile& file) {
-  // use a collection to emulate std::pair
-  auto pairModel = RNTupleModel::Create();
-  m_psetId = RNTupleFieldPtr<std::string>("first", "", *pairModel);
-  m_psetBlob = RNTupleFieldPtr<std::string>("second", "", *pairModel);
   auto model = RNTupleModel::Create();
-  m_collection = model->MakeCollection(edm::poolNames::idToParameterSetBlobsBranchName(), std::move(pairModel));
-  // TODO use Append when we bump our RNTuple version
+  m_pset = RNTupleFieldPtr<PSetType>(edm::poolNames::idToParameterSetBlobsBranchName(), "", *model);
+
   RNTupleWriteOptions options;
   options.SetCompression(file.GetCompressionSettings());
-  m_ntuple = MakeRNTupleWriter(std::move(model),
-                               std::make_unique<RPageSinkFile>(edm::poolNames::parameterSetsTreeName(), file, options));
+  m_ntuple = RNTupleWriter::Append(std::move(model), edm::poolNames::parameterSetsTreeName(), file, options);
 }
 
 void PSetNTuple::fill(edm::pset::Registry* pset, TFile& file) {
@@ -101,41 +95,32 @@ void PSetNTuple::fill(edm::pset::Registry* pset, TFile& file) {
     createFields(file);
   }
   for (const auto& ps : *pset) {
-    std::ostringstream oss;
-    oss << ps.first;
-    m_psetId.fill(oss.str());
-    m_psetBlob.fill(ps.second.toString());
-    m_collection->Fill();
+    std::string psString;
+    ps.second.toString(psString);
+    edm::ParameterSetBlob psBlob(psString);
+    m_pset.fill(std::make_pair(ps.first, psBlob));
     m_ntuple->Fill();
   }
 }
 
 void PSetNTuple::finalizeWrite() { m_ntuple.reset(); }
 
-// TODO blocked on RNTuple typedef member field support
 void MetadataNTuple::createFields(TFile& file) {
-  auto procHistModel = RNTupleModel::Create();
-  // ProcessHistory.transients_.phid_ replacement
-  m_phId = RNTupleFieldPtr<std::string>("transients_phid_", "", *procHistModel);
   auto model = RNTupleModel::Create();
-  m_procHist = model->MakeCollection(edm::poolNames::processHistoryBranchName(), std::move(procHistModel));
+  m_procHist = RNTupleFieldPtr<edm::ProcessHistory>(edm::poolNames::processHistoryBranchName(), "", *model);
   RNTupleWriteOptions options;
   options.SetCompression(file.GetCompressionSettings());
-  m_ntuple = MakeRNTupleWriter(std::move(model),
-                               std::make_unique<RPageSinkFile>(edm::poolNames::metaDataTreeName(), file, options));
+  m_ntuple = RNTupleWriter::Append(std::move(model), edm::poolNames::metaDataTreeName(), file, options);
 }
 
 void MetadataNTuple::fill(const edm::ProcessHistoryRegistry& procHist, TFile& file) {
   if (!m_ntuple) {
     createFields(file);
   }
   for (const auto& ph : procHist) {
-    std::string phid;
-    ph.second.id().toString(phid);
-    m_phId.fill(phid);
-    m_procHist->Fill();
+    m_procHist.fill(ph.second);
+    m_ntuple->Fill();
   }
-  m_ntuple->Fill();
 }
 
 void MetadataNTuple::finalizeWrite() { m_ntuple.reset(); }

PhysicsTools/NanoAOD/plugins/rntuple/NanoAODRNTuples.h

@@ -12,14 +12,8 @@
 
 #include "TFile.h"
 #include <ROOT/RNTuple.hxx>
-#if ROOT_VERSION_CODE < ROOT_VERSION(6, 31, 0)
-using ROOT::Experimental::RCollectionNTupleWriter;
-#else
 #include <ROOT/RNTupleWriter.hxx>
-#include <ROOT/RNTupleCollectionWriter.hxx>
-using ROOT::Experimental::RNTupleCollectionWriter;
-#endif
-using ROOT::Experimental::RNTupleWriter;
+using ROOT::RNTupleWriter;
 
 #include "EventStringOutputFields.h"
 #include "RNTupleFieldPtr.h"
@@ -43,16 +37,19 @@ class LumiNTuple {
 class RunNTuple {
 public:
   RunNTuple() = default;
-  void registerToken(const edm::EDGetToken& token);
+  void registerCounterTableToken(const edm::EDGetToken& token);
+  void registerFlatTableToken(const edm::EDGetToken& token);
   void fill(const edm::RunForOutput& iRun, TFile& file);
   void finalizeWrite();
 
 private:
   void createFields(const edm::RunForOutput& iRun, TFile& file);
-  std::vector<edm::EDGetToken> m_tokens;
+  std::vector<edm::EDGetToken> m_counterTableTokens;
+  std::vector<edm::EDGetToken> m_flatTableTokens;
   std::unique_ptr<RNTupleWriter> m_ntuple;
   RNTupleFieldPtr<UInt_t> m_run;
-  std::vector<SummaryTableOutputFields> m_tables;
+  std::vector<SummaryTableOutputFields> m_counterTables;
+  TableCollectionSet m_flatTables;
 };
 
 class PSetNTuple {
@@ -62,21 +59,9 @@ class PSetNTuple {
   void finalizeWrite();
 
 private:
-  // TODO blocked on RNTuple std::pair support
-  // using PSetType = std::pair<edm::ParameterSetID, edm::ParameterSetBlob>;
-  // RNTupleFieldPtr<PSetType> m_pset;
+  using PSetType = std::pair<edm::ParameterSetID, edm::ParameterSetBlob>;
+  RNTupleFieldPtr<PSetType> m_pset;
   void createFields(TFile& file);
-  // TODO blocked on RNTuple typedef member field support:
-  // https://github.com/root-project/root/issues/7861
-  // RNTupleFieldPtr<edm::ParameterSetID> m_psetId;
-  // RNTupleFieldPtr<edm::ParameterSetBlob> m_psetBlob;
-#if ROOT_VERSION_CODE < ROOT_VERSION(6, 31, 0)
-  std::shared_ptr<RCollectionNTupleWriter> m_collection;
-#else
-  std::shared_ptr<RNTupleCollectionWriter> m_collection;
-#endif
-  RNTupleFieldPtr<std::string> m_psetId;
-  RNTupleFieldPtr<std::string> m_psetBlob;
   std::unique_ptr<RNTupleWriter> m_ntuple;
 };
 
@@ -88,13 +73,7 @@ class MetadataNTuple {
 
 private:
   void createFields(TFile& file);
-#if ROOT_VERSION_CODE < ROOT_VERSION(6, 31, 0)
-  std::shared_ptr<RCollectionNTupleWriter> m_procHist;
-#else
-  std::shared_ptr<RNTupleCollectionWriter> m_procHist;
-#endif
-
-  RNTupleFieldPtr<std::string> m_phId;
+  RNTupleFieldPtr<edm::ProcessHistory> m_procHist;
   std::unique_ptr<RNTupleWriter> m_ntuple;
 };