[ntuple] Update tutorials

Author: enirolf

tutorials/io/ntuple/ntpl012_processor_chain.C

@@ -64,28 +64,26 @@ void Read(const std::vector<RNTupleOpenSpec> &ntuples)
    TH1F hPx("h", "This is the px distribution", 100, -4, 4);
    hPx.SetFillColor(48);
 
-   auto model = ROOT::RNTupleModel::Create();
-   auto ptrPx = model->MakeField<std::vector<float>>("vpx");
-
-   // By passing a model to the processor, we can use the pointers to field values created upon model creation during
-   // processing. When no model is provided, a default model is created based on the first ntuple specified.
-   // Access to the entry values in this case can be achieved through RNTupleProcessor::GetEntry() or through its
-   // iterator.
-   auto processor = RNTupleProcessor::CreateChain(ntuples, std::move(model));
+   // The chain-based processor can be created by passing a list of RNTupleOpenSpecs, describing the name and location
+   // of each ntuple in the chain.
+   auto processor = RNTupleProcessor::CreateChain(ntuples);
    int prevProcessorNumber{-1};
 
-   for (const auto &entry : *processor) {
-      // The RNTupleProcessor provides some additional bookkeeping information. The local entry number is reset each
-      // a new ntuple in the chain is opened for processing.
+   // Access to the processor's fields is done by first requesting them through RNTupleProcessor::RequestField(). The
+   // returned value can be used to read the current entry's value for that particular field.
+   auto px = processor->RequestField<std::vector<float>>("vpx");
+
+   // The iterator value is the index of the current entry being processed.
+   for (auto idx : *processor) {
+      // The RNTupleProcessor provides some additional bookkeeping information, such as the current processor number.
       if (static_cast<int>(processor->GetCurrentProcessorNumber()) > prevProcessorNumber) {
          prevProcessorNumber = processor->GetCurrentProcessorNumber();
-         std::cout << "Processing `ntuple" << prevProcessorNumber + 1 << "` (" << processor->GetNEntriesProcessed()
+         std::cout << "Processing `ntuple" << prevProcessorNumber + 1 << "` (" << idx + 1
                    << " total entries processed so far)" << std::endl;
       }
 
-      // We can use the pointer to the field obtained while creating our model to read the field's data for the current
-      // entry.
-      for (auto x : *ptrPx) {
+      // We use the value returned from requesting the field to read its data for the current entry.
+      for (auto x : *px) {
          hPx.Fill(x);
       }
    }

tutorials/io/ntuple/ntpl015_processor_join.C

@@ -24,15 +24,15 @@
 using ROOT::Experimental::RNTupleOpenSpec;
 using ROOT::Experimental::RNTupleProcessor;
 
-const std::string kMainNTupleName = "mainNTuple";
+const std::string kPrimaryNTupleName = "mainNTuple";
 const std::string kMainNTuplePath = "main_ntuple.root";
 const std::string kAuxNTupleName = "auxNTuple";
 const std::string kAuxNTuplePath = "aux_ntuple.root";
 
-// Number of events to generate for the auxiliary ntuple. The main ntuple will have a fifth of this number.
+// Number of events to generate for the auxiliary ntuple. The primary ntuple will have a fifth of this number.
 constexpr int kNEvents = 10000;
 
-void WriteMain(std::string_view ntupleName, std::string_view ntupleFileName)
+void WritePrimary(std::string_view ntupleName, std::string_view ntupleFileName)
 {
    auto model = ROOT::RNTupleModel::Create();
 
@@ -41,15 +41,15 @@ void WriteMain(std::string_view ntupleName, std::string_view ntupleFileName)
 
    auto writer = ROOT::RNTupleWriter::Recreate(std::move(model), ntupleName, ntupleFileName);
 
-   // The main ntuple only contains a subset of the entries present in the auxiliary ntuple.
+   // The primary ntuple only contains a subset of the entries present in the auxiliary ntuple.
    for (int i = 0; i < kNEvents; i += 5) {
       *fldI = i;
       *fldVpx = gRandom->Gaus();
 
       writer->Fill();
    }
 
-   std::cout << "Wrote " << writer->GetNEntries() << " to the main RNTuple" << std::endl;
+   std::cout << "Wrote " << writer->GetNEntries() << " to the primary RNTuple" << std::endl;
 }
 
 void WriteAux(std::string_view ntupleName, std::string_view ntupleFileName)
@@ -77,23 +77,25 @@ void Read()
    TH1F hPy("h", "This is the px + py distribution", 100, -4, 4);
    hPy.SetFillColor(48);
 
-   // The first specified ntuple is the main ntuple and will be used to drive the processor loop. The subsequent
-   // list of ntuples (in this case, only one) are auxiliary and will be joined with the entries from the main ntuple.
-   // We specify field "i" as the join field. This field, which should be present in all ntuples specified is used to
-   // identify which entries belong together. Multiple join fields can be specified, in which case the combination of
-   // field values is used. It is possible to specify up to 4 join fields. Providing an empty list of join fields
-   // signals to the processor that all entries are aligned.
+   // The first specified ntuple is the primary ntuple and will be used to drive the processor loop. The subsequent
+   // list of ntuples (in this case, only one) are auxiliary and will be joined with the entries from the primary
+   // ntuple. We specify field "i" as the join field. This field, which should be present in all ntuples specified is
+   // used to identify which entries belong together. Multiple join fields can be specified, in which case the
+   // combination of field values is used. It is possible to specify up to 4 join fields. Providing an empty list of
+   // join fields signals to the processor that all entries are aligned.
    auto processor =
-      RNTupleProcessor::CreateJoin({kMainNTupleName, kMainNTuplePath}, {kAuxNTupleName, kAuxNTuplePath}, {"i"});
-
-   float px, py;
-   for (const auto &entry : *processor) {
-      // Fields from the main ntuple are accessed by their original name.
-      px = *entry.GetPtr<float>("vpx");
-      // Fields from auxiliary ntuples are accessed by prepending the name of the auxiliary ntuple.
-      py = *entry.GetPtr<float>(kAuxNTupleName + ".vpy");
-
-      hPy.Fill(px + py);
+      RNTupleProcessor::CreateJoin({kPrimaryNTupleName, kMainNTuplePath}, {kAuxNTupleName, kAuxNTuplePath}, {"i"});
+
+   // Access to the processor's fields is done by first requesting them through RNTupleProcessor::RequestField(). The
+   // returned value can be used to read the current entry's value for that particular field. Fields from the primary
+   // ntuple are requested by their original name.
+   auto px = processor->RequestField<float>("vpx");
+   // Fields from auxiliary ntuples are requested by prepending the name of the auxiliary ntuple.
+   auto py = processor->RequestField<float>(kAuxNTupleName + ".vpy");
+
+   // The iterator value is the index of the current entry being processed. In this example, we don't use it.
+   for (auto _ : *processor) {
+      hPy.Fill(*px + *py);
    }
 
    std::cout << "Processed a total of " << processor->GetNEntriesProcessed() << " entries" << std::endl;
@@ -103,7 +105,7 @@ void Read()
 
 void ntpl015_processor_join()
 {
-   WriteMain(kMainNTupleName, kMainNTuplePath);
+   WritePrimary(kPrimaryNTupleName, kMainNTuplePath);
    WriteAux(kAuxNTupleName, kAuxNTuplePath);
 
    Read();