framework::test::IsGoodEventFile Class Reference

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	exist_collection_
	collection should exist in file
bool	exist_object_
	object should exist in file

Detailed Description

Definition at line 265 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 288 of file FunctionalCoreTest.cxx.

      : pass_(pass),
        entries_(entries),
        runs_(runs),
        exist_collection_(existColl),
        exist_object_(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 388 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 (exist_collection_)
      ss << " be the correct pattern.";
    else
      ss << " not be in the file.";
 
    ss << " TestObject_" << pass_ << " was verified to ";
    if (exist_object_)
      ss << " be the correct pattern.";
    else
      ss << " not be in the file.";
 
    return ss.str();
  }

References exist_collection_, exist_object_, 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 304 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 (exist_collection_) {
      // 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 (exist_object_) {
      // 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> run_header(runs, "RunHeader");
 
    while (runs.Next()) {
      if (run_header->getRunNumber() !=
          run_header->getIntParameter("Should Be Run Number")) {
        f->Close();
        return false;
      }
    }
 
    f->Close();
 
    return true;
  }

References entries_, exist_collection_, exist_object_, pass_, and runs_.

Member Data Documentation

entries_

int framework::test::IsGoodEventFile::entries_

private

correct number of entries in the event ttree

Definition at line 271 of file FunctionalCoreTest.cxx.

Referenced by match().

exist_collection_

bool framework::test::IsGoodEventFile::exist_collection_

private

collection should exist in file

Definition at line 277 of file FunctionalCoreTest.cxx.

Referenced by describe(), and match().

exist_object_

bool framework::test::IsGoodEventFile::exist_object_

private

object should exist in file

Definition at line 280 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 268 of file FunctionalCoreTest.cxx.

Referenced by describe(), and match().

runs_

int framework::test::IsGoodEventFile::runs_

private

correct number of runs

Definition at line 274 of file FunctionalCoreTest.cxx.

Referenced by match().

---

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

• Framework/test/FunctionalCoreTest.cxx