AgataEventDisplay.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Olivier Stezowski & Christian Finck        *
 *   stezow(AT)ipnl.in2p3.fr, cfinck(AT)ires.in2p3.fr                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   FreAgataEventDisplaye Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "Riostream.h"

#ifndef Gw_AgataEventDisplay
#include "AgataEventDisplay.h"
#endif

#ifndef Gw_AgataEventContainer
#include "AgataEventContainer.h" 
#endif

#ifndef Gw_AgataGeometryTransformer
#include "AgataGeometryTransformer.h"
#endif

#ifndef Gw_AgataHitDisplay
#include "AgataHitDisplay.h"
#endif

#ifndef Gw_AgataTrackDisplay
#include "AgataTrackDisplay.h"
#endif

// root include 
#ifndef ROOT_TEveGeoNode
#include "TEveGeoNode.h"
#endif

#ifndef ROOT_TEveManager
#include "TEveManager.h"
#endif

#ifndef ROOT_TEveBrowser
#include "TEveBrowser.h"
#endif

#ifndef ROOT_TGeoManager
#include "TGeoManager.h"
#endif

#ifndef ROOT_TGeoNode
#include "TGeoNode.h"
#endif

#ifndef ROOT_TGeoVolume
#include "TGeoVolume.h"
#endif

#ifndef ROOT_TGButton
#include "TGButton.h"
#endif

#ifndef ROOT_TGLViewer
#include "TGLViewer.h"
#endif

#ifndef ROOT_TGLabel
#include "TGLabel.h"
#endif

#ifndef ROOT_TGTextView
#include "TGTextView.h"
#endif

#ifndef ROOT_TGTextEntry
#include "TGTextEntry.h"
#endif

#ifndef ROOT_TList
#include "TList.h"
#endif

#ifndef ROOT_TNamed
#include "TNamed.h"
#endif

#ifndef ROOT_TSystem
#include "TSystem.h"
#endif

using namespace Gw;

//
ClassImp(AgataEventDisplay)

AgataEventDisplay* AgataEventDisplay::fgInstance  = 0x0;

Bool_t AgataEventDisplay::fgAgataGeoDone   = false;
Bool_t AgataEventDisplay::fgDanteGeoDone   = false;
Bool_t AgataEventDisplay::fgPrismaGeoDone  = false;
Bool_t AgataEventDisplay::fgPassiveGeoDone = false;
Bool_t AgataEventDisplay::fgFloorGeoDone   = true;

const Char_t* AgataEventDisplay::fgDefaultAgataPath   = "./";
const Char_t* AgataEventDisplay::fgDefaultDanteConf   = "Dante.conf";
const Char_t* AgataEventDisplay::fgDefaultPrismaConf  = "solver.conf";

//__________________________________________________________
AgataEventDisplay* AgataEventDisplay::Instance()
{
 if (fgInstance == 0x0)
  fgInstance = new  AgataEventDisplay();
  
  return fgInstance;
}

//__________________________________________________________
AgataEventDisplay::AgataEventDisplay() 
  : BaseEventDisplay(),
    fAgataContainer(new AgataEventContainer()),
        fQuadHitList(new TList()),
        fLineTrackList(new TList()),
    fBoxDefWidth(0.4),
    fBoxDefHeight(0.4),
    fQuadDefWidth(0.4),
    fQuadDefHeight(0.4),
    fInfoView(0x0),
    fEventEntry(0x0),
    fGUIFlag(true)
{ 
  // default constructor
  fLog.GetProcessName() = "AgataEventDisplay";
  fQuadHitList->SetOwner(true);
  fLineTrackList->SetOwner(true);
  
  if ( gGeoManager == NULL ) { // a new Geo Manager is created if needed
        
        new TGeoManager("Agata","Creating Geometry AGATA");
        
        TGeoMaterial *mat  = new TGeoMaterial("Vacuum",0,0,0); 
        TGeoMedium   *med  = new TGeoMedium("Vacuum",1,mat);
        
        fTopVolume = gGeoManager->MakeBox("World",med,100,100,100); 
        gGeoManager->SetTopVolume(fTopVolume);
  }
}

//__________________________________________________________
AgataEventDisplay::~AgataEventDisplay()
{
  // default destructor
  delete fAgataContainer;
  delete fQuadHitList;
  delete fLineTrackList;
  if (fInfoView)
    delete fInfoView;
  if (fEventEntry)
    delete fEventEntry;
  if (fRefreshButton)
        fRefreshButton->Delete();
}


//__________________________________________________________
void AgataEventDisplay::BuildDefaultGeometry(Bool_t danteGeo, Bool_t prismaGeo, Bool_t agataGeo, Bool_t passiveGeo)
{
   TGeoVolume* vol = 0x0;
   if (agataGeo && !fgAgataGeoDone) {
          TGeoRotation* rot = new TGeoRotation();
          rot->RotateY(180.);
          vol = Gw::AgataGeometryTransformer::BuildAgata(fgDefaultAgataPath);
          if (vol) {
                 AddGeometry(vol, rot);  
                 fgAgataGeoDone = true; 
          }
   }
   
   if (passiveGeo && !fgPassiveGeoDone) {
          
          TGeoHMatrix  transfo;
          TGeoRotation rot;
          rot.RotateY(42);  
          TGeoTranslation trans(-18*TMath::Sin(42*TMath::DegToRad()), 0., -18*TMath::Cos(42*TMath::DegToRad()));
          
          transfo = trans*rot;
          TGeoHMatrix *hm = new TGeoHMatrix(transfo);
          
          vol = Gw::AgataGeometryTransformer::AddBeamPipe(18, 0.1, 0.2);
          if (vol) {
                 AddGeometry(vol, hm);
                 fgPassiveGeoDone = true;
          }
          
          vol = Gw::AgataGeometryTransformer::AddTarget();
          if (vol) {
                 AddGeometry(vol);
                 fgPassiveGeoDone = true;
          }
          
          if (fgFloorGeoDone) {
                 TGeoTranslation* trans2 = new TGeoTranslation();
                 if (!prismaGeo) {
                        trans2->SetDy(-82.);
                        trans2->SetDz(-8.);
                        vol = Gw::AgataGeometryTransformer::AddFloor(20, 0.1, 25);
                 } else {
                        trans2->SetDx(-260.);
                        trans2->SetDy(-82.);
                        trans2->SetDz(280);
                        vol = Gw::AgataGeometryTransformer::AddFloor(350, 0.1, 360);    
                 }
                 if (vol) {
                        AddGeometry(vol, trans2);       
                        fgPassiveGeoDone = true;
                 }
          }
   }
   
   if (danteGeo && !fgDanteGeoDone) {
          TGeoRotation* rot = new TGeoRotation();
          rot->RotateY(90);
          vol = Gw::AgataGeometryTransformer::BuildDante(fgDefaultDanteConf);
          if (vol) {
                 AddGeometry(vol, rot);
                 fgDanteGeoDone = true;
          }
   }
   
   if (prismaGeo && !fgPrismaGeoDone) {
          vol = Gw::AgataGeometryTransformer::BuildPrisma(fgDefaultPrismaConf);
          if (vol) {
                 AddGeometry(vol);
                 fgPrismaGeoDone = true;
          }
   }
   
}

//__________________________________________________________
const Char_t* AgataEventDisplay::RegisterBranch(Option_t* type)
{
  return fAgataContainer->RegisterBranch(type);
}

//__________________________________________________________
void AgataEventDisplay::SetTrackStyle(const Char_t* s, Option_t* type)
{
  fMapStyle[type] = s;
}


//__________________________________________________________
void AgataEventDisplay::ShowDisplay()
{
  fLog.SetProcessMethod("ShowDisplay()");
  
  if (fgIsDisplayed) {
    gEve->FullRedraw3D(kTRUE);
        fLog << warning << "Display already open, just redraw canvas" << dolog;
        return;
  }

  TEveManager::Create();
  gEve->AddEvent(this);
  
  if (gGeoManager) {
    TGeoNode* topNode = gGeoManager->GetTopNode();
    TGeoManager::SetVerboseLevel(0);
    if (topNode == 0x0) {
      fLog << error << "No top node in geometry" << dolog;;
      return;
    } else {
      TEveGeoTopNode* out = new TEveGeoTopNode(gGeoManager, topNode);
          gEve->AddGlobalElement(out);
    }
  } else {
    fLog << warning << "No geometry loaded" << nline;
  }
  
  std::map<const Char_t*, const Char_t*>::iterator it;
  
  for (Int_t i = 0; i < fAgataContainer->GetNofBranches(); ++i) {
        const Char_t* type =  AgataEventContainer::GetTypeName(i);
        AgataHitDisplay* quadHits = new AgataHitDisplay(Form("%s %s", type, "Hits"));
        quadHits->SetMaxEnergy(fMaxEnergy);
        quadHits->SetDefWidth(fQuadDefWidth);
        quadHits->SetDefHeight(fQuadDefHeight);
        quadHits->SetPickable(true);
        fQuadHitList->Add(quadHits);
        
        AgataTrackDisplay* lineTracks = new AgataTrackDisplay(Form("%s %s", type, "Tracks"));
        // loop over map to be sure 
        for (it = fMapStyle.begin(); it != fMapStyle.end(); ++it) {
          TString sType(it->first);
          if (sType.Contains(type)) {
                TString sStyle(it->second);
                lineTracks->SetStyle(sStyle);
          }
        }
          
        lineTracks->SetMaxEnergy(fMaxEnergy);
        lineTracks->SetDefWidth(fBoxDefWidth);
        lineTracks->SetDefHeight(fBoxDefHeight);
        lineTracks->SetPickable(true);
        fLineTrackList->Add(lineTracks);
  }
  
  if (fGUIFlag)
    MakeGUI();

#if ROOT_VERSION_CODE >= ROOT_VERSION(5,24,0)
  TGLViewer* v = gEve->GetDefaultGLViewer();
#else
  TGLViewer* v = gEve->GetGLViewer();
#endif
  
  v->SetClearColor(kWhite);
  
  gEve->FullRedraw3D(kTRUE);

  fgIsDisplayed = true;
        
  fLog << dolog;
}

//__________________________________________________________
void AgataEventDisplay::MakeGUI()
{
  
  TEveBrowser* browser = gEve->GetBrowser();
  browser->StartEmbedding(TRootBrowser::kLeft);
  
  TGMainFrame* frmMain = new TGMainFrame(gClient->GetRoot(), 1000, 600);
  frmMain->SetWindowName("XX GUI");
  frmMain->SetCleanup(kDeepCleanup);
  
  TGHorizontalFrame *eventFrame = new TGHorizontalFrame(frmMain);
  
  TString icondir( Form("%s/icons/", gSystem->Getenv("ROOTSYS")) );
  TGPictureButton* b = 0x0;
  
  b = new TGPictureButton(eventFrame, gClient->GetPicture(icondir + "ReloadPage.gif"));
  eventFrame->AddFrame(b);
  b->SetToolTipText("First Event");
  b->Connect("Clicked()", "Gw::AgataEventDisplay", this, "FirstEvent()");
  
  b = new TGPictureButton(eventFrame, gClient->GetPicture(icondir + "GoBack.gif"));
  eventFrame->AddFrame(b);
  b->SetToolTipText("Previous Event");
  b->Connect("Clicked()", "Gw::AgataEventDisplay", this, "PrevEvent()");
  
  b = new TGPictureButton(eventFrame, gClient->GetPicture(icondir + "GoForward.gif"));
  eventFrame->AddFrame(b);
  b->SetToolTipText("Next Event");
  b->Connect("Clicked()", "Gw::AgataEventDisplay", this, "NextEvent()");

  fRefreshButton = new TGCheckButton(eventFrame, "Refresh", 1);
  fRefreshButton->SetState(kButtonDown);
  eventFrame->AddFrame(fRefreshButton, new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 0, 5, 0));
  frmMain->AddFrame(eventFrame, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 0, 5, 5));
  
  TGVerticalFrame *infoFrameView = new TGVerticalFrame(frmMain);
  fEventEntry = new TGTextEntry(infoFrameView);
  infoFrameView->AddFrame(fEventEntry, new TGLayoutHints(kLHintsLeft | kLHintsCenterY  | 
                                                        kLHintsExpandX, 2, 10, 0, 10));
  
  TGLabel*  infoName = new TGLabel(infoFrameView, "Selection:");
  infoFrameView->AddFrame(infoName, new TGLayoutHints(kLHintsLeft | kLHintsTop, 2, 0, 5, 5));
  
  fInfoView = new TGTextView(infoFrameView, 300, 400);
  fInfoView->ShowBottom();
  infoFrameView->AddFrame(fInfoView, new TGLayoutHints(kLHintsLeft | kLHintsCenterY  | 
                                                    kLHintsExpandX, 2, 10, 0, 0));
  
  TGTextButton* clearInfo = new TGTextButton(infoFrameView,"&Clear");
  clearInfo->Connect("Clicked()","Gw::AgataEventDisplay",this,"ClearInfoView()");
  clearInfo->SetToolTipText("Clear Info View");
  infoFrameView->AddFrame(clearInfo, new TGLayoutHints(kLHintsLeft | kLHintsCenterY,15,5,3,4));
  
  frmMain->AddFrame(infoFrameView, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 0, 5, 5));
  frmMain->MapSubwindows();
  frmMain->Resize();
  frmMain->MapWindow();
  browser->StopEmbedding();
  browser->SetTabTitle("Info", 0);
  
  for (Int_t i = 0; i < fAgataContainer->GetNofBranches(); ++i) { 
        AgataHitDisplay* quadHits = static_cast<AgataHitDisplay*> (fQuadHitList->At(i));
        quadHits->SetEmitSignals(true);
        quadHits->Connect("SecSelected(TEveDigitSet*, Int_t )", "Gw::AgataEventDisplay", this, "UpdateHitInfo(TEveDigitSet*, Int_t)");
        
        AgataTrackDisplay* lineTracks = static_cast<AgataTrackDisplay*> (fLineTrackList->At(i));
        lineTracks->SetEmitSignals(true);
        lineTracks->Connect("SecSelected(TEveDigitSet*, Int_t )", "Gw::AgataEventDisplay", this, "UpdateTrackInfo(TEveDigitSet*, Int_t)");
  }
  
}

//__________________________________________________________
void AgataEventDisplay::UpdateHitInfo(TEveDigitSet* qs, Int_t idx)
{
  AgataHitDisplay* quadHits = dynamic_cast<AgataHitDisplay*> (qs);

  fInfoView->AddLine( Form("%s # %3d with energy: %3d\n", quadHits->GetName(), idx, quadHits->GetSelectedValue()) );
}

//__________________________________________________________
void AgataEventDisplay::UpdateTrackInfo(TEveDigitSet* qs, Int_t idx)
{
  AgataTrackDisplay* lineTracks = dynamic_cast<AgataTrackDisplay*> (qs);

  std::pair<Int_t, Int_t> p;
  p = lineTracks->GetIndexes(idx);
  
  fInfoView->AddLine( Form("%s # %2d:", lineTracks->GetName(), p.first) );
  fInfoView->AddLine( Form(" associated hit# %2d\n", p.second) );
  fInfoView->AddLine( Form(" and energy: %3d\n", lineTracks->GetSelectedValue()) );
}

//__________________________________________________________
void AgataEventDisplay::ClearInfoView()
{
  // clear log message 
  fInfoView->Clear();
  fInfoView->ShowBottom();  
}

//__________________________________________________________
void AgataEventDisplay::FirstEvent()
{
  fLog.SetProcessMethod("FirstEvent()");

  // reset  
  fCurrentEventId = 0;

  if (!fFirstEventDone) {
        for (Int_t i = 0; i < fAgataContainer->GetNofBranches(); ++i) { 
          AgataHitDisplay* quadHits = static_cast<AgataHitDisplay*> (fQuadHitList->At(i));
          quadHits->ResetHits();
          gEve->AddElement(quadHits);

          AgataTrackDisplay* lineTracks = static_cast<AgataTrackDisplay*> (fLineTrackList->At(i));
          lineTracks->ResetTracks();
          gEve->AddElement(lineTracks);
        }
  }
  
  UpdateElements();

  fLog << dolog;
  fFirstEventDone = true;  
}

//__________________________________________________________
void AgataEventDisplay::NextEvent()
{
  fLog.SetProcessMethod("NextEvent()");
  
  if (fFirstEventDone == false) {
    fLog << warning << "Reseting iterator by calling FirstEvent method" << nline;
    FirstEvent();
    fFirstEventDone = true;
  }

  if (++fCurrentEventId >= fAgataContainer->GetNofEvents()) {
    fLog << warning << "Already last event" << dolog;
    fCurrentEventId = fAgataContainer->GetNofEvents()-1;
    return;
  }
  
  UpdateElements();  
   fLog << dolog;
}

//__________________________________________________________
void AgataEventDisplay::PrevEvent()
{
  fLog.SetProcessMethod("PrevEvent()");
  
  if (fFirstEventDone == false) {
    fLog << warning << "Click on first event before" << nline;
    return;
  }
    
  if (--fCurrentEventId < 0) {
    fLog << warning << "Already first event" << dolog;
    fCurrentEventId = 0;
    return;
  }
  
   UpdateElements();
   fLog << dolog;
}

//__________________________________________________________
void AgataEventDisplay::Reset()
{
  fAgataContainer->ClearEvents();
  fCurrentEventId = 0;
  fFirstEventDone = false;
}

//__________________________________________________________
void AgataEventDisplay::UpdateElements()
{
 
  fLog.SetProcessMethod("UpdateElements()");
  
  if (fGUIFlag)
    fEventEntry->SetText(Form("Event number: %d out of %d", fCurrentEventId, fAgataContainer->GetNofEvents()));
  
  for (Int_t i = 0; i < fAgataContainer->GetNofBranches(); ++i) { 
        
        Option_t* type = AgataEventContainer::GetTypeName(i);
        AgataHitDisplay* quadHits = static_cast<AgataHitDisplay*> (fQuadHitList->At(i));
        AgataTrackDisplay* lineTracks = static_cast<AgataTrackDisplay*> (fLineTrackList->At(i));
        
        if (!fGUIFlag || (fGUIFlag && fRefreshButton->IsOn())) {
          quadHits->ResetHits();
          lineTracks->ResetTracks();
        }
        
        TClonesArray* hitList = 0x0;
        TrackHit* tHit = 0x0;
        StdHit*   sHit = 0x0;
        
        hitList = fAgataContainer->GetTrackList(fCurrentEventId, type, false);
        if (hitList == 0x0) {
          fLog << debug << Form("Track not available for this event in type %s", type) << dolog;
        } else {
          
          Int_t nHits = hitList->GetEntries();
          printf("%s Tracks display %d\n", type, nHits);
          for (Int_t i = 0; i < nHits; ++i) {
                
                TObject* obj = hitList->At(i);
                
                tHit = dynamic_cast<TrackHit*> ( obj );
                

                Float_t eTot = tHit->GetE();    
                Float_t xOld = 0.;
                Float_t yOld = 0.;
                Float_t zOld = 0.;
                
                //printf("TrackHit Display %f %f %f %f\n", tHit->GetX(), tHit->GetY(), tHit->GetZ(), eTot);
        
                lineTracks->AddNewTrack();
                
                for (Int_t j = 0; j < tHit->GetNbHits(); ++j) {
                  Float_t x = tHit->GetHit(j)->GetX();
                  Float_t y = tHit->GetHit(j)->GetY();
                  Float_t z = tHit->GetHit(j)->GetZ();
                  Float_t e = tHit->GetHit(j)->GetE();
                  
                  // avoid first hit nil (in some case)
                  if (x == 0.0 && y == 0.0 && z == 0.0) continue;
                  
                  // put total energy for last hit
                  if (j != 0) {
                        lineTracks->AddTracklet(e, xOld, yOld, zOld, x, y, z);
                        //printf("TrackHit Display %f %f %f %f\n", x, y, z, e);
                  } else {
                        lineTracks->AddTracklet(eTot, xOld, yOld, zOld, x, y, z, true);
                        //printf("TrackHit Display %f %f %f %f\n", x, y, z, eTot);
                  }
                  xOld = tHit->GetHit(j)->GetX(); 
                  yOld = tHit->GetHit(j)->GetY(); 
                  zOld = tHit->GetHit(j)->GetZ(); 
                }
          } 
        }
        
        hitList = fAgataContainer->GetHitList(fCurrentEventId, type, false);
        if (hitList == 0x0) {
           fLog << debug << Form("Hit not available for this event in type %s", type) << dolog;
        } else {
          
          Int_t nHits = hitList->GetEntries();
          //printf("Hits display %d\n", nHits);
          for (Int_t i = 0; i < nHits; ++i) {
                
                TObject* obj = hitList->At(i);
                
                sHit = dynamic_cast<StdHit*> ( obj );
                
                // just display hits
                Float_t x = sHit->GetX();
                Float_t y = sHit->GetY();
                Float_t z = sHit->GetZ();
                Float_t e = sHit->GetE();
                //printf("Hit Display  %f %f %f\n", x, y, z);
                quadHits->AddHit(e, x, y, z);
                quadHits->QuadId(new TNamed(Form("hit %d", i), "Hit Only"));
          } 
          
        }
        // refit anyway
        quadHits->RefitPlex();
        lineTracks->RefitPlex(); 
  }
  gEve->FullRedraw3D(kFALSE);

}