mcr/hdt_read/RunSummaryHistos.C

#include "TH2.h"
#include "TCanvas.h"
#include "TPDF.h"
#include "TFile.h"
#include "TApplication.h"
#include "TTree.h"
#include "TDatime.h"
#include "TLegend.h"
#include "TStyle.h"

#include "TFndGenInfo.h"
#include "TFndHdt.h"
#include "Gui.h"

#include "TFile.h"
#include "TTree.h"

#include "AccessHDT_MultiRun.C"

class HdtAcc_Appl1: public THdtAccess{

private:

  TLegend *leg[30];

  TString fCanvTit;
  TString fCurRunName;
  

  // --- outputs
  TFile *fOutFile;
  TCanvas *fCanvas;

  // --- noise
  Float_t fNoise;
  Float_t fNoise_Err;
  
  // --- histograms
  // Gts Histos
  TH1F *fHPU_cont[K_N_GTS_P_UNITS]; //-> Pattern Units histograms
  TH1F *fHPU_mult[K_N_GTS_P_UNITS]; //-> Pattern Units histograms
  TH1F *fHTrigSel[K_N_GTS_SELECTORS]; //-> Pattern Units histograms

  // Tof Histos
  TH2F *fH_Tof_i_o_mult;
  TH1F *fH_Tof_map[2]; 
  TH1F *fH_Tof_map_mt[2]; 
  
  TH1F *fH_Tofi_High_mult; // multiplicity on high thresholds
  TH1F *fH_Tofi_High_map; // pattern on high thresholds

  TH1D *fHD_TofiMult; // used as projection from fH_Tof_i_o_mult
  TH1D *fHD_TofoMult; // used as projection from fH_Tof_i_o_mult

  // Sil Histos
  //    pattern filled with number of clusters/module/event
  TH1F *fH_Sil_Patt_Clust_Low[2]; // [ISIM,OSIM] under threshold (MIP)
  TH1F *fH_Sil_Patt_Clust_High[2]; // [ISIM,OSIM] over threshold (PROTON/KAON)
  
  // Lmd Histos
  TH2F *fH_Lmd_i_o_mult;
  TH1F *fH_Lmd_tot_mult;
  TH2F *fH_Lmd_map[2]; 

  // Stb Histos
  TH1F *fH_Stb_mult;
  TH1F *fH_Stb_map[K_N_STB_CROWNS]; 
  TH1F *fH_Stb_Tdc[K_N_STB_CROWNS];

  // Noise Histos
  TH1F *fH_Noise;
  TH1F *fH_Noise_Err;

private:
  void InitGtsHistos();
  void InitTofHistos();
  void InitSilHistos();
  void InitLmdHistos();
  void InitStbHistos();
  void InitNoiseHistos();

  void FillGtsHistos();
  void FillTofHistos();
  void FillSilHistos();
  void FillLmdHistos();
  void FillStbHistos();
  void FillNoiseHistos();

  void SaveGtsHistos();
  void SaveTofHistos();
  void SaveSilHistos();
  void SaveLmdHistos();
  void SaveStbHistos();
  void SaveNoiseHistos();
  
  void ResetGtsHistos();
  void ResetTofHistos();
  void ResetSilHistos();
  void ResetLmdHistos();
  void ResetStbHistos();
  void ResetNoiseHistos();

  void RemoveGtsHistos();
  void RemoveTofHistos();
  void RemoveSilHistos();
  void RemoveLmdHistos();
  void RemoveStbHistos();
  void RemoveNoiseHistos();

  //
  void CreateOutputRootFile();
  void CloseOutputFile();

public:
  HdtAcc_Appl1();
  ~HdtAcc_Appl1();

  void Pre_Run_Operation();
  void Post_Run_Operation();

  void UseHdtEvent();

  // --- added for current application
  // --- style and displaying
  void SetHistoProperties(TH1 *his,Int_t mode);
  void EvalPatternUnit();
  void EvalNoise();
  void DrawSummaryHistos();
  void SaveSummaryPdf();

  // --- histogramming
  void InitHistos(){
    InitGtsHistos();
    InitTofHistos();
    InitSilHistos();
    InitLmdHistos();
    InitStbHistos();
    InitNoiseHistos();
  }
  
  void FillHistos(){
    FillGtsHistos();
    FillTofHistos();
    FillSilHistos();
    FillLmdHistos();
    FillStbHistos();
    FillNoiseHistos();
  }
  
  void SaveHistos(){
    CreateOutputRootFile();
    SaveGtsHistos();
    SaveTofHistos();
    SaveSilHistos();
    SaveLmdHistos();
    SaveStbHistos();
    SaveNoiseHistos();
    // output file not closed in order not to loose histos
  }

  void ResetHistos(){
    ResetGtsHistos();
    ResetTofHistos();
    ResetSilHistos();
    ResetLmdHistos();
    ResetStbHistos();
    ResetNoiseHistos();
  }

  void RemoveHistos(){
    RemoveGtsHistos();
    RemoveTofHistos();
    RemoveSilHistos();
    RemoveLmdHistos();
    RemoveStbHistos();
    RemoveNoiseHistos();
  }

  // ---

  ClassDef(HdtAcc_Appl1,1)
    };

ClassImp(HdtAcc_Appl1)

//_______________________________
HdtAcc_Appl1::HdtAcc_Appl1():
  fCanvTit(),fCurRunName(),
  fOutFile(),fCanvas(),
  fNoise(),fNoise_Err(),
  fHPU_cont(),fHPU_mult(),fHTrigSel(),
  fH_Tof_i_o_mult(),fH_Tof_map(),fH_Tof_map_mt(),fH_Tofi_High_mult(),fH_Tofi_High_map(),
  fHD_TofiMult(),fHD_TofoMult(),
  fH_Sil_Patt_Clust_Low(),fH_Sil_Patt_Clust_High(),
  fH_Lmd_i_o_mult(),fH_Lmd_tot_mult(),fH_Lmd_map(),
  fH_Stb_mult(),fH_Stb_map(),fH_Stb_Tdc(),
  fH_Noise(),fH_Noise_Err()
{

  //  cout << "HdtAcc_Appl1 constructor called" << endl;

}

//_______________________________
HdtAcc_Appl1::~HdtAcc_Appl1(){

  FinishRun();

  if( fCanvas ){
    fCanvas->Clear();
    delete fCanvas;
    fCanvas = 0;
  }

  RemoveHistos();


}

//_______________________________
void HdtAcc_Appl1::Pre_Run_Operation(){

  //  cout << "Performing pre-run operation for run " << fCurrentRun << endl;
  fCurRunName = BuildRunName(fRunType,fCurrentRun);
}

//_______________________________
void HdtAcc_Appl1::Post_Run_Operation(){

  //  cout << "Performing post-run operation for run " << fCurrentRun << endl;
  EvalPatternUnit();
  EvalNoise();
}

//_______________________________
void HdtAcc_Appl1::UseHdtEvent(){
  
  FillHistos();
  //  cout << "...............UseHdtEvent.................... " << endl;
  //  fCurHdtEv->PrintHits();
}

// --- Added methods (used for this application only)

//_______________________________
void HdtAcc_Appl1::SetHistoProperties(TH1 *his,Int_t mode){
  // mode values:
  //            0: normal with thik line
  //            1: first of (BW) superposition
  //            2: second of (BW) superposition
  gStyle->SetOptStat(1000101);
  gStyle->SetStatStyle(3002);
  gStyle->SetStatColor(0);
  gStyle->SetStatTextColor(12);
  
  gStyle->SetStatX(0.98);
  gStyle->SetStatW(0.235);
  gStyle->SetStatY(0.99);
  gStyle->SetStatH(0.35);
  
  gStyle->SetTitleX(0);
  gStyle->SetTitleW(0.5);
  gStyle->SetTitleY(1);
  gStyle->SetTitleH(0.08);
  
  switch(mode){
  case 0:
    his->SetLineWidth(2);
    break;
  case 1:
    his->SetLineStyle(1);
    his->SetLineWidth(3);
    his->SetFillStyle(3005);
    his->SetFillColor(15);
    break;
  case 2:    
    gStyle->SetStatX(0.74);
    //     gStyle->SetStatW(0.20);
    //     gStyle->SetStatY(0.99);
    //     gStyle->SetStatH(0.35);
    
    his->SetLineStyle(1);
    his->SetLineWidth(1);
    his->SetFillStyle(3001);
    his->SetFillColor(1);
  }

}

//_______________________________
void HdtAcc_Appl1::EvalNoise(){

  Float_t allevs = (Float_t) (fCurHdtEv->GetEventNumber() );
  fNoise = fH_Noise->GetMean();
  fNoise_Err = fH_Noise_Err->GetEntries() / allevs;

  TString rtim_str = "";
  rtim_str.Form(" Noise:%.1f (err:%.2f%)",fNoise,fNoise_Err);
  fCanvTit+=rtim_str;
  
}

//_______________________________
void HdtAcc_Appl1::EvalPatternUnit(){

  if(fVerboseLevel > 0) Printf("\n Evaluating trigger");

  Float_t max = fHPU_cont[0]->GetMaximum();
  if(fVerboseLevel > 1) Printf("maximum: %1f",max);

  Float_t thr = max/10;
  if(fVerboseLevel > 1) Printf("thr: %3f",thr);

  const Int_t nbinsx = (const Int_t) ( fHPU_cont[0]->GetNbinsX() );
  
  UInt_t b_on_code = 0;
  UInt_t b_over_th_code = 0;
  Bool_t b_on[16+1] = { kFALSE };
  Bool_t b_over_th[16+1] = { kFALSE };
  
  // take care: b_on indexing as bit numbering (from 1 to 16)
  //           b_on[0] will be always empty!
  for(Int_t b=2; b<=nbinsx; b++){
    Float_t cont = fHPU_cont[0]->GetBinContent(b);
    if(fVerboseLevel > 2) Printf("b: %i; content: %1f",b-1,cont);
    if(cont > 0 ) b_on[b-1] = kTRUE;
    if(cont > thr) b_over_th[b-1] = kTRUE;
  }
  // ---
  TString chk_str_on = "bits on: " ;
  TString chk_str_over_thr = "bits over threshold: " ;
  for(Int_t b=1; b<=16; b++){
    if(b_on[b]) {
      chk_str_on += b; chk_str_on +=  " "; 
      b_on_code = b_on_code | (0x1 << b);
    }
    if(b_over_th[b]) {
      chk_str_over_thr += b; chk_str_over_thr +=  " ";
      b_over_th_code = b_over_th_code | (0x1 << b);
    }
  }
  if(fVerboseLevel > 2){
    Printf("%s (0x%X)",chk_str_on.Data(),b_on_code);
    Printf("%s (0x%X)",chk_str_over_thr.Data(),b_over_th_code);
  }
  // ---
  //   UInt_t bhabha_code = 0x614;
  //   UInt_t hype_code = 0x232; // was 432
  //   UInt_t cosm_code = 0x410; // was 450
  UInt_t bhabha_code = 0x4;
  UInt_t hype_code = 0x2;
  UInt_t cosm_code = 0x40;
  UInt_t cosm_code1 = 0x400;
  
  UInt_t chk_bhabha = b_over_th_code & bhabha_code;
  UInt_t chk_hype   = b_over_th_code & hype_code;
  UInt_t chk_cosm   = b_over_th_code & cosm_code; // before the GorTofone hdw improvement
  UInt_t chk_cosm1   = b_over_th_code & cosm_code1; // after the GorTofone hdw improvement
  
  if(fVerboseLevel > 1){
    Printf("\n\n-----------------------");
    
    Printf("Check bhabha : 0x%X",chk_bhabha);
    Printf("Check hype   : 0x%X",chk_hype);
    Printf("Check cosm   : 0x%X",chk_cosm);
    Printf("Check cosm1  : 0x%X",chk_cosm1);
  }
  
  Bool_t rec_bha  = (chk_bhabha == bhabha_code) ? kTRUE : kFALSE;
  Bool_t rec_hyp  = (chk_hype  == hype_code) ? kTRUE : kFALSE;
  Bool_t rec_cosm = (chk_cosm  == cosm_code) ? kTRUE : kFALSE;
  Bool_t rec_cosm1 = (chk_cosm1  == cosm_code1) ? kTRUE : kFALSE;
  
  TString res_msg = "TRIG: ";
  if(rec_bha && ( (b_over_th_code & 0x40) == 0) )  res_msg += " BHA ";
  if(rec_hyp && ( (b_over_th_code & 0x40) == 0) ){
    res_msg += " HYP ";
    if( (b_over_th_code & 0x4) == 0) res_msg = " HYP ";
  }
  if( rec_cosm || (rec_cosm1 && !(rec_bha || rec_hyp)) ) res_msg += " COSM ";
  
  if(res_msg.CompareTo("TRIG: ")==0) res_msg = " ? ";

  if(fVerboseLevel > 0) Printf("detected trigger: \"%s\"",res_msg.Data());
  // ---

  fCanvTit.Form("%s (%s)",fCurRunName.Data(),res_msg.Data());

  //   Grab runtime (last run)
  TString rtim_str = "";
  if(fCurRunInfo){
    //fCurRunInfo->Print();
    TDatime rdatime = fCurRunInfo->GetDateTime();
    rtim_str.Form(" (%s)",rdatime.AsSQLString());
    fCanvTit+=rtim_str;
  }

}

//_______________________________
void HdtAcc_Appl1::InitGtsHistos(){
  
  TString hname;
  TString htitle;
  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    hname.Form("GtsHist_PU_cont_%d",i+1);
    htitle.Form("Pattern Unit %d (bits content)",i+1);
    fHPU_cont[i] = new TH1F(hname,htitle,17,-0.5,16.5);
    hname.Form("GtsHist_PU_mult_%d",i+1);
    htitle.Form("Pattern Unit %d (multiplicity)",i+1);
    fHPU_mult[i] = new TH1F(hname,htitle,16,-0.5,15.5);
  }
  
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++){
    hname.Form("GtsHist_TrigSel_%d",i+1);
    htitle.Form("Trigger Selector %d",i+1);
    fHTrigSel[i] = new TH1F(hname,htitle,16,-0.5,15.5);
  }
}

//_______________________________
void HdtAcc_Appl1::InitTofHistos(){

  fH_Tof_i_o_mult = new TH2F("tof_i_o_mult","Tof inner vs outer mult.",74,-0.5,73.5,14,-0.5,13.5);
  
  fH_Tof_map[0] = new TH1F("tof_i_map","Inner Tof Hit Map - full hits",14,-0.5,13.5);   
  fH_Tof_map[1] = new TH1F("tof_o_map","Outer Tof Hit Map - full hits",74,-0.5,73.5);   

  fH_Tof_map_mt[0] = new TH1F("tof_i_mt_map","Inner Tof Mean Timer pattern",14,-0.5,13.5);   
  fH_Tof_map_mt[1] = new TH1F("tof_o_mt_map","Outer Tof Mean Timer pattern",74,-0.5,73.5);   
  
  // --- 
  fH_Tofi_High_mult = new TH1F("TOFINO_MT_H_mul","TOFINO hi-MT-mult.",14,-0.5,13.5);
  fH_Tofi_High_map = new TH1F("TOFINO_MT_H_map","TOFINO hi-MT-patt.",14,-0.5,13.5);

}

//_______________________________
void HdtAcc_Appl1::InitSilHistos(){

  fH_Sil_Patt_Clust_Low[0]  = new TH1F("ISIM_PATT_Low" ,"ISIM PATT",10,-0.5,9.5);
  fH_Sil_Patt_Clust_High[0] = new TH1F("ISIM_PATT_High","ISIM PATT High",10,-0.5,9.5);

  fH_Sil_Patt_Clust_Low[1]  = new TH1F("OSIM_PATT_Low" ,"OSIM PATT",12,-0.5,11.5);
  fH_Sil_Patt_Clust_High[1] = new TH1F("OSIM_PATT_High","OSIM PATT High",12,-0.5,11.5);

}
//_______________________________
void HdtAcc_Appl1::InitLmdHistos(){

  fH_Lmd_i_o_mult = new TH2F("lmd_i_o_mult","Lmd inner vs outer mult.",10,-0.5,9.5,10,-0.5,9.5);
  fH_Lmd_tot_mult = new TH1F("lmd_tot_mult","Lmd total multiplicity",30,-0.5,29.5);

  fH_Lmd_map[0] = new TH2F("lmd_i_map","Inner Lmd Hit Map (Wire vs Drift Number) - full hits",9,-0.5,9.5,14,-0.5,13.5);   
  fH_Lmd_map[1] = new TH2F("lmd_o_map","Outer Lmd Hit Map (Wire vs Drift Number) - full hits",9,-0.5,9.5,24,-0.5,23.5);   

}
//_______________________________
void HdtAcc_Appl1::InitStbHistos(){

  fH_Stb_mult = new TH1F("stb_mult","Stb multiplicity",101,-0.5,100.5);
  TString hname;
  TString htitle;
  
  for(Int_t ch=0;ch<K_N_STB_CROWNS;ch++ ){
    hname.Form("stb_map_%d",ch+1);
    htitle.Form("Stb Crown %d pattern",ch+1);
    fH_Stb_map[ch] = new TH1F(hname,htitle,K_N_STB_TUBES+2,-0.5,(Float_t) K_N_STB_TUBES+1.5); 
    hname.Form("Stb_Tdc_Crown_%d",ch+1);
    htitle.Form("Stb Crown %d Tdc distribution",ch+1);
    fH_Stb_Tdc[ch] = new TH1F(hname,htitle,660,0.,1980.);
  }
  
}

//_______________________________
void HdtAcc_Appl1::InitNoiseHistos(){

  fH_Noise = new TH1F("gen_noise","general noise",8,-0.5,7.5);
  fH_Noise_Err = new TH1F("gen_noise_err","general noise error",8,-7.5,0.5);

}


//_______________________________
void HdtAcc_Appl1::FillGtsHistos(){

  TFndTrig *fTrig = fCurHdtEv->GetGts();
  //  
  Int_t pu_mult[K_N_GTS_P_UNITS] = {0};
  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    for(Int_t bit=0;bit<16;bit++){
      Short_t content = fTrig->GetPU_cont_bit(i,bit);
      fHPU_cont[i]->Fill(bit+1,content);
      if(content > 0) pu_mult[i]++;
    }
    fHPU_mult[i]->Fill(pu_mult[i]);
  }
  // ---
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++){
    for(Int_t bit=0;bit<16;bit++) fHTrigSel[i]->Fill(bit,fTrig->GetTriggerSelector_bit(i,bit));
  }  
  //
  fTrig = 0;
}
//_______________________________
void HdtAcc_Appl1::FillTofHistos(){

  TClonesArray *TofHits = fCurHdtEv->GetTofHits();
  //
  Int_t lay, slab;
  TFndHTof *cur_hit = 0;
  Int_t i_mult = 0;
  Int_t i_high_mult = 0;
  Int_t o_mult = 0;
  //cout << TofHits->GetEntries() << " tof hits" << endl;
  for(Int_t ic=0;ic< TofHits->GetEntries(); ic++) {
    cur_hit =  (TFndHTof *) ( TofHits->At(ic) );
    cur_hit->GetLayer_Slab(lay,slab);
    
    Int_t ae = cur_hit->GetAdcE();
    Int_t ap = cur_hit->GetAdcP();
    Int_t te = cur_hit->GetTdcE();
    Int_t tp = cur_hit->GetTdcP();
    Int_t tm = cur_hit->GetMeanTimer();
    Int_t tm_high = cur_hit->GetHighMeanTimer();
    Bool_t fullHit = kTRUE;
    if(ae==-1 || ap==-1 || te==-1 || tp==-1) fullHit = 0;
    
    if(tm >= 0 && lay == 1) i_mult++;
    if(tm_high >= 0 && lay == 1) i_high_mult++;
    else if(tm >= 0 && lay == 2) o_mult++;
    
    if(fullHit) fH_Tof_map[lay-1]->Fill(slab);
    if(tm>=0) fH_Tof_map_mt[lay-1]->Fill(slab);
    if(tm_high >= 0 && lay == 1) fH_Tofi_High_map->Fill(slab);
    
  }   
  fH_Tof_i_o_mult->Fill(o_mult,i_mult);
  fH_Tofi_High_mult->Fill(i_high_mult);
  //
  TofHits = 0;
}
//_______________________________
void HdtAcc_Appl1::FillSilHistos(){

  TClonesArray *SilClus = fCurHdtEv->GetSilClusters();
  //
  if(!SilClus) return;
  TFndHSilCluster *cur_clus = 0;
  Int_t n_clusts = (Int_t)SilClus->GetEntries();
  //  cout << "n_clusts: " << n_clusts << endl;
  
  for(Int_t ic=0;ic< n_clusts; ic++) {
    cur_clus = (TFndHSilCluster *) ( SilClus->At(ic) );
    if(!cur_clus) return;
    //    cur_clus->PrintHit();
    Int_t slay = cur_clus->GetLayer();
    Int_t smod = cur_clus->GetModNum();
    // --- check
    if(slay < 1 || slay > 2){
      cout << " ************* ERROR: FillSilHistos(): slay = " << slay << endl;
      return;
    }
    if(slay == 1 && (smod < 1 || smod > 8) ){
      cout << " ************* ERROR: FillSilHistos(): slay = " << slay << "; mod = " << smod << endl;
      return;      
    }
    if(slay == 2 && (smod < 1 || smod > 10) ){
      cout << " ************* ERROR: FillSilHistos(): slay = " << slay << "; mod = " << smod << endl;
      return;      
    }
    // ---
    // add energy selection
    //    Bool_t is_over_threshold = kTRUE; // GET IT FROM THE CLUSTER
    //    if(is_over_threshold)
    if (cur_clus->GetIDCl() == 1 && cur_clus->GetGoodCl() == 1){
      fH_Sil_Patt_Clust_High[slay-1]->Fill(smod);
    } else if (cur_clus->GetGoodCl() == 1) {
      fH_Sil_Patt_Clust_Low[slay-1]->Fill(smod);
    }    
  }// hits loop end
  //  
  SilClus = 0;
}
//_______________________________
void HdtAcc_Appl1::FillLmdHistos(){

  TClonesArray *LmdHits = fCurHdtEv->GetLmdHits();
  //
  Int_t lay, cham, wire;
  TFndHLmd *cur_hit = 0;
  Int_t i_mult = 0;
  Int_t o_mult = 0;
  for(Int_t ic=0;ic< LmdHits->GetEntries(); ic++) {
    cur_hit =  (TFndHLmd *) ( LmdHits->At(ic) );
    //cur_hit->PrintHit();
    cur_hit->GetLayer_Chamber_Wire(lay, cham, wire);
    Float_t ae = cur_hit->GetAdcE();
    Float_t ap = cur_hit->GetAdcP();
    Float_t te = cur_hit->GetTdcE();
    Float_t tp = cur_hit->GetTdcP();
    Float_t fullHit = ae*ap*te*tp;
    if(lay == 1) i_mult++;
    if(lay == 2) o_mult++;
    
    if(fullHit) fH_Lmd_map[lay-1]->Fill(cham,wire);
  }   
  fH_Lmd_i_o_mult->Fill(o_mult,i_mult);
  fH_Lmd_tot_mult->Fill(o_mult+i_mult);
  //
  LmdHits = 0;
}
//_______________________________
void HdtAcc_Appl1::FillStbHistos(){

  TClonesArray *StbHits = fCurHdtEv->GetStbHits();
  //
  Int_t crown, tube;
  TFndHStb *cur_hit = 0;
  fH_Stb_mult->Fill(StbHits->GetEntries());
  for(Int_t ic=0;ic< StbHits->GetEntries(); ic++) {
    cur_hit =  (TFndHStb *) ( StbHits->At(ic) );
    cur_hit->GetCrown_Tube(crown, tube);
    fH_Stb_map[crown-1]->Fill(tube);
    fH_Stb_Tdc[crown-1]->Fill(cur_hit->GetTdc());
  } 
  //
  StbHits = 0;
}
//_______________________________
void HdtAcc_Appl1::FillNoiseHistos(){

  Int_t cur_noise = fCurHdtEv->GetNoiseLevel();
  Float_t cn = 999;
  Float_t cner = -999;

  if(cur_noise == -999) return;

  if( cur_noise >= 0 ){
    cn = (cur_noise != 999) ? (Float_t)(cur_noise) : 4;
  }
  else{
    cner = (Float_t)(cur_noise);
  }

  if(cn != 999) fH_Noise->Fill(cn);
  if(cner != -999) fH_Noise_Err->Fill(cner);

}

//_______________________________
void HdtAcc_Appl1::DrawSummaryHistos(){

  gStyle->SetPalette(1,0);
  if(fCanvas) delete fCanvas;
  fCanvas = new TCanvas("FND_Monitor","FND_Monitor",580,840);
  
  fCanvas->Clear();

  TString title = fCanvTit;
  //  Printf("==========> \"%s\"",fCanvTit.Data());
  Int_t TitColor = -1;
  Double_t pad_tit_h = 0.07;
  Double_t TitSize = 0.3;
  // ---
   
  Double_t sep = 0.005;  
  Double_t ori_w = (Double_t) ( fCanvas->GetWindowWidth() );
  Double_t ori_h = (Double_t) ( fCanvas->GetWindowHeight() );

  //   if(ori_w == 0 || ori_w == 32000) ori_w = 800;
  //   if(ori_h == 0 || ori_h == 32000) ori_h = 600;
  
  Double_t w_h_ratio = ori_w / ori_h;
  
  UInt_t displ_h = (UInt_t) ( ori_h - ( ori_h * pad_tit_h + sep) );
  UInt_t displ_w = (UInt_t) ( displ_h * w_h_ratio );

  
  TPad *pt = new TPad("pt","ptit",
                      .01 , (1.- (pad_tit_h - sep) ) ,
                      .99 ,  .999);
  
  if(TitColor != -1)pt->SetFillColor(TitColor);
  
  fCanvas->cd();
  pt->Draw();
  // WRITE TITLE
  pt->cd();
  TLatex tit;//= new TLatex(.05,.95,title);
  tit.SetTextAlign(23);
  tit.SetTextSize(TitSize);
  tit.DrawLatex(0.5,0.65,title);

  Double_t dis_perc_w = (Double_t) (displ_w) / ori_w;
  Double_t dis_perc_h = (Double_t) (displ_h) / ori_h;
  
  Double_t half_p = (1. - dis_perc_w)/2;

  TPad *pd = new TPad("pd","pdis",
                      half_p     , .0001,
                      1 - half_p , dis_perc_h);

  fCanvas->cd();
  pd->Draw();

  pd->cd();  

  pd->Divide(2,4);
  pd->cd(1);

  // --- TOF multiplicities
  fHD_TofiMult = fH_Tof_i_o_mult->ProjectionY();
  fHD_TofiMult->SetAxisRange(-0.5,7.5,"X");
  fHD_TofiMult->SetName("TOFINO MT multiplicity");
  fHD_TofiMult->SetTitle("TOFINO MT multiplicity");
  SetHistoProperties(fHD_TofiMult,1);
  fHD_TofiMult->Draw();

  fH_Tofi_High_mult->SetAxisRange(-0.5,7.5,"X");
  fH_Tofi_High_mult->SetName("TOFINO MT-h mult.");
  SetHistoProperties(fH_Tofi_High_mult,2);
  fH_Tofi_High_mult->Draw("sames");
  if(fH_Tofi_High_mult->GetMaximum() > fHD_TofiMult->GetMaximum() ) fHD_TofiMult->SetAxisRange(0,fH_Tofi_High_mult->GetMaximum(),"Y");

  leg[0] = new TLegend(0.6,0.5,0.99,0.75);
  leg[0]->AddEntry(fHD_TofiMult->GetName(),"low th.","cf");
  leg[0]->AddEntry(fH_Tofi_High_mult->GetName(),"high th.","cf");
  leg[0]->Draw();

  pd->cd(2);
  fHD_TofoMult = fH_Tof_i_o_mult->ProjectionX();
  fHD_TofoMult->SetAxisRange(-0.5,15.5,"X");
  fHD_TofoMult->SetTitle("TOFONE MT multiplicity");
  SetHistoProperties(fHD_TofoMult,0);
  fHD_TofoMult->Draw();
  
  // --- TOF patterns
  pd->cd(3);
  fH_Tof_map_mt[0]->SetAxisRange(-0.5,13.5,"X");
  fH_Tof_map_mt[0]->SetName("TOFINO MT-l patt.");
  fH_Tof_map_mt[0]->SetTitle("TOFINO MT patt.");
  SetHistoProperties(fH_Tof_map_mt[0],1);
  fH_Tof_map_mt[0]->Draw();

  fH_Tofi_High_map->SetAxisRange(-0.5,13.5,"X");
  fH_Tofi_High_map->SetName("TOFINO MT-h pattern");
  fH_Tofi_High_map->SetTitle("TOFINO MT-high pattern");
  SetHistoProperties(fH_Tofi_High_map,2);
  fH_Tofi_High_map->Draw("sames");

  pd->cd(4);
  fH_Tof_map_mt[1]->SetAxisRange(-0.5,72.5,"X");
  SetHistoProperties(fH_Tof_map_mt[1],0);
  fH_Tof_map_mt[1]->Draw();

  // --- SIL
  pd->cd(5);// ISIM
  SetHistoProperties(fH_Sil_Patt_Clust_Low[0],1);
  fH_Sil_Patt_Clust_Low[0]->Draw();
  SetHistoProperties(fH_Sil_Patt_Clust_High[0],2);
  fH_Sil_Patt_Clust_High[0]->Draw("sames");
  pd->cd(6);// OSIM
  SetHistoProperties(fH_Sil_Patt_Clust_Low[1],1);
  fH_Sil_Patt_Clust_Low[1]->Draw();
  SetHistoProperties(fH_Sil_Patt_Clust_High[1],2);
  fH_Sil_Patt_Clust_High[1]->Draw("sames");


  // --- LMD and STB multiplicities
  pd->cd(7);
  fH_Lmd_tot_mult->SetAxisRange(-0.5,14.5,"X");
  SetHistoProperties(fH_Lmd_tot_mult,0);
  fH_Lmd_tot_mult->Draw();  

  pd->cd(8);
  fH_Stb_mult->SetAxisRange(-0.5,34.5,"X");
  SetHistoProperties(fH_Stb_mult,0);
  fH_Stb_mult->Draw();

}

//_______________________________
void HdtAcc_Appl1::SaveSummaryPdf(){

  TString start_pth=ExpandPathName("$FND_HISTOS");
  
#if defined _FND_OUTPUTS_USE_SUBDIR
  CreateGrpSubDir(fRunType,fFirstRun,start_pth);
  TString fnam = BuildRunName(fRunType,fFirstRun,kTRUE);
#else
  TString fnam = BuildRunName(fRunType,fFirstRun);
#endif
  if(fLastRun != fFirstRun){
    fnam += "-";
    fnam += fLastRun;
  }
  fnam += "-summary.pdf";
  
  TString pdfname = "";
  pdfname.Form("%s/%s",start_pth.Data(),fnam.Data());

  DrawSummaryHistos();

  // --- SAVE PDF
  fCanvas->cd();
  fCanvas->SaveAs(pdfname);
  
}

//_______________________________
void HdtAcc_Appl1::CreateOutputRootFile(){
  
  CloseOutputFile();
  
  TString start_pth = ExpandPathName("$FND_HISTOS/root-files");
  
#if defined _FND_OUTPUTS_USE_SUBDIR
  CreateGrpSubDir(fRunType,fFirstRun,start_pth);
  TString fnam = BuildRunName(fRunType,fFirstRun,kTRUE);
#else
  TString fnam = BuildRunName(fRunType,fFirstRun);
#endif
  
  if(fLastRun != fFirstRun){
    fnam += "-";
    fnam += fLastRun;
  }
  fnam += "-monitor.root";
  
  TString outpath = "";
  outpath.Form("%s/%s",start_pth.Data(),fnam.Data());
  fOutFile = new TFile(outpath,"RECREATE");
}

//_______________________________
void HdtAcc_Appl1::CloseOutputFile(){

  if(!fOutFile) return;

  if(fOutFile->IsOpen()) fOutFile->Close();
  delete fOutFile;
  fOutFile = 0;
}

//_______________________________
void HdtAcc_Appl1::SaveGtsHistos(){

  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    fHPU_cont[i]->Write();
    fHPU_mult[i]->Write();
  }
  
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++){
    fHTrigSel[i]->Write();
  }
}
//_______________________________
void HdtAcc_Appl1::SaveTofHistos(){

  fH_Tof_i_o_mult->Write();
  
  fH_Tof_map[0]->Write();   
  fH_Tof_map[1]->Write();   
  fH_Tof_map_mt[0]->Write();
  fH_Tof_map_mt[1]->Write();

  // --- 
  fH_Tofi_High_mult->Write();
  fH_Tofi_High_map ->Write();

  if(fHD_TofiMult) { fHD_TofiMult->Write(); } 
  if(fHD_TofoMult) { fHD_TofoMult->Write(); } 

}
//_______________________________
void HdtAcc_Appl1::SaveSilHistos(){
  
  fH_Sil_Patt_Clust_Low[0]  ->Write();
  fH_Sil_Patt_Clust_High[0] ->Write();
  
  fH_Sil_Patt_Clust_Low[1]  ->Write();
  fH_Sil_Patt_Clust_High[1] ->Write();

}
//_______________________________
void HdtAcc_Appl1::SaveLmdHistos(){
 
  fH_Lmd_i_o_mult->Write();
  fH_Lmd_tot_mult->Write();

  fH_Lmd_map[0]->Write();   
  fH_Lmd_map[1]->Write();  

}
//_______________________________
void HdtAcc_Appl1::SaveStbHistos(){

  fH_Stb_mult->Write();
  
  for(Int_t ch=0;ch<K_N_STB_CROWNS;ch++ ){
    fH_Stb_map[ch]->Write(); 
    fH_Stb_Tdc[ch]->Write();
  }
}
//_______________________________
void HdtAcc_Appl1::SaveNoiseHistos(){

  fH_Noise->Write();
  fH_Noise_Err->Write();
}


//_______________________________
void HdtAcc_Appl1::ResetGtsHistos(){

  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    fHPU_cont[i]->Reset();
    fHPU_mult[i]->Reset();
  }
  
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++){
    fHTrigSel[i]->Reset();
  }
}
//_______________________________
void HdtAcc_Appl1::ResetTofHistos(){

  fH_Tof_i_o_mult->Reset();
  
  fH_Tof_map[0]->Reset();   
  fH_Tof_map[1]->Reset();   
  fH_Tof_map_mt[0]->Reset();   
  fH_Tof_map_mt[1]->Reset();   
  
  // --- 
  fH_Tofi_High_mult->Reset();
  fH_Tofi_High_map ->Reset();

  if(fHD_TofiMult) { fHD_TofiMult->Reset(); } 
  if(fHD_TofoMult) { fHD_TofoMult->Reset(); } 

}
//_______________________________
void HdtAcc_Appl1::ResetSilHistos(){

  fH_Sil_Patt_Clust_Low[0]  ->Reset();
  fH_Sil_Patt_Clust_High[0] ->Reset();

  fH_Sil_Patt_Clust_Low[1]  ->Reset();
  fH_Sil_Patt_Clust_High[1] ->Reset();

}
//_______________________________
void HdtAcc_Appl1::ResetLmdHistos(){

  fH_Lmd_i_o_mult->Reset();
  fH_Lmd_tot_mult->Reset();

  fH_Lmd_map[0]->Reset();   
  fH_Lmd_map[1]->Reset();  

}
//_______________________________
void HdtAcc_Appl1::ResetStbHistos(){

  fH_Stb_mult->Reset();
  
  for(Int_t ch=0;ch<K_N_STB_CROWNS;ch++ ){
    fH_Stb_map[ch]->Reset(); 
    fH_Stb_Tdc[ch]->Reset();
  }
  
}
//_______________________________
void HdtAcc_Appl1::ResetNoiseHistos(){

  fH_Noise->Reset();
  fH_Noise_Err->Reset();
}


//_______________________________
void HdtAcc_Appl1::RemoveGtsHistos(){

  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    delete fHPU_cont[i]; fHPU_cont[i] = 0;
    delete fHPU_mult[i]; fHPU_mult[i] = 0;
  }
  
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++){
    delete fHTrigSel[i]; fHTrigSel[i] = 0;
  }
}
//_______________________________
void HdtAcc_Appl1::RemoveTofHistos(){

  delete fH_Tof_i_o_mult; fH_Tof_i_o_mult = 0;
  
  delete fH_Tof_map[0]; fH_Tof_map[0] = 0;   
  delete fH_Tof_map[1]; fH_Tof_map[1] = 0;
  delete fH_Tof_map_mt[0]; fH_Tof_map_mt[0] = 0;   
  delete fH_Tof_map_mt[1]; fH_Tof_map_mt[1] = 0;
  
  // --- 
  delete fH_Tofi_High_mult; fH_Tofi_High_mult = 0;
  delete fH_Tofi_High_map;  fH_Tofi_High_map = 0;

  // do not uncomment   if(fHD_TofiMult) { delete fHD_TofiMult; fHD_TofiMult = 0; } 
  // do not uncomment   if(fHD_TofoMult) { delete fHD_TofoMult; fHD_TofoMult = 0; } 

}
//_______________________________
void HdtAcc_Appl1::RemoveSilHistos(){

  delete fH_Sil_Patt_Clust_Low[0]; fH_Sil_Patt_Clust_Low[0] = 0;
  delete fH_Sil_Patt_Clust_High[0]; fH_Sil_Patt_Clust_High[0] = 0;

  delete fH_Sil_Patt_Clust_Low[1]; fH_Sil_Patt_Clust_Low[1] = 0;
  delete fH_Sil_Patt_Clust_High[1]; fH_Sil_Patt_Clust_High[1] = 0;
}
//_______________________________
void HdtAcc_Appl1::RemoveLmdHistos(){

  delete fH_Lmd_i_o_mult; fH_Lmd_i_o_mult = 0;
  delete fH_Lmd_tot_mult; fH_Lmd_tot_mult = 0;

  delete fH_Lmd_map[0];   fH_Lmd_map[0] = 0;
  delete fH_Lmd_map[1];   fH_Lmd_map[1] = 0;
}
//_______________________________
void HdtAcc_Appl1::RemoveStbHistos(){

  delete fH_Stb_mult; fH_Stb_mult = 0;
  
  for(Int_t ch=0;ch<K_N_STB_CROWNS;ch++ ){
    delete fH_Stb_map[ch]; fH_Stb_map[ch] = 0;
    delete fH_Stb_Tdc[ch]; fH_Stb_Tdc[ch] = 0;
  }
  
}
//_______________________________
void HdtAcc_Appl1::RemoveNoiseHistos(){

  delete fH_Noise; fH_Noise = 0;
  delete fH_Noise_Err; fH_Noise_Err = 0;
  
}

  //_______________________________________________
  //_______________________________________________
  //_______________________________________________
void RunSummaryHistos(TString run_type="FINU",Int_t first_run = -1,Int_t last_run = -1,Int_t n_evs_run=-1,Int_t n_evs_tot=-1){
  // this is an application of the official method for reading HDT-files
  //  (see $FROOTSYS/mcr_included/AccessHDT_MultiRun.C

  enum E_DisplaySaveMode_e {
    E_DisSavMod_DoNothing = 0,
    E_DisSavMod_DrawOnly = 1,
    E_DisSavMod_SavePdfOnly = 2,
    E_DisSavMod_SaveRootOnly = 3,
    E_DisSavMod_Complete = 4
  };

  E_DisplaySaveMode_e display_mode = E_DisSavMod_Complete;

  HdtAcc_Appl1 *hdt_appl = new HdtAcc_Appl1();
  Int_t debug_lev = 0;
  //
  hdt_appl->SetVerboseLevel(0);
  hdt_appl->SetUpdateEvGap(3000);
  //
  hdt_appl->InitHistos();
  hdt_appl->Init("$MSQL_DB_HOST","$RDT",run_type,first_run,last_run,n_evs_run,n_evs_tot,debug_lev);

  Int_t res_loop =  hdt_appl->RunLoop();
  if( res_loop != 0 ) return;
  
  if(display_mode != E_DisSavMod_DoNothing){
    hdt_appl->DrawSummaryHistos();  
    if(display_mode == E_DisSavMod_SaveRootOnly || display_mode == E_DisSavMod_Complete)
      hdt_appl->SaveHistos(); 
    
    if(display_mode == E_DisSavMod_SavePdfOnly || display_mode == E_DisSavMod_Complete)
      hdt_appl->SaveSummaryPdf();// histograms will be lost after this line
    
    hdt_appl->CloseOutputFile();// histograms will be lost after this line
  }
  // --- 
  if(display_mode != E_DisSavMod_DrawOnly) delete hdt_appl; // need to keep histos
  
}

---