JRunHistograms.hh

Go to the documentation of this file.

#ifndef __JRUNHISTOGRAMS__
#define __JRUNHISTOGRAMS__
 
 
 
#include "JSupport/JSupport.hh"
#include "JSupport/JSupportToolkit.hh"
 
#include "JTrigger/JTriggerInterface.hh"
#include "JTrigger/JTriggerBits.hh"
 
#include "JDetector/JModuleRouter.hh"
#include "JDetector/JDetectorToolkit.hh"
 
#include "JDAQ/JDAQClock.hh"
#include "JDAQ/JDAQ.hh"
#include "JDAQ/JDAQTimeslice.hh"
 
#include "JGizmo/JManager.hh"
 
#include "TH1D.h"
#include "TH2D.h"
#include "TProfile2D.h"
#include "TAxis.h"
#include "TCanvas.h"
#include "TPaveText.h"
#include "TStyle.h"
#include "TString.h"
#include "TMath.h"
#include "TColor.h"
#include "TDirectory.h"
#include "TPRegexp.h"
#include "TObjArray.h"
#include "TObjString.h"
 
using namespace std ;
using namespace KM3NETDAQ ;
using namespace JLANG ;   
using namespace JPP ;
using namespace JSUPPORT ;
 
/*
 * Rebins a histogram with constant bin width in a linear scale, so that the bins will have constant width in log10 scale. 
 *
 * \param h The histogram.
 */
template <class T>
void BinLogX (T* h){
  
  TAxis *axis = h->GetXaxis();
 
  int bins = axis->GetNbins();
  
  Axis_t from = axis->GetXmin();
 
  Axis_t to = axis->GetXmax();
 
  Axis_t width = (to - from) / bins;
 
  Axis_t *new_bins = new Axis_t[bins + 1];
  
  for (int i = 0; i <= bins; i++) {
 
    new_bins[i] = TMath::Power(10, from + i * width);
    
  }
 
  axis->Set(bins, new_bins);
 
  delete new_bins;
 
}
 
/*
 * Normalizes a histogram to a given value. 
 *
 * \param h The histogram.
 * \param n The normalization constant
 */
template <class T>
void normalize (T* h , double n = 1.0){
  
  h -> Scale(n / h -> Integral()) ;
 
}
 
 
/*
 * Structure to store histograms obtained from the JDAQSummary TTree. 
 */
struct SummaryHistograms{
 
  TH1D* h_fifo ;
 
  TH1D* h_mean_fifo ;
  
  TH1D* h_daq_status ;
 
  TH1D* h_frame_index_check ;
 
  //  TH1D* h_mean_daq_status ;
 
  TH1D* h_hrv ;
 
  //  TH1D* h_mean_hrv ;
 
  //  TH1D* h_mean_wr_status ;
 
  //  TH1D* h_mean_active_PMTs ;
  
  TH2D* h_fifo_per_dom ;
 
  TH2D* h_daq_status_per_dom ;
 
  TH2D* h_hrv_per_dom ;
 
  TH2D* h_rate_summary ;
 
  TH1D* h_pmt_rate_distribution ;
 
  /* One histogram for each DU */
  
  JManager < string , TH2D >* m_mean_summary_rate ; 
 
  /* One histogram for each module */
    
  JManager < string , TProfile2D >* m_summary_rate_vs_time ;
  
  JManager < string , TH2D >* m_summary_rate_distribution ; 
    
  JManager < string , TProfile2D >* m_fifo_full ; 
  
  JManager < string , TProfile2D >* m_hrv ; 
 
  JManager < string , TProfile >* m_module_rates_vs_time ;
 
  TProfile* h_rate ;
  
  SummaryHistograms(){
    
    h_frame_index_check = NULL;
 
    h_fifo = NULL;
 
    //    h_mean_fifo = NULL;
 
    h_daq_status = NULL;
 
    //    h_mean_daq_status = NULL ;
    
    h_hrv = NULL ;
 
    //    h_mean_hrv = NULL;
 
    //    h_mean_wr_status = NULL;
 
    //    h_mean_active_PMTs = NULL ;
    
    h_fifo_per_dom = NULL ;
 
    h_daq_status_per_dom = NULL ;
 
    h_hrv_per_dom = NULL ;
 
    h_rate_summary = NULL ;
 
    h_pmt_rate_distribution = NULL ;
 
    m_mean_summary_rate = NULL ;
 
    m_summary_rate_vs_time = NULL ;
 
    m_summary_rate_distribution = NULL ;
 
    m_fifo_full = NULL ;
 
    m_hrv = NULL ;
 
    m_module_rates_vs_time = NULL ;
 
    h_rate = NULL ;
 
  }
 
  /*
   * Initializes the histograms for summary slices
   */  
  void initialize(std::set<int> & du_ids , int modules_per_string , JFrameIndexRange & frame_index_range){
 
    int first_frame = frame_index_range.first ;
    
    int last_frame = frame_index_range.second ;
    
    int n_frames = last_frame - first_frame + 1 ;
 
    double frame_time_s = getFrameTime() * 1.0e-9 ;
    
    double min_time = -0.5 * frame_time_s ;
 
    double max_time = (frame_index_range.second - frame_index_range.first + 0.5 ) * frame_time_s ;
    
    init_h_fifo (n_frames , first_frame , last_frame) ;
 
    //    init_h_mean_fifo () ;
    
    init_h_daq_status (n_frames , first_frame , last_frame) ;
 
    //    init_h_mean_daq_status () ;
    
    init_h_hrv (n_frames , first_frame , last_frame) ;
 
    //    init_h_mean_hrv () ;
 
    //    init_h_mean_wr_status () ;
 
    //    init_h_mean_active_PMTs (du_ids) ;
    
    init_h_fifo_per_dom (du_ids , modules_per_string) ;
    
    init_h_daq_status_per_dom (du_ids , modules_per_string) ;
    
    init_h_hrv_per_dom (du_ids , modules_per_string) ;
 
    init_h_rate_summary (du_ids , modules_per_string) ;
 
    init_h_pmt_rate_distribution() ;
    
    init_m_mean_summary_rate (modules_per_string) ;
    
    init_m_summary_rate_vs_time (n_frames , min_time , max_time) ;
    
    init_m_summary_rate_distribution () ;
 
    init_m_fifo_full (n_frames , min_time , max_time) ;
 
    init_m_hrv (n_frames , min_time , max_time) ;
 
    init_m_module_rates_vs_time (n_frames , min_time , max_time) ;     
    
    init_h_rate (n_frames , first_frame , last_frame) ;
 
  }
   
  /*
   * Initializes the histogram.
   *
   * \param n_frames The number of frames.
   * \param first_frame the index of the first frame.
   * \param last_frame tha index of the last frame.
   */
  void init_h_frame_index_check (int n_frames){
 
    string name = MAKE_STRING ("h_frame_index_check") ;
 
    string title = MAKE_STRING (" ; frame count ; frame index") ;
 
    h_frame_index_check = new TH1D (name.c_str() , title.c_str() , n_frames , -0.5 , n_frames + 0.5 ) ;
 
  }
   
  /*
   * Initializes the histogram.
   *
   * \param n_frames The number of frames.
   * \param first_frame the index of the first frame.
   * \param last_frame tha index of the last frame.
   */
  void init_h_fifo (int n_frames , int first_frame , int last_frame){
 
    string name = MAKE_STRING ("h_fifo") ;
 
    string title = MAKE_STRING ("FIFO status ; slice number ; Average number of PMTs per module with FIFO almost full") ;
 
    h_fifo = new TH1D (name.c_str() , title.c_str() , n_frames , -0.5 , last_frame - first_frame + 0.5 ) ;
 
  }
 
  // /*
  //  * Initializes the histogram.
  //  */
  // void init_h_mean_fifo (){
 
  //   string name = MAKE_STRING ("h_mean_fifo") ;
 
  //   string title = MAKE_STRING ("Frame and TDC channel averaged fifo status") ;
    
  //   h_mean_fifo = new TH1D (name.c_str() , title.c_str() , 100000 , 0 , 1 ) ;  
      
  // }
  
  /*
   * Initializes the histogram.
   *
   * \param n_frames The number of frames.
   * \param first_frame the index of the first frame.
   * \param last_frame tha index of the last frame.
   */
  void init_h_daq_status (int n_frames , int first_frame , int last_frame){
 
    string name = MAKE_STRING ("h_daq_status") ;
 
    string title = MAKE_STRING ("DAQ status ; slice number ; Number of DOMS with wrong DAQ status of packets") ;
 
    h_daq_status = new TH1D (name.c_str() , title.c_str() , n_frames , -0.5 , last_frame - first_frame + 0.5 ) ;
 
  }
 
  // /*
  //  * Initializes the histogram.
  //  */
  // void init_h_mean_daq_status (){
 
  //   string name = MAKE_STRING ("h_mean_daq_status") ;
 
  //   string title = MAKE_STRING ("Frame averaged daq status") ;
    
  //   h_mean_daq_status = new TH1D (name.c_str() , title.c_str() , 100000 , 0 , 1 ) ;  
      
  // }
  
  /*
   * Initializes the histogram.
   *
   * \param n_frames The number of frames.
   * \param first_frame the index of the first frame.
   * \param last_frame the index of the last frame.
   */
  void init_h_hrv (int n_frames , int first_frame , int last_frame){
 
    string name = MAKE_STRING ("h_hrv") ;
 
    string title = MAKE_STRING ("High Rate Veto ; slice number ; Average number of PMTs per module in HRV regime") ;
    
    h_hrv = new TH1D (name.c_str() , title.c_str() , n_frames , -0.5 , last_frame - first_frame + 0.5 ) ;
 
  }
  
  // /*
  //  * Initializes the histogram.
  //  */
  // void init_h_mean_hrv (){
 
  //   string name = MAKE_STRING ("h_mean_hrv") ;
 
  //   string title = MAKE_STRING ("Frame and TDC channel averaged hrv status") ;
    
  //   h_mean_hrv = new TH1D (name.c_str() , title.c_str() , 100000 , 0 , 1 ) ;  
      
  // }
 
  // /*
  //  * Initializes the histogram.
  //  */
  // void init_h_mean_wr_status (){
 
  //   string name = MAKE_STRING ("h_mean_wr_status") ;
 
  //   string title = MAKE_STRING ("Frame averaged white rabbit status") ;
    
  //   h_mean_wr_status = new TH1D (name.c_str() , title.c_str() , 100000 , 0 , 1 ) ;  
      
  // }
 
  // /*
  //  * Initializes the histogram.
  //  */
  // void init_h_mean_active_PMTs (std::set<int> & du_ids){
 
  //   string name = MAKE_STRING ("h_mean_active_PMTs") ;
 
  //   string title = MAKE_STRING ("Frame averaged number of active PMTs") ;
    
  //   h_mean_wr_status = new TH1D (name.c_str() , title.c_str() , NUMBER_OF_PMTS * du_ids.size() , 0.5 , NUMBER_OF_PMTS * du_ids.size() + 0.5 ) ;  
      
  // }
 
  /*
   * Initializes the histogram.
   *
   * \param du_ids The list of ids for the DUs in the detector.
   * \param modules_per_string the number of modules in a string. 
   */  
  void init_h_fifo_per_dom (std::set<int> & du_ids , int modules_per_string){
 
    string name = MAKE_STRING ("h_fifo_per_dom") ;
 
    string title = MAKE_STRING (" FIFO ; String ; Floor ; Number of slices with FIFO almost full ") ;
 
    h_fifo_per_dom = new TH2D (name.c_str() , title.c_str() , *du_ids.rbegin() , 0.5 , *du_ids.rbegin() + 0.5 , modules_per_string , 0.5 , modules_per_string + 0.5 ) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param du_ids The list of ids for the DUs in the detector.
   * \param modules_per_string the number of modules in a string. 
   */  
  void init_h_daq_status_per_dom (std::set<int> & du_ids , int modules_per_string){
 
    string name = MAKE_STRING ("h_daq_status_per_dom") ;
 
    string title = MAKE_STRING (" DAQ Status ; String ; Floor ; Number of slices with wrong DAQ status of packets ") ;
 
    h_daq_status_per_dom = new TH2D (name.c_str() , title.c_str() , *du_ids.rbegin() , 0.5 , *du_ids.rbegin() + 0.5 , modules_per_string , 0.5 , modules_per_string + 0.5 ) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param du_ids The list of ids for the DUs in the detector.
   * \param modules_per_du the number of modules in a string. 
   */  
  void init_h_hrv_per_dom (set<int> & du_ids , int modules_per_string){
 
    string name = MAKE_STRING ("h_hrv_per_dom") ;
    
    string title = MAKE_STRING (" HRV ; String ; Floor ; Number of slices with at least 1 PMT in HRV ") ;
 
    h_hrv_per_dom = new TH2D (name.c_str() , title.c_str() , *du_ids.rbegin() , 0.5 , *du_ids.rbegin() + 0.5 , modules_per_string , 0.5 , modules_per_string + 0.5 ) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param du_ids The list of ids for the DUs in the detector.
   * \param modules_per_du the number of modules in a string. 
   */
  void init_h_rate_summary (set<int> & du_ids , int modules_per_string){
 
    string name = MAKE_STRING ("h_rate_summary") ;
    
    string title = MAKE_STRING (" Summary slices ; String ; Floor ; Mean rate over all summary slices [kHz] ") ;
 
    h_rate_summary = new TH2D (name.c_str() , title.c_str() , *du_ids.rbegin() , 0.5 , *du_ids.rbegin() + 0.5 , modules_per_string , 0.5 , modules_per_string + 0.5 ) ;
 
  }
  
  /*
   * Initializes the histogram.
   */  
  void init_h_pmt_rate_distribution(){
 
    string name = MAKE_STRING ("h_pmt_rate_distribution") ;
    
    string title = MAKE_STRING (" PMT rate distribution from summary slices ; rate [kHz] ; Counts ") ;    
 
    h_pmt_rate_distribution = new TH1D (name.c_str() , title.c_str() , 40 , 0 , log10(1000)) ;
 
    BinLogX (h_pmt_rate_distribution) ;
 
    h_pmt_rate_distribution -> SetMinimum(1) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param modules_per_string the number of modules in a string. 
   */  
  void init_m_mean_summary_rate (int modules_per_string){
    
    string name = MAKE_STRING ("%/h_mean_summary_rate") ;
 
    string title = MAKE_STRING (" ; PMT ; Floor ; rate [kHz] ") ;
    
    m_mean_summary_rate = new JManager < string , TH2D > (new TH2D(name.c_str() , title.c_str() , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5 , modules_per_string , 0.5 , 0.5 + modules_per_string)) ;
    
  }
  
  /*
   * Initializes the histograms.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param ts_name String containing the timeslice type.
   * \param n_frames The number of frames
   * \param min_time The minimum time
   * \param max_time The maximum time
   */  
  void init_m_summary_rate_vs_time(int n_frames , double first_frame , double last_frame){
 
    string name = MAKE_STRING ( "%/h_rate_vs_time_Summaryslice" ) ;
 
    string title = MAKE_STRING ("Summary slices ; frame index ; TDC channel ; rate [Hz]") ;
      
    m_summary_rate_vs_time = new JManager < string , TProfile2D > (new TProfile2D (name.c_str() , title.c_str() , int (n_frames/600) , -0.5 , last_frame - first_frame + 0.5 , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5)) ;
 
  }
  
  /*
   * Initializes the histograms. The frame index range information is needed.
   *
   */  
  void init_m_summary_rate_distribution(){
 
      string name = MAKE_STRING ("%/h_pmt_rate_distributions_Summaryslice") ;
    
      string title = MAKE_STRING ("Summaryslice ; rate [kHz] ; TDC channel ; counts ") ;    
 
      TH2D* h_summary_rate_distribution = new TH2D (name.c_str() , title.c_str() ,
                                           40 , 0 , log10(1000),
                                           NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5) ;
 
      BinLogX (h_summary_rate_distribution) ;
 
      m_summary_rate_distribution = new JManager < string , TH2D > (h_summary_rate_distribution) ;
      
  }
  
  /*
   * Initializes the histograms.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param ts_name String containing the timeslice type.
   * \param n_frames The number of frames
   * \param min_time The minimum time
   * \param max_time The maximum time
   */  
  void init_m_fifo_full(int n_frames , double first_frame , double last_frame){
 
    string name = MAKE_STRING ( "%/h_fifo_almost_full" ) ;
 
    string title = MAKE_STRING (" ; frame index ; TDC channel ; FIFO almost full") ;
      
    m_fifo_full = new JManager < string , TProfile2D > (new TProfile2D (name.c_str() , title.c_str() , int(n_frames/600) , -0.5 , last_frame - first_frame + 0.5 , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5)) ;
 
  }
  
  /*
   * Initializes the histograms.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param ts_name String containing the timeslice type.
   * \param n_frames The number of frames
   * \param min_time The minimum time
   * \param max_time The maximum time
   */  
  void init_m_hrv(int n_frames , double first_frame , double last_frame){
 
    string name = MAKE_STRING ( "%/h_hrv" ) ;
 
    string title = MAKE_STRING (" ; frame index ; TDC channel ; HRV ") ;
      
    m_hrv = new JManager < string , TProfile2D > (new TProfile2D (name.c_str() , title.c_str() , int(n_frames/600) , -0.5 , last_frame - first_frame + 0.5 , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5)) ;
 
  }
 
  
  /*
   * Initializes the histograms.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param ts_name String containing the timeslice type.
   * \param min_time The minimum time
   * \param max_time The maximum time
   */  
  void init_m_module_rates_vs_time(int n_frames , double min_time , double max_time){
 
    string name = MAKE_STRING ( "%/h_module_rate_vs_time_Summaryslice") ;
 
    string title = MAKE_STRING ("Summaryslice ; time since run start [s] ; rate [Hz]" ) ;
      
    m_module_rates_vs_time = new JManager < string , TProfile > (new TProfile (name.c_str() , title.c_str() , int(n_frames/1) , min_time , max_time)) ;
 
  }
 
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param n_frames The number of frames.
   * \param first_frame the index of the first frame.
   * \param last_frame tha index of the last frame.
   * \param ts_name String containing the timeslice type.
   */
  void init_h_rate (int n_frames , int first_frame , int last_frame){
 
    string name = MAKE_STRING ("h_rate_Summaryslice") ;
 
    string title = MAKE_STRING ("Average module rate (Summaryslice) ; slice number ; rate [Hz]") ;
 
    h_rate = new TProfile ( name.c_str() , title.c_str() , int(n_frames/600) , -0.5 , last_frame - first_frame + 0.5 ) ;
 
  }
     
};
 
struct TimesliceHistograms{
  
  int min_ToT ;
 
  int max_ToT ;
 
  int min_logdt ;
 
  int max_logdt ;
 
  int nbins_logdt ;
 
  int nbins_time ;
 
  /* One histogram per timeslice type. I decided not to use a JManager here because the range of each histogram could be different for each timeslice type. */
 
  vector < TH1D* > h_slice_start_time ;
 
  //  vector < TH1D* > h_rate ;
 
  vector < TProfile* > h_rate ;
  
  //  vector < TH1D* > h_active_modules ;
 
  vector < TProfile* > h_active_modules ;
 
  //  vector < TH2D* > h_du_active_modules ;
 
  vector < TProfile2D* > h_du_active_modules ;
 
  vector < TH2D* > h_dom_mean_rates ;
 
  vector < TH1D* > h_ToT_255_vs_time ;
  
  vector < TH2D* > h_ToT_255_Floor_vs_time ;
  
  vector < TH2D* > h_ToT_255_Floor_vs_time_2 ;
 
  /* One JManager per timeslice type. Each JManager hosts a histogram for each DU */
 
  vector < JManager < string , TH2D >* > m_mean_ToT ;
 
  vector < JManager < string , TH2D >* > m_ToT_255 ;
 
  /* One JManager per timeslice type. Each manager hosts a histogram for an optical module. The key is expected to follow the pattern SXXFXX */  
 
  vector < JManager < string , TProfile >* > m_module_rates_vs_time ;
 
  vector < JManager < string , TH2D >* > m_pmt_tot_distributions ;
  
  vector < JManager < string , TH2D >* > m_pmt_rate_distributions ;
  
  vector < JManager < string , TProfile2D >* > m_pmt_tot_vs_time ;
 
  vector < JManager < string , TProfile2D >* > m_pmt_rates_vs_time ;
 
  vector < JManager < string , TH2D >* > m_pmt_dt_consecutive_hits ;
 
  TimesliceHistograms():
 
    min_ToT (0),
 
    max_ToT (255),
 
    min_logdt (0),
 
    max_logdt (9),
 
    nbins_logdt (150),
 
    nbins_time (200)
 
  {
 
    int number_of_timeslice_types = JLength<JDAQTimesliceTypes_t>::value ;
    
    h_slice_start_time.resize (number_of_timeslice_types , NULL) ;
 
    h_rate.resize (number_of_timeslice_types , NULL) ;
 
    h_active_modules.resize (number_of_timeslice_types , NULL) ;
 
    h_du_active_modules.resize (number_of_timeslice_types , NULL) ;
 
    h_dom_mean_rates.resize (number_of_timeslice_types , NULL) ;
    
    h_ToT_255_vs_time.resize (number_of_timeslice_types , NULL) ;
    
    h_ToT_255_Floor_vs_time.resize (number_of_timeslice_types , NULL) ;
 
    h_ToT_255_Floor_vs_time_2.resize (number_of_timeslice_types , NULL) ;
 
    m_mean_ToT.resize (number_of_timeslice_types , NULL) ;
 
    m_ToT_255.resize (number_of_timeslice_types , NULL) ;
 
    m_module_rates_vs_time.resize (number_of_timeslice_types , NULL) ;
 
    m_pmt_tot_distributions.resize (number_of_timeslice_types , NULL) ;
 
    m_pmt_rate_distributions.resize (number_of_timeslice_types , NULL) ;
   
    m_pmt_rates_vs_time.resize (number_of_timeslice_types , NULL) ;
 
    m_pmt_tot_vs_time.resize (number_of_timeslice_types , NULL) ;
 
    m_pmt_dt_consecutive_hits.resize (number_of_timeslice_types , NULL) ;
    
  }
 
  /*
   * Initializes histograms for a given timeslice type.
   *
   * \param du_ids The list of ids for the DUs in the detector
   * \param modules_per_string the number of modules in a string
   * \param frame_index_range maximum and minimum time slice indices in the run. The range of some histograms is based on the number of time slices, and their indices.
   * \param ts_type Index of the timeslice types on the JDAQTimesliceTypes_t typelist. 
   * \param ts_name The name of the timeslice type
   */
  void initialize(std::set<int> du_ids , int modules_per_string , JFrameIndexRange & frame_index_range , int ts_type , std::string ts_name){
 
    int first_frame = frame_index_range.first ;
 
    int last_frame = frame_index_range.second ;
 
    int n_frames = last_frame - first_frame + 1 ;
    
    double frame_time_s = getFrameTime() * 1.0e-9 ;
    
    double min_time = -0.5 * frame_time_s ;
 
    double max_time = (frame_index_range.second - frame_index_range.first + 0.5 ) * frame_time_s ;
 
    init_h_slice_starting_time (ts_type , n_frames , first_frame , last_frame , ts_name) ;
 
    init_h_rate (ts_type , n_frames , first_frame , last_frame , ts_name) ;
 
    init_h_active_modules (ts_type , n_frames , first_frame , last_frame , ts_name) ;
 
    init_h_du_active_modules (ts_type , du_ids , n_frames , first_frame , last_frame , ts_name) ;
 
    init_h_dom_mean_rates (ts_type , du_ids , modules_per_string , ts_name) ;
 
    init_h_ToT_255_vs_time (ts_type , ts_name) ;
 
    init_h_ToT_255_Floor_vs_time (ts_type , modules_per_string , ts_name) ;
 
    init_h_ToT_255_Floor_vs_time_2 (ts_type , modules_per_string , ts_name) ;
 
    init_m_mean_ToT (ts_type , modules_per_string , ts_name) ;
 
    init_m_ToT_255 (ts_type , modules_per_string , ts_name) ;
 
    init_m_module_rates_vs_time (ts_type , n_frames , min_time , max_time , ts_name) ;
 
    init_m_pmt_tot_distributions (ts_type , ts_name) ;
 
    init_m_pmt_rate_distributions (ts_type , ts_name) ;
 
    init_m_pmt_tot_vs_time (ts_type , n_frames , min_time , max_time , ts_name) ; 
 
    init_m_pmt_rates_vs_time (ts_type , n_frames , min_time , max_time , ts_name) ;
    
    init_m_pmt_dt_consecutive_hits(ts_type , ts_name) ;
    
  }
 
  /*
   * Fills the mean ToT as a function of the PMT and floor number for a given DU
   *
   * \param table table with the ToT distributions for each PMT in a module, for every timeslice type
   * \param string The string number
   * \param floor The floor number
   */
  void Fill_mean_ToT_histograms(){
    
    int i = 0  ;
    
    for (typename vector < JManager < string , TH2D >* >::const_iterator it = m_pmt_tot_distributions.begin() ; it != m_pmt_tot_distributions.end() ; ++it , ++i){
 
      if ((*it)){
        
        for (typename JManager < string , TH2D >::const_iterator j = (*it) -> begin() ; j != (*it) -> end() ; ++j){
 
          TString s (MAKE_STRING(j -> first).c_str()) ;
 
          TPRegexp r ("(\\w+)/(\\DU)(\\d+)/(F)(\\d+)") ;
 
          TObjArray* o = r.MatchS(s) ;
 
          int String = ((TObjString *)o->At(3))->GetString().Atoi();
          
          int Floor = ((TObjString *)o->At(5))->GetString().Atoi();
          
          for (int pmt = 1 ; pmt <= (j -> second) -> GetYaxis() -> GetNbins() ; pmt++){
 
            (*m_mean_ToT[i])[MAKE_STRING("Detector/DU" + to_string(String))] -> Fill(Floor , (j->second) -> GetYaxis() -> GetBinCenter(pmt) , (j -> second) -> ProjectionX ("" , pmt , pmt) -> GetMean () ) ;
            
          }  
          
        }
          
      }
 
    }
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param n_frames The number of frames.
   * \param first_frame the index of the first frame.
   * \param last_frame the index of the last frame.
   * \param ts_name The name of the timeslice type.
   */
  void init_h_slice_starting_time (int ts_type , int n_frames , int first_frame , int last_frame , std::string ts_name){
 
    string name = MAKE_STRING ("h_slice_starting_time_" + ts_name ) ;
 
    string title = MAKE_STRING ("Slice Starting Time (" + ts_name + "); slice number ; time since first slice [s]") ;
 
    h_slice_start_time[ts_type] = new TH1D (name.c_str() , title.c_str() , n_frames , -0.5 , last_frame - first_frame + 0.5 ) ;
    
  }
  
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param n_frames The number of frames.
   * \param first_frame the index of the first frame.
   * \param last_frame tha index of the last frame.
   * \param ts_name String containing the timeslice type.
   */
  void init_h_rate (int ts_type , int n_frames , int first_frame , int last_frame , std::string ts_name){
 
    string name = MAKE_STRING ("h_rate_" + ts_name) ;
 
    string title = MAKE_STRING ("Average module rate ("+ts_name+") ; slice number ; rate [Hz]") ;
 
    h_rate[ts_type] = new TProfile ( name.c_str() , title.c_str() , int(n_frames/600) , -0.5 , last_frame - first_frame + 0.5 ) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param n_frames The number of frames.
   * \param first_frame the index of the first frame.
   * \param last_frame tha index of the last frame.
   * \param ts_name String containing the timeslice type.
   */
  void init_h_active_modules (int ts_type , int n_frames , int first_frame , int last_frame , std::string ts_name){
 
    string name = MAKE_STRING ("h_active_DOMS_" + ts_name) ;
 
    string title = MAKE_STRING (" Active modules (" + ts_name + "); slice number ; fraction of active modules") ;
 
    h_active_modules[ts_type] = new TProfile ( name.c_str() , title.c_str() , int(n_frames/600) , -0.5 , last_frame - first_frame + 0.5 ) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param du_ids The list of ids for the DUs in the detector.
   * \param n_frames The number of frames.
   * \param first_frame the index of the first frame.
   * \param last_frame tha index of the last frame.
   * \param ts_name String containing the timeslice type.
   */
  void init_h_du_active_modules (int ts_type , std::set<int> du_ids , int n_frames , int first_frame , int last_frame , std::string ts_name){
 
    string name = MAKE_STRING ("h_du_active_DOMS_" + ts_name) ;
 
    string title = MAKE_STRING ("Active modules in DU (" + ts_name + "); slice number ; DU number ; number of active modules") ;
 
    h_du_active_modules[ts_type] = new TProfile2D (name.c_str() , title.c_str() , int(n_frames/600) , -0.5 , last_frame - first_frame + 0.5 , *du_ids.rbegin() , 0.5 , *du_ids.rbegin() + 0.5 ) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param modules_per_string The number of modules in a string.
   * \param ts_name String containing the timeslice type.
   */
  void init_h_dom_mean_rates (int ts_type , std::set<int> du_ids , int modules_per_string , std::string ts_name){
 
    string name = MAKE_STRING ("h_mean_dom_rates_" + ts_name) ;
 
    string title = MAKE_STRING (ts_name + " ; Floor number ; DU number ; time slice averaged rate [Hz]") ;
 
    h_dom_mean_rates[ts_type] = new TH2D (name.c_str() , title.c_str() , *du_ids.rbegin() , 0.5 , *du_ids.rbegin() + 0.5 , modules_per_string , 0.5 , 0.5 + modules_per_string) ;
    
  }
  
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param ts_name String containing the timeslice type.
   */  
  void init_h_ToT_255_vs_time (int ts_type , string ts_name){
 
    string name = MAKE_STRING ("h_ToT_255_vs_time_" + ts_name) ;
 
    string title = MAKE_STRING (" (" + ts_name + ") Hits with ToT = 255 ns. All PMTs, all timeslices ; Time since beginning of slice [ns] ; counts ") ;
    
    h_ToT_255_vs_time[ts_type] = new TH1D (name.c_str() , title.c_str() , 100 , 0 , log10(getFrameTime())) ;
 
    BinLogX (h_ToT_255_vs_time[ts_type]) ;
 
  }
 
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param modules_per_string the number of modules in a string.
   * \param ts_name String containing the timeslice type.
   */
  void init_h_ToT_255_Floor_vs_time (int ts_type , int modules_per_string , string ts_name){
 
    string name = MAKE_STRING ("h_ToT_255_Floor_vs_time_" + ts_name) ;
 
    string title = MAKE_STRING (" (" + ts_name + ") Hits with ToT = 255 ns. All DUs , all timeslices ; Time since beginning of slice [ns] ; Floor number ; counts ") ;
 
    h_ToT_255_Floor_vs_time[ts_type] = new TH2D (name.c_str() , title.c_str() , 100 , 0 , log10(getFrameTime()) , modules_per_string , 0.5 , 0.5 + modules_per_string) ;
 
    BinLogX(h_ToT_255_Floor_vs_time[ts_type]) ;
    
  }
  
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param modules_per_string the number of modules in a string.
   * \param ts_name String containing the timeslice type.
   */
  void init_h_ToT_255_Floor_vs_time_2 (int ts_type , int modules_per_string , string ts_name){
 
    string name = MAKE_STRING ("h_ToT_255_Floor_vs_time_2_" + ts_name) ;
 
    string title = MAKE_STRING (" (" + ts_name + ") Hits with ToT = 255 ns. All DUs , all timeslices ; Time since beginning of slice [ns] ; Floor number ; counts ") ;
 
    h_ToT_255_Floor_vs_time_2[ts_type] = new TH2D (name.c_str() , title.c_str() , 100 , 0 , getFrameTime() , modules_per_string , 0.5 , 0.5 + modules_per_string) ;
    
  }
    
  /*
   * Initializes the histogram.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param modules_per_string the number of modules in a string.
   * \param ts_name String containing the timeslice type.
   */
  void init_m_mean_ToT (int ts_type , int modules_per_string , string ts_name){
 
    string name = MAKE_STRING ("%/h_mean_ToT_" + ts_name) ;
 
    string title = MAKE_STRING (ts_name + " ; Floor number ; TDC channel ; mean ToT over all timeslices [ns] ") ;
 
    m_mean_ToT[ts_type] = new JManager < string , TH2D > (new TH2D (name.c_str() , title.c_str() , modules_per_string , 0.5 , 0.5 + modules_per_string , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5)) ;
    
  }
 
  /*
   * Initializes the histogram.
   *
   * \param detector A JDetector. 
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param ts_name String containing the timeslice type.
   */  
  void init_m_ToT_255 (int ts_type , int modules_per_string , string ts_name){
 
    string name = MAKE_STRING ("%/h_ToT_255_" + ts_name) ;
 
    string title = MAKE_STRING (ts_name + " ; Floor number ; TDC channel ; number of hits with ToT = 255 ns ") ;
    
    m_ToT_255[ts_type] = new JManager < string , TH2D > (new TH2D (name.c_str() , title.c_str() , modules_per_string , 0.5 , 0.5 + modules_per_string , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5)) ;
 
  }
 
  /*
   * Initializes the histograms.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param ts_name String containing the timeslice type.
   * \param min_time The minimum time
   * \param max_time The maximum time
   */  
  void init_m_module_rates_vs_time(int ts_type , int n_frames , double min_time , double max_time , string ts_name){
 
    string name = MAKE_STRING ( "%/h_module_rate_vs_time_" + ts_name ) ;
 
    string title = MAKE_STRING (ts_name + " ; time since run start [s] ; rate [Hz]" ) ;
      
    m_module_rates_vs_time[ts_type] = new JManager < string , TProfile > (new TProfile (name.c_str() , title.c_str() , int(n_frames/600) , min_time , max_time)) ;
 
  }
 
  /*
   * Initializes the histograms. The frame index range information is needed.
   *
   * \param ts_type index for the timeslice type, according to the JDAQTimeslicetypes_t typelist
   * \param ts_name suffix string
   */
  void init_m_pmt_tot_distributions (int ts_type , string ts_name){
        
    string name = MAKE_STRING ("%_" + ts_name + "_2SToT") ;
 
    string title = MAKE_STRING (ts_name + " ; TDC channel ; ToT [ns] ; counts") ;
      
    m_pmt_tot_distributions[ts_type] = new JManager < string , TH2D > (new TH2D (name.c_str() , title.c_str() ,
                                                                                 NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5 ,
                                                                                 max_ToT - min_ToT + 1 , min_ToT - 0.5 , max_ToT + 0.5)) ;
 
  }
 
  /*
   * Initializes the histograms. The frame index range information is needed.
   *
   * \param ts_type index for the timeslice type, according to the JDAQTimeslicetypes_t typelist
   * \param ts_name suffix string
   */  
  void init_m_pmt_rate_distributions(int ts_type , string ts_name){
 
      string name = MAKE_STRING ("%/h_pmt_rate_distributions_" + ts_name) ;
    
      string title = MAKE_STRING (ts_name + " ; rate [kHz] ; TDC channel ; counts ") ;    
 
      TH2D* h_pmt_rate_distributions = new TH2D (name.c_str() , title.c_str() ,
                                           60 , -6 , log10(20),
                                           NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5) ;
 
      BinLogX (h_pmt_rate_distributions) ;
 
      m_pmt_rate_distributions[ts_type] = new JManager < string , TH2D > (h_pmt_rate_distributions) ;
      
  }
 
  /*
   * Initializes the histograms.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param ts_name String containing the timeslice type.
   * \param n_frames The number of frames in the run
   * \param min_time The minimum time
   * \param max_time The maximum time
   */  
  void init_m_pmt_tot_vs_time(int ts_type , int n_frames , double min_time , double max_time , string ts_name){
    
      string name = MAKE_STRING ("%/ToT_vs_time_" + ts_name) ;
      
      string title = MAKE_STRING (ts_name + " ; time [s] ; TDC channel ; ToT [ns]") ;
      
      m_pmt_tot_vs_time[ts_type] = new JManager < string , TProfile2D > (new TProfile2D (name.c_str() , title.c_str() , int(n_frames/600) , min_time , max_time , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5)) ;
 
    }    
 
  /*
   * Initializes the histograms.
   *
   * \param ts_type index of the timeslicetype indicating its position on the JDAQTimeslicetypes_t typelist
   * \param ts_name String containing the timeslice type.
   * \param n_frames The number of frames
   * \param min_time The minimum time
   * \param max_time The maximum time
   */  
  void init_m_pmt_rates_vs_time(int ts_type , int n_frames , double min_time , double max_time , string ts_name){
 
    string name = MAKE_STRING ( "%/h_rate_vs_time_" + ts_name ) ;
 
    string title = MAKE_STRING (ts_name + " ; time since run start [s] ; TDC channel ; rate [Hz]") ;
      
    m_pmt_rates_vs_time[ts_type] = new JManager < string , TProfile2D > (new TProfile2D (name.c_str() , title.c_str() , int(n_frames/600) , min_time , max_time , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5)) ;
 
  }
  
  /*
   * Initializes the histograms. The frame index range information is needed.
   *
   * \param ts_type index for the timeslice type, according to the JDAQTimeslicetypes_t typelist
   * \param ts_name suffix string
   */  
  void init_m_pmt_dt_consecutive_hits(int ts_type , string ts_name){
    
    string name = MAKE_STRING ("%/h_dt_consecutive_hits_" + ts_name) ;
 
    string title = MAKE_STRING (ts_name + " ; log(dt [ns]) ; TDC channel ; counts") ;
      
    m_pmt_dt_consecutive_hits[ts_type] = new JManager < string , TH2D > (new TH2D (name.c_str() , title.c_str() , nbins_logdt , min_logdt , max_logdt, NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5)) ;
 
  }
  
};
 
/*
 * Structure to store histograms obtained from the JDAQEvent TTree 
 */
struct TriggerHistograms{
 
  TH1D* h_Trigger_bit_event ;
 
  TH1D* h_Trigger_bit_hit ;
 
  TH1D* h_Snapshot_hits ;
 
  TH1D* h_Triggered_hits ;
 
  TH2D* h_Snapshot_hits_per_module ;
 
  TH2D* h_Triggered_hits_per_module ;
 
  TH2D* h_Trigger_map ;
 
  /* One histogram per trigger */
  
  JManager < string , TH1D >* m_trigger_rates ;
 
  /* One histogram per DU*/
  
  JManager < string , TH2D >* m_Snapshot_hits_per_pmt ;
 
  JManager < string , TH2D >* m_Trigger_map ;
  
  TH1D* h_pmt_distribution_triggered_hits ;
 
  TH1D* h_tot_distribution_triggered_hits ;
 
  TH1D* h_pmt_distribution_snapshot_hits ;
 
  TH1D* h_tot_distribution_snapshot_hits ;
 
  TH1D* h_n_triggered_hits_distribution ;
 
  /*
   * Constructor
   */
  TriggerHistograms(){
 
    h_Trigger_bit_event = NULL ;
 
    h_Trigger_bit_hit = NULL ;
 
    h_Snapshot_hits = NULL ;
 
    h_Triggered_hits = NULL ;
 
    h_Snapshot_hits_per_module = NULL ;
 
    h_Triggered_hits_per_module = NULL ;
 
    h_Trigger_map = NULL ;
 
    m_trigger_rates = NULL ;
 
    m_Snapshot_hits_per_pmt = NULL ;
    
    m_Trigger_map = NULL ;
    
    h_pmt_distribution_triggered_hits = NULL ;
 
    h_tot_distribution_triggered_hits = NULL ;
    
    h_pmt_distribution_snapshot_hits = NULL ;
 
    h_tot_distribution_snapshot_hits = NULL ;
 
    h_n_triggered_hits_distribution = NULL ;
 
  }
 
  /*
   * Initializes the histograms.
   * \param du_ids The list of du ids in the detector
   * \param frame_index_range The range of frame indices 
   * \param modules_per_string The number of modules in a string.
   */
  void initialize(std::set<int> & du_ids , JFrameIndexRange & frame_index_range , int modules_per_string){
 
    int first_frame = frame_index_range.first ;
    
    int last_frame = frame_index_range.second ;
    
    int n_frames = last_frame - first_frame + 1 ;
 
    int n_pmts = du_ids.size() * modules_per_string * NUMBER_OF_PMTS ;
    
    init_h_Trigger_bit_event () ;
    
    init_h_Trigger_bit_hit () ;
 
    init_h_Snapshot_hits () ;
 
    init_h_Triggered_hits () ;
 
    init_h_Snapshot_hits_per_module (modules_per_string , du_ids) ;
 
    init_h_Triggered_hits_per_module (modules_per_string , du_ids) ;
 
    init_m_trigger_rates(first_frame , last_frame) ;
 
    init_m_Snapshot_hits_per_pmt (modules_per_string) ;
    
    init_m_Trigger_map (modules_per_string , n_frames , first_frame , last_frame) ;
    
    init_h_Trigger_map (modules_per_string ,  n_frames , first_frame , last_frame) ;
    
    init_h_pmt_distribution_triggered_hits() ;
 
    init_h_tot_distribution_triggered_hits() ;
    
    init_h_pmt_distribution_snapshot_hits() ;
 
    init_h_tot_distribution_snapshot_hits() ;
 
    init_h_n_triggered_hits_distribution (n_pmts) ;
    
  }
 
  /*
   * Initializes the histogram.
   */
  void init_h_Trigger_bit_event (){
 
    string name = MAKE_STRING ("h_Trigger_bit_event") ;
 
    string title = MAKE_STRING ("Number of events as a function of trigger bit in event ; Trigger Bit ; Counts ") ;
  
    h_Trigger_bit_event = new TH1D (name.c_str() , title.c_str() , NUMBER_OF_TRIGGER_BITS , -0.5, NUMBER_OF_TRIGGER_BITS - 0.5 ) ;
 
    for (int i = 0 ; i < (int) NUMBER_OF_TRIGGER_BITS ; i++){
 
      if (getTriggerName(i)){
 
        h_Trigger_bit_event -> GetXaxis() -> SetBinLabel(i+1 , getTriggerName(i) ) ;
 
      } else {
 
        h_Trigger_bit_event -> GetXaxis() -> SetBinLabel(i+1 , "" ) ;
        
      }
      
    }
 
     h_Trigger_bit_event -> GetXaxis() -> LabelsOption("v") ; 
 
  }
 
  /*
   * Initializes the histogram.
   */
  void init_h_Trigger_bit_hit (){
 
    string name = MAKE_STRING ("h_Trigger_bit_hit") ;
 
    string title = MAKE_STRING ("Number of hits per event as a function of trigger bit in hit ; Trigger Bit ; #Events ") ;
  
    h_Trigger_bit_hit = new TH1D (name.c_str() , title.c_str() , NUMBER_OF_TRIGGER_BITS, -0.5, NUMBER_OF_TRIGGER_BITS - 0.5 ) ;
 
    for (int i = 0 ; i < (int) NUMBER_OF_TRIGGER_BITS ; i++){
 
      if (getTriggerName(i)){
 
        h_Trigger_bit_hit -> GetXaxis() -> SetBinLabel(i+1 , getTriggerName(i) ) ;
 
      } else {
 
        h_Trigger_bit_hit -> GetXaxis() -> SetBinLabel(i+1 , "" ) ;
        
      }
      
    }
 
     h_Trigger_bit_hit -> GetXaxis() -> LabelsOption("v") ; 
    
  }
 
  /*
   * Initializes the histogram.
   */
  void init_h_Snapshot_hits (){
 
    string name = MAKE_STRING ("h_Snapshot_hits") ;
 
    string title = MAKE_STRING (" Snapshot hits ; Number of hits ; Counts/#Events ") ;
  
    h_Snapshot_hits = new TH1D (name.c_str() , title.c_str() , 50, 0, 4 ) ;
 
    BinLogX (h_Snapshot_hits) ;
 
  }
 
  /*
   * Initializes the histogram.
   */
  void init_h_Triggered_hits (){
 
    string name = MAKE_STRING ("h_Triggered_hits") ;
 
    string title = MAKE_STRING (" Triggered hits ; Number of hits ; Counts/#Events ") ;
  
    h_Triggered_hits = new TH1D (name.c_str() , title.c_str() , 50 , 0, 4 ) ;
 
    BinLogX (h_Triggered_hits) ;
 
  }
 
  /*
   * Initializes the histogram.
   * \param du_ids The list of du ids in the detector
   * \param modules_per_string.
   */
  void init_h_Snapshot_hits_per_module(int modules_per_string , std::set<int> & du_ids){
 
    string name = MAKE_STRING ("h_Snapshot_hits_per_module") ;
 
    string title = MAKE_STRING (" ; String ; Floor ; Number of snapshot hits ") ;
  
    h_Snapshot_hits_per_module = new TH2D (name.c_str() , title.c_str() ,
                                           *du_ids.rbegin() , 0.5 , *du_ids.rbegin() + 0.5 ,
                                           modules_per_string , 0.5 , modules_per_string + 0.5 ) ;
    
  }
  
  /*
   * Initializes the histogram.
   * \param du_ids The list of du ids in the detector
   * \param modules_per_string.
   */
  void init_h_Triggered_hits_per_module(int modules_per_string , std::set<int> & du_ids){
 
    string name = MAKE_STRING ("h_Triggered_hits_per_module") ;
 
    string title = MAKE_STRING (" ; String ; Floor ; Number of triggered hits ") ;
  
    h_Triggered_hits_per_module = new TH2D (name.c_str() , title.c_str() ,
                                           *du_ids.rbegin() , 0.5 , *du_ids.rbegin() + 0.5 ,
                                           modules_per_string , 0.5 , modules_per_string + 0.5 ) ;
    
  }
  
  /*
   * Initializes the histogram manager.
   * \param modules_per_string The number of modules in a string
   * \param first_frame The first frame index.
   * \param last_frame The last frame index
   * \param seconds_per_bin Bin width in seconds
   */
  void init_h_Trigger_map(int modules_per_string , int n_frames , int first_frame , int last_frame){
 
    string name = MAKE_STRING ("h_Trigger_map") ;
 
    string title = MAKE_STRING (" ; Frame index ; DOM ; Number of triggered hits ") ;
  
    h_Trigger_map = new TH2D (name.c_str() , title.c_str() , n_frames , -0.5 , last_frame - first_frame + 0.5 ,
                              modules_per_string , 0.5 , modules_per_string + 0.5 ) ;
 
  }
 
  /*
   * Initializes the histogram manager.
   *
   * \param first_frame The first frame index.
   * \param last_frame The last frame index
   * \param seconds_per_bin Bin width in seconds
   */
  void init_m_trigger_rates(int first_frame , int last_frame , int seconds_per_bin = 30){
 
    int frames_per_bin = seconds_per_bin / getFrameTime() / 1e-9 ;
 
    int n_bins = (last_frame - first_frame) / frames_per_bin ;
 
    string title = MAKE_STRING (" ; Frame Index ; rate [Hz] ") ;
 
    m_trigger_rates = new JManager <string , TH1D> (new TH1D("h_rate_%" , title.c_str() , n_bins , -0.5 , last_frame - first_frame + 0.5)) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param modules_per_string The number of modules in a string.
   */
  void init_m_Snapshot_hits_per_pmt(int modules_per_string){
 
    string name = MAKE_STRING ("%/h_Snapshot_hits_per_pmt") ;
      
    string title = MAKE_STRING (" ; PMT ; Floor ; Number of snapshot hits ") ;
      
    m_Snapshot_hits_per_pmt = new JManager < string , TH2D > ( new TH2D (name.c_str() , title.c_str() , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5 ,
                                                                         modules_per_string , 0.5 , modules_per_string + 0.5 ) ) ;
 
  }
 
  /*
   * Initializes the histogram manager.
   * \param modules_per_string The number of modules in a string
   * \param first_frame The first frame index.
   * \param last_frame The last frame index
   * \param seconds_per_bin Bin width in seconds
   */
  void init_m_Trigger_map(int modules_per_string , int n_frames , int first_frame , int last_frame){
 
    string name = MAKE_STRING ("%/h_Trigger_map") ;
 
    string title = MAKE_STRING (" ; Frame index ; DOM ; Mean number of triggered hits per event") ;
  
    m_Trigger_map = new JManager < string , TH2D > ( new TH2D (name.c_str() , title.c_str() , int(n_frames/600) , -0.5 , last_frame - first_frame + 0.5 ,
                                                               modules_per_string , 0.5 , modules_per_string + 0.5)) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param detector A JDetector.
   */
  void init_h_pmt_distribution_triggered_hits(){
 
    string name = MAKE_STRING ("h_pmt_distribution_triggered_hits") ;
 
    string title = MAKE_STRING (" ; PMT number ; Counts [a.u.]") ;
  
    h_pmt_distribution_triggered_hits = new TH1D (name.c_str() , title.c_str() , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5) ;
 
  }
  
  /*
   * Initializes the histogram.
   */
  void init_h_tot_distribution_triggered_hits(){
 
    string name = MAKE_STRING ("h_tot_distribution_triggered_hits") ;
 
    string title = MAKE_STRING (" ; ToT [ns] ; Counts [a.u.]") ;
  
    h_tot_distribution_triggered_hits = new TH1D (name.c_str() , title.c_str() , 255 , 0.5 , 255.5 ) ;
 
  }
    
  /*
   * Initializes the histogram.
   */
  void init_h_pmt_distribution_snapshot_hits(){
 
    string name = MAKE_STRING ("h_pmt_distribution_snapshot_hits") ;
 
    string title = MAKE_STRING (" ; PMT number ; Counts [a.u.]") ;
  
    h_pmt_distribution_snapshot_hits = new TH1D (name.c_str() , title.c_str() , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5) ;
 
  }
  
  /*
   * Initializes the histogram.
   */
  void init_h_tot_distribution_snapshot_hits(){
 
    string name = MAKE_STRING ("h_tot_distribution_snapshot_hits") ;
 
    string title = MAKE_STRING (" ; ToT [ns] ; Counts [a.u.]") ;
  
    h_tot_distribution_snapshot_hits = new TH1D (name.c_str() , title.c_str() , 255 , 0.5 , 255.5 ) ;
 
  }
  
  /*
   * Initializes the histogram.
   *
   * \param n_pmts The number of pmts in the detector.
   */
  void init_h_n_triggered_hits_distribution(int n_pmts){
 
    string name = MAKE_STRING ("h_n_triggered_hits_distribution") ;
 
    string title = MAKE_STRING (" ; Number of hits ; Counts") ;
  
    h_n_triggered_hits_distribution = new TH1D (name.c_str() , title.c_str() , n_pmts , 0.5 , n_pmts + 0.5 ) ;
 
  }
 
};
 
/*
 * Class to manage the histograms produced by JRunAnalyzer.
 */
class JRA_Histograms{
 
public:
 
  JDetector detector ;
 
  SummaryHistograms h_summary ;
 
  TimesliceHistograms h_timeslice ;
 
  TriggerHistograms h_trigger ;
 
  std::set <int> du_ids ;
 
  int modules_per_string ;
  
  JRA_Histograms(){}
 
  JRA_Histograms (JDetector & det){
     
    detector = det ;
    
    du_ids = getStringIDs(detector) ;
    
    modules_per_string = JDETECTOR::getNumberOfModules (detector) / getNumberOfStrings (detector) ;
 
    h_summary = SummaryHistograms() ;
 
    h_timeslice = TimesliceHistograms() ;
    
    h_trigger = TriggerHistograms () ;
    
  }
    
  /*
   * Initializes summary slice histograms.
   *
   * \param range The range of values for the summary slice indices in the run. The range of some histograms is based on the number of time slices, and their indices.
   */
  void initialize_summary_histograms (JFrameIndexRange & range){
    
    h_summary.initialize(du_ids , modules_per_string , range) ;
 
  }
    
  /*
   * Initializes summary slice histograms.
   *
   * \param range The range of values for the summary slice indices in the run. The range of some histograms is based on the number of time slices, and their indices.
   */
  template <class T>
  void initialize_timeslice_histograms (JFrameIndexRange & range){
    
    const int index = JIndexOf<JDAQTimesliceTypes_t , T>::value ;
 
    const string prefix = "KM3NETDAQ::JDAQ" ;
 
    string ts_name = T::Class_Name() ;
    
    string::size_type pos = ts_name.find(prefix);
 
    if (pos != string::npos) ts_name.replace(ts_name.find(prefix) , prefix.length() , "") ;
      
    h_timeslice.initialize(du_ids , modules_per_string , range , index , ts_name) ;
    
  }
  
  /*
   * Initializes JDAQEvent histograms.
   */
  void initialize_trigger_histograms (JFrameIndexRange & range){
    
    h_trigger.initialize (du_ids , range , modules_per_string) ;
    
  }
 
  /*
   * Checks if the histograms in a table have been initialized. If yes, it writes them on the indicated directory of a root file
   *
   * \param f The root file
   * \param dirname The directory where the histograms will be written
   * \param table A vector of histograms.
   */
  template <class T>
  void Write_histogram_table_to_file(TFile & f , string dirname , vector < vector < T* > > table){
 
    if(f.GetDirectory(dirname.c_str()) == 0) f.mkdir (dirname.c_str()) ;
 
    f.cd (dirname.c_str()) ;
 
    for (int i=0 ; i < (int)table.size() ; i++){
 
      for (int j=0 ; j< (int)table[i].size() ; j++){
 
        if (table[i][j]) table [i][j] -> Write() ;
 
      }
 
    }
    
  }
 
  /*
   * Checks if the histograms in a table have been initialized. If yes, it writes them on the indicated directory of a root file
   *
   * \param f The root file
   * \param dirname The directory where the histograms will be written
   * \param table A vector of histograms.
   */
  template <class T>
  void Write_histogram_table_to_file(TFile & f , string dirname , vector < T* > table){
 
    if(f.GetDirectory(dirname.c_str()) == 0) f.mkdir (dirname.c_str()) ;
 
    f.cd (dirname.c_str()) ;
 
    for (int i=0 ; i < (int)table.size() ; i++){
 
      if (table[i]) table[i] -> Write() ;
 
    }
    
  }
 
  /*
   * Checks if the histograms in a table have been initialized. If yes, it writes them on the indicated directory of a root file
   *
   * \param f The root file
   * \param dirname The directory where the histograms will be written
   * \param table A vector of histograms.
   */
  template <class T , class V>
  void Write_manager_to_file(TFile & f , string dirname , JManager < T , V >* table){
 
    if(f.GetDirectory(dirname.c_str()) == 0) f.mkdir (dirname.c_str()) ;
 
    f.cd (dirname.c_str()) ;
    
    for (typename JManager < T , V >::const_iterator i = table -> begin() ; i != table -> end() ; ++i){
      
      i -> second -> Write() ;
      
    }
    
  }
  
  /*
   * Replaces wildcard in manager objects titles by their keys.
   * \param A manager.
   * \param wc The wildcard
   */
  template <class T , class V>
  void Replace_wildcard_in_name(JManager < T , V >* manager , char wc = '%'){
    
    for (typename JManager < T , V >::const_iterator i = manager -> begin() ; i != manager -> end() ; ++i){
 
      if (i -> second -> GetTitle()){
 
        std::string buffer = i -> second -> GetTitle() ;
        
        string::size_type ipos = buffer.find(wc) ;
        
        if (ipos!=std::string::npos){
          
          ostringstream os;
          
          os << i -> first ;
          
          buffer.replace(ipos, 1, os.str());
          
          i -> second -> SetTitle(buffer.c_str()) ;
          
        }
        
      }
      
    }
    
  }
 
  /*
   * Writes the contents of a JManager into a file. Each object in each will be written in a directory specified by its key.
   * \param f The root file
   * \param A manager.
   */
  template < class T , class V >
  void  Write_manager_in_key_dir(TFile & f ,JManager <T , V>* manager){
    
    for (typename JManager < T , V >::const_iterator i = manager -> begin() ; i != manager -> end() ; ++i){
      
      std::string fullpath = MAKE_STRING(i-> second -> GetName()) ;
 
      int pos = fullpath.rfind ('/');
 
      std::string name = fullpath.substr (pos + 1) ;
 
      std::string path = fullpath.substr (0 , pos) ;
 
      if (f.GetDirectory(path.c_str()) == 0) f.mkdir (path.c_str()) ;
 
      f.cd(path.c_str()) ;
 
      i -> second -> SetName(name.c_str()) ;
 
      i -> second -> Write() ;
      
    }
 
  }
 
  /*
   * Writes the contents of a vector of JManager objects into a file. Each object in each will be written in a directory specified by its key.
   * \param f The root file
   * \param table the list of JManager objects.
   */
  template < class T , class V >
  void  Write_manager_table_in_key_dir(TFile & f , vector < JManager < T , V >* > table){
 
    for (typename vector < JManager < T , V >* >::const_iterator i = table.begin() ; i != table.end() ; ++i){
 
      if ((*i)){
      
        for (typename JManager < T , V >::const_iterator j = (*i) -> begin() ; j != (*i) -> end() ; ++j){
 
          std::string fullpath = MAKE_STRING(j-> second -> GetName()) ;
 
          int pos = fullpath.rfind ('/');
 
          std::string name = fullpath.substr (pos + 1) ;
 
          std::string path = fullpath.substr (0 , pos) ;
 
          if (f.GetDirectory(path.c_str()) == 0) f.mkdir (path.c_str()) ;
 
          f.cd(path.c_str()) ;
 
          j -> second -> SetName(name.c_str()) ;
          
          j -> second -> Write() ;
      
        }
      
      }
      
    }
 
  }
 
  /*
   * Writes the histograms to a root file. 
   * \param f The root file. 
   */
  void Write_to_file(TFile & f){
 
    f.mkdir("Detector") ;
 
    f.cd("Detector") ;
 
    if (h_summary.h_fifo) h_summary.h_fifo -> Write() ; 
 
    if (h_summary.h_daq_status) h_summary.h_daq_status -> Write() ;
 
    if (h_summary.h_hrv) h_summary.h_hrv -> Write() ;
 
    if (h_summary.h_fifo_per_dom) h_summary.h_fifo_per_dom -> Write() ;
 
    if (h_summary.h_daq_status_per_dom) h_summary.h_daq_status_per_dom -> Write() ;
 
    if (h_summary.h_hrv_per_dom) h_summary.h_hrv_per_dom -> Write() ;
 
    if (h_summary.h_rate_summary) h_summary.h_rate_summary -> Write() ;
 
    if (h_summary.h_pmt_rate_distribution) h_summary.h_pmt_rate_distribution -> Write() ;
 
    if (h_summary.h_frame_index_check) h_summary.h_frame_index_check -> Write() ;
 
    // if (h_summary.h_mean_fifo) h_summary.h_mean_fifo -> Write() ;
  
    // if (h_summary.h_mean_daq_status) h_summary.h_mean_daq_status -> Write() ;
 
    // if (h_summary.h_mean_hrv) h_summary.h_mean_hrv -> Write() ;
 
    // if (h_summary.h_mean_wr_status) h_summary.h_mean_wr_status -> Write() ;
 
    // if (h_summary.h_mean_active_PMTs) h_summary.h_mean_active_PMTs -> Write() ;
  
    Write_histogram_table_to_file(f , MAKE_STRING("Detector/ToT_255_vs_time") , h_timeslice.h_ToT_255_vs_time) ;
    
    Write_histogram_table_to_file(f , MAKE_STRING("Detector/ToT_255_Floor_vs_time") , h_timeslice.h_ToT_255_Floor_vs_time) ;
 
    Write_histogram_table_to_file(f , MAKE_STRING("Detector/ToT_255_Floor_vs_time") , h_timeslice.h_ToT_255_Floor_vs_time_2) ;
 
    Write_histogram_table_to_file(f , MAKE_STRING("Detector/slice_start_time") , h_timeslice.h_slice_start_time) ;
 
    Write_histogram_table_to_file(f , MAKE_STRING("Detector/Rate") , h_timeslice.h_rate) ;
 
    Write_histogram_table_to_file(f , MAKE_STRING("Detector/Active_modules_detector") , h_timeslice.h_active_modules) ;
 
    Write_histogram_table_to_file(f , MAKE_STRING("Detector/Active_modules_du") , h_timeslice.h_du_active_modules) ;
 
    Write_histogram_table_to_file(f , MAKE_STRING("Detector/DOM_mean_rates") , h_timeslice.h_dom_mean_rates) ;
 
    Write_manager_table_in_key_dir (f , h_timeslice.m_pmt_tot_distributions) ;
  
    Write_manager_table_in_key_dir (f , h_timeslice.m_pmt_rate_distributions) ;
 
    Write_manager_table_in_key_dir (f , h_timeslice.m_pmt_tot_vs_time) ;
 
    Write_manager_table_in_key_dir (f , h_timeslice.m_pmt_rates_vs_time) ;
 
    if (h_summary.m_summary_rate_vs_time) Write_manager_in_key_dir (f , h_summary.m_summary_rate_vs_time) ;
 
    if (h_summary.m_summary_rate_distribution) Write_manager_in_key_dir (f , h_summary.m_summary_rate_distribution) ;
 
    if (h_summary.m_fifo_full) Write_manager_in_key_dir (f , h_summary.m_fifo_full) ;
 
    if (h_summary.m_hrv) Write_manager_in_key_dir (f , h_summary.m_hrv) ;
 
    if (h_summary.m_module_rates_vs_time) Write_manager_in_key_dir (f , h_summary.m_module_rates_vs_time) ;
 
    if (h_trigger.m_Trigger_map) Write_manager_in_key_dir (f , h_trigger.m_Trigger_map) ;
    
    Write_manager_table_in_key_dir (f , h_timeslice.m_pmt_dt_consecutive_hits) ;
 
    Write_manager_table_in_key_dir (f , h_timeslice.m_ToT_255) ;
 
    Write_manager_table_in_key_dir (f , h_timeslice.m_module_rates_vs_time) ;
 
    if (h_summary.m_mean_summary_rate) Write_manager_in_key_dir( f , h_summary.m_mean_summary_rate) ;
 
    h_timeslice.Fill_mean_ToT_histograms() ;
    
    Write_manager_table_in_key_dir (f , h_timeslice.m_mean_ToT) ;
 
    f.mkdir ( MAKE_STRING ("JDAQEvent").c_str() ) ;
 
    f.cd ("JDAQEvent") ;
 
    if (h_trigger.h_Trigger_bit_event) h_trigger.h_Trigger_bit_event -> Write() ; 
 
    if (h_trigger.h_Trigger_bit_hit) h_trigger.h_Trigger_bit_hit -> Write() ; 
 
    f.mkdir ( MAKE_STRING ("JDAQEvent/hits_per_event").c_str() ) ;
 
    f.cd ("JDAQEvent/hits_per_event") ;
 
    if (h_trigger.h_Triggered_hits) h_trigger.h_Triggered_hits -> Write() ; 
 
    if (h_trigger.h_Snapshot_hits) h_trigger.h_Snapshot_hits -> Write() ;
 
    f.mkdir ( MAKE_STRING ("JDAQEvent/hits_pmt_distributions").c_str() ) ;
 
    f.cd ("JDAQEvent/hits_pmt_distributions") ;
    
    if (h_trigger.h_pmt_distribution_triggered_hits) { normalize (h_trigger.h_pmt_distribution_triggered_hits) ; h_trigger.h_pmt_distribution_triggered_hits -> Write() ; }
 
    if (h_trigger.h_pmt_distribution_snapshot_hits) {normalize (h_trigger.h_pmt_distribution_snapshot_hits) ; h_trigger.h_pmt_distribution_snapshot_hits -> Write() ; }
 
    f.mkdir ( MAKE_STRING ("JDAQEvent/hits_tot_distributions").c_str() ) ;
 
    f.cd ("JDAQEvent/hits_tot_distributions") ;
 
    if (h_trigger.h_tot_distribution_triggered_hits) { normalize (h_trigger.h_tot_distribution_triggered_hits) ; h_trigger.h_tot_distribution_triggered_hits -> Write() ; }
    
    if (h_trigger.h_tot_distribution_snapshot_hits) { normalize (h_trigger.h_tot_distribution_snapshot_hits) ; h_trigger.h_tot_distribution_snapshot_hits -> Write() ; }
 
    f.mkdir ( MAKE_STRING ("JDAQEvent/trigger_rates").c_str() ) ;
 
    f.cd ("JDAQEvent/trigger_rates") ;
    
    if (h_trigger.m_trigger_rates){ 
 
      for (JManager<string , TH1D>::const_iterator i = h_trigger.m_trigger_rates->begin() ; i != h_trigger.m_trigger_rates->end() ; ++i){
 
        i -> second -> Scale (1./(i->second->GetBinWidth(1) * getFrameTime() * 1e-9) ) ; 
        
        i -> second -> Write() ;
        
      }
 
    }
 
    f.cd ("JDAQEvent") ;
    
    //if (h_trigger.h_Trigger_map) { h_trigger.h_Trigger_map -> Write() ; }
 
    if (h_trigger.h_Triggered_hits_per_module) { h_trigger.h_Triggered_hits_per_module -> Write() ; }
    
    if (h_trigger.h_Snapshot_hits_per_module) { h_trigger.h_Snapshot_hits_per_module -> Write() ; }
 
    if (h_trigger.h_n_triggered_hits_distribution) { h_trigger.h_n_triggered_hits_distribution -> Write() ; }
 
    if (h_trigger.m_Snapshot_hits_per_pmt) Write_manager_in_key_dir( f , h_trigger.m_Snapshot_hits_per_pmt) ;
 
  }
 
};
 
#endif