RawFileMerger.cxx

Go to the documentation of this file.

#include "RawFile/RawFileMerger.h"
#include <filesystem>
#include <memory>
#include <cstring>
 
RawFileMerger::RawFileMerger( const std::string& srcfile ) : m_srcfname( srcfile ) {
  m_srcfile = new RawDataMining( srcfile );
  m_fidx    = new CgemIndexFile();
  m_cache   = new RawDataCache( 1024 * 1024 );
}
 
RawFileMerger::~RawFileMerger() {
  delete m_cache;
  delete m_fidx;
  delete m_srcfile;
}
 
bool RawFileMerger::mergeWithIndexFile( const std::string& file ) {
  if ( !m_fidx->open4read( file ) ) {
    std::cerr << "Error: failed to open index file " << file << std::endl;
    return false;
  }
 
  if ( !openDestFile( m_fcount ) ) {
    std::cerr << "Error: failed to open destination file" << std::endl;
    return false;
  }
 
  uint32_t* srcEvt = m_srcfile->nextEvent();
 
  while ( srcEvt != nullptr ) {
    // check if the file is too large
    if ( m_fs.tellp() > 0xFFF00000 /* nearly to 4GB */ ) {
      m_fs << m_srcfile->fileEndRecord();
      m_fs.close();
      if ( !openDestFile( ++m_fcount ) ) return false;
    }
 
    // find and read the CGEM data
    uint32_t l1id = srcEvt[10 + srcEvt[5]] + 1;  // +1 to match with the CGEM L1ID
    uint32_t* cgemData     = m_fidx->getCgemData( l1id );
    if ( cgemData[1] != 0 ) {
      // merge the CGEM data to the original event
      uint32_t  sizeWords = srcEvt[1] + cgemData[1];
      uint32_t  sizeBytes = sizeWords * sizeof( uint32_t );
      uint32_t* destEvt   = m_cache->reserve<uint32_t>( sizeWords );
      auto      nptr      = mempcpy( destEvt, srcEvt, srcEvt[1] * sizeof( uint32_t ) );
      memcpy( nptr, cgemData, cgemData[1] * sizeof( uint32_t ) );
 
      destEvt[1]   = sizeWords;
      auto destDSR = m_srcfile->dataSeparatorRecord();
      destDSR.setDataBlockSize( sizeBytes );
 
      // write out the merged event
      m_fs << destDSR;
      m_fs.write( reinterpret_cast<const char*>( destEvt ), sizeBytes );
    }
    else {
      std::cout << "Warning: CGEM with L1ID " << l1id << " will be ignored!!!" << std::endl;
      ++m_ignored;
    }
 
    srcEvt = m_srcfile->nextEvent();
  }
 
  if ( m_srcfile->eof() ) {
    m_fs << m_srcfile->fileEndRecord();
  }
  m_fs.close();
 
  return true;
}
 
bool RawFileMerger::openDestFile( char fcount ) {
  auto fp = m_srcfname.rfind( "/" );
  std::string _srcfile = (fp != std::string::npos) ? m_srcfname.substr( fp+1 ) : m_srcfname;
 
  auto ip = _srcfile.rfind( "_file" );
  if ( ip == std::string::npos ) {
    std::cerr << "Error: nonstandard raw file name " << m_srcfname << std::endl;
    exit( 1 );
  }
 
  std::string destfname = m_destdir;
  if ( !destfname.empty() && destfname.back() != '/' ) {
    destfname += "/";
  }
  destfname += _srcfile.substr( 0, ip );
  destfname += "_merge";
  destfname += fcount;
  destfname += _srcfile.substr( ip );
 
  std::cout << "RawFileMerger: create new file " << destfname << std::endl;
  if ( std::filesystem::exists( destfname ) ) {
    std::cerr << "Error: file " << destfname << " already exists" << std::endl;
    return false;
  }
 
  m_fs.open( destfname, std::ios::out | std::ios::binary );
  if ( !m_fs.is_open() ) {
    std::cerr << "Error: cannot open file " << destfname << std::endl;
    return false;
  }
 
  m_fs << m_srcfile->fileStartRecord() << m_srcfile->fileNameStrings() << m_srcfile->runParametersRecord();
 
  return true;
}