CgemIndexFile.cxx

Go to the documentation of this file.

#include "RawFile/CgemIndexFile.h"
#include "RawFile/raw_ifstream.h"
#include "IRawFile/RawFileExceptions.h"
#include <filesystem>
#include <iostream>
 
CgemIndexFile::CgemIndexFile() {
  m_meta = new RawDataCache( kMaxNumFiles * sizeof( CgemSubFileMeta ) );
  m_data = new RawDataCache( 512 * 1024 );
}
 
CgemIndexFile::~CgemIndexFile() {
  this->close();
  delete m_meta;
  delete m_data;
}
 
bool CgemIndexFile::open4read( const std::string& file ) {
  if ( !std::filesystem::exists( file ) ) {
    std::cerr << "Error: CgemIndexFile can find " << file << std::endl;
    return false;
  }
 
  uint32_t fheader[8];
 
  m_fs.open( file.c_str(), std::ios::binary | std::ios::in );
  m_fs.read( reinterpret_cast<char*>(fheader), sizeof(uint32_t) * 8 );
 
  if (fheader[0] != kIndexFileMarker) {
    std::cerr << "Error: CgemIndexFile wrong header marker" << std::endl;
    return false;
  }
 
  m_numFiles = fheader[7];
 
  uint32_t metaSize = kMaxNumFiles * sizeof( CgemSubFileMeta );
  m_fs.read( m_meta->data<char>(), metaSize );
 
  m_subFiles.resize( m_numFiles, nullptr );
 
  return true;
}
 
bool CgemIndexFile::open4write( const std::string& file ) {
  if ( std::filesystem::exists( file ) ) {
    std::cerr << "Error: CgemIndexFile can not overwrite an exist file " << file << std::endl;
    return false;
  }
 
  m_fs.open( file.c_str(), std::ios::binary | std::ios::in | std::ios::out | std::ios::trunc );
  m_fs.write( reinterpret_cast<const char*>( &kIndexFileMarker ), sizeof( uint32_t ) );
  for ( int i = 0; i < 7; i++ ) {
    // six for the reserved bytes and one for the real numfiles
    m_fs.write( reinterpret_cast<const char*>( &m_numFiles ), sizeof( uint32_t ) );
  }
 
  auto _subfMeta = m_meta->data<CgemSubFileMeta>();
  for ( int i = 0; i < kMaxNumFiles; i++ ) {
    _subfMeta[i].lastL1id = 0;
    _subfMeta[i].pos       = 0;
  }
 
  uint32_t metaSize = kMaxNumFiles * sizeof( CgemSubFileMeta );
  m_fs.write( reinterpret_cast<char *>(_subfMeta), metaSize );
 
  if ( m_fs.good() ) {
    m_isWrite = true;
    m_subFile = new CgemSubFileContext;
    m_subFile->i_fidx->reserve<CgemEventIndex>( 1024 * 1024 );
  }
 
  return m_isWrite;
}
 
bool CgemIndexFile::append_from( const std::string& file ) {
  if ( m_numFiles+1 >= kMaxNumFiles ) {
    std::cerr << "Error: too many files, the supported max file number is " << kMaxNumFiles << std::endl;
    return false;
  }
 
  const uint32_t HeaderSize = 18;
  uint32_t evtHeader[HeaderSize];
  DataSeparatorRecord dsr;
 
  auto& _numEvents = m_subFile->i_numEvents;
  auto _fidx = m_subFile->i_fidx->data<CgemEventIndex>();
 
  _numEvents = 0;
  m_subFile->i_datafn = file;
  uint32_t maxNumEvents = m_subFile->i_fidx->capacity() / sizeof(CgemEventIndex);
 
  raw_ifstream ifs( std::vector<std::string>{ file } );
 
  while (true) {
    try {
      ifs >> dsr;
    }
    catch ( ReachEndOfFile& e ) {
      break;
    }
    catch ( ... ) {
      std::cerr << "Error: invalid data in file " << file << std::endl;
      return false;
    }
    ifs.read( reinterpret_cast<char*>( evtHeader ), HeaderSize * sizeof( uint32_t ) );
    ++_numEvents;
    if ( _numEvents > maxNumEvents ) {
      do {
        maxNumEvents *= 2;
      } while (_numEvents > maxNumEvents);
      _fidx = m_subFile->i_fidx->expand<CgemEventIndex>(maxNumEvents);
    }
    uint32_t dataSize = (evtHeader[1] - evtHeader[2]) * sizeof( uint32_t );
    auto _eidx = _fidx + _numEvents - 1;
    _eidx->l1id = evtHeader[10 + evtHeader[5]];
    _eidx->pos = ifs.tellg();
    _eidx->size = dataSize;
    ifs.seekg( dataSize, std::ios::cur );
  }
 
  auto _meta = m_meta->data<CgemSubFileMeta>();
  _meta[m_numFiles].lastL1id = _fidx[_numEvents-1].l1id;
  _meta[m_numFiles].pos = m_fs.tellp();
 
  m_fs.write(reinterpret_cast<const char*>(&kSubIndexFileMarker), sizeof(uint32_t));
  m_fs.write(reinterpret_cast<const char*>(&_numEvents), sizeof(uint32_t));
  m_fs << file << '\n';
  int sleft = 256 - sizeof(uint32_t) * 2 - 1 - file.size();
  for (int i = 0; i < sleft; ++i) {
      m_fs.put('Z');
  }
  m_fs.write(reinterpret_cast<char*>(_fidx), _numEvents * sizeof(CgemEventIndex));
 
  ++m_numFiles;
  std::cout << "CgemIndexFile: total " << _numEvents << " events in file " << file << std::endl;
 
  return true;
}
 
void CgemIndexFile::close() {
  if ( m_isWrite ) {
    m_fs.seekp( 7 * sizeof(uint32_t) );
    m_fs.write(reinterpret_cast<char*>(&m_numFiles), sizeof(uint32_t));
    uint32_t metaSize = kMaxNumFiles * sizeof( CgemSubFileMeta );
    m_fs.write(m_meta->data<char>(), metaSize);
    delete m_subFile;
    m_isWrite = false;
  }
  else {
    for ( auto& f : m_subFiles ) {
      delete f;
    }
    m_subFiles.clear();
  }
  m_numFiles  = 0;
  m_subFile   = nullptr;
  m_fs.close();
}
 
void CgemIndexFile::show() {
  if ( m_numFiles != 0 ) {
    std::cout << "CgemIndexFile: " << m_numFiles << " SubFiles" << std::endl;
    auto _meta = m_meta->data<CgemSubFileMeta>();
    for ( uint32_t i = 0; i < m_numFiles; ++i ) {
      std::cout << "    SubFile " << std::setw( 3 ) << i << ": lastL1ID " << _meta[i].lastL1id << std::endl;
    }
  }
}
 
void CgemIndexFile::showSubFile() {
  auto& _numEvents = m_subFile->i_numEvents;
  std::cout << "Related Data File: " << m_subFile->i_datafn
            << "\nNumber of Events: " << _numEvents << std::endl;
 
  if (_numEvents > 10) {
    showSubFileRange(0, 3);
    std::cout << "              ..." << std::endl;
    showSubFileRange(_numEvents - 3, _numEvents);
  }
  else {
    showSubFileRange(0, _numEvents);
  }
}
 
void CgemIndexFile::showSubFileRange( const uint32_t start, const uint32_t end )
{
  if ( end > m_subFile->i_numEvents ) {
    std::cerr << "Error: CgemIndexFile exceeds the max event number " << m_subFile->i_numEvents << std::endl;
    return;
  }
 
  auto _fidx = m_subFile->i_fidx->data<CgemEventIndex>();
  for (uint32_t i = start; i < end; ++i) {
    std::cout << std::setw( 12 ) << i << ": L1ID" << std::setw( 12 ) << _fidx[i].l1id
              << "   Pos" << std::setw( 12 ) << _fidx[i].pos << "   Size " << _fidx[i].size << std::endl;
  }
}
 
bool CgemIndexFile::loadSubFile(const uint32_t n) {
 
  if ( n < m_numFiles ) {
    if ( m_subFiles[n] != nullptr ) {
      m_subFile = m_subFiles[n];
      return true;
    }
    m_subFiles[n] = new CgemSubFileContext();
    m_subFile = m_subFiles[n];
    auto _meta = m_meta->data<CgemSubFileMeta>();
    m_fs.seekg(_meta[n].pos);
 
    uint32_t subFileMeta[2];
    m_fs.read( reinterpret_cast<char*>(subFileMeta), sizeof(uint32_t) * 2 );
    if (subFileMeta[0] == kSubIndexFileMarker) {
      m_fs >> m_subFile->i_datafn;
      if ( std::filesystem::exists( m_subFile->i_datafn ) ) {
        m_subFile->i_numEvents = subFileMeta[1];
        m_fs.seekg( _meta[n].pos + 256 );
        m_subFile->i_fidx->reserve<CgemEventIndex>(m_subFile->i_numEvents);
        m_fs.read( m_subFile->i_fidx->data<char>(), m_subFile->i_numEvents * sizeof( CgemEventIndex ) );
        return m_fs.good();
      }
      else {
        std::cerr << "Error: CgemIndexFile can not find data file " << m_subFile->i_datafn << std::endl;
      }
    }
    else {
      std::cerr << "Error: CgemIndexFile wrong SubFile marker" << std::endl;
    }
  }
  else {
    std::cerr << "Error: CgemIndexFile exceeds the max SubFile number " << m_numFiles << std::endl;
  }
 
  return false;
}
 
uint32_t* CgemIndexFile::getCgemData( const uint32_t l1id ) {
  uint32_t* _noCGEM = m_data->data<uint32_t>();
  _noCGEM[1] = 0;  // set the data size to 0, so that it will effectively be ignored
 
  auto _idx = ( m_subFile != nullptr ) ? m_subFile->i_fidx->data<CgemEventIndex>() : nullptr;
  if ( _idx == nullptr || _idx[0].l1id > l1id || _idx[m_subFile->i_numEvents - 1].l1id < l1id ) {
    auto _meta = m_meta->data<CgemSubFileMeta>();
    int _n = 0;
    while ( _meta[_n].lastL1id < l1id ) {
      if ( ++_n >= m_numFiles ) {
        std::cerr << "Warning: CgemIndexFile can not find the index for L1ID+ " << l1id << std::endl;
        return _noCGEM;
      }
    }
    if ( !loadSubFile( _n ) ) { return _noCGEM; }
    if ( !m_subFile->i_datafs.is_open() ) {
      m_subFile->i_datafs.open( m_subFile->i_datafn.c_str(), std::ios::binary );
    }
    _idx = m_subFile->i_fidx->data<CgemEventIndex>();
  }
 
  uint32_t ii = l1id - _idx[0].l1id;
  // while ( _idx[ii].l1id != l1id && ii != 0) --ii; // there exists lost trigger in CGEM data
 
  if ( _idx[ii].l1id == l1id ) {
    auto _cache = m_data->reserve<char>( _idx[ii].size );
    m_subFile->i_datafs.seekg( _idx[ii].pos );
    m_subFile->i_datafs.read( _cache, _idx[ii].size );
    uint32_t* _data = reinterpret_cast<uint32_t*>( _cache );
    if ( _data[0] == 0xbb1234bb ) {
      return _data;
    }
    else {
      std::cerr << "Error: CgemIndexFile wrong SubDetector marker" << std::endl;
    }
  }
  else {
    std::cerr << "Warning: CgemIndexFile can not find the index for L1ID- " << l1id << std::endl;
  }
 
  return _noCGEM;
}