LMD/TFndLmdMonFrame.cxx

// @(#)fROOT/LMD:$Name:  $:$Id: TFndLmdMonFrame.cxx,v 1.25 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>

//     GUI Monitor frame for the FINUDA Low Mass Drift Chambers' monitoring                //
//                                                                                         //
//                                                                                         //
//  - Both online and offline mode are available (se constructors)                         //
//  - Shared memories (TMapFile) are used for the online monitoring, while the "offline"   //
//    histogram filling reads files directly (files are produced by the "geb2hdt" macro).  //
//                                                                                         //
//   (see GTS relative class for descriptions)                                             //
//                                                                                         //

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

#include "TFndLmdMonFrame.h" 
#include "TFndRun.h" 

ClassImp(TFndLmdMonFrame)

//____________________________________________________
TFndLmdMonFrame::TFndLmdMonFrame(TString filename):TFndMonFrame(filename),fIO(),fdch(),fwir(),maps(),iadc(),itdc(),oadc(),otdc(),fInnPad(),fOutPad(),fMultPad(),fWirePad(),fAllPad(),fChSelBut(),fAllButton(),fWireBut(),zoombutton(),fhists(),h2(),sly(),fWhichGroup(-1),fAllId(-1)
{
  // the button highlight color can be different for the 2 layers
  // All colors are customizable

  Init();
}

//____________________________________________________
void TFndLmdMonFrame::Init() {

  //   fCheckedHistos = new TObjArray(1000);
  SetStyle();
  fHighlightCol[0] = 5;
  fHighlightCol[1] = 5;
  //   fSHMEntries = 0;
  //   time_t now;
  //   now = time(&now);
  //   fTime = now;
  //   cout << "Time is: " << fTime << " in TFndLmdMonFrame::Init()" << endl;
  
  //  fndrun->SetLmdMonFrame(this);
  //  if(!fCanStartGUI){
  //    Warning("Init()","Can't start GUI interface");
  //    return;
  //  }
  //  StartInterface();
}

//____________________________________________________
void TFndLmdMonFrame::Open() {

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

//____________________________________________________
Bool_t TFndLmdMonFrame::StartInterface() {
  // The GUI interface is built (including sub-pads and buttons) 
  // Shared memories are open if you are working online
  // Files have been already opened if you are working offline

  Int_t BackgroundCol = 12;
  Int_t DisplayPadCol = 15;

  Float_t sep = 0.001;
  Float_t smallsep = 0.0005;

  Float_t Start_X_displaypad = 0.08;
  Float_t Stop_X_displaypad  = 1.;
  Float_t Start_Y_displaypad = 0.05;
  Float_t Stop_Y_displaypad  = 0.94;

  Float_t MultInn_Y_Edge = 0.11;
  Float_t InnOutEdge = ((Stop_Y_displaypad-sep)+(MultInn_Y_Edge+smallsep))/2;

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


  fdch=1;
  fwir=1;
  // shared memories used only in "online-mode"
  ReloadMapFiles();
  //   fCanStartGUI = ReloadMapFiles();
  //   if(!fCanStartGUI) return;
  
  if (fRF)  Printf("TFndLmdMonFrame::StartInterface ---> source file found...starting GUI");

  // ---
  // main canvas
  //  Int_t xsize = 1050;
  //  Int_t ysize =  700;
  //  Int_t x0 = 150;
  //  Int_t y0 = 0;
  fMainCanvas[0] = new TCanvas("Lmd_MainCanvas","LMD Detector Display",
                               fMainCanvCoord[0],fMainCanvCoord[1],
                               fMainCanvCoord[2],fMainCanvCoord[3]);
  SetMonitorTitle(0,"LMD");
  fMainCanvas[0]->SetEditable(kFALSE);
  //  fMainCanvas[0]->ToggleEventStatus();
  fMainCanvas[0]->SetFillColor(BackgroundCol);
  fMainCanvas[0]->Draw();
  
  // Display pad
  fMainCanvas[0]->cd();
  fDisplayPad[0] = new TPad("LmdMonFrameDisplayPad","hist display",
                         Start_X_displaypad+sep,Start_Y_displaypad+sep,Stop_X_displaypad,Stop_Y_displaypad);
  fDisplayPad[0]->Draw();
  fDisplayPad[0]->SetFillColor(DisplayPadCol);
  fDisplayPad[0]->SetBorderSize(2);

  // Bottom pad
  fAllPad = new TPad("lmd_AllPadControl","lmd_AllPadControl",Start_X_displaypad+sep,0.,Stop_X_displaypad,Start_Y_displaypad-sep);
  fAllPad->Draw();

  // Left pad
  fMultPad = new TPad("mulLmdSelPad","mulLmdSelPad",0.,0.,Start_X_displaypad-sep,MultInn_Y_Edge-smallsep);
  fMultPad->SetFillColor(13);
  fMultPad->Draw();
  fInnPad = new TPad("iLmdSelPad","iLmdSelPad",0.,MultInn_Y_Edge+smallsep,Start_X_displaypad-sep,InnOutEdge-smallsep);
  fInnPad->SetFillColor(13);
  fInnPad->Draw();
  fOutPad = new TPad("oLmdSelPad","oLmdSelPad",0.,InnOutEdge+smallsep,Start_X_displaypad-sep,0.94);
  fOutPad->SetFillColor(13);
  fOutPad->Draw();

  //  Control Pads
  fMainCanvas[0]->cd();
  fWirePad = new TPad("selectwire","wr",0.,Stop_Y_displaypad+sep,1.,1.);
  fWirePad->SetFillColor(BackgroundCol);
  fWirePad->Draw();

  DrawButtons();
  BuildConnections();

  fAllPad->SetEditable(kFALSE);
  fMultPad->SetEditable(kFALSE);
  fInnPad->SetEditable(kFALSE);
  fOutPad->SetEditable(kFALSE);

  return kTRUE;
  //  fClosed = kFALSE;
}

//____________________________________________________
void TFndLmdMonFrame::DrawButtons() {

  //  cout << "...drawing buttons..." << endl;
  Float_t MapWidth = 0.08;

  Float_t step = (1-MapWidth)/8.;
  Float_t xi = 0.;
  Float_t xf = MapWidth;
  //cout << "   -> ALL (bottom-pad)" << endl;
  fAllPad->cd();
  fAllButton[0] = new TButton("Maps","fndrun->LmdMonFrame()->DisplayMaps();",xi,0.,xf,1.);
  fAllButton[0]->SetTextSize(0.5);
  fAllButton[0]->Draw();
  xi = xf;
  xf += step;
  fAllButton[1] = new TButton("i_eff","fndrun->LmdMonFrame()->DisplayAllHist(0,0);",xi,0.,xf,1.);
  fAllButton[1]->SetTextSize(0.5);
  fAllButton[1]->Draw();
  xi = xf;
  xf += step;
  fAllButton[2] = new TButton("o_eff","fndrun->LmdMonFrame()->DisplayAllHist(1,0);",xi,0.,xf,1.);
  fAllButton[2]->SetTextSize(0.5);
  fAllButton[2]->Draw();
  xi = xf;
  xf += step;
  fAllButton[3] = new TButton("i_adcs","fndrun->LmdMonFrame()->DisplayAllHist(0,1);",xi,0.,xf,1.);
  fAllButton[3]->SetTextSize(0.5);
  fAllButton[3]->Draw();
  xi = xf;
  xf += step;
  fAllButton[4] = new TButton("o_adcs","fndrun->LmdMonFrame()->DisplayAllHist(1,1);",xi,0.,xf,1.);
  fAllButton[4]->SetTextSize(0.5);
  fAllButton[4]->Draw();
  xi = xf;
  xf += step;
  fAllButton[5] = new TButton("i_tdcs","fndrun->LmdMonFrame()->DisplayAllHist(0,2);",xi,0.,xf,1.);
  fAllButton[5]->SetTextSize(0.5);
  fAllButton[5]->Draw();
  xi = xf;
  xf += step;
  fAllButton[6] = new TButton("o_tdcs","fndrun->LmdMonFrame()->DisplayAllHist(1,2);",xi,0.,xf,1.);
  fAllButton[6]->SetTextSize(0.5);
  fAllButton[6]->Draw();
  xi = xf;
  xf += step;
  fAllButton[7] = new TButton("i_adc_tdc","fndrun->LmdMonFrame()->DisplayAllHist(0,3);",xi,0.,xf,1.);
  fAllButton[7]->SetTextSize(0.5);
  fAllButton[7]->Draw();
  xi = xf;
  xf += step;
  fAllButton[8] = new TButton("o_adc_tdc","fndrun->LmdMonFrame()->DisplayAllHist(1,3);",xi,0.,xf,1.);
  fAllButton[8]->SetTextSize(0.5);
  fAllButton[8]->Draw();

  //cout << "   -> PEDESTAL [fMultPad] (bottom-left-pad)" << endl;
  fMultPad->cd();
  fAllButton[9] = new TButton("i_mul","fndrun->LmdMonFrame()->DisplayAllHist(0,4);",0.,0.,1.0,0.5);
  fAllButton[9]->Draw();
  fAllButton[10] = new TButton("o_mul","fndrun->LmdMonFrame()->DisplayAllHist(1,4);",0.,0.5,1.0,1.);
  fAllButton[10]->Draw();

  fAllPad->Modified();
  // ---
  //cout << "   -> INNER LMDs Pad [fInnPad] (left-pad)" << endl;
  fInnPad->cd();
  for(Int_t i=0;i<8;i++) {
    TString str1 = TString("fndrun->LmdMonFrame()->SelectChamber(0,");
    TString modlab = TString("i_");
    modlab+=i+1;
    str1+=i+1;
    str1+="); ";
    str1+="fndrun->LmdMonFrame()->DrawWirePad();";
    //cout << "      -> fChSelBut[" << i << "] : " << modlab.Data() << " -> " << str1.Data() << endl;
    fChSelBut[i] = new TButton(modlab.Data(),str1.Data(),0.00,0.125*i,1.0,0.125*(i+1));
    fChSelBut[i]->Draw();
  }
  fInnPad->Modified();
  // ---
  //cout << "   -> OUTER LMDs Pad [fOutPad] (left-pad)" << endl;
  fOutPad->cd();
  for(Int_t i=0;i<8;i++) {
    TString str1 = TString("fndrun->LmdMonFrame()->SelectChamber(1,");
    TString modlab = TString("o_");
    modlab+=i+1;
    str1+=i+1;
    str1+=");";
    str1+="fndrun->LmdMonFrame()->DrawWirePad();";
    //cout << "      -> fChSelBut[" << i+8 << "] : " << modlab.Data() << " -> " << str1.Data() << endl;
    fChSelBut[i+8] = new TButton(modlab.Data(),str1.Data(),0.00,0.125*i,1.0,0.125*(i+1));
    fChSelBut[i+8]->Draw();
  }
  fOutPad->Modified();
  // ---
  //  cout << "Buttons drawing completed." << endl;
  RebuildWirePad();
  ResetFrameColors();
}

//____________________________________________________
TFndLmdMonFrame::~TFndLmdMonFrame() {
   if(!fClosed) Close();
}

//____________________________________________________
void TFndLmdMonFrame::Close() {
  // the consumer should not close shared memories

  if(!fClosed){
    Printf("TFndLmdMonFrame::Close ---> closing and re-initializing to zero all mapfiles...");    
    if(maps) { maps->Close(); maps = 0; }
    if(iadc) { iadc->Close(); iadc = 0; }
    if(itdc) { itdc->Close(); itdc = 0; }
    if(oadc) { oadc->Close(); oadc = 0; }
    if(otdc) { otdc->Close(); otdc = 0; }
    Printf("TFndLmdMonFrame::Close ---> Done.");    
    
    for(Int_t i=0;i<16;i++) { delete fChSelBut[i]; fChSelBut[i] = 0; }       // LDM num buttons
    for(Int_t i=0;i<11;i++) { delete fAllButton[i]; fAllButton[i] = 0; } // bottom pad buttons
    
    fWirePad->Close();  delete fWirePad; //fWirePad = 0;
    fOutPad->Close();   delete fOutPad;  //fOutPad = 0;
    fInnPad->Close();   delete fInnPad;  //fInnPad = 0;
    fMultPad->Close();  delete fMultPad; //fMultPad = 0;
    fAllPad->Close();   delete fAllPad;  //fAllPad = 0;
    fDisplayPad[0]->Close(); delete fDisplayPad[0]; fDisplayPad[0] = 0;
    fMainCanvas[0]->Close(); delete fMainCanvas[0]; fMainCanvas[0] = 0;
  }
  fClosed = kTRUE;
}

//____________________________________________________
Bool_t TFndLmdMonFrame::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[5] = 0;

#if defined _FND_ONL_USE_MAP_FILES_
  if(fndrun->GetDebug()) Printf("TFndLmdMonFrame::ReloadMapFiles ---> closing and re-initializing to zero all mapfiles...");    
  if(maps) { maps->Close(); maps = 0; }
  if(iadc) { iadc->Close(); iadc = 0; }
  if(itdc) { itdc->Close(); itdc = 0; }
  if(oadc) { oadc->Close(); oadc = 0; }
  if(otdc) { otdc->Close(); otdc = 0; }
  if(fndrun->GetDebug()) Printf("TFndLmdMonFrame::ReloadMapFiles ---> Done");
  //
  shr_file_map_name[0] = "$FND_SHR/lmd.map";
  shr_file_map_name[1] = "$FND_SHR/lmd_i_adc.map";
  shr_file_map_name[2] = "$FND_SHR/lmd_i_tdc.map";
  shr_file_map_name[3] = "$FND_SHR/lmd_o_adc.map";
  shr_file_map_name[4] = "$FND_SHR/lmd_o_tdc.map";
#elif defined _FND_ONL_USE_SHARED_FILES_
  if(maps) { if(maps->IsOpen()) maps->Close(); delete maps; maps = 0; }
  if(iadc) { if(iadc->IsOpen()) iadc->Close(); delete iadc; iadc = 0; }
  if(itdc) { if(itdc->IsOpen()) itdc->Close(); delete itdc; itdc = 0; }
  if(oadc) { if(oadc->IsOpen()) oadc->Close(); delete oadc; oadc = 0; }
  if(otdc) { if(otdc->IsOpen()) otdc->Close(); delete otdc; otdc = 0; }
  //
  shr_file_map_name[0] = "$FND_SHR/lmd.file.map";
  shr_file_map_name[1] = "$FND_SHR/lmd_i_adc.file.map";
  shr_file_map_name[2] = "$FND_SHR/lmd_i_tdc.file.map";
  shr_file_map_name[3] = "$FND_SHR/lmd_o_adc.file.map";
  shr_file_map_name[4] = "$FND_SHR/lmd_o_tdc.file.map";
#endif
  
  
  if(fndrun->GetDebug()) Printf("TFndLmdMonFrame::ReloadMapFiles ---> Reloading shared memories...");
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[0].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    maps  = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[0].Data()),"READ");
    if(fndrun->GetDebug()) maps->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    maps  = new TFile(FROOT::ExpandPathName(shr_file_map_name[0].Data()),"READ");
#endif
  }
  else result = kFALSE;
  
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[1].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    iadc = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[1].Data()),"READ");
    if(fndrun->GetDebug()) iadc->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    iadc = new TFile(FROOT::ExpandPathName(shr_file_map_name[1].Data()),"READ");
#endif
  }
  else result = kFALSE;
  
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[2].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    itdc = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[2].Data()),"READ");
    if(fndrun->GetDebug()) itdc->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    itdc = new TFile(FROOT::ExpandPathName(shr_file_map_name[2].Data()),"READ");
#endif
  }
  else result = kFALSE;
  
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[3].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    //    oadc = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/lmd_o_adc.map"),"READ",(Int_t)(1048576*FROOT::K_LmdOadcMapSize));
    oadc = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[3].Data()),"READ");
    if(fndrun->GetDebug()) oadc->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    oadc = new TFile(FROOT::ExpandPathName(shr_file_map_name[3].Data()),"READ");
#endif
  }
  else result = kFALSE;
  
  if(!gSystem->AccessPathName(FROOT::ExpandPathName(shr_file_map_name[4].Data()))){
#if defined _FND_ONL_USE_MAP_FILES_
    //    otdc = TMapFile::Create(FROOT::ExpandPathName("$FND_SHR/lmd_o_tdc.map"),"READ",(Int_t)(1048576*FROOT::K_LmdOtdcMapSize));
    otdc = TMapFile::Create(FROOT::ExpandPathName(shr_file_map_name[4].Data()),"READ");
    if(fndrun->GetDebug()) otdc->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    otdc = new TFile(FROOT::ExpandPathName(shr_file_map_name[4].Data()),"READ");
#endif
  }
  else result = kFALSE; 
  
  if(fndrun->GetDebug()){
    if(result) Printf("TFndLmdMonFrame::ReloadMapFiles ---> Done");
    else Printf("TFndLmdMonFrame::ReloadMapFiles ---> shared memories not found!");
  }
  return result;
}

//____________________________________________________
void TFndLmdMonFrame::ResetFrameColors() {
  // All pads and buttons are reset to their default colors
  
  //cout << "...Resetting default colors..." << endl;
  Int_t MultCol = 30;
  Int_t ChMapCol = 41;
  Int_t ChNumICol = 42;
  Int_t ChNumOCol = 44;
  Int_t EffCol = 17;
  Int_t AdcCol    = 38;
  Int_t TdcCol    = 50;
  Int_t AdcTdcCol = 29;

  Int_t WireButCol = 42;

  //  fAllPad->cd();
  fAllButton[0]->SetFillColor(ChMapCol);
  fAllButton[1]->SetFillColor(EffCol);
  fAllButton[2]->SetFillColor(EffCol);
  fAllButton[3]->SetFillColor(AdcCol);
  fAllButton[4]->SetFillColor(AdcCol);
  fAllButton[5]->SetFillColor(TdcCol);
  fAllButton[6]->SetFillColor(TdcCol);
  fAllButton[7]->SetFillColor(AdcTdcCol);
  fAllButton[8]->SetFillColor(AdcTdcCol);
  fAllButton[9] ->SetFillColor(MultCol);
  fAllButton[10]->SetFillColor(MultCol);
  for(Int_t i=0;i<11;i++) fAllButton[i]->Modified();
  // ---
  for(Int_t i=0;i<8;i++){
    fChSelBut[i]->SetFillColor(ChNumICol); fChSelBut[i]->Modified(); 
    fChSelBut[i+8]->SetFillColor(ChNumOCol); fChSelBut[i+8]->Modified();
  }
  fWireBut[0]->SetFillColor(50); fWireBut[0]->Modified();
  for(Int_t i=1;i<=fNWires;i++) { fWireBut[i]->SetFillColor(WireButCol); fWireBut[i]->Modified(); }
  //cout << "...done." << endl;
}

//____________________________________________________
void TFndLmdMonFrame::SelectChamber(Int_t io, Int_t d){ 
  // Set the "fIO" and "fdch" data-members
  // and rebuild the wire-pad (without drawing it)

  fIO=io; fdch=d; 
  fNWires = 22;
  if(fIO == 0) fNWires = 12;
  fwir = 0;
  RebuildWirePad();
  //  gSystem->ProcessEvents();
  SelectWire(0);
  DisplayHist();

  fWhichGroup = 0;
  fAllId = 0;
}

//____________________________________________________
void TFndLmdMonFrame::RebuildWirePad(){
  // all wire-buttons are deleted and rebuilt, but not drawn

  //cout << "Rebuilding wire pad: " << fWirePad << endl;
  Int_t WireButCol = 42;
  for(Int_t i=0;i<=23;i++) { delete fWireBut[i]; fWireBut[i] = 0;}
  fNWires = 22; 
  if(fIO == 0) fNWires = 12;

  Float_t xi = 0.;
  Float_t step = 1./(fNWires+1);
  Float_t xf = step;

  fWirePad->cd(); 
  fWireBut[0] = new TButton("All","fndrun->LmdMonFrame()->SelectWire(0);fndrun->LmdMonFrame()->DisplayHist();",xi,0.,xf,1.);
  fWireBut[0]->SetFillColor(50);
  xi = xf;
  xf += step;

  fWirePad->cd();
  for(Int_t i=1;i<=fNWires;i++) {
    TString str1 = TString("w");
    TString str3 = TString("fndrun->LmdMonFrame()->SelectWire(");
    str1+=i;
    str3+=i;
    str3+="); fndrun->LmdMonFrame()->DisplayHist();";
    fWireBut[i] = new TButton(str1.Data(),str3.Data(),xi,0.,xf,1.);
    fWireBut[i]->SetFillColor(WireButCol);
    fWireBut[i]->SetTextSize(0.4);
    xi = xf;
    xf += step;
    if(xf > 1.) xf = 1.;
  }
  fWirePad->Modified();
  //  fWirePad->Update();
}

//____________________________________________________
void TFndLmdMonFrame::DrawWirePad(){
  // all wire-buttons are drawn (depending on the selected chamber)

//   if(!ReloadMapFiles()){
//     fDisplayPad[0]->Clear();
//     fDisplayPad[0]->Modified();
//     return;
//   }
  //  cout << "Drawing wire pad: " << fWirePad << endl;
  fWirePad->cd(); 
  for(Int_t i=0;i<=fNWires;i++){
    fWireBut[i]->Draw();
  }
  gPad->Modified();
  //  cout << "WirePad drawn" << endl;
}

//____________________________________________________
TButton *TFndLmdMonFrame::HighlightButtons(Int_t which_group,Int_t All_id){
  // Highlight active buttons (considering the selected Chamber/Layer/Wire)
  //  - which_group==0 : Chamber/Wire buttons highlighted
  //  - which_group==1 : fAllButtons buttons highlighted
  //  - All_id : index for the all_button

  fWhichGroup = which_group;
  fAllId = All_id;

  Int_t dch_id = fdch+fIO*8-1; // index for the LMD number button
  switch(which_group){
  case 0:
    fChSelBut[dch_id]->SetFillColor(fHighlightCol[fIO]);
    fChSelBut[dch_id]->Modified();
    
    fWireBut[fwir]->SetFillColor(fHighlightCol[fIO]);
    fWireBut[fwir]->Modified();
    return fWireBut[fwir];
    //return fChSelBut[dch_id];
    //    break;
  case 1:
    fAllButton[All_id]->SetFillColor(fHighlightCol[fIO]); 
    fAllButton[All_id]->Modified();
    return fAllButton[All_id];
    //    break;
  default: return 0;
  }
}

//___________________________________________
void TFndLmdMonFrame::RefreshSingleMonView(){

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


//_____________________
//_____________________
//_____________________
//____________________________________________________
void TFndLmdMonFrame::DrawHist(Int_t opt, Int_t flg, Char_t *DrawOpt){
  // Draw a selected histogram (see the source code for more details)
  // The field "flg" can be: "0":simple drawing ; "1":superposed drawing
  // The "DrawOpt" field acts only if "flg" is "0"
  
  //  Info("TFndLmdMonFrame::DrawHist"," ************************* called: %d ; %d; %s",opt,flg,DrawOpt);

  //  if(!fzoom) for(Int_t i=0;i<4;i++) fnbx[i] = 0;

  h2 = NULL;
  fhists = 0;
  sly = NULL;

  TString type = TString("");
  switch(opt){
  case 0:  type = "adc";  break;  // 2D
  case 1:  type = "adce";  break;
  case 2:  type = "adcp";  break;
  case 3:  type = "crg";  break;
  case 4:  type = "zet";  break;
    
    //  case 5:  type = "mapadce";  break;
    //   case 6:  type = "mapadcp";  break;
    //   case 7:  type = "maptdce";  break;
    //   case 8:  type = "maptdcp";  break;
  case 5:  type = "aepat";  break;
  case 6:  type = "appat";  break;
  case 7:  type = "tepat";  break;
  case 8:  type = "tppat";  break;
  case 9:  type = "mapadctdc";  break;  // 2D
  case 10: type = "adc_tdc";  break;  // 2D
    
  case 11: type = "tdc";  break;  // 2D
  case 12: type = "tdce";  break;
  case 13: type = "tdcp";  break;
  case 14: type = "tmean";  break;
  case 15: type = "tdf";  break;
    
  case 16: type = "mul";  break;
  default: break;
  }

  TString etichetta = TString("");
  //  if((fwir == 0 && (opt<6 || opt>9)) || opt==9) etichetta+="lmd_all_";
  //   if((fwir == 0 && (opt != 9)) || opt==9) etichetta+="lmd_all_";
  //   else etichetta+="lmd";
  //  etichetta+="lmd_all_";
  if(fwir == 0) etichetta+="lmd_all_";
  else etichetta+="lmd";
  etichetta+=type.Data();

  //  if(opt < 6 || opt > 8) {
  etichetta+="_"; 
  etichetta+=fIO+1; 
  etichetta+="_"; 
  etichetta+=fdch;
  //  }
  
  if(fwir != 0) {
    etichetta+="_"; 
    etichetta+=fwir;
  }
  // --- histogram name builld:
  //  now must get from the correct "shared-memory/file"
  
  // handle options from 0 to 8
  if(opt<9) {
    if(opt==0){
      if(!fRF){
        if(fIO==0) h2 =(TH2F*) iadc->Get(etichetta.Data());
        else h2 =(TH2F*) oadc->Get(etichetta.Data());
      } 
      else h2 =(TH2F*) fRF->Get(etichetta.Data());
    } 
    else if(opt==7 || opt ==8){
      if(!fRF){
        if(fIO==0) fhists  =(TH1F*) itdc->Get(etichetta.Data());
        else fhists  =(TH1F*) otdc->Get(etichetta.Data());
      } 
      else fhists  =(TH1F*) fRF->Get(etichetta.Data());
    }
    else {
      if(!fRF) {
        if(fIO==0) fhists =(TH1F*) iadc->Get(etichetta.Data());
        else fhists =(TH1F*) oadc->Get(etichetta.Data());
      } 
      else fhists =(TH1F*) fRF->Get(etichetta.Data());
    }
  }
  // now options 9,10
  else if (opt==9 || opt ==10) {
    if(!fRF) 
      h2 =(TH2F*) maps->Get(etichetta.Data());
    else
      h2 =(TH2F*) fRF->Get(etichetta.Data());
    //    if(opt>=6 && opt<=8) {
    Int_t drch = fdch;
    if(fIO == 1) drch += 10;
    if(h2) sly = h2->ProjectionY("_py",drch,drch);
    if(sly) sly->SetLineColor(2*(2-opt%2));
    //    }
  } 
  // now options 11,12,13,14,15,16
  else {
    if(opt==11) {
      if(!fRF) {
        if(fIO==0) h2 =(TH2F*) itdc->Get(etichetta.Data());
        else h2 =(TH2F*) otdc->Get(etichetta.Data());
      } 
      else h2 =(TH2F*) fRF->Get(etichetta.Data());
    } 
    else if(opt==16) {
      if(!fRF) {
        fhists =(TH1F*) maps->Get(etichetta.Data());
      } 
      else fhists =(TH1F*) fRF->Get(etichetta.Data());
    } 
    else {
      if(!fRF) {
        if(fIO==0) fhists =(TH1F*) itdc->Get(etichetta.Data());
        else fhists =(TH1F*) otdc->Get(etichetta.Data());
      } 
      else fhists =(TH1F*) fRF->Get(etichetta.Data());
    }
  }

  // --- here handle superimposing
  if(flg) {
    if(fhists) fhists->Draw("SAME");
    if(sly) { sly->Draw("SAME"); }
  }
  else {
    if(fhists) fhists->Draw(DrawOpt);
    if(sly) sly->Draw(DrawOpt);
  }

  //  Info("TFndLmdMonFrame::DrawHist"," ************************* finishing: %x",h2);
  if(h2) h2->Draw(DrawOpt);
}
  
//____________________________________________________
void TFndLmdMonFrame::DisplayMaps(){
  // Control histograms are shown

  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }

  Char_t *Draw2D_opt = "box";
  //  Char_t *Draw2D_opt = "colz";
  RebuildWirePad();
  fDisplayPad[0]->Clear();
  Int_t EachPadCol = 18;
  Float_t Margin = 0.002;
  Int_t npads = 8;
  //  cout << " -> displaying map histograms" << endl;
  fDisplayPad[0]->Divide(4,2,Margin,Margin,EachPadCol);

  fwir = 0;
  for(Int_t j=0;j<npads;j++) {
    TString hnamestr = TString("lmd");
    if(j==0)         hnamestr+="_i_o_mult";
    if(j!=0)         hnamestr+="map";
    if(j>0 && j<4)   hnamestr+="adc";
    if(j>4)          hnamestr+="tdc";
    if(j==2 || j==6) hnamestr+="e";
    if(j==3 || j==7) hnamestr+="p";

    fDisplayPad[0]->cd(j+1);
    //    Printf("Drawing \"%s\" in pad",hnamestr.Data(),j+1);

    if(!fRF) 
      h2 = (TH2F *) maps->Get(hnamestr.Data());
    else
      h2 = (TH2F *) fRF->Get(hnamestr.Data());
    if(h2){
      h2->Draw(Draw2D_opt);
      //TFndMonFrame::GetPadStats()->SetOptStat(11);
    }
  }    
  fDisplayPad[0]->Modified();
  ResetFrameColors();
  HighlightButtons(1,0);
}

//____________________________________________________
void TFndLmdMonFrame::DisplayHist(){
  // Called when a wire-button is clicked
  // If the button is "ALL" overall histgrams of all wires
  // of the current chamber will be displayed

  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }

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

  fDisplayPad[0]->Clear();
  Int_t npads = 0;
  if(fwir == 0){
    //    cout << " -> displaying histograms for chamber " << fdch << " --- layer " << fIO << " (overall of all wires)" << endl;
    fDisplayPad[0]->Divide(4,3,Margin,Margin,EachPadCol);
    npads = 12;
  }
  else{
    //    cout << " -> displaying histograms for chamber " << fdch << " --- layer " << fIO << " --- wires " << fwir << endl;
    fDisplayPad[0]->Divide(4,2,Margin,Margin,EachPadCol);
    npads = 8;
  }
  
  Int_t opt = 0;
  if(fwir == 0){
    for(Int_t i=0;i<npads;i++){
      //      Info("TFndLmdMonFrame::DisplayHist"," ************************* Drawing DEBUG");
      fDisplayPad[0]->cd(i+1);
      if(i==0 || i==3) Draw2D_opt = "box";
      //      if(i==0) Draw2D_opt = "box";
      //else if(i>=4 && i<=8) Draw2D_opt = "box"; 
      else Draw2D_opt = "";
      //      Draw2D_opt = ""; // debug line!!!
      // cout <<"pad: " << i+1 << " --- draw-opt: \"" << Draw2D_opt << "\"" << endl;
      DrawHist(opt,0,Draw2D_opt);
      if(i==1 || i==9) DrawHist(++opt,1,Draw2D_opt);
      //if(i==1) DrawHist(++opt,1);
      opt++;
    }
  }
  else{
    opt = 1;
    for(Int_t i=0;i<npads;i++){
      if(i==4) opt = 12;
      fDisplayPad[0]->cd(i+1);
      DrawHist(opt,0);
      opt++;
    }
  }
  fDisplayPad[0]->Modified();
  ResetFrameColors();
  HighlightButtons(0,0);
}

//____________________________________________________
void TFndLmdMonFrame::DisplayAllHist(Int_t io, Int_t option){
  // called by "all-buttons" (bottom-pad)
 
  if(!ReloadMapFiles()){
    fDisplayPad[0]->Clear();
    fDisplayPad[0]->Modified();
    return;
  }

  RebuildWirePad();
  fDisplayPad[0]->Clear();
  Int_t EachPadCol = 18;
  Float_t Margin = 0.002;
  Int_t npads = 8;
  fIO = io;
  //  cout << " -> displaying control histograms for layer " << fIO+1 << endl;
  fDisplayPad[0]->Divide(4,2,Margin,Margin,EachPadCol);

  fwir = 0;
  for(Int_t i=0;i<npads;i++){
    fDisplayPad[0]->cd(i+1);
    fdch = i+1;

    switch(option){
    case 0: DrawHist(9,0,"colz"); break;
    case 1: DrawHist(3,0); break;
    case 2: DrawHist(14,0); break;
    case 3: DrawHist(10,0); break;
    case 4: DrawHist(16,0); break;
      //    case 4: DrawHist(16,0); DrawHist(17,1); break;
    default: break;
    }
  }
  fDisplayPad[0]->Modified();
  ResetFrameColors();

  Int_t all_id = 1+fIO+2*option;
  HighlightButtons(1,all_id);
}

//____________________________________________________
// void TFndLmdMonFrame::KillProd(){
//    gSystem->Exec("rm mons_lmd.dat");
//    gSystem->Exec("ps | grep geb2hdt | awk '{print $1}' > mons_lmd.dat");
//    FILE *gs = fopen("mons_lmd.dat","r");
//    Int_t gpid;
//    if (gs) while ( fscanf(gs,"%d",&gpid) == 1) {
//       char cmd[60];
//       printf("Killing geb2hdt with Pid=%d\n",gpid);
//       sprintf(cmd,"kill -9 %d\n",gpid);
//       system(cmd);
//    }
// }

//____________________________________________________
// void TFndLmdMonFrame::Exec(Int_t option){
  
//   switch(option){
//   case 1:
//     gSystem->Exec("geb2hdt $MSQLHOST $FND_DATA lmd>&lmd.dat&");
//     break;
//   case 2:
//     KillProd();
//     break;
//   case 3:
//     break;
//   case 4:
//     gSystem->Exec("tail lmd.dat");
//     break;
//   case 5:
//     break;
//   }

// }

//_____________________________________
// Bool_t TFndLmdMonFrame::CheckEntries() 
// { 
//   Bool_t kReload = kFALSE;
//   TH2F *i_o_mult = (TH2F *) maps->Get("lmd_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 LMD Shared memories" << endl;
//      kReload = kTRUE;
//   }
//   return kReload;
// }

//_____________________________________
// void TFndLmdMonFrame::CheckHistos() 
// { 
//   Bool_t kReload = CheckEntries();
//   if(kReload) ReloadMapFiles();
//   CheckIOMult();
//   CheckMaps();
//   CheckAdcTdcMaps();
  
//   CheckAdcs();
//   CheckTdcs();
  
// }


//_____________________________________
// void TFndLmdMonFrame::CheckIOMult() 
// { 
//   /*
//   Bool_t isCosmic = fndrun->Hdt()->Trig()->Cosmic();
//   if(isCosmic) cout << "Cosmic ray trigger on" << endl;
//   */
//   TString s2("lmd_i_o_mult");
//   cout << "check lmd_i_o_mult" << endl;
//   TH2F *i_o_mult = (TH2F *) maps->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;
//      fCheckedHistos->Remove(a);
//      fCheckedHistos->Compress();
//       }
//       break;
//     }   
//   }
//   if(doCheck && isThere == kFALSE) {
//     cout << "Add " << s2.Data() << " to objarray" << endl;
//     a = new TFndMonCheckFrame(maps,s2,2,gClient->GetRoot());
//     fCheckedHistos->Add(a);
//   }
//   delete i_o_mult;
// }

//_____________________________________
// void TFndLmdMonFrame::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;
//   Bool_t lmdAdcTdcMap[16]; 
//   Bool_t isMapThere[16];
//   for(Int_t idet=0;idet<2;idet++) {
//     char layer[3];
//     sprintf(layer,"%d",idet+1);
//     for(Int_t itsl=0; itsl<8; itsl++) {
//       Int_t index = idet*8+itsl+1;
//       TString hname("lmd_all_mapadctdc_");
//       char dch[3];
//       sprintf(dch,"%d",itsl+1);
//       hname.Append(layer);
//       hname.Append("_");
//       hname.Append(dch);
//       TH2F *mapAT = (TH2F *) maps->Get(hname.Data());
//       lmdAdcTdcMap[index] = 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(content[idx] > maxi) {
//                      maxi_x = nbx;
//                      maxi_y = nby;
//                      maxi = content[idx];
//                } 
//              }
//       }
//       if(maxi_x*maxi_y != 9) {
//              cout << "layer " << idet+1 << ", chamber: " << itsl+1 << ", maximum in wrong place: " << maxi_x << "," << maxi_y << endl;
//              lmdAdcTdcMap[index] = 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) {
//                      lmdAdcTdcMap[itsl] = kTRUE;
//                      cout << "layer " << idet+1 << ", chamber: " << itsl+1 << ", maximum in wrong place, idx: " << idx << "," << maxi_x << "," << maxi_y << endl;
//                } 
//              }      
//       }
      
//       TFndMonCheckFrame *a =0;
//       isMapThere[index] = 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[index] = kTRUE;
//                a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//                if(!lmdAdcTdcMap[index]) {
//                      cout << "Remove: " << curName.Data() << endl;
//                      fCheckedHistos->Remove(a);
//                      fCheckedHistos->Compress();
//                }
//                break;
//              }
//       }   
//       if(lmdAdcTdcMap[index] && isMapThere[index] == kFALSE) {
//              cout << "Add " << hname.Data() << " to objarray" << endl;
//              a = new TFndMonCheckFrame(maps,hname,2,gClient->GetRoot());
//              fCheckedHistos->Add(a);
//       }
//       delete mapAT;
//     }
//   }
//   /*
//   for(Int_t idet=0;idet<2;idet++) {
//     for(Int_t itsl=0; itsl<8; itsl++) {
//       Int_t index = idet*8+itsl+1;
//       if(lmdAdcTdcMap[index]) {
//      CheckAdcs(idet+1,itsl+1);
//      CheckTdcs(idet+1,itsl+1);
//       }
//     }
//   }
//   */

// }

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

//   cout << "check hit maps" << endl;
//   Float_t ScalingFactor = 0.1;
//   Bool_t lmdAdcMap[4]; 
//   Bool_t lmdTdcMap[4]; 
//   Bool_t isAdcMapThere[4];
//   Bool_t isTdcMapThere[4];
//   TH2F *mapADC[4];
//   TH2F *mapTDC[4];
//   Int_t nx = 20;
//   Int_t ny = 24;
//   Int_t contentADC[4][nx][ny];
//   Int_t contentTDC[4][nx][ny];
//   for(Int_t idet=0;idet<4;idet++) {
//     char suff[3];
//     if(idet==1) sprintf(suff,"%s","0");
//     if(idet==2) sprintf(suff,"%s","e");
//     if(idet==3) sprintf(suff,"%s","p");
//      TString hnamea("lmdmapadc");
//      if(idet > 0) hnamea.Append(suff);
//      TString hnamet("lmdmaptdc");
//      if(idet > 0) hnamet.Append(suff);
// //   cout << "analyse histograms " << hnamea.Data() << ", " << hnamet.Data() << endl; 
//      mapADC[idet] = (TH2F *) maps->Get(hnamea.Data());
//      mapTDC[idet] = (TH2F *) maps->Get(hnamet.Data());
// //   cout << "got histograms " << hnamea.Data() << ", " << hnamet.Data() << endl; 
//      lmdAdcMap[idet] = kFALSE;
//      lmdTdcMap[idet] = kFALSE;
//      Int_t nx = mapADC[idet]->GetNbinsX();
//      Int_t ny = mapADC[idet]->GetNbinsY();
// //   cout << "fill content for histograms " << hnamea.Data() << ", " << hnamet.Data() << endl; 
//      for(Int_t nbx=0; nbx<nx; nbx++) {
//              for(Int_t nby=0; nby<ny; nby++) {
//                      contentADC[idet][nbx][nby] = (Int_t) mapADC[idet]->GetBinContent(nbx+1,nby+1);
//                      contentTDC[idet][nbx][nby] = (Int_t) mapTDC[idet]->GetBinContent(nbx+1,nby+1);
//              }
//      }
//   }

// // check warning conditions

// //   cout << "warning conditions" << endl; 
//   for(Int_t nbx=0; nbx<18; nbx++) {
//      if(nbx == 8 || nbx == 9) continue;
//      for(Int_t nby=0; nby<22; nby++) {
//        if(nbx < 10 && nby > 11) continue;
//        for(Int_t idet=0;idet<4;idet++) {
//              if((Float_t) TMath::Abs(contentADC[idet][nbx][nby] - contentTDC[idet][nbx][nby]) > ScalingFactor*TMath::Max(contentTDC[idet][nbx][nby],contentADC[idet][nbx][nby])) {
//                lmdAdcMap[idet] = kTRUE;
//                if(idet == 0) cout << "e||p != 0 Maps, ";
//                if(idet == 1) cout << "e&&p != 0 Maps, ";
//                if(idet == 2) cout << "e-side Maps, ";
//                if(idet == 3) cout << "p-side Maps, ";
//                cout << "Warning: ADC counts differ from TDC for more than " << (Int_t) 1./ScalingFactor << "%, Chamber: " << nbx+1 << ", Wire: " << nby+1 << endl;
//          }
//        }
//        if((Float_t) TMath::Abs(contentADC[2][nbx][nby] - contentADC[3][nbx][nby]) > ScalingFactor*TMath::Max(contentADC[2][nbx][nby],contentADC[3][nbx][nby])) {
//              lmdAdcMap[2] = kTRUE;
//              lmdAdcMap[3] = kTRUE;
//              cout << "Warning: ADC counts (e-side - p-side) for more than " << (Int_t) 1./ScalingFactor << "%, Chamber: " << nbx+1 << ", Wire: " << nby+1 << endl;
//        }
//        if((Float_t) TMath::Abs(contentTDC[2][nbx][nby] - contentTDC[3][nbx][nby]) > ScalingFactor*TMath::Max(contentTDC[2][nbx][nby],contentTDC[3][nbx][nby])) {
//              lmdTdcMap[2] = kTRUE;
//              lmdTdcMap[3] = kTRUE;
//              cout << "Warning: TDC counts (e-side - p-side) for more than " << (Int_t) 1./ScalingFactor << "%, Chamber: " << nbx+1 << ", Wire: " << nby+1 << endl;
//        }
//      }      
//   }

// // update ObjArray

//   for(Int_t idet=0;idet<4;idet++) {
//     char suff[3];
//     if(idet==1) sprintf(suff,"%s","0");
//     if(idet==2) sprintf(suff,"%s","e");
//     if(idet==3) sprintf(suff,"%s","p");
//      TString hnamea("lmdmapadc");
//      hnamea.Append(suff);
//      TString hnamet("lmdmaptdc");
//      hnamet.Append(suff);

// //   cout << "update histograms " << hnamea.Data() << ", " << hnamet.Data() << endl; 
//      TFndMonCheckFrame *a =0;
//      isAdcMapThere[idet] = kFALSE;
//      Int_t nH = fCheckedHistos->GetEntriesFast();
//      for(Int_t i=0; i<nH; i++) {
//        TString curName = ((TFndMonCheckFrame *) fCheckedHistos->At(i))->GetHName();
//        if(!curName.CompareTo(hnamea)) {
//                isAdcMapThere[idet] = kTRUE;
//                a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//                if(!lmdAdcMap[idet]) {
//                      cout << "Remove: " << curName.Data() << endl;
//                      fCheckedHistos->Remove(a);
//                      fCheckedHistos->Compress();
//                }
//                break;
//        }
//        if(!curName.CompareTo(hnamet)) {
//                isTdcMapThere[idet] = kTRUE;
//                a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//                if(!lmdTdcMap[idet]) {
//                      cout << "Remove: " << curName.Data() << endl;
//                      fCheckedHistos->Remove(a);
//                      fCheckedHistos->Compress();
//                }
//                break;
//        }
//      }   
//      if(lmdAdcMap[idet] && isAdcMapThere[idet] == kFALSE) {
//              cout << "Add " << hnamea.Data() << " to objarray" << endl;
//              a = new TFndMonCheckFrame(maps,hnamea,2,gClient->GetRoot());
//              fCheckedHistos->Add(a);
//      }
//      delete mapADC[idet];
//      if(lmdTdcMap[idet] && isTdcMapThere[idet] == kFALSE) {
//              cout << "Add " << hnamet.Data() << " to objarray" << endl;
//              a = new TFndMonCheckFrame(maps,hnamet,2,gClient->GetRoot());
//              fCheckedHistos->Add(a);
//      }
//      delete mapTDC[idet];
//   }
// }

//_____________________________________
// void TFndLmdMonFrame::CheckAdcs() 
// { 
//   for(Int_t idet=0;idet<2;idet++)
//     for(Int_t itsl=0; itsl<8; itsl++)
//       CheckAdcs(idet+1,itsl+1); 
// }

//_____________________________________
// void TFndLmdMonFrame::CheckAdcs(Int_t layer, Int_t chamber) 
// { 
//   /*
//   Bool_t isCosmic = fndrun->Hdt()->Trig()->Cosmic();
//   if(isCosmic) cout << "Cosmic ray trigger on" << endl;
//   */

//   cout << "check Adcs for layer: " << layer << ", chamber: " << chamber << endl;
//   char clayer[3];
//   sprintf(clayer,"%d",layer);
//   char dch[3];
//   sprintf(dch,"%d",chamber);
//   Int_t nwires = 12;
//   if(layer == 2) nwires = 22;
//   Bool_t lmdAdcs[2*nwires]; 
//   Bool_t isAdcThere[2*nwires];
//   for(Int_t iw=0;iw<nwires;iw++) {
//     char wire[3];
//     sprintf(wire,"%d",iw+1);
    
//     for(Int_t is=0;is<2;is++) {
//       Int_t idx = nwires*is + iw;
//       TString hname("lmdadc");
//       if(is == 0) hname.Append("e_");
//       else hname.Append("p_");
//       hname.Append(clayer);
//       hname.Append("_");
//       hname.Append(dch);
//       hname.Append("_");
//       hname.Append(wire);
      
//       TH1F *mapAT = 0;
//       if(layer == 1)
//              mapAT = (TH1F *) iadc->Get(hname.Data());
//       else if(layer == 2)
//              mapAT = (TH1F *) oadc->Get(hname.Data());
      
//       lmdAdcs[idx] = kFALSE;
//       Int_t nx = mapAT->GetNbinsX();
      
//       Float_t lowEdge[nx];
//       Int_t content[nx];
//       Int_t nEntries = (Int_t) mapAT->GetEntries();
//       Float_t maxi = 0;
//       Int_t maxi_x = -1;
//       for(Int_t nbx=0; nbx<nx; nbx++) {
//              lowEdge[nbx] = (Float_t) mapAT->GetBinLowEdge(nbx+1);
//         content[nbx] = (Int_t) mapAT->GetBinContent(nbx+1);
//         if(content[nbx] > maxi) {
//           maxi_x = (Int_t) lowEdge[nbx];
//           maxi = content[nbx];
//         } 
//       }
//       if(nEntries > 100 && maxi_x <= 100 && maxi_x > 0) {
//              if(is == 0) cout << "layer " << layer << ", chamber: " << chamber << ", wire: " << iw+1 << ", side e: maximum in wrong place: " << maxi_x << endl;
//              else cout << "layer " << layer << ", chamber: " << chamber << ", wire: " << iw+1 << ", side p: maximum in wrong place: " << maxi_x << endl;
//              lmdAdcs[idx] = kTRUE;
//       }
        
//       TFndMonCheckFrame *a =0;
//       isAdcThere[idx] = 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)) {
//                isAdcThere[idx] = kTRUE;
//                a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//                if(!lmdAdcs[idx]) {
//                      cout << "Remove: " << curName.Data() << endl;
//                      fCheckedHistos->Remove(a);
//                      fCheckedHistos->Compress();
//                }
//              break;
//              }
//       }   
//       if(lmdAdcs[idx] && isAdcThere[idx] == kFALSE) {
//              cout << "Add " << hname.Data() << " to objarray" << endl;
//              if(layer == 1)
//                a = new TFndMonCheckFrame(iadc,hname,1,gClient->GetRoot());
//              else if(layer == 2)
//                a = new TFndMonCheckFrame(oadc,hname,1,gClient->GetRoot());
//              fCheckedHistos->Add(a);
//       }   
//       delete mapAT;
//     }
//   } 
// }

//_____________________________________
// void TFndLmdMonFrame::CheckTdcs() 
// { 
//   for(Int_t idet=0;idet<2;idet++)
//     for(Int_t itsl=0; itsl<8; itsl++)
//       CheckTdcs(idet+1,itsl+1); 
// }

//_____________________________________
// void TFndLmdMonFrame::CheckTdcs(Int_t layer, Int_t chamber) 
// { 
//   /*
//     Bool_t isCosmic = fndrun->Hdt()->Trig()->Cosmic();
//     if(isCosmic) cout << "Cosmic ray trigger on" << endl;
//   */
  
//   cout << "check Tdcs for layer: " << layer << ", chamber: " << chamber << endl;
//   char clayer[3];
//   sprintf(clayer,"%d",layer);
//   char dch[3];
//   sprintf(dch,"%d",chamber);
//   Int_t nwires = 12;
//   if(layer == 2) nwires = 22;
//   Bool_t lmdTdcs[nwires]; 
//   Bool_t isTdcThere[nwires];
//   Float_t maxi[nwires];
//   Int_t maxi_x[nwires];
//   Int_t maxi_b[nwires];
//   Int_t t_maxi[nwires];
//   Float_t t_cell[nwires];
//   Float_t t_start[nwires];
//   Float_t t_stop[nwires];

//   Float_t ScalingFactor = 0.1;
//   for(Int_t iw=0;iw<nwires;iw++) {
  
//     char wire[3];
//     sprintf(wire,"%d",iw+1);
//      TString hname("lmdtmean_");
//      hname.Append(clayer);
//      hname.Append("_");
//      hname.Append(dch);
//      hname.Append("_");
//      hname.Append(wire);
        
//      Int_t nx;
//      Float_t lowEdge[nx];
//      Int_t content[nx];
// //   cout << "get histogram " << hname.Data() << endl;
//      TH1F *mapAT = 0;
//      if(layer == 1)
//        mapAT = (TH1F *) itdc->Get(hname.Data());
//      else if(layer == 2)
//        mapAT = (TH1F *) otdc->Get(hname.Data());
      
//      lmdTdcs[iw] = kFALSE;
//      nx = mapAT->GetNbinsX();            
//      Int_t nEntries = (Int_t) mapAT->GetEntries();
// //   cout << "analyse histogram " << hname.Data() << ", " << nx << " bins, " << nEntries << " entries " << endl;       

//      maxi_b[iw] = 0;
//      for(Int_t nbx=0; nbx<nx; nbx++) {
//        lowEdge[nbx] = (Float_t) mapAT->GetBinLowEdge(nbx+1);
//        content[nbx] += (Int_t) mapAT->GetBinContent(nbx+1);
//        if(content[nbx] > maxi[iw]) {
//              maxi_b[iw] = nbx;
//              maxi_x[iw] = (Int_t) lowEdge[nbx];
//              maxi[iw] = content[nbx];
//        } 
//      }
// //   cout << "analyse histogram " << hname.Data() << ", tstart " << maxi_b[iw] << endl;        
//      for(Int_t nbx=0; nbx<nx; nbx++) {
//        if(content[nbx] > (Int_t) ScalingFactor*content[maxi_b[iw]]) {
//              t_start[iw] = lowEdge[nbx];
//              break;
//        }
//      }
// //   cout << "analyse histogram " << hname.Data() << ", tstop " << endl;       
//      for(Int_t nbx=nx; nbx>0; nbx--) {
//        if(content[nbx] > (Int_t) ScalingFactor*content[maxi_b[iw]]) {
//              t_stop[iw] = lowEdge[nbx];
//              break;
//        }
//      }

// //   cout << "analyse histogram " << hname.Data() << ", tmaxi position" << endl;       
//     t_cell[iw] = 1500;
//      t_maxi[iw] = 3200;
//      Int_t twidth = (Int_t)(t_stop[iw] - t_start[iw]);
//      if(twidth > t_cell[iw]) {
//        cout << "layer " << layer << ", chamber: " << chamber << ", wire: " << iw+1 << ", time distribution is wrong, interval is: " << twidth << endl;
//        lmdTdcs[iw] = kTRUE;          
//      }

//      if(t_stop[iw] < maxi_x[iw]) {
//        cout << "layer " << layer << ", chamber: " << chamber << ", wire: " << iw+1 << ", maximum and stopping time swapped" << endl;
//        lmdTdcs[iw] = kTRUE;          
//      }
//      if(t_start[iw] > maxi_x[iw]) {
//        cout << "layer " << layer << ", chamber: " << chamber << ", wire: " << iw+1 << ", maximum and starting time swapped" << endl;
//        lmdTdcs[iw] = kTRUE;          
//      }

//      if(TMath::Abs(maxi_x[iw] - t_maxi[iw]) > 100 && maxi_x[iw] > 0) {
//        cout << "layer " << layer << ", chamber: " << chamber << ", wire: " << iw+1 << ", TDC maximum in wrong place: " << maxi_x[iw] << endl;
//        lmdTdcs[iw] = kTRUE;
//      }
        
//      TFndMonCheckFrame *a =0;
//      isTdcThere[iw] = kFALSE;
//      Int_t nH = fCheckedHistos->GetEntriesFast();
//      if(nH > 1000) cout << "Fatal Error: too many entries in TObjArray" << endl;
//      for(Int_t i=0; i<nH; i++) {
//        TString curName = ((TFndMonCheckFrame *) fCheckedHistos->At(i))->GetHName();
//        if(!curName.CompareTo(hname)) {
//              isTdcThere[iw] = kTRUE;
//              a = ((TFndMonCheckFrame *) fCheckedHistos->At(i));
//              if(!lmdTdcs[iw]) {
//                cout << "Remove: " << curName.Data() << endl;
//                fCheckedHistos->Remove(a);
//                fCheckedHistos->Compress();
//              }
//              break;
//        }
//      }   
//      if(lmdTdcs[iw] && isTdcThere[iw] == kFALSE) {
//        cout << "Add " << hname.Data() << " to objarray" << endl;
//        if(layer == 1)
//              a = new TFndMonCheckFrame(itdc,hname,1,gClient->GetRoot());
//        else if(layer == 2)
//              a = new TFndMonCheckFrame(otdc,hname,1,gClient->GetRoot());
//        fCheckedHistos->Add(a);
//      }
//      delete mapAT;
//   }
// }

//_____________________________________
// void TFndLmdMonFrame::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();
//     }
//   }
// }

---