framework::test::isGoodEventFile Class Reference

Checks: More...

Public Member Functions
	isGoodEventFile (const std::string &pass, const int &entries, const int &runs, bool existColl=true, bool existObj=true)
	Constructor.
bool	match (const std::string &filename) const override
	Actually do the matching.
virtual std::string	describe () const override
	Human-readable statement for any match that is true.

Private Attributes
std::string	pass_
	pass name to check the collection and/or object for
int	entries_
	correct number of entries in the event ttree
int	runs_
	correct number of runs
bool	existCollection_
	collection should exist in file
bool	existObject_
	object should exist in file

Detailed Description

Checks:

• Event File exists and is readable
• Has the LDMX_Events TTree
• Events tree has correct number of entries
• if existCollection: looks through collections on the event tree to make sure they have the same form as set by TestProducer
• if existObject: looks through objects on event tree to make sure they have the same form as set by TestProducer
• Has the LDMX_Run TTree
• Run tree has correct number of entries
• RunHeaders in RunTree have matching RunNumbers and EventCounts

Definition at line 235 of file FunctionalCoreTest.cxx.

Constructor & Destructor Documentation

isGoodEventFile()

framework::test::isGoodEventFile::isGoodEventFile ( const std::string &  pass, const int &  entries, const int &  runs, bool  existColl = true, bool  existObj = true  )

inline

Constructor.

Sets the correct number of entries and the other checking parameters

Definition at line 258 of file FunctionalCoreTest.cxx.

      : pass_(pass),
        entries_(entries),
        runs_(runs),
        existCollection_(existColl),
        existObject_(existObj) {}

Member Function Documentation

describe()

virtual std::string framework::test::isGoodEventFile::describe ( ) const

inlineoverridevirtual

Human-readable statement for any match that is true.

Definition at line 358 of file FunctionalCoreTest.cxx.

                                              {
    std::ostringstream ss;
    ss << "can be opened and has the correct number of entries in the event "
          "tree and the run tree.";
 
    ss << " TestCollection_" << pass_ << " was verified to ";
    if (existCollection_)
      ss << " be the correct pattern.";
    else
      ss << " not be in the file.";
 
    ss << " TestObject_" << pass_ << " was verified to ";
    if (existObject_)
      ss << " be the correct pattern.";
    else
      ss << " not be in the file.";
 
    return ss.str();
  }

References existCollection_, existObject_, and pass_.

match()

bool framework::test::isGoodEventFile::match ( const std::string &  filename ) const

inlineoverride

Actually do the matching.

The event and run tree names are hardcoded. The branchnames are also hardcoded.

Parameters

[in]

filename

name of event file to check

Definition at line 274 of file FunctionalCoreTest.cxx.

                                                       {
    TFile* f = TFile::Open(filename.c_str());
    if (!f) return false;
 
    TTreeReader events("LDMX_Events", f);
 
    if (events.GetEntries(true) != entries_) {
      f->Close();
      return false;
    }
 
    // Event tree should _always_ have the ldmx::EventHeader
    TTreeReaderValue<ldmx::EventHeader> header(events, "EventHeader");
 
    if (existCollection_) {
      // make sure collection matches pattern
      TTreeReaderValue<std::vector<ldmx::CalorimeterHit>> collection(
          events, ("TestCollection_" + pass_).c_str());
      while (events.Next()) {
        if (collection->size() != header->getEventNumber()) {
          f->Close();
          return false;
        }
        for (unsigned int i = 0; i < collection->size(); i++)
          if (collection->at(i).getID() != header->getEventNumber() * 10 + i) {
            f->Close();
            return false;
          }
      }
      // restart in case checking object as well
      events.Restart();
    } else {
      // check to make sure collection is NOT there
      auto t{(TTree*)f->Get("LDMX_Events")};
      if (t and t->GetBranch(("TestCollection_" + pass_).c_str())) {
        f->Close();
        return false;
      }
    }
 
    if (existObject_) {
      // make sure object matches pattern
      TTreeReaderValue<ldmx::HcalVetoResult> object(
          events, ("TestObject_" + pass_).c_str());
      while (events.Next()) {
        if (object->getMaxPEHit().getID() != header->getEventNumber()) {
          f->Close();
          return false;
        }
      }
    } else {
      // check to make sure object is NOT there
      auto t{(TTree*)f->Get("LDMX_Events")};
      if (t and t->GetBranch(("TestObject_" + pass_).c_str())) {
        f->Close();
        return false;
      }
    }
 
    TTreeReader runs("LDMX_Run", f);
 
    if (runs.GetEntries(true) != runs_) {
      f->Close();
      return false;
    }
 
    TTreeReaderValue<ldmx::RunHeader> runHeader(runs, "RunHeader");
 
    while (runs.Next()) {
      if (runHeader->getRunNumber() !=
          runHeader->getIntParameter("Should Be Run Number")) {
        f->Close();
        return false;
      }
    }
 
    f->Close();
 
    return true;
  }

References entries_, existCollection_, existObject_, pass_, and runs_.

Member Data Documentation

entries_

int framework::test::isGoodEventFile::entries_

private

correct number of entries in the event ttree

Definition at line 241 of file FunctionalCoreTest.cxx.

Referenced by match().

existCollection_

bool framework::test::isGoodEventFile::existCollection_

private

collection should exist in file

Definition at line 247 of file FunctionalCoreTest.cxx.

Referenced by describe(), and match().

existObject_

bool framework::test::isGoodEventFile::existObject_

private

object should exist in file

Definition at line 250 of file FunctionalCoreTest.cxx.

Referenced by describe(), and match().

pass_

std::string framework::test::isGoodEventFile::pass_

private

pass name to check the collection and/or object for

Definition at line 238 of file FunctionalCoreTest.cxx.

Referenced by describe(), and match().

runs_

int framework::test::isGoodEventFile::runs_

private

correct number of runs

Definition at line 244 of file FunctionalCoreTest.cxx.

Referenced by match().

---

The documentation for this class was generated from the following file:

• Framework/test/FunctionalCoreTest.cxx