Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
run_alice_esd_split.C File Reference

Detailed Description

Complex example showing ALICE ESD visualization in several views.

alice_esd_split.C - a simple event-display for ALICE ESD tracks and clusters version with several windows in the same workspace

Only standard ROOT is used to process the ALICE ESD files.

No ALICE code is needed, only four simple coordinate-transformation functions declared in this macro.

A simple geometry of 10KB, extracted from the full TGeo-geometry, is used to outline the central detectors of ALICE.

All files are access from the web by using the "CACHEREAD" option.

Automatic building of ALICE ESD class declarations and dictionaries.

ALICE ESD is a TTree containing tracks and other event-related information with one entry per event. All these classes are part of the AliROOT offline framework and are not available to standard ROOT.

To be able to access the event data in a natural way, by using data-members of classes and object containers, the header files and class dictionaries are automatically generated from the TStreamerInfo classes stored in the ESD file by using the TFile::MakeProject() function. The header files and a shared library is created in the aliesd/ directory and can be loaded dynamically into the ROOT session.

See the run_alice_esd.C macro.

Creation of simple GUI for event navigation.

Most common use of the event-display is to browse through a collection of events. Thus a simple GUI allowing this is created in the function make_gui().

Eve uses the configurable ROOT-browser as its main window and so we create an extra tab in the left working area of the browser and provide backward/forward buttons.

Event-navigation functions.

As this is a simple macro, we store the information about the current event in the global variable 'Int_t esd_event_id'. The functions for event-navigation simply modify this variable and call the load_event() function which does the following:

  1. drop the old visualization objects;
  2. retrieve given event from the ESD tree;
  3. call alice_esd_read() function to create visualization objects for the new event.

Reading of ALICE data and creation of visualization objects.

This is performed in alice_esd_read() function, with the following steps:

  1. create the track container object - TEveTrackList;
  2. iterate over the ESD tracks, create TEveTrack objects and append them to the container;
  3. instruct the container to extrapolate the tracks and set their visual attributes.
#include "aliesd/AliESDEvent.h"
#include "aliesd/AliESDRun.h"
#include "aliesd/AliESDtrack.h"
void make_gui();
void load_event();
// Configuration and global variables.
const char *esd_file_name = "http://root.cern.ch/files/alice_ESDs.root";
const char *esd_friends_file_name = "http://root.cern.ch/files/alice_ESDfriends.root";
const char *esd_geom_file_name = "http://root.cern.ch/files/alice_ESDgeometry.root";
TFile *esd_file = nullptr;
TTree *esd_tree = nullptr;
AliESDEvent *esd = nullptr;
Int_t esd_event_id = 0; // Current event id.
/******************************************************************************/
// Initialization and steering functions
/******************************************************************************/
//______________________________________________________________________________
{
// Main function, initializes the application.
//
// 1. Load the auto-generated library holding ESD classes and ESD dictionaries.
// 2. Open ESD data-files.
// 3. Load cartoon geometry.
// 4. Spawn simple GUI.
// 5. Load first event.
printf("*** Opening ESD ***\n");
if (!esd_file)
return;
printf("*** Opening ESD-friends ***\n");
return;
esd_tree = (TTree *)esd_file->Get("esdTree");
esd = (AliESDEvent *)esd_tree->GetUserInfo()->FindObject("AliESDEvent");
// Set the branch addresses.
{
TIter next(esd->fESDObjects);
while ((el = (TNamed *)next())) {
TString bname(el->GetName());
if (bname.CompareTo("AliESDfriend") == 0) {
// AliESDfriend needs some '.' magick.
esd_tree->SetBranchAddress("ESDfriend.", esd->fESDObjects->GetObjectRef(el));
} else {
esd_tree->SetBranchAddress(bname, esd->fESDObjects->GetObjectRef(el));
}
}
}
// Adapt the main frame to the screen size...
if (auto_size) {
UInt_t ww, hh;
gVirtualX->GetWindowSize(gVirtualX->GetDefaultRootWindow(), qq, qq, ww, hh);
if (screen_ratio > 1.5) {
gEve->GetBrowser()->MoveResize(100, 50, ww - 300, hh - 100);
} else {
gEve->GetBrowser()->Move(50, 50);
}
}
{ // Simple geometry
if (!geom)
return;
geom->Close();
delete geom;
}
// import the geometry in the projection managers
if (gRPhiMgr) {
a->SetNdivisions(3);
gEve->GetScenes()->FindChild("R-Phi Projection")->AddElement(a);
gRPhiMgr->ImportElements(gGeoShape);
}
if (gRhoZMgr) {
a->SetNdivisions(3);
gEve->GetScenes()->FindChild("Rho-Z Projection")->AddElement(a);
gRhoZMgr->ImportElements(gGeoShape);
}
gEve->Redraw3D(kTRUE); // Reset camera after the first event has been shown.
}
//______________________________________________________________________________
void load_event()
{
// Load event specified in global esd_event_id.
// The contents of previous event are removed.
printf("Loading event %d.\n", esd_event_id);
gTextEntry->SetTextColor(0xff0000);
gTextEntry->SetText(Form("Loading event %d...", esd_event_id));
track_list->DestroyElements();
esd_tree->GetEntry(esd_event_id);
gTextEntry->SetTextColor((Pixel_t)0x000000);
gTextEntry->SetText(Form("Event %d loaded", esd_event_id));
gROOT->ProcessLine("SplitGLView::UpdateSummary()");
}
//______________________________________________________________________________
{
// cleanup then import geometry and event
// in the projection managers
if (gRPhiMgr && top) {
gRPhiMgr->DestroyElements();
gRPhiMgr->ImportElements(gGeoShape);
gRPhiMgr->ImportElements(top);
}
if (gRhoZMgr && top) {
gRhoZMgr->DestroyElements();
gRhoZMgr->ImportElements(gGeoShape);
gRhoZMgr->ImportElements(top);
}
}
/******************************************************************************/
// GUI
/******************************************************************************/
//______________________________________________________________________________
//
// EvNavHandler class is needed to connect GUI signals.
class EvNavHandler {
public:
void Fwd()
{
if (esd_event_id < esd_tree->GetEntries() - 1) {
} else {
gTextEntry->SetTextColor(0xff0000);
gTextEntry->SetText("Already at last event");
printf("Already at last event.\n");
}
}
void Bck()
{
if (esd_event_id > 0) {
} else {
gTextEntry->SetTextColor(0xff0000);
gTextEntry->SetText("Already at first event");
printf("Already at first event.\n");
}
}
};
//______________________________________________________________________________
void make_gui()
{
// Create minimal GUI for event navigation.
gROOT->ProcessLine(".L SplitGLView.C+");
browser->ShowCloseTab(kFALSE);
browser->ExecPlugin("SplitGLView", 0, "new SplitGLView(gClient->GetRoot(), 600, 450, kTRUE)");
browser->ShowCloseTab(kTRUE);
browser->StartEmbedding(TRootBrowser::kLeft);
TGMainFrame *frmMain = new TGMainFrame(gClient->GetRoot(), 1000, 600);
frmMain->SetWindowName("XX GUI");
frmMain->SetCleanup(kDeepCleanup);
{
TString icondir(Form("%s/icons/", gSystem->Getenv("ROOTSYS")));
b = new TGPictureButton(hf, gClient->GetPicture(icondir + "GoBack.gif"));
hf->AddFrame(b, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 10, 2, 10, 10));
b->Connect("Clicked()", "EvNavHandler", fh, "Bck()");
b = new TGPictureButton(hf, gClient->GetPicture(icondir + "GoForward.gif"));
hf->AddFrame(b, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 2, 10, 10, 10));
b->Connect("Clicked()", "EvNavHandler", fh, "Fwd()");
gTextEntry->SetEnabled(kFALSE);
hf->AddFrame(gTextEntry, new TGLayoutHints(kLHintsLeft | kLHintsCenterY | kLHintsExpandX, 2, 10, 10, 10));
}
frmMain->AddFrame(hf, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 0, 0, 20, 0));
gProgress->ShowPosition(kTRUE, kFALSE, "%.0f tracks");
gProgress->SetBarColor("green");
frmMain->AddFrame(gProgress, new TGLayoutHints(kLHintsExpandX, 10, 10, 5, 5));
frmMain->MapSubwindows();
frmMain->Resize();
frmMain->MapWindow();
browser->StopEmbedding();
browser->SetTabTitle("Event Control", 0);
}
/******************************************************************************/
// Code for reading AliESD and creating visualization objects
/******************************************************************************/
kITSin = 0x0001,
kITSout = 0x0002,
kITSrefit = 0x0004,
kITSpid = 0x0008,
kTPCin = 0x0010,
kTPCout = 0x0020,
kTPCrefit = 0x0040,
kTPCpid = 0x0080,
kTRDin = 0x0100,
kTRDout = 0x0200,
kTRDrefit = 0x0400,
kTRDpid = 0x0800,
kTOFin = 0x1000,
kTOFout = 0x2000,
kTOFrefit = 0x4000,
kTOFpid = 0x8000,
kHMPIDpid = 0x20000,
kEMCALmatch = 0x40000,
kTRDbackup = 0x80000,
kTRDStop = 0x20000000,
kESDpid = 0x40000000,
kTIME = 0x80000000
};
//______________________________________________________________________________
{
// Read tracks and associated clusters from current event.
AliESDRun *esdrun = (AliESDRun *)esd->fESDObjects->FindObject("AliESDRun");
TClonesArray *tracks = (TClonesArray *)esd->fESDObjects->FindObject("Tracks");
// This needs further investigation. Clusters not shown.
// AliESDfriend *frnd = (AliESDfriend*) esd->fESDObjects->FindObject("AliESDfriend");
// printf("Friend %p, n_tracks:%d\n", frnd, frnd->fTracks.GetEntries());
if (track_list == 0) {
track_list = new TEveTrackList("ESD Tracks");
track_list->SetMainColor(6);
// track_list->SetLineWidth(2);
track_list->SetMarkerColor(kYellow);
track_list->SetMarkerStyle(4);
track_list->SetMarkerSize(0.5);
}
TEveTrackPropagator *trkProp = track_list->GetPropagator();
trkProp->SetMagField(0.1 * esdrun->fMagneticField); // kGaus to Tesla
gProgress->Reset();
gProgress->SetMax(tracks->GetEntriesFast());
for (Int_t n = 0; n < tracks->GetEntriesFast(); ++n) {
// If ITS refit failed, take track parameters at inner TPC radius.
if (!trackIsOn(at, kITSrefit)) {
tp = at->fIp;
}
track->SetAttLineAttMarker(track_list);
track_list->AddElement(track);
// This needs further investigation. Clusters not shown.
// if (frnd)
// {
// AliESDfriendTrack* ft = (AliESDfriendTrack*) frnd->fTracks->At(n);
// printf("%d friend = %p\n", ft);
// }
gProgress->Increment(1);
}
track_list->MakeTracks();
}
//______________________________________________________________________________
{
// Helper function creating TEveTrack from AliESDtrack.
//
// Optionally specific track-parameters (e.g. at TPC entry point)
// can be specified via the tp argument.
Double_t pbuf[3], vbuf[3];
if (tp == 0)
tp = at;
rt.fLabel = at->fLabel;
rt.fIndex = index;
rt.fStatus = (Int_t)at->fFlags;
rt.fSign = (tp->fP[4] > 0) ? 1 : -1;
rt.fV.Set(vbuf);
rt.fP.Set(pbuf);
Double_t mc = 0.138; // at->GetMass(); - Complicated function, requiring PID.
rt.fBeta = ep / TMath::Sqrt(ep * ep + mc * mc);
track->SetName(Form("TEveTrack %d", rt.fIndex));
track->SetStdTitle();
return track;
}
//______________________________________________________________________________
{
// Check is track-flag specified by mask are set.
return (t->fFlags & mask) > 0;
}
//______________________________________________________________________________
{
// Get global position of starting point of tp.
r[0] = tp->fX;
r[1] = tp->fP[0];
r[2] = tp->fP[1];
Double_t cs = TMath::Cos(tp->fAlpha), sn = TMath::Sin(tp->fAlpha), x = r[0];
r[0] = x * cs - r[1] * sn;
r[1] = x * sn + r[1] * cs;
}
//______________________________________________________________________________
{
// Return global momentum vector of starting point of tp.
p[0] = tp->fP[4];
p[1] = tp->fP[2];
p[2] = tp->fP[3];
Double_t pt = 1. / TMath::Abs(p[0]);
Double_t cs = TMath::Cos(tp->fAlpha), sn = TMath::Sin(tp->fAlpha);
Double_t r = TMath::Sqrt(1 - p[1] * p[1]);
p[0] = pt * (r * cs - p[1] * sn);
p[1] = pt * (p[1] * cs + r * sn);
p[2] = pt * p[2];
}
//______________________________________________________________________________
{
// Return magnitude of momentum of tp.
return TMath::Sqrt(1. + tp->fP[3] * tp->fP[3]) / TMath::Abs(tp->fP[4]);
}
#define R__EXTERN
Definition DllImport.h:26
ULong_t Pixel_t
Pixel value.
Definition GuiTypes.h:40
#define b(i)
Definition RSha256.hxx:100
#define a(i)
Definition RSha256.hxx:99
bool Bool_t
Definition RtypesCore.h:63
int Int_t
Definition RtypesCore.h:45
unsigned int UInt_t
Definition RtypesCore.h:46
float Float_t
Definition RtypesCore.h:57
constexpr Bool_t kFALSE
Definition RtypesCore.h:94
double Double_t
Definition RtypesCore.h:59
constexpr Bool_t kTRUE
Definition RtypesCore.h:93
@ kYellow
Definition Rtypes.h:66
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
R__EXTERN TEveManager * gEve
#define gClient
Definition TGClient.h:157
@ kDeepCleanup
Definition TGFrame.h:42
@ kLHintsLeft
Definition TGLayout.h:24
@ kLHintsCenterY
Definition TGLayout.h:28
@ kLHintsTop
Definition TGLayout.h:27
@ kLHintsExpandX
Definition TGLayout.h:30
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t mask
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
#define gROOT
Definition TROOT.h:406
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2489
R__EXTERN TSystem * gSystem
Definition TSystem.h:561
#define gVirtualX
Definition TVirtualX.h:337
An array of clone (identical) objects.
Specialization of TRootBrowser for Eve.
Base class for TEveUtil visualization elements, providing hierarchy management, rendering control and...
Definition TEveElement.h:36
virtual void AddElement(TEveElement *el)
Add el to the list of children.
TEveElement * FindChild(const TString &name, const TClass *cls=nullptr)
Find the first child with given name.
Globally positioned TGeoShape with rendering attributes and an optional list of daughter shape-extrac...
Wrapper for TGeoShape with absolute positioning and color attributes allowing display of extracted TG...
static TEveGeoShape * ImportShapeExtract(TEveGeoShapeExtract *gse, TEveElement *parent=nullptr)
Import a shape extract 'gse' under element 'parent'.
void AddElement(TEveElement *element, TEveElement *parent=nullptr)
Add an element.
void AddGlobalElement(TEveElement *element, TEveElement *parent=nullptr)
Add a global element, i.e.
TEveSceneList * GetScenes() const
TEveBrowser * GetBrowser() const
static TEveManager * Create(Bool_t map_window=kTRUE, Option_t *opt="FIV")
If global TEveManager* gEve is not set initialize it.
void Redraw3D(Bool_t resetCameras=kFALSE, Bool_t dropLogicals=kFALSE)
TEveEventManager * GetCurrentEvent() const
Axes for non-linear projections.
Manager class for steering of projections and managing projected objects.
A list of tracks supporting change of common attributes and selection based on track parameters.
Definition TEveTrack.h:140
Holding structure for a number of track rendering parameters.
Visual representation of a track.
Definition TEveTrack.h:33
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
Definition TFile.h:53
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
Definition TFile.cxx:4091
static Bool_t SetCacheFileDir(std::string_view cacheDir, Bool_t operateDisconnected=kTRUE, Bool_t forceCacheread=kFALSE)
Sets the directory where to locally stage/cache remote files.
Definition TFile.cxx:4634
void MoveResize(Int_t x, Int_t y, UInt_t w=0, UInt_t h=0) override
Move and/or resize the frame.
Definition TGFrame.cxx:629
void Move(Int_t x, Int_t y) override
Move frame.
Definition TGFrame.cxx:593
A composite frame that layout their children in horizontal way.
Definition TGFrame.h:385
This class describes layout hints used by the layout classes.
Definition TGLayout.h:50
Defines top level windows that interact with the system Window Manager.
Definition TGFrame.h:397
Yield an action as soon as it is clicked.
Definition TGButton.h:228
A TGTextEntry is a one line text input widget.
Definition TGTextEntry.h:24
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
Mother of all ROOT objects.
Definition TObject.h:41
Basic string class.
Definition TString.h:139
virtual const char * Getenv(const char *env)
Get environment variable.
Definition TSystem.cxx:1665
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
Definition TSystem.cxx:416
A TTree represents a columnar dataset.
Definition TTree.h:79
TPaveText * pt
Double_t x[n]
Definition legend1.C:17
const Int_t n
Definition legend1.C:16
Double_t Sqrt(Double_t x)
Returns the square root of x.
Definition TMath.h:666
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Definition TMath.h:598
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Definition TMath.h:592
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:123
void tracks()
Definition tracks.C:48
Author
Bertrand Bellenot

Definition in file run_alice_esd_split.C.