TRlmdFile.cxx

Go to the documentation of this file.

#include <iostream>
#include <bitset>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <cerrno>
#include <cassert>
#include <cstdlib>
#include <locale>
#include <time.h>
 
#ifdef HAVE_ZLIB
#include <zlib.h>
#endif
 
#include "TString.h"
 
#include "TRlmdFile.h"
#include "TRlmdEvent.h"
#include "TRunInfo.h"
#include "THILDetectorInformation.h"
#include "THILMnemonic.h"
#include "HILDataVersion.h"
 
TRlmdFile::TRlmdFile(const char* filename, TRawFile::EOpenType open_type) : TRlmdFile()
{
   switch(open_type) {
   case TRawFile::EOpenType::kRead: Open(filename); break;
   case TRawFile::EOpenType::kWrite: break;
   }
}
 
TRlmdFile::~TRlmdFile()
{
   // Default dtor. It closes the read in lmd file as well as the output lmd file.
   Close();
}
 
std::string TRlmdFile::Status(bool)
{
   return Form(HIDE_CURSOR " Processed event, have processed %.2fMB/%.2f MB              " SHOW_CURSOR "\r",
               (fInputStream.tellg() / 1000000.0), (FileSize() / 1000000.0));
}
 
/// Open a lmd .lmd file with given file name.
///
/// Remote files can be accessed using these special file names:
/// - pipein://command - read data produced by given command, see examples below
/// - ssh://username\@hostname/path/file.mid - read remote file through an ssh pipe
/// - ssh://username\@hostname/path/file.mid.gz and file.mid.bz2 - same for compressed files
/// - dccp://path/file.mid (also file.mid.gz and file.mid.bz2) - read data from dcache, requires dccp in the PATH
///
/// Examples:
/// - ./event_dump.exe /ladd/data9/t2km11/data/run02696.mid.gz - read normal compressed file
/// - ./event_dump.exe ssh://ladd09//ladd/data9/t2km11/data/run02696.mid.gz - read compressed file through ssh to ladd09
/// (note double "/")
/// - ./event_dump.exe pipein://"cat /ladd/data9/t2km11/data/run02696.mid.gz | gzip -dc" - read data piped from a
/// command or script (note quotes)
/// - ./event_dump.exe pipein://"gzip -dc /ladd/data9/t2km11/data/run02696.mid.gz" - another way to read compressed
/// files
/// - ./event_dump.exe dccp:///pnfs/triumf.ca/data/t2km11/aug2008/run02837.mid.gz - read file directly from a dcache
/// pool (note triple "/")
///
/// \param[in] filename The file to open.
/// \returns "true" for succes, "false" for error, use GetLastError() to see why
bool TRlmdFile::Open(const char* filename)
{
   Filename(filename);
 
   try {
      fInputStream.open(GetFilename(), std::ifstream::in | std::ifstream::binary);
      fInputStream.seekg(0, std::ifstream::end);
      if(fInputStream.tellg() < 0) {
         std::cout << R"(Failed to open ")" << GetFilename() << "/" << Filename() << R"("!)" << std::endl;
         return false;
      }
      FileSize(fInputStream.tellg());
      fInputStream.seekg(0, std::ifstream::beg);
      //std::ofstream debugFile("debug.txt", std::ios::app);
      //debugFile<<"Total file size is "<<FileSize()<<" bytes"<<std::endl;
 
      // Read Header Information
      RlmdFileHeader header;
      fInputStream.read(reinterpret_cast<char*>(&header), sizeof(RlmdFileHeader));
 
      //debugFile<<"read header of size "<<sizeof(RlmdFileHeader)<<" bytes"<<std::endl;
      fStartDate = header.date;
      fStartDate = fStartDate.substr(0, 12);
      fStartTime = header.time;
      fStartTime = fStartTime.substr(0, 8);
      fTemplate  = header.templateName;
      fTemplate  = fTemplate.substr(0, 1480);
   } catch(std::exception& e) {
      std::cout << "Caught " << e.what() << " at " << __FILE__ << " : " << __LINE__ << std::endl;
   }
 
   // setup TChannel to use our mnemonics
   TChannel::SetMnemonicClass(THILMnemonic::Class());
 
   TRunInfo::SetRunInfo(GetRunNumber(), GetSubRunNumber());
   TRunInfo::SetRunLength(300);
   TRunInfo::ClearVersion();
   TRunInfo::SetVersion(HILDATA_RELEASE);
 
   BytesRead(fInputStream.tellg());
   std::cout << "Successfully read " << BytesRead() << " bytes of header with start date " << fStartDate << " " << fStartTime << " and template " << fTemplate << "!" << std::endl;
 
   THILDetectorInformation* detInfo = new THILDetectorInformation();
   TRunInfo::SetDetectorInformation(detInfo);
 
   return true;
}
 
void TRlmdFile::Close()
{
   fInputStream.close();
   BytesRead(FileSize());   // just to make sure we don't try to read more data after the file was closed
}
 
/// \param [in] Event Pointer to an empty TRlmdEvent
/// \returns "true" for success, "false" for failure, see GetLastError() to see why
///
///  EDITED FROM THE ORIGINAL TO RETURN TOTAL SUCESSFULLY BYTES READ INSTEAD OF TRUE/FALSE,  PCB
///
int TRlmdFile::Read(std::shared_ptr<TRawEvent> Event)
{
   if(Event == nullptr) return -1;
 
   size_t                      LastReadSize = 0;
   std::shared_ptr<TRlmdEvent> RlmdEvent    = std::static_pointer_cast<TRlmdEvent>(Event);
   RlmdEvent->Clear();
 
   if(BytesRead() < FileSize()) {
      //std::ofstream debugFile("debug.txt", std::ios::app);
      //debugFile<<std::hex;
      //debugFile<<"buffer 0x"<<fBuffersRead<<": starting to read at 0x"<<fInputStream.tellg()<<std::endl;
      // Read the buffer header
      fInputStream.read(reinterpret_cast<char*>(&fBufferHeader), sizeof(RlmdBufferHeader));
      LastReadSize += static_cast<size_t>(fInputStream.gcount());
 
      switch(fBufferHeader.type) {
      case 2:   // normal event so we read the buffer data into the event and send it on
         //debugFile<<"read buffer header of size 0x"<<sizeof(RlmdBufferHeader)<<", reading buffer of size 0x"<<2*fBufferHeader.dataLength<<" starting at 0x"<<fInputStream.tellg()<<std::endl;
         try {
            // the data length never changes, so this should only resize the vector once
            ResizeBuffer(2 * fBufferHeader.dataLength);   // 2* accounts for the size of uint16_t
            fInputStream.read(BufferData(), 2 * fBufferHeader.dataLength);
            LastReadSize += static_cast<size_t>(fInputStream.gcount());
            IncrementBytesRead(LastReadSize);
            //std::cout<<"Read normal buffer with "<<2*fBufferHeader.dataLength<<"/"<<LastReadSize<<" bytes, now at byte "<<BytesRead()<<std::endl;
            RlmdEvent->SetData(ReadBuffer());
            ++fBuffersRead;
         } catch(std::exception& e) {
            std::cout << "Caught " << e.what() << " at " << __FILE__ << " : " << __LINE__ << std::endl;
            return -1;
         }
         break;
      case 3:   // file footer so we "unread" the buffer header, read the footer and then close the file
         fInputStream.seekg(-sizeof(RlmdBufferHeader), std::ifstream::cur);
         RlmdFileFooter footer;
         //debugFile<<"tail buffer 0x"<<fBuffersRead<<": starting to read at 0x"<<fInputStream.tellg()<<std::endl;
         fInputStream.read(reinterpret_cast<char*>(&footer), sizeof(RlmdFileFooter));
         fStopDate = footer.date;
         fStopDate = fStopDate.substr(0, 12);
         fStopTime = footer.time;
         fStopTime = fStopTime.substr(0, 8);
         TRunInfo::SetRunStart(ConvertToEpoch(fStartDate, fStartTime));
         TRunInfo::SetRunStop(ConvertToEpoch(fStopDate, fStopTime));
         TRunInfo::SetRunLength();
         Close();
         LastReadSize = 0;   // setting this to zero as it doesn't matter in this case?
         break;
      default:
         std::cerr << "Unknown buffer type " << fBufferHeader.type << std::endl;
         break;
      }
   }
   return LastReadSize;
}
 
void TRlmdFile::Skip(size_t)
{
   // this might be wrong, in the case of the rlmd file we could check the data length from the buffer header, skip that far ahead
   // and read the next buffer header
   std::cerr << "Sorry, but we can't skip events in an RLMD file, the whole file is treated as a single event!" << std::endl;
   return;
}
 
int TRlmdFile::GetRunNumber()
{
   // Parse the run number from the current TRlmdFile. This assumes a format of
   // <name>###.rlmd.
   if(Filename().length() == 0) {
      return 0;
   }
   std::size_t found = Filename().rfind(".rlmd");
   if(found == std::string::npos) {
      return 0;
   }
   std::string temp;
   temp = Filename().substr(found - 3, 3);
   return atoi(temp.c_str());
}
 
int TRlmdFile::GetSubRunNumber()
{
   // There are no subruns in .lmd files
   return -1;
}
 
time_t TRlmdFile::ConvertToEpoch(const std::string& date, const std::string& time)
{
   std::stringstream str;
   str << date << time;
   std::tm t = {};
   str >> std::get_time(&t, "%d-%b-%Y %H:%M:S");
   return std::mktime(&t);
}
 
// end