TOF/TFndTofMonFrame.cxx

// @(#)fROOT/TOF:$Name:  $:$Id: TFndTofMonFrame.cxx,v 1.22 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>, 2000

//                                                //
//               TFndTofMonFrame                  //
//                                                //
//  Class for the TOF monitoring GUI              //
//  (see Gts relative class for descriptions)     //
//                                                //

#include <TSystem.h>
#include <TStyle.h>

#include "FROOT.h"
#include "TFndTofMonFrame.h" 
#include "TFndRun.h" 
#include "TFndHdt.h" 

ClassImp(TFndTofMonFrame)

//_____________________________________
TFndTofMonFrame::TFndTofMonFrame(TString filename):
  TFndMonFrame(filename),fIO(),fCurSlab(),fNSlabs(),
  fGenMapFile(),fAdcMapFile(),fTdcMapFile(),
  fSlabPad(),fAllPad(),
  fSlabButton(),fAllButton(),
  hists(),h2(),
  fWhichGroup(-1),fAllId(-1)
{
  
  Init();
}

//_____________________________________
TFndTofMonFrame::~TFndTofMonFrame() {
  
  if(!fClosed) Close();
}
  
//_____________________________________
void TFndTofMonFrame::Init() {

  //   fCheckedHistos = new TObjArray(1000);
  SetStyle();

  fNSlabs[0] = 12;
  fNSlabs[1] = 72;

  fHighlightCol[0] = 5;
  fHighlightCol[1] = 5;

  //   fSHMEntries = 0;
  //   time_t now;
  //   now = time(&now);
  //   fTime = now;
  //   cout << "Time is: " << fTime << " in TFndTofMonFrame::Init()" << endl;
  
  //  fndrun->SetTofMonFrame(this);
  //   if(! StartInterface(0)) return;
  //   if(! StartInterface(1)) return;
  //  fClosed = kFALSE;
}

//_____________________________________
void TFndTofMonFrame::Open() {
  
  if(!fClosed) return;
  if(! StartInterface(1)) return;  
  if(! StartInterface(0)) return;  // TOFINO on top
  fClosed = kFALSE;
}

//_____________________________________
void TFndTofMonFrame::Close() {
  // the consumer should not close shared memories

  if(!fClosed){
    Printf("TFndTofMonFrame::Close() ---> closing and re-initializing to zero all mapfiles");    
    if(fGenMapFile) { fGenMapFile->Close(); fGenMapFile = 0; }
    if(fAdcMapFile) { fAdcMapFile->Close(); fAdcMapFile = 0; }
    if(fTdcMapFile) { fTdcMapFile->Close(); fTdcMapFile = 0; }
    Printf("TFndTofMonFrame::Close() ---> Done");    
  }
  fClosed = kTRUE;

}

//_____________________________________
Bool_t TFndTofMonFrame::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[3] = 0;

#if defined _FND_ONL_USE_MAP_FILES_
  if(fndrun->GetDebug()) Printf("TFndTofMonFrame::ReloadMapFiles() ---> closing and re-initializing to zero all mapfiles");      
  if(fGenMapFile) { fGenMapFile->Close(); fGenMapFile = 0; }
  if(fAdcMapFile) { fAdcMapFile->Close(); fAdcMapFile = 0; }
  if(fTdcMapFile) { fTdcMapFile->Close(); fTdcMapFile = 0; }
  if(fndrun->GetDebug()) Printf("TFndTofMonFrame::ReloadMapFiles() ---> Done");
  //
  shr_file_map_name[0] = "$FND_SHR/tof_map.map";
  shr_file_map_name[1] = "$FND_SHR/tof_adc.map";
  shr_file_map_name[2] = "$FND_SHR/tof_tdc.map";
#elif defined _FND_ONL_USE_SHARED_FILES_
  if(fGenMapFile) { if(fGenMapFile->IsOpen()) fGenMapFile->Close(); delete fGenMapFile; fGenMapFile = 0; }
  if(fAdcMapFile) { if(fAdcMapFile->IsOpen()) fAdcMapFile->Close(); delete fAdcMapFile; fAdcMapFile = 0; }
  if(fTdcMapFile) { if(fTdcMapFile->IsOpen()) fTdcMapFile->Close(); delete fTdcMapFile; fTdcMapFile = 0; }
  if(fndrun->GetDebug()) Printf("TFndTofMonFrame::ReloadMapFiles() ---> Done");
  //
  shr_file_map_name[0] = "$FND_SHR/tof_map.file.map";
  shr_file_map_name[1] = "$FND_SHR/tof_adc.file.map";
  shr_file_map_name[2] = "$FND_SHR/tof_tdc.file.map";
#endif
  
  if(fndrun->GetDebug()) Printf("Reloading shared memories...");
  
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[0].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    if(fndrun->GetDebug()) Printf(" fGenMapFile ");
    //fGenMapFile = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/tof_map.map"),"READ",(Int_t)(1048576*FROOT::K_TofMapSize));
    fGenMapFile = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[0].Data()),"READ");
    if(fndrun->GetDebug())fGenMapFile->Print();
    //if(fndrun->GetDebug())fGenMapFile->ls();
#elif defined _FND_ONL_USE_SHARED_FILES_
    fGenMapFile = new TFile(FROOT::ExpandPathName(shr_file_map_name[0].Data()),"READ");
    Info("TFndTofMonFrame::ReloadMapFiles","Reloading shared file \"%s\"",shr_file_map_name[0].Data());
    //fGenMapFile->ls();
#endif
  }
  else result = kFALSE;
  
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[1].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    if(fndrun->GetDebug()) Printf(" fAdcMapFile ");
    //fAdcMapFile = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/tof_adc.map"),"READ",(Int_t)(1048576*FROOT::K_TofAdcMapSize));
    fAdcMapFile = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[1].Data()),"READ");
    if(fndrun->GetDebug())fAdcMapFile->Print();
    //if(fndrun->GetDebug())fAdcMapFile->ls();
#elif defined _FND_ONL_USE_SHARED_FILES_
    fAdcMapFile = new TFile(FROOT::ExpandPathName(shr_file_map_name[1].Data()),"READ");
    Info("TFndTofMonFrame::ReloadMapFiles","Reloading shared file \"%s\"",shr_file_map_name[1].Data());
    //fAdcMapFile->ls();
#endif
  }
  else result = kFALSE;
  
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[2].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    if(fndrun->GetDebug()) Printf(" fTdcMapFile ");
    //fTdcMapFile = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/tof_tdc.map"),"READ",(Int_t)(1048576*FROOT::K_TofTdcMapSize));
    fTdcMapFile = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[2].Data()),"READ");
    if(fndrun->GetDebug())fTdcMapFile->Print();
    //if(fndrun->GetDebug())fTdcMapFile->ls();
#elif defined _FND_ONL_USE_SHARED_FILES_
    fTdcMapFile = new TFile(FROOT::ExpandPathName(shr_file_map_name[2].Data()),"READ");
    Info("TFndTofMonFrame::ReloadMapFiles","Reloading shared file \"%s\"",shr_file_map_name[2].Data());
    //fTdcMapFile->ls();
#endif
  }
  else result = kFALSE;
  
  if(fndrun->GetDebug()){
    if(result)  Printf("TFndTofMonFrame::ReloadMapFiles() ---> exiting method");
    else Printf("TFndTofMonFrame::ReloadMapFiles() ---> exiting method (shared memories not found)");
  }
  return result;
}

//_____________________________________
Bool_t TFndTofMonFrame::StartInterface(Int_t ring) {
  
  Int_t BackgroundCol = 12;
  Int_t DisplayPadCol = 15;

  Int_t x0 = 150;     // main canvas
  Int_t y0 = 100;       // main canvas
  //  Int_t xsize = 1050; // main canvas
  //  Int_t ysize = 700;  // main canvas

  Float_t sep = 0.001;
  Float_t smallsep = 0.0005;

  Float_t Start_X_displaypad[2];
  Float_t Stop_X_displaypad[2];
  Float_t Start_Y_displaypad[2];
  Float_t Stop_Y_displaypad[2];
  Start_X_displaypad[0] = 0.085;
  Stop_X_displaypad[0]  = 1.;
  Start_Y_displaypad[0] = 0.05;
  Stop_Y_displaypad[0]  = 1.;
  
  Start_X_displaypad[1] = 0.055;
  Stop_X_displaypad[1]  = 0.945;
  Start_Y_displaypad[1] = 0.05;
  Stop_Y_displaypad[1]  = 0.95;

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

  fIO=ring;
  fCurSlab=0;

  //  cout << "layer (fIO): " << fIO << endl;
  ReloadMapFiles();
  //  cout << "mapfiles loaded" << endl;
  //  fCanStartGUI = ReloadMapFiles();
  //  if(!fCanStartGUI) return 0;

  if (fRF)  Printf("TFndTofMonFrame::StartInterface ---> source file found...starting GUI");
  
  TString str1 = TString();
  TString name1 = TString();
  //  Char_t *mod;
  //  if(fIO==0) mod = "tof";
  //  if(fIO==1) mod = "TOF";
  Char_t *mod[2];
  mod[0] = "tof";
  mod[1] = "TOF";
  str1+=mod[fIO];
  str1+=" Detector Display";
  name1+=mod[fIO];
  name1+="_MainCanvas";
  if(fIO==1) {
    x0 +=100;
    y0 -=100;
  }
  fMainCanvas[fIO] = new TCanvas(name1.Data(),str1.Data(),
                                 fMainCanvCoord[0],fMainCanvCoord[1],
                                 fMainCanvCoord[2],fMainCanvCoord[3]); 
  if(fIO==0) SetMonitorTitle(0,"tofino");
  else SetMonitorTitle(1,"TOFONE");
  fMainCanvas[fIO]->SetEditable(kFALSE);
  fMainCanvas[fIO]->SetFillColor(BackgroundCol);
  fMainCanvas[fIO]->Draw();

  //  cout << "control pad" << endl;
  str1+=mod[fIO];
  str1+=" control pad";

  //  cout << "fDisplayPad" << endl;
  str1 = mod[fIO];
  str1+=" hist display";
  name1 = mod[fIO];
  name1+=" viewpad";
  fDisplayPad[fIO] = new TPad(name1.Data(),str1.Data(),
                              Start_X_displaypad[fIO],Start_Y_displaypad[fIO],
                              Stop_X_displaypad[fIO],Stop_Y_displaypad[fIO]);
  fDisplayPad[fIO]->Draw();
  fDisplayPad[fIO]->SetFillColor(DisplayPadCol);
  fDisplayPad[fIO]->SetBorderSize(2);

  str1 = mod[fIO];
  str1+=" tof_AllPadControl";

  //  cout << "fAllPad" << endl; // tofino only
  fAllPad[0] = new TPad(str1.Data(),str1.Data(),
                        Start_X_displaypad[fIO], 0.,
                        Stop_X_displaypad[fIO],  Start_Y_displaypad[fIO]-sep);

  switch(fIO){
  case 0: // tofino
    fSlabPad[0] = new TPad("SlabTofSelPad","SlabTofSelPad",0.,Start_Y_displaypad[fIO],Start_X_displaypad[fIO]-sep,Stop_Y_displaypad[fIO]);
    fSlabPad[0]->SetFillColor(13);
    fSlabPad[0]->Draw();

    fAllPad[fIO]->Draw();    
    break;
  case 1: // tofone
    fSlabPad[1] = new TPad("SlabTofSelPad1","SlabTofSelPad1",
                           0.,                          Start_Y_displaypad[fIO]+smallsep,
                           Start_X_displaypad[fIO]-sep, Stop_Y_displaypad[fIO]-smallsep);
    fSlabPad[1]->SetFillColor(3);
    fSlabPad[1]->Draw();

    fSlabPad[2] = new TPad("SlabTofSelPad2","SlabTofSelPad2",
                           0., Stop_Y_displaypad[fIO]+smallsep,
                           1., 1.);
    fSlabPad[2]->SetFillColor(3);
    fSlabPad[2]->Draw();
 
    fSlabPad[3] = new TPad("SlabTofSelPad3","SlabTofSelPad3",
                           Stop_X_displaypad[fIO]+sep, Start_Y_displaypad[fIO]+smallsep,
                           1.,                         Stop_Y_displaypad[fIO]-smallsep);
    fSlabPad[3]->SetFillColor(3);
    fSlabPad[3]->Draw();

    fSlabPad[4] = new TPad("SlabTofSelPad4","SlabTofSelPad4",
                           0., 0.,
                           1., Start_Y_displaypad[fIO]-smallsep);
    fSlabPad[4]->SetFillColor(3);
    fSlabPad[4]->Draw();
    break;
  default: break;
  }

  DrawButtons();
  BuildConnections();
  return kTRUE;
}

//_____________________________________
void TFndTofMonFrame::DrawButtons() {

  Int_t ButtonsPerPad = 18;
  Float_t butstep = 0.0001;
  //  fMainCanvas[fIO]->cd();
  Float_t step = 1./9.;
  Float_t xi = 0.;
  Float_t yi = 0.;
  Float_t xo = 0.;
  Float_t yo = 0.;
  Float_t xf = 0; // tofino All only

  TString command = TString();
  TString modlab = TString();
  
  switch(fIO){
  case 0: // tofino
    //    cout << "...building buttons for TOFINO..." << endl;
    // AllPad (tofino only)
    fAllPad[fIO]->cd();
    xf = 0;
    xf = step;
    fAllButton[0] = new TButton("Maps","fndrun->TofMonFrame()->DisplayMaps();",xi,0.,xf,1.);
    fAllButton[0]->Draw();
    xi = xf;
    xf += step;
    fAllButton[1] = new TButton("eff","fndrun->TofMonFrame()->DisplayAllHist(0,10);",xi,0.,xf,1.);
    fAllButton[1]->Draw();
    xi = xf;
    xf += step;
    fAllButton[2] = new TButton("adc_tdc","fndrun->TofMonFrame()->DisplayAllHist(0,11);",xi,0.,xf,1.);
    fAllButton[2]->Draw();
    xi = xf;
    xf += step;
    fAllButton[3] = new TButton("adcs","fndrun->TofMonFrame()->DisplayAllHist(0,0);",xi,0.,xf,1.);
    fAllButton[3]->Draw();
    xi = xf;
    xf += step;
    fAllButton[4] = new TButton("light","fndrun->TofMonFrame()->DisplayAllHist(0,3);",xi,0.,xf,1.);
    fAllButton[4]->Draw();
    xi = xf;
    xf += step;
    fAllButton[5] = new TButton("zet","fndrun->TofMonFrame()->DisplayAllHist(0,4);",xi,0.,xf,1.);
    fAllButton[5]->Draw();
    xi = xf;
    xf += step;
    fAllButton[6] = new TButton("tdcs","fndrun->TofMonFrame()->DisplayAllHist(0,5);",xi,0.,xf,1.);
    fAllButton[6]->Draw();
    xi = xf;
    xf += step;
    fAllButton[7] = new TButton("tmn","fndrun->TofMonFrame()->DisplayAllHist(0,8);",xi,0.,xf,1.);
    fAllButton[7]->Draw();
    xi = xf;
    xf += step;
    fAllButton[8] = new TButton("tdf","fndrun->TofMonFrame()->DisplayAllHist(0,9);",xi,0.,xf,1.);
    fAllButton[8]->Draw();
    fAllPad[fIO]->Modified();

    // SlabPad
    fSlabPad[0]->cd();
    for(Int_t i=0;i<fNSlabs[fIO];i++) {
      // n = i+1;
      modlab = "sl_";
      modlab+=i+1;
      command = "fndrun->TofMonFrame()->SelectSlab(";
      command+=i+1;
      command+="); ";
      command+="fndrun->TofMonFrame()->DisplayHist();";
      
      xi = 0.;
      yi = ((Float_t) i)/fNSlabs[fIO];
      xo = 1.;
      yo = (i+1.)/fNSlabs[fIO];
      fSlabButton[i] = new TButton(modlab.Data(),command.Data(),xi,yi,xo,yo);
      fSlabButton[i]->SetTextSize(0.5);
      fSlabButton[i]->Draw();
      
    }
    fSlabPad[0]->Modified();
    break;
    
  case 1: // tofone
    //    cout << "...building buttons for TOFONE..." << endl;
    
    step = 1./(Float_t)ButtonsPerPad;
    for(Int_t p=1;p<=4;p++) {
      fSlabPad[p]->cd();
      // --- initialize buttons placement
      switch(p){
      case 1:
        xi = 0;  yi = 0;
        xo = 1.; yo = step - butstep;
        break;
      case 2:
        xi = 0;    yi = 0;
        xo = step; yo = 1.;
        break;
      case 3:
        xi = 0;  yi = 1. - step;
        xo = 1.; yo = 1.;
        break;
      case 4:
        xi = 1. -step; yi = 0;
        xo = 1.;       yo = 1.;
        break;
      default: break;
      }
      // --- buttons placement initialized

      // --- Building buttons
      for(Int_t i=0;i<ButtonsPerPad;i++) {
        //      cout << "p: " << p << " --- i: " << i << endl; 
        Int_t nsl = i + fNSlabs[0] + (ButtonsPerPad * (p-1)) +1;
        Int_t but_id = nsl - 1;
        if(nsl>(fNSlabs[0]+fNSlabs[1])) Error("DrawButtons","\"nsl\" too big!!!");
        modlab = "sl_";
        modlab+= nsl-fNSlabs[0];
        command = "fndrun->TofMonFrame()->SelectSlab(";
        command+=nsl;
        command+="); ";
        command+="fndrun->TofMonFrame()->DisplayHist();";
        // ---
        fSlabButton[but_id] = new TButton(modlab.Data(),command.Data(),xi,yi,xo,yo);
        fSlabButton[but_id]->SetTextSize(0.5);
        fSlabButton[but_id]->Draw();
        // --- next button placement
        switch(p){
        case 1:
          xi = 0;  yi = yo + butstep;
          xo = 1.; yo += step - butstep;
          break;
        case 2:
          xi = xo + butstep;    yi = 0;
          xo += step - butstep; yo = 1.;
          break;
        case 3:
          xi = 0;  yo = yi - butstep;
          xo = 1.; yi -= step - butstep;
          break;
        case 4:
          xo = xi -butstep;     yi = 0;
          xi -= step - butstep; yo = 1.;
          break;
        default: break;
        }
        // ---
      }
      fSlabPad[p]->Modified();    
    }
    break; // ending tofone buttons
    
  default: break;
  }
  
  ResetFrameColors();
}

//_____________________________________
void TFndTofMonFrame::ResetFrameColors(){
  
  Int_t SlabButCol[2];
  SlabButCol[0] = 33; // tofino slab buttons
  SlabButCol[1] = 38; // tofone slab buttons
  Int_t AllButCols[9] = {25,25,22,22,28,28,22,22,28}; // tofino "all" buttons

  switch(fIO){
  case 0: // tofino
    for(Int_t i=0;i<9;i++){
      fAllButton[i]->SetFillColor(AllButCols[i]);
      fAllButton[i]->Modified();
    }
    for(Int_t i=0;i<fNSlabs[fIO];i++){
      fSlabButton[i]->SetFillColor(SlabButCol[fIO]);
      fSlabButton[i]->Modified();
    }
    break;
  case 1:
    for(Int_t i=0;i<fNSlabs[1];i++){
      fSlabButton[fNSlabs[0]+i]->SetFillColor(SlabButCol[fIO]);
      fSlabButton[fNSlabs[0]+i]->Modified();
    }
    break;
  default: break;
  }
}

//_____________________________________
void TFndTofMonFrame::SelectSlab(Int_t s){ 
  if(s<0 || s>(fNSlabs[0]+fNSlabs[1])) { Warning("SelectSlab","Wrong Slab Number: %d",s); return; } 
  fIO = 0; 
  fCurSlab = s;
  if(s>fNSlabs[0]) { fIO = 1; fCurSlab = s+88; } 
}

//_____________________________________
void TFndTofMonFrame::DrawHist(Int_t opt, Int_t flg, Char_t *DrawOpt){
  
  // --- new code (D. Faso - November 2005)
  TString type = 0;
  //  cout << "option = " << opt << endl;
  switch(opt){
  case  0: type = "adc"; break;
  case  1: type = "adcp"; break;
  case  2: type = "adce"; break;
  case  3: type = "crg"; break;
  case  4: type = "zet"; break;
  case  5: type = "tdc"; break;
  case  6: type = "tdcp"; break;
  case  7: type = "tdce"; break;
  case  8: type = "tmn"; break;
  case  9: type = "tdf"; break;
  case 10: type = "mapadctdc"; break;
  case 11: type = "adc_tdc"; break;
  case 12: type = "tmn_hw"; break;
  default: if(fndrun->GetDebug()) Warning("DrawHist","wrong option"); return;
  }

  h2 = NULL;
  hists = NULL;

  TString label = TString("tof_"); label+=type.Data(); label+="_"; label+=fCurSlab;
  switch(opt){
  case 0:
    if(fIsOnline) h2 =(TH2F*) fAdcMapFile->Get(label.Data());
    else          h2 =(TH2F*) fRF->Get(label.Data());
    break;
  case 1:
    if(fIsOnline) hists =(TH1F*) fAdcMapFile->Get(label.Data());
    else          hists =(TH1F*) fRF->Get(label.Data());   
    break;
  case 2:
    if(fIsOnline) hists =(TH1F*) fAdcMapFile->Get(label.Data());
    else          hists =(TH1F*) fRF->Get(label.Data());   
    break;
  case 3:
    if(fIsOnline) hists =(TH1F*) fAdcMapFile->Get(label.Data());
    else          hists =(TH1F*) fRF->Get(label.Data());   
    break;
  case 4:
    if(fIsOnline) hists =(TH1F*) fAdcMapFile->Get(label.Data());
    else          hists =(TH1F*) fRF->Get(label.Data());   
    break;
  case 5:
    if(fIsOnline) h2 =(TH2F*) fTdcMapFile->Get(label.Data());
    else          h2 =(TH2F*) fRF->Get(label.Data());
    break;
  case 6:
    if(fIsOnline) hists =(TH1F*) fTdcMapFile->Get(label.Data());
    else          hists =(TH1F*) fRF->Get(label.Data());
    break;
  case 7:
    if(fIsOnline) hists =(TH1F*) fTdcMapFile->Get(label.Data());
    else          hists =(TH1F*) fRF->Get(label.Data());
    break;
  case 8:
    if(fIsOnline) hists =(TH1F*) fTdcMapFile->Get(label.Data());
    else          hists =(TH1F*) fRF->Get(label.Data());
    break;
  case 9:
    if(fIsOnline) hists =(TH1F*) fTdcMapFile->Get(label.Data());
    else          hists =(TH1F*) fRF->Get(label.Data());
    break;
  case 10:
    if(fIsOnline) h2 =(TH2F*) fGenMapFile->Get(label.Data());
    else          h2 =(TH2F*) fRF->Get(label.Data());
    break;
  case 11:
    if(fIsOnline) h2 =(TH2F*) fGenMapFile->Get(label.Data());
    else          h2 =(TH2F*) fRF->Get(label.Data());
    break;
  case 12:
    if(fIsOnline) hists =(TH1F*) fTdcMapFile ->Get(label.Data());
    else          hists =(TH1F*) fRF->Get(label.Data());
    break;
  default: if(fndrun->GetDebug()) Warning("DrawHist","wrong option"); return;
  }

  if(h2) h2->Draw(DrawOpt);
  if(hists) {
    if(flg) 
      hists->Draw("SAME");
    else
      hists->Draw(DrawOpt);
  }

}
  
//_____________________________________
void TFndTofMonFrame::DisplayMaps(){

  if(!ReloadMapFiles()){
    for(Int_t i=0;i<2;i++){
      fDisplayPad[i]->Clear();
      fDisplayPad[i]->Modified();
    }
    Warning("TFndTofMonFrame::DisplayMaps","Problems while reloading shared memories");
    return;
  }

  Char_t *Draw2D_opt = "colz";
  Int_t EachPadCol = 18;
  Float_t Margin = 0.002;

  //  fMainCanvas[0]->cd();
  
  fDisplayPad[0]->Clear();
  fDisplayPad[0]->Divide(4,2,Margin,Margin,EachPadCol);
  
  for(Int_t j=0;j<8;j++) {
    TString str = TString("tof_");
    if(j==0) str+="i_o_mult";
    if(j!=0) str+="map";
    if(j>=1 && j<4) str+="adc";
    if(j==4) str+="mt";
    if(j>4) str+="tdc";
    if(j==2 || j==6) str+="p";
    if(j==3 || j==7) str+="e";
    fDisplayPad[0]->cd(j+1);
    h2 = 0;
    hists = 0;
    if(j==0) {
      Draw2D_opt = "box";
      if(fRF)
        h2 = (TH2F *) fRF->Get(str.Data());
      else
        h2 = (TH2F *) fGenMapFile->Get(str.Data());
    } 
    else {
      Draw2D_opt = "";
      if(fRF)
        hists = (TH1F *) fRF->Get(str.Data());
      else
        hists = (TH1F *) fGenMapFile->Get(str.Data());
    }
    if(h2) h2->Draw(Draw2D_opt);
    if(hists) hists->Draw(Draw2D_opt);
  }    
  fDisplayPad[0]->Modified();

  ResetFrameColors();
  HighlightButtons(1,0);
}

//_____________________________________
void TFndTofMonFrame::DisplayHist(){

  if(!ReloadMapFiles()){
    for(Int_t i=0;i<2;i++){
      fDisplayPad[i]->Clear();
      fDisplayPad[i]->Modified();
    }
    Warning("TFndTofMonFrame::DisplayHist","Problems while reloading shared memories");
    return;
  }
  Char_t *Draw2D_opt = "";
  Int_t EachPadCol = 17;
  Float_t Margin = 0.002;

  
  fDisplayPad[fIO]->Clear();
  fDisplayPad[fIO]->Divide(4,3,Margin,Margin,EachPadCol);

  
  Int_t opt = -1;
  for(Int_t j=0;j<12;j++){
    fDisplayPad[fIO]->cd(j+1);
    opt++;
    if(j==8) Draw2D_opt = "colz";
    else Draw2D_opt = "";
    DrawHist(opt,0,Draw2D_opt);
    if(j==1 || j==5) DrawHist(++opt,1);
  }
  fDisplayPad[fIO]->Modified();

  ResetFrameColors();
  HighlightButtons(0);
}    

//_____________________________________
void TFndTofMonFrame::DisplayAllHist(Int_t io, Int_t option){

  if(!ReloadMapFiles()){
    for(Int_t i=0;i<2;i++){
      fDisplayPad[i]->Clear();
      fDisplayPad[i]->Modified();
    }
    Warning("TFndTofMonFrame::DisplayAllHist","Problems while reloading shared memories");
    return;
  }
  Char_t *Draw2D_opt = 0;
  if(option==10) Draw2D_opt = "colz"; // eff
  else Draw2D_opt = "";

  Int_t EachPadCol = 19;
  Float_t Margin = 0.002;

  fDisplayPad[0]->Clear();
  fDisplayPad[0]->Divide(4,3,Margin,Margin,EachPadCol);


  fIO = io;
  //fCurSlab = 0;
  for(Int_t k=0;k<12;k++){
    fDisplayPad[0]->cd(k+1);
    fCurSlab = k+1;
    DrawHist(option,0,Draw2D_opt);
  }
  fDisplayPad[0]->Modified();

  ResetFrameColors();
  Int_t all_id = 0;
  switch(option){
  case 10: all_id = 1; break;
  case 11: all_id = 2; break;
  case 0:  all_id = 3; break;
  case 3:  all_id = 4; break;
  case 4:  all_id = 5; break;
  case 5:  all_id = 6; break;
  case 8:  all_id = 7; break;
  case 9:  all_id = 8; break;
  default: break;
  }
  HighlightButtons(1,all_id);
}

//____________________________________________________
TButton *TFndTofMonFrame::HighlightButtons(Int_t which_group,Int_t All_id){
  // Highlight active buttons (considering the selected detector (tofino/tofone))
  //  - which_group==0 : fSlabButton buttons highlighted
  //  - which_group==1 : fAllButtons buttons highlighted
  //  - All_id : index for the all_button

  // --- remember the last clicked button
  fWhichGroup = which_group;
  fAllId = All_id;

  Int_t sl = fCurSlab;
  if(sl > fNSlabs[0]) sl -= 88; 
  //  cout << "fCurSlab: " << fCurSlab << endl;
  
  switch(which_group){
  case 0:
    fSlabButton[sl-1]->SetFillColor(fHighlightCol[fIO]);
    fSlabButton[sl-1]->Modified();
    return fSlabButton[sl-1];
    //     break;
  case 1:
    fAllButton[All_id]->SetFillColor(fHighlightCol[fIO]); 
    fAllButton[All_id]->Modified();
    return fAllButton[All_id];
    //break;
  default: return 0;
  } 
}

//___________________________________________
void TFndTofMonFrame::RefreshSingleMonView(){

  if(fndrun->GetDebug()){
    Printf("");
    Printf("fWhichGroup: %d",fWhichGroup);
    Printf("fCurSlab: %d",fCurSlab);
    Printf("fAllId: %d",fAllId);
    Printf("fIO: %d",fIO);
  }

  if(fWhichGroup ==- 1 || fAllId == - 1) return;

  if(fCurSlab > fNSlabs[0]) FlashDisplayPad(1); // flash tofone
  else FlashDisplayPad(0); // flash tofino

  HighlightButtons(fWhichGroup,fAllId)->ExecuteEvent(11,0,0);
}

//_____________________________________
// void TFndTofMonFrame::CheckHistos() 
// { 
//   Bool_t kReload = CheckEntries();
//   if(kReload) ReloadMapFiles();
//   CheckIOMult();
//   CheckAdcTdcMaps();
//   CheckMTPattern();
//   CheckHWMT();
//   CheckSWMT();
// }

//_____________________________________
// Bool_t TFndTofMonFrame::CheckEntries() 
// { 
//   Bool_t kReload = kFALSE;
//   TH2F *i_o_mult = (TH2F *) fGenMapFile->Get("tof_i_o_mult");
//   Int_t fEntries = (Int_t) i_o_mult->GetEntries();
//   time_t now;
//   now = time(&now);
//   Int_t timeInterval = now - fTime;
//   fTime = now;
//   Int_t tUpdate = 60;
//   if(timeInterval > tUpdate && fEntries == fSHMEntries) {
//     cout << "Number of Entries did not change for the last " << tUpdate << " seconds: reload TOF Shared memories" << endl;
//     kReload = kTRUE;
//   }
//   return kReload;
// }

//_____________________________________
// void TFndTofMonFrame::CheckIOMult() 
// { 
//   /*
//     Bool_t isCosmic = fndrun->Hdt()->Trig()->Cosmic();
//     if(isCosmic) cout << "Cosmic ray trigger on" << endl;
//   */
//   TString s2("tof_i_o_mult");
//   cout << "check tof_i_o_mult" << endl;
//   TH2F *i_o_mult = (TH2F *) fGenMapFile->Get(s2.Data());
//   Bool_t doCheck = kFALSE;

//   /*
//     Int_t nx = i_o_mult->GetNbinsX();
//     Int_t ny = i_o_mult->GetNbinsY();
//     for(Int_t i=0; i<nx; i++) {
//     for(Int_t j=0; j<ny; j++) {
//     Double_t nEntries = i_o_mult->GetBinContent(i+1,j+1);
//     // FIXME
//     if(nEntries > 0 && i >= 10) doCheck = kTRUE;
//     if(nEntries > 0 && j >= 10) doCheck = kTRUE;
//     }
//     }
//   */
//   doCheck = kTRUE; // check by default

//   TFndMonCheckFrame *a =0;
//   Bool_t isThere = kFALSE;
//   Int_t nH = fCheckedHistos->GetEntriesFast();
//   //  cout << nH << " entries in objarray" << endl;
//   for(Int_t i=0; i<nH; i++) {
//     TString curName = ((TFndMonCheckFrame *) fCheckedHistos->At(i))->GetHName();    
//     if(!curName.CompareTo(s2)) {
//       isThere = kTRUE;
//       a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//       if(!doCheck) {
//      cout << "Remove: " << curName.Data() << endl;
//      TFndMonCheckFrame *b = (TFndMonCheckFrame *) fCheckedHistos->Remove(a);
//      fCheckedHistos->Compress();
//      /*
//        cout << "delete a " << endl;
//        delete a;
//        cout << "delete b " << endl;
//        delete b;
//      */
//       }
//       break;
//     }   
//   }
//   if(doCheck && isThere == kFALSE) {
//     cout << "Add " << s2.Data() << " to objarray" << endl;
//     a = new TFndMonCheckFrame(fGenMapFile,s2,2,gClient->GetRoot());
//     fCheckedHistos->Add(a);
//   }
//   delete i_o_mult;
// }

//_____________________________________
// void TFndTofMonFrame::CheckMTPattern() 
// { 
//   /*
//     Bool_t isCosmic = fndrun->Hdt()->Trig()->Cosmic();
//     if(isCosmic) cout << "Cosmic ray trigger on" << endl;
//   */
//   cout << "check mean timer pattern" << endl;
//   TString s2("tof_mapmt");
//   TH1F *mtPattern = (TH1F *) fGenMapFile->Get(s2.Data());
//   Bool_t doCheck = kFALSE;
//   Int_t nx = mtPattern->GetNbinsX();

//   Double_t nEntries[nx];
//   Double_t mttofAverage = 0.;
//   Double_t mttofSigma = 0.;
//   Double_t mtTofAverage = 0.;
//   Double_t mtTofSigma = 0.;
//   for(Int_t i=0; i<nx; i++) {
//     nEntries[i] = mtPattern->GetBinContent(i+1);
//     if(i<100) {
//       mttofAverage += nEntries[i];
//       mttofSigma += nEntries[i]*nEntries[i];
//     } else {
//       mtTofAverage += nEntries[i];
//       mtTofSigma += nEntries[i]*nEntries[i];
//     }
//   }
//   mttofAverage /= nx;
//   mttofSigma /= nx;
//   mttofSigma = TMath::Sqrt(mttofSigma);
//   mtTofAverage /= nx;
//   mtTofSigma /= nx;
//   mtTofSigma = TMath::Sqrt(mtTofSigma);
//   cout << "tof: average " << mttofAverage << ", sigma: " << mttofSigma << endl;
//   cout << "TOF: average " << mtTofAverage << ", sigma: " << mtTofSigma << endl;
//   for(Int_t i=0; i<nx; i++) {
//     if(i<100 && mttofAverage > 100 && (nEntries[i] < mttofAverage-3*mttofSigma || nEntries[i] > mttofAverage+3*mttofSigma)) {
//       doCheck = kTRUE;
//       cout << "Warning: mean timer counts for tof slab: " << i+1 << " out of range" << endl;
//     }
//     if(i>=100 && mtTofAverage > 100 && (nEntries[i] < mtTofAverage-3*mtTofSigma || nEntries[i] > mtTofAverage+3*mtTofSigma)) {
//       doCheck = kTRUE;
//       cout << "Warning: mean timer counts for TOF slab: " << i+1 << " out of range" << endl;
//     }
//   }

//   TFndMonCheckFrame *a =0;
//   Bool_t isThere = kFALSE;
//   Int_t nH = fCheckedHistos->GetEntriesFast();
//   for(Int_t i=0; i<nH; i++) {
//     TString curName = ((TFndMonCheckFrame *) fCheckedHistos->At(i))->GetHName();    
//     if(!curName.CompareTo(s2)) {
//       isThere = kTRUE;
//       a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//       if(!doCheck) {
//      cout << "Remove: " << curName.Data() << endl;
//      fCheckedHistos->Remove(a);
//      fCheckedHistos->Compress();
//       }
//       break;
//     }   
//   }
//   if(doCheck && isThere == kFALSE) {
//     cout << "Add " << s2.Data() << " to objarray" << endl;
//     a = new TFndMonCheckFrame(fGenMapFile,s2,1,gClient->GetRoot());
//     fCheckedHistos->Add(a);
//   }
//   delete mtPattern;
// }

//_____________________________________
// void TFndTofMonFrame::CheckHWMT() 
// { 
//   /*
//     Bool_t isCosmic = fndrun->Hdt()->Trig()->Cosmic();
//     if(isCosmic) cout << "Cosmic ray trigger on" << endl;
//   */
//   cout << "check HW mean timer" << endl;

//   // mean timer HW
//   for(Int_t idet=0;idet<2;idet++) {
//     Int_t ntslab = 12 + 60*idet;
//     Bool_t tofMT[ntslab]; 
//     Bool_t isTMNThere[ntslab];
//     for(Int_t itsl=0; itsl<ntslab; itsl++) {
//       TString hname("tof_tmn_hw_");
//       char slab[3];
//       sprintf(slab,"%d",100*idet+itsl+1);
//       hname.Append(slab);
//       TH1F *hwMT = (TH1F *) fTdcMapFile->Get(hname.Data());
//       tofMT[itsl] = kFALSE;
//       Int_t nx = hwMT->GetNbinsX();
//       Double_t maxi = 0.;
//       Double_t tmaxi = 0.;
//       for(Int_t nb=0; nb<nx; nb++) {
//      Double_t lowEdge = hwMT->GetBinLowEdge(nb+1);
//      Double_t width = hwMT->GetBinWidth(nb+1);
//      Int_t content = (Int_t) hwMT->GetBinContent(nb+1);
//      if(content > maxi) {
//        tmaxi = lowEdge;
//        maxi = content;
//      }
//       }
//       if(tmaxi != 0 && (tmaxi < 2200 || tmaxi > 3300 )) {
//      tofMT[itsl] = kTRUE;
//      cout << "bad HW mean timer for slab: " << 100*idet+itsl+1 << " at t = " << tmaxi << endl;
//       }

//       TFndMonCheckFrame *a =0;
//       isTMNThere[itsl] = kFALSE;
//       Int_t nH = fCheckedHistos->GetEntriesFast();
//       for(Int_t i=0; i<nH; i++) {
//      TString curName = ((TFndMonCheckFrame *) fCheckedHistos->At(i))->GetHName();
//      if(!curName.CompareTo(hname)) {
//        isTMNThere[itsl] = kTRUE;       
//        a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//        if(!tofMT[itsl]) {
//          cout << "Remove: " << curName.Data() << endl;
//          fCheckedHistos->Remove(a);
//          fCheckedHistos->Compress();
//        }
//        break;
//      }   
//       }
//       if(tofMT[itsl] && isTMNThere[itsl] == kFALSE) {
//      cout << "Add " << hname.Data() << " to objarray" << endl;
//      a = new TFndMonCheckFrame(fTdcMapFile,hname,1,gClient->GetRoot());
//      fCheckedHistos->Add(a);
//       }
//       delete hwMT;
//     }
//   }
// }

//_____________________________________
// void TFndTofMonFrame::CheckSWMT() 
// { 
//   /*
//     Bool_t isCosmic = fndrun->Hdt()->Trig()->Cosmic();
//     if(isCosmic) cout << "Cosmic ray trigger on" << endl;
//   */
//   cout << "check SW mean timer" << endl;
//   for(Int_t idet=0;idet<2;idet++) {
//     Int_t ntslab = 12 + 60*idet;
//     Bool_t tofMT[ntslab]; 
//     Bool_t isTMNThere[ntslab];
//     for(Int_t itsl=0; itsl<ntslab; itsl++) {
//       TString hname("tof_tmn_");
//       char slab[3];
//       sprintf(slab,"%d",100*idet+itsl+1);
//       hname.Append(slab);
//       TH1F *swMT = (TH1F *) fTdcMapFile->Get(hname.Data());
//       tofMT[itsl] = kFALSE;
//       Int_t nx = swMT->GetNbinsX();
//       Double_t maxi = 0.;
//       Double_t tmaxi = 0.;
//       for(Int_t nb=0; nb<nx; nb++) {
//      Double_t lowEdge = swMT->GetBinLowEdge(nb+1);
//      Double_t width = swMT->GetBinWidth(nb+1);
//      Int_t content = (Int_t) swMT->GetBinContent(nb+1);
//      if(content > maxi) {
//        tmaxi = lowEdge;
//        maxi = content;
//      }
//       }
//       if(tmaxi != 0 && (tmaxi < 2400 || tmaxi > 3100 )) {
//      tofMT[itsl] = kTRUE;
//      cout << "bad SW mean timer for slab: " << 100*idet+itsl+1 << " at t = " << tmaxi << endl;
//       }

//       TFndMonCheckFrame *a =0;
//       isTMNThere[itsl] = kFALSE;
//       Int_t nH = fCheckedHistos->GetEntriesFast();
//       for(Int_t i=0; i<nH; i++) {
//      TString curName = ((TFndMonCheckFrame *) fCheckedHistos->At(i))->GetHName();
//      if(!curName.CompareTo(hname)) {
//        isTMNThere[itsl] = kTRUE;
//        a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//        if(!tofMT[itsl]) {
//          cout << "Remove: " << curName.Data() << endl;
//          fCheckedHistos->Remove(a);
//          fCheckedHistos->Compress();
//        }
//        break;
//      }
//       }   
//       if(tofMT[itsl] && isTMNThere[itsl] == kFALSE) {
//      cout << "Add " << hname.Data() << " to objarray" << endl;
//      a = new TFndMonCheckFrame(fTdcMapFile,hname,1,gClient->GetRoot());
//      fCheckedHistos->Add(a);
//       }
//       delete swMT;
//     }
//   }
// }

//_____________________________________
// void TFndTofMonFrame::CheckAdcTdcMaps() 
// { 
//   /*
//     Bool_t isCosmic = fndrun->Hdt()->Trig()->Cosmic();
//     if(isCosmic) cout << "Cosmic ray trigger on" << endl;
//   */

//   cout << "check Adc vs Tdc maps" << endl;
//   Float_t ScalingFactor = 0.2;
//   for(Int_t idet=0;idet<2;idet++) {
//     Int_t ntslab = 12 + 60*idet;
//     Bool_t tofAdcTdcMap[ntslab]; 
//     Bool_t isMapThere[ntslab];
//     for(Int_t itsl=0; itsl<ntslab; itsl++) {
//       TString hname("tof_mapadctdc_");
//       char slab[3];
//       sprintf(slab,"%d",100*idet+itsl+1);
//       hname.Append(slab);
//       TH2F *mapAT = (TH2F *) fGenMapFile->Get(hname.Data());
//       tofAdcTdcMap[itsl] = kFALSE;
//       Int_t nx = mapAT->GetNbinsX();
//       Int_t ny = mapAT->GetNbinsY();

//       Int_t content[nx*ny];
//       Float_t maxi = 0;
//       Int_t maxi_x = -1;
//       Int_t maxi_y = -1;
//       for(Int_t nbx=0; nbx<nx; nbx++) {
//      for(Int_t nby=0; nby<ny; nby++) {
//        Int_t idx = nbx*ny+nby;
//        content[idx] = (Int_t) mapAT->GetBinContent(nbx+1,nby+1);
//        if(idet == 0 && idx == 3) content[idx] = 0; // FIXME
//        if(content[idx] > maxi) {
//          maxi_x = nbx;
//          maxi_y = nby;
//          maxi = content[idx];
//        } 
//      }
//       }
//       if(maxi_x*maxi_y != 9) {
//      cout << "slab " << 100*idet+itsl+1 << ", maximum in wrong place: " << maxi_x << "," << maxi_y << endl;
//      tofAdcTdcMap[itsl] = kTRUE;
//       }
//       for(Int_t nbx=0; nbx<nx; nbx++) {
//      for(Int_t nby=0; nby<ny; nby++) {
//        Int_t idx = nbx*ny+nby;
//        if(content[idx] > ScalingFactor*maxi && maxi_x != nbx && maxi_y != nby) {
//          tofAdcTdcMap[itsl] = kTRUE;
//          cout << "slab " << 100*idet+itsl+1 << ", maximum in wrong place, idx: " << idx << "," << maxi_x << "," << maxi_y << endl;
//        } 
//      }      
//       }
//       /*
//      if(content[0] != 0) {
//      tofAdcTdcMap[itsl] = kTRUE;
//      cout << content[0] << " bad Adc & Tdc on both sides for slab: " << itsl+1 << " of detector " << idet+1 << endl;
//      }
//      if(content[1]+content[2] != 0) {
//      tofAdcTdcMap[itsl] = kTRUE;
//      cout << content[1]+content[2] << " bad Tdc(both) & Adc on one side for slab: " << itsl+1 << " of detector " << idet+1 << endl;
//      } 
//      if(content[4]+content[8] != 0) {
//      tofAdcTdcMap[itsl] = kTRUE;
//      cout << content[4]+content[8] << " bad Adc(both) & Tdc on one side for slab: " << itsl+1 << " of detector " << idet+1 << endl;
//      } 
//      if(content[5]+content[6]+content[9]+content[10] != 0) {
//      tofAdcTdcMap[itsl] = kTRUE;
//      cout << content[5]+content[6]+content[9]+content[10] << " bad Adc & Tdc on one side for slab: " << itsl+1 << " of detector " << idet+1 << endl;
//      } 
//      if(content[3] != 0) {
//      tofAdcTdcMap[itsl] = kTRUE;
//      cout << content[3] << " bad Tdc(both) for slab: " << itsl+1 << " of detector " << idet+1 << endl;
//      } 
//      if(content[12] != 0) {
//      tofAdcTdcMap[itsl] = kTRUE;
//      cout << content[12] << " bad Adc(both) for slab: " << itsl+1 << " of detector " << idet+1 << endl;
//      }
//      if(content[7]+content[11] != 0) {
//      tofAdcTdcMap[itsl] = kTRUE;
//      cout << content[7]+content[11] << " bad Tdc on one side for slab: " << itsl+1 << " of detector " << idet+1 << endl;
//      } 
//      if(content[13]+content[14] != 0) {
//      tofAdcTdcMap[itsl] = kTRUE;
//      cout << content[13]+content[14] << " bad Adc on one side for slab: " << itsl+1 << " of detector " << idet+1 << endl;
//      } 
//       */
//       TFndMonCheckFrame *a =0;
//       isMapThere[itsl] = kFALSE;
//       Int_t nH = fCheckedHistos->GetEntriesFast();
//       for(Int_t i=0; i<nH; i++) {
//      TString curName = ((TFndMonCheckFrame *) fCheckedHistos->At(i))->GetHName();
//      if(!curName.CompareTo(hname)) {
//        isMapThere[itsl] = kTRUE;
//        a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//        if(!tofAdcTdcMap[itsl]) {
//          cout << "Remove: " << curName.Data() << endl;
//          fCheckedHistos->Remove(a);
//          fCheckedHistos->Compress();
//        }
//        break;
//      }
//       }   
//       if(tofAdcTdcMap[itsl] && isMapThere[itsl] == kFALSE) {
//      cout << "Add " << hname.Data() << " to objarray" << endl;
//      a = new TFndMonCheckFrame(fGenMapFile,hname,2,gClient->GetRoot());
//      fCheckedHistos->Add(a);
//       }
//       delete mapAT;
//     }
//   }
// }

//_____________________________________
// void TFndTofMonFrame::DrawCheckedHistos() 
// { 
//   static TFndMonCheckFrame *a[1000];
//   if(fNHpres != 0 && fNHpres <= 1000) 
//     for(Int_t i=0; i<fNHpres; i++) 
//       if(a[i]) a[i]->DoClose();  
//   Int_t nH = fCheckedHistos->GetEntriesFast();
//   if(nH > 0) {
//     fNHpres = nH;
//     for(Int_t i=0; i<fNHpres; i++) {
//       a[i] = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//       a[i]->Create();
//       a[i]->DoDraw();
//     }
//   }
// }

---