SIL/TFndSilMonFrame.cxx

// @(#)fROOT/SIL:$Name:  $:$Id: TFndSilMonFrame.cxx,v 1.21 2007/09/24 07:32:41 Diego_Faso Exp $
// Revision Author: Diego Faso <mailto:faso@to.infn.it>, 2005/06/24
// Original Author: Piergiorgio Cerello <mailto:cerello@to.infn.it>, Diego Faso <mailto:faso@to.infn.it>, 2002

//                                                //
//               TFndSilMonFrame                  //
//                                                //
//  Class for the SIL monitoring GUI              //
//                                                //
//                                                //

#include <TROOT.h>
#include <TSystem.h>
#include <TStyle.h>
#include <TLine.h>
#include <TFile.h>
#include <TThread.h>

#include "TFndSilMonFrame.h"
#include "TFndRun.h" 



ClassImp(TFndSilMonFrame)
 
//________________________________________
TFndSilMonFrame::TFndSilMonFrame(TString filename, TString filename2):
  TFndMonFrame(filename, filename2),
  fLayer(),fModNum(),fSide(),fSideHighlightCol(),
  fIsmMapFile(),fOsmMapFile(),
  fIsimPad(),fOsimPad(),fAllPadControl(),
  fModNumBut(),fAllButton(),
  fSideSelPad(),fModAllBut(),fSideBut(),
  fHisto(),
  fWhichGroup(-1),fAllId(-1)
{

  //  Printf("TFndSilMonFrame::DEBUG!!!!!!!!! \"%s\" --- \"%s\"",filename.Data(),filename2.Data());
  Init();
}

//________________________________________
TFndSilMonFrame::~TFndSilMonFrame() {
   
  if(!fClosed) Close();
}
  
//________________________________________
void TFndSilMonFrame::Init(){

  SetStyle();
  fSideHighlightCol = 3;

  // --- set names of all histos
  //   fNam_Noise[E_FIN_OUTER_LAYER][K_N_Sil_Modules][K_N_Sil_Sides];
  //   fNam_Mult[E_FIN_OUTER_LAYER][K_N_Sil_Modules][K_N_Sil_Sides];
  //   fNam_ClCh[E_FIN_OUTER_LAYER][K_N_Sil_Modules][K_N_Sil_Sides];
  //   fNam_CMsigma[E_FIN_OUTER_LAYER][K_N_Sil_Modules][K_N_Sil_Sides];
  //   fNam_CMmean[E_FIN_OUTER_LAYER][K_N_Sil_Modules][K_N_Sil_Sides];
  //   fNam_CleanMult[E_FIN_OUTER_LAYER][K_N_Sil_Modules][K_N_Sil_Sides-1];
  //   fNam_ClChClean[E_FIN_OUTER_LAYER][K_N_Sil_Modules][K_N_Sil_Sides-1];
  //   fNam_dEdx[E_FIN_OUTER_LAYER][K_N_Sil_Modules][K_N_Sil_Sides-1];
  //   fNam_dEdx_PvsZ[E_FIN_OUTER_LAYER][K_N_Sil_Modules];
  //   fNam_Pos_PvsZ[E_FIN_OUTER_LAYER][K_N_Sil_Modules];
  
  TString hnam = "";  

  TString CluHNam = "";

  TString det_nam = "";
  for(Int_t lay_idx = 0; lay_idx <=1 ; lay_idx++){
    det_nam = (lay_idx == 0) ? "Isim" : "Osim"; 
    
    for(Int_t mod = 0; mod < K_N_Sil_Modules; mod++){
      if(lay_idx ==0 && mod > 7) break; // only 8 moduls for ISIM
      for(Int_t sid = 0; sid < K_N_Sil_Sides; sid++){
        
        hnam.Form("%sNoise_%d_%s",det_nam.Data(),mod+1,SilSide_Name(sid).Data());
        fNam_Noise[lay_idx][mod][sid] = hnam;
        
        hnam.Replace(4,5,"Mult");
        fNam_Mult[lay_idx][mod][sid] = hnam;
        
        hnam.Replace(4,4,"ClustCharge");
        fNam_ClCh[lay_idx][mod][sid] = hnam;
        
        hnam.Replace(4,11,"CM_sigma");
        fNam_CMsigma[lay_idx][mod][sid] = hnam;
        
        //      hnam.Replace(4,11,"CM_sigma");
        //      fNam_CMsigma[lay_idx][mod][sid] = hnam;
        
        hnam.Replace(4,8,"CM_mean");
        fNam_CMmean[lay_idx][mod][sid] = hnam;
        if(sid < 2){
          TString sidnam = ( sid == 0 ) ? "PHI" : "Z";

          CluHNam.Form("%s_CleanMult_%d_%s",det_nam.Data(),mod+1,sidnam.Data() );
          fNam_CleanMult[lay_idx][mod][sid] = CluHNam;

          CluHNam.Form("%s_ClustChClean_%d_%s",det_nam.Data(),mod+1,sidnam.Data() );
          fNam_ClChClean[lay_idx][mod][sid] = CluHNam;

          CluHNam.Form("%s_dEdx_%d_%s",det_nam.Data(),mod+1,sidnam.Data() );
          fNam_dEdx[lay_idx][mod][sid] = CluHNam;         
        }
        
        if(sid == 0){
          CluHNam.Form("%s_dEdx_PvsZ_%d",det_nam.Data(),mod+1 );
          fNam_dEdx_PvsZ[lay_idx][mod] = CluHNam;
          
          CluHNam.Form("%s_Pos_PvsZ_%d",det_nam.Data(),mod+1 );
          fNam_Pos_PvsZ[lay_idx][mod] = CluHNam;
        }
        
      }
    }
  }
  
  // Uncomment following lines for debugging purposes only!
  /*
   for(Int_t lay_idx = 0; lay_idx <=1 ; lay_idx++){    
     for(Int_t mod = 0; mod < K_N_Sil_Modules; mod++){
       if(lay_idx ==0 && mod > 7) break; // only 8 moduls for ISIM
       for(Int_t sid = 0; sid < K_N_Sil_Sides; sid++){
         
         Printf("====> Noise   : \"%s\"",fNam_Noise[lay_idx][mod][sid].Data()); 
         Printf("====> Mult    : \"%s\"",fNam_Mult[lay_idx][mod][sid].Data());  
         Printf("====> ClCrg   : \"%s\"",fNam_ClCh[lay_idx][mod][sid].Data());  
         Printf("====> CM_sigma: \"%s\"",fNam_CMsigma[lay_idx][mod][sid].Data());       
         Printf("====> CM_mean : \"%s\"",fNam_CMmean[lay_idx][mod][sid].Data());        
       }
     }
   }
  */

  //  fndrun->SetSilMonFrame(this);
  //  StartInterface();
}

//________________________________________
void TFndSilMonFrame::Open() {

  if(!fClosed) return; 
  if(!StartInterface()) return;
  fClosed = kFALSE;
}

//________________________________________
Bool_t TFndSilMonFrame::StartInterface() {
  
  Int_t BackgroundCol = 12; // was 40
  Int_t DisplayPadCol = 15; // was 4

  Float_t sep = 0.001;
  Float_t smallsep = 0.0005;

  Float_t Start_X_displaypad = 0.06;
  Float_t Stop_X_displaypad  = 1.;
  Float_t Start_Y_displaypad = 0.05;
  Float_t Stop_Y_displaypad  = 0.95;

  Float_t Sep_IsmOsmPads  = 0.5;
  Float_t Sep_SideChipPads  = 0.35;

  // Stop here if no source file was found
  if(!fCanStartGUI) return kFALSE;

  fLayer=0;
  fSide=1;
  fModNum=1;
  
  ReloadMapFiles();
  //   fCanStartGUI = ReloadMapFiles();
  //   if(!fCanStartGUI) return;
  
  if (fRF && fRF2)  cout << "...source files found...starting GUI" << endl;
  
  fMainCanvas[0] = new TCanvas("Sil_MainCanvas","SIL Main Canvas",
                               fMainCanvCoord[0],fMainCanvCoord[1],
                               fMainCanvCoord[2],fMainCanvCoord[3]);
  SetMonitorTitle(0,"SIL");
  fMainCanvas[0]->SetEditable(kFALSE);
  //  fMainCanvas[0]->ToggleEventStatus();
  fMainCanvas[0]->SetFillColor(BackgroundCol);
  fMainCanvas[0]->Draw();
  
  fDisplayPad[0] = new TPad("SilMonFrameDisplayPad","SIL hist display",
                         Start_X_displaypad+sep,Start_Y_displaypad+sep,Stop_X_displaypad,Stop_Y_displaypad-sep);
  fDisplayPad[0]->Draw();
  fDisplayPad[0]->SetFillColor(DisplayPadCol);
  fDisplayPad[0]->SetBorderSize(2);
  
  // --- allpadcontrol (bottom)
  fAllPadControl=new TPad("allpadcontrol","allpadcontol",Start_X_displaypad+sep,0,Stop_X_displaypad,Start_Y_displaypad-sep);
  fAllPadControl->Draw();
  
  fOsimPad=new TPad("ismSelectionpad","ismSelectionpad",0.,0.,Start_X_displaypad-sep,Sep_IsmOsmPads-smallsep);
  fOsimPad->SetFillColor(13);
  fOsimPad->Draw();
  
  fIsimPad=new TPad("osmSelectionpad","osmSelectionpad",0.,Sep_IsmOsmPads+smallsep,Start_X_displaypad-sep,Stop_Y_displaypad-sep);
  fIsimPad->SetFillColor(13);
  fIsimPad->Draw();

  // Control Pads
  fMainCanvas[0]->cd();

  fSideSelPad =new TPad("selectside","sd",0.,Stop_Y_displaypad+sep,Sep_SideChipPads-smallsep,1.);
  fSideSelPad->Draw();
  
  DrawButtons();
  BuildConnections();


  return kTRUE;
  //  fClosed = kFALSE;
}

//________________________________________
void TFndSilMonFrame::Close() {
  // the consumer should not close shared memories

  
  if(!fClosed){
    delete fHisto; 
    
    cout << "...closing and re-initializing to zero all mapfiles..." << endl;    
    if(fIsmMapFile) {fIsmMapFile->Close(); fIsmMapFile = 0; }
    if(fOsmMapFile) {fOsmMapFile->Close(); fOsmMapFile = 0; }
    cout << "...done (Close)" << endl;
    
    for(Int_t i=0;i<8;i++) { delete fModNumBut[i]; fModNumBut[i] = 0; } // ISIM buttons
    for(Int_t i=8;i<18;i++){ delete fModNumBut[i]; fModNumBut[i] = 0; } // OSIM buttons
    
    for(Int_t i=0;i<8;i++){ delete fAllButton[i]; fAllButton[i] = 0; }

    delete fModAllBut;
    for(Int_t i=0;i<4;i++){ delete fSideBut[i]; fSideBut[i] = 0; }
    
    fIsimPad->Close();       delete fIsimPad;       fIsimPad = 0;
    fOsimPad->Close();       delete fOsimPad;       fOsimPad = 0;
    fSideSelPad->Close();    delete fSideSelPad;    fSideSelPad = 0;
    fAllPadControl->Close(); delete fAllPadControl; fAllPadControl = 0;
  }
  
  fClosed = kTRUE;
}  

//________________________________________
Bool_t TFndSilMonFrame::ReloadMapFiles(){
  
  Bool_t result = kTRUE;
  if(!fIsOnline) return result;

  if( CheckProducerMessages() != 0 ) return kFALSE; // chech if shared memories are busy (producer message)
  TString shr_file_map_name[2] = 0;

#if defined _FND_ONL_USE_MAP_FILES_
  if(fndrun->GetDebug())cout << "...closing and re-initializing to zero all mapfiles..." << endl;    
  if(fIsmMapFile) {fIsmMapFile->Close(); fIsmMapFile = 0; }
  if(fOsmMapFile) {fOsmMapFile->Close(); fOsmMapFile = 0; }
  if(fndrun->GetDebug())cout << "...done" << endl;
  //
  shr_file_map_name[0] = "$FND_SHR/ism.map";
  shr_file_map_name[1] = "$FND_SHR/osm.map";
#elif defined _FND_ONL_USE_SHARED_FILES_
  if(fIsmMapFile) { if(fIsmMapFile->IsOpen()) fIsmMapFile->Close(); delete fIsmMapFile; fIsmMapFile = 0; }
  if(fOsmMapFile) { if(fOsmMapFile->IsOpen()) fOsmMapFile->Close(); delete fOsmMapFile; fOsmMapFile = 0; }
  if(fndrun->GetDebug())cout << "...done" << endl;
  //
  shr_file_map_name[0] = "$FND_SHR/ism.file.map";
  shr_file_map_name[1] = "$FND_SHR/osm.file.map";
#endif

  if(fndrun->GetDebug()) cout << endl << "Reloading shared memories..." << endl;
  
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[0].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    fIsmMapFile = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[0].Data()),"READ");   
    if(fndrun->GetDebug()) fIsmMapFile->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    fIsmMapFile = new TFile(FROOT::ExpandPathName(shr_file_map_name[0].Data()),"READ");   
    Info("TFndSilMonFrame::ReloadMapFiles","Reloading shared file \"%s\"",shr_file_map_name[0].Data());
#endif
  }
  else result = kFALSE;
  
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[1].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    fOsmMapFile = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[1].Data()),"READ");   
    if(fndrun->GetDebug()) fOsmMapFile->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    fOsmMapFile = new TFile(FROOT::ExpandPathName(shr_file_map_name[1].Data()),"READ");   
    Info("TFndSilMonFrame::ReloadMapFiles","Reloading shared file \"%s\"",shr_file_map_name[1].Data());
#endif
  }
  else result = kFALSE;

  if(fndrun->GetDebug()) {
    if(result) cout << "...done" << endl << endl;
    else cout << "SIL - shared memories not found!" << endl << endl;
  }
  return result;
}

//________________________________________
void TFndSilMonFrame::DrawButtons() {

  fMainCanvas[0]->cd();

  TString but_label = "";
  TString but_cmd = "";
  // ISIM  Sidepads
  fIsimPad->cd();
  for(Int_t j=0;j<8;j++){
    but_cmd = TString("fndrun->SilMonFrame()->SelectModule(1,");
    but_cmd+=j+1;
    but_cmd+="); ";
    but_cmd+="fndrun->SilMonFrame()->DisplayModuleDefault();";

    but_label.Form("i_%i",j+1);
    //     but_label  = TString("i_");
    //     but_label+=j+1;

    fModNumBut[j]=new TButton(but_label.Data(),but_cmd.Data(),0.00,0.125*j,1.0,0.125*(j+1));
    fModNumBut[j]->Draw();
  }

  // OSIM  Sidepads
  fOsimPad->cd();
  for(Int_t j=0;j<10;j++){
    but_cmd = TString("fndrun->SilMonFrame()->SelectModule(2,");
    but_cmd+=j+1;
    but_cmd+="); ";
    but_cmd+="fndrun->SilMonFrame()->DisplayModuleDefault();";

    but_label.Form("o_%i",j+1);
    //     but_label  = TString("o_");
    //     but_label+=j+1;
    
    fModNumBut[8+j]=new TButton(but_label.Data(),but_cmd.Data(),0.00,0.10*j,1.0,0.10*(j+1));
    fModNumBut[8+j]->Draw();
  }

  // Global  Sidepads
  fAllPadControl->cd();
  
  Float_t step = 1./8.;
  Float_t xi = 0.;
  Float_t xf = step;
  fAllButton[0]=new TButton("ISM mult","fndrun->SilMonFrame()->DisplayAllHist(1,1);",xi,0,xf,1);
  fAllButton[0]->Draw(); 
  xi = xf;
  xf += step;
  fAllButton[1]=new TButton("OSM mult","fndrun->SilMonFrame()->DisplayAllHist(2,1);",xi,0,xf,1);
  fAllButton[1]->Draw(); 
  xi = xf;
  xf += step;
  fAllButton[2]=new TButton("ISM nois","fndrun->SilMonFrame()->DisplayAllHist(1,0);",xi,0,xf,1); 
  fAllButton[2]->Draw();        
  xi = xf;
  xf += step;
  fAllButton[3]=new TButton("OSM nois","fndrun->SilMonFrame()->DisplayAllHist(2,0);",xi,0,xf,1); 
  fAllButton[3]->Draw();        
  xi = xf;
  xf += step;
  fAllButton[4]=new TButton("ISM CM_s","fndrun->SilMonFrame()->DisplayAllHist(1,3);",xi,0,xf,1);
  fAllButton[4]->Draw();
  xi = xf;
  xf += step;
  fAllButton[5]=new TButton("OSM CM_s","fndrun->SilMonFrame()->DisplayAllHist(2,3);",xi,0,xf,1);
  fAllButton[5]->Draw();
  xi = xf;
  xf += step;
  fAllButton[6]=new TButton("ISM clu","fndrun->SilMonFrame()->DisplayAllHist(1,4);",xi,0,xf,1);
  fAllButton[6]->Draw();
  xi = xf;
  xf += step;
  fAllButton[7]=new TButton("OSM clu","fndrun->SilMonFrame()->DisplayAllHist(2,4);",xi,0,xf,1);
  fAllButton[7]->Draw();

  ResetFrameColors();
}

//________________________________________
void TFndSilMonFrame::ResetFrameColors(){
  
  for(Int_t i=0;i<8;i++){
    fModNumBut[i]->SetFillColor(50); // ISIM
    fModNumBut[i]->Modified();
  }

  for(Int_t i=8;i<18;i++){
    fModNumBut[i]->SetFillColor(38); // OSIM
    fModNumBut[i]->Modified();
  }

  for(Int_t i=0;i<8;i++){ 
    if(i%2==0) fAllButton[i]->SetFillColor(42); 
    else fAllButton[i]->SetFillColor(33); 
    fAllButton[i]->Modified();
  }

  if(fModAllBut){
    fModAllBut->SetFillColor(25);
    fModAllBut->Modified();
  }
  for(Int_t i=0;i<4;i++){
    if(fSideBut[i]){
      fSideBut[i]->SetFillColor(25);
      fSideBut[i]->Modified();
    }
  }

}

//____________________________________________________
TButton *TFndSilMonFrame::HighlightButtons(Int_t which_group,Int_t All_id){
  // whichgroup: 
  //            0->Module   : Module number
  //            1->Mod-Side : Module number, side
  //            2->All      : current allbutton only

  fWhichGroup = which_group;
  fAllId = All_id;

  Int_t mod_id = ( (fLayer-1) *8 + fModNum)-1;
  //  cout << "Highlighting button for module index: " << mod_id << endl;

  switch(which_group){
  case 0:
    fModNumBut[mod_id]->SetFillColor(fHighlightCol[fLayer]);
    fModNumBut[mod_id]->Modified();
    return fModNumBut[mod_id];
    //break;
  case 1:
    fModNumBut[mod_id]->SetFillColor(fHighlightCol[fLayer]);
    fModNumBut[mod_id]->Modified();
    if(fSide == -1){
      fModAllBut->SetFillColor(fSideHighlightCol);
      fModAllBut->Modified();
      return fModAllBut;
    }
    else{ // all sides
      fSideBut[fSide]->SetFillColor(fSideHighlightCol);
      fSideBut[fSide]->Modified();
      return fSideBut[fSide];
    }
    //break;
  case 2:
    fAllButton[All_id]->SetFillColor(fHighlightCol[fLayer]);
    fAllButton[All_id]->Modified();
    //    fAllPadControl->Modified();
    return fAllButton[All_id];
    //break;
  default: return 0;
  }
}

//___________________________________________
void TFndSilMonFrame::RefreshSingleMonView(){

  if(fWhichGroup ==- 1 || fAllId == - 1) return;
  FlashDisplayPad();
  HighlightButtons(fWhichGroup,fAllId)->ExecuteEvent(11,0,0);
}

//________________________________________
void TFndSilMonFrame::ClearSidePad(){

  delete fModAllBut; fModAllBut = 0;
  for(Int_t i=0;i<4;i++) { delete fSideBut[i];fSideBut[i] = 0; }
}

//________________________________________
void TFndSilMonFrame::RebuildSidePad() {

  Bool_t rcheck = kTRUE;
  for(Int_t i=0;i<4;i++){
    rcheck = rcheck && fModAllBut;
    rcheck = rcheck && fSideBut[i];
  }
  if(rcheck) {
    //    cout << "SidePad already built" << endl;
    return;
  }
  //  cout << "rebuilding SidePad" << endl;

  fSideSelPad->cd(); 
  fModAllBut=new TButton("All-Sides",
                         "fndrun->SilMonFrame()->DisplayHist(1);",
                         0. , 0. , .2 , 1. );
  fModAllBut->Draw(); 
  //
  fSideBut[0]=new TButton("Phi",
                            "fndrun->SilMonFrame()->SelectSide(0);fndrun->SilMonFrame()->DisplayHist(0);",
                            .2 , 0. , .4 , 1. );
  fSideBut[0]->Draw();  
  // ---
  fSideBut[1]=new TButton("ZA",
                            "fndrun->SilMonFrame()->SelectSide(1);fndrun->SilMonFrame()->DisplayHist(0);",
                            .4 , 0. , .6 , 1. );
  fSideBut[1]->Draw();  
  // ---
  fSideBut[2]=new TButton("ZB",
                            "fndrun->SilMonFrame()->SelectSide(2);fndrun->SilMonFrame()->DisplayHist(0);",
                            .6 , 0. , .8 , 1. );
  fSideBut[2]->Draw(); 
  // ---
  fSideBut[3]=new TButton("Phi vs Z",
                            "fndrun->SilMonFrame()->SelectSide(3);fndrun->SilMonFrame()->DisplayHist(0);",
                            .8 , 0. , 1. , 1. );
  fSideBut[3]->Draw(); 
  // ---
  fSideSelPad->Modified();

}

//________________________________________
void TFndSilMonFrame::DisplayModuleDefault(){
 
  //  Printf("Displaying default!!!!!!!!!!!!!!!!!!!!!!!!!!!!1");
  SelectSide(3);
  DisplayHist(0);

}

//________________________________________
void TFndSilMonFrame::DisplayHist(Int_t display_mode){
  
  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }
  //  cout << "Displaying hist for detector \"" << fLayer << "\" --- module \"" << fModNum << "\"" << endl;
  Int_t   EachPadCol1 = 17;
  Float_t Margin1     = 0.007;
  Int_t   EachPadCol2 = 19;
  Float_t Margin2     = 0.002;
  
  fDisplayPad[0]->Clear();
  
  if(display_mode == (Int_t)E_SilHist_Displ_SingleSide ){
    if(fSide == 3){ // clusters control
      fDisplayPad[0]->Divide(1,2,Margin1,Margin1,EachPadCol1);
      fDisplayPad[0]->GetPad(1)->Divide(2,2,Margin2,Margin2,EachPadCol2);;
      fDisplayPad[0]->GetPad(2)->Divide(2,1,Margin2,Margin2,EachPadCol2);;
      
      for(Int_t si=0;si<2;si++){
        fSide = si;
        fDisplayPad[0]->GetPad(1)->cd(1 + si );
        DrawHist(E_SilHist_CluDeDx);
        
        fDisplayPad[0]->GetPad(1)->cd(3 + si );
        DrawHist(E_SilHist_CluCleanMult);
      }
      
      fDisplayPad[0]->GetPad(2)->cd(1);
      DrawHist(E_SilHist_CluDeDx2D);
      
      fDisplayPad[0]->GetPad(2)->cd(2);
      DrawHist(E_SilHist_CluPos2D);      
      
      // --- 
      fSide = 3;
    }
    else{ // single side
      fDisplayPad[0]->Divide(1,2,Margin1,Margin1,EachPadCol1);
      fDisplayPad[0]->GetPad(1)->Divide(1,2,Margin2,Margin2,EachPadCol2);
      fDisplayPad[0]->GetPad(2)->Divide(2,1,Margin2,Margin2,EachPadCol2);
      fDisplayPad[0]->GetPad(2)->GetPad(1)->Divide(1,2,Margin2,Margin2,EachPadCol2);
      
      fDisplayPad[0]->GetPad(1)->cd(1);
      DrawHist(E_SilHist_Noise);
      
      fDisplayPad[0]->GetPad(1)->cd(2);
      DrawHist(E_SilHist_Mult);
      
      fDisplayPad[0]->GetPad(2)->GetPad(1)->cd(1);
      DrawHist(E_SilHist_CMmean);
      
      fDisplayPad[0]->GetPad(2)->GetPad(1)->cd(2);
      DrawHist(E_SilHist_CMsigma);
      
      fDisplayPad[0]->GetPad(2)->cd(2);
      DrawHist(E_SilHist_CluCrg);
    }
  }
  else if(display_mode == (Int_t)E_SilHist_Displ_AllSides){
    fDisplayPad[0]->Divide(3,2,Margin1,Margin1,EachPadCol1);
    fDisplayPad[0]->GetPad(1)->Divide(1,2,Margin2,Margin2,EachPadCol2);;
    fDisplayPad[0]->GetPad(2)->Divide(1,2,Margin2,Margin2,EachPadCol2);;
    fDisplayPad[0]->GetPad(3)->Divide(1,2,Margin2,Margin2,EachPadCol2);;
    
    fDisplayPad[0]->GetPad(4)->Divide(2,1,Margin2,Margin2,EachPadCol2);;
    fDisplayPad[0]->GetPad(5)->Divide(2,1,Margin2,Margin2,EachPadCol2);;
    fDisplayPad[0]->GetPad(6)->Divide(2,1,Margin2,Margin2,EachPadCol2);;
    
    fDisplayPad[0]->GetPad(4)->GetPad(1)->Divide(1,2,Margin2,Margin2,EachPadCol2);;
    fDisplayPad[0]->GetPad(5)->GetPad(1)->Divide(1,2,Margin2,Margin2,EachPadCol2);;
    fDisplayPad[0]->GetPad(6)->GetPad(1)->Divide(1,2,Margin2,Margin2,EachPadCol2);;
    
    for(Int_t k=0;k<3;k++){
      SelectSide(k);
      
      fDisplayPad[0]->GetPad(k+1)->cd(1);
      DrawHist(E_SilHist_Noise);

      fDisplayPad[0]->GetPad(k+1)->cd(2);
      DrawHist(E_SilHist_Mult);

      fDisplayPad[0]->GetPad(k+4)->GetPad(1)->cd(1);
      DrawHist(E_SilHist_CMmean);

      fDisplayPad[0]->GetPad(k+4)->GetPad(1)->cd(2);
      DrawHist(E_SilHist_CMsigma);

      fDisplayPad[0]->GetPad(k+4)->cd(2);
      DrawHist(E_SilHist_CluCrg);
    }
    SelectSide(-1);
  }
  RebuildSidePad();
  ResetFrameColors();

  HighlightButtons(1);
}

//________________________________________
void TFndSilMonFrame::DisplayAllHist(Int_t layer, Int_t type){

  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }
  Int_t   EachPadCol = 19;
  Float_t Margin     = 0.002;

  fDisplayPad[0]->Clear();
  Int_t kmax = 0;
  
  fLayer = layer;
  switch(fLayer){
  case (Int_t)E_FIN_INNER_LAYER:
    kmax = 8;
    fDisplayPad[0]->Divide(4,6,Margin,Margin,EachPadCol);
    break;
  case (Int_t)E_FIN_OUTER_LAYER:
    kmax = 10;
    fDisplayPad[0]->Divide(5,6,Margin,Margin,EachPadCol);
    break;
  default: break;
  }
  
  for(Int_t k=0;k<kmax;k++){
    for(Int_t s=0;s<3;s++){
      fDisplayPad[0]->cd(k*3+s+1);
      fModNum = k+1;
      SelectSide(s);
      DrawHist((E_SilHist) type);
    }
  }
  
  // --- side pad must be cleared
  // --- (it depends on the selected module)
  ClearSidePad();
  ResetFrameColors();
  Int_t all_id = -1;
  if     (fLayer == (Int_t)E_FIN_INNER_LAYER && type == (Int_t) E_SilHist_Mult)    all_id = 0;
  else if(fLayer == (Int_t)E_FIN_OUTER_LAYER && type == (Int_t) E_SilHist_Mult)    all_id = 1;
  else if(fLayer == (Int_t)E_FIN_INNER_LAYER && type == (Int_t) E_SilHist_Noise)   all_id = 2;
  else if(fLayer == (Int_t)E_FIN_OUTER_LAYER && type == (Int_t) E_SilHist_Noise)   all_id = 3;
  else if(fLayer == (Int_t)E_FIN_INNER_LAYER && type == (Int_t) E_SilHist_CMsigma) all_id = 4;
  else if(fLayer == (Int_t)E_FIN_OUTER_LAYER && type == (Int_t) E_SilHist_CMsigma) all_id = 5;
  else if(fLayer == (Int_t)E_FIN_INNER_LAYER && type == (Int_t) E_SilHist_CluCrg)  all_id = 6;
  else if(fLayer == (Int_t)E_FIN_OUTER_LAYER && type == (Int_t) E_SilHist_CluCrg)  all_id = 7;
  else{
    Error("DisplayAllHist","\"all_id\" out of range!");
    return;
  }
  HighlightButtons(2,all_id);
}

//________________________________________
void TFndSilMonFrame::SelectModule(Int_t layer,Int_t module) {
  
  fLayer = layer; 
  fModNum = module; 
  //  Info("SelectModule","current selection: Layer %i; module %i",fLayer, fModNum);
}

//________________________________________
void TFndSilMonFrame::SelectSide(Int_t side){
  
  fSide=side; 
  //  Info("SelectSide","current side: %i (\"%s\")",fSide,SilSide_Name(fSide).Data());
  
}

//________________________________________
void TFndSilMonFrame::DrawHist(E_SilHist which_type){
  // this method will get and draw one histogram,
  // according to the current (layer,module,side) selection
  // and to the required type (received argument)
  
  TString hnam = "";
  TString hopt = "";

  switch(which_type) {
  case E_SilHist_Noise  : hnam = fNam_Noise[fLayer-1][fModNum-1][fSide];     break;
  case E_SilHist_Mult   : hnam = fNam_Mult[fLayer-1][fModNum-1][fSide];      break;
  case E_SilHist_CMmean : hnam = fNam_CMmean[fLayer-1][fModNum-1][fSide];    break;
  case E_SilHist_CMsigma: hnam = fNam_CMsigma[fLayer-1][fModNum-1][fSide];    break;
  case E_SilHist_CluCrg : hnam = fNam_ClCh[fLayer-1][fModNum-1][fSide]; break;
  case E_SilHist_CluCleanMult : hnam = fNam_CleanMult[fLayer-1][fModNum-1][fSide]; break;
  case E_SilHist_CluCrgClean  : hnam = fNam_ClChClean[fLayer-1][fModNum-1][fSide]; break;
  case E_SilHist_CluDeDx      : hnam = fNam_dEdx[fLayer-1][fModNum-1][fSide]; break;
  case E_SilHist_CluDeDx2D    : hnam = fNam_dEdx_PvsZ[fLayer-1][fModNum-1]; break;
  case E_SilHist_CluPos2D     : hnam = fNam_Pos_PvsZ[fLayer-1][fModNum-1]; hopt = "colz"; break;
  default: 
    Error("DrawHist","Type not available");
    return;
  }
  

  //  Printf("Histograms to be shown: \"%s\"",hnam.Data());

  if(fLayer == (Int_t)E_FIN_INNER_LAYER){
    if(fIsOnline) fHisto =(TH1F*) fIsmMapFile->Get(hnam.Data());
    else          fHisto =(TH1F*) fRF->Get(hnam.Data());   
  }
  else if(fLayer == (Int_t)E_FIN_OUTER_LAYER){
    if(fIsOnline) fHisto =(TH1F*) fOsmMapFile->Get(hnam.Data());
    else          fHisto =(TH1F*) fRF2->Get(hnam.Data());   
  }
  
  if(!fHisto) return;
  fHisto->GetXaxis()->SetLabelSize(0.08);
  fHisto->GetYaxis()->SetLabelSize(0.08);
  fHisto->Draw(hopt);

  return;
}

---