STB/TFndStbMonFrame.cxx

// @(#)fROOT/STB:$Name:  $:$Id: TFndStbMonFrame.cxx,v 1.19 2007/09/05 10:48:18 Diego_Faso Exp $
// Revision Author: Diego Faso <mailto:faso@to.infn.it>, 2005/06/24
// Original Author: Piergiorgio Cerello <mailto:cerello@to.infn.it>, 2001

//                                                //
//               TFndStbMonFrame                  //
//                                                //
//  Class for the STB monitoring GUI              //
//                                                //
//  (see GTS relative class for descriptions)     //
//                                                //
//                                                //

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

#include "TFndStbMonFrame.h" 
#include "TFndRun.h" 
#include "TFndStbMon.h" 

ClassImp(TFndStbMonFrame)

//_______________________________________________
TFndStbMonFrame::TFndStbMonFrame(TString filename):TFndMonFrame(filename),fMap(),fShm(),fNMaxCrown(K_N_STB_CROWNS),fNMaxTube(K_N_STB_TUBES),fcrown(),ftube(),h1(),h2(),hpat(),fCrownPad(),fTubePad(),fHistoPad(),fActionPad(),fMessagePad(),fCrownPadTitBut(),fTubePadTitBut(),fCrownBut(),fTubeBut(),fStatusBut(),fErrorBut(),fPatternBut(),fTdcMapBut(),fMulBut(),fCrownButCol(),fTubeButCol(),fMessageButCol(),fHistoButCol(),fMulButCol(),fLastAction(-1)
{
  // Ctor

  Init();
}

//_______________________________________________
void TFndStbMonFrame::Init() {

  SetStyle();
  //  fndrun->SetStbMonFrame(this);
  //  StartInterface();
  return;
}

//_______________________________________________
void TFndStbMonFrame::Open() {
  
  if(!fClosed) return;
  if(!StartInterface()) return;
  fClosed = kFALSE;
}

//_______________________________________________
TFndStbMonFrame::~TFndStbMonFrame() {
  // Dtor

   if(!fClosed) Close();
}

//_______________________________________________
void TFndStbMonFrame::Close() {

  if(!fClosed){
    
    //     delete h1; h1 = 0;
    //     delete h2; h2 = 0;
    //    for(Int_t i=0;i<K_N_STB_CROWNS;i++){ delete hpat[i]; hpat[i] = NULL;}

    //    cout << "...closing and re-initializing to zero all mapfiles..." << endl;    
    if(fMap) {fMap->Close(); fMap = 0; }
    for(Int_t i=0;i<K_N_STB_CROWNS;i++)if(fShm[i]) {fShm[i]->Close(); fShm[i] = 0; }
    //    cout << "...done (Close)" << endl;

    delete fCrownPadTitBut; fCrownPadTitBut = 0;
    delete fTubePadTitBut;  fTubePadTitBut = 0;
    
    for(Int_t i=0;i<K_N_STB_CROWNS;i++){
      delete fCrownBut[i]; fCrownBut[i] = 0;
      delete fTubeBut[i];  fTubeBut[i] = 0;
    }
    
    delete fStatusBut; fStatusBut = 0;
    delete fErrorBut;  fErrorBut = 0;
    delete fMulBut;     fMulBut = 0;
    
    fCrownPad->Close();   delete fCrownPad;   fCrownPad = 0;
    fTubePad->Close();    delete fTubePad;    fTubePad = 0;
    fHistoPad->Close();   delete fHistoPad;   fHistoPad = 0;
    fMessagePad->Close(); delete fMessagePad; fMessagePad = 0;
    fActionPad->Close();  delete fActionPad;  fActionPad = 0;
  }
  fClosed = kTRUE;
}

//___________________________________________
Bool_t TFndStbMonFrame::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[7] = 0;


#if defined _FND_ONL_USE_MAP_FILES_
  if(fndrun->GetDebug()) cout << "...closing and re-initializing to zero all mapfiles..." << endl;    
  if(fMap) {fMap->Close(); fMap = 0; }
  for(Int_t i=0;i<K_N_STB_CROWNS;i++) if(fShm[i]) {fShm[i]->Close(); fShm[i] = 0; }
  if(fndrun->GetDebug()) cout << "...done" << endl;
  //
  shr_file_map_name[0] = "$FND_SHR/stb.map";
  shr_file_map_name[1] = "$FND_SHR/stb_tdc_1.map";
  shr_file_map_name[2] = "$FND_SHR/stb_tdc_2.map";
  shr_file_map_name[3] = "$FND_SHR/stb_tdc_3.map";
  shr_file_map_name[4] = "$FND_SHR/stb_tdc_4.map";
  shr_file_map_name[5] = "$FND_SHR/stb_tdc_5.map";
  shr_file_map_name[6] = "$FND_SHR/stb_tdc_6.map";
#elif defined _FND_ONL_USE_SHARED_FILES_
  if(fMap) {fMap->Close(); delete fMap; fMap = 0; }
  for(Int_t i=0;i<K_N_STB_CROWNS;i++) if(fShm[i]) { if(fShm[i]->IsOpen()) fShm[i]->Close(); delete fShm[i]; fShm[i] = 0; }
  //
  shr_file_map_name[0] = "$FND_SHR/stb.file.map";
  shr_file_map_name[1] = "$FND_SHR/stb_tdc_1.file.map";
  shr_file_map_name[2] = "$FND_SHR/stb_tdc_2.file.map";
  shr_file_map_name[3] = "$FND_SHR/stb_tdc_3.file.map";
  shr_file_map_name[4] = "$FND_SHR/stb_tdc_4.file.map";
  shr_file_map_name[5] = "$FND_SHR/stb_tdc_5.file.map";
  shr_file_map_name[6] = "$FND_SHR/stb_tdc_6.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_
    fMap = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[0].Data()),"READ");
    if(fndrun->GetDebug()) fMap->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    fMap = new TFile(FROOT::ExpandPathName(shr_file_map_name[0].Data()),"READ");
#endif
  }
  else result = kFALSE;
  
  for(Int_t shr_id=0;shr_id<6;shr_id++){
    if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[shr_id+1].Data()))){ 
#if defined _FND_ONL_USE_MAP_FILES_
      fShm[shr_id] = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[shr_id+1].Data()),"READ");
      if(fndrun->GetDebug()) fShm[shr_id]->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
      fShm[shr_id] = new TFile(FROOT::ExpandPathName(shr_file_map_name[shr_id+1].Data()),"READ");
#endif
    }
    else result = kFALSE;
  }

  //   if(!gSystem->AccessPathName(FROOT::ExpandPathName("$FND_SHR/stb_tdc_2.map"))){ 
  //     fShm[1] = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/stb_tdc_2.map"),"READ");
  //     if(fndrun->GetDebug()) fShm[1]->Print();
  //   }
  //   else result = kFALSE;
  
  //   if(!gSystem->AccessPathName(FROOT::ExpandPathName("$FND_SHR/stb_tdc_3.map"))){ 
  //     fShm[2] = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/stb_tdc_3.map"),"READ");
  //     if(fndrun->GetDebug()) fShm[2]->Print();
  //   }
  //   else result = kFALSE;
  
  //   if(!gSystem->AccessPathName(FROOT::ExpandPathName("$FND_SHR/stb_tdc_4.map"))){ 
  //     fShm[3] = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/stb_tdc_4.map"),"READ");
  //     if(fndrun->GetDebug()) fShm[3]->Print();
  //   }
  //   else result = kFALSE;
  
  //   if(!gSystem->AccessPathName(FROOT::ExpandPathName("$FND_SHR/stb_tdc_5.map"))){ 
  //     fShm[4] = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/stb_tdc_5.map"),"READ");
  //     if(fndrun->GetDebug()) fShm[4]->Print();
  //   }
  //   else result = kFALSE;
  
  //   if(!gSystem->AccessPathName(FROOT::ExpandPathName("$FND_SHR/stb_tdc_6.map"))){ 
  //     fShm[5] = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/stb_tdc_6.map"),"READ");
  //     if(fndrun->GetDebug()) fShm[5]->Print();
  //   }
  //   else result = kFALSE;
  
  if(fndrun->GetDebug()){
    if(result) cout << "...done" << endl << endl;
    else cout << "STB - shared memories not found!" << endl << endl;
  }
  return result;
  
}

//___________________________________________
void TFndStbMonFrame::RefreshSingleMonView(){
  // In this class the HighlightButton() method
  // is not implemented, so the RefreshSingleMonView() method
  // must remember the last clicked button

  if(fLastAction==-1) return;

  FlashDisplayPad();
  switch(fLastAction){
  case 0: // crown-tube
    fCrownBut[fcrown-1]->ExecuteEvent(11,0,0);
    break;
  case 1: // pattern
    fPatternBut->ExecuteEvent(11,0,0);
    break;
  case 2: // 2D map
    fTdcMapBut->ExecuteEvent(11,0,0);
    break;
  case 3: // 2D map
    fMulBut->ExecuteEvent(11,0,0);
    break;
  }
  
}


//_______________________________________________
Bool_t TFndStbMonFrame::StartInterface() {

  //  fT0flag = 0;
  fcrown = 1;
  ftube = 1;

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

  // Stop here if no shared memory found
  ReloadMapFiles();
  //   fCanStartGUI = ReloadMapFiles();
  //   if(!fCanStartGUI) return; 
  
  //  if (fRF)  cout << "...source file found...starting GUI" << endl;

  fCrownButCol=50;
  fTubeButCol=50;
  fMessageButCol=190;
  fHistoButCol=30;
  fMulButCol=38;
  fHighlightCol[0]=5;
  //--------------------------- PADS -------------------------

  fMainCanvas[0] = new TCanvas("Stb_MainCanvas","STB Detector Display",
                               fMainCanvCoord[0],fMainCanvCoord[1],
                               fMainCanvCoord[2],fMainCanvCoord[3]);
  SetMonitorTitle(0,"STB");
  fMainCanvas[0]->SetEditable(kFALSE);
  //  fMainCanvas[0]->ToggleEventStatus();
  fMainCanvas[0]->SetFillColor(1);
  fMainCanvas[0]->Draw();
  // -----
  fCrownPad = new TPad("CrownPad","Crown Pad",0.,0.5,0.1,1.);
  fCrownPad->SetFillColor(44);
  fCrownPad->SetBorderSize(2);
  fCrownPad->Draw();
  // -----
  fTubePad = new TPad("TubePad","Tube Pad",0.1,0.5,0.2,1.);
  fTubePad->SetFillColor(33);
  fTubePad->SetBorderSize(2);
  fTubePad->Draw();
  // -----
  fMessagePad = new TPad("MessagePad","Message Pad",0.,.35,.2,.50);
  fMessagePad->SetFillColor(24);
  fMessagePad->SetBorderSize(2);
  fMessagePad->Draw();
  // -----
  fHistoPad = new TPad("HistoPad","Histo Pad",0.,.15,0.2,0.35);
  fHistoPad->SetFillColor(33);
  fHistoPad->SetBorderSize(2);
  fHistoPad->Draw();
  // -----
  fActionPad = new TPad("ActionPad","Action Pad",0.,0.,.2,.15);
  fActionPad->SetFillColor(14);
  fActionPad->SetBorderSize(2);
  fActionPad->Draw();
  // -----
  fDisplayPad[0] = new TPad("StbDisplayPad","Stb Display Pad",0.2,0.,1.,1.);
  fDisplayPad[0]->SetFillColor(33);
  fDisplayPad[0]->SetBorderSize(2);
  fDisplayPad[0]->Draw();

  // -----
  DrawButtons();
  BuildConnections();

  fCrownPad->SetEditable(kFALSE);
  fTubePad->SetEditable(kFALSE);
  fMessagePad->SetEditable(kFALSE);
  fHistoPad->SetEditable(kFALSE);
  fActionPad->SetEditable(kFALSE);
  //fDisplayPad[0]->SetEditable(kFALSE);

  return kTRUE;
  //  fClosed = kFALSE;
}

//_______________________________________________
void TFndStbMonFrame::DrawButtons() {

  fCrownPad->cd();

  Float_t xMinBut = 0.07 ;
  Float_t xMaxBut = 0.93 ;
  Float_t y=0.8;
  Float_t HeightBut=0.1;
  Float_t dy=0.03;

  TButton *CrownPadTitBut = new TButton("Crown","",xMinBut,.88,xMaxBut,.98);
  CrownPadTitBut->SetFillColor(71);
  CrownPadTitBut->Draw();

  TString *titlec = new TString("Crown  ");
  TString *methodc = new TString("fndrun->StbMonFrame()->SetCrown(0)"); 
 
  Char_t crn[2];
  for (Int_t c=0;c<fNMaxCrown;c++) {
    sprintf(crn,"%d",c+1);
    titlec->Replace(6,1,crn);
    methodc->Replace(32,1,crn);

    fCrownBut[c] = new TButton(titlec->Data(), methodc->Data(),xMinBut,y-HeightBut,xMaxBut,y);
    fCrownBut[c]->SetFillColor(fCrownButCol);
    fCrownBut[c]->SetTextSize(0.5);
    fCrownBut[c]->Draw();
    y -= HeightBut + dy;
  }  
  delete titlec;
  delete methodc;

  //_______________
  fTubePad->cd();
  //_______________
  y=0.80;

  TButton *fTubePadTitBut = new TButton("Tube","",xMinBut,.88,xMaxBut,.98);
  fTubePadTitBut->SetFillColor(71);
  fTubePadTitBut->Draw();

  TString *titlet = new TString("    ");
  TString *methodt = new TString("fndrun->StbMonFrame()->ShiftTube(");
  Char_t shiftstep[4];
  Int_t shift = 1;
  for (Int_t t=0;t<6;t++) {
    methodt->Remove(33,5);
  
    if(t%2==0) { 
      titlet->Replace(0,1,"-"); 
      methodt->Append("-");
      if(t!=0) shift = shift * 10;
    }  
    else {
      titlet->Replace(0,3,"+"); 
      methodt->Append("+");
    }
    sprintf(shiftstep,"%d",shift);
    titlet->Replace(1,3,shiftstep);
    methodt->Append(shiftstep);
    methodt->Append(")");
 
    fTubeBut[t] = new TButton(titlet->Data(),methodt->Data(),xMinBut,y-HeightBut,xMaxBut,y);
    fTubeBut[t]->SetFillColor(fTubeButCol); 
    fTubeBut[t]->Draw(); 
    y -= HeightBut + dy;
  }

  //_______________
  fMessagePad->cd();
  //_______________
  fStatusBut = new TButton("              ","",.02,.52,.98,.9);
  fStatusBut->SetFillColor(fMessageButCol);
  fStatusBut->SetTextSize(0.5);
  fStatusBut->Draw();
  
  fErrorBut = new TButton("              ","",.02,.1,.98,.48);
  fErrorBut->SetFillColor(fMessageButCol);
  fErrorBut->SetTextSize(0.5);
  fErrorBut->Draw();
  //_______________
  fHistoPad->cd();
  //_______________
  fPatternBut = new TButton("Pattern","fndrun->StbMonFrame()->DrawPatterns()",.02,.7,.98,.95);
  fPatternBut->SetFillColor(fHistoButCol);
  fPatternBut->Draw();
  
  fTdcMapBut = new TButton("TDC Map","fndrun->StbMonFrame()->DrawTdcMap()",.02,.4,.98,.65);
  fTdcMapBut->SetFillColor(fHistoButCol);
  fTdcMapBut->Draw();

  fMulBut = new TButton("MULT","fndrun->StbMonFrame()->DrawMultiplicity()",.02,.1,.98,.35);
  fMulBut->SetFillColor(fMulButCol);
  fMulBut->Draw();
  
  //_______________
  fActionPad->cd();
  //_______________

}

//___________________________________________________
void TFndStbMonFrame::SetCrown(Int_t cr) {

  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }
  fcrown = cr;
  //  cout << "Selected Crown " << fcrown << "  -  Tube " <<ftube << endl;

  ClearButton();
  fCrownBut[fcrown-1]->SetFillColor(fHighlightCol[0]);
  
  TellSelection();
  fStatusBut->SetFillColor(fMessageButCol);
  fStatusBut->Modified();
  
  DrawHist();
}

//___________________________________________________
void TFndStbMonFrame::ShiftTube(Int_t shift) {
  
  ClearButton();
  
  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }
  if(ftube+shift>0 && ftube+shift<=fNMaxTube) {
    ftube = ftube + shift;
    //    cout << "Selected Crown " << fcrown << "  -  Tube " <<ftube << endl;
  }
  else {
    fErrorBut->SetFillColor(100);
    fErrorBut->SetTitle("Tube Out Of Range");
    fErrorBut->Modified();
    cout << "..... straw tube number out of range ....." << endl; 
    if(ftube+shift<1) ftube = 1;
    if(ftube+shift>fNMaxTube) ftube = K_N_STB_TUBES;
  }

 TellSelection();
 if(shift==-1)   fTubeBut[0]->SetFillColor(fHighlightCol[0]);
 if(shift==+1)   fTubeBut[1]->SetFillColor(fHighlightCol[0]);
 if(shift==-10)  fTubeBut[2]->SetFillColor(fHighlightCol[0]);
 if(shift==+10)  fTubeBut[3]->SetFillColor(fHighlightCol[0]);
 if(shift==-100) fTubeBut[4]->SetFillColor(fHighlightCol[0]);
 if(shift==+100) fTubeBut[5]->SetFillColor(fHighlightCol[0]);
 fCrownBut[fcrown-1]->SetFillColor(fHighlightCol[0]);

 DrawHist();
}

//___________________________________________________
void TFndStbMonFrame::TellSelection() {
  TString *title = new TString("crown   - ");
  TString *titlet = new TString("tube    ");
  Char_t crownsel[2];
  Char_t tubesel[4]; 
  sprintf(crownsel,"%d",fcrown);
  sprintf(tubesel,"%d",ftube);
  title->Replace(6,1,crownsel);
  titlet->Replace(5,3,tubesel);
  title->Append(titlet->Data());
  fStatusBut->SetTitle(title->Data()); 
  fStatusBut->Modified();
  delete titlet;
  delete title;
}

//___________________________________________________
void TFndStbMonFrame::T0Calib() {

  Info("T0Calib","deprecated method");

  /*
  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }
  fT0flag = 1;
  fT0But->SetFillColor(69);
  //fT0But->Modified;
  TString *filename = new TString(fRF->GetName());
  cout << filename->Data() << endl;
  if(!fndrun->StbMon()) fndrun->StartStbMonitor(filename);
  fndrun->StbMon()->TimeCalibration();
  delete filename;
  fT0But->SetFillColor(65);
  //fT0But->Modified;
  */


  return;
}

//___________________________________________________
void TFndStbMonFrame::ClearButton() {

  for (Int_t c=0;c<fNMaxCrown;c++) {
    fCrownBut[c]->SetFillColor(fCrownButCol);
    fTubeBut[c]->SetFillColor(fTubeButCol);
    fCrownBut[c]->Modified();
    fTubeBut[c]->Modified();
  }
  fErrorBut->SetFillColor(fMessageButCol);
  fErrorBut->SetTitle("              ");
  fErrorBut->Modified();

  fPatternBut->SetFillColor(fHistoButCol);
  fPatternBut->Modified();

  fTdcMapBut->SetFillColor(fHistoButCol);
  fTdcMapBut->Modified();

  fMulBut->SetFillColor(fHistoButCol);
  fMulBut->Modified();
  
  fDisplayPad[0]->Clear();
}

//___________________________________________________
void TFndStbMonFrame::DrawHist(){  
  
  //   delete h1; h1 = 0;
  //   delete h2; h2 = 0;
  TString h1name("stbtdc_");
  // *** stringa con nome dell'istogramma "stbtdc_1_1"  ***
  Char_t crownsel[2];
  Char_t tubesel[4]; 
  sprintf(crownsel,"%d",fcrown);
  sprintf(tubesel,"%d",ftube);
  h1name.Append(crownsel);
  h1name.Append("_");
  h1name.Append(tubesel);

  if(!fRF) {
    h1 = (TH1F*) fShm[fcrown-1]->Get(h1name.Data());
  } else {
    h1 = (TH1F*) fRF->Get(h1name.Data());
  }
  
  fDisplayPad[0]->cd();
  if(h1) h1->Draw();
  //  cout << "...drawing " << h1name.Data() << endl;
  Int_t maxcont = 0;
  Int_t stb_tdc_bins = h1->GetNbinsX();
  for(Int_t nb=0; nb<stb_tdc_bins; nb++) {
    Int_t cont = (Int_t) h1->GetBinContent(nb+1);
    if(cont >= maxcont) { 
      maxcont = cont; 
    }
  }

  //  if(fT0flag==1) fndrun->StbMon()->DisplayTZero(fcrown,ftube,maxcont);
  fLastAction = 0; // remember last action
  return;
}
//___________________________________________________
void TFndStbMonFrame::DrawTdcMap(){  
  
  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }
  //   delete h1; h1 = 0;
  //   delete h2; h2 = 0;
  
  ClearButton();
  fTdcMapBut->SetFillColor(fHighlightCol[0]);
  fTdcMapBut->Modified();
  
  if(!fRF) {
    h2 = (TH2F*) fMap->Get("stbmaptdc");
  } else {
    h2 = (TH2F*) fRF->Get("stbmaptdc");
  }   
  fStatusBut->SetTitle("TDC map"); 
  fStatusBut->Modified();
  fDisplayPad[0]->cd();
  if(h2) h2->Draw(""); // you can try "colz"
  fLastAction = 2; // remember last action
  return;
}

//___________________________________________________
void TFndStbMonFrame::DrawPatterns(){  

  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }
  //   delete h1; h1 = 0;
  //   delete h2; h2 = 0;
  //  for(Int_t i=0;i<K_N_STB_CROWNS;i++){ delete hpat[i]; hpat[i] = NULL;}
  ClearButton();
  fPatternBut->SetFillColor(fHighlightCol[0]);
  fPatternBut->Modified();
  fStatusBut->SetTitle("TDC Patterns"); 
  fStatusBut->Modified();

  fDisplayPad[0]->Divide(3,2,.001,.001);

  TString title = TString("stb_pattern_ ");
  Char_t cr[2];
  for(Int_t i=0;i<K_N_STB_CROWNS;i++){
    sprintf(cr,"%d",i+1);
    title.Replace(12,1,cr);
    if(!fRF) {
      hpat[i] = (TH1F*) fMap->Get(title.Data());
    } else {
      hpat[i] = (TH1F*) fRF->Get(title.Data());
    }
    fDisplayPad[0]->cd(i+1);
    if(hpat[i]) hpat[i]->Draw();
  }
  fLastAction = 1; // remember last action
}


//___________________________________________________
void TFndStbMonFrame::DrawMultiplicity(){

  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }
  
  ClearButton();
  fMulBut->SetFillColor(fHighlightCol[0]);
  fMulBut->Modified();
  fStatusBut->SetTitle("TDC Mult"); 
  fStatusBut->Modified();

  if(!fRF) {
    h1 = (TH1F*) fMap->Get("stbmult");
  } else {
    h1 = (TH1F*) fRF->Get("stbmult");
  }   
  fStatusBut->SetTitle("TDC mult"); 
  fStatusBut->Modified();
  fDisplayPad[0]->cd();
  if(h1) h1->Draw("");
  fLastAction = 3; // remember last action
  return;

}

---