Athena::RootConnection Class Reference

This class provides the implementation of Athena::RootConnection class, similar to Gaudi IDataConnection. More...

#include <RootConnection.h>

Collaboration diagram for Athena::RootConnection:

Public Member Functions
	RootConnection (const IInterface *own, const std::string &pfn)
	Standard constructor.
virtual	~RootConnection ()
	Standard destructor.
StatusCode	connectRead ()
	Open data stream in read mode.
StatusCode	connectWrite (const std::string &mode)
	Open data stream in write mode.
StatusCode	commit ()
	Commit data stream to ROOT.
StatusCode	disconnect ()
	Release data stream and release implementation dependent resources.
bool	isConnected () const
	Check if connected to data source.
StatusCode	read (void *const data, size_t len)
	Read root byte buffer from input stream.
StatusCode	write (const void *data, unsigned long &len)
	Write root byte buffer to output stream.
StatusCode	setContainer (const std::string &container, const std::string &type)
	Set the container name and type, creating TTree and TBranch as needed.

Private Attributes
std::string	m_fid
	File ID of the connection.
std::string	m_pfn
	Physical file name of the connection.
TFile *	m_file
	Age counter.
TTree *	m_tree
	Pointer to the main event data tree.
TBranch *	m_branch
	Pointer to the current data branch.
char	m_branchTypeCode
	Branch typecode for branch we are asked to write out.

Detailed Description

This class provides the implementation of Athena::RootConnection class, similar to Gaudi IDataConnection.

Definition at line 35 of file RootConnection.h.

Constructor & Destructor Documentation

RootConnection()

Athena::RootConnection::RootConnection	(	const IInterface *	own,
		const std::string &	pfn )

Standard constructor.

Definition at line 62 of file RootConnection.cxx.

                                                                        :
    m_fid(),
    m_pfn(pfn),
    m_file(0),
    m_tree(0),
    m_branch(0),
    m_branchTypeCode('\0') {
}

~RootConnection()

Athena::RootConnection::~RootConnection ( )

virtual

Standard destructor.

Definition at line 71 of file RootConnection.cxx.

                                {
}

Member Function Documentation

commit()

StatusCode Athena::RootConnection::commit

(

)

Commit data stream to ROOT.

Definition at line 96 of file RootConnection.cxx.

                                  {
  if (m_file == 0) {
    REPORT_MESSAGE (MSG::ERROR) << "commit: No file connected!";
    return StatusCode::FAILURE;
  }
  if (m_tree !=0 && m_branch != 0) {
    m_tree->SetEntries(m_branch->GetEntries());
  }
  //FIXME: call OptimizeBaskets()
  //m_tree->AutoSave();
  //m_tree->FlushBaskets();
  return StatusCode::SUCCESS;
}

connectRead()

StatusCode Athena::RootConnection::connectRead

(

)

Open data stream in read mode.

Definition at line 74 of file RootConnection.cxx.

                                       {
  if (m_file == 0) {
    m_file = TFile::Open(m_pfn.c_str());
  }
  if (m_file == 0 || m_file->IsZombie())   {
    delete m_file; m_file = 0;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

connectWrite()

StatusCode Athena::RootConnection::connectWrite

(

const std::string &

mode

)

Open data stream in write mode.

Definition at line 85 of file RootConnection.cxx.

                                                             {
  if (m_file == 0) {
    m_file = TFile::Open(m_pfn.c_str(), mode.c_str(), "AthenaRoot event data file");
  }
  if (m_file == 0 || m_file->IsZombie()) {
    delete m_file; m_file = 0;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

disconnect()

StatusCode Athena::RootConnection::disconnect

(

)

Release data stream and release implementation dependent resources.

Definition at line 110 of file RootConnection.cxx.

                                      {
  if (!this->commit().isSuccess()) {
    return StatusCode::FAILURE;
  }
  if (m_tree != 0 && m_file->IsWritable()) {
    m_file->cd("/");
    m_tree->Write(); m_tree = 0;
  }
  m_file->Close(); m_file = 0;
  return StatusCode::SUCCESS;
}

isConnected()

bool Athena::RootConnection::isConnected

(

)

const

Check if connected to data source.

Definition at line 122 of file RootConnection.cxx.

                                       {
   return false;
}

read()

StatusCode Athena::RootConnection::read	(	void *const	data,
		size_t	len )

Read root byte buffer from input stream.

Definition at line 126 of file RootConnection.cxx.

                                                       {
   return StatusCode::FAILURE;
}

setContainer()

StatusCode Athena::RootConnection::setContainer	(	const std::string &	container,
		const std::string &	type )

Set the container name and type, creating TTree and TBranch as needed.

Definition at line 148 of file RootConnection.cxx.

                                                                                         {
  if (m_file == 0) {
    return StatusCode::FAILURE;
  }
  std::string treeName(container), branchName;
  for (std::string::iterator itr = treeName.begin(), iend = treeName.end(); itr != iend; ++itr)    {
    if (*itr == '/') *itr = '_';
  }
  std::string::size_type inx1 = container.find('(');
  if (inx1 != std::string::npos) {
    std::string::size_type inx2 = container.find(')');
    if (inx2 == std::string::npos || inx2 != container.size() - 1) {
      return StatusCode::FAILURE;
    }
    branchName = treeName.substr(inx1 + 1, inx2 - inx1 - 1);
    treeName.resize(inx1);//inx1 was already checked
  }
  if (m_tree == 0) {
    m_tree = (TTree*)m_file->Get(treeName.c_str());
  }
  if (m_tree == 0 && m_file->IsWritable()) {
    int splitlevel = 0; //FIXME: Make configurable
    m_file->cd("/");
    m_tree = new TTree(treeName.c_str(), "Main event data tree", splitlevel);
    m_tree->SetDirectory(m_file);
    m_tree->Reset();
  }
  if (!m_tree)
    return StatusCode::FAILURE;
  m_branch = m_tree->GetBranch(branchName.c_str());
  RootType root_type = RootType::ByNameNoQuiet(type);
  m_branchTypeCode = ::typecode_from_typeid(root_type.TypeInfo());
  if (m_branch == 0 && m_file->IsWritable()) {
    int bufsize = 32000; //FIXME: Make configurable
    int splitlevel = 0; //FIXME: Make configurable
    if (m_branchTypeCode == '\0') {
      m_branch = m_tree->Bronch(branchName.c_str(),
                type.c_str(),
                0,
                bufsize,
                splitlevel);
    } else {
      m_branch = m_tree->Branch(branchName.c_str(),
                0,
                (branchName + "/" + m_branchTypeCode).c_str(),
                bufsize);
    }
    if (m_branch != 0) {
      // let the Athena framework deal with deletion
      m_branch->SetAutoDelete(kFALSE);
      int level = 1; //FIXME: Make configurable
      m_branch->SetCompressionLevel(level);
    }
  }
  if (m_branch == 0) {
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

write()

StatusCode Athena::RootConnection::write	(	const void *	data,
		unsigned long &	len )

Write root byte buffer to output stream.

Definition at line 130 of file RootConnection.cxx.

                                                                     {
  void* address ATLAS_THREAD_SAFE = const_cast<void*>(data);
  if (m_file == 0 || m_tree == 0 || m_branch == 0) {
    return StatusCode::FAILURE;
  }
  if (m_branchTypeCode == '\0') {
    m_branch->SetAddress(&address);
  } else {
    m_branch->SetAddress(address);
  }
  int32_t nbytes = m_branch->Fill();
  if (nbytes < 0) {
    return StatusCode::FAILURE;
  }
  len = m_branch->GetEntryNumber();
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_branch

TBranch* Athena::RootConnection::m_branch

private

Pointer to the current data branch.

Definition at line 82 of file RootConnection.h.

m_branchTypeCode

char Athena::RootConnection::m_branchTypeCode

private

Branch typecode for branch we are asked to write out.

Definition at line 84 of file RootConnection.h.

m_fid

std::string Athena::RootConnection::m_fid

private

File ID of the connection.

Definition at line 69 of file RootConnection.h.

m_file

TFile* Athena::RootConnection::m_file

private

Age counter.

Owner pointer Pointer to the Root event data file

Definition at line 78 of file RootConnection.h.

m_pfn

std::string Athena::RootConnection::m_pfn

private

Physical file name of the connection.

Definition at line 71 of file RootConnection.h.

m_tree

TTree* Athena::RootConnection::m_tree

private

Pointer to the main event data tree.

Definition at line 80 of file RootConnection.h.

---

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

• RootConnection.h
• RootConnection.cxx