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

Constructor & Destructor Documentation

ColumnarPhysLiteTest()

columnar::ColumnarPhysLiteTest::ColumnarPhysLiteTest

(

)

Definition at line 1794 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 1826 of file ColumnarPhysliteTest.cxx.

  {
    return true;
  }

doCall()

void columnar::ColumnarPhysLiteTest::doCall

(

const TestUtils::TestDefinition &

testDefinition

)

Definition at line 2073 of file ColumnarPhysliteTest.cxx.

  {
    doCallMulti ({testDefinition});
  }

doCallMulti()

void columnar::ColumnarPhysLiteTest::doCallMulti

(

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

testDefinitions

)

Definition at line 2078 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);
 
      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);
        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.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;
        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 1820 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 1999 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 (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

(

std::span< const TestUtils::TestDefinition >

testDefinitions

)

Definition at line 1832 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.
    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 (!allMetTermNames.empty())
      knownColumns.push_back (std::make_shared<ColumnDataOutputMet> ("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>> ("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 40 of file ColumnarPhysliteTest.h.

knownColumns

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

Definition at line 43 of file ColumnarPhysliteTest.h.

offsetColumns

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

Definition at line 45 of file ColumnarPhysliteTest.h.

tree

TTree* columnar::ColumnarPhysLiteTest::tree = nullptr

Definition at line 41 of file ColumnarPhysliteTest.h.

usedColumns

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

Definition at line 44 of file ColumnarPhysliteTest.h.

---

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

• ColumnarPhysliteTest.h
• ColumnarPhysliteTest.cxx