RActionCustomLoader.hxx

Go to the documentation of this file.

// Author: Vincenzo Eduardo Padulano CERN 10/2026
// Author: Silia Taider CERN 10/2026
 
#ifndef ROOT_RActionCustomLoader
#define ROOT_RActionCustomLoader
 
#include "ROOT/RDF/ColumnReaderUtils.hxx"
#include "ROOT/RDF/GraphNode.hxx"
#include "ROOT/RDF/RActionBase.hxx"
#include "ROOT/RDF/RFilterBase.hxx"
#include "ROOT/RDF/RJittedFilter.hxx"
#include "ROOT/RDF/RLoopManager.hxx"
 
#include <cstddef> // std::size_t
#include <memory>
#include <string>
#include <vector>
 
namespace ROOT::Internal::RDF {
 
template <typename Helper, typename PrevNode>
class R__CLING_PTRCHECK(off) RActionCustomLoader final : public RActionBase {
 
   // Template needed to avoid dependency on ActionHelpers.hxx
   Helper fHelper;
 
   // If the PrevNode is a RJittedFilter, our collection of previous nodes will have to use the RFilterBase type:
   // we'll have a RJittedFilter for the nominal case, but the others will be concrete filters.
   using PrevNodeCommon_t = std::conditional_t<std::is_same_v<PrevNode, ROOT::Detail::RDF::RJittedFilter>,
                                               ROOT::Detail::RDF::RFilterBase, PrevNode>;
   /// Previous nodes in the computation graph. First element is nominal, others are varied.
   std::vector<std::shared_ptr<PrevNodeCommon_t>> fPrevNodes;
 
   /// Column readers per slot and per input column
   std::vector<std::vector<RColumnReaderBase *>> fValues;
 
   /// Value addresses of the current entry per slot, reused for every entry
   std::vector<std::vector<void *>> fValueAddresses;
 
   // Types of input columns
   std::vector<const std::type_info *> fColTypeIDs;
 
   ROOT::RDF::SampleCallback_t GetSampleCallback() final { return fHelper.GetSampleCallback(); }
 
public:
   RActionCustomLoader(Helper &&h, const std::vector<std::string> &columns,
                       const std::vector<const std::type_info *> &colTypeIDs, std::shared_ptr<PrevNode> pd,
                       const RColumnRegister &colRegister)
      : RActionBase(pd->GetLoopManagerUnchecked(), columns, colRegister, pd->GetVariations()),
        fHelper(std::move(h)),
        fPrevNodes{std::static_pointer_cast<PrevNodeCommon_t>(pd)},
        fValues(GetNSlots()),
        fValueAddresses(GetNSlots()),
        fColTypeIDs(colTypeIDs)
   {
      fLoopManager->Register(this);
   }
 
   RActionCustomLoader(const RActionCustomLoader &) = delete;
   RActionCustomLoader &operator=(const RActionCustomLoader &) = delete;
   RActionCustomLoader(RActionCustomLoader &&) = delete;
   RActionCustomLoader &operator=(RActionCustomLoader &&) = delete;
 
   ~RActionCustomLoader() final { fLoopManager->Deregister(this); }
 
   /**
      Retrieve a wrapper to the result of the action that knows how to merge
      with others of the same type.
   */
   std::unique_ptr<ROOT::Detail::RDF::RMergeableValueBase> GetMergeableValue() const final
   {
      return fHelper.GetMergeableValue();
   }
 
   void Initialize() final { fHelper.Initialize(); }
 
   void InitSlot(TTreeReader *r, unsigned int slot) final
   {
      fValues[slot] = GetUntypedColumnReaders(slot, r, RActionBase::GetColRegister(), *fLoopManager,
                                              RActionBase::GetColumnNames(), fColTypeIDs);
      fHelper.InitTask(r, slot);
   }
 
   void *GetValue(unsigned int slot, std::size_t readerIdx, Long64_t entry)
   {
      assert(slot < fValues.size());
      assert(readerIdx < fValues[slot].size());
      if (auto *val = fValues[slot][readerIdx]->template TryGet<void>(entry))
         return val;
 
      throw std::out_of_range{"RDataFrame: Action (" + fHelper.GetActionName() +
                              ") could not retrieve value for column '" + fColumnNames[readerIdx] + "' for entry " +
                              std::to_string(entry) +
                              ". You can use the DefaultValueFor operation to provide a default value, or "
                              "FilterAvailable/FilterMissing to discard/keep entries with missing values instead."};
   }
 
   void CallExec(unsigned int slot, Long64_t entry)
   {
      auto &untypedValues = fValueAddresses[slot];
      auto nReaders = fValues[slot].size();
      untypedValues.resize(nReaders);
      for (decltype(nReaders) readerIdx{}; readerIdx < nReaders; readerIdx++)
         untypedValues[readerIdx] = GetValue(slot, readerIdx, entry);
 
      fHelper.Exec(slot, untypedValues);
   }
 
   void Run(unsigned int slot, Long64_t entry) final
   {
 
      if (fPrevNodes.front()->CheckFilters(slot, entry))
         CallExec(slot, entry);
   }
 
   void TriggerChildrenCount() final
   {
      for (auto const &node : fPrevNodes)
         node->IncrChildrenCount();
   }
 
   /// Clean-up operations to be performed at the end of a task.
   void FinalizeSlot(unsigned int slot) final
   {
      fValues[slot].clear();
      fHelper.CallFinalizeTask(slot);
   }
 
   /// Clean-up and finalize the action result (e.g. merging slot-local results).
   /// It invokes the helper's Finalize method.
   void Finalize() final
   {
      fHelper.Finalize();
      SetHasRun();
   }
 
   std::shared_ptr<GraphDrawing::GraphNode>
   GetGraph(std::unordered_map<void *, std::shared_ptr<GraphDrawing::GraphNode>> &visitedMap) final
   {
      // Action nodes do not need to go through CreateFilterNode: they are never common nodes between multiple branches
      const auto nodeType = HasRun() ? GraphDrawing::ENodeType::kUsedAction : GraphDrawing::ENodeType::kAction;
      auto thisNode = std::make_shared<GraphDrawing::GraphNode>(fHelper.GetActionName(), visitedMap.size(), nodeType);
      visitedMap[(void *)this] = thisNode;
 
      for (auto const &node : fPrevNodes) {
         auto prevNode = node->GetGraph(visitedMap);
         const auto &prevColumns = prevNode->GetDefinedColumns();
         auto upmostNode = AddDefinesToGraph(thisNode, GetColRegister(), prevColumns, visitedMap);
 
         thisNode->AddDefinedColumns(GetColRegister().GenerateColumnNames());
         upmostNode->SetPrevNode(prevNode);
      }
      return thisNode;
   }
 
   /// Forwards to the action helpers; will throw since PartialUpdate not supported for most snapshot helpers.
   void *PartialUpdate(unsigned int slot) final { return fHelper.CallPartialUpdate(slot); }
 
   [[maybe_unused]] std::unique_ptr<RActionBase> MakeVariedAction(std::vector<void *> && /*results*/) final
   {
      throw std::runtime_error("not implemented.");
   }
 
   /**
    * \brief Returns a new action with a cloned helper.
    *
    * \param[in] newResult The result to be filled by the new action (needed to clone the helper).
    * \return A unique pointer to the new action.
    */
   std::unique_ptr<RActionBase> CloneAction(void *newResult) final
   {
      return std::make_unique<RActionCustomLoader>(fHelper.CallMakeNew(newResult), GetColumnNames(), fColTypeIDs,
                                                   std::static_pointer_cast<PrevNode>(fPrevNodes.front()),
                                                   GetColRegister());
   }
};
 
} // namespace ROOT::Internal::RDF
 
#endif // ROOT_RActionCustomLoader