/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/root/gui/EventDisplay.cpp

Go to the documentation of this file.

#include <gui/EventDisplay.hh> 
#include <string>


#include "root/CaloRun.hh"
#include "root/CaloEvent.hh"
#include "root/CaloHit.hh"
#include "root/MTEvent.hh"
#include "root/MTChannel.hh"
#include "xml/XMLTool.hh"
#include "tools/Toolbox.hh"
#include "Chamber.hh"
#include "DiracChamber1.hh"
#include "GassiplexChamber1.hh"
#include "GassiplexChamber4.hh"
#include "Hardroc1Chamber.hh"
#include "MicroException.hh"
#include "Log.hh"
#include "Toolbox.hh"


#include <TGResourcePool.h>
#include <TView.h>
#include "TExec.h"
#include <TGSlider.h>
#include <TG3DLine.h>
#include <TGToolBar.h>




#include "TGSplitter.h"
#include "TGFileDialog.h"
#include <TGClient.h>
#include <TRootCanvas.h>
#include <TGMenu.h>
#include <TGStatusBar.h>
#include <TGButton.h>
#include <TColor.h>
#include <TGLabel.h>
#include <TGNumberEntry.h>

#include <TROOT.h>
#include <TRint.h>
#include <TKey.h>
#include <TCanvas.h>
#include <TTree.h>
#include <TFile.h>
#include <TSystem.h>
#include <TGeoManager.h>
#include <TGeoMatrix.h>
 #include <RQ_OBJECT.h>
#include <iostream>
#include <sstream>

#include <string>


#include <TRootEmbeddedCanvas.h>
#include <TGListBox.h>
#include <TList.h>

#include "TRootHelpDialog.h"


#define CALOEVENT 1
#define MTEVENT 2


using namespace std;


ClassImp(EventDisplay)

std::vector<EventDisplay*> EventDisplay::frames;


const char *xpm_names[] = {
   "open.png",
   "openxml.png",
   "",
   "previous.png",
   "next.png",
   "",
   "zoom.png",
   "unzoom.png",
   "",
   "colorhits.png",
   "onlymicromegas.png",
   "showchamber.png",
   "",
   "exit.png",
   0
};


enum RootShowerMessageTypes {
   M_FILE_EVENT_OPEN,
   M_FILE_XML_OPEN,
   M_EVENT_PREV,
   M_EVENT_NEXT,
   M_EVENT_SELECT,
   M_ZOOM_PLUS,
   M_ZOOM_MOINS,
   M_SHOW_CHAMBER,
   M_COLOR_MICROMEGAS_HIT,
   M_ONLY_MICROMEGAS,
   M_FILE_EXIT,
};


ToolBarData_t tb_data[] = {
   { "", "Open Root event file",     kFALSE, M_FILE_EVENT_OPEN,  NULL },
   { "", "Open XML Steer file",      kFALSE, M_FILE_XML_OPEN,    NULL },
   { "",              0,             0,      -1,                 NULL },
   { "", "Previous event",           kFALSE, M_EVENT_PREV,       NULL },
   { "", "Next event",               kFALSE, M_EVENT_NEXT,       NULL },
   { "",              0,             0,      -1,                 NULL },
   { "", "Zoom",                     kFALSE, M_ZOOM_PLUS,        NULL },
   { "", "Unzoom",                   kFALSE, M_ZOOM_MOINS,       NULL },
   { "",  0            ,             0,      -1,                 NULL },
   { "", "Use different color for micromegas hits",kFALSE, M_COLOR_MICROMEGAS_HIT,  NULL },
   { "", "Show only micromegas hits",kFALSE, M_ONLY_MICROMEGAS,  NULL },
   { "", "Show chambers",            kFALSE, M_SHOW_CHAMBER,     NULL },
   { "",  0            ,             0,      -1,                 NULL },
   { "", "Exit Application",         kFALSE, M_FILE_EXIT,        NULL },
   { NULL,NULL            ,          0,      0,                  NULL }
};

const char *dnd_types[] = {
   "ROOT files",    "*.root",
    0,               0
};

const char *filetypes[] = { "All files",     "*",
                            "ROOT files",    "*.root",
                            0,               0 };



EventDisplay::EventDisplay(std::string &rootfileName, std::string &xmlfileName, const TGWindow *p, UInt_t w, UInt_t h)
   : TGMainFrame(p, w, h,kMainFrame | kVerticalFrame), eventNum(-1), steername(xmlfileName) , c1(NULL), detector(NULL),  eventType(UNDEFINED)
     , hitMicromegas(false), onlyMicromegas(false),drawChamber(false), world(NULL), dtHist(NULL) ,dtCan(NULL), deltaTMax(NULL), deltaTMin(NULL)
{
  file = new TFile(rootfileName.c_str(),"READONLY");
  this->Init(w,h);
  fillTreeInfo(*file);
  fStatusBar->SetText(rootfileName.c_str(),1);
  buildDetector();
  frames.push_back(this);
}

EventDisplay::EventDisplay(std::string &rootfileName, const TGWindow *p, UInt_t w, UInt_t h)
   : TGMainFrame(p, w, h,kMainFrame | kVerticalFrame), eventNum(-1), c1(NULL), eventType(UNDEFINED), detector(NULL),   steername("")
    , hitMicromegas(false) , onlyMicromegas(false),drawChamber(false), world(NULL), dtHist(NULL) ,dtCan(NULL), deltaTMax(NULL), deltaTMin(NULL)
{
  file = new TFile(rootfileName.c_str(),"READONLY");
  this->Init(w,h);
  fillTreeInfo(*file);
  fStatusBar->SetText(rootfileName.c_str(),1);
  frames.push_back(this);
}


EventDisplay::EventDisplay(const TGWindow *p, UInt_t w, UInt_t h)
    : TGMainFrame(p, w, h,kMainFrame | kVerticalFrame), eventNum(-1) , file(NULL), steername("") , c1(NULL) , detector(NULL)  
     , hitMicromegas(false), onlyMicromegas(false),drawChamber(false), world(NULL), dtHist(NULL) ,dtCan(NULL), deltaTMax(NULL), deltaTMin(NULL)
{
  this->Init(w,h);
  frames.push_back(this);
}
    
void EventDisplay::Init(UInt_t width,UInt_t height)
{
  gSystem->Load("libGeom");

  // construct Menu Bar
  fMenuBar = new TGMenuBar(this, 35, 10, kHorizontalFrame);
  fMenuFile = new TGPopupMenu(gClient->GetRoot());

  fMenuFile->AddEntry(" &Open Event file...", M_FILE_EVENT_OPEN, 0, gClient->GetPicture("bld_open.png"));
  fMenuFile->AddEntry(" &Open XML steer file...", M_FILE_XML_OPEN,0,gClient->GetPicture("bld_open.png"));
  fMenuFile->AddEntry(" &Exit ...", M_FILE_EXIT);

  fMenuFile->Connect("Activated(Int_t)", "EventDisplay", this,
                      "HandleMenu(int)");

  fMenuBar->AddPopup("&File", fMenuFile, new TGLayoutHints(kLHintsTop|kLHintsLeft, 0, 4, 0, 0));

  this->AddFrame(fMenuBar, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 2, 5));

   // Create menubar and popup menus.

 // layout hint items
   TGLayoutHints *fMenuBarLayout = new TGLayoutHints(kLHintsTop| kLHintsLeft | kLHintsExpandX,
                                      0, 0, 0, 0);
   TGLayoutHints *fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0);
   TGLayoutHints *fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight);

   TGMenuBar *fMenuBar = new TGMenuBar(this, 1, 1, kHorizontalFrame | kRaisedFrame);

   //---- toolbar
   int spacing = 12;
   fToolBar = new TGToolBar(this, 60, 20, kHorizontalFrame | kRaisedFrame);
   for (int i = 0; xpm_names[i]; i++) {
      TString iconname(gProgPath);
      iconname += "/icons/";
      iconname += xpm_names[i];
      tb_data[i].fPixmap = iconname.Data();
      if (strlen(xpm_names[i]) == 0) {
         fToolBar->AddFrame(new TGVertical3DLine(fToolBar), new TGLayoutHints(kLHintsExpandY, 4, 4));
         continue;
      }
      const TGPicture *pic = fClient->GetPicture(tb_data[i].fPixmap);
      TGPictureButton *pb = new TGPictureButton(fToolBar, pic, tb_data[i].fId);
      pb->SetToolTipText(tb_data[i].fTipText);
      tb_data[i].fButton = pb;

      fToolBar->AddButton(this, pb, spacing);
   //   spacing = 0;
   }
   AddFrame(fToolBar, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 0, 0, 0, 0));
   fToolBar->GetButton(M_ONLY_MICROMEGAS)->SetState(kButtonDisabled);
   fToolBar->GetButton(M_SHOW_CHAMBER)->SetState(kButtonDisabled);
   fToolBar->GetButton(M_COLOR_MICROMEGAS_HIT)->SetState(kButtonDisabled);


// main frame Management
  this->SetMWMHints(kMWMDecorAll,
                kMWMFuncAll,
                kMWMInputModeless);
  this->MapSubwindows();

  this->Resize(this->GetDefaultSize());
  this->MapWindow();
  this->Resize(width,height);

// Event Control
  // Construct event information  prev and next button
  TGHorizontalFrame *controls = new TGHorizontalFrame(this);
  AddFrame(controls, new TGLayoutHints(kLHintsExpandX));

  TGLabel *fLbEvent = new TGLabel(controls, "Event number");
  LbEventNum = new TGNumberEntryField(controls);
  LbEventNum->SetIntNumber(-1);

  controls->AddFrame(fLbEvent, new TGLayoutHints(kLHintsLeft|kLHintsCenterY, 5, 2, 2, 2));
  controls->AddFrame(LbEventNum, new TGLayoutHints(kLHintsLeft|kLHintsCenterY, 5, 2, 2, 2));
  LbEventNum->Connect(" ReturnPressed()", "EventDisplay", this, "SetEventNum()");
  
// DeltaT Control
  ULong_t ucolor;        // will reflect user color changes
  gClient->GetColorByName("#ccccff",ucolor);

  // horizontal frame
  TGVerticalFrame *dtFrame = new TGVerticalFrame(this,240,120,kVerticalFrame | kSunkenFrame | kRaisedFrame ,ucolor);
  this->AddFrame(dtFrame, new TGLayoutHints(kLHintsExpandX ));
  

  TGLabel *deltaTLabel = new TGLabel(dtFrame, "DeltaT");
  deltaTLabel->SetBackgroundColor(ucolor);
  deltaTLabel->SetForegroundColor(kBlack);
  dtFrame->AddFrame(deltaTLabel, new TGLayoutHints(kLHintsCenterX));


  TGHorizontalFrame *dtBottomFrame = new TGHorizontalFrame(dtFrame,1,1,kHorizontalFrame| kSunkenFrame ,ucolor);
  dtFrame->AddFrame(dtBottomFrame, new TGLayoutHints(kLHintsExpandX));

  slider = new TGDoubleHSlider(dtBottomFrame, 200, kScaleNo, 10,
                                   kHorizontalFrame,
                                   GetDefaultFrameBackground(),
                                   kFALSE, kFALSE);
  slider->SetBackgroundColor(ucolor);
  slider->Connect("PositionChanged()", "EventDisplay",
                      this, "DoSlider()");

  slider->Connect("Released()", "EventDisplay",
                      this, "SliderReleased()");

  slider->SetRange(0,1);
  slider->SetPosition(0,1);


  deltaTMin = new TGNumberEntryField(dtBottomFrame);
  deltaTMin-> SetBackgroundColor(ucolor);
  deltaTMin-> SetForegroundColor(kBlack);
  deltaTMin->SetState(true);
  deltaTMin->Connect(" ReturnPressed()", "EventDisplay", this, "SetSliderRange()");


  dtBottomFrame->AddFrame(deltaTMin, new TGLayoutHints(kLHintsLeft));
  dtBottomFrame->AddFrame(slider, new TGLayoutHints(kLHintsExpandX));


  deltaTMax = new TGNumberEntryField(dtBottomFrame);
  deltaTMax-> SetBackgroundColor(ucolor);
  deltaTMax-> SetForegroundColor(kBlack);
  deltaTMax->Connect(" ReturnPressed()", "EventDisplay", this, "SetSliderRange()");

  dtBottomFrame->AddFrame(deltaTMax, new TGLayoutHints(kLHintsRight));
  deltaTMax->SetState(true);


  TGLabel *fooLabel = new TGLabel(dtFrame, "    ");
  fooLabel->SetBackgroundColor(ucolor);
  fooLabel->SetForegroundColor(kBlack);
  dtFrame->AddFrame(fooLabel, new TGLayoutHints(kLHintsCenterX));



  // EventDisplay
  // Display Option Frame
  mainFrame = new TGVerticalFrame(this,240,120,kHorizontalFrame | kSunkenFrame | kRaisedFrame );
  this->AddFrame(mainFrame, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY | kSunkenFrame | kRaisedFrame));

  TGCompositeFrame *canvasZone = new TGCompositeFrame(mainFrame,1,1, kHorizontalFrame | kRaisedFrame);


  TGHorizontalFrame *fV1 = new TGHorizontalFrame(canvasZone, 800, 1  ,kSunkenFrame | kFixedWidth );
  TGHorizontalFrame *fV2 = new TGHorizontalFrame(canvasZone, 1, 1,kSunkenFrame);


  canvasZone->AddFrame(fV1,  new TGLayoutHints( kLHintsLeft   | kLHintsExpandY,2,0,2,2));

  TGVSplitter *splitter = new TGVSplitter(canvasZone, 10);
  splitter->SetFrame(fV1, kTRUE);
  canvasZone->AddFrame(splitter,  new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 0, 0 ,0, 0));
  canvasZone->AddFrame(fV2,  new TGLayoutHints( kLHintsRight | kLHintsExpandX  |kLHintsExpandY,0,2,2,2));


  // 3D View
  gCanvas = new TGCanvas(fV2,1,1); 
  TGViewPort *viewPort = gCanvas->GetViewPort();

  TGCompositeFrame *compositeFrame = new TGCompositeFrame(viewPort,1,1 );

  TRootEmbeddedCanvas *rootEmbeddedCanvas = new TRootEmbeddedCanvas(0,compositeFrame,1100,900);
  c1 = rootEmbeddedCanvas->GetCanvas();

  gCanvas->SetContainer(compositeFrame);

  c1->SetFillColor(kBlack);
  compositeFrame->AddFrame(rootEmbeddedCanvas, new TGLayoutHints( kLHintsExpandX ));

  viewPort->AddFrame(compositeFrame);
  fV2->AddFrame(gCanvas, new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsExpandX | kLHintsExpandY,0,0,0,0));
  //fV2->AddFrame(gCanvas);

  // DT Histogram
  TGCompositeFrame *compositeFrameDt = new TGCompositeFrame(fV1,1,1 );

  TRootEmbeddedCanvas *embeddedCanvasDt = new TRootEmbeddedCanvas(0,compositeFrameDt,800,600);
  dtCan = embeddedCanvasDt->GetCanvas();

  compositeFrameDt->AddFrame(embeddedCanvasDt, new TGLayoutHints(kLHintsExpandX ));
  fV1->AddFrame(compositeFrameDt, new TGLayoutHints(kLHintsLeft | kLHintsBottom | kLHintsExpandX | kLHintsExpandY ,0,0,0,0));

  mainFrame->AddFrame(canvasZone, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));



 // Create status bar
   Int_t parts[] = {25, 60,15};
   fStatusBar = new TGStatusBar(this, 50, 10, kHorizontalFrame);
   fStatusBar->SetParts(parts, 3);
   this->AddFrame(fStatusBar, new TGLayoutHints(kLHintsBottom| kLHintsExpandX, 0, 0, 0, 0));
   fStatusBar->SetText("Waiting to read event ...",0);

  MapSubwindows();
  SetWindowName("Micromegas LAPP Event Viewer");
  SetIconName("Micromegas LAPP Event Viewer");
  Layout();
  MapWindow();
  

}

EventDisplay::~EventDisplay()
{
}



//______________________________________________________________________________
void EventDisplay::SliderReleased()
{
 this->Display(true);
}
//______________________________________________________________________________
void EventDisplay::DoSlider()
{
 deltaTMin->SetNumber(slider->GetMinPosition());

 deltaTMax->SetNumber(slider->GetMaxPosition());
}
//______________________________________________________________________________
void EventDisplay::SetSliderRange()
{
    if ( deltaTMin->GetIntNumber() < 0 ) { deltaTMin->SetNumber(0 ); }
    else if ( deltaTMax->GetIntNumber() < 0 ) { deltaTMax->SetNumber(0 ); }
    slider->SetPosition(deltaTMin->GetIntNumber(),deltaTMax->GetIntNumber());
    this->Display(true);
}
//______________________________________________________________________________
void EventDisplay::UnZoom()
{

  c1->cd();
  c1->GetView()->UnzoomView(0, 1.25);
  c1->Modified();
  c1->Update();

}
//______________________________________________________________________________
void EventDisplay::Zoom()
{
  c1->cd();
  c1->GetView()->ZoomView(0, 1.25);
  c1->Modified();
  c1->Update();
  
}
//______________________________________________________________________________
void EventDisplay::SetEventNum()
{
  if ( file == NULL ) { return ; }
  if ( LbEventNum->GetIntNumber() >= 0)
  {
    eventNum = LbEventNum->GetIntNumber();
    adjustSlider();
    this->Display(true);
  }
}

//______________________________________________________________________________
void EventDisplay::ShowChamberClick()
{
    gSystem->ProcessEvents();
    this->Display(true);
}

//______________________________________________________________________________
void EventDisplay::PrevEvent()
{
  if ( file == NULL ) { return ; }
  if ( eventNum == 0 ) eventNum = 1; 
  eventNum--;

  LbEventNum->SetIntNumber(eventNum);
  adjustSlider();
  this->Display(true);
}

//______________________________________________________________________________
void EventDisplay::NextEvent()
{
  if ( file == NULL ) { return ; }
  eventNum++;
  LbEventNum->SetIntNumber(eventNum);
  adjustSlider();
  this->Display(true);
}

//______________________________________________________________________________
void EventDisplay::adjustSlider()
{
  UInt_t min = 0;
  UInt_t max = 0xffffffff;
  slider->SetRange(min, max);
  deltaTMin->SetNumber(min);

  deltaTMax->SetNumber(max);
  slider->SetPosition(min,max);
  TTree *tree =  NULL;
  TBranch *branch= NULL;
  Int_t nbEvent = 0;


  TreeInfo_t* info = getTreeInfo(eventNum);
  
  if ( info->type == CALOEVENT )
  {
    CaloEvent* caloEvt = new CaloEvent();
    tree = info->tree;
    branch= tree->GetBranch("CaloEvent");
    branch->SetAddress(&caloEvt);
    tree->GetEntry(this->eventNum-info->min);

    Int_t NC=caloEvt->GetNHits();
    UInt_t min = 0xffffffff;
    UInt_t max = 0;

    for(int i=0;i<NC  ;i++)
    {
      CaloHit* caloChannel = (CaloHit*)caloEvt->GetHits()->UncheckedAt(i);
      UInt_t dt= caloChannel->GetDeltaT();
      if ( dt < min ) { min = dt; }
      if ( dt > max ) { max = dt; }
    }

    slider->SetRange(min, max);
    deltaTMin->SetNumber(min);

    deltaTMax->SetNumber(max);
    slider->SetPosition(min-1,max+1);
    delete caloEvt;
  }
  else
  {
    MTEvent* mtEvt = new MTEvent();
    tree = info->tree;
    branch= tree->GetBranch("MTEvent");
    branch->SetAddress(&mtEvt);
    tree->GetEntry(this->eventNum-info->min);

    Int_t NC=mtEvt->GetNchannel();
    UInt_t min = 0xffffffff;
    UInt_t max = 0;

    for(int i=0;i<NC  ;i++)
    {
      MTChannel* caloChannel = (MTChannel*)mtEvt->GetChannels()->UncheckedAt(i);
      UInt_t t2 = caloChannel->GetBcIdDif();
      UInt_t t3 = caloChannel->GetBcIdHit();
      UInt_t dt = t2 - t3;

      
      if ( dt < min ) { min = dt; }
      if ( dt > max ) { max = dt; }
    }

    slider->SetRange(min, max);
    deltaTMin->SetNumber(min);
    deltaTMax->SetNumber(max);
    slider->SetPosition(min,max); 
   

    delete mtEvt;
  }
}



//______________________________________________________________________________

Bool_t EventDisplay::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)

{
   Window_t wdummy;
   int ax, ay;
   TRootHelpDialog *hd;
   //TGListTreeItem *item;
   TGFileInfo fi;
   Char_t  strtmp[250];

    // Process events generated by the buttons in the frame.
    switch (GET_MSG(msg)) {

        case kC_COMMAND:

            switch (GET_SUBMSG(msg)) {
              case kCM_BUTTON:
                  switch (parm1) {
                  
                  case   M_FILE_EVENT_OPEN:
                    OpenFile();
                  break;
                  case   M_FILE_XML_OPEN:
                    OpenXMLFile();
                  break;
                  case   M_EVENT_PREV:
                    PrevEvent();
                  break;
                  case   M_EVENT_NEXT:
                    NextEvent();
                  break;
                  case   M_EVENT_SELECT:
                  SetEventNum();
                  break;
                  case   M_ZOOM_PLUS:
                    Zoom();
                  break;
                  case   M_ZOOM_MOINS:
                    UnZoom();
                  break;
                  case   M_SHOW_CHAMBER:
                     drawChamber = !drawChamber;
                     fToolBar->GetButton(M_SHOW_CHAMBER)->SetDown(drawChamber);
                     ShowChamberClick();
                  break;
                  case   M_COLOR_MICROMEGAS_HIT:
                    hitMicromegas = !hitMicromegas; 
                    fToolBar->GetButton(M_COLOR_MICROMEGAS_HIT)->SetDown(hitMicromegas);
                    ShowChamberClick();
                  break;
                  case   M_ONLY_MICROMEGAS:
                    onlyMicromegas = !onlyMicromegas; 
                    fToolBar->GetButton(M_ONLY_MICROMEGAS)->SetDown(onlyMicromegas);
                    ShowChamberClick();
                  break;
                  case   M_FILE_EXIT:
                    CloseWindow();
                  break;
                  }
                     break;


                default:
                    break;
            }
        default:
            break;
    }
    return kTRUE;
}



//______________________________________________________________________________
void EventDisplay::Display( bool updateDt)
{
  if ( file == NULL ) { return ; }
  if ( file->IsZombie()) {
    exit(-1);
  }

  if ( world ) { world->ClearNodes(); }
  frame =new TGeoManager("Frame","mM event displayer");
  mat = new TGeoMaterial("SomeMaterial",1,1,1);
  med = new TGeoMedium("SomeMedium",1,mat);
  world = frame->MakeBox("World", med, 1, 1, 1); // x, y , z size unit cm


  

  if (detector != NULL &&  drawChamber &&  steername.compare("") != 0)
  {
    ChamberMap_t chambers = detector->getChambers();
    for ( ChamberMap_t::const_iterator iter = chambers.begin(); iter!=chambers.end(); iter++)
    {
      Chamber *chamber = (*iter).second;
      TGeoVolume *pad = frame->MakeBox("1" ,med,chamber->getYLength(),chamber->getXLength(),9600 );
      unsigned int color = 17;

      if ( chamber->getType().find("MICROROC")  != string::npos )
      { color = 7 ; }
        
      world->AddNode(pad,1,new TGeoTranslation(chamber->getX(),chamber->getY(),chamber->getZ()));
      pad->SetLineColor(color);
    }
  }
  
    TreeInfo_t* info = getTreeInfo(eventNum);
    if ( info != NULL ) 
    {
      if ( info->type == CALOEVENT ) 
      {
        this->DisplayCaloEvent(updateDt);
      }
      else if  ( info->type == MTEVENT )  
      {
        this->DisplayMTEvent(updateDt);
      }
    }
}

//__________________________________________________________________________________________________________________
void EventDisplay::DisplayCaloEvent(bool updateDT)
{
  if ( updateDT )
  {
    if ( dtHist != NULL ) { delete dtHist ;}
    dtHist = new TH1I("dt", "dt", deltaTMax->GetNumber()-deltaTMin->GetNumber()+2, deltaTMin->GetNumber()-1,deltaTMax->GetNumber()+1);
    TExec *ex = new TExec("ex","EventDisplay::zoomC1()");
    dtHist->GetListOfFunctions()->Add(ex);
  }

  CaloEvent *caloEvt = NULL;
 // TKey *key;
  int padNumber = 0;
  UInt_t curEvent = 0;

  TTree *tree =  NULL;
  TBranch *branch= NULL;
  Int_t nbEvent = 0;

  caloEvt = new CaloEvent();
  TreeInfo_t* info = getTreeInfo(eventNum);
  if ( info != NULL )
  {
    tree = info->tree;
    branch= tree->GetBranch("CaloEvent");
    branch->SetAddress(&caloEvt);
  }
  else { return; }
    
    
  tree->GetEntry(this->eventNum-info->min);
  string foo = "EventId ";
  Toolbox::addIntToString(foo, this->eventNum-info->min);
  fStatusBar->SetText(foo.c_str(),2);

  Int_t NC=caloEvt->GetNHits();
  frame->SetMaxVisNodes(NC+100);

  float x,y,z;
  UInt_t drawHits = 0;
  for(int i=0;i<NC  ;i++)
  {
    if ( padNumber < 169300)
    {
      CaloHit* caloChannel = NULL;
      //the only known way to get the information from the channels number i
      caloChannel = (CaloHit*)caloEvt->GetHits()->UncheckedAt(i);
  
    
      Int_t dt= caloChannel->GetDeltaT();

      bool chamberMicromegas = false;

      

      if (onlyMicromegas && !this->IsMicromegas(caloChannel->GetLayer())  )  {continue;}
      if (  dt < deltaTMin->GetNumber() || dt> deltaTMax->GetNumber() )
      { 
        continue; 
        
      }
    
      drawHits++;
 
      if ( updateDT ) dtHist->Fill(dt);
      float xLength = 9600 ;  //micron 
      float yLength = 9600 ;  //micron
      float zLength = 2000;     //micron
      // ChannelPad name
      string padID="";
      stringstream currentpad;// (stringstream::in | stringstream::out);
      padNumber++;
      currentpad<<padNumber;
      padID="pad_"+currentpad.str();

      TGeoVolume *pad = frame->MakeBox(padID.c_str(),med,yLength/2,xLength/2,zLength/2 );
      x=caloChannel->GetX();//*10000 ;
      y=caloChannel->GetY();//*10000 ;
      z=caloChannel->GetZ();//*10000 ;
      //set now the color of the pad
      int color;
      int colors[3] = {kBlue,kGreen,kRed};
      if ( hitMicromegas && !this->IsMicromegas(caloChannel->GetLayer()))
      {   
        colors[0] = 31; 
        colors[1] = 41; 
        colors[2] = 44; }
      stringstream ch;
      ch<<i;

      color = colors[caloChannel->GetThreshold()-1];

      ostringstream ox,oy,oz;
      ox << x; oy << y; oz <<z ;
      {
        world->AddNode(pad,1,new TGeoTranslation(x,y,z));
      }
      pad->SetLineColor(color);
      pad->SetFillColor(color);
      pad->SetFillStyle(4100);
      Char_t  strtmp[250];
      sprintf(strtmp,"Hits reading : %4d, please wait...",i);
      // Update display here to not slow down too much...
      gSystem->ProcessEvents();
      fStatusBar->SetText(strtmp,0);

    }
    else
    {
      break;
    }
  }
  string str = "Done: "; 
  Toolbox::addIntToString(str, drawHits);
  str = str + "  hits / " ;
  Toolbox::addIntToString(str, caloEvt->GetNHits());
  fStatusBar->SetText(str.c_str(),0);


  frame->SetTopVolume(world);
  
  frame->CloseGeometry();
  dtCan->cd();
  if ( updateDT ) dtHist->Draw();
  c1->cd();
  world->Draw();
  c1->Update();
  if ( updateDT &&  dtCan ) dtCan->Update();
  delete caloEvt;

}
//______________________________________________________________________________________________________________________________________
void EventDisplay::DisplayMTEvent(bool updateDT)
{
  if ( updateDT )
  {
    if ( dtHist != NULL ) { delete dtHist; }
    dtHist = new TH1I("dt", "dt", deltaTMax->GetNumber()-deltaTMin->GetNumber()+2, deltaTMin->GetNumber()-1,deltaTMax->GetNumber()+1);

    TExec *ex = new TExec("ex","EventDisplay::zoomC1()");
    dtHist->GetListOfFunctions()->Add(ex);
  }


  MTEvent *mtEvt = NULL;
  int padNumber = 0;
  UInt_t curEvent = 0;

  TTree *tree =  NULL;
  TBranch *branch= NULL;
  Int_t nbEvent = 0;

  mtEvt = new MTEvent();
  TreeInfo_t* info = getTreeInfo(eventNum);
  if ( info != NULL )
  {
    tree = info->tree;
    branch= tree->GetBranch("MTEvent");
    branch->SetAddress(&mtEvt);
  }
  else { return; }

  tree->GetEntry(this->eventNum-info->min);

  Int_t NC = mtEvt->GetNchannel();
  //NC = 3000;
  frame->SetMaxVisNodes(NC+100);

  UInt_t minSlider = deltaTMin->GetNumber();
  UInt_t maxSlider = deltaTMax->GetNumber();


  map<string,TGeoVolume*> pads;
  map<string,int> padsDigitalValue;
  float x,y,z;
  TGeoTranslation *tr = NULL;
  UInt_t  drawHits = 0;
  for(int i=0;i<NC  ;i++)
  {
    //if ( padNumber < 169300)
    {
      MTChannel* mtChannel=NULL;
      //the only known way to get the information from the channels number i
      mtChannel = (MTChannel*)mtEvt->GetChannels()->UncheckedAt(i);
      
      UInt_t t2 = mtChannel->GetBcIdDif();
      UInt_t t3 = mtChannel->GetBcIdHit();
      UInt_t dt = t2 - t3;
      if (onlyMicromegas && !this->IsMicromegas(mtChannel->GetChamberId())  )  {continue;}
      if (  dt < minSlider || dt > maxSlider ) {  continue; }
      drawHits++;

      if ( updateDT ) dtHist->Fill(dt);
      float xLength = 9600 ;  //micron 
      float yLength = 9600 ;  //micron
      float zLength = 2000;   //micron
      // ChannelPad name
      string padID="";
      stringstream currentpad;// (stringstream::in | stringstream::out);
      padNumber++;
      currentpad<<padNumber;
      padID="pad_"+currentpad.str();

      x=mtChannel->GetX();//*10000 ;
      y=mtChannel->GetY();//*10000 ;
      z=mtChannel->GetZ();//*10000 ;

      ostringstream ox,oy,oz;
      ox << x; oy << y; oz <<z ;
      string key = "x[" + ox.str() + "]y[" + oy.str() + "]z[" + oz.str() +"]" ;
      TGeoVolume *pad = NULL;

      int color;
      int colors[3] = {kBlue,kGreen,kRed};
      if ( hitMicromegas && !this->IsMicromegas(mtChannel->GetChamberId()))
      { colors[0] = colors[1] = colors[2] = kGray; }

      if ( pads.find(key) == pads.end())
      {
         pad = frame->MakeBox(padID.c_str(),med,yLength/2,xLength/2,zLength/2 );
         pads.insert(make_pair(key,pad));
         tr = new TGeoTranslation(x,y,z);
         world->AddNode(pad,1,tr);
         //set now the color of the pad
         
      //   padsDigitalValue.insert(make_pair(key,colors[mtChannel->GetDigitalValue()-1]));
         padsDigitalValue.insert(make_pair(key,mtChannel->GetDigitalValue()-1));

         color = colors[mtChannel->GetDigitalValue()-1];

      }
      else {
        pad = pads.find(key)->second ;
        int oldDigitalValue = padsDigitalValue.find(key)->second;
        int digitalValue = 0;
        if ( mtChannel->GetDigitalValue() > oldDigitalValue )
        {
          digitalValue =  mtChannel->GetDigitalValue() ;
        }
        else
        {
          digitalValue = oldDigitalValue;
        }
        color = colors[digitalValue-1]; 
      }


        Char_t  strtmp[250];
        sprintf(strtmp,"Hits reading : %4d, please wait...",i);
        fStatusBar->SetText(strtmp,0);
        // Update display here to not slow down too much...
        gSystem->ProcessEvents();



        stringstream ch;
        ch<<i;

        if ( pad ) 
        {
          pad->SetLineColor(color);
          pad->SetFillColor(color);
          pad->SetFillStyle(4100);
        }
        else { cout << "Pad not found[" << key << "]" << endl; return ; }
    }
  }
  cout << " number of pad["<< padNumber <<  "]" << endl;
  
  string str = "Done: ";
  Toolbox::addIntToString(str, drawHits);
  str = str + "  hits / " ;
  Toolbox::addIntToString(str, mtEvt->GetNchannel());
  fStatusBar->SetText(str.c_str(),0);




  frame->SetTopVolume(world);

  if ( !frame->IsClosed() ) frame->CloseGeometry();
  dtCan->cd();
  if ( updateDT ) dtHist->Draw();
  c1->cd();
  world->Draw();
  if ( updateDT ) dtCan->Update();
  c1->Update();
  
  delete mtEvt;
}

//______________________________________________________________________________
void EventDisplay::HandleMenu(int menu_id)
{
   // Handle menu events.

   switch (menu_id) {
      case M_FILE_EXIT:
         // close the window and quit application
        CloseWindow();
         gApplication->Terminate(0);
         break;
      case M_FILE_EVENT_OPEN:
        OpenFile();
        break;
      case M_FILE_XML_OPEN:
        OpenXMLFile();
        break;
   }
}

//______________________________________________________________________________
void EventDisplay::fillTreeInfo(const TFile &file)
{
  treeInfos.clear();
  
  TIter nextkey(file.GetListOfKeys());
  TKey *key;
  UInt_t nbEvent = 0;
  while (key = (TKey*)nextkey()) 
  {
    TreeInfo_t *foo = new TreeInfo_t();

    TTree *tree = (TTree*)key->ReadObj();
    foo->min=nbEvent;
    foo->max=foo->min+tree->GetEntries()-1;
    nbEvent = foo->max+1;
    foo->tree = tree;
    if ( tree->FindBranch("CaloEvent")!= NULL)
    {
      foo->type = CALOEVENT;
    }
    else if ( tree->FindBranch("MTEvent")!= NULL)
    {
      foo->type = MTEVENT;
    }

    treeInfos.push_back(foo);
  }

}
 
//______________________________________________________________________________
TreeInfo_t* EventDisplay::getTreeInfo(UInt_t eventNum)
{
  
  
  std::vector<TreeInfo_t*>::const_iterator iter;

  for( iter = treeInfos.begin(); iter != treeInfos.end(); iter++)
  {
    TreeInfo_t* info= *iter;
    if ( eventNum >= info->min && eventNum <= info->max )
    {
      return info;
    }
  }
  return NULL;
}

//______________________________________________________________________________
bool EventDisplay::IsMicromegas(UInt_t chamberId)
{
    Chamber *chamber = NULL;
    if ( detector != NULL )
    {
      chamber = &(detector->getChamberById(chamberId));
      if ( chamber != NULL  )
      {
         if ( chamber->getType().find("MICROROC")  != string::npos )
        {
            return true;
        }
      }
    }
  return false;
}


//______________________________________________________________________________
bool EventDisplay::buildDetector()
{
  if (steername.compare("") !=0 )
  {
    XMLTool xml;
    SteerDesc steerDesc;
    xml.parse(steerDesc, steername); // parse steer file and fill steerDesc
    detector = new Detector();

    UInt_t nbChamber= detector->build(steerDesc);

    if ( nbChamber == 0 || nbChamber!= steerDesc.chambers.size() )
    {
       fToolBar->GetButton(M_ONLY_MICROMEGAS)->SetState(kButtonDisabled);
       fToolBar->GetButton(M_SHOW_CHAMBER)->SetState(kButtonDisabled);
       fToolBar->GetButton(M_COLOR_MICROMEGAS_HIT)->SetState(kButtonDisabled);
      return false;
    }
    fToolBar->GetButton(M_ONLY_MICROMEGAS)->SetState(kButtonUp);
    fToolBar->GetButton(M_SHOW_CHAMBER)->SetState(kButtonUp);
    fToolBar->GetButton(M_COLOR_MICROMEGAS_HIT)->SetState(kButtonUp);
  }

return true;
}


//______________________________________________________________________________
void EventDisplay::OpenFile()
{
   TRootHelpDialog *hd;
   static TString dir(".");
   TGFileInfo fi;
   fi.fFileTypes = dnd_types;
   fi.fIniDir    = StrDup(dir);

         fi.fFileTypes = filetypes;
           new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
           if ( fi.fFilename != NULL )
           {
            string *full;
            full  = new string(fi.fFilename);
            if ( file != NULL )
            {
              std::vector<TreeInfo_t*>::const_iterator iter;
              for( iter = treeInfos.begin(); iter != treeInfos.end(); iter++)
              {
                TreeInfo_t* info= *iter;
                {
                  delete info;
                }
              }
              treeInfos.clear();
              delete dtHist;
              dtHist = NULL;
              file->Close();
              delete file;
              eventNum = 0;
              LbEventNum->SetIntNumber(eventNum);
            }


            file = new TFile(full->c_str(),"READONLY");
            fStatusBar->SetText(full->c_str(),1);
            fillTreeInfo(*file);
        }

 }

//______________________________________________________________________________
void EventDisplay::OpenXMLFile()
{
   TRootHelpDialog *hd;
   static TString dir(".");
   TGFileInfo fi;
   fi.fFileTypes = dnd_types;
   fi.fIniDir    = StrDup(dir);
           fi.fFileTypes = filetypes;
           new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
           if ( fi.fFilename != NULL )
            {
              steername  = fi.fFilename;
              buildDetector();
            }
}

//______________________________________________________________________________
Bool_t EventDisplay::HandleConfigureNotify(Event_t *event)
{
   // This event is generated when the frame is resized.

   TGFrame* f = (TGFrame*)this;
   if ((event->fWidth != f->GetWidth()) || (event->fHeight != f->GetHeight())) {
      UInt_t w = event->fWidth;
      UInt_t h = event->fHeight;
      f->Resize(w,h);
      f->Layout();
   }
   return kTRUE;
}


//______________________________________________________________________________
void EventDisplay::processZoom(void)
{

  if ( deltaTMin->GetNumber() != dtCan->GetUxmin() || deltaTMax->GetNumber() != dtCan->GetUxmax() )
  { 
    
    if ( dtCan->GetUxmin() < 0 )
    {
      deltaTMin->SetNumber(0);
    }
    else
    {
      deltaTMin->SetNumber(dtCan->GetUxmin());
    }

    deltaTMax->SetNumber(dtCan->GetUxmax());
    this->Display(false);
  }
}

//______________________________________________________________________________
void EventDisplay::zoomC1(void)
{

  for ( std::vector<EventDisplay*>::const_iterator iter = frames.begin() ; iter != frames.end(); iter++)
  {
    
    (*iter)->processZoom();
  }
}

---