columnar::ColumnarPhysLiteTest Struct Reference

#include <ColumnarPhysliteTest.h>

Inheritance diagram for columnar::ColumnarPhysLiteTest:

Collaboration diagram for columnar::ColumnarPhysLiteTest:

Classes
struct	XAODArgs
	the arguments for the function calling in xAOD mode More...

Public Member Functions
	ColumnarPhysLiteTest ()
	~ColumnarPhysLiteTest ()
std::string	makeUniqueName ()
	make a unique tool name to be used in unit tests More...
void	setupKnownColumns ()
void	setupColumns (ColumnarToolWrapper &toolWrapper)
void	doCall (asg::AsgTool &tool, const std::string &name, const std::string &container, std::function< void(XAODArgs &)> callXAOD, const std::vector< std::pair< std::string, std::string >> &containerRenames, const std::string &sysName="")

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

Public Attributes
std::unique_ptr< TFile >	file
TTree *	tree = nullptr
std::vector< std::shared_ptr< PhysliteTestHelpers::IColumnData > >	knownColumns
std::vector< std::shared_ptr< PhysliteTestHelpers::IColumnData > >	usedColumns
std::unordered_map< std::string, const PhysliteTestHelpers::IColumnData * >	sizeColumns

Detailed Description

Definition at line 31 of file ColumnarPhysliteTest.h.

Constructor & Destructor Documentation

ColumnarPhysLiteTest()

columnar::ColumnarPhysLiteTest::ColumnarPhysLiteTest

(

)

Definition at line 458 of file ColumnarPhysliteTest.cxx.

  {
    static std::once_flag flag;
    std::call_once (flag, [] ()
    {
#ifdef XAOD_STANDALONE
      xAOD::Init().ignore();
 
      // Preload the component factories:  Alternately this could be
      // loaded and executed via a dictionary, but I had some technical
      // issue with that, and this seems to be working.
      CP::preloadComponentFactories();
#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");
 
    setupKnownColumns ();
  }

~ColumnarPhysLiteTest()

columnar::ColumnarPhysLiteTest::~ColumnarPhysLiteTest ( )

default

Member Function Documentation

checkMode()

bool columnar::ColumnarPhysLiteTest::checkMode ( )

static

check whether we have the right mode

Definition at line 497 of file ColumnarPhysliteTest.cxx.

  {
    return true;
  }

doCall()

void columnar::ColumnarPhysLiteTest::doCall	(	asg::AsgTool &	tool,
		const std::string &	name,
		const std::string &	container,
		std::function< void(XAODArgs &)>	callXAOD,
		const std::vector< std::pair< std::string, std::string >> &	containerRenames,
		const std::string &	sysName = ""
	)

Definition at line 626 of file ColumnarPhysliteTest.cxx.

  {
    using namespace asg::msgUserCode;
 
    if (!sysName.empty())
    {
      auto *sysTool = dynamic_cast<CP::ISystematicsTool*>(&tool);
      if (!sysTool)
        throw std::runtime_error ("tool does not support systematics");
      std::cout << "applying systematic variation: " << sysName << std::endl;
      if (sysTool->applySystematicVariation (CP::SystematicSet (sysName)).isFailure())
        throw std::runtime_error ("failed to apply systematic variation: " + sysName);
    }
    if constexpr (columnarAccessMode == 2)
    {
      auto *myTool = dynamic_cast<ColumnarTool<ColumnarModeArray>*>(&tool);
      if (!containerRenames.empty())
        renameContainers (*myTool, containerRenames);
      ColumnarToolWrapper toolWrapper (myTool);
      setupColumns (toolWrapper);
 
      Benchmark benchmark (name);
 
      const PhysliteTestHelpers::IColumnData *sizeColumn = nullptr;
      if (!container.empty())
      {
        auto iter = sizeColumns.find (container);
        if (iter == sizeColumns.end())
          throw std::runtime_error ("missing size column: " + container);
        sizeColumn = iter->second;
      }
 
      const auto numberOfEvents = tree->GetEntries();
      std::uint64_t totalSize = 0;
      Long64_t entry = 0;
      for (; benchmark.getTotalTime() < targetTime; ++entry)
      {
        ColumnarToolWrapperData columnData (&toolWrapper);
        for (auto& column : usedColumns)
          column->setData (columnData, entry % numberOfEvents);
        if (sizeColumn)
        {
          totalSize += sizeColumn->getSize();
          if (entry + 1 == numberOfEvents)
            std::cout << "average size: " << float (totalSize) / numberOfEvents << std::endl;
        }
        benchmark.startTimer ();
        columnData.call ();
        benchmark.stopTimer ();
      }
      std::cout << "Total entries read: " << entry << 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 (name + " empty clear");
      Benchmark benchmarkCallClear (name + " call clear");
      Benchmark benchmarkPrepClear (name + " prep clear");
#endif
      Benchmark benchmarkCall (name + " call");
      Benchmark benchmarkPrep (name + " prep");
      Benchmark benchmarkGetEntry (name + " getEntry");
 
      const auto numberOfEvents = event.getEntries();
      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.  As a fail-safe it also bounds the time
      // spend in i/o, which can be significant in Athena, but at a much
      // higher level.
      for (; benchmarkCall.getTotalTime() < targetTime && benchmarkPrep.getTotalTime() + benchmarkGetEntry.getTotalTime() < 20 * targetTime; ++entry)
      {
        benchmarkGetEntry.startTimer ();
        event.getEntry (entry % numberOfEvents);
        benchmarkGetEntry.stopTimer ();
        XAODArgs args;
        args.inputContainer = container;
        args.outputContainer = container + "Copy1";
        args.isPrepCall = true;
        benchmarkPrep.startTimer ();
        callXAOD (args);
        benchmarkPrep.stopTimer ();
        args.outputContainer = container + "Copy2";
        args.isPrepCall = false;
#ifdef XAOD_STANDALONE
        benchmarkPrepClear.startTimer ();
        store.clear ();
        benchmarkPrepClear.stopTimer ();
#endif
        benchmarkCall.startTimer ();
        callXAOD (args);
        benchmarkCall.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;
    }
  }

makeUniqueName()

std::string columnar::ColumnarPhysLiteTest::makeUniqueName

(

)

make a unique tool name to be used in unit tests

Definition at line 491 of file ColumnarPhysliteTest.cxx.

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

setupColumns()

void columnar::ColumnarPhysLiteTest::setupColumns

(

ColumnarToolWrapper &

toolWrapper

)

Definition at line 594 of file ColumnarPhysliteTest.cxx.

  {
    std::unordered_map<std::string,ColumnInfo> requestedColumns;
    for (auto& column : toolWrapper.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, sizeColumns, 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;
    }
    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

(

)

Definition at line 503 of file ColumnarPhysliteTest.cxx.

  {
    using namespace PhysliteTestHelpers;
 
    knownColumns.push_back (std::make_shared<ColumnDataEventCount> ());
    knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint32_t>> ("EventInfo.RandomRunNumber", "EventInfoAuxDyn.RandomRunNumber"));
    knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint64_t>> ("EventInfo.eventNumber", "EventInfoAuxDyn.eventNumber"));
    knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint32_t>> ("EventInfo.eventTypeBitmask", "EventInfoAuxDyn.eventTypeBitmask"));
    knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint32_t>> ("EventInfo.runNumber", "EventInfoAuxDyn.runNumber"));
    // knownColumns.push_back (std::make_shared<ColumnDataScalar<float>> ("EventInfo.NPV", "EventInfoAuxDyn.NPV"));
    knownColumns.push_back (std::make_shared<ColumnDataScalar<float>> ("EventInfo.averageInteractionsPerCrossing", "EventInfoAuxDyn.averageInteractionsPerCrossing"));
    // knownColumns.push_back (std::make_shared<ColumnDataScalar<int>> ("EventInfo.Njet", "EventInfoAuxDyn.Njet"));
 
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisElectrons.pt", "AnalysisElectronsAuxDyn.pt"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisElectrons.eta", "AnalysisElectronsAuxDyn.eta"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisElectrons.phi", "AnalysisElectronsAuxDyn.phi"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisElectrons.m", "AnalysisElectronsAuxDyn.m"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<uint16_t>> ("AnalysisElectrons.author", "AnalysisElectronsAuxDyn.author"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVector<ColumnarOffsetType>> ("AnalysisElectrons.caloClusterLinks.data", "AnalysisElectronsAuxDyn.caloClusterIndex"));
 
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisElectrons.ptOut", 0));
 
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisElectrons.sfOut", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<char>> ("AnalysisElectrons.validOut", 0));
 
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("egammaClusters.calE", "egammaClustersAuxDyn.calE"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("egammaClusters.calEta", "egammaClustersAuxDyn.calEta"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("egammaClusters.calPhi", "egammaClustersAuxDyn.calPhi"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("egammaClusters.ETACALOFRAME", "egammaClustersAuxDyn.ETACALOFRAME"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("egammaClusters.PHICALOFRAME", "egammaClustersAuxDyn.PHICALOFRAME"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<uint32_t>> ("egammaClusters.samplingPattern", "egammaClustersAuxDyn.samplingPattern"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> ("egammaClusters.e_sampl.data", "egammaClustersAuxDyn.e_sampl"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> ("egammaClusters.eta_sampl.data", "egammaClustersAuxDyn.eta_sampl"));
 
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisMuons.pt", "AnalysisMuonsAuxDyn.pt"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisMuons.eta", "AnalysisMuonsAuxDyn.eta"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisMuons.phi", "AnalysisMuonsAuxDyn.phi"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisMuons.charge", "AnalysisMuonsAuxDyn.charge"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint16_t>> ("AnalysisMuons.muonType", "AnalysisMuonsAuxDyn.muonType"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint16_t>> ("AnalysisMuons.author", "AnalysisMuonsAuxDyn.author"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<std::int32_t>> ("AnalysisMuons.resolutionCategory", "AnalysisMuonsAuxDyn.resolutionCategory"));
 
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.ptOut", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.chargeOut", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.InnerDetectorCharge", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.InnerDetectorPt", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.MuonSpectrometerCharge", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.MuonSpectrometerPt", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.sfOut", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<char>> ("AnalysisMuons.validOut", 0));
 
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisJets.pt", "AnalysisJetsAuxDyn.pt"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisJets.eta", "AnalysisJetsAuxDyn.eta"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisJets.phi", "AnalysisJetsAuxDyn.phi"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("AnalysisJets.m", "AnalysisJetsAuxDyn.m"));
    // knownColumns.push_back (std::make_shared<ColumnDataVector<char>> ("AnalysisJets.IsBjet", "AnalysisJetsAuxDyn.IsBjet"));
    // knownColumns.push_back (std::make_shared<ColumnDataVector<int>> ("AnalysisJets.R10TruthLabel_R21Consolidated", "AnalysisJetsAuxDyn.R10TruthLabel_R21Consolidated"));
 
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.ptOut", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.mOut", 0));
    knownColumns.push_back (std::make_shared<ColumnDataOutVector<char>> ("AnalysisJets.selection", 0));
 
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("InDetTrackParticles.d0", "InDetTrackParticlesAuxDyn.d0"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("InDetTrackParticles.phi", "InDetTrackParticlesAuxDyn.phi"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("InDetTrackParticles.qOverP", "InDetTrackParticlesAuxDyn.qOverP"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("InDetTrackParticles.theta", "InDetTrackParticlesAuxDyn.theta"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("InDetTrackParticles.z0", "InDetTrackParticlesAuxDyn.z0"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> ("InDetTrackParticles.definingParametersCovMatrixDiag.data", "InDetTrackParticlesAuxDyn.definingParametersCovMatrixDiag"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> ("InDetTrackParticles.definingParametersCovMatrixOffDiag.data", "InDetTrackParticlesAuxDyn.definingParametersCovMatrixOffDiag"));
 
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("CombinedMuonTrackParticles.d0", "CombinedMuonTrackParticlesAuxDyn.d0"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("CombinedMuonTrackParticles.phi", "CombinedMuonTrackParticlesAuxDyn.phi"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("CombinedMuonTrackParticles.qOverP", "CombinedMuonTrackParticlesAuxDyn.qOverP"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("CombinedMuonTrackParticles.theta", "CombinedMuonTrackParticlesAuxDyn.theta"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("CombinedMuonTrackParticles.z0", "CombinedMuonTrackParticlesAuxDyn.z0"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> ("CombinedMuonTrackParticles.definingParametersCovMatrixDiag.data", "CombinedMuonTrackParticlesAuxDyn.definingParametersCovMatrixDiag"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> ("CombinedMuonTrackParticles.definingParametersCovMatrixOffDiag.data", "CombinedMuonTrackParticlesAuxDyn.definingParametersCovMatrixOffDiag"));
 
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("ExtrapolatedMuonTrackParticles.d0", "ExtrapolatedMuonTrackParticlesAuxDyn.d0"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("ExtrapolatedMuonTrackParticles.phi", "ExtrapolatedMuonTrackParticlesAuxDyn.phi"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("ExtrapolatedMuonTrackParticles.qOverP", "ExtrapolatedMuonTrackParticlesAuxDyn.qOverP"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("ExtrapolatedMuonTrackParticles.theta", "ExtrapolatedMuonTrackParticlesAuxDyn.theta"));
    knownColumns.push_back (std::make_shared<ColumnDataVector<float>> ("ExtrapolatedMuonTrackParticles.z0", "ExtrapolatedMuonTrackParticlesAuxDyn.z0"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> ("ExtrapolatedMuonTrackParticles.definingParametersCovMatrixDiag.data", "ExtrapolatedMuonTrackParticlesAuxDyn.definingParametersCovMatrixDiag"));
    knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> ("ExtrapolatedMuonTrackParticles.definingParametersCovMatrixOffDiag.data", "ExtrapolatedMuonTrackParticlesAuxDyn.definingParametersCovMatrixOffDiag"));
 
    knownColumns.push_back (std::make_shared<ColumnDataSplitLink> ("AnalysisMuons.inDetTrackParticleLink", "AnalysisMuonsAuxDyn.inDetTrackParticleLink"));
    knownColumns.push_back (std::make_shared<ColumnDataSplitLink> ("AnalysisMuons.combinedTrackParticleLink", "AnalysisMuonsAuxDyn.combinedTrackParticleLink"));
    knownColumns.push_back (std::make_shared<ColumnDataSplitLink> ("AnalysisMuons.extrapolatedMuonSpectrometerTrackParticleLink", "AnalysisMuonsAuxDyn.extrapolatedMuonSpectrometerTrackParticleLink"));
  }

Member Data Documentation

file

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

Definition at line 33 of file ColumnarPhysliteTest.h.

knownColumns

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

Definition at line 36 of file ColumnarPhysliteTest.h.

sizeColumns

std::unordered_map<std::string,const PhysliteTestHelpers::IColumnData*> columnar::ColumnarPhysLiteTest::sizeColumns

Definition at line 38 of file ColumnarPhysliteTest.h.

tree

TTree* columnar::ColumnarPhysLiteTest::tree = nullptr

Definition at line 34 of file ColumnarPhysliteTest.h.

usedColumns

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

Definition at line 37 of file ColumnarPhysliteTest.h.

---

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

• ColumnarPhysliteTest.h
• ColumnarPhysliteTest.cxx