JRunHistograms.hh

Go to the documentation of this file.

#ifndef __JRUNHISTOGRAMS__
#define __JRUNHISTOGRAMS__

/**
 * \author rgruiz, adomi
 */

#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 "km3net-dataformat/online/JDAQClock.hh"
#include "km3net-dataformat/online/JDAQ.hh"
#include "km3net-dataformat/online/JDAQTimeslice.hh"

#include "JROOT/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;
}


/*
 * 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 BinLogY (T* h){
  
  TAxis *axis      = h->GetYaxis();
  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;
}

double binsToT[] = {-0.5 , 0.5 , 1.5 , 2.5 , 3.5 , 4.5 , 5.5 , 6.5 , 7.5 , 8.5 , 9.5 , 10.5 , 11.5 , 12.5 , 13.5 , 14.5 , 15.5 , 
                    16.5 , 17.5 , 18.5 , 19.5 , 20.5 , 21.5 , 22.5 , 23.5 , 24.5 , 25.5 , 26.5 , 27.5 , 28.5 , 30.5 , 32.5 , 34.5 , 
                    36.5 , 38.5 , 40.5 , 45.5 , 50.5 , 55.5 , 60.5 , 65.5 , 70.5 , 75.5 , 80.5 , 85.5 , 90.5 , 95.5 , 100.5 , 120.5 , 140.5 , 
                    160.5 , 180.5 , 200.5 , 254.5 , 255.5 , 256.5}; 

int nbinsToT = sizeof(binsToT)/sizeof(*binsToT) - 1;


/*
 * Normalizes a histogram to a given value. 
 *
 * \param h The histogram.
 * \param n The normalization constant
 */
void normalizeBW1D (TH1D* h){
   
  for(int i=0 ; i < h->GetNbinsX() ; i++){

    double width = h -> GetXaxis() -> GetBinWidth(i);
        
    h -> SetBinContent(i , h -> GetBinContent(i) / width);
    h -> SetBinError  (i , h -> GetBinError(i)   / width);
  }
}


/*
 * Structure to store histograms obtained from the JDAQSummary TTree. 
 */
struct SummaryHistograms{
  TH1D* h_mean_fifo;
  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;
  TH1D* h_dom_rate_distribution;

  /* One histogram for each DU */
  JManager < string , TH2D >* m_mean_summary_rate;
  JManager < string , TH1D >* m_mean_summary_rate_distribution; 

  /* One histogram for each module */    
  JManager < string , TH2D >* m_summary_rate_distribution; 
  
  SummaryHistograms(){
    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;
    h_dom_rate_distribution          = NULL;
    m_mean_summary_rate              = NULL;
    m_mean_summary_rate_distribution = NULL;
    m_summary_rate_distribution      = NULL;
  }

  /*
   * Initializes the histograms for summary slices
   */  
  void initialize(std::set<int> & du_ids , int modules_per_string){

    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_h_dom_rate_distribution          ();
    init_m_mean_summary_rate              (modules_per_string);
    init_m_mean_summary_rate_distribution ();
    init_m_summary_rate_distribution      ();
  }
   
  /*
   * 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 x number of PMTs ");

    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 x number of PMTs 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() , 20 , 0 , log10(100));

    BinLogX (h_pmt_rate_distribution);

    h_pmt_rate_distribution -> SetMinimum(1);
  }
  
  /*
   * Initializes the histogram.
   */  
  void init_h_dom_rate_distribution(){

    string name  = MAKE_STRING ("h_dom_rate_distribution");
    string title = MAKE_STRING ("DOM rate distribution from summary slices ; rate [kHz] ; Counts");    

    h_dom_rate_distribution = new TH1D (name.c_str() , title.c_str() , 50 , log10(50) , log10(2000));

    BinLogX (h_dom_rate_distribution);

    h_dom_rate_distribution -> SetMinimum(1);
  }

  /*
   * Initializes the histogram.
   *
   * \param modules_per_string the number of modules in a string. 
   */  
  void init_m_mean_summary_rate_distribution (){
    
    string name  = MAKE_STRING ("%/h_mean_summary_rate_distribution");
    string title = MAKE_STRING (" ; rate [kHz] ; # PMTs");
    
    TH1D* h = new TH1D(name.c_str() , title.c_str() , 40 , 0 , log10(1000));

    BinLogX (h);

    m_mean_summary_rate_distribution = new JManager < string , TH1D > (h);
  }
      
  /*
   * 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 (" ; TDC Channel ; 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. 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 ; TDC channel ; rate [kHz] ; counts");    

      TH2D* h_summary_rate_distribution = new TH2D (name.c_str() , title.c_str(),
                                                    NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5 ,
                                                    100 , -1 , log10(10000));

      BinLogY (h_summary_rate_distribution);

      m_summary_rate_distribution = new JManager < string , TH2D > (h_summary_rate_distribution);
  }
};

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 < TH2D* >       h_dom_mean_rates;

  /* One JManager per timeslice type. Each JManager hosts a histogram for each DU */

  vector < JManager < string , TH2D >* > m_mean_ToT;
  vector < JManager < string , TH1D >* > m_mean_ToT_distribution;

  /* 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 , TH2D >* >       m_pmt_tot_distributions;
  vector < JManager < string , TH2D >* >       m_pmt_rate_distributions;

  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_dom_mean_rates         .resize (number_of_timeslice_types , NULL);
    m_mean_ToT               .resize (number_of_timeslice_types , NULL);
    m_mean_ToT_distribution  .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);
  }

  /*
   * 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 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 , int ts_type , std::string ts_name){

    init_h_dom_mean_rates          (ts_type , du_ids , modules_per_string , ts_name);
    init_m_mean_ToT                (ts_type , modules_per_string , ts_name);
    init_m_mean_ToT_distribution   (ts_type , ts_name);
    init_m_pmt_tot_distributions   (ts_type , ts_name);
    init_m_pmt_rate_distributions  (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) -> GetXaxis() -> GetNbins() ; pmt++){

            (*m_mean_ToT[i])[MAKE_STRING("Detector/DU" + to_string(String))] -> Fill((j->second) -> GetXaxis() -> GetBinCenter(pmt) , Floor , (j -> second) -> ProjectionY ("" , pmt , pmt) -> GetMean () );
            (*m_mean_ToT_distribution[i])[MAKE_STRING("Detector/DU" + to_string(String))] -> Fill((j -> second) -> ProjectionY ("" , pmt , pmt) -> GetMean () );            
          }  
        }
      }
    }
  }
  
  /*
   * 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 + " ; DU number ; Floor 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 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 + " ; TDC channel ; Floor number ; mean ToT [ns] ");

    m_mean_ToT[ts_type] = 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 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_distribution (int ts_type , string ts_name){

    string name  = MAKE_STRING ("%/h_mean_ToT_distribution" + ts_name);
    string title = MAKE_STRING (ts_name + " ; ToT [ns] ; # PMTS ");

    m_mean_ToT_distribution[ts_type] = new JManager < string , TH1D > (new TH1D (name.c_str() , title.c_str() , 255 , 0.5 , 255.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_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");

    TH2D* h = new TH2D (name.c_str() , title.c_str() , NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5 , nbinsToT , binsToT);

    h->Sumw2();

    m_pmt_tot_distributions[ts_type] = new JManager < string , TH2D > (h);

  }

  /*
   * 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 + " ; TDC channel ; rate [kHz] ; counts ");    

      TH2D* h_pmt_rate_distributions = new TH2D (name.c_str() , title.c_str(),
                                                 NUMBER_OF_PMTS , -0.5 , NUMBER_OF_PMTS - 0.5 ,
                                                 60 , -6 , log10(1000));

      BinLogY (h_pmt_rate_distributions);

      m_pmt_rate_distributions[ts_type] = new JManager < string , TH2D > (h_pmt_rate_distributions);      
  }  
};

/*
 * 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;
  TH1D* h_Triggered_hits_3dmuon;
  TH2D* h_Triggered_hits_3dmuon_per_module;
  TH1D* h_Triggered_over_Snapshot_hits;
  TH1D* h_Number_of_overlays;
  TH2D* h_Snapshot_hits_per_module;
  TH2D* h_Triggered_hits_per_module;

  /* One histogram per DU*/
  
  JManager < string , TH2D >* m_Snapshot_hits_per_pmt;
  
  TH1D* h_pmt_distribution_triggered_hits;
  TH1D* h_tot_distribution_triggered_hits;
  TH1D* h_pmt_distribution_snapshot_hits;
  TH1D* h_tot_distribution_snapshot_hits;

  /*
   * Constructor
   */
  TriggerHistograms(){
    h_Trigger_bit_event                 = NULL;
    h_Trigger_bit_hit                   = NULL;
    h_Snapshot_hits                     = NULL;
    h_Triggered_hits                    = NULL;
    h_Triggered_hits_3dmuon             = NULL;
    h_Triggered_hits_3dmuon_per_module  = NULL;
    h_Triggered_over_Snapshot_hits      = NULL;
    h_Number_of_overlays                = NULL;
    h_Snapshot_hits_per_module          = NULL;
    h_Triggered_hits_per_module         = NULL;
    m_Snapshot_hits_per_pmt             = 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;
  }

  /*
   * 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 , int modules_per_string){

    init_h_Trigger_bit_event                ();
    init_h_Trigger_bit_hit                  ();
    init_h_Snapshot_hits                    ();
    init_h_Triggered_hits                   ();
    init_h_Triggered_hits_3dmuon            ();
    init_h_Triggered_hits_3dmuon_per_module (modules_per_string , du_ids);
    init_h_Triggered_over_Snapshot_hits     ();
    init_h_Number_of_overlays               ();
    init_h_Snapshot_hits_per_module         (modules_per_string , du_ids);
    init_h_Triggered_hits_per_module        (modules_per_string , du_ids);
    init_m_Snapshot_hits_per_pmt            (modules_per_string);
    init_h_pmt_distribution_triggered_hits  ();
    init_h_tot_distribution_triggered_hits  ();
    init_h_pmt_distribution_snapshot_hits   ();
    init_h_tot_distribution_snapshot_hits   ();
  }

  /*
   * 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 (" ; Number of snapshot hits; 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 (" ; Number of triggered hits; Events ");
  
    h_Triggered_hits = new TH1D (name.c_str() , title.c_str() , 50 , 0, 4 );

    BinLogX (h_Triggered_hits);
  }

  /*
   * Initializes the histogram.
   */
  void init_h_Triggered_hits_3dmuon (){

    string name  = MAKE_STRING ("h_Triggered_hits_3dmuon");
    string title = MAKE_STRING (" ; Number of triggered hits for JTRIGGER3DMUON; Events ");
  
    h_Triggered_hits_3dmuon = new TH1D (name.c_str() , title.c_str() , 50 , 0, 3 );

    BinLogX (h_Triggered_hits_3dmuon);
  }

  /*                                                                                             
   * Initializes the histogram.                                                                            
   */
  void init_h_Triggered_hits_3dmuon_per_module (int modules_per_string , std::set<int> & du_ids){

    string name  = MAKE_STRING ("h_Triggered_hits_3dmuon_per_module");
    string title = MAKE_STRING ("Number of triggered hits for JTRIGGER3DMUON; String ; Floor ; Number of JTRIGGER3DMUON hits");

    h_Triggered_hits_3dmuon_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.
   */
  void init_h_Triggered_over_Snapshot_hits (){

    string name  = MAKE_STRING ("h_Triggered_over_Snapshot_hits");
    string title = MAKE_STRING (" ; Triggered/Snapshot hits; Events ");
  
    h_Triggered_over_Snapshot_hits = new TH1D (name.c_str() , title.c_str() , 100 , 0, 0.5 );
  }


  /*
   * Initializes the histogram.
   */
  void init_h_Number_of_overlays (){

    string name  = MAKE_STRING ("h_Number_of_overlays");
    string title = MAKE_STRING (" ; Number of overlays; Events ");

    int MAX_OVERLAYS = 1000;
    
    h_Number_of_overlays = new TH1D (name.c_str() , title.c_str() , MAX_OVERLAYS , -0.5, MAX_OVERLAYS - 0.5 );
  }

  /*
   * 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.
   *
   * \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 (" ; TDC Channel ; 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.
   *
   * \param detector A JDetector.
   */
  void init_h_pmt_distribution_triggered_hits(){

    string name  = MAKE_STRING ("h_pmt_distribution_triggered_hits");
    string title = MAKE_STRING (" ; TDC Channel ; 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() , nbinsToT , binsToT);

  }
  
  /*
   * Initializes the histogram.
   */
  void init_h_pmt_distribution_snapshot_hits(){

    string  name = MAKE_STRING ("h_pmt_distribution_snapshot_hits");
    string title = MAKE_STRING (" ; TDC Channel ; 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() , nbinsToT , binsToT);

  }
};

/*
 * Class to manage the histograms produced by JRunAnalyzer.
 */
class JRA_Histograms{

public:

  SummaryHistograms   h_summary;
  TimesliceHistograms h_timeslice;
  TriggerHistograms   h_trigger;
  std::set <int>      du_ids;
  int                 modules_per_string;
  
  JRA_Histograms(){}

  JRA_Histograms (const JDetector& detector){

    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 (){
    
    h_summary.initialize(du_ids , modules_per_string);

  }
    
  /*
   * 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 (){
    
    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 , index , ts_name);
  }
  
  /*
   * Initializes JDAQEvent histograms.
   */
  void initialize_trigger_histograms (){
    
    h_trigger.initialize (du_ids , 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_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_dom_rate_distribution) h_summary.h_dom_rate_distribution -> Write();

    Write_histogram_table_to_file(f , MAKE_STRING("Detector"), h_timeslice.h_dom_mean_rates);

    for (typename vector < JManager < string , TH2D >* >::const_iterator i = h_timeslice.m_pmt_tot_distributions.begin() ; i != h_timeslice.m_pmt_tot_distributions.end() ; ++i){

      if ((*i)){
      
        for (typename JManager < string , TH2D >::const_iterator j = (*i) -> begin() ; j != (*i) -> end() ; ++j){

          for(int k=1 ; k < j -> second -> GetNbinsX() ; ++k){

            for(int t=1 ; t < j -> second -> GetNbinsY() ; ++t){

              double width = j -> second -> GetYaxis() -> GetBinWidth(t);
              
              j -> second -> SetBinContent(k,t,j -> second -> GetBinContent(k,t) / width);
              j -> second -> SetBinError(k,t,j -> second -> GetBinError(k,t) / width);
            }
          } 
        }      
      }
    }

    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);
    if (h_summary.m_summary_rate_distribution) Write_manager_in_key_dir (f , h_summary.m_summary_rate_distribution);

    if (h_summary.m_mean_summary_rate)              Write_manager_in_key_dir( f , h_summary.m_mean_summary_rate);
    if (h_summary.m_mean_summary_rate_distribution) Write_manager_in_key_dir( f , h_summary.m_mean_summary_rate_distribution);

    h_timeslice.Fill_mean_ToT_histograms();
    
    Write_manager_table_in_key_dir (f , h_timeslice.m_mean_ToT);
    Write_manager_table_in_key_dir (f , h_timeslice.m_mean_ToT_distribution);

    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(); 
    if (h_trigger.h_Triggered_hits)        h_trigger.h_Triggered_hits        -> Write(); 
    if (h_trigger.h_Triggered_hits_3dmuon) h_trigger.h_Triggered_hits_3dmuon -> Write(); 
    if (h_trigger.h_Triggered_hits_3dmuon_per_module) h_trigger.h_Triggered_hits_3dmuon_per_module -> Write(); 
    if (h_trigger.h_Snapshot_hits)         h_trigger.h_Snapshot_hits         -> Write();
    if (h_trigger.h_Triggered_over_Snapshot_hits)       h_trigger.h_Triggered_over_Snapshot_hits  -> Write();
    if (h_trigger.h_Number_of_overlays)  h_trigger.h_Number_of_overlays -> Write();
    if (h_trigger.h_pmt_distribution_triggered_hits) {h_trigger.h_pmt_distribution_triggered_hits -> Write();}
    if (h_trigger.h_pmt_distribution_snapshot_hits)  {h_trigger.h_pmt_distribution_snapshot_hits  -> Write();}
    if (h_trigger.h_tot_distribution_triggered_hits) {normalizeBW1D (h_trigger.h_tot_distribution_triggered_hits) ; h_trigger.h_tot_distribution_triggered_hits-> Write();}
    if (h_trigger.h_tot_distribution_snapshot_hits)  {normalizeBW1D (h_trigger.h_tot_distribution_snapshot_hits)  ; h_trigger.h_tot_distribution_snapshot_hits -> 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.m_Snapshot_hits_per_pmt) Write_manager_in_key_dir(f , h_trigger.m_Snapshot_hits_per_pmt);
  }
};

#endif