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 (const TestUtils::TestDefinition &testDefinition)
void	setupColumns (ToolColumnVectorMap &toolWrapper)
void	doCall (const TestUtils::TestDefinition &testDefinition)

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::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 36 of file ColumnarPhysliteTest.h.

Constructor & Destructor Documentation

ColumnarPhysLiteTest()

columnar::ColumnarPhysLiteTest::ColumnarPhysLiteTest

(

)

Definition at line 1752 of file ColumnarPhysliteTest.cxx.

  {
    static std::once_flag flag;
    std::call_once (flag, [] ()
    {
#ifdef XAOD_STANDALONE
      xAOD::Init().ignore();
#else
      POOL::Init();
#endif
    });
 
    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 tree");
  }

~ColumnarPhysLiteTest()

columnar::ColumnarPhysLiteTest::~ColumnarPhysLiteTest ( )

default

Member Function Documentation

checkMode()

bool columnar::ColumnarPhysLiteTest::checkMode ( )

static

check whether we have the right mode

Definition at line 1784 of file ColumnarPhysliteTest.cxx.

  {
    return true;
  }

doCall()

void columnar::ColumnarPhysLiteTest::doCall

(

const TestUtils::TestDefinition &

testDefinition

)

Definition at line 2021 of file ColumnarPhysliteTest.cxx.

  {
    using namespace asg::msgUserCode;
    auto userConfiguration = TestUtils::UserConfiguration::fromEnvironment();
 
    if (!testDefinition.sysName.empty())
    {
      auto *sysTool = dynamic_cast<CP::ISystematicsTool*>(testDefinition.tool);
      if (!sysTool)
        throw std::runtime_error ("tool does not support systematics");
      std::cout << "applying systematic variation: " << testDefinition.sysName << std::endl;
      if (sysTool->applySystematicVariation (CP::SystematicSet (testDefinition.sysName)).isFailure())
        throw std::runtime_error ("failed to apply systematic variation: " + testDefinition.sysName);
    }
    if constexpr (columnarAccessMode == 2)
    {
      auto *myTool = dynamic_cast<ColumnarTool<ColumnarModeArray>*>(testDefinition.tool);
      if (!testDefinition.containerRenames.empty())
        renameContainers (*myTool, testDefinition.containerRenames);
      ColumnVectorHeader columnHeader;
      ToolColumnVectorMap toolWrapper (columnHeader, *myTool);
 
      setupKnownColumns (testDefinition);
      setupColumns (toolWrapper);
 
      Benchmark benchmarkCall (testDefinition.name, userConfiguration.batchSize);
      Benchmark benchmarkCall2 (testDefinition.name + "(call2)", userConfiguration.batchSize);
      Benchmark benchmarkCheck (testDefinition.name + "(column check)", userConfiguration.batchSize);
      Benchmark benchmarkEmpty ("empty");
 
      const auto numberOfEvents = tree->GetEntries();
      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);
        TestUtils::ToolWrapperData toolColumnData (&columnData, &toolWrapper);
        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 (toolColumnData);
          benchmarkCheck.startTimer ();
          columnData.checkData ();
          benchmarkCheck.stopTimer ();
          benchmarkCall.startTimer ();
          columnData.callNoCheck (*myTool);
          benchmarkCall.stopTimer ();
          if (userConfiguration.runToolTwice)
          {
            benchmarkCall2.startTimer ();
            columnData.callNoCheck (*myTool);
            benchmarkCall2.stopTimer ();
          }
          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" << std::endl;
      benchmarkEmpty.setSilence();
      {
        std::vector<TestUtils::BranchPerfData> branchPerfData;
        TestUtils::BranchPerfData summary;
        summary.name = "total";
        summary.timeRead = 0;
        summary.timeUnpack = 0;
        summary.timeShallowCopy = 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.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 header = std::format ("{:{}} | read(ns) | unpack(ns) | size(B) | rate(MB/s) | compression | baskets | entries | null", "branch name", 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;
        toolPerfData.emplace_back ();
        toolPerfData.back().name = testDefinition.name;
        toolPerfData.back().timeCall = benchmarkCall.getEntryTime(emptyTime);
        if (userConfiguration.runToolTwice)
          toolPerfData.back().timeCall2 = benchmarkCall2.getEntryTime(emptyTime);
        toolPerfData.back().timeCheck = benchmarkCheck.getEntryTime(emptyTime);
        benchmarkCall.setSilence();
        benchmarkCall2.setSilence();
        benchmarkCheck.setSilence();
        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) | check(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 << "           |";
          if (data.timeCheck)
            std::cout << std::format ("{:>10.1f}", data.timeCheck.value());
          std::cout << std::endl;
        }
      }
    } else if constexpr (columnarAccessMode == 0)
    {
      // this test simply doesn't work in Athena
#ifdef XAOD_STANDALONE
      xAOD::TEvent event;
      xAOD::TStore store;
#else
      POOL::TEvent event;
#endif
      ANA_CHECK_THROW (event.readFrom (file.get()));
 
#ifdef XAOD_STANDALONE
      Benchmark benchmarkEmptyClear (testDefinition.name + " empty clear");
      Benchmark benchmarkCallClear (testDefinition.name + " call clear");
      Benchmark benchmarkPrepClear (testDefinition.name + " prep clear");
#endif
      Benchmark benchmarkRepeatCall (testDefinition.name + " repeat-call");
      Benchmark benchmarkCall (testDefinition.name + " call");
      Benchmark benchmarkCallCopyRecord (testDefinition.name + " call copy-record");
      Benchmark benchmarkCallRetrieve (testDefinition.name + " call retrieve");
      Benchmark benchmarkPrep (testDefinition.name + " prep");
      Benchmark benchmarkPrepCopyRecord (testDefinition.name + " prep copy-record");
      Benchmark benchmarkPrepRetrieve (testDefinition.name + " prep retrieve");
      Benchmark benchmarkGetEntry (testDefinition.name + " getEntry");
 
      const auto numberOfEvents = event.getEntries();
#ifdef XAOD_STANDALONE
      std::cout << "known container keys:" << std::endl;
      for (auto& [container, key] : columnar::TestUtils::knownKeys)
      {
        std::cout << std::format ("  {} -> 0x{:x}, 0x{:x} -> {}", container, event.getHash (container), key, event.getName (key)) << std::endl;
      }
#endif
      if (numberOfEvents == 0){
        throw std::runtime_error ("ColumnarPhysLiteTest: numberOfEvents == 0");
      }
      Long64_t entry = 0;
 
      // Instead of running for a fixed number of events, we run for a
      // fixed amount of time.  That is because individual tools can
      // vary wildly in how long they take to run, and we mostly want to
      // make sure that we ran the tool enough to get a precise
      // performance estimate.
      const auto startTime = std::chrono::high_resolution_clock::now();
      for (; (std::chrono::high_resolution_clock::now() - startTime) < userConfiguration.targetTime; ++entry)
      {
        benchmarkGetEntry.startTimer ();
        event.getEntry (entry % numberOfEvents);
        benchmarkGetEntry.stopTimer ();
        benchmarkPrepRetrieve.startTimer ();
        ASSERT_SUCCESS (testDefinition.xAODToolCaller->retrieve (*testDefinition.tool->evtStore()));
        benchmarkPrepRetrieve.stopTimer ();
        benchmarkPrepCopyRecord.startTimer ();
        static const std::string prepPostfix = "Prep";
        ASSERT_SUCCESS (testDefinition.xAODToolCaller->copyRecord (*testDefinition.tool->evtStore(), prepPostfix));
        benchmarkPrepCopyRecord.stopTimer ();
        benchmarkPrep.startTimer ();
        ASSERT_SUCCESS (testDefinition.xAODToolCaller->call ());
        benchmarkPrep.stopTimer ();
#ifdef XAOD_STANDALONE
        benchmarkPrepClear.startTimer ();
        store.clear ();
        benchmarkPrepClear.stopTimer ();
#endif
        benchmarkCallRetrieve.startTimer ();
        ASSERT_SUCCESS (testDefinition.xAODToolCaller->retrieve (*testDefinition.tool->evtStore()));
        benchmarkCallRetrieve.stopTimer ();
        benchmarkCallCopyRecord.startTimer ();
        static const std::string callPostfix = "Call";
        ASSERT_SUCCESS (testDefinition.xAODToolCaller->copyRecord (*testDefinition.tool->evtStore(), callPostfix));
        benchmarkCallCopyRecord.stopTimer ();
        benchmarkCall.startTimer ();
        ASSERT_SUCCESS (testDefinition.xAODToolCaller->call ());
        benchmarkCall.stopTimer ();
        if (userConfiguration.runToolTwice)
        {
          benchmarkRepeatCall.startTimer ();
          ASSERT_SUCCESS (testDefinition.xAODToolCaller->call ());
          benchmarkRepeatCall.stopTimer ();
        }
#ifdef XAOD_STANDALONE
        benchmarkCallClear.startTimer ();
        store.clear ();
        benchmarkCallClear.stopTimer ();
        benchmarkEmptyClear.startTimer ();
        store.clear ();
        benchmarkEmptyClear.stopTimer ();
#endif
      }
      std::cout << "Total entries read: " << entry << std::endl;
    } else if constexpr (columnarAccessMode == 100)
    {
      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 1778 of file ColumnarPhysliteTest.cxx.

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

setupColumns()

void columnar::ColumnarPhysLiteTest::setupColumns

(

ToolColumnVectorMap &

toolWrapper

)

Definition at line 1948 of file ColumnarPhysliteTest.cxx.

  {
    using namespace asg::msgUserCode;
 
    std::unordered_map<std::string,ColumnInfo> requestedColumns;
    for (auto& column : toolWrapper.getTool().getColumnInfo())
      requestedColumns[column.name] = std::move (column);
 
    for (auto& name : toolWrapper.getColumnNames())
      std::cout << "requested columns: " << name << std::endl;
 
    for (auto& column : knownColumns)
    {
      if (column->connect (tree, 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 (*info.type == typeid(float))
        myColumn = std::make_shared<TestUtils::ColumnDataOutVector<float>> (info.name, 0);
      else if (*info.type == typeid(char))
        myColumn = std::make_shared<TestUtils::ColumnDataOutVector<char>> (info.name, 0);
      else if (*info.type == typeid(std::uint16_t))
        myColumn = std::make_shared<TestUtils::ColumnDataOutVector<std::uint16_t>> (info.name, 0);
      else if (*info.type == typeid(std::uint64_t))
        myColumn = std::make_shared<TestUtils::ColumnDataOutVector<std::uint64_t>> (info.name, 0);
      else
      {
        ANA_MSG_WARNING ("unhandled column type: " << info.name << " " << info.type->name());
        return false;
      }
      knownColumns.push_back (myColumn);
      if (!myColumn->connect (tree, 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

(

const TestUtils::TestDefinition &

testDefinition

)

Definition at line 1790 of file ColumnarPhysliteTest.cxx.

  {
    using namespace TestUtils;
 
    knownColumns.push_back (std::make_shared<ColumnDataEventCount> ());
 
    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>> (branch->GetName()));
                break;
              case kUInt_t:
                knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint32_t>> (branch->GetName()));
                break;
              case kULong_t:
                knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint64_t>> (branch->GetName()));
                break;
              case kULong64_t:
                knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint64_t>> (branch->GetName()));
                break;
              case kFloat_t:
                knownColumns.push_back (std::make_shared<ColumnDataScalar<float>> (branch->GetName()));
                break;
              default:
                // no-op
                break;
            }
          } else
          {
            if (*branchClass->GetTypeInfo() == typeid(std::vector<float>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<float>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<char>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<char>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int8_t>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<std::int8_t>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint8_t>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint8_t>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int16_t>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<std::int16_t>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint16_t>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint16_t>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int32_t>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<std::int32_t>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint32_t>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint32_t>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int64_t>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<std::int64_t>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint64_t>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint64_t>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<float>>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::int32_t>>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVectorVector<std::int32_t>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::uint64_t>>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVectorVector<std::uint64_t>> (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>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::vector<unsigned char>>>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVector<unsigned char>> (branch->GetName()));
            } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::string>))
            {
              knownColumns.push_back (std::make_shared<ColumnDataMetNames> (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> ("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>> ("AnalysisElectronsAuxDyn.caloClusterLinks"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::TrackParticleContainer>> ("AnalysisElectronsAuxDyn.trackParticleLinks"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer>> ("AnalysisPhotonsAuxDyn.caloClusterLinks"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::VertexContainer>> ("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>> ("GSFConversionVerticesAuxDyn.trackParticleLinks"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorSplitLink<xAOD::TrackParticleContainer>> ("GSFTrackParticlesAuxDyn.originalTrackParticle"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVariantLink<xAOD::IParticleContainer>>("AnalysisJetsAuxDyn.GhostTrack"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorLink<xAOD::JetContainer>>("METAssoc_AnalysisMETAux.jetLink"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVariantLink<xAOD::IParticleContainer>>("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.
    if (!testDefinition.metTermNames.empty())
      knownColumns.push_back (std::make_shared<ColumnDataOutputMet> ("OutputMET", testDefinition.metTermNames));
 
    // 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>> ("AnalysisMuons.objectType", xAOD::Type::Muon));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.m", ParticleConstants::muonMassInMeV));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint16_t>> ("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>> ("AnalysisMuons.MetObjectWeight", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.MetObjectWeight", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.MetObjectWeightSoft", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<MissingETBase::Types::bitmask_t>> ("METAssoc_AnalysisMET.useObjectFlags", 0));
  }

Member Data Documentation

file

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

Definition at line 38 of file ColumnarPhysliteTest.h.

knownColumns

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

Definition at line 41 of file ColumnarPhysliteTest.h.

offsetColumns

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

Definition at line 43 of file ColumnarPhysliteTest.h.

tree

TTree* columnar::ColumnarPhysLiteTest::tree = nullptr

Definition at line 39 of file ColumnarPhysliteTest.h.

usedColumns

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

Definition at line 42 of file ColumnarPhysliteTest.h.

---

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

• ColumnarPhysliteTest.h
• ColumnarPhysliteTest.cxx