BinaryFileReader.h

Go to the documentation of this file.

 
#ifndef PANDORA_BINARY_FILE_READER_H
#define PANDORA_BINARY_FILE_READER_H 1
 
#include "Pandora/Pandora.h"
 
#include "Objects/CartesianVector.h"
#include "Objects/TrackState.h"
 
#include "Persistency/FileReader.h"
 
#include <fstream>
 
namespace pandora
{
 
class BinaryFileReader : public FileReader
{
public:
    BinaryFileReader(const pandora::Pandora &pandora, const std::string &fileName);
 
    ~BinaryFileReader();
 
    template<typename T>
    StatusCode ReadVariable(T &t);
 
private:
    StatusCode ReadHeader();
    StatusCode GoToNextContainer();
    ContainerId GetNextContainerId();
    StatusCode GoToGeometry(const unsigned int geometryNumber);
    StatusCode GoToEvent(const unsigned int eventNumber);
    StatusCode ReadNextGeometryComponent();
    StatusCode ReadNextEventComponent();
 
    StatusCode ReadSubDetector(bool checkComponentId = true);
 
    StatusCode ReadLArTPC(bool checkComponentId = true);
 
    StatusCode ReadLineGap(bool checkComponentId = true);
 
    StatusCode ReadBoxGap(bool checkComponentId = true);
 
    StatusCode ReadConcentricGap(bool checkComponentId = true);
 
    StatusCode ReadCaloHit(bool checkComponentId = true);
 
    StatusCode ReadTrack(bool checkComponentId = true);
 
    StatusCode ReadMCParticle(bool checkComponentId = true);
 
    StatusCode ReadRelationship(bool checkComponentId = true);
 
    std::ifstream::pos_type         m_containerPosition;    
    std::ifstream::pos_type         m_containerSize;        
    std::ifstream                   m_fileStream;           
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template<typename T>
inline StatusCode BinaryFileReader::ReadVariable(T &t)
{
    char *const pMemBlock = new char[sizeof(T)];
    m_fileStream.read(pMemBlock, sizeof(T));
 
    t = *(reinterpret_cast<T*>(pMemBlock));
    delete[] pMemBlock;
 
    if (!m_fileStream.good())
        return STATUS_CODE_FAILURE;
 
    return STATUS_CODE_SUCCESS;
}
 
template<>
inline StatusCode BinaryFileReader::ReadVariable(std::string &t)
{
    unsigned int stringSize;
    const StatusCode statusCode(this->ReadVariable(stringSize));
 
    if (STATUS_CODE_SUCCESS != statusCode)
        return statusCode;
 
    char *const pMemBlock = new char[stringSize];
    m_fileStream.read(pMemBlock, stringSize);
 
    t = std::string(pMemBlock, stringSize);
    delete[] pMemBlock;
 
    if (!m_fileStream.good())
        return STATUS_CODE_FAILURE;
 
    return STATUS_CODE_SUCCESS;
}
 
template<>
inline StatusCode BinaryFileReader::ReadVariable(CartesianVector &t)
{
    float x, y, z;
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(x));
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(y));
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(z));
    t = CartesianVector(x, y, z);
 
    return STATUS_CODE_SUCCESS;
}
 
template<>
inline StatusCode BinaryFileReader::ReadVariable(TrackState &t)
{
    CartesianVector position(0.f, 0.f, 0.f), momentum(0.f, 0.f, 0.f);
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(position));
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(momentum));
    t = TrackState(position, momentum);
 
    return STATUS_CODE_SUCCESS;
}
 
} // namespace pandora
 
#endif // #ifndef PANDORA_BINARY_FILE_READER_H