readWD.hh

Go to the documentation of this file.

 
#ifndef READWD_H
#define READWD_H
 
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <numeric>
#include <algorithm>
#include <math.h>
#include <cstring>
 
#define SAMPLES_PER_WAVEFORM 1024 
 
/*
  ┌─────────────────────────────────────────────────────────────────────────┐
  │ CLASSES                                                                 │
  └─────────────────────────────────────────────────────────────────────────┘
 */
 
struct TAG
{
    TAG() { tag[4] = '\0'; }
    char tag[5]; 
};
 
struct EventHeader
{
    char tag[4];                
    unsigned int serialNumber;  
    unsigned short year;        
    unsigned short month;       
    unsigned short day;         
    unsigned short hour;        
    unsigned short min;         
    unsigned short sec;         
    unsigned short ms;          
    unsigned short rangeCenter; 
};
 
class DAQConfig;
class DAQEvent;
class DAQFile;
 
class DAQConfig
{
private:
    DAQConfig();
 
    void MakeConfig(DAQFile &);
    void ShowConfig();
 
    std::map<int, std::map<int, std::pair<int, int>>> intWindow_;   
    std::map<int, std::map<int, std::pair<int, int>>> pedInterval_; 
    std::map<int, std::map<int, float>> peakThr_;                   
    std::map<int, std::map<int, bool>> user_iw_;                    
 
    void SetIntWindow(std::pair<int, int>, int, int);
    void SetIntWindow(std::pair<int, int>);
    void SetPedInterval(std::pair<int, int>, int, int);
    void SetPedInterval(std::pair<int, int>);
    void SetPeakThr(float, int, int);
    void SetPeakThr(float);
 
    bool is_makeconfig_; 
 
    friend class DAQEvent;
    friend class DAQFile;
};
 
class DAQEvent
{
    using MAP = std::map<int, std::map<int, std::vector<float>>>; 
 
public:
    DAQEvent &GetChannel(const int &, const int &);
    void SetPedInterval(int, int);
    void SetPeakThr(float);
    void SetIntWindow(int, int);
    void SetIntWindow(float, float);
 
    void MakeConfig(DAQFile &file) { config_.MakeConfig(file); };
    void ShowConfig() { config_.ShowConfig(); };
 
    bool IsSaturated();
    float GetCharge();
    float GetAmplitude();
    float GetTime(float);
    float GetTimeCF(float);
    float GetRiseTime();
    const std::pair<float, float> &GetPedestal();
    const std::vector<float> &GetVolts();
    const std::vector<float> &GetTimes();
    const std::vector<int> &GetPeakIndices();
    const std::pair<int, int> &GetIntegrationBounds();
    const EventHeader &GetEH() { return eh_; };
 
    const MAP &GetVoltMap() { return volts_; };
    const MAP &GetTimeMap() { return times_; };
 
protected:
    DAQEvent();
 
    DAQEvent &TimeCalibration(const unsigned short &, const std::vector<float> &, int, int);
    DAQEvent &EvalPedestal();
    DAQEvent &EvalIntegrationBounds();
    DAQEvent &FindPeaks();
 
    MAP times_; 
    MAP volts_; 
 
    EventHeader eh_;
    DAQConfig config_; 
 
    std::pair<float, float> ped_;      
    std::pair<float, float> peak_;     
    std::pair<int, int> ped_interval_; 
    std::pair<int, int> iw_;           
    std::pair<int, int> ch_;           
    std::vector<int> indexMin_;        
 
    bool is_init_;         
    bool is_getch_;        
    bool is_iw_;           
    bool is_ped_;          
    bool is_peak_;         
    float peak_threshold_; 
 
    unsigned int evtserial_old_; 
    std::pair<int, int> ch_old_; 
    std::vector<bool> routine_;  
 
    friend class DAQFile;
};
 
class DRSEvent : public DAQEvent
{
public:
    DRSEvent();
    static const std::string type_;
};
 
class WDBEvent : public DAQEvent
{
public:
    WDBEvent();
    static const std::string type_;
};
 
class DAQFile
{
    using MAP = std::map<int, std::map<int, std::vector<float>>>; 
 
public:
    DAQFile();
    DAQFile(const std::string &);
    ~DAQFile() { in_.close(); }
 
    DAQFile &Close();
    DAQFile &Open(const std::string &);
    DAQFile &Reset();
 
    DAQFile &GetEvent(int);
 
    bool operator>>(DRSEvent &);
    bool operator>>(WDBEvent &);
 
    const MAP &GetTimeMap() { return times_; };
 
private:
    DAQFile &Initialise();
 
    bool operator>>(TAG &);
    bool operator>>(EventHeader &);
    operator bool();
    void Read(TAG &);
    void Read(EventHeader &);
    void Read(std::vector<float> &);
    void Read(std::vector<float> &, const unsigned short &);
    void ResetTag() { in_.seekg(-4, in_.cur); }
 
    std::string filename_; 
    std::ifstream in_;     
    char o_;               
    char n_;               
    bool initialization_;  
    MAP times_;            
    bool is_lab_;          
    std::string type_;     
    int first_evt_pos_;    
 
    friend class DAQConfig;
};
 
/*
  ┌─────────────────────────────────────────────────────────────────────────┐
  │ FUNCTIONS                                                               │
  └─────────────────────────────────────────────────────────────────────────┘
 */
 
std::ostream &operator<<(std::ostream &, const TAG &);
std::ostream &operator<<(std::ostream &, const EventHeader &);
 
#endif