/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 "Chamber.hh"
#include "Detector.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 <TGSlider.h>


#include "TGFileDialog.h"
#include <TGClient.h>
#include <TRootCanvas.h>
#include <TGMenu.h>
#include <TGButton.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 <TGClient.h>
#include <TGListBox.h>
#include <TList.h>

#include "TRootHelpDialog.h"


#define CALOEVENT 1
#define MTEVENT 2


ClassImp(EventDisplay)

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), eventNum(0), steername(xmlfileName) , c1(NULL), dtHist(NULL) , eventType(UNDEFINED)
{
  file = new TFile(rootfileName.c_str(),"READONLY");
  fillTreeInfo(*file);
  this->Init();
  fLbRootFile->SetText(rootfileName.c_str());
}

EventDisplay::EventDisplay(std::string &rootfileName, const TGWindow *p, UInt_t w, UInt_t h)
   : TGMainFrame(p, w, h), eventNum(0), c1(NULL), dtHist(NULL) , eventType(UNDEFINED)
{
  file = new TFile(rootfileName.c_str(),"READONLY");
  fillTreeInfo(*file);
  this->Init();
  fLbRootFile->SetText(rootfileName.c_str());
}


EventDisplay::EventDisplay(const TGWindow *p, UInt_t w, UInt_t h)
    : TGMainFrame(p, w, h), eventNum(0) , file(NULL), steername("") , c1(NULL) , dtHist(NULL) 
{
//  cout << "dtHist[" << dtHist <<"]" << endl;
  this->Init();
}
    
void EventDisplay::Init()
{
  gSystem->Load("libGeom");

  histCan = new TCanvas("dt", "dt", 600, 600);
  c1 = new TCanvas("Event Display", "Event Display", 600, 600);
  c1->SetFillColor(kBlack);

  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

  // construct Menu Bar
  fMenuBar = new TGMenuBar(this, 35, 50, 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|kLHintsExpandY, 2, 2, 2, 5));


  // Construct Root file label
  const TGFont *font = gClient->GetFont("-*-times-r-*-*-10-*-*-*-*-*-*-*");
  if (!font)
     font = gClient->GetResourcePool()->GetDefaultFont();
  GCValues_t   gval;
  gval.fMask = kGCBackground | kGCFont | kGCForeground;
  gval.fFont = font->GetFontHandle();
  FontStruct_t labelfont = font->GetFontStruct();
  TGGC *fTextGC = gClient->GetGC(&gval, kTRUE);
  ULong_t bcolor, ycolor;
  gClient->GetColorByName("white", ycolor);
  gClient->GetColorByName("black", bcolor);

  fLbRootFile = new TGLabel(this, "file name", fTextGC->GetGC(), labelfont, kChildFrame, bcolor);
  AddFrame(fLbRootFile, new TGLayoutHints(kLHintsExpandX|kLHintsExpandY, 1, 5, 3, 4));



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

  TGLabel *fLbEvent = new TGLabel(controls, "Event");
  LbEventNum = new TGNumberEntryField(controls);

  prevButton = new TGTextButton(controls, "&<<", PREVID);
  nextButton = new TGTextButton(controls, "&>>", NEXTID);
  exitButton = new TGTextButton(this, "&Exit", 2);

  controls->AddFrame(fLbEvent, new TGLayoutHints(kLHintsLeft|kLHintsCenterY, 5, 2, 2, 2));
  controls->AddFrame(LbEventNum, new TGLayoutHints(kLHintsLeft|kLHintsCenterY, 5, 2, 2, 2));
  controls->AddFrame(prevButton, new TGLayoutHints(kLHintsLeft|kLHintsCenterY, 5, 2, 2, 2));
  controls->AddFrame(nextButton, new TGLayoutHints(kLHintsLeft|kLHintsCenterY, 5, 2, 2, 2));
  prevButton->Connect("Clicked()", "EventDisplay", this, "PrevEvent()");
  nextButton->Connect("Clicked()", "EventDisplay", this, "NextEvent()");
  LbEventNum->Connect(" ReturnPressed()", "EventDisplay", this, "SetEventNum()");
  


 // Zoom
  TGHorizontalFrame *zoomZone = new TGHorizontalFrame(this);
  AddFrame(zoomZone, new TGLayoutHints(kLHintsExpandX|kLHintsExpandY));
  zoomup = new TGTextButton(zoomZone, "&Zoom +", 2);
  zoomdown = new TGTextButton(zoomZone, "&Zoom -", 2);
  zoomZone->AddFrame(zoomup, new TGLayoutHints(kLHintsExpandX));
  zoomup->Connect("Clicked()", "EventDisplay", this, "Zoom()");
  zoomZone->AddFrame(zoomdown, new TGLayoutHints(kLHintsExpandX));
  zoomdown->Connect("Clicked()", "EventDisplay", this, "UnZoom()");

// DeltaT Control
  // Construct DeltaT information Min/Max and slider
  slider = new TGDoubleHSlider(this, 200, kDoubleScaleBoth, 10,
                                   kHorizontalFrame,
                                   GetDefaultFrameBackground(),
                                   kFALSE, kFALSE);
  slider->Connect("PositionChanged()", "EventDisplay",
                      this, "DoSlider()");

  // BCID_DIF et BCID_HIT sont code sur 24 bits
  // donc DT  max = ( BCID_DIF - BCID_HIT ) = 0xffffff
  //slider->SetRange(0,0xffffff);
  //slider->SetPosition(0,0xffffff);
  slider->SetRange(0,1);
  slider->SetPosition(0,1);


  TGLabel *deltaTLabel = new TGLabel(this, "DeltaT");
  this->AddFrame(deltaTLabel, new TGLayoutHints(kLHintsExpandX));
  this->AddFrame(slider, new TGLayoutHints(kLHintsExpandX|kLHintsExpandY));

  TGHorizontalFrame *deltaT = new TGHorizontalFrame(this);
  AddFrame(deltaT, new TGLayoutHints(kLHintsExpandX|kLHintsExpandY));

  deltaTMin = new TGNumberEntryField(deltaT);
  deltaTMax = new TGNumberEntryField(deltaT);

  TGLabel *deltaTMinLabel = new TGLabel(deltaT, "Min");
  TGLabel *deltaTMaxLabel = new TGLabel(deltaT, "Max");
  deltaT->AddFrame(deltaTMinLabel, new TGLayoutHints(kLHintsExpandX));
  deltaT->AddFrame(deltaTMin, new TGLayoutHints(kLHintsExpandX));
  deltaT->AddFrame(deltaTMaxLabel, new TGLayoutHints(kLHintsExpandX));
  deltaT->AddFrame(deltaTMax, new TGLayoutHints(kLHintsExpandX));
  deltaTMin->SetState(false);
  deltaTMax->SetState(false);


  // check and exit button
  exitButton->SetCommand(".q" );
  fChkBut = new TGCheckButton(this, "Show chambers", 4);
  
  fLbRootFile->SetTextColor(ycolor);
  fLbRootFile->Resize(350, 80);
  fLayout = new TGLayoutHints(kLHintsCenterX | kLHintsCenterY);
  AddFrame(fChkBut, fLayout);
  AddFrame(exitButton, new TGLayoutHints(kLHintsExpandX|kLHintsExpandY, 5, 5, 3, 4));



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

EventDisplay::~EventDisplay()
{
  if ( file != NULL )
  {
    file->Close();
    delete file;
  }
}



//______________________________________________________________________________
void EventDisplay::DoSlider()
{
 deltaTMin->SetNumber(slider->GetMinPosition());
 deltaTMax->SetNumber(slider->GetMaxPosition());
 this->Display();


}
//______________________________________________________________________________
void EventDisplay::UnZoom()
{
  c1->cd();
  gPad->GetView()->ZoomOut();
  c1->SetCanvasSize((UInt_t)(c1->GetWw()*.9),(UInt_t)(c1->GetWh()*.9));
  
}
//______________________________________________________________________________
void EventDisplay::Zoom()
{
  c1->cd();
  gPad->GetView()->ZoomIn();
  c1->SetCanvasSize((UInt_t)(c1->GetWw()*1.1),(UInt_t)(c1->GetWh()*1.1));
  
}
//______________________________________________________________________________
void EventDisplay::SetEventNum()
{
  if ( file == NULL ) { return ; }
  eventNum = LbEventNum->GetIntNumber();
  adjustSlider();
  this->Display();
}


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

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

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

//______________________________________________________________________________
void EventDisplay::adjustSlider()
{
  Int_t min = 0;
  Int_t max = 0xffffffff;
  slider->SetRange(min, max);
  deltaTMin->SetNumber(min);
  deltaTMax->SetNumber(max);
  slider->SetPosition(min,max);
  return ;
  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();
    Int_t min = 0xffffffff;
    Int_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; }
    }

    cout << "min[" << min << "] max[" << max <<"]" << endl;
    slider->SetRange(min, max);
    deltaTMin->SetNumber(min);
    deltaTMax->SetNumber(max);
    slider->SetPosition(min,max);
    delete caloEvt;
  }
  else
  {
    MTEvent* caloEvt = new MTEvent();
    tree = info->tree;
    branch= tree->GetBranch("MTEvent");
    branch->SetAddress(&caloEvt);
    tree->GetEntry(this->eventNum-info->min);

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

    for(int i=0;i<NC  ;i++)
    {
      MTChannel* caloChannel = (MTChannel*)caloEvt->GetChannels()->UncheckedAt(i);
      UInt_t t2 = caloChannel->GetBcId_Dif();
      UInt_t t3 = caloChannel->GetBcId_Hit();
      UInt_t dt = t2 - t3;

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

    cout << "min[" << min << "] max[" << max <<"]" << endl;
    slider->SetRange(min, max);
    deltaTMin->SetNumber(min);
    deltaTMax->SetNumber(max);
    slider->SetPosition(min,max);
    delete caloEvt;
  }
}



//______________________________________________________________________________

Bool_t EventDisplay::ProcessMessage(Long_t msg, Long_t parm1, Long_t)
{
    // Process events generated by the buttons in the frame.
    switch (GET_MSG(msg)) {
        case kC_COMMAND:
            switch (GET_SUBMSG(msg)) {
                case kCM_CHECKBUTTON:
                    this->Display();
                    break;
                default:
                    break;
            }
        default:
            break;
    }
    return kTRUE;
}



/* @version $Revision: 1675 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-04-25 16:38:26 +0200 (Wed, 25 Apr 2012) $ */
//______________________________________________________________________________

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

//   world->ClearNodes();
  

  if ( fChkBut->IsDown())
  {
    Detector detector;
    SteerDesc steerDesc;
    XMLTool xml;
    xml.parse(steerDesc, steername); // parse steer file and fill steerDesc

    if ( ! detector.build(steerDesc) == steerDesc.chambers.size() )
    {
      FILE_LOG(logERROR) << "Geometry Error. Please check your XML file."  << endl;
      exit(-1);
    }
    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(),96 );
      int color = 17;
      cout << "chamber->getX(): " << chamber->getX() << "chamber->getY(): " << chamber->getY() << "chamber->getZ(): " << chamber->getZ() << endl;

 
      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();
      }
      else if  ( info->type == MTEVENT )  
      {
        this->DisplayMTEvent();
      }
    }
}

//__________________________________________________________________________________________________________________
void EventDisplay::DisplayCaloEvent()
{
  if ( dtHist != NULL ) { delete dtHist ;}
  dtHist = new TH1I("dt", "dt", slider->GetMaxPosition()-slider->GetMinPosition(), slider->GetMinPosition(), slider->GetMaxPosition() );
  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; }
  cout << "Get tree[" << tree << "]" << endl;
    
    
  tree->GetEntry(this->eventNum-info->min);

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


  float x,y,z;
  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();
      if (  dt < slider->GetMinPosition() || dt> slider->GetMaxPosition())
      { 
        continue;
      }
*/

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

cout <<  "xLength: " << xLength <<  "yLength: " << yLength <<  "zLength: " << zLength << endl;
      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 ;
cout <<  "x: " << x <<  "y: " << y <<  "z: " << z << endl;
      //set now the color of the pad
      int color;
      int sMax = 30;//set to limit of saturation
      stringstream ch;
      ch<<i;

      if ( caloChannel->GetThreshold() == 1 ) { color = 5; }
      else  if ( caloChannel->GetThreshold() == 2 ) { color = 6; }
      else  if ( caloChannel->GetThreshold() == 3 ) { color = 2; }

      ostringstream ox,oy,oz;
      ox << x; oy << y; oz <<z ;
      string key = "x[" + ox.str() + "]y[" + oy.str() + "]z[" + oz.str() +"]" ;
//        if ( node[key]==false)
      {
        world->AddNode(pad,1,new TGeoTranslation(x,y,z));
      //  node[key] = true;
      //  color = color * 2;
      }
      pad->SetLineColor(color);
      pad->SetFillColor(color);
      pad->SetFillStyle(4100);
    }
    else
    {
      break;
    }
  }
  frame->SetTopVolume(world);
  
  frame->CloseGeometry();
  histCan->cd();
  dtHist->Draw();
  c1->cd();
  world->Draw();
  c1->Update();
  histCan->Update();
delete caloEvt;

}
//______________________________________________________________________________________________________________________________________
void EventDisplay::DisplayMTEvent()
{

  //if ( world != NULL ) { delete world; }
  //if ( frame != NULL ) { delete frame; }
  //frame =new TGeoManager("Frame","mM event displayer");
  //world = frame->MakeBox("World", med, 1, 1, 1); // x, y , z size unit cm




//  world->ClearNodes();
  if ( dtHist != NULL ) { delete dtHist; }
  dtHist = new TH1I("dt", "dt", 
                    slider->GetMaxPosition()-slider->GetMinPosition(),
                    slider->GetMinPosition(),slider->GetMaxPosition() );
  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 = slider->GetMinPosition();
  UInt_t maxSlider = slider->GetMaxPosition();

  float x,y,z;
  for(int i=0;i<NC  ;i++)
  {
//    if ( padNumber < 169300)
    {
      cout << "compute channel " << i << " / " << NC << "\t\t\t\t\t\t\t\t\t\t\t\r" << flush;
      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->GetBcId_Dif();
      UInt_t t3 = mtChannel->GetBcId_Hit();
      UInt_t dt = t2 - t3;
      if (  dt < minSlider || dt > maxSlider ) { continue; }

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

      x=mtChannel->GetX() ;
      y=mtChannel->GetY() ;
      z=mtChannel->GetZ() ;
      //set now the color of the pad
      int color;
      int sMax = 30;//set to limit of saturation
      stringstream ch;
      ch<<i;

      if ( mtChannel->GetDigitalValue() == 1 ) { color = 5; }
      else  if ( mtChannel->GetDigitalValue() == 2 ) { color = 6; }
      else  if ( mtChannel->GetDigitalValue() == 3 ) { color = 2; }

      ostringstream ox,oy,oz;
      ox << x; oy << y; oz <<z ;
      string key = "x[" + ox.str() + "]y[" + oy.str() + "]z[" + oz.str() +"]" ;
      TGeoVolume *pad = NULL;
      TGeoTranslation *tr = NULL;
      if ( nodes.find(key) == nodes.end()   )
      {
        pad = frame->MakeBox(padID.c_str(),med,yLength/2,xLength/2,zLength/2 );
        nodes.insert(make_pair(key,pad));
        tr = new TGeoTranslation(x,y,z);
        trans.insert(make_pair(key,tr));
      world->AddNode(pad,1,tr);
      }
      else
      {
        pad = nodes[key];
        tr = trans[key];
      }
      pad->SetLineColor(color);
      pad->SetFillColor(color);
      pad->SetFillStyle(4100);
    }
  }
  frame->SetTopVolume(world);

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

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

   TRootHelpDialog *hd;
   static TString dir(".");
   TGFileInfo fi;
   fi.fFileTypes = dnd_types;
   fi.fIniDir    = StrDup(dir);


   switch (menu_id) {
          gApplication->Terminate(0);
      case M_FILE_EXIT:
         // close the window and quit application
         gApplication->Terminate(0);
         break;
      case M_FILE_EVENT_OPEN:
           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;
            }
 
    
            file = new TFile(full->c_str(),"READONLY");
            fLbRootFile->SetText(full->c_str());
            fCaloTypeCheckBut = 0;
            fillTreeInfo(*file);

          }
        break;
      case M_FILE_XML_OPEN:
           fi.fFileTypes = filetypes;
           new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
           if ( fi.fFilename != NULL ) steername  = fi.fFilename;
        break;
      case M_HELP_ABOUT:
         hd = new TRootHelpDialog(this, "About Drag and Drop...", 550, 250);
         //hd->SetText(gHelpDND);
         hd->Popup();
         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;
}

---