FPGATrackSimInputHeaderTool Class Reference

#include <FPGATrackSimInputHeaderTool.h>

Inheritance diagram for FPGATrackSimInputHeaderTool:

Collaboration diagram for FPGATrackSimInputHeaderTool:

Public Member Functions
	FPGATrackSimInputHeaderTool (const std::string &, const std::string &, const IInterface *)
virtual	~FPGATrackSimInputHeaderTool ()=default
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	readData (FPGATrackSimEventInputHeader *header, bool &last) const override
virtual StatusCode	writeData (FPGATrackSimEventInputHeader *header) const override

Private Member Functions
StatusCode	openFile (std::string const &path) const

Private Attributes
StringArrayProperty	m_inpath {this, "InFileName", {"."}, "input file paths"}
StringProperty	m_rwoption {this, "RWstatus", std::string("READ"), "define read or write file option: READ, RECREATE, HEADER"}
std::atomic< unsigned >	m_event = 0
std::atomic< unsigned >	m_totevent = 0
std::atomic< unsigned >	m_file = 0
std::mutex	m_fileMutex
std::string	m_branchName

Detailed Description

Definition at line 22 of file FPGATrackSimInputHeaderTool.h.

Constructor & Destructor Documentation

FPGATrackSimInputHeaderTool()

FPGATrackSimInputHeaderTool::FPGATrackSimInputHeaderTool	(	const std::string &	algname,
		const std::string &	name,
		const IInterface *	ifc )

Definition at line 9 of file FPGATrackSimInputHeaderTool.cxx.

                                                                                                                               :
  base_class(algname,name,ifc)
{}

~FPGATrackSimInputHeaderTool()

virtual FPGATrackSimInputHeaderTool::~FPGATrackSimInputHeaderTool ( )

virtualdefault

Member Function Documentation

finalize()

StatusCode FPGATrackSimInputHeaderTool::finalize ( )

overridevirtual

Definition at line 92 of file FPGATrackSimInputHeaderTool.cxx.

                                                {
  ATH_MSG_INFO ( "finalize: closing files");
  if (m_rwoption.value()==std::string("RECREATE")){
    m_EventTree->Print();
     // close the output files, but check that it exists (for athenaMP)
    m_infile ->Write();
  }
  if (m_rwoption.value()!=std::string("HEADER"))
    m_infile ->Close();
 
  delete m_eventHeader;
  return StatusCode::SUCCESS;
}

initialize()

StatusCode FPGATrackSimInputHeaderTool::initialize ( )

overridevirtual

Definition at line 56 of file FPGATrackSimInputHeaderTool.cxx.

                                                  {
  
  m_eventHeader = new FPGATrackSimEventInputHeader();
  // set default name
  m_branchName="FPGATrackSimEventInputHeader";
 
   // open input file
  if( m_rwoption.value()!=std::string("HEADER"))
  {
    if (m_inpath.value().empty())
    {
        ATH_MSG_ERROR("Empty input file list");
        return StatusCode::FAILURE;
    }
    ATH_CHECK(openFile(m_inpath.value().front()));
  }
  if (m_rwoption.value()==std::string("READ") ) {
    ATH_MSG_DEBUG ("Initialized in READ MODE");
  }
  else if (m_rwoption.value()==std::string("RECREATE") || m_rwoption.value()==std::string("HEADER")) {
    ATH_MSG_INFO ("Creating empty brnaches in output file");
    m_EventTree = new TTree("FPGATrackSimEventTree","data");
    m_EventTree->Branch(m_branchName.c_str(),
            m_branchName.c_str(),// class name
            &m_eventHeader);
  }
  else {
    ATH_MSG_ERROR("RWstatus =" <<m_rwoption.value()<<" not allowed!");
    return StatusCode::FAILURE;
  }
  m_event=0; // in file
  m_totevent=0; // total counter
  return StatusCode::SUCCESS;
}

openFile()

StatusCode FPGATrackSimInputHeaderTool::openFile ( std::string const & path ) const

private

Definition at line 13 of file FPGATrackSimInputHeaderTool.cxx.

{
    // close old file
    if (m_infile && m_infile->IsOpen())
    {
        m_infile->Close();
        // I don't think we delete the pointer cause root handles that?
    }
 
    // open new file
    ATH_MSG_DEBUG ( "Opening file  "  << path << " in " <<  m_rwoption.value() <<" mode" );
    m_infile = TFile::Open(path.c_str(), m_rwoption.value().c_str());
 
    if (m_infile == nullptr)
    {
        ATH_MSG_FATAL("Could not open input file: " << path);
        return StatusCode::FAILURE;
    }
    if (m_rwoption.value()==std::string("READ") )
    {
       //get the tree, try the old name and also the new name for backwards compatability
      m_EventTree = (TTree*) m_infile->Get("FPGATrackSimEventTree");
 
      if (m_EventTree == nullptr || m_EventTree->GetEntries() == -1 ){
        ATH_MSG_FATAL ("Input file: " << path << " has no entries");
        return StatusCode::FAILURE;
      }
      ATH_MSG_INFO ( "Input file: " << path << " has "<< m_EventTree->GetEntries() <<" event entries" );
 
      if(!m_EventTree->GetListOfBranches()->FindObject(m_branchName.c_str())){
         ATH_MSG_FATAL ("Branch: " << m_branchName << " not found!");
         return StatusCode::FAILURE;
      }
      ATH_MSG_INFO ( "Getting branch and set EventHeader" );
      TBranch *branch  = m_EventTree->GetBranch(m_branchName.c_str());
      branch->SetAddress(&m_eventHeader);
    }
    m_event=0;
    return StatusCode::SUCCESS;
}

readData()

StatusCode FPGATrackSimInputHeaderTool::readData ( FPGATrackSimEventInputHeader * header, bool & last ) const

overridevirtual

Definition at line 126 of file FPGATrackSimInputHeaderTool.cxx.

{
  if (m_rwoption.value()!=std::string("READ") ){
    ATH_MSG_WARNING ("Asked to read file that is not in READ mode");
    return StatusCode::SUCCESS;
  }
 
  last=false;
 
  ATH_MSG_DEBUG ("Asked Event "<<m_event <<" in this file; current total is "<<m_totevent);
  if (m_event >= static_cast<unsigned>(m_EventTree->GetEntries()))
  {
    std::lock_guard<std::mutex> lock(m_fileMutex);
    if (m_event >= static_cast<unsigned>(m_EventTree->GetEntries()))
    {
        unsigned current_file = m_file++;
        if (current_file < m_inpath.value().size())
            ATH_CHECK(openFile(m_inpath.value().at(current_file)));
        else {
            last=true;
            return StatusCode::SUCCESS;
        }
    }
  }
 
  // Protect ROOT I/O with mutex
  {
    std::lock_guard<std::mutex> lock(m_fileMutex);
    m_EventTree->GetEntry(m_event);
  }
 
  // increase counters
  m_event++;
  m_totevent++;
 
  ATH_MSG_DEBUG("Reading event  "<<m_eventHeader->event() );
  *header= *m_eventHeader; //copy object to the external pointer
 
  return StatusCode::SUCCESS;
 
}

writeData()

StatusCode FPGATrackSimInputHeaderTool::writeData ( FPGATrackSimEventInputHeader * header ) const

overridevirtual

Definition at line 107 of file FPGATrackSimInputHeaderTool.cxx.

                                                                                            {
  if (m_rwoption.value()==std::string("READ") ){
   ATH_MSG_WARNING ("Asked to write file in READ  mode");
   return StatusCode::SUCCESS;
  }
 
  if (header != nullptr){
    *m_eventHeader= *header;//copy object
    m_EventTree->Fill();
    ATH_MSG_DEBUG ("Wrote Event "<<m_event <<" in header event "<<m_eventHeader->event() );
    m_event++;
  }
 
  // Do we need this? TODO
  //m_eventHeader->Clear(); //clean the pointer
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_branchName

std::string FPGATrackSimInputHeaderTool::m_branchName

private

Definition at line 44 of file FPGATrackSimInputHeaderTool.h.

m_event

std::atomic<unsigned> FPGATrackSimInputHeaderTool::m_event = 0

mutableprivate

Definition at line 39 of file FPGATrackSimInputHeaderTool.h.

m_file

std::atomic<unsigned> FPGATrackSimInputHeaderTool::m_file = 0

mutableprivate

Definition at line 41 of file FPGATrackSimInputHeaderTool.h.

m_fileMutex

std::mutex FPGATrackSimInputHeaderTool::m_fileMutex

mutableprivate

Definition at line 42 of file FPGATrackSimInputHeaderTool.h.

m_inpath

StringArrayProperty FPGATrackSimInputHeaderTool::m_inpath {this, "InFileName", {"."}, "input file paths"}

private

Definition at line 34 of file FPGATrackSimInputHeaderTool.h.

{this, "InFileName", {"."}, "input file paths"};

m_rwoption

StringProperty FPGATrackSimInputHeaderTool::m_rwoption {this, "RWstatus", std::string("READ"), "define read or write file option: READ, RECREATE, HEADER"}

private

Definition at line 35 of file FPGATrackSimInputHeaderTool.h.

{this, "RWstatus", std::string("READ"), "define read or write file option: READ, RECREATE, HEADER"};

m_totevent

std::atomic<unsigned> FPGATrackSimInputHeaderTool::m_totevent = 0

mutableprivate

Definition at line 40 of file FPGATrackSimInputHeaderTool.h.

---

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

• FPGATrackSimInputHeaderTool.h
• FPGATrackSimInputHeaderTool.cxx