hribf_buffers.h

Go to the documentation of this file.

#ifndef HRIBF_BUFFERS_H
#define HRIBF_BUFFERS_H

#include <fstream>
#include <vector>

#define HRIBF_BUFFERS_VERSION "1.3.00"
#define HRIBF_BUFFERS_DATE "Sept. 19th, 2016"

#define ACTUAL_BUFF_SIZE 8194 

class Client;

class BufferType{
  protected:
    unsigned int bufftype;
    unsigned int buffsize;
    unsigned int buffend;
    unsigned int zero;
    bool debug_mode;
    
    BufferType(unsigned int bufftype_, unsigned int buffsize_, unsigned int buffend_=0xFFFFFFFF);
    
    virtual bool Write(std::ofstream *file_);

    virtual bool Read(std::ifstream *file_);
    
    virtual void Reset(){  }
    
  public:
    unsigned int GetBufferType(){ return bufftype; }
    
    unsigned int GetBufferSize(){ return buffsize; }
    
    unsigned int GetBufferEndFlag(){ return buffend; }
    
    bool DebugMode(){ return debug_mode; }
  
    void SetDebugMode(bool debug_=true){ debug_mode = debug_; }

    bool ReadHeader(std::ifstream *file_);
};

class PLD_header : public BufferType{
  private:
    unsigned int run_num; // Run number
    unsigned int max_spill_size; // Maximum size of spill in file (in words)
    float run_time; // Total length of run (time acquisition is running in seconds)
    char format[17]; // 'PIXIE LIST DATA ' (16 bytes)
    char facility[17]; // 'U OF TENNESSEE  ' (16 bytes)
    char start_date[25]; // Wed Feb 13 16:06:10 2013 (24 bytes)
    char end_date[25]; // Wed Feb 13 16:06:10 2013 (24 bytes)
    char *run_title; // Unlimited length

    time_t runStartTime;
    time_t runStopTime; 

  public:
    PLD_header();
    ~PLD_header();
    
    unsigned int GetBufferLength(); 
    
    char *GetFacility(){ return facility; }
    
    char *GetFormat(){ return format; }
        
    char *GetStartDate(){ return start_date; }
    
    char *GetEndDate(){ return end_date; }
    
    char *GetRunTitle(){ return run_title; }
        
    unsigned int GetRunNumber(){ return run_num; }
    
    unsigned int GetMaxSpillSize(){ return max_spill_size; }
    
    float GetRunTime(){ return run_time; }
        
    void SetStartDateTime();
    
    void SetEndDateTime();

    void SetFacility(std::string input_);
    
    void SetTitle(std::string input_);
    
    void SetRunNumber(unsigned int input_){ run_num = input_; }
    
    void SetMaxSpillSize(unsigned int max_spill_size_){ max_spill_size = max_spill_size_; }
    
    void SetRunTime(float time_){ run_time = time_; }
    
    virtual bool Write(std::ofstream *file_);

    virtual bool Read(std::ifstream *file_);

    virtual void Reset();
    
    void Print();
    
    void PrintDelimited(const char &delimiter_='\t');
};

class PLD_data : public BufferType{
  private:
    
  public:
    PLD_data(); 

    virtual bool Write(std::ofstream *file_, char *data_, unsigned int nWords_);
    
    virtual bool Read(std::ifstream *file_, char *data_, unsigned int &nBytes, unsigned int max_bytes_, bool dry_run_mode=false);

    virtual void Reset(){ }
};

/* The DIR buffer is written at the beginning of each .ldf file. When the file is ready
   to be closed, the data within the DIR buffer is re-written with run information. */
class DIR_buffer : public BufferType{
  private:
    unsigned int total_buff_size;
    unsigned int run_num;
    unsigned int unknown[3];
    
  public:
    DIR_buffer();
    
    unsigned int GetTotalBufferSize(){ return total_buff_size; }
    
    unsigned int GetRunNumber(){ return run_num; }
    
    void SetRunNumber(unsigned int input_){ run_num = input_; }
    
    /* DIR buffer (1 word buffer type, 1 word buffer size, 1 word for total buffer length,
       1 word for total number of buffers, 2 unknown words, 1 word for run number, 1 unknown word,
       and 8186 zeros) */
    virtual bool Write(std::ofstream *file_);

    virtual bool Read(std::ifstream *file_);

    virtual void Reset();
    
    void Print();
    
    void PrintDelimited(const char &delimiter_='\t');
};

/* The HEAD buffer is written after the DIR buffer for each .ldf file. HEAD contains information
   about the run including the date/time, the title, and the run number. */
class HEAD_buffer : public BufferType{
  private:
    char facility[9];
    char format[9];
    char type[17];
    char date[17];
    char run_title[81];
    unsigned int run_num;

  public:
    HEAD_buffer();
        
    char *GetFacility(){ return facility; }
    
    char *GetFormat(){ return format; }
        
    char *GetType(){ return type; }
    
    char *GetDate(){ return date; }
    
    char *GetRunTitle(){ return run_title; }
        
    unsigned int GetRunNumber(){ return run_num; }
        
    bool SetDateTime();
    
    bool SetTitle(std::string input_);
    
    void SetRunNumber(unsigned int input_){ run_num = input_; }

    virtual bool Write(std::ofstream *file_);

    virtual bool Read(std::ifstream *file_);

    virtual void Reset();
    
    void Print();
    
    void PrintDelimited(const char &delimiter_='\t');
};

class DATA_buffer : public BufferType{
  private:
    int retval; 

    unsigned int buffer1[ACTUAL_BUFF_SIZE]; 
    unsigned int buffer2[ACTUAL_BUFF_SIZE]; 

    unsigned int *curr_buffer; 
    unsigned int *next_buffer; 
    
    unsigned int bcount; 
    unsigned int buff_head; 
    unsigned int buff_size; 
    unsigned int good_chunks; 
    unsigned int missing_chunks; 

    unsigned int buff_pos; 

    bool open_(std::ofstream *file_);

    bool read_next_buffer(std::ifstream *f_, bool force_=false);
    
  public:
    DATA_buffer(); 

    bool Close(std::ofstream *file_);

    int GetSpillSize(std::ifstream *file_);

    int GetRetval(){ return retval; }
    
    unsigned int GetNumChunks(){ return good_chunks; }
    
    unsigned int GetNumMissing(){ return missing_chunks; }
    
    virtual bool Write(std::ofstream *file_, char *data_, unsigned int nWords_, int &buffs_written);
    
    virtual bool Read(std::ifstream *file_, char *data_, unsigned int &nBytes_, unsigned int max_bytes_, bool &full_spill, bool &bad_spill, bool dry_run_mode=false);

    virtual void Reset();
};

class EOF_buffer : public BufferType{   
  public:
    EOF_buffer(); 
    
    virtual bool Write(std::ofstream *file_);

    virtual bool Read(std::ifstream *file_);
    
    virtual void Reset(){ }
};

class PollOutputFile{
  private:
    std::ofstream output_file;
    std::string fname_prefix;
    std::string current_filename;
    std::string current_full_filename;
    PLD_header pldHead;
    PLD_data pldData;
    DIR_buffer dirBuff;
    HEAD_buffer headBuff;
    DATA_buffer dataBuff;
    EOF_buffer eofBuff;
    unsigned int max_spill_size;
    unsigned int current_file_num;
    unsigned int output_format;
    unsigned int number_spills;
    unsigned int run_num;
    bool debug_mode;
    
    unsigned int current_depth;
    std::string current_directory;
    std::vector<std::string> directories;

    std::string get_filename();
    
    bool get_full_filename(std::string &output);

    bool overwrite_dir(int total_buffers_=-1);

    void initialize();

  public:
    PollOutputFile();

    PollOutputFile(std::string filename_);
    
    ~PollOutputFile(){ CloseFile(); }
    
    std::streampos GetFilesize(){ return output_file.tellp(); }
    
    std::string GetCurrentFilename(){ return current_filename; }
    
    unsigned int GetNumberSpills(){ return number_spills; }

    PLD_header *GetPLDheader(){ return &pldHead; }

    PLD_data *GetPLDdata(){ return &pldData; }
    
    DIR_buffer *GetDIRbuffer(){ return &dirBuff; }
    
    HEAD_buffer *GetHEADbuffer(){ return &headBuff; }

    DATA_buffer *GetDATAbuffer(){ return &dataBuff; }
    
    EOF_buffer *GetEOFbuffer(){ return &eofBuff; }
    
    void SetDebugMode(bool debug_=true);
    
    bool SetFileFormat(unsigned int format_);

    void SetFilenamePrefix(std::string filename_);

    bool IsOpen(){ return (output_file.is_open() && output_file.good()); }
    
    int Write(char *data_, unsigned int nWords_);

    int SendPacket(Client *cli_);

    bool OpenNewFile(std::string title_, unsigned int &run_num_, std::string prefix, std::string output_dir="./", bool continueRun = false);

    std::string GetNextFileName(unsigned int &run_num_, std::string prefix, std::string output_dir, bool continueRun = false);
    
    unsigned int GetRunNumber();

    void CloseFile(float total_run_time_=0.0);
};

#endif