columnar::ColumnarPhysLiteTest Struct Reference

#include <ColumnarPhysliteTest.h>

Inheritance diagram for columnar::ColumnarPhysLiteTest:

Collaboration diagram for columnar::ColumnarPhysLiteTest:

Public Member Functions
	ColumnarPhysLiteTest ()
	~ColumnarPhysLiteTest ()
std::string	makeUniqueName ()
	make a unique tool name to be used in unit tests
void	setupKnownColumns (std::span< const TestUtils::TestDefinition > testDefinitions)
void	setupColumns (const ColumnVectorHeader &columnHeader)
void	doCall (const TestUtils::TestDefinition &testDefinition)
void	doCallMulti (const std::vector< TestUtils::TestDefinition > &testDefinitions)

Static Public Member Functions
static bool	checkMode ()
	check whether we have the right mode

Public Attributes
std::unique_ptr< TFile >	file
TTree *	tree = nullptr
std::unique_ptr< ROOT::RNTupleReader >	rntreader
std::unique_ptr< ROOT::Experimental::RNTupleInspector >	inspector
columnar::TestUtils::RNTupleBackend *	rntbackend = nullptr
std::vector< std::shared_ptr< TestUtils::IColumnData > >	knownColumns
std::vector< std::shared_ptr< TestUtils::IColumnData > >	usedColumns
std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * >	offsetColumns

Detailed Description

Definition at line 42 of file ColumnarPhysliteTest.h.

Constructor & Destructor Documentation

ColumnarPhysLiteTest()

columnar::ColumnarPhysLiteTest::ColumnarPhysLiteTest

(

)

Definition at line 2144 of file ColumnarPhysliteTest.cxx.

  {
    static std::once_flag flag;
    std::call_once (flag, [] ()
    {
#ifdef XAOD_STANDALONE
      xAOD::Init().ignore();
#else
      POOL::Init();
#endif
    });
 
    auto userConfiguration = TestUtils::UserConfiguration::fromEnvironment();
    if (userConfiguration.isrntuple) 
    {
      auto* fileName = getenv("ASG_TEST_FILE_RNTUPLE_LITE_MC");
      if (fileName == nullptr)
        throw std::runtime_error("missing ASG_TEST_FILE_RNTUPLE_LITE_MC");
      rntreader = ROOT::RNTupleReader::Open("EventData", fileName);
      inspector = ROOT::Experimental::RNTupleInspector::Create("EventData", fileName);
      rntbackend = new TestUtils::RNTupleBackend{rntreader.get(), inspector.get()};
      if (!rntreader or !inspector)
        throw std::runtime_error("failed to open rntuple");
    } else 
    {
      auto* fileName = getenv("ASG_TEST_FILE_LITE_MC");
      if (fileName == nullptr)
        throw std::runtime_error("missing ASG_TEST_FILE_LITE_MC");
      file.reset(TFile::Open(fileName, "READ"));
      if (!file)
        throw std::runtime_error("failed to open file");
      tree = dynamic_cast<TTree*>(file->Get("CollectionTree"));
      if (!tree)
        throw std::runtime_error("failed to open rntuple");
    }
  }

~ColumnarPhysLiteTest()

columnar::ColumnarPhysLiteTest::~ColumnarPhysLiteTest

(

)

Definition at line 2182 of file ColumnarPhysliteTest.cxx.

  {
    if (rntbackend)
      delete rntbackend;
  }

Member Function Documentation

checkMode()

bool columnar::ColumnarPhysLiteTest::checkMode ( )

static

check whether we have the right mode

Definition at line 2194 of file ColumnarPhysliteTest.cxx.

  {
    return true;
  }

doCall()

void columnar::ColumnarPhysLiteTest::doCall

(

const TestUtils::TestDefinition &

testDefinition

)

Definition at line 2628 of file ColumnarPhysliteTest.cxx.

  {
    doCallMulti ({testDefinition});
  }

doCallMulti()

void columnar::ColumnarPhysLiteTest::doCallMulti

(

const std::vector< TestUtils::TestDefinition > &

testDefinitions

)

Definition at line 2634 of file ColumnarPhysliteTest.cxx.

                                                      {
  using namespace asg::msgUserCode;
  auto userConfiguration = TestUtils::UserConfiguration::fromEnvironment();
 
  // apply systematics for all test definitions
  for (const auto& td : testDefinitions) {
    if (!td.sysName.empty()) {
      auto* sysTool = dynamic_cast<CP::ISystematicsTool*>(td.tool);
      if (!sysTool)
        throw std::runtime_error("tool does not support systematics");
      std::cout << "applying systematic variation: " << td.sysName << std::endl;
      if (sysTool->applySystematicVariation(CP::SystematicSet(td.sysName))
              .isFailure())
        throw std::runtime_error("failed to apply systematic variation: " +
                                 td.sysName);
    }
  }
 
  if constexpr (columnarAccessMode == 2) {
    // Create shared column header for all tools
    ColumnVectorHeader columnHeader;
 
    // Build vector of ToolData from all testDefinitions
    std::vector<TestUtils::ToolData> toolDataVec;
    for (const auto& td : testDefinitions)
      toolDataVec.emplace_back(userConfiguration, td, columnHeader);
 
    setupKnownColumns(testDefinitions);
    // Set up columns using the shared header (all tools have already
    // registered their columns via ToolColumnVectorMap, so we get all columns
    // from the header)
    setupColumns(columnHeader);
 
    // connect column indices from header to each column for direct setting
    for (auto& column : usedColumns)
      column->connectColumnIndices(columnHeader);
 
    Benchmark benchmarkEmpty("empty");
    Benchmark benchmarkCheck("", userConfiguration.batchSize);
    auto numberOfEvents = 0;
    if (tree) {
      numberOfEvents = tree->GetEntries();
    } else if (rntbackend) {
      numberOfEvents = rntreader->GetNEntries();
    }
    Long64_t entry = 0;
    const auto startTime = std::chrono::high_resolution_clock::now();
    bool endLoop = false;
    for (; !endLoop; ++entry) {
      // just sample how much overhead there is for starting and
      // stopping the timer
      benchmarkEmpty.startTimer();
      benchmarkEmpty.stopTimer();
      ColumnVectorData columnData(&columnHeader);
      for (auto& column : usedColumns)
        column->getEntry(entry % numberOfEvents);
      if ((entry + 1) % userConfiguration.batchSize == 0) {
        if (entry < numberOfEvents) {
          for (auto& column : usedColumns)
            column->collectColumnData();
        }
        for (auto& column : usedColumns)
          column->setData(columnData);
 
        // Check data once (shared column data)
        benchmarkCheck.startTimer();
        columnData.checkData();
        benchmarkCheck.stopTimer();
        // Call each tool
        for (auto& toolData : toolDataVec) {
          toolData.call(columnData);
        }
        for (auto& column : usedColumns)
          column->clearColumns();
        if ((std::chrono::high_resolution_clock::now() - startTime) >
            userConfiguration.targetTime)
          endLoop = true;
      } else if (entry + 1 == numberOfEvents) {
        for (auto& column : usedColumns)
          column->collectColumnData();
      }
    }
      std::cout << "Entries in file: " << numberOfEvents << std::endl;
      std::cout << "Total entries read: " << entry << std::endl;
      const float emptyTime = benchmarkEmpty.getEntryTime(0).value();
      std::cout << "Empty benchmark time: " << emptyTime << "ns (tick=" << Benchmark::getTickDuration() << "ns)" << std::endl;
      benchmarkEmpty.setSilence();
      const auto checkTime = benchmarkCheck.getEntryTime(emptyTime);
      if (checkTime)
        std::cout << "Check data time: " << checkTime.value() << "ns" << std::endl;
      benchmarkCheck.setSilence();
      {
        std::vector<TestUtils::BranchPerfData> branchPerfData;
        TestUtils::BranchPerfData summary;
        summary.name = "total";
        summary.timeRead = 0;
        summary.timeUnpack = 0;
        summary.timeShallowCopy = 0;
        summary.entrySize = 0;
        summary.uncompressedSize = 0;
        summary.numBaskets = 0;
        summary.entries = std::nullopt;
        summary.nullEntries = std::nullopt;
        for (auto& column : usedColumns)
        {
          branchPerfData.push_back (column->getPerfData (emptyTime));
          summary.timeRead.value() += branchPerfData.back().timeRead.value_or(0);
          summary.timeUnpack.value() += branchPerfData.back().timeUnpack.value_or(0);
          summary.entrySize.value() += branchPerfData.back().entrySize.value_or(0);
          summary.uncompressedSize.value() += branchPerfData.back().uncompressedSize.value_or(0);
          summary.numBaskets.value() += branchPerfData.back().numBaskets.value_or(0);
          summary.timeShallowCopy.value() += branchPerfData.back().timeShallowCopy.value_or(0);
        }
        std::sort (branchPerfData.begin(), branchPerfData.end(), [] (const auto& a, const auto& b) {return a.name < b.name;});
        branchPerfData.insert (branchPerfData.end(), summary);
        const std::size_t nameWidth = std::max_element (branchPerfData.begin(), branchPerfData.end(), [] (const auto& a, const auto& b) {return a.name.size() < b.name.size();})->name.size();
        std::string label = userConfiguration.isrntuple ? "field name" : "branch name";
        std::string header = std::format ("{:{}} | read(ns) | unpack(ns) | size(B) | rate(MB/s) | compression | baskets | entries | null", label, nameWidth);
        std::cout << "\n" << header << std::endl;
        std::cout << std::string (header.size(), '-') << std::endl;
        for (auto& data : branchPerfData)
        {
          if (data.name == "total")
            std::cout << std::string (header.size(), '-') << std::endl;
          std::cout << std::format ("{:{}} |", data.name, nameWidth);
          if (data.timeRead)
            std::cout << std::format ("{:>9.0f} |", data.timeRead.value());
          else
            std::cout << "          |";
          if (data.timeUnpack)
            std::cout << std::format ("{:>11.1f} |", data.timeUnpack.value());
          else
            std::cout << "            |";
          if (data.entrySize)
            std::cout << std::format ("{:>8.1f} |", data.entrySize.value());
          else
            std::cout << "         |";
          if (data.timeRead && data.entrySize)
            std::cout << std::format ("{:>11.1f} |", (data.entrySize.value() / (data.timeRead.value() * 1e-3 * 1.024 * 1.024)));
          else
            std::cout << "            |";
          if (data.entrySize && data.uncompressedSize)
            std::cout << std::format ("{:>12.2f} |", float (data.uncompressedSize.value()) / data.entrySize.value());
          else
            std::cout << "             |";
          if (data.numBaskets)
            std::cout << std::format ("{:>8} |", data.numBaskets.value());
          else
            std::cout << "         |";
          if (data.entries)
            std::cout << std::format ("{:>8.2f} |", static_cast<float>(data.entries.value())/numberOfEvents);
          else
            std::cout << "         |";
          if (data.nullEntries && data.entries)
            std::cout << std::format ("{:>4.0f}%", static_cast<float>(data.nullEntries.value()) / data.entries.value() * 100.0f);
          std::cout << std::endl;
        }
      }
      {
        std::vector<TestUtils::ToolPerfData> toolPerfData;
        for (auto& toolData : toolDataVec)
        {
          toolPerfData.emplace_back ();
          toolPerfData.back().name = toolData.name;
          toolPerfData.back().timeCall = toolData.benchmarkCall.getEntryTime (emptyTime);
          if (userConfiguration.runToolTwice)
            toolPerfData.back().timeCall2 = toolData.benchmarkCall2.getEntryTime (emptyTime);
        }
        const std::size_t nameWidth = std::max_element (toolPerfData.begin(), toolPerfData.end(), [] (const auto& a, const auto& b) {return a.name.size() < b.name.size();})->name.size();
        std::string header = std::format ("{:{}} | call(ns) | call2(ns)", "tool name", nameWidth);
        std::cout << "\n" << header << std::endl;
        std::cout << std::string (header.size(), '-') << std::endl;
        for (auto& data : toolPerfData)
        {
          std::cout << std::format ("{:{}} |", data.name, nameWidth);
          if (data.timeCall)
            std::cout << std::format ("{:>9.0f} |", data.timeCall.value());
          else
            std::cout << "          |";
          if (data.timeCall2)
            std::cout << std::format ("{:>10.0f}", data.timeCall2.value());
          else
            std::cout << "          ";
          std::cout << std::endl;
        }
        // Add totals line for multiple tools
        if (toolPerfData.size() > 1)
        {
          std::optional<float> totalCall, totalCall2;
          for (const auto& data : toolPerfData)
          {
            if (data.timeCall)
              totalCall = totalCall.value_or (0) + data.timeCall.value();
            if (data.timeCall2)
              totalCall2 = totalCall2.value_or (0) + data.timeCall2.value();
          }
          std::cout << std::string (header.size(), '-') << std::endl;
          std::cout << std::format ("{:{}} |", "total", nameWidth);
          if (totalCall)
            std::cout << std::format ("{:>9.0f} |", totalCall.value());
          else
            std::cout << "          |";
          if (totalCall2)
            std::cout << std::format ("{:>10.0f}", totalCall2.value());
          else
            std::cout << "          ";
          std::cout << std::endl;
        }
      }
    } else if constexpr (columnarAccessMode == 0)
    {
      TestUtils::runXaodTest (userConfiguration, testDefinitions, file.get());
    } else if constexpr (columnarAccessMode == 100)
    {
      const auto& testDefinition = testDefinitions[0];
      TestUtils::runXaodArrayTest (userConfiguration, testDefinition, file.get());
    }
  }

makeUniqueName()

std::string columnar::ColumnarPhysLiteTest::makeUniqueName

(

)

make a unique tool name to be used in unit tests

Definition at line 2188 of file ColumnarPhysliteTest.cxx.

  {
    static std::atomic<unsigned> index = 0;
    return "UniquePhysliteTestTool" + std::to_string(++index);
  }

setupColumns()

void columnar::ColumnarPhysLiteTest::setupColumns

(

const ColumnVectorHeader &

columnHeader

)

Definition at line 2520 of file ColumnarPhysliteTest.cxx.

  {
    using namespace asg::msgUserCode;
 
    // Get all column info directly from the header (all tools have already
    // registered their columns via ToolColumnVectorMap)
    auto requestedColumns = columnHeader.getAllColumnInfo();
 
    // Print requested columns
    for (auto& [name, info] : requestedColumns)
      std::cout << "requested columns: " << name << std::endl;
 
    for (auto& column : knownColumns)
    {
      if (tree) 
      {
        if (column->connect (tree, offsetColumns, requestedColumns))
          usedColumns.push_back (column);
      } else if (rntbackend) 
      {
        if (column->connect(rntbackend, offsetColumns, requestedColumns))
          usedColumns.push_back(column);
      }
    }
 
    std::set<std::string> unclaimedColumns;
    for (auto& column : requestedColumns)
    {
      if (!column.second.isOptional)
        unclaimedColumns.insert (column.first);
      else
        std::cout << "optional column not claimed: " << column.first << std::endl;
    }
    std::erase_if (unclaimedColumns, [&] (auto& columnName)
    {
      const auto& info = requestedColumns.at (columnName);
      if (info.accessMode != ColumnAccessMode::output || !info.fixedDimensions.empty())
        return false;
      auto offsetIter = std::find_if (usedColumns.begin(), usedColumns.end(), [&] (const std::shared_ptr<TestUtils::IColumnData>& column)
      {
        for (auto& output : column->outputColumns)
        {
          if (output.name == info.offsetName)
            return true;
        }
        return false;
      });
      if (offsetIter == usedColumns.end())
        return false;
      std::shared_ptr<TestUtils::IColumnData> myColumn;
      if (tree) 
      {
        if (*info.type == typeid(float))
          myColumn = std::make_shared<TestUtils::ColumnDataOutVector<float, BranchReader>>(info.name, 0);
        else if (*info.type == typeid(char))
          myColumn = std::make_shared<TestUtils::ColumnDataOutVector<char, BranchReader>>(info.name, 0);
        else if (*info.type == typeid(std::uint16_t))
          myColumn = std::make_shared<TestUtils::ColumnDataOutVector<std::uint16_t, BranchReader>>(info.name, 0);
        else if (*info.type == typeid(std::uint64_t))
          myColumn = std::make_shared<TestUtils::ColumnDataOutVector<std::uint64_t, BranchReader>>(info.name, 0);
        else 
        {
          ANA_MSG_WARNING("unhandled column type: " << info.name << " "<< info.type->name());
          return false;
        }
      } else if (rntbackend) 
      {
        if (*info.type == typeid(float))
          myColumn = std::make_shared<TestUtils::ColumnDataOutVector<float, RNTFieldReader>>(info.name,0);
        else if (*info.type == typeid(char))
          myColumn = std::make_shared<TestUtils::ColumnDataOutVector<char, RNTFieldReader>>(info.name, 0);
        else if (*info.type == typeid(std::uint16_t))
          myColumn = std::make_shared<TestUtils::ColumnDataOutVector<std::uint16_t, RNTFieldReader>>(info.name, 0);
        else if (*info.type == typeid(std::uint64_t))
          myColumn = std::make_shared<TestUtils::ColumnDataOutVector<std::uint64_t, RNTFieldReader>>(info.name, 0);
        else 
        {
          ANA_MSG_WARNING("unhandled column type: " << info.name << " " << info.type->name());
          return false;
        }
      }
      knownColumns.push_back(myColumn);
      if (tree) {
        if (!myColumn->connect(tree, offsetColumns, requestedColumns)) 
        {
          ANA_MSG_WARNING("failed to connect dynamic output column: " << info.name);
          return false;
        }
      } else if (rntbackend) 
      {
        if (!myColumn->connect(rntbackend, offsetColumns, requestedColumns)) 
        {
          ANA_MSG_WARNING("failed to connect dynamic output column: " << info.name);
          return false;
        }
      }
      usedColumns.push_back(myColumn);
      return true;
    });
    if (!unclaimedColumns.empty()) 
    {
      std::string message = "columns not claimed:";
      for (auto& column : unclaimedColumns)
        message += " " + column;
      throw std::runtime_error(message);
    }
  }

setupKnownColumns()

void columnar::ColumnarPhysLiteTest::setupKnownColumns

(

std::span< const TestUtils::TestDefinition >

testDefinitions

)

Definition at line 2200 of file ColumnarPhysliteTest.cxx.

  {
    using namespace TestUtils;
 
    knownColumns.push_back (std::make_shared<ColumnDataEventCount> ());
 
    if (tree) 
    {
      tree->SetMakeClass(1);
      {
        std::unordered_map<std::string, TBranch*> branches;
        {
          TIter branchIter(tree->GetListOfBranches());
          TObject* obj = nullptr;
          while ((obj = branchIter())) 
          {
            TBranch* branch = nullptr;
            if ((branch = dynamic_cast<TBranch*>(obj))) 
            {
              branches.emplace(branch->GetName(), branch);
              TIter subBranchIter(branch->GetListOfBranches());
              while ((obj = subBranchIter())) 
              {
                if (auto subBranch = dynamic_cast<TBranch*>(obj))
                  branches.emplace(subBranch->GetName(), subBranch);
              }
            }
          }
        }
 
        for (const auto& [name, branch] : branches) 
        {
          if (name.find("AuxDyn.") != std::string::npos ||
               name.find("Aux.") != std::string::npos) 
          {
            TClass* branchClass = nullptr;
            EDataType branchType{};
            branch->GetExpectedType(branchClass, branchType);
            if (branchClass == nullptr) 
            {
              switch (branchType) 
              {
                case kInt_t:
                  knownColumns.push_back(std::make_shared<ColumnDataScalar<std::int32_t, BranchReader>>(branch->GetName()));
                  break;
                case kUInt_t:
                  knownColumns.push_back(std::make_shared<ColumnDataScalar<std::uint32_t, BranchReader>>(branch->GetName()));
                  break;
                case kULong_t:
                  knownColumns.push_back(std::make_shared<ColumnDataScalar<std::uint64_t, BranchReader>>(branch->GetName()));
                  break;
                case kULong64_t:
                  knownColumns.push_back(std::make_shared<ColumnDataScalar<std::uint64_t, BranchReader>>(branch->GetName()));
                  break;
                case kFloat_t:
                  knownColumns.push_back(std::make_shared<ColumnDataScalar<float, BranchReader>>(branch->GetName()));
                  break;
                default:
                  // no-op
                  break;
              }
            } else 
            {
              if (*branchClass->GetTypeInfo() == typeid(std::vector<float>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<float,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<char>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<char,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int8_t>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<std::int8_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint8_t>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint8_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int16_t>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<std::int16_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint16_t>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint16_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int32_t>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<std::int32_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint32_t>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint32_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int64_t>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<std::int64_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint64_t>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint64_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<float>>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::int32_t>>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVectorVector<std::int32_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::uint64_t>>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVectorVector<std::uint64_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::vector<std::size_t>>>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVector<std::size_t,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::vector<unsigned char>>>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVector<unsigned char,BranchReader>> (branch->GetName()));
              } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::string>))
              {
                knownColumns.push_back (std::make_shared<ColumnDataMetNames<BranchReader>> (branch->GetName()));
              }
            }
          }
        }  
      }
      // This is a fallback for the case that we don't have an explicit
      // `samplingPattern` branch in our input file (i.e. an older file),
      // to allow us to still test tools needing it.  This is likely not
      // something that actual users can do (they need the new files), but
      // for testing it seems like a reasonable workaround.
      knownColumns.push_back(std::make_shared<ColumnDataSamplingPattern<BranchReader>>("egammaClusters"));
 
      // For branches that are element links they need to be explicitly
      // declared to have the correct xAOD type, correct split setting,
      // and correct linked containers.
      
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer,BranchReader>>("AnalysisElectronsAuxDyn.caloClusterLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::TrackParticleContainer, BranchReader>>("AnalysisElectronsAuxDyn.trackParticleLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer,BranchReader>>("AnalysisPhotonsAuxDyn.caloClusterLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::VertexContainer, BranchReader>>("AnalysisPhotonsAuxDyn.vertexLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorSplitLink<xAOD::TrackParticleContainer>>("AnalysisMuonsAuxDyn.inDetTrackParticleLink"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorSplitLink<xAOD::TrackParticleContainer>>("AnalysisMuonsAuxDyn.combinedTrackParticleLink"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorSplitLink<xAOD::TrackParticleContainer>>("AnalysisMuonsAuxDyn.extrapolatedMuonSpectrometerTrackParticleLink"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::TrackParticleContainer, BranchReader>>("GSFConversionVerticesAuxDyn.trackParticleLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorSplitLink<xAOD::TrackParticleContainer>>("GSFTrackParticlesAuxDyn.originalTrackParticle"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorVariantLink<xAOD::IParticleContainer, BranchReader>>("AnalysisJetsAuxDyn.GhostTrack"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorLink<xAOD::JetContainer, BranchReader>>("METAssoc_AnalysisMETAux.jetLink"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorVariantLink<xAOD::IParticleContainer, BranchReader>>("METAssoc_AnalysisMETAux.objectLinks"));
      
    }else if (rntbackend) 
    {
      std::unordered_map<std::string, ROOT::DescriptorId_t> fields;
      {
       const auto& desc = rntreader->GetDescriptor();
 
       for (const auto& field : desc.GetTopLevelFields()) 
       {
          auto fieldName = field.GetFieldName();
          fields.emplace(desc.GetQualifiedFieldName(field.GetId()), field.GetId());
 
         std::vector<ROOT::DescriptorId_t> subFieldIds{field.GetId()};
         while (!subFieldIds.empty()) 
         {
           const auto parentId = subFieldIds.back();
           auto parentname=desc.GetQualifiedFieldName(parentId);
           subFieldIds.pop_back();
 
           for (const auto& subField : desc.GetFieldIterable(parentId)) 
           {
             auto subFieldName = desc.GetQualifiedFieldName(subField.GetId());
 
             fields.emplace(desc.GetQualifiedFieldName(subField.GetId()), subField.GetId());
 
             subFieldIds.push_back(subField.GetId());
           }
          }
        }
      }
 
      const auto& desc = rntreader->GetDescriptor();
      for (const auto& [name, fieldId] : fields) 
      {
        auto fieldName = desc.GetQualifiedFieldName(fieldId);
 
        if (name.find("AuxDyn:") != std::string::npos ||
          name.find("Aux:") != std::string::npos) 
        {
 
          const auto& fieldDesc = desc.GetFieldDescriptor(fieldId);
          const std::string typeName = desc.GetTypeNameForComparison(fieldDesc);
          if (typeName == "std::int32_t" || typeName == "int") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataScalar<std::int32_t, RNTFieldReader>>(name));
          } else if (typeName == "std::uint32_t" || typeName == "unsigned int") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataScalar<std::uint32_t, RNTFieldReader>>(name));
          } else if (typeName == "std::uint64_t" || typeName == "unsigned long" || typeName == "unsigned long long") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataScalar<std::uint64_t, RNTFieldReader>>(name));
          } else if (typeName == "float") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataScalar<float, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<float>") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataVector<float, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<char>") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataVector<char, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::int8_t>") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataVector<std::int8_t, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::uint8_t>") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataVector<std::uint8_t, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::int16_t>") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataVector<std::int16_t, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::uint16_t>") 
          {
            knownColumns.push_back(std::make_shared<ColumnDataVector<std::uint16_t, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::int32_t>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVector<std::int32_t, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::uint32_t>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVector<std::uint32_t, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::int64_t>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVector<std::int64_t, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::uint64_t>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVector<std::uint64_t, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::vector<float>>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVectorVector<float, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::vector<std::int32_t>>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVectorVector<std::int32_t, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::vector<std::uint64_t>>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVectorVector<std::uint64_t, RNTFieldReader>>(name));
          } else if (typeName =="std::vector<std::vector<std::vector<std::size_t>>>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVectorVectorVector<std::size_t, RNTFieldReader>>(name));
          }else if (typeName =="std::vector<std::vector<std::vector<std::uint64_t>>>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVectorVectorVector<std::uint64_t, RNTFieldReader>>(name));
          }else if (typeName =="std::vector<std::vector<std::vector<std::uint8_t>>>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVectorVectorVector<std::uint8_t, RNTFieldReader>>(name));
          } else if (typeName =="std::vector<std::vector<std::vector<unsigned char>>>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataVectorVectorVector<unsigned char, RNTFieldReader>>(name));
          } else if (typeName == "std::vector<std::string>") 
          {
             knownColumns.push_back(std::make_shared<ColumnDataMetNames<RNTFieldReader>>(name));
          }
        }
      }
      knownColumns.push_back(std::make_shared<ColumnDataSamplingPattern<RNTFieldReader>>("egammaClusters"));
 
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer,RNTFieldReader>>("AnalysisElectronsAuxDyn:caloClusterLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::TrackParticleContainer, RNTFieldReader>>("AnalysisElectronsAuxDyn:trackParticleLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer,RNTFieldReader>>("AnalysisPhotonsAuxDyn:caloClusterLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::VertexContainer, RNTFieldReader>>("AnalysisPhotonsAuxDyn:vertexLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorRLink<xAOD::TrackParticleContainer,RNTFieldReader>>("AnalysisMuonsAuxDyn:inDetTrackParticleLink"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorRLink<xAOD::TrackParticleContainer,RNTFieldReader>>("AnalysisMuonsAuxDyn:combinedTrackParticleLink"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorRLink< xAOD::TrackParticleContainer, RNTFieldReader>>("AnalysisMuonsAuxDyn:extrapolatedMuonSpectrometerTrackParticleLink"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorLink<xAOD::TrackParticleContainer, RNTFieldReader>>("GSFConversionVerticesAuxDyn:trackParticleLinks"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorRLink<xAOD::TrackParticleContainer,RNTFieldReader>>("GSFTrackParticlesAuxDyn:originalTrackParticle"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorVariantLink<xAOD::IParticleContainer, RNTFieldReader>>("AnalysisJetsAuxDyn:GhostTrack"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorLink<xAOD::JetContainer, RNTFieldReader>>("METAssoc_AnalysisMETAux:.jetLink"));
      knownColumns.push_back(std::make_shared<ColumnDataVectorVectorVariantLink<xAOD::IParticleContainer, RNTFieldReader>>("METAssoc_AnalysisMETAux:.objectLinks"));
 
    }
 
 
    // For METMaker we need to preplace all of the MET terms that we
    // expect to be used, that's what this line does.
    std::vector<std::string> allMetTermNames;
    for (const auto& td : testDefinitions)
    {
      for (const auto& name : td.metTermNames)
      {
        if (std::find (allMetTermNames.begin(), allMetTermNames.end(), name) == allMetTermNames.end())
          allMetTermNames.push_back (name);
      }
    }
   
 
    if (tree) 
    {
       if (!allMetTermNames.empty())
         knownColumns.push_back(std::make_shared<ColumnDataOutputMet<BranchReader>>("OutputMET",allMetTermNames));
 
      // For METMaker we need various extra columns to run. This may need
      // some work to avoid, but would likey be worth it.
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<std::uint16_t, BranchReader>>("AnalysisMuons.objectType", xAOD::Type::Muon));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<float, BranchReader>>("AnalysisMuons.m", ParticleConstants::muonMassInMeV));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<std::uint16_t, BranchReader>>("AnalysisJets.objectType", xAOD::Type::Jet));
 
      // These are columns that represent variables that are normally held
      // by METAssociationHelper, or alternatively are decorated on the
      // MET terms (even though they are per object).
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<float, BranchReader>>("AnalysisMuons.MetObjectWeight", 0));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<float, BranchReader>>("AnalysisJets.MetObjectWeight", 0));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<float, BranchReader>>("AnalysisJets.MetObjectWeightSoft", 0));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<MissingETBase::Types::bitmask_t,BranchReader>>("METAssoc_AnalysisMET.useObjectFlags", 0));
    } else if (rntbackend) 
    {
      if (!allMetTermNames.empty())
         knownColumns.push_back(std::make_shared<ColumnDataOutputMet<BranchReader>>("OutputMET",allMetTermNames));
 
      // For METMaker we need various extra columns to run. This may need
      // some work to avoid, but would likey be worth it.
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<std::uint16_t, RNTFieldReader>>("AnalysisMuons.objectType", xAOD::Type::Muon));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<float, RNTFieldReader>>("AnalysisMuons.m", ParticleConstants::muonMassInMeV));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<std::uint16_t, RNTFieldReader>>("AnalysisJets.objectType", xAOD::Type::Jet));
 
      // These are columns that represent variables that are normally held
      // by METAssociationHelper, or alternatively are decorated on the
      // MET terms (even though they are per object).
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<float, RNTFieldReader>>("AnalysisMuons.MetObjectWeight", 0));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<float, RNTFieldReader>>("AnalysisJets.MetObjectWeight", 0));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<float, RNTFieldReader>>("AnalysisJets.MetObjectWeightSoft", 0));
      knownColumns.push_back(std::make_shared<ColumnDataOutVector<MissingETBase::Types::bitmask_t,RNTFieldReader>>("METAssoc_AnalysisMET.useObjectFlags", 0));
    }
  }  // namespace columnar

Member Data Documentation

file

std::unique_ptr<TFile> columnar::ColumnarPhysLiteTest::file

Definition at line 44 of file ColumnarPhysliteTest.h.

inspector

std::unique_ptr<ROOT::Experimental::RNTupleInspector> columnar::ColumnarPhysLiteTest::inspector

Definition at line 47 of file ColumnarPhysliteTest.h.

knownColumns

std::vector<std::shared_ptr<TestUtils::IColumnData> > columnar::ColumnarPhysLiteTest::knownColumns

Definition at line 49 of file ColumnarPhysliteTest.h.

offsetColumns

std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*> columnar::ColumnarPhysLiteTest::offsetColumns

Definition at line 51 of file ColumnarPhysliteTest.h.

rntbackend

columnar::TestUtils::RNTupleBackend* columnar::ColumnarPhysLiteTest::rntbackend = nullptr

Definition at line 48 of file ColumnarPhysliteTest.h.

rntreader

std::unique_ptr<ROOT::RNTupleReader> columnar::ColumnarPhysLiteTest::rntreader

Definition at line 46 of file ColumnarPhysliteTest.h.

tree

TTree* columnar::ColumnarPhysLiteTest::tree = nullptr

Definition at line 45 of file ColumnarPhysliteTest.h.

usedColumns

std::vector<std::shared_ptr<TestUtils::IColumnData> > columnar::ColumnarPhysLiteTest::usedColumns

Definition at line 50 of file ColumnarPhysliteTest.h.

---

The documentation for this struct was generated from the following files:

• ColumnarPhysliteTest.h
• ColumnarPhysliteTest.cxx