mcr/hdt_read/DefaultHistos.C

// First version (with lots of histograms)
//  of the FINUDA run-summary histograms production
// Date:   September 2006
// Author: Piergiorgio Cerello

#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"

using namespace FROOT;
//using namespace FROOT;

// Load Library for the PDF/PS management

Int_t fVerboseLev = 0;

//gSystem->Load("libPostscript.so");
TLegend *leg[30];
// 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_Tofi_High_mult; // multiplicity on high thresholds
TH1F *fH_Tofi_High_map; // pattern on high thresholds

TH1F *fH_Tof_map_ae[2];
TH1F *fH_Tof_map_ap[2];
TH1F *fH_Tof_map_te[2];
TH1F *fH_Tof_map_tp[2];
TH1F *fH_Tof_map_mt[2]; 
TH1F *fH_Tof_TotAdc[2][K_N_TOFONE_SLABS+1];
TH1F *fH_Tof_AvgTdc[2][K_N_TOFONE_SLABS+1];

// 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]; 
TH2F *fH_Lmd_map_ae[2];
TH2F *fH_Lmd_map_ap[2];
TH2F *fH_Lmd_map_te[2];
TH2F *fH_Lmd_map_tp[2];
TH1F *fH_Lmd_TotAdc[2][K_N_LMD_CHAMS_PER_LAYER+1];
TH1F *fH_Lmd_AvgTdc[2][K_N_LMD_CHAMS_PER_LAYER+1];

// Stb Histos

TH1F *fH_Stb_mult;
TH1F *fH_Stb_map[K_N_STB_CROWNS]; 
TH1F *fH_Stb_Tdc[K_N_STB_CROWNS];

TFile *fHdtFile = 0;

TFndHdt *fCurHdtEv = 0;
TTree *fHdtTree = 0;

TString fCanvTit = 0;
TString fCurRunName = 0;

TFndGenInfo *fRunInfo = 0;

void DeclareGtsHistos(){

  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 DeclareTofHistos(){

  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_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);

  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_Tof_map_ae[0] = new TH1F("tof_i_map_ae","Inner Tof Hit Map - ADC e-side",14,-0.5,13.5);
  fH_Tof_map_ae[1] = new TH1F("tof_o_map_ae","Outer Tof Hit Map - ADC e-side",74,-0.5,73.5);

  fH_Tof_map_ap[0] = new TH1F("tof_i_map_ap","Inner Tof Hit Map - ADC p-side",14,-0.5,13.5);
  fH_Tof_map_ap[1] = new TH1F("tof_o_map_ap","Outer Tof Hit Map - ADC p-side",74,-0.5,73.5);
   
  fH_Tof_map_te[0] = new TH1F("tof_i_map_te","Inner Tof Hit Map - TDC e-side",14,-0.5,13.5);
  fH_Tof_map_te[1] = new TH1F("tof_o_map_te","Outer Tof Hit Map - TDC e-side",74,-0.5,73.5);

  fH_Tof_map_tp[0] = new TH1F("tof_i_map_tp","Inner Tof Hit Map - TDC p-side",14,-0.5,13.5);
  fH_Tof_map_tp[1] = new TH1F("tof_o_map_tp","Outer Tof Hit Map - TDC p-side",74,-0.5,73.5);

  TString hname;
  TString htitle;

  for(Int_t lay=0;lay<2;lay++ ){
        for(Int_t ch=0;ch<12+60*lay;ch++ ){
          hname.Form("fH_Tof_TotAdc_%d_%d",lay+1,ch+1);
          htitle.Form("Tof Adc sqrt(e*p) lay: %d, slab: %d",lay+1,ch+1);
          fH_Tof_TotAdc[lay][ch] = new TH1F(hname,htitle,105,0,4200);
          hname.Form("fH_Tof_AvgTdc_%d_%d",lay+1,ch+1);
          htitle.Form("Tof Tdc (e+p)/2 lay: %d, slab: %d",lay+1,ch+1);
          fH_Tof_AvgTdc[lay][ch] = new TH1F(hname,htitle,105,0,4200);
          //Printf("Out name: \"%s\"",hname.Data());
    }
        Int_t idx = 12;
        if(lay == 1) idx = 72;
        hname.Form("fH_Tof_TotAdc_%d",lay+1);
    htitle.Form("Tof Adc sqrt(e*p) layer: %d, all slabs",lay+1);
        fH_Tof_TotAdc[lay][idx] = new TH1F(hname,htitle,105,0,4200);
        hname.Form("fH_Tof_AvgTdc_%d",lay+1);
        htitle.Form("Tof Tdc (e+p)/2 layer: %d, all slabs",lay+1);
        fH_Tof_AvgTdc[lay][idx] = new TH1F(hname,htitle,105,0,4200);
  }

}

void DeclareSilHistos(){

  fH_Sil_Patt_Clust_Low[0]  = new TH1F("ISIM_PATT_Low" ,"ISIM PATT Low",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 Low",10,-0.5,9.5);
  fH_Sil_Patt_Clust_High[1] = new TH1F("OSIM_PATT_High","OSIM PATT High",10,-0.5,9.5);

}

void DeclareLmdHistos(){

  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);   

  fH_Lmd_map_ae[0] = new TH2F("lmd_i_map_ae","Inner Lmd Hit Map (Wire vs Drift Number) - ADC e-side",
                              10,-0.5,9.5,14,-0.5,13.5);   
  fH_Lmd_map_ae[1] = new TH2F("lmd_o_map_ae","Outer Lmd Hit Map (Wire vs Drift Number) - ADC e-side",
                              10,-0.5,9.5,24,-0.5,23.5);

  fH_Lmd_map_ap[0] = new TH2F("lmd_i_map_ap","Inner Lmd Hit Map (Wire vs Drift Number) - ADC p-side",
                              10,-0.5,9.5,14,-0.5,13.5);   
  fH_Lmd_map_ap[1] = new TH2F("lmd_o_map_ap","Outer Lmd Hit Map (Wire vs Drift Number) - ADC p-side",
                              10,-0.5,9.5,24,-0.5,23.5);
   
  fH_Lmd_map_te[0] = new TH2F("lmd_i_map_te","Inner Lmd Hit Map (Wire vs Drift Number) - TDC e-side",
                              10,-0.5,9.5,14,-0.5,13.5);   
  fH_Lmd_map_te[1] = new TH2F("lmd_o_map_te","Outer Lmd Hit Map (Wire vs Drift Number) - TDC e-side",
                              10,-0.5,9.5,24,-0.5,23.5);

  fH_Lmd_map_tp[0] = new TH2F("lmd_i_map_tp","Inner Lmd Hit Map (Wire vs Drift Number) - TDC p-side",
                              10,-0.5,9.5,14,-0.5,13.5);   
  fH_Lmd_map_tp[1] = new TH2F("lmd_o_map_tp","Outer Lmd Hit Map (Wire vs Drift Number) - TDC p-side",
                              10,-0.5,9.5,24,-0.5,23.5);

  TString hname;
  TString htitle;

  Int_t idx = 8;
  for(Int_t lay=0;lay<2;lay++ ){
        for(Int_t ch=0;ch<K_N_LMD_CHAMS_PER_LAYER;ch++ ){
          hname.Form("fH_Lmd_TotAdc_%d_%d",lay+1,ch+1);
          htitle.Form("Lmd Adc (e+p) lay: %d, ch: %d",lay+1,ch+1);
          fH_Lmd_TotAdc[lay][ch] = new TH1F(hname,htitle,210,0,8400);
          hname.Form("fH_Lmd_AvgTdc_%d_%d",lay+1,ch+1);
          htitle.Form("Lmd Tdc (e+p)/2 lay: %d, ch: %d",lay+1,ch+1);
          fH_Lmd_AvgTdc[lay][ch] = new TH1F(hname,htitle,105,0,4200);
          //Printf("Out name: \"%s\"",hname.Data());
    }
        hname.Form("fH_Lmd_TotAdc_%d",lay+1);
        htitle.Form("Lmd Adc (e+p) layer: %d all wires",lay+1);
        fH_Lmd_TotAdc[lay][idx] = new TH1F(hname,htitle,210,0,8400);
        hname.Form("fH_Lmd_AvgTdc_%d",lay+1);
        htitle.Form("Lmd Tdc (e+p)/2 layer: %d all wires",lay+1);
        fH_Lmd_AvgTdc[lay][idx] = new TH1F(hname,htitle,105,0,4200);
  }
}

void DeclareStbHistos(){

  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 DeclareHistos(){
        DeclareGtsHistos();
        DeclareTofHistos();
        DeclareSilHistos();
        DeclareLmdHistos();
        DeclareStbHistos();
}

Int_t OpenHdtFile(const TString &runname){
  // return value:
  //              0: ok
  //             -1: file not found

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

  TString fnam;
  fnam.Form("%s/%s.hdt.root",ExpandPathName("$FND_HDT").Data(),runname.Data());
  
  if(gSystem->AccessPathName(fnam)){
    gROOT->Warning("OpenHdtFile","file \"%s\" not found",fnam.Data());
    return -1;
  }

  if(fVerboseLev > 1) gROOT->Info("OpenHdtFile","opening file \"%s\"",fnam.Data());
  fHdtFile = new TFile(fnam,"OPEN");
  fRunInfo = (TFndGenInfo *) fHdtFile->Get("TFndGenInfo");

  return 0;
}


Int_t LoadHdtTree(){
  // return value:
  //              0: ok
  //             -1: Problems while getting HDT tree from file
  
  
  fHdtTree = (TTree *) ( fHdtFile->Get("FIN_HDT_TREE") );
  if(!fHdtTree){
    gROOT->Warning("LoadHdtTree","Problems while getting HDT tree from file");
    return -1;
  }
  if(fVerboseLev > 1) fHdtTree->Print();

  fHdtTree->SetBranchAddress("fndhdt",&fCurHdtEv);
  return 0;
}


void 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));
  }  
}

void 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->PrintHit();
    cur_hit->GetLayer_Slab(lay,slab);
        //Printf("%d %d",lay, slab);
    //Printf("");
        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(ae>=0) fH_Tof_map_ae[lay-1]->Fill(slab); 
        if(ap>=0) fH_Tof_map_ap[lay-1]->Fill(slab); 
        if(te>=0) fH_Tof_map_te[lay-1]->Fill(slab); 
        if(tp>=0) fH_Tof_map_tp[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_TotAdc[lay-1][slab-1]->Fill(TMath::Sqrt(ae*ap));
        fH_Tof_AvgTdc[lay-1][slab-1]->Fill(0.5*(te+tp));
        Int_t idx = 12;
        if(slab > 12) idx = 72;
        fH_Tof_TotAdc[lay-1][idx]->Fill(TMath::Sqrt(ae*ap));
        fH_Tof_AvgTdc[lay-1][idx]->Fill(0.5*(te+tp));
  }   
  fH_Tof_i_o_mult->Fill(o_mult,i_mult);
  fH_Tofi_High_mult->Fill(i_high_mult);
}

void 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)
      fH_Sil_Patt_Clust_High[slay-1]->Fill(smod);
    //    else
      fH_Sil_Patt_Clust_Low[slay-1]->Fill(smod);

  }// hits loop end

}

void FillLmdHistos(){
  
  TClonesArray *LmdHits = fCurHdtEv->GetLmdHits();

  Int_t lay, cham, wire;
  TFndHLmd *cur_hit = 0;
  Int_t i_mult = 0;
  Int_t o_mult = 0;
  Int_t idx = 8;
  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);
        //Printf("%d %d %d",lay, cham, wire);
    //Printf("");
        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);
        if(ae>=0) fH_Lmd_map_ae[lay-1]->Fill(cham,wire); 
        if(ap>=0) fH_Lmd_map_ap[lay-1]->Fill(cham,wire); 
        if(te>=0) fH_Lmd_map_te[lay-1]->Fill(cham,wire); 
        if(tp>=0) fH_Lmd_map_tp[lay-1]->Fill(cham,wire);   
        fH_Lmd_TotAdc[lay-1][cham-1]->Fill(ae+ap);
        fH_Lmd_AvgTdc[lay-1][cham-1]->Fill(0.5*(te+tp));
        fH_Lmd_TotAdc[lay-1][idx]->Fill(ae+ap);
        fH_Lmd_AvgTdc[lay-1][idx]->Fill(0.5*(te+tp));
  }   
  fH_Lmd_i_o_mult->Fill(o_mult,i_mult);
  fH_Lmd_tot_mult->Fill(o_mult+i_mult);

}

void 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->PrintHit();
    cur_hit->GetCrown_Tube(crown, tube);
    //     Printf("%d %d %d",lay, cham, wire);
    //     Printf("");
        fH_Stb_map[crown-1]->Fill(tube);
        fH_Stb_Tdc[crown-1]->Fill(cur_hit->GetTdc());
  }   
}

void FillHistos(){
  //cout << "fill gts histos" << endl;
  FillGtsHistos();
  //cout << "fill tof histos" << endl;
  FillTofHistos();
  //cout << "fill sil histos" << endl;
  FillSilHistos();
  //cout << "fill lmd histos" << endl;
  FillLmdHistos();
  //cout << "fill stb histos" << endl;
  FillStbHistos();
}

void EventLoop(const Int_t &nevs){
  
  Int_t entries = fHdtTree->GetEntries();
  if(fVerboseLev > 2) cout << entries << " events in the run" << endl;
  
  Int_t cur_ev = 0;
  while(1){
    if(cur_ev >= entries){      
      if(fVerboseLev > 0) gROOT->Info("EventLoop","run completed");
      break;
    }
    if(nevs != -1 && cur_ev >= nevs){      
      if(fVerboseLev > 0) gROOT->Info("EventLoop","requested number of events reached");
      break;
    }
    //cout << "get event " << cur_ev << endl; 
    fHdtTree->GetEntry(cur_ev);
    //
    //cout << "fill histos" << endl;
    FillHistos();
    if(fVerboseLev > 2 || ( (cur_ev%1000)==0 && fVerboseLev>0) ) cout << "processing event: " << cur_ev << endl;
    //fCurHdtEv->PrintLmdHits();
    //
    cur_ev++;
  }
}

void 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 SaveTofHistos(){

  for(Int_t lay=0;lay<2;lay++ ){
        fH_Tof_map[lay]->Write();
        fH_Tof_map_ae[lay]->Write();
        fH_Tof_map_ap[lay]->Write();
        fH_Tof_map_te[lay]->Write();  
        fH_Tof_map_tp[lay]->Write();
        fH_Tof_map_mt[lay]->Write();

        for(Int_t slab=0;slab<=12+60*lay;slab++ ){
          fH_Tof_TotAdc[lay][slab]->Write();
          fH_Tof_AvgTdc[lay][slab]->Write();
        }   

  }
  fH_Tof_i_o_mult->Write();
}

void SaveSilHistos(){
  
  for(Int_t lay=0;lay<2;lay++){
    fH_Sil_Patt_Clust_Low[lay]->Write();
    fH_Sil_Patt_Clust_High[lay]->Write();
  }
  
}
  
void SaveLmdHistos(){
  for(Int_t lay=0;lay<2;lay++ ){
        fH_Lmd_map[lay]->Write();
        fH_Lmd_map_ae[lay]->Write();
        fH_Lmd_map_ap[lay]->Write();
        fH_Lmd_map_te[lay]->Write();  
        fH_Lmd_map_tp[lay]->Write();
        for(Int_t ch=0;ch<=K_N_LMD_CHAMS_PER_LAYER;ch++ ){
          fH_Lmd_TotAdc[lay][ch]->Write();
          fH_Lmd_AvgTdc[lay][ch]->Write();
        }   
  }
  fH_Lmd_i_o_mult->Write();
  fH_Lmd_tot_mult->Write();
}
  
void SaveStbHistos(){
  fH_Stb_mult->Write();
  for(Int_t crown=0;crown<K_N_STB_CROWNS;crown++ ){
        fH_Stb_map[crown]->Write();
        fH_Stb_Tdc[crown]->Write();
  }
}
  
void SaveHistos(TString &fname){        
  fname.Append("_monitor.root");
  TFile *fOutFile = new TFile(fname,"RECREATE");
  SaveGtsHistos();
  SaveTofHistos();
  SaveSilHistos();
  SaveLmdHistos();
  SaveStbHistos();
  fOutFile->Close();
  delete fOutFile;
  fOutFile = 0;
}


void 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 DrawGtsHistos(TCanvas *gts, TString &fname){
        gts->Clear();
        gts->Divide(2,4);
        for(Int_t k=0; k<4; k++) {
          gts->cd(2*k+1);
          fHPU_cont[k]->Draw();
          gts->cd(2*(k+1));
          fHPU_mult[k]->Draw();
        }
        gts->Print(fname.Data());
}

void DrawMultiplicityHistos(TCanvas *mlt, TString &fname){
        mlt->Clear();
        mlt->Divide(1,3);
        mlt->cd(1);
        fH_Tof_i_o_mult->Draw("zcol");
        mlt->cd(2);
        fH_Lmd_i_o_mult->Draw("zcol");
        mlt->cd(3);
        fH_Stb_mult->Draw();
        mlt->Print(fname.Data());
}

void DrawTofHistos(TCanvas *tof, TString &fname){

        tof->Clear();
        tof->Divide(2,3);
        TH1D *i_mult = fH_Tof_i_o_mult->ProjectionY();
        i_mult->SetTitle("tofino multiplicity");
        tof->cd(1);
        i_mult->Draw();
        tof->cd(2);
        fH_Tof_map[0]->Draw();
        tof->cd(3);
        fH_Tof_map_ae[0]->Draw();       
        tof->cd(4);
        fH_Tof_map_ap[0]->Draw();
        tof->cd(5);
        fH_Tof_map_te[0]->Draw();
        tof->cd(6);
        fH_Tof_map_tp[0]->Draw();
        tof->Print(fname.Data());

        tof->Clear();
        tof->Divide(2,3);
        TH1D *o_mult = fH_Tof_i_o_mult->ProjectionX();
        o_mult->SetTitle("TOFONE multiplicity");
        tof->cd(1);
        o_mult->Draw();
        tof->cd(2);
        fH_Tof_map[1]->Draw();
        tof->cd(3);
        fH_Tof_map_ae[1]->Draw();       
        tof->cd(4);
        fH_Tof_map_ap[1]->Draw();
        tof->cd(5);
        fH_Tof_map_te[1]->Draw();
        tof->cd(6);
        fH_Tof_map_tp[1]->Draw();
        tof->Print(fname.Data());

        tof->Clear();
        tof->Divide(2,2);
        tof->cd(1);
        fH_Tof_TotAdc[0][12]->Draw();
        tof->cd(2);
        fH_Tof_AvgTdc[0][12]->Draw();
        tof->cd(3);
        fH_Tof_TotAdc[1][72]->Draw();
        tof->cd(4);
        fH_Tof_AvgTdc[1][72]->Draw();
        tof->Print(fname.Data());
}

void DrawLmdHistos(TCanvas *lmd, TString &fname){

        lmd->Clear();
        lmd->Divide(2,3);
        TH1D *i_mult = fH_Lmd_i_o_mult->ProjectionY();
        i_mult->SetTitle("Inner LMD multiplicity");
        lmd->cd(1);
        i_mult->Draw();
        lmd->cd(2);
        fH_Lmd_map[0]->Draw("zcol");
        lmd->cd(3);
        fH_Lmd_map_ae[0]->Draw("zcol"); 
        lmd->cd(4);
        fH_Lmd_map_ap[0]->Draw("zcol");
        lmd->cd(5);
        fH_Lmd_map_te[0]->Draw("zcol");
        lmd->cd(6);
        fH_Lmd_map_tp[0]->Draw("zcol");
        lmd->Print(fname.Data());

        lmd->Clear();
        lmd->Divide(2,3);
        TH1D *o_mult = fH_Lmd_i_o_mult->ProjectionX();
        o_mult->SetTitle("Outer LMD multiplicity");
        lmd->cd(1);
        o_mult->Draw();
        lmd->cd(2);
        fH_Lmd_map[1]->Draw("zcol");
        lmd->cd(3);
        fH_Lmd_map_ae[1]->Draw("zcol"); 
        lmd->cd(4);
        fH_Lmd_map_ap[1]->Draw("zcol");
        lmd->cd(5);
        fH_Lmd_map_te[1]->Draw("zcol");
        lmd->cd(6);
        fH_Lmd_map_tp[1]->Draw("zcol");
        lmd->Print(fname.Data());

        for(Int_t j=0;j<2;j++) {
          lmd->Clear();
          lmd->Divide(2,4);
          for(Int_t i=0;i<8;i++) {
                lmd->cd(i+1);
                fH_Lmd_TotAdc[j][i]->Draw();
          }
          lmd->Print(fname.Data());
        }
        
        for(Int_t j=0;j<2;j++) {
          lmd->Clear();
          lmd->Divide(2,4);
          for(Int_t i=0;i<8;i++) {
                lmd->cd(i+1);
                fH_Lmd_AvgTdc[j][i]->Draw();
          }
          lmd->Print(fname.Data());
        }
        
}

void DrawStbHistos(TCanvas *stb, TString &fname){

        stb->Clear();
        stb->Divide(2,3);
        for(Int_t i=0;i<6;i++) {
          stb->cd(i+1);
          fH_Stb_map[i]->Draw();
        }
        stb->Print(fname.Data());

        stb->Clear();
        stb->Divide(2,3);
        for(Int_t i=0;i<6;i++) {
          stb->cd(i+1);
          fH_Stb_Tdc[i]->Draw();
        }
        stb->Print(fname.Data());
}

void DrawHistos(TString &fname){        
  TString pdfname(fname);
  pdfname.Append(".pdf");
  fname.Append(".ps");

  gStyle->SetPalette(1,0);
  TCanvas *fCanvas = new TCanvas("FND_Monitor","FND_Monitor",580,840);
  TString cName(fname.Data());
  cName.Append("[");
  fCanvas->Print(cName.Data());
  DrawGtsHistos(fCanvas,fname);
  DrawMultiplicityHistos(fCanvas,fname);
  DrawTofHistos(fCanvas,fname);
  DrawLmdHistos(fCanvas,fname);
  DrawStbHistos(fCanvas,fname);
  TString dName(fname.Data());
  dName.Append("]");
  fCanvas->Print(dName.Data());
  TString cmd("ps2pdf ");
  cmd.Append(fname.Data());
  cmd.Append(" ");
  cmd.Append(pdfname.Data());
  if(fVerboseLev > 2) cout << "command is " << cmd.Data() << endl;
  gSystem->Exec(cmd.Data());
  TString cmd1("rm ");
  cmd1.Append(fname.Data());
  gSystem->Exec(cmd1.Data());
}


void EvalPatternUnit(){

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

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

  Float_t thr = max/10;
  if(fVerboseLev > 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(fVerboseLev > 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(fVerboseLev > 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 = 0x432;
  UInt_t cosm_code = 0x450;

  UInt_t chk_bhabha = b_on_code & bhabha_code;
  UInt_t chk_hype   = b_on_code & hype_code;
  UInt_t chk_cosm   = b_on_code & cosm_code;

  if(fVerboseLev > 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);
  }

  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;

  TString res_msg = "TRIG: ";
  if(rec_bha && ( (b_on_code & 0x40) == 0) )  res_msg += " BHA ";
  if(rec_hyp && ( (b_on_code & 0x40) == 0) ){
    res_msg += " HYP ";
    if( (b_over_th_code & 0x4) == 0) res_msg = " HYP ";
  }
  if(rec_cosm) res_msg += " COSM ";
  
  if(res_msg.CompareTo("TRIG: ")==0) res_msg = " ? ";

  if(fVerboseLev > 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(fRunInfo){
    //    fRunInfo->Print();
    TDatime rdatime = fRunInfo->GetDateTime();
    rtim_str.Form(" (%s)",rdatime.AsSQLString());
    fCanvTit+=rtim_str;
  }

}

void DrawSummaryHistos(TString &fname){ 

  TString pdfname = fname;
  pdfname+=".pdf";

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

  TString title = fCanvTit;
  TString filename = pdfname;
  Int_t TitColor = -1;
  Double_t pad_tit_h = 0.05;
  Double_t TitSize = 0.5;
  // ---
   
  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
  TH1D *i_mult = fH_Tof_i_o_mult->ProjectionY();
  i_mult->SetAxisRange(-0.5,7.5,"X");
  i_mult->SetName("TOFINO MT multiplicity");
  i_mult->SetTitle("TOFINO MT multiplicity");
  SetHistoProperties(i_mult,1);
  i_mult->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() > i_mult->GetMaximum() ) i_mult->SetAxisRange(0,fH_Tofi_High_mult->GetMaximum(),"Y");

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

  pd->cd(2);
  TH1D *o_mult = fH_Tof_i_o_mult->ProjectionX();
  o_mult->SetAxisRange(-0.5,15.5,"X");
  o_mult->SetTitle("TOFONE MT multiplicity");
  SetHistoProperties(o_mult,0);
  o_mult->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-low 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();


  // --- SAVE PDF
  fCanvas->cd();
  fCanvas->SaveAs(filename);
  /* first summary without SIL histos
    fCanvas->Divide(2,3);
    fCanvas->cd(1);
    TH1D *i_mult = fH_Tof_i_o_mult->ProjectionY();
    i_mult->SetAxisRange(-0.5,7.5,"X");
    i_mult->SetTitle("tofino multiplicity");
    i_mult->Draw();
    fCanvas->cd(2);
    TH1D *o_mult = fH_Tof_i_o_mult->ProjectionX();
    o_mult->SetAxisRange(-0.5,15.5,"X");
    o_mult->SetTitle("TOFONE multiplicity");
    o_mult->Draw();
    fCanvas->cd(3);
    fH_Lmd_tot_mult->SetAxisRange(-0.5,14.5,"X");
    fH_Lmd_tot_mult->Draw();  
    fCanvas->cd(4);
    fH_Stb_mult->SetAxisRange(-0.5,34.5,"X");
    fH_Stb_mult->Draw();
    fCanvas->cd(5);
    fH_Tof_map_mt[0]->SetAxisRange(-0.5,12.5,"X");
    fH_Tof_map_mt[0]->Draw();
    fCanvas->cd(6);
    fH_Tof_map_mt[1]->SetAxisRange(-0.5,72.5,"X");
    fH_Tof_map_mt[1]->Draw();
  */
  //  Gui::SaveCanvasWithTitle(fCanvas,fCanvTit,pdfname,"","",-1,0.05,0.3);

  // --- PU1 histogram (used for checking trigger)
  //   TCanvas *c_remove = new TCanvas();
  //   fHPU_cont[0]->Draw();
  
}

void DefaultHistos(const TString &runtype,const Int_t &run_num,const Int_t &nOfRuns = 1, const Int_t &nevs = 10000000){

  DeclareHistos();
  if(fVerboseLev > 0) cout << "Loop on " << nOfRuns << " runs" << endl;
  for(Int_t irun=0;irun<nOfRuns;irun++) {
        if(fVerboseLev > 0) cout << "run " << irun+1 << " of " << nOfRuns << endl;
        fCurRunName = BuildRunName(runtype,run_num+irun);

        if(fVerboseLev > 2) cout << "open hdt" << endl;
        if(OpenHdtFile(fCurRunName) !=0) continue;

        if(fVerboseLev > 2) cout << "load tree" << endl;
        if(LoadHdtTree() != 0) continue;

        if(fVerboseLev > 2) cout << "event loop" << endl;
        EventLoop(nevs);
  }
  TString fullrunname = BuildRunName(runtype,run_num);
  fullrunname.Append("-");
  TString finalrunname = BuildRunName(fullrunname,run_num+nOfRuns-1);
  finalrunname.Prepend(FROOT::ExpandPathName("$FND_HISTOS/").Data());
  SaveHistos(finalrunname);
  if(fVerboseLev > 2) cout << "Run name: " << finalrunname.Data() << endl;

  EvalPatternUnit();

  if(nOfRuns == 1) {
    DrawSummaryHistos(finalrunname);
  }
  else
        DrawHistos(finalrunname);
}

---