EventBuilder.hh

Go to the documentation of this file.

#ifndef __EVENTBUILDER_HH
#define __EVENTBUILDER_HH
 
#include <fstream>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <memory>
 
#include <TFile.h>
#include <TTree.h>
#include <TMath.h>
#include <TChain.h>
#include <TH1.h>
#include <TH2.h>
#include <TProfile.h>
#include <TVector2.h>
#include <TVector3.h>
#include <TGProgressBar.h>
#include <TSystem.h>
#include <TKey.h>
#include <TCanvas.h>
#include <TROOT.h>
 
// Settings header
#ifndef __SETTINGS_HH
# include "Settings.hh"
#endif
 
// Calibration header
#ifndef __CALIBRATION_HH
# include "Calibration.hh"
#endif
 
// Data packets header
#ifndef __DATAPACKETS_HH
# include "DataPackets.hh"
#endif
 
// Miniball Events tree
#ifndef __MINIBALLEVTS_HH
# include "MiniballEvts.hh"
#endif
 
 
 
class MiniballEventBuilder {
    
public:
 
    MiniballEventBuilder( std::shared_ptr<MiniballSettings> myset );
    ~MiniballEventBuilder() {};
 
    void    SetInputFile( std::string input_file_name );
    void    SetInputTree( TTree *user_tree );
    void    SetMBSInfoTree( TTree *user_tree );
    void    SetOutput( std::string output_file_name, bool cWrite = false );
    void    StartFile();    
    void    Initialise();   
    void    MakeEventHists();
    void    ResetHists();
    
    inline void AddCalibration( std::shared_ptr<MiniballCalibration> mycal ){
        cal = mycal;
        overwrite_cal = true;
    };
    inline void AddProgressBar( std::shared_ptr<TGProgressBar> myprog ){
        prog = myprog;
        _prog_ = true;
    };
 
    unsigned long   BuildEvents();
 
    // Resolve multiplicities and coincidences etc
    void GammaRayFinder();
    void ParticleFinder();
    void BeamDumpFinder();
    void SpedeFinder();
    void IonChamberFinder();
 
    inline TFile* GetFile(){ return output_file; };
    inline TTree* GetTree(){ return output_tree; };
    inline void CloseOutput(){
        std::cout << "Writing output file...\r";
        std::cout.flush();
        output_file->Write( nullptr, TObject::kOverwrite );
        std::cout << "Writing output file... Done!" << std::endl << std::endl;
        output_tree->ResetBranchAddresses();
        PurgeOutput();
        output_file->Close();
        input_tree->ResetBranchAddresses();
        mbsinfo_tree->ResetBranchAddresses();
        input_file->Close();
        delete in_data;
        delete mbs_info;
        log_file.close(); //?? to close or not to close?
    }; 
    inline void PurgeOutput(){
        input_tree->Reset();
        mbsinfo_tree->Reset();
        output_file->Purge(2);
    }
 
 
private:
    
    TFile *input_file;
    TTree *input_tree;
    TTree *mbsinfo_tree;
    MiniballDataPackets *in_data;
    MBSInfoPackets *mbs_info;
    std::shared_ptr<DgfData> dgf_data;
    std::shared_ptr<AdcData> adc_data;
    std::shared_ptr<FebexData> febex_data;
    std::shared_ptr<InfoData> info_data;
 
    TFile *output_file;
    TTree *output_tree;
    std::unique_ptr<MiniballEvts> write_evts;
    std::shared_ptr<GammaRayEvt> gamma_evt;
    std::shared_ptr<GammaRayAddbackEvt> gamma_ab_evt;
    std::shared_ptr<ParticleEvt> particle_evt;
    std::shared_ptr<SpedeEvt> spede_evt;
    std::shared_ptr<BeamDumpEvt> bd_evt;
    std::shared_ptr<IonChamberEvt> ic_evt;
 
    // Do calibration
    std::shared_ptr<MiniballCalibration> cal;
    bool overwrite_cal;
    
    // Settings file
    std::shared_ptr<MiniballSettings> set;
    
    // Progress bar
    bool _prog_;
    std::shared_ptr<TGProgressBar> prog;
    
    // Check if histograms are made
    bool hists_ready = false;
 
    // List of histograms for reset later
    TList *histlist;
 
    // Log file
    std::ofstream log_file; 
    
    // Flag to know we've opened a file on disk
    bool flag_input_file;
 
    // Build window which comes from the settings file
    long build_window;  
 
    // Flags
    bool flag_close_event;
    std::vector<std::vector<bool>> flag_pause, flag_resume;
    bool event_open;
 
    // Time variables
    long                time_diff;
    unsigned long long  time_prev, time_min, time_max, time_first;
    unsigned long long  ebis_time, ebis_prev;
    unsigned long long  t1_time, t1_prev;
    unsigned long long  sc_time, sc_prev;
    unsigned long long  laser_time;
    double pulser_f, ebis_f, t1_f, sc_f;
    double pulser_T, ebis_T, t1_T, sc_T;
    std::vector<unsigned long long>  pulser_time, pulser_prev;
    std::vector<std::vector<unsigned long long>> pause_time, resume_time;
    std::vector<std::vector<unsigned long long>> sync_time;
    std::vector<std::vector<unsigned long long>> febex_dead_time;
    std::vector<std::vector<unsigned long long>> febex_time_start, febex_time_stop;
    std::vector<std::vector<std::vector<unsigned long long>>> febex_time_ch;
 
    // Data variables - generic
    unsigned char       mysfp;          
    unsigned char       myboard;        
    unsigned char       mydgf;          
    unsigned char       myadc;          
    unsigned char       mych;           
    unsigned long long  mytime;         
    long                myhittime;      
    unsigned long long  myeventid;      
    unsigned long long  preveventid;    
    unsigned long long  myeventtime;    
    float               myenergy;       
    bool                mythres;        
    bool                mypileup;       
    bool                myclipped;      
    bool                mylaser;        
 
 
    // Miniball specific variables
    std::vector<float>                  mb_en_list;     
    std::vector<unsigned long long>     mb_ts_list;     
    std::vector<unsigned char>          mb_clu_list;    
    std::vector<unsigned char>          mb_cry_list;    
    std::vector<unsigned char>          mb_seg_list;    
 
    // CD detector specific variables
    std::vector<float>                  cd_en_list;     
    std::vector<unsigned long long>     cd_ts_list;     
    std::vector<unsigned char>          cd_det_list;    
    std::vector<unsigned char>          cd_sec_list;    
    std::vector<unsigned char>          cd_side_list;   
    std::vector<unsigned char>          cd_strip_list;  
 
    // PAD detector specific variables
    std::vector<float>                  pad_en_list;    
    std::vector<unsigned long long>     pad_ts_list;    
    std::vector<unsigned char>          pad_det_list;   
    std::vector<unsigned char>          pad_sec_list;   
 
    
    // Beam dump detector specific variables
    std::vector<float>                  bd_en_list;     
    std::vector<unsigned long long>     bd_ts_list;     
    std::vector<unsigned char>          bd_det_list;    
 
    // Spede detector specific variables
    std::vector<float>                  spede_en_list;      
    std::vector<unsigned long long>     spede_ts_list;      
    std::vector<unsigned char>          spede_seg_list;     
 
    // IonChamber detector specific variables
    std::vector<float>                  ic_en_list;     
    std::vector<unsigned long long>     ic_ts_list;     
    std::vector<unsigned char>          ic_id_list;     
 
 
    // Counters
    unsigned long               hit_ctr, gamma_ctr, gamma_ab_ctr, cd_ctr, bd_ctr, spede_ctr, ic_ctr;
    unsigned long               n_entries, n_mbs_entries, n_febex_data, n_info_data, n_dgf_data, n_adc_data;
    unsigned long               n_ebis, n_t1, n_sc, n_rilis;
    std::vector<unsigned long>  n_sfp, n_dgf, n_adc, n_pulser;
    std::vector<std::vector<unsigned long>> n_board, n_sync;
    std::vector<std::vector<unsigned long>> n_pause, n_resume;
    unsigned long               n_miniball, n_cd, n_pad, n_spede, n_bd, n_ic;
    unsigned long               repeat_ctr;
 
 
    // Timing histograms
    TH1F *tdiff, *tdiff_clean;
    TH1F *pulser_period, *ebis_period, *t1_period, *sc_period;
    TProfile *pulser_freq, *ebis_freq, *t1_freq, *sc_freq;
    TH2F *pulser_tdiff;
 
    // Miniball histograms
    TH1F *mb_td_core_seg;
    TH1F *mb_td_core_core;
    std::vector<std::vector<TH2F*>> mb_en_core_seg;
    std::vector<std::vector<TH2F*>> mb_en_core_seg_ebis_on;
 
    // CD histograms
    std::vector<std::vector<TH2F*>> cd_pn_mult;
    std::vector<std::vector<TH2F*>> cd_pen_id, cd_nen_id;
    std::vector<std::vector<TH1F*>> cd_pn_td, cd_pp_td, cd_nn_td;
    std::vector<std::vector<TH2F*>> cd_pn_1v1, cd_pn_1v2, cd_pn_2v1, cd_pn_2v2;
 
    // Pad histograms
    std::vector<std::vector<TH2F*>> cd_ppad_mult;
    std::vector<std::vector<TH1F*>> cd_ppad_td;
    std::vector<TH2F*> pad_en_id;
 
    // Ion chamber histograms
    TH2F *ic_dE_E;
    TH1F *ic_dE, *ic_E;
    TH1F *ic_td;
    
};
 
#endif