EVE/alice-macros/alieve_set_cuts.C

   1 /**************************************************************************
   2  * Copyright(c) 1998-2009, ALICE Experiment at CERN, all rights reserved. *
   3  * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
   4  * full copyright notice.                                                 *
   5  **************************************************************************/
   6
   7 // Author: Pawel Debski 2010
   8
   9 #include <TGButton.h>
  10 #include <TGComboBox.h>
  11 #include <TEveBrowser.h>
  12 #include <TGButtonGroup.h>
  13 #include <TGLabel.h>
  14 #include <TGNumberEntry.h>
  15 #include <TG3DLine.h>
  16 #include <TApplication.h>
  17 #include <TGComboBox.h>
  18 #include <TLatex.h>
  19 #include <TGSlider.h>
  20 #include "TGDoubleSlider.h"
  21 #include <TEvePointSet.h>
  22
  23 class SetCutsWindow : public TGMainFrame {
  24
  25 protected:
  26    TGCheckButton* gDrawV0s;
  27    TGCheckButton* gDrawCascades;
  28    TGCheckButton* gDrawKinks;
  29    TGCheckButton* gDrawVertex;
  30    TGCheckButton* gDrawTracklets;
  31    TGCheckButton* gDrawTracks;
  32    TGCheckButton* gDrawClusters;
  33    TGCheckButton* gDrawTracksType1;
  34    TGCheckButton* gDrawTracksType2;
  35    TGCheckButton* gDrawTracksType3;
  36    TGCheckButton* gDrawTracksType4;
  37    TGCheckButton* gDrawTracksType5;
  38    TGCheckButton* gDrawTracksType6;
  39    TGCheckButton* gDrawTracksType7;
  40    TGCheckButton* gCutOnP;
  41    TGCheckButton* gCutOnPt;
  42    TGCheckButton* gCutOnEta;
  43    TGCheckButton* gCutOnMult;
  44    TGCheckButton* gCutOnCls;
  45    TEveGDoubleValuator* gPRange;
  46    TEveGDoubleValuator* gPtRange;
  47    TEveGDoubleValuator* gEtaRange;
  48    TGHSlider* gMultRange;
  49    TGNumberEntry* gMultRangeNE;
  50    TGHSlider* gClsRange;
  51    TGNumberEntry* gClsRangeNE;
  52    TGHSlider* gPMVRange;
  53    TGLabel* gPMVRangeLabel;
  54    TGComboBox* gVectorMode;
  55    TGComboBox* gPosColorList;
  56    TGTextButton* gPosColorButton;
  57    TGComboBox* gNegColorList;
  58    TGTextButton* gNegColorButton;
  59    TGComboBox* gTrackColorScale;
  60    TGComboBox* gBkgColorList;
  61    TGTextButton* gBkgColorButton;
  62    TGLOverlayButton *gOverlayButton3D;
  63    TGLOverlayButton *gOverlayButtonRPhi;
  64    TGLOverlayButton *gOverlayButtonRhoZ;
  65    Bool_t gDrawHistograms[12];
  66
  67 public:
  68    SetCutsWindow();
  69    void MultNECallBack();
  70    void MultSliderCallBack();
  71    void ClsNECallBack();
  72    void ClsSliderCallBack();
  73    void PosTracksCallBack();
  74    void NegTracksCallBack();
  75    void BackgroundCallBack();
  76    void PMVSliderCallBack();
  77    void AddDescriptions();
  78    void MuonGeometry();
  79    void DefaultGeometry();
  80    void BrightGeometry();
  81    void TransparentGeometry();
  82    void YellowGeometry();
  83    void SaveAllViews();
  84    void Save3DView();
  85    void SaveRPhiView();
  86    void DrawPtHisto();
  87    void DrawEtaHisto();
  88    void DrawPhiHisto();
  89    void DrawPhiPtHisto();
  90    void DrawPtYHisto();
  91    void DrawEtaPhiHisto();
  92    void DrawPtHistoAll();
  93    void DrawEtaHistoAll();
  94    void DrawPhiHistoAll();
  95    void DrawPhiPtHistoAll();
  96    void DrawPtYHistoAll();
  97    void DrawEtaPhiHistoAll();
  98    void DrawHistos();
  99    void DrawHistosAll();
 100    void DrawResiduals();
 101    Int_t GetTrackColorByMomentum(Double_t, Int_t);
 102    void SetStandardCuts();
 103    void AddMomentumVectors();
 104    void SetCuts();
 105    void CloseTab();
 106
 107    ClassDef(SetCutsWindow, 0)
 108 };
 109
 110 //________________________________________________
 111
 112 namespace
 113 {
 114
 115    const char *gPictureSaveAsTypes[] = {"PNG Image", "*.png", 0, 0}; //for saving pictures
 116
 117 }
 118
 119 //________________________________________________
 120
 121 SetCutsWindow::SetCutsWindow() : TGMainFrame(gClient->GetRoot(), 10, 10, kHorizontalFrame)
 122 {
 123
 124    // Main test window.
 125
 126    gEve->GetWindowManager()->HideAllEveDecorations();
 127
 128    SetCleanup(kDeepCleanup);
 129
 130    TGTextButton *b = 0;
 131    TGLabel *label = 0;
 132    TGHorizontalFrame *hframe = 0;
 133    TGHorizontalFrame *hframeMerge = 0;
 134    TGHorizontalFrame *hframe1 = 0;
 135    TGHorizontalFrame *hframe2 = 0;
 136    TGVerticalFrame *vframe = 0;
 137
 138    gOverlayButton3D = 0;
 139    gOverlayButtonRPhi = 0;
 140    gOverlayButtonRhoZ = 0;
 141
 142    for(Int_t i = 0; i < 12; i++)
 143       gDrawHistograms[i] = kFALSE;
 144
 145    TEveBrowser *browser = gEve->GetBrowser();
 146
 147    TGShutter *mainShutter = new TGShutter(this, kSunkenFrame);
 148
 149    TGShutterItem *item1 = new TGShutterItem(mainShutter, new TGHotString("Draw Objects"), 1);
 150
 151    TGShutterItem *item2 = new TGShutterItem(mainShutter, new TGHotString("Track Cuts"), 2);
 152
 153    TGShutterItem *item3 = new TGShutterItem(mainShutter, new TGHotString("Colors"), 3);
 154
 155    TGShutterItem *item4 = new TGShutterItem(mainShutter, new TGHotString("Geometry"), 4);
 156
 157    TGShutterItem *item5 = new TGShutterItem(mainShutter, new TGHotString("Analysis"), 5);
 158
 159    TGShutterItem *item6 = new TGShutterItem(mainShutter, new TGHotString("Momentum Vectors"), 6);
 160
 161    mainShutter->AddItem(item1);
 162
 163    mainShutter->AddItem(item2);
 164
 165    mainShutter->AddItem(item3);
 166
 167    mainShutter->AddItem(item4);
 168
 169    mainShutter->AddItem(item5);
 170
 171    mainShutter->AddItem(item6);
 172
 173    AddFrame(mainShutter, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
 174
 175    TGCompositeFrame *container1 = (TGCompositeFrame *) item1->GetContainer();
 176
 177    TGCompositeFrame *container2 = (TGCompositeFrame *) item2->GetContainer();
 178
 179    TGCompositeFrame *container3 = (TGCompositeFrame *) item3->GetContainer();
 180
 181    TGCompositeFrame *container4 = (TGCompositeFrame *) item4->GetContainer();
 182
 183    TGCompositeFrame *container5 = (TGCompositeFrame *) item5->GetContainer();
 184
 185    TGCompositeFrame *container6 = (TGCompositeFrame *) item6->GetContainer();
 186
 187    // Draw Elements
 188
 189    TGVerticalFrame *drawElements = new TGVerticalFrame(container1);
 190    container1->AddFrame(drawElements, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
 191
 192    // Track Cuts
 193    TGVerticalFrame *trackCuts = new TGVerticalFrame(container2);
 194    container2->AddFrame(trackCuts, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
 195
 196    // Buttons
 197    TGVerticalFrame *buttons = new TGVerticalFrame(container3);
 198    container3->AddFrame(buttons, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
 199
 200    // Geometry
 201    TGVerticalFrame *geometry = new TGVerticalFrame(container4);
 202    container4->AddFrame(geometry, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
 203
 204    // Analysis
 205    TGVerticalFrame *analysis = new TGVerticalFrame(container5);
 206    container5->AddFrame(analysis, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
 207
 208    // Momentum Vectors
 209    TGVerticalFrame *momentumVectors = new TGVerticalFrame(container6);
 210    container6->AddFrame(momentumVectors, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
 211
 212    // DRAW ELEMENTS
 213
 214    separator = new TGHorizontal3DLine(drawElements);
 215    drawElements->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 216
 217    label = new TGLabel(drawElements, "ESD objects");
 218    drawElements->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 219
 220    separator = new TGHorizontal3DLine(drawElements);
 221    drawElements->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 222
 223    // V0s
 224
 225    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 226
 227    label = new TGLabel(hframeMerge, "V0s");
 228    gDrawV0s = new TGCheckButton(hframeMerge, "", 10);
 229    gDrawV0s->SetEnabled(kTRUE);
 230    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 231    hframeMerge->AddFrame(gDrawV0s);
 232
 233    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 234
 235    // Cascades
 236
 237    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 238
 239    label = new TGLabel(hframeMerge, "Cascades");
 240    gDrawCascades = new TGCheckButton(hframeMerge, "", 10);
 241    gDrawCascades->SetEnabled(kTRUE);
 242    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 243    hframeMerge->AddFrame(gDrawCascades);
 244
 245    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 246
 247    // Kinks
 248
 249    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 250
 251    label = new TGLabel(hframeMerge, "Kinks");
 252    gDrawKinks = new TGCheckButton(hframeMerge, "", 10);
 253    gDrawKinks->SetEnabled(kTRUE);
 254    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 255    hframeMerge->AddFrame(gDrawKinks);
 256
 257    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 258
 259    // Primary Vertex
 260
 261    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 262
 263    label = new TGLabel(hframeMerge, "Primary Vertex");
 264    gDrawVertex = new TGCheckButton(hframeMerge, "", 10);
 265    gDrawVertex->SetEnabled(kTRUE);
 266    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 267    hframeMerge->AddFrame(gDrawVertex);
 268
 269    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 270
 271    // Tracklets
 272
 273    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 274
 275    label = new TGLabel(hframeMerge, "Tracklets");
 276    gDrawTracklets = new TGCheckButton(hframeMerge, "", 10);
 277    gDrawTracklets->SetEnabled(kTRUE);
 278    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 279    hframeMerge->AddFrame(gDrawTracklets);
 280
 281    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 282
 283    // Tracks
 284
 285    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 286
 287    label = new TGLabel(hframeMerge, "Tracks");
 288    gDrawTracks = new TGCheckButton(hframeMerge, "", 10);
 289    gDrawTracks->SetEnabled(kTRUE);
 290    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 291    hframeMerge->AddFrame(gDrawTracks);
 292
 293    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 294
 295    // Clusters
 296
 297    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 298
 299    label = new TGLabel(hframeMerge, "Clusters");
 300    gDrawClusters = new TGCheckButton(hframeMerge, "", 10);
 301    gDrawClusters->SetEnabled(kTRUE);
 302    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 303    hframeMerge->AddFrame(gDrawClusters);
 304
 305    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 306
 307    // TRACK TYPES
 308
 309    separator = new TGHorizontal3DLine(drawElements);
 310    drawElements->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 311
 312    label = new TGLabel(drawElements, "Track types");
 313    drawElements->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 314
 315    separator = new TGHorizontal3DLine(drawElements);
 316    drawElements->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 317
 318    // sigma < 3
 319
 320    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 321
 322    label = new TGLabel(hframeMerge, "Sigma < 3");
 323    gDrawTracksType1 = new TGCheckButton(hframeMerge, "", 10);
 324    gDrawTracksType1->SetEnabled(kTRUE);
 325    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 326    hframeMerge->AddFrame(gDrawTracksType1);
 327
 328    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 329
 330    // 3 < sigma < 5
 331
 332    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 333
 334    label = new TGLabel(hframeMerge, "3 < Sigma < 5");
 335    gDrawTracksType2 = new TGCheckButton(hframeMerge, "", 10);
 336    gDrawTracksType2->SetEnabled(kTRUE);
 337    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 338    hframeMerge->AddFrame(gDrawTracksType2);
 339
 340    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 341
 342    // 5 < Sigma
 343
 344    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 345
 346    label = new TGLabel(hframeMerge, "5 < Sigma");
 347    gDrawTracksType3 = new TGCheckButton(hframeMerge, "", 10);
 348    gDrawTracksType3->SetEnabled(kTRUE);
 349    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 350    hframeMerge->AddFrame(gDrawTracksType3);
 351
 352    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 353
 354    // no ITS refit;
 355
 356    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 357
 358    label = new TGLabel(hframeMerge, "no ITS refit");
 359    gDrawTracksType4 = new TGCheckButton(hframeMerge, "", 10);
 360    gDrawTracksType4->SetEnabled(kTRUE);
 361    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 362    hframeMerge->AddFrame(gDrawTracksType4);
 363
 364    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 365
 366    // no TPC refit
 367
 368    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 369
 370    label = new TGLabel(hframeMerge, "no TPC refit");
 371    gDrawTracksType5 = new TGCheckButton(hframeMerge, "", 10);
 372    gDrawTracksType5->SetEnabled(kTRUE);
 373    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 374    hframeMerge->AddFrame(gDrawTracksType5);
 375
 376    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 377
 378    // ITS ncl>=3
 379
 380    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 381
 382    label = new TGLabel(hframeMerge, "ITS ncl>=3");
 383    gDrawTracksType6 = new TGCheckButton(hframeMerge, "", 10);
 384    gDrawTracksType6->SetEnabled(kTRUE);
 385    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 386    hframeMerge->AddFrame(gDrawTracksType6);
 387
 388    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 389
 390    // ITS others
 391
 392    hframeMerge = new TGHorizontalFrame(drawElements, 200, 20, kFixedWidth);
 393
 394    label = new TGLabel(hframeMerge, "ITS others");
 395    gDrawTracksType7 = new TGCheckButton(hframeMerge, "", 10);
 396    gDrawTracksType7->SetEnabled(kTRUE);
 397    hframeMerge->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 398    hframeMerge->AddFrame(gDrawTracksType7);
 399
 400    drawElements->AddFrame(hframeMerge, new TGLayoutHints(kLHintsExpandX));
 401
 402    // Main menu
 403
 404    separator = new TGHorizontal3DLine(drawElements);
 405    drawElements->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 406
 407    hframe = new TGHorizontalFrame(drawElements, 150, 20, kFixedWidth);
 408
 409    b = new TGTextButton(hframe, "Apply Cuts");
 410    b->Connect("Clicked()", "SetCutsWindow", this, "SetCuts()");
 411
 412    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 413
 414    drawElements->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 415
 416    hframe = new TGHorizontalFrame(drawElements, 150, 20, kFixedWidth);
 417
 418    b = new TGTextButton(hframe, "Close Tab");
 419    b->Connect("Clicked()", "SetCutsWindow", this, "CloseTab()");
 420
 421    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 422
 423    drawElements->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX));
 424
 425    // TRACK CUTS
 426
 427    separator = new TGHorizontal3DLine(trackCuts);
 428    trackCuts->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 429
 430    hframe = new TGHorizontalFrame(trackCuts, 200, 20, kFixedWidth);
 431
 432    gPRange = new TEveGDoubleValuator(hframe,"P range:", 40, 0);
 433    gPRange->SetNELength(6);
 434    gPRange->SetLabelWidth(50);
 435    gPRange->Build();
 436    gPRange->GetSlider()->SetWidth(180);
 437    gPRange->SetLimits(0, 5, TGNumberFormat::kNESRealTwo);
 438    gPRange->SetValues(0, 5, TGNumberFormat::kNESRealTwo);
 439
 440    gCutOnP = new TGCheckButton(hframe, "", 10);
 441    gCutOnP->SetEnabled(kTRUE);
 442
 443    hframe->AddFrame(gPRange, new TGLayoutHints(kLHintsExpandX, 10, 10, 10, 10));
 444    hframe->AddFrame(gCutOnP, new TGLayoutHints(kLHintsNormal, 10, 10, 10, 10));
 445
 446    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX));
 447
 448    // Pt
 449
 450    hframe = new TGHorizontalFrame(trackCuts, 200, 20, kFixedWidth);
 451
 452    gPtRange = new TEveGDoubleValuator(hframe,"Pt range:", 40, 0);
 453    gPtRange->SetNELength(6);
 454    gPtRange->SetLabelWidth(50);
 455    gPtRange->Build();
 456    gPtRange->GetSlider()->SetWidth(180);
 457    gPtRange->SetLimits(0, 5, TGNumberFormat::kNESRealTwo);
 458    gPtRange->SetValues(0, 5, TGNumberFormat::kNESRealTwo);
 459
 460    gCutOnPt = new TGCheckButton(hframe, "", 10);
 461    gCutOnPt->SetEnabled(kTRUE);
 462
 463    hframe->AddFrame(gPtRange, new TGLayoutHints(kLHintsExpandX, 10, 10, 10, 10));
 464    hframe->AddFrame(gCutOnPt, new TGLayoutHints(kLHintsNormal, 10, 10, 10, 10));
 465
 466    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX));
 467
 468    // Eta
 469
 470    hframe = new TGHorizontalFrame(trackCuts, 200, 20, kFixedWidth);
 471
 472    gEtaRange = new TEveGDoubleValuator(hframe,"Eta range:", 40, 0);
 473    gEtaRange->SetNELength(6);
 474    gEtaRange->SetLabelWidth(50);
 475    gEtaRange->Build();
 476    gEtaRange->GetSlider()->SetWidth(180);
 477    gEtaRange->SetLimits(-5, 5, TGNumberFormat::kNESRealTwo);
 478    gEtaRange->SetValues(-5, 5, TGNumberFormat::kNESRealTwo);
 479
 480    gCutOnEta = new TGCheckButton(hframe, "", 10);
 481    gCutOnEta->SetEnabled(kTRUE);
 482
 483    hframe->AddFrame(gEtaRange, new TGLayoutHints(kLHintsExpandX, 10, 10, 10, 10));
 484    hframe->AddFrame(gCutOnEta, new TGLayoutHints(kLHintsNormal, 10, 10, 10, 10));
 485
 486    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX));
 487
 488    // Multiplicity
 489
 490    hframe = new TGHorizontalFrame(trackCuts, 200, 20, kFixedWidth);
 491
 492    label = new TGLabel(hframe, "% Tracks displayed:");
 493
 494    gMultRangeNE = new TGNumberEntry(hframe, 0, 6);
 495    gMultRangeNE->SetNumber(100);
 496    gCutOnMult = new TGCheckButton(hframe, "", 10);
 497    gCutOnMult->SetEnabled(kTRUE);
 498
 499    hframe->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
 500    hframe->AddFrame(gMultRangeNE, new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0));
 501    hframe->AddFrame(gCutOnMult, new TGLayoutHints(kLHintsRight, 10, 10, 0, 0));//kLHintsNormal
 502
 503    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 0, 0, 10, 0));
 504
 505    hframe = new TGHorizontalFrame(trackCuts, 200, 20, kFixedWidth);
 506
 507    gMultRange = new TGHSlider(hframe,180);
 508    gMultRange->SetRange(0, 100);
 509    gMultRange->SetPosition(100);
 510    gMultRange->Connect("PositionChanged(Int_t)", "SetCutsWindow", this, "MultSliderCallBack()");
 511
 512    gMultRangeNE->Connect("ValueSet(Long_t)", "SetCutsWindow", this, "MultNECallBack()");
 513
 514    hframe->AddFrame(gMultRange, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
 515
 516    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 10));
 517
 518    // TPC Clusters
 519
 520    hframe = new TGHorizontalFrame(trackCuts, 200, 20, kFixedWidth);
 521
 522    label = new TGLabel(hframe, "TPC clusters:");
 523
 524    gClsRangeNE = new TGNumberEntry(hframe, 0, 6);
 525    gClsRangeNE->SetNumber(0);
 526    gClsRangeNE->Connect("ValueSet(Long_t)", "SetCutsWindow", this, "ClsNECallBack()");
 527
 528    gCutOnCls = new TGCheckButton(hframe, "", 10);
 529    gCutOnCls->SetEnabled(kTRUE);
 530
 531    hframe->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
 532    hframe->AddFrame(gClsRangeNE, new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0));
 533    hframe->AddFrame(gCutOnCls, new TGLayoutHints(kLHintsRight, 10, 10, 0, 0));//kLHintsNormal
 534
 535    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 0, 0, 10, 0));
 536
 537    hframe = new TGHorizontalFrame(trackCuts, 200, 20, kFixedWidth);
 538
 539    gClsRange = new TGHSlider(hframe,180);
 540    gClsRange->SetRange(0, 200);
 541    gClsRange->SetPosition(0);
 542    gClsRange->Connect("PositionChanged(Int_t)", "SetCutsWindow", this, "ClsSliderCallBack()");
 543
 544    hframe->AddFrame(gClsRange, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
 545
 546    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 10));
 547
 548    separator = new TGHorizontal3DLine(trackCuts);
 549    trackCuts->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 550
 551    // Standard cuts
 552
 553    hframe = new TGHorizontalFrame(trackCuts, 100, 20, kFixedWidth);
 554
 555    b = new TGTextButton(hframe, "Standard Cuts");
 556    b->Connect("Clicked()", "SetCutsWindow", this, "SetStandardCuts()");
 557
 558    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 559
 560    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 10, 10, 10, 10));
 561
 562    // Main menu
 563
 564    separator = new TGHorizontal3DLine(trackCuts);
 565    trackCuts->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 566
 567    hframe = new TGHorizontalFrame(trackCuts, 150, 20, kFixedWidth);
 568
 569    b = new TGTextButton(hframe, "Apply Cuts");
 570    b->Connect("Clicked()", "SetCutsWindow", this, "SetCuts()");
 571
 572    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 573
 574    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 575
 576    hframe = new TGHorizontalFrame(trackCuts, 150, 20, kFixedWidth);
 577
 578    b = new TGTextButton(hframe, "Close Tab");
 579    b->Connect("Clicked()", "SetCutsWindow", this, "CloseTab()");
 580
 581    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 582
 583    trackCuts->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX));
 584
 585    // BUTTONS
 586
 587    separator = new TGHorizontal3DLine(buttons);
 588    buttons->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 589
 590    // Positive tracks colorset
 591
 592    hframe = new TGHorizontalFrame(buttons, 200, 20, kFixedWidth);
 593
 594    label = new TGLabel(hframe, "Positive tracks:");
 595    hframe->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 596
 597    gPosColorList = new TGComboBox(hframe);
 598    gPosColorList->AddEntry("Mixed 1", 0);
 599    gPosColorList->AddEntry("Mixed 2", 1);
 600    gPosColorList->AddEntry("Cyan-Blue", 2);
 601    gPosColorList->AddEntry("Yellow-Red", 3);
 602    gPosColorList->AddEntry("Red 1", 4);
 603    gPosColorList->AddEntry("Red 2", 5);
 604    gPosColorList->AddEntry("Orange 1", 6);
 605    gPosColorList->AddEntry("Orange 2", 7);
 606    gPosColorList->AddEntry("Yellow 1", 8);
 607    gPosColorList->AddEntry("Yellow 2", 9);
 608    gPosColorList->AddEntry("Spring 1", 10);
 609    gPosColorList->AddEntry("Spring 2", 11);
 610    gPosColorList->AddEntry("Green 1", 12);
 611    gPosColorList->AddEntry("Green 2", 13);
 612    gPosColorList->AddEntry("Teal 1", 14);
 613    gPosColorList->AddEntry("Teal 2", 15);
 614    gPosColorList->AddEntry("Cyan 1", 16);
 615    gPosColorList->AddEntry("Cyan 2", 17);
 616    gPosColorList->AddEntry("Azure 1", 18);
 617    gPosColorList->AddEntry("Azure 2", 19);
 618    gPosColorList->AddEntry("Blue 1", 20);
 619    gPosColorList->AddEntry("Blue 2", 21);
 620    gPosColorList->AddEntry("Violet 1", 22);
 621    gPosColorList->AddEntry("Violet 2", 23);
 622    gPosColorList->AddEntry("Magenta 1", 24);
 623    gPosColorList->AddEntry("Magenta 2", 25);
 624    gPosColorList->AddEntry("Pink 1", 26);
 625    gPosColorList->AddEntry("Pink 2", 27);
 626
 627    gPosColorList->Select(0, kFALSE);
 628
 629    gPosColorList->Resize(100,20);
 630    gPosColorList->Connect("Selected(Int_t)", "SetCutsWindow", this, "PosTracksCallBack()");
 631    hframe->AddFrame(gPosColorList, new TGLayoutHints(kLHintsExpandX));
 632
 633    gPosColorButton = new TGTextButton(hframe, "    ");
 634
 635    hframe->AddFrame(gPosColorButton, new TGLayoutHints(kLHintsNormal, 5, 5, 1, 1));
 636
 637    buttons->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 638
 639    // Negative tracks colorset
 640
 641    hframe = new TGHorizontalFrame(buttons, 200, 20, kFixedWidth);
 642
 643    label = new TGLabel(hframe, "Negative tracks:");
 644    hframe->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 645
 646    gNegColorList = new TGComboBox(hframe);
 647    gNegColorList->AddEntry("Mixed 1", 0);
 648    gNegColorList->AddEntry("Mixed 2", 1);
 649    gNegColorList->AddEntry("Cyan-Blue", 2);
 650    gNegColorList->AddEntry("Yellow-Red", 3);
 651    gNegColorList->AddEntry("Red 1", 4);
 652    gNegColorList->AddEntry("Red 2", 5);
 653    gNegColorList->AddEntry("Orange 1", 6);
 654    gNegColorList->AddEntry("Orange 2", 7);
 655    gNegColorList->AddEntry("Yellow 1", 8);
 656    gNegColorList->AddEntry("Yellow 2", 9);
 657    gNegColorList->AddEntry("Spring 1", 10);
 658    gNegColorList->AddEntry("Spring 2", 11);
 659    gNegColorList->AddEntry("Green 1", 12);
 660    gNegColorList->AddEntry("Green 2", 13);
 661    gNegColorList->AddEntry("Teal 1", 14);
 662    gNegColorList->AddEntry("Teal 2", 15);
 663    gNegColorList->AddEntry("Cyan 1", 16);
 664    gNegColorList->AddEntry("Cyan 2", 17);
 665    gNegColorList->AddEntry("Azure 1", 18);
 666    gNegColorList->AddEntry("Azure 2", 19);
 667    gNegColorList->AddEntry("Blue 1", 20);
 668    gNegColorList->AddEntry("Blue 2", 21);
 669    gNegColorList->AddEntry("Violet 1", 22);
 670    gNegColorList->AddEntry("Violet 2", 23);
 671    gNegColorList->AddEntry("Magenta 1", 24);
 672    gNegColorList->AddEntry("Magenta 2", 25);
 673    gNegColorList->AddEntry("Pink 1", 26);
 674    gNegColorList->AddEntry("Pink 2", 27);
 675
 676    gNegColorList->Select(0, kFALSE);
 677
 678    gNegColorList->Resize(100,20);
 679    gNegColorList->Connect("Selected(Int_t)", "SetCutsWindow", this, "NegTracksCallBack()");
 680    hframe->AddFrame(gNegColorList, new TGLayoutHints(kLHintsExpandX));
 681
 682    gNegColorButton = new TGTextButton(hframe, "    ");
 683    hframe->AddFrame(gNegColorButton, new TGLayoutHints(kLHintsNormal, 5, 5, 1, 1));
 684
 685    buttons->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 686
 687    // Color scale
 688
 689    hframe = new TGHorizontalFrame(buttons, 200, 20, kFixedWidth);
 690
 691    label = new TGLabel(hframe, "Color scale:");
 692    hframe->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 693
 694    gTrackColorScale = new TGComboBox(hframe);
 695    gTrackColorScale->AddEntry("Linear", 1);
 696    gTrackColorScale->AddEntry("Logarithmic", 2);
 697    gTrackColorScale->AddEntry("Power", 3);
 698
 699    gTrackColorScale->Select(1, kFALSE);
 700
 701    gTrackColorScale->Resize(100,20);
 702    hframe->AddFrame(gTrackColorScale, new TGLayoutHints(kLHintsExpandX));
 703
 704    label = new TGLabel(hframe, "      ");
 705    hframe->AddFrame(label, new TGLayoutHints(kLHintsNormal, 5, 5, 1, 1));
 706
 707    buttons->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 708
 709
 710    // Background color
 711
 712    hframe = new TGHorizontalFrame(buttons, 200, 20, kFixedWidth);
 713
 714    label = new TGLabel(hframe, "Background:");
 715    hframe->AddFrame(label, new TGLayoutHints(kLHintsExpandX));
 716
 717    gBkgColorList = new TGComboBox(hframe);
 718    gBkgColorList->AddEntry("White", 1);
 719    gBkgColorList->AddEntry("Black", 2);
 720
 721    gBkgColorList->Select(1, kFALSE);
 722
 723    gBkgColorList->Resize(100,20);
 724    gBkgColorList->Connect("Selected(Int_t)", "SetCutsWindow", this, "BackgroundCallBack()");
 725    hframe->AddFrame(gBkgColorList, new TGLayoutHints(kLHintsExpandX));
 726
 727    gBkgColorButton = new TGTextButton(hframe, "    ");
 728    hframe->AddFrame(gBkgColorButton, new TGLayoutHints(kLHintsNormal, 5, 5, 1, 1));
 729
 730    buttons->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 731
 732    // Main menu
 733
 734    separator = new TGHorizontal3DLine(buttons);
 735    buttons->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 736
 737    hframe = new TGHorizontalFrame(buttons, 150, 20, kFixedWidth);
 738
 739    b = new TGTextButton(hframe, "Apply Cuts");
 740    b->Connect("Clicked()", "SetCutsWindow", this, "SetCuts()");
 741
 742    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 743
 744    buttons->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 745
 746    hframe = new TGHorizontalFrame(buttons, 150, 20, kFixedWidth);
 747
 748    b = new TGTextButton(hframe, "Close Tab");
 749    b->Connect("Clicked()", "SetCutsWindow", this, "CloseTab()");
 750
 751    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 752
 753    buttons->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX));
 754
 755    // GEOMETRY
 756
 757    separator = new TGHorizontal3DLine(geometry);
 758    geometry->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 759
 760    label = new TGLabel(geometry, "Geometries");
 761    geometry->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 762
 763    // Geometry
 764
 765    separator = new TGHorizontal3DLine(geometry);
 766    geometry->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 767
 768    hframe = new TGHorizontalFrame(geometry, 200, 20, kFixedWidth);
 769
 770    b = new TGTextButton(hframe, "MUON arm");
 771    b->Connect("Clicked()", "SetCutsWindow", this, "MuonGeometry()");
 772    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 773
 774    geometry->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 775
 776    hframe = new TGHorizontalFrame(geometry, 200, 20, kFixedWidth);
 777
 778    b = new TGTextButton(hframe, "Default");
 779    b->Connect("Clicked()", "SetCutsWindow", this, "DefaultGeometry()");
 780    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 781
 782    b = new TGTextButton(hframe, "Bright");
 783    b->Connect("Clicked()", "SetCutsWindow", this, "BrightGeometry()");
 784    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 785
 786    geometry->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 787
 788    hframe = new TGHorizontalFrame(geometry, 200, 20, kFixedWidth);
 789
 790    b = new TGTextButton(hframe, "Transparent");
 791    b->Connect("Clicked()", "SetCutsWindow", this, "TransparentGeometry()");
 792    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 793
 794    b = new TGTextButton(hframe, "Yellow");
 795    b->Connect("Clicked()", "SetCutsWindow", this, "YellowGeometry()");
 796    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 797
 798    geometry->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 799
 800    // Snapshots
 801
 802    separator = new TGHorizontal3DLine(geometry);
 803    geometry->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 804
 805    label = new TGLabel(geometry, "Snapshots");
 806    geometry->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 807
 808    separator = new TGHorizontal3DLine(geometry);
 809    geometry->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 810
 811    hframe = new TGHorizontalFrame(geometry, 200, 20, kFixedWidth);
 812
 813    b = new TGTextButton(hframe, "Save all Views");
 814    b->Connect("Clicked()", "SetCutsWindow", this, "SaveAllViews()");
 815    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 816
 817    geometry->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 818
 819    hframe = new TGHorizontalFrame(geometry, 200, 20, kFixedWidth);
 820
 821    b = new TGTextButton(hframe, "3D View");
 822    b->Connect("Clicked()", "SetCutsWindow", this, "Save3DView()");
 823    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 824
 825    b = new TGTextButton(hframe, "RPhi");
 826    b->Connect("Clicked()", "SetCutsWindow", this, "SaveRPhiView()");
 827    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 828
 829    b = new TGTextButton(hframe, "RhoZ");
 830    b->Connect("Clicked()", "SetCutsWindow", this, "SaveRhoZView()");
 831    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 832
 833    geometry->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 834
 835    // Main menu
 836
 837    separator = new TGHorizontal3DLine(geometry);
 838    geometry->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 839
 840    hframe = new TGHorizontalFrame(geometry, 150, 20, kFixedWidth);
 841
 842    b = new TGTextButton(hframe, "Apply Cuts");
 843    b->Connect("Clicked()", "SetCutsWindow", this, "SetCuts()");
 844
 845    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 846
 847    geometry->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 848
 849    hframe = new TGHorizontalFrame(geometry, 150, 20, kFixedWidth);
 850
 851    b = new TGTextButton(hframe, "Close Tab");
 852    b->Connect("Clicked()", "SetCutsWindow", this, "CloseTab()");
 853
 854    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 855
 856    geometry->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX));
 857
 858    // ANALYSIS
 859
 860    separator = new TGHorizontal3DLine(analysis);
 861    analysis->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 862
 863    label = new TGLabel(analysis, "Single Event Histograms");
 864    analysis->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 865
 866    // Single Event
 867
 868    separator = new TGHorizontal3DLine(analysis);
 869    analysis->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 870
 871    hframe = new TGHorizontalFrame(analysis, 200, 20, kFixedWidth);
 872
 873    b = new TGTextButton(hframe, "Pt");
 874    b->AllowStayDown(kTRUE);
 875    b->Connect("Clicked()", "SetCutsWindow", this, "DrawPtHisto()");
 876    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 877
 878    b = new TGTextButton(hframe, "Eta");
 879    b->AllowStayDown(kTRUE);
 880    b->Connect("Clicked()", "SetCutsWindow", this, "DrawEtaHisto()");
 881    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 882
 883    b = new TGTextButton(hframe, "Phi");
 884    b->AllowStayDown(kTRUE);
 885    b->Connect("Clicked()", "SetCutsWindow", this, "DrawPhiHisto()");
 886    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 887
 888    analysis->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));
 889
 890    hframe = new TGHorizontalFrame(analysis, 200, 20, kFixedWidth);
 891
 892    b = new TGTextButton(hframe, "Phi-Pt");
 893    b->AllowStayDown(kTRUE);
 894    b->Connect("Clicked()", "SetCutsWindow", this, "DrawPhiPtHisto()");
 895    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 896
 897    b = new TGTextButton(hframe, "Pt-Y");
 898    b->AllowStayDown(kTRUE);
 899    b->Connect("Clicked()", "SetCutsWindow", this, "DrawPtYHisto()");
 900    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 901
 902    b = new TGTextButton(hframe, "Eta-Phi");
 903    b->AllowStayDown(kTRUE);
 904    b->Connect("Clicked()", "SetCutsWindow", this, "DrawEtaPhiHisto()");
 905    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 906
 907    analysis->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));
 908
 909    hframe = new TGHorizontalFrame(analysis, 200, 20, kFixedWidth);
 910
 911    b = new TGTextButton(hframe, "Draw Histograms");
 912    b->Connect("Clicked()", "SetCutsWindow", this, "DrawHistos()");
 913    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 914
 915    analysis->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 916
 917    // All Events
 918
 919    separator = new TGHorizontal3DLine(analysis);
 920    analysis->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 921
 922    label = new TGLabel(analysis, "All Events Histograms");
 923    analysis->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 924
 925    separator = new TGHorizontal3DLine(analysis);
 926    analysis->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 927
 928    hframe = new TGHorizontalFrame(analysis, 200, 20, kFixedWidth);
 929
 930    b = new TGTextButton(hframe, "Pt");
 931    b->AllowStayDown(kTRUE);
 932    b->Connect("Clicked()", "SetCutsWindow", this, "DrawPtHistoAll()");
 933    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 934
 935    b = new TGTextButton(hframe, "Eta");
 936    b->AllowStayDown(kTRUE);
 937    b->Connect("Clicked()", "SetCutsWindow", this, "DrawEtaHistoAll()");
 938    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 939
 940    b = new TGTextButton(hframe, "Phi");
 941    b->AllowStayDown(kTRUE);
 942    b->Connect("Clicked()", "SetCutsWindow", this, "DrawPhiHistoAll()");
 943    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 944
 945    analysis->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));
 946
 947    hframe = new TGHorizontalFrame(analysis, 200, 20, kFixedWidth);
 948
 949    b = new TGTextButton(hframe, "Phi-Pt");
 950    b->AllowStayDown(kTRUE);
 951    b->Connect("Clicked()", "SetCutsWindow", this, "DrawPhiPtHistoAll()");
 952    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 953
 954    b = new TGTextButton(hframe, "Pt-Y");
 955    b->AllowStayDown(kTRUE);
 956    b->Connect("Clicked()", "SetCutsWindow", this, "DrawPtYHistoAll()");
 957    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 958
 959    b = new TGTextButton(hframe, "Eta-Phi");
 960    b->AllowStayDown(kTRUE);
 961    b->Connect("Clicked()", "SetCutsWindow", this, "DrawEtaPhiHistoAll()");
 962    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
 963
 964    analysis->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));
 965
 966    hframe = new TGHorizontalFrame(analysis, 200, 20, kFixedWidth);
 967
 968    b = new TGTextButton(hframe, "Draw Histograms");
 969    b->Connect("Clicked()", "SetCutsWindow", this, "DrawHistosAll()");
 970    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 971
 972    analysis->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 973
 974    separator = new TGHorizontal3DLine(analysis);
 975    analysis->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 976
 977    label = new TGLabel(analysis, "Residuals");
 978    analysis->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 979
 980    separator = new TGHorizontal3DLine(analysis);
 981    analysis->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 982
 983    hframe = new TGHorizontalFrame(analysis, 200, 20, kFixedWidth);
 984
 985    b = new TGTextButton(hframe, "Draw Residuals");
 986    b->Connect("Clicked()", "SetCutsWindow", this, "DrawResiduals()");
 987    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 988
 989    analysis->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 990
 991    // Main menu
 992
 993    separator = new TGHorizontal3DLine(analysis);
 994    analysis->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
 995
 996    hframe = new TGHorizontalFrame(analysis, 150, 20, kFixedWidth);
 997
 998    b = new TGTextButton(hframe, "Apply Cuts");
 999    b->Connect("Clicked()", "SetCutsWindow", this, "SetCuts()");
1000
1001    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
1002
1003    analysis->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1004
1005    hframe = new TGHorizontalFrame(analysis, 150, 20, kFixedWidth);
1006
1007    b = new TGTextButton(hframe, "Close Tab");
1008    b->Connect("Clicked()", "SetCutsWindow", this, "CloseTab()");
1009
1010    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1011
1012    analysis->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX));
1013
1014    // MOMENTUM VECTORS
1015
1016    // Draw momentum vectors
1017
1018    separator = new TGHorizontal3DLine(momentumVectors);
1019    momentumVectors->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1020
1021    label = new TGLabel(momentumVectors, "Draw Momentum Vectors");
1022    momentumVectors->AddFrame(label, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1023
1024    separator = new TGHorizontal3DLine(momentumVectors);
1025    momentumVectors->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1026
1027    hframe = new TGHorizontalFrame(momentumVectors, 200, 20, kFixedWidth);
1028
1029    label = new TGLabel(hframe, "Scale:");
1030    hframe->AddFrame(label, new TGLayoutHints(kLHintsNormal, 5, 5, 0, 0));
1031
1032    gVectorMode = new TGComboBox(hframe);
1033    gVectorMode->AddEntry("Log scale", 1);
1034    gVectorMode->AddEntry("maxP -> 600cm", 2);
1035    gVectorMode->AddEntry("1GeV -> 100cm", 3);
1036    gVectorMode->Resize(150,20);
1037    gVectorMode->Select(2);
1038
1039    hframe->AddFrame(gVectorMode, new TGLayoutHints(kLHintsNormal, 0, 5, 0, 0));
1040
1041    momentumVectors->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1042
1043    hframe = new TGHorizontalFrame(momentumVectors, 200, 20, kFixedWidth);
1044
1045    label = new TGLabel(hframe, "Minimal P: ");
1046    hframe->AddFrame(label, new TGLayoutHints(kLHintsNormal, 5, 5, 0, 0));
1047
1048    gPMVRangeLabel = new TGLabel(hframe, "0.0");
1049    hframe->AddFrame(gPMVRangeLabel, new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0));
1050
1051    label = new TGLabel(hframe, "GeV/c");
1052    hframe->AddFrame(label, new TGLayoutHints(kLHintsNormal, 1, 0, 0, 0));
1053
1054    momentumVectors->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1055
1056    hframe = new TGHorizontalFrame(momentumVectors, 200, 20, kFixedWidth);
1057
1058    gPMVRange = new TGHSlider(hframe,180);
1059    gPMVRange->SetRange(0, 50);
1060    gPMVRange->SetPosition(0);
1061    gPMVRange->Connect("PositionChanged(Int_t)", "SetCutsWindow", this, "PMVSliderCallBack()");
1062
1063    hframe->AddFrame(gPMVRange, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1064
1065    momentumVectors->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1066
1067    hframe = new TGHorizontalFrame(momentumVectors, 150, 20, kFixedWidth);
1068
1069    b = new TGTextButton(hframe, "Draw");
1070    b->Connect("Clicked()", "SetCutsWindow", this, "AddMomentumVectors()");
1071    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));
1072
1073    momentumVectors->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1074
1075    // Main menu
1076
1077    separator = new TGHorizontal3DLine(momentumVectors);
1078    momentumVectors->AddFrame(separator, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1079
1080    hframe = new TGHorizontalFrame(momentumVectors, 150, 20, kFixedWidth);
1081
1082    b = new TGTextButton(hframe, "Apply Cuts");
1083    b->Connect("Clicked()", "SetCutsWindow", this, "SetCuts()");
1084
1085    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX));
1086
1087    momentumVectors->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1088
1089    hframe = new TGHorizontalFrame(momentumVectors, 150, 20, kFixedWidth);
1090
1091    b = new TGTextButton(hframe, "Close Tab");
1092    b->Connect("Clicked()", "SetCutsWindow", this, "CloseTab()");
1093
1094    hframe->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5));
1095
1096    momentumVectors->AddFrame(hframe, new TGLayoutHints(kLHintsExpandX));
1097
1098    // FINAL STUFF
1099
1100    Resize();
1101
1102    MapSubwindows();
1103
1104    SetWMSizeHints(GetDefaultWidth(), GetDefaultHeight(), 1000, 1000, 0 ,0);
1105    SetWindowName("Pb-Pb set");
1106    MapRaised();
1107
1108 }
1109
1110 //______________________________________________________________________________
1111
1112 void SetCutsWindow::MultNECallBack()
1113 {
1114
1115    Double_t entry;
1116
1117    entry = gMultRangeNE->GetNumber();
1118    gMultRange->SetPosition(entry);
1119
1120    return;
1121
1122 }
1123
1124 //______________________________________________________________________________
1125
1126 void SetCutsWindow::MultSliderCallBack()
1127 {
1128
1129    Double_t entry;
1130
1131    entry = gMultRange->GetPosition();
1132    gMultRangeNE->SetNumber(entry);
1133
1134    return;
1135
1136 }
1137
1138 //______________________________________________________________________________
1139
1140 void SetCutsWindow::ClsNECallBack()
1141 {
1142 M
1143    Double_t entry;
1144
1145    entry = gClsRangeNE->GetNumber();
1146    gClsRange->SetPosition(entry);
1147
1148    return;
1149
1150 }
1151
1152 //______________________________________________________________________________
1153
1154 void SetCutsWindow::ClsSliderCallBack()
1155 {
1156
1157    Double_t entry;
1158
1159    entry = gClsRange->GetPosition();
1160    gClsRangeNE->SetNumber(entry);
1161
1162    return;
1163
1164 }
1165
1166 //______________________________________________________________________________
1167
1168 void SetCutsWindow::PosTracksCallBack()
1169 {
1170
1171    switch(gPosColorList->GetSelected())
1172    {
1173       case 0:
1174          gPosColorButton->SetBackgroundColor(gROOT->GetColor(18)->GetPixel());
1175          gPosColorButton->SetText("M 1");
1176          break;
1177
1178       case 1:
1179          gPosColorButton->SetBackgroundColor(gROOT->GetColor(18)->GetPixel());
1180          gPosColorButton->SetText("M 2");
1181          break;
1182
1183       case 2:
1184          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kAzure)->GetPixel());
1185          gPosColorButton->SetText("   ");
1186          break;
1187
1188       case 3:
1189          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kOrange)->GetPixel());
1190          gPosColorButton->SetText("   ");
1191          break;
1192
1193       case 4:
1194          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kRed)->GetPixel());
1195          gPosColorButton->SetText(" 1 ");
1196          break;
1197
1198       case 5:
1199          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kRed)->GetPixel());
1200          gPosColorButton->SetText(" 2 ");
1201          break;
1202
1203       case 6:
1204          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kOrange)->GetPixel());
1205          gPosColorButton->SetText(" 1 ");
1206          break;
1207
1208       case 7:
1209          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kOrange)->GetPixel());
1210          gPosColorButton->SetText(" 2 ");
1211          break;
1212
1213       case 8:
1214          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kYellow)->GetPixel());
1215          gPosColorButton->SetText(" 1 ");
1216          break;
1217
1218       case 9:
1219          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kYellow)->GetPixel());
1220          gPosColorButton->SetText(" 2 ");
1221          break;
1222
1223       case 10:
1224          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kSpring)->GetPixel());
1225          gPosColorButton->SetText(" 1 ");
1226          break;
1227
1228       case 11:
1229          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kSpring)->GetPixel());
1230          gPosColorButton->SetText(" 2 ");
1231          break;
1232
1233       case 12:
1234          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kGreen)->GetPixel());
1235          gPosColorButton->SetText(" 1 ");
1236          break;
1237
1238       case 13:
1239          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kGreen)->GetPixel());
1240          gPosColorButton->SetText(" 2 ");
1241          break;
1242
1243       case 14:
1244          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kTeal)->GetPixel());
1245          gPosColorButton->SetText(" 1 ");
1246          break;
1247
1248       case 15:
1249          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kTeal)->GetPixel());
1250          gPosColorButton->SetText(" 2 ");
1251          break;
1252
1253       case 16:
1254          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kCyan)->GetPixel());
1255          gPosColorButton->SetText(" 1 ");
1256          break;
1257
1258       case 17:
1259          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kCyan)->GetPixel());
1260          gPosColorButton->SetText(" 2 ");
1261          break;
1262
1263       case 18:
1264          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kAzure)->GetPixel());
1265          gPosColorButton->SetText(" 1 ");
1266          break;
1267
1268       case 19:
1269          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kAzure)->GetPixel());
1270          gPosColorButton->SetText(" 2 ");
1271          break;
1272
1273       case 20:
1274          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kBlue)->GetPixel());
1275          gPosColorButton->SetText(" 1 ");
1276          break;
1277
1278       case 21:
1279          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kBlue)->GetPixel());
1280          gPosColorButton->SetText(" 2 ");
1281          break;
1282
1283       case 22:
1284          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kViolet)->GetPixel());
1285          gPosColorButton->SetText(" 1 ");
1286          break;
1287
1288       case 23:
1289          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kViolet)->GetPixel());
1290          gPosColorButton->SetText(" 2 ");
1291          break;
1292
1293       case 24:
1294          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kMagenta)->GetPixel());
1295          gPosColorButton->SetText(" 1 ");
1296          break;
1297
1298       case 25:
1299          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kMagenta)->GetPixel());
1300          gPosColorButton->SetText(" 2 ");
1301          break;
1302
1303       case 26:
1304          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kPink)->GetPixel());
1305          gPosColorButton->SetText(" 1 ");
1306          break;
1307
1308       case 27:
1309          gPosColorButton->SetBackgroundColor(gROOT->GetColor(kPink)->GetPixel());
1310          gPosColorButton->SetText(" 2 ");
1311          break;
1312
1313       default:
1314          gPosColorButton->SetBackgroundColor(gROOT->GetColor(18)->GetPixel());
1315          gPosColorButton->SetText("M 1");
1316          break;
1317
1318    }
1319
1320    return;
1321
1322 }
1323
1324 void SetCutsWindow::NegTracksCallBack()
1325 {
1326
1327    switch(gNegColorList->GetSelected())
1328    {
1329       case 0:
1330          gNegColorButton->SetBackgroundColor(gROOT->GetColor(18)->GetPixel());
1331          gNegColorButton->SetText("M 1");
1332          break;
1333
1334       case 1:
1335          gNegColorButton->SetBackgroundColor(gROOT->GetColor(18)->GetPixel());
1336          gNegColorButton->SetText("M 2");
1337          break;
1338
1339       case 2:
1340          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kAzure)->GetPixel());
1341          gNegColorButton->SetText("   ");
1342          break;
1343
1344       case 3:
1345          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kOrange)->GetPixel());
1346          gNegColorButton->SetText("   ");
1347          break;
1348
1349       case 4:
1350          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kRed)->GetPixel());
1351          gNegColorButton->SetText(" 1 ");
1352          break;
1353
1354       case 5:
1355          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kRed)->GetPixel());
1356          gNegColorButton->SetText(" 2 ");
1357          break;
1358
1359       case 6:
1360          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kOrange)->GetPixel());
1361          gNegColorButton->SetText(" 1 ");
1362          break;
1363
1364       case 7:
1365          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kOrange)->GetPixel());
1366          gNegColorButton->SetText(" 2 ");
1367          break;
1368
1369       case 8:
1370          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kYellow)->GetPixel());
1371          gNegColorButton->SetText(" 1 ");
1372          break;
1373
1374       case 9:
1375          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kYellow)->GetPixel());
1376          gNegColorButton->SetText(" 2 ");
1377          break;
1378
1379       case 10:
1380          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kSpring)->GetPixel());
1381          gNegColorButton->SetText(" 1 ");
1382          break;
1383
1384       case 11:
1385          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kSpring)->GetPixel());
1386          gNegColorButton->SetText(" 2 ");
1387          break;
1388
1389       case 12:
1390          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kGreen)->GetPixel());
1391          gNegColorButton->SetText(" 1 ");
1392          break;
1393
1394       case 13:
1395          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kGreen)->GetPixel());
1396          gNegColorButton->SetText(" 2 ");
1397          break;
1398
1399       case 14:
1400          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kTeal)->GetPixel());
1401          gNegColorButton->SetText(" 1 ");
1402          break;
1403
1404       case 15:
1405          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kTeal)->GetPixel());
1406          gNegColorButton->SetText(" 2 ");
1407          break;
1408
1409       case 16:
1410          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kCyan)->GetPixel());
1411          gNegColorButton->SetText(" 1 ");
1412          break;
1413
1414       case 17:
1415          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kCyan)->GetPixel());
1416          gNegColorButton->SetText(" 2 ");
1417          break;
1418
1419       case 18:
1420          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kAzure)->GetPixel());
1421          gNegColorButton->SetText(" 1 ");
1422          break;
1423
1424       case 19:
1425          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kAzure)->GetPixel());
1426          gNegColorButton->SetText(" 2 ");
1427          break;
1428
1429       case 20:
1430          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kBlue)->GetPixel());
1431          gNegColorButton->SetText(" 1 ");
1432          break;
1433
1434       case 21:
1435          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kBlue)->GetPixel());
1436          gNegColorButton->SetText(" 2 ");
1437          break;
1438
1439       case 22:
1440          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kViolet)->GetPixel());
1441          gNegColorButton->SetText(" 1 ");
1442          break;
1443
1444       case 23:
1445          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kViolet)->GetPixel());
1446          gNegColorButton->SetText(" 2 ");
1447          break;
1448
1449       case 24:
1450          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kMagenta)->GetPixel());
1451          gNegColorButton->SetText(" 1 ");
1452          break;
1453
1454       case 25:
1455          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kMagenta)->GetPixel());
1456          gNegColorButton->SetText(" 2 ");
1457          break;
1458
1459       case 26:
1460          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kPink)->GetPixel());
1461          gNegColorButton->SetText(" 1 ");
1462          break;
1463
1464       case 27:
1465          gNegColorButton->SetBackgroundColor(gROOT->GetColor(kPink)->GetPixel());
1466          gNegColorButton->SetText(" 2 ");
1467          break;
1468
1469       default:
1470          gNegColorButton->SetBackgroundColor(gROOT->GetColor(18)->GetPixel());
1471          gNegColorButton->SetText("M 1");
1472          break;
1473
1474    }
1475
1476    return;
1477
1478 }
1479
1480 void SetCutsWindow::BackgroundCallBack()
1481 {
1482
1483    switch(gBkgColorList->GetSelected())
1484    {
1485
1486       case 1:
1487          gBkgColorButton->SetBackgroundColor(gROOT->GetColor(0)->GetPixel());
1488          gBkgColorButton->SetText("    ");
1489
1490          if(!gEve->GetViewers()->UseLightColorSet())
1491            gEve->GetViewers()->SwitchColorSet(); //white background
1492
1493          break;
1494
1495       case 2:
1496          gBkgColorButton->SetBackgroundColor(gROOT->GetColor(1)->GetPixel());
1497          gBkgColorButton->SetText("    ");
1498
1499          if(gEve->GetViewers()->UseLightColorSet())
1500             gEve->GetViewers()->SwitchColorSet(); //black background
1501
1502          break;
1503
1504       default:
1505          gBkgColorButton->SetBackgroundColor(gROOT->GetColor(18)->GetPixel());
1506          gBkgColorButton->SetText("    ");
1507
1508          break;
1509
1510    }
1511
1512    return;
1513
1514 }
1515
1516 //______________________________________________________________________________
1517
1518 void SetCutsWindow::PMVSliderCallBack()
1519 {
1520
1521    Double_t entry;
1522
1523    entry = gPMVRange->GetPosition();
1524    gPMVRangeLabel->SetText(Form("%2.1f",0.1*entry));
1525
1526    return;
1527
1528 }
1529
1530 //______________________________________________________________________________
1531
1532 void SetCutsWindow::AddDescriptions()
1533 {
1534
1535 /*
1536    if(gOverlayButton3D && gOverlayButtonRPhi && gOverlayButtonRhoZ)
1537    {
1538
1539       (dynamic_cast<TEveViewer*>(gEve->GetViewers()->FindChild("3D View")))->GetGLViewer()->RemoveOverlayElement((TGLOverlayElement*)gOverlayButton3D);
1540       (dynamic_cast<TEveViewer*>(gEve->GetViewers()->FindChild("RPhi View")))->GetGLViewer()->RemoveOverlayElement((TGLOverlayElement*)gOverlayButtonRPhi);
1541       (dynamic_cast<TEveViewer*>(gEve->GetViewers()->FindChild("RhoZ View")))->GetGLViewer()->RemoveOverlayElement((TGLOverlayElement*)gOverlayButtonRhoZ);
1542
1543    }
1544    else
1545    {
1546
1547       AliEveMultiView *multiView = AliEveMultiView::Instance();
1548
1549       TGLViewer *glv = (dynamic_cast<TEveViewer*>(gEve->GetViewers()->FindChild("3D View")))->GetGLViewer();
1550       gOverlayButton3D = new TGLOverlayButton(glv,  "ALICE run 123456 event 123", 0, 0, multiView->Get3DView()->GetEveFrame()->GetWidth(), 30);
1551       gOverlayButton3D->SetAlphaValues(0.5, 0.5);
1552
1553       glv = (dynamic_cast<TEveViewer*>(gEve->GetViewers()->FindChild("RPhi View")))->GetGLViewer();
1554       gOverlayButtonRPhi = new TGLOverlayButton(glv,  "ALICE run 123456 event 123", 0, 0, multiView->GetRPhiView()->GetEveFrame()->GetWidth(), 30);
1555       gOverlayButtonRPhi->SetAlphaValues(0.5, 0.5);
1556
1557       glv = (dynamic_cast<TEveViewer*>(gEve->GetViewers()->FindChild("RhoZ View")))->GetGLViewer();
1558       gOverlayButtonRhoZ = new TGLOverlayButton(glv,  "ALICE run 123456 event 123", 0, 0, multiView->GetRhoZView()->GetEveFrame()->GetWidth(), 30);
1559       gOverlayButtonRhoZ->SetAlphaValues(0.5, 0.5);
1560
1561    }
1562
1563    gEve->Redraw3D(kFALSE, kTRUE);
1564 */
1565
1566    return;
1567
1568 }
1569
1570 //______________________________________________________________________________
1571
1572 void SetCutsWindow::MuonGeometry()
1573 {
1574
1575    if(gEve->GetScenes()->FirstChild()->FindChild("Gentle MUON"))
1576    {
1577       if(gEve->GetScenes()->FirstChild()->FindChild("Gentle MUON")->GetRnrSelf() || gEve->GetScenes()->FirstChild()->FindChild("Gentle MUON")->GetRnrChildren())
1578       {
1579          gEve->GetScenes()->FirstChild()->FindChild("Gentle MUON")->SetRnrSelf(kFALSE);
1580          gEve->GetScenes()->FirstChild()->FindChild("Gentle MUON")->SetRnrChildren(kFALSE);
1581       }
1582       else
1583       {
1584          gEve->GetScenes()->FirstChild()->FindChild("Gentle MUON")->SetRnrSelf(kTRUE);
1585          gEve->GetScenes()->FirstChild()->FindChild("Gentle MUON")->SetRnrChildren(kTRUE);
1586       }
1587
1588    }
1589
1590    gEve->FullRedraw3D();
1591
1592    return;
1593
1594 }
1595
1596 //______________________________________________________________________________
1597
1598 void SetCutsWindow::DefaultGeometry()
1599 {
1600
1601    AliEveMultiView *mv = AliEveMultiView::Instance();
1602
1603    mv->DestroyAllGeometries(); //destroy RPhi and Rhoz geometries before putting new
1604
1605    gEve->LoadVizDB("geom_gentle_default.C", kTRUE, kTRUE); //loading geometry
1606
1607    if(!gEve->GetViewers()->UseLightColorSet())
1608       gEve->GetViewers()->SwitchColorSet(); //white background
1609
1610    gEve->FullRedraw3D();
1611
1612    return;
1613
1614 }
1615
1616 //______________________________________________________________________________
1617
1618 void SetCutsWindow::BrightGeometry()
1619 {
1620
1621    AliEveMultiView *mv = AliEveMultiView::Instance();
1622
1623    mv->DestroyAllGeometries();
1624
1625    gEve->LoadVizDB("geom_gentle_bright.C", kTRUE, kTRUE);
1626
1627    if(gEve->GetViewers()->UseLightColorSet())
1628       gEve->GetViewers()->SwitchColorSet();
1629
1630
1631
1632    gEve->FullRedraw3D();
1633
1634    return;
1635
1636 }
1637
1638 //______________________________________________________________________________
1639
1640 void SetCutsWindow::TransparentGeometry()
1641 {
1642
1643    AliEveMultiView *mv = AliEveMultiView::Instance();
1644
1645    mv->DestroyAllGeometries();
1646
1647    gEve->LoadVizDB("geom_gentle_transparent.C", kTRUE, kTRUE);
1648
1649    if(!gEve->GetViewers()->UseLightColorSet())
1650       gEve->GetViewers()->SwitchColorSet();
1651
1652    gEve->FullRedraw3D();
1653
1654    return;
1655
1656 }
1657
1658 //______________________________________________________________________________
1659
1660 void SetCutsWindow::YellowGeometry()
1661 {
1662
1663    AliEveMultiView *mv = AliEveMultiView::Instance();
1664
1665    mv->DestroyAllGeometries();
1666
1667    gEve->LoadVizDB("geom_gentle_yellow.C", kTRUE, kTRUE);
1668
1669    if(!gEve->GetViewers()->UseLightColorSet())
1670       gEve->GetViewers()->SwitchColorSet();
1671
1672    gEve->FullRedraw3D();
1673
1674    return;
1675
1676 }
1677
1678 //______________________________________________________________________________
1679
1680 void SetCutsWindow::SaveAllViews()
1681 {
1682
1683      TGFileInfo fi;
1684      fi.fFileTypes   = gPictureSaveAsTypes;
1685      fi.fIniDir      = StrDup(""); // current directory
1686      fi.fFileTypeIdx = 0;
1687      fi.fOverwrite   = kTRUE;
1688      new TGFileDialog(gClient->GetDefaultRoot(),
1689      gEve->GetMainWindow(), kFDSave, &fi);
1690      if (!fi.fFilename) return;
1691
1692      TPMERegexp filere(".*/([^/]+$)");
1693      if (filere.Match(fi.fFilename) != 2)
1694      {
1695        Warning("AliEvePopupHandler", "file '%s' bad.", fi.fFilename);
1696        return;
1697      }
1698
1699      TString file1(filere[1]);
1700      TString file2(filere[1]);
1701      TString file3(filere[1]);
1702
1703      if (!file1.EndsWith(".png"))
1704        file1 += "_3D.png";
1705
1706      if (!file2.EndsWith(".png"))
1707        file2 += "_RPhi.png";
1708
1709      if (!file3.EndsWith(".png"))
1710        file3 += "_RhoZ.png";
1711
1712      gSystem->ChangeDirectory(fi.fIniDir);
1713
1714      printf("Saving...\n");
1715
1716      TEveViewerList *viewers = gEve->GetViewers();
1717      TEveElement::List_i i = viewers->BeginChildren();
1718      i++;
1719      TEveViewer* view3d = ((TEveViewer*)*i);
1720      view3d->GetGLViewer()->SavePictureScale(file1,4.0); // getting high resolution
1721      i++;
1722      TEveViewer* viewrphi = ((TEveViewer*)*i);
1723      viewrphi->GetGLViewer()->SavePictureScale(file2,4.0);
1724      i++;
1725      TEveViewer* viewrhoz = ((TEveViewer*)*i);
1726      viewrhoz->GetGLViewer()->SavePictureScale(file3,4.0);
1727
1728      printf("Done.\n");
1729
1730    return;
1731
1732 }
1733
1734 //______________________________________________________________________________
1735
1736 void SetCutsWindow::Save3DView()
1737 {
1738
1739      TGFileInfo fi;
1740      fi.fFileTypes   = gPictureSaveAsTypes;
1741      fi.fIniDir      = StrDup(""); // current directory
1742      fi.fFileTypeIdx = 0;
1743      fi.fOverwrite   = kTRUE;
1744      new TGFileDialog(gClient->GetDefaultRoot(),
1745      gEve->GetMainWindow(), kFDSave, &fi);
1746      if (!fi.fFilename) return;
1747
1748      TPMERegexp filere(".*/([^/]+$)");
1749      if (filere.Match(fi.fFilename) != 2)
1750      {
1751        Warning("AliEvePopupHandler", "file '%s' bad.", fi.fFilename);
1752        return;
1753      }
1754
1755      TString file1(filere[1]);
1756
1757      if (!file1.EndsWith(".png"))
1758        file1 += ".png";
1759
1760      gSystem->ChangeDirectory(fi.fIniDir);
1761
1762      printf("Saving...\n");
1763
1764      TEveViewerList *viewers = gEve->GetViewers();
1765      TEveElement::List_i i = viewers->BeginChildren();
1766      i++;
1767      TEveViewer* view3d = ((TEveViewer*)*i);
1768      view3d->GetGLViewer()->SavePictureScale(file1,4.0);
1769
1770      printf("Done.\n");
1771
1772    return;
1773
1774 }
1775
1776 //______________________________________________________________________________
1777
1778 void SetCutsWindow::SaveRPhiView()
1779 {
1780
1781      TGFileInfo fi;
1782      fi.fFileTypes   = gPictureSaveAsTypes;
1783      fi.fIniDir      = StrDup(""); // current directory
1784      fi.fFileTypeIdx = 0;
1785      fi.fOverwrite   = kTRUE;
1786      new TGFileDialog(gClient->GetDefaultRoot(),
1787      gEve->GetMainWindow(), kFDSave, &fi);
1788      if (!fi.fFilename) return;
1789
1790      TPMERegexp filere(".*/([^/]+$)");
1791      if (filere.Match(fi.fFilename) != 2)
1792      {
1793        Warning("AliEvePopupHandler", "file '%s' bad.", fi.fFilename);
1794        return;
1795      }
1796
1797      TString file1(filere[1]);
1798
1799      if (!file1.EndsWith(".png"))
1800        file1 += ".png";
1801
1802      gSystem->ChangeDirectory(fi.fIniDir);
1803
1804      printf("Saving...\n");
1805
1806      TEveViewerList *viewers = gEve->GetViewers();
1807      TEveElement::List_i i = viewers->BeginChildren();
1808      i++;
1809      i++;
1810      TEveViewer* viewrphi = ((TEveViewer*)*i);
1811      viewrphi->GetGLViewer()->SavePictureScale(file1,4.0);
1812
1813      printf("Done.\n");
1814
1815
1816    return;
1817
1818 }
1819
1820 //______________________________________________________________________________
1821
1822 void SetCutsWindow::SaveRhoZView()
1823 {
1824
1825      TGFileInfo fi;
1826      fi.fFileTypes   = gPictureSaveAsTypes;
1827      fi.fIniDir      = StrDup(""); // current directory
1828      fi.fFileTypeIdx = 0;
1829      fi.fOverwrite   = kTRUE;
1830      new TGFileDialog(gClient->GetDefaultRoot(),
1831      gEve->GetMainWindow(), kFDSave, &fi);
1832      if (!fi.fFilename) return;
1833
1834      TPMERegexp filere(".*/([^/]+$)");
1835      if (filere.Match(fi.fFilename) != 2)
1836      {
1837        Warning("AliEvePopupHandler", "file '%s' bad.", fi.fFilename);
1838        return;
1839      }
1840
1841      TString file1(filere[1]);
1842
1843      if (!file1.EndsWith(".png"))
1844        file1 += ".png";
1845
1846      gSystem->ChangeDirectory(fi.fIniDir);
1847
1848      printf("Saving...\n");
1849
1850      TEveViewerList *viewers = gEve->GetViewers();
1851      TEveElement::List_i i = viewers->BeginChildren();
1852      i++;
1853      i++;
1854      i++;
1855      TEveViewer* viewrhoz = ((TEveViewer*)*i);
1856      viewrhoz->GetGLViewer()->SavePictureScale(file1,4.0);
1857
1858      printf("Done.\n");
1859
1860
1861    return;
1862
1863 }
1864 //______________________________________________________________________________
1865
1866 void SetCutsWindow::DrawPtHisto()
1867 {
1868    if(gDrawHistograms[0])
1869       gDrawHistograms[0] = kFALSE;
1870    else
1871       gDrawHistograms[0] = kTRUE;
1872
1873    return;
1874
1875 }
1876
1877 //______________________________________________________________________________
1878
1879 void SetCutsWindow::DrawEtaHisto()
1880 {
1881    if(gDrawHistograms[1])
1882       gDrawHistograms[1] = kFALSE;
1883    else
1884       gDrawHistograms[1] = kTRUE;
1885
1886    return;
1887
1888 }
1889
1890 //______________________________________________________________________________
1891
1892 void SetCutsWindow::DrawPhiHisto()
1893 {
1894    if(gDrawHistograms[2])
1895       gDrawHistograms[2] = kFALSE;
1896    else
1897       gDrawHistograms[2] = kTRUE;
1898
1899    return;
1900
1901 }
1902
1903 //______________________________________________________________________________
1904
1905 void SetCutsWindow::DrawPhiPtHisto()
1906 {
1907    if(gDrawHistograms[3])
1908       gDrawHistograms[3] = kFALSE;
1909    else
1910       gDrawHistograms[3] = kTRUE;
1911
1912    return;
1913
1914 }
1915
1916 //______________________________________________________________________________
1917
1918 void SetCutsWindow::DrawPtYHisto()
1919 {
1920    if(gDrawHistograms[4])
1921       gDrawHistograms[4] = kFALSE;
1922    else
1923       gDrawHistograms[4] = kTRUE;
1924
1925    return;
1926
1927 }
1928
1929 //______________________________________________________________________________
1930
1931 void SetCutsWindow::DrawEtaPhiHisto()
1932 {
1933    if(gDrawHistograms[5])
1934       gDrawHistograms[5] = kFALSE;
1935    else
1936       gDrawHistograms[5] = kTRUE;
1937
1938    return;
1939
1940 }
1941
1942 //______________________________________________________________________________
1943
1944 void SetCutsWindow::DrawPtHistoAll()
1945 {
1946    if(gDrawHistograms[6])
1947       gDrawHistograms[6] = kFALSE;
1948    else
1949       gDrawHistograms[6] = kTRUE;
1950
1951    return;
1952
1953 }
1954
1955 //______________________________________________________________________________
1956
1957 void SetCutsWindow::DrawEtaHistoAll()
1958 {
1959    if(gDrawHistograms[7])
1960       gDrawHistograms[7] = kFALSE;
1961    else
1962       gDrawHistograms[7] = kTRUE;
1963
1964    return;
1965
1966 }
1967
1968 //______________________________________________________________________________
1969
1970 void SetCutsWindow::DrawPhiHistoAll()
1971 {
1972    if(gDrawHistograms[8])
1973       gDrawHistograms[8] = kFALSE;
1974    else
1975       gDrawHistograms[8] = kTRUE;
1976
1977    return;
1978
1979 }
1980
1981 //______________________________________________________________________________
1982
1983 void SetCutsWindow::DrawPhiPtHistoAll()
1984 {
1985    if(gDrawHistograms[9])
1986       gDrawHistograms[9] = kFALSE;
1987    else
1988       gDrawHistograms[9] = kTRUE;
1989
1990    return;
1991
1992 }
1993
1994 //______________________________________________________________________________
1995
1996 void SetCutsWindow::DrawPtYHistoAll()
1997 {
1998    if(gDrawHistograms[10])
1999       gDrawHistograms[10] = kFALSE;
2000    else
2001       gDrawHistograms[10] = kTRUE;
2002
2003    return;
2004
2005 }
2006
2007 //______________________________________________________________________________
2008
2009 void SetCutsWindow::DrawEtaPhiHistoAll()
2010 {
2011    if(gDrawHistograms[11])
2012       gDrawHistograms[11] = kFALSE;
2013    else
2014       gDrawHistograms[11] = kTRUE;
2015
2016    return;
2017
2018 }
2019
2020 //______________________________________________________________________________
2021
2022 void SetCutsWindow::DrawHistos()
2023 {
2024
2025    Int_t nHistos1 = 0;
2026    Int_t nHistos2 = 0;
2027
2028    TCanvas* pad1 = 0;
2029    TCanvas* pad2 = 0;
2030
2031    if(gDrawHistograms[0])
2032    {
2033          nHistos1++;
2034          TH1D* histPt = new TH1D("Pt\nSingle Event", "AliEve Pt histogram", 100, 0.0, 5.0);
2035    }
2036
2037    if(gDrawHistograms[1])
2038    {
2039          nHistos1++;
2040          TH1D* histEta = new TH1D("#eta\nSingle Event", "AliEve #eta histogram", 100, -1.5, 1.5);
2041    }
2042
2043    if(gDrawHistograms[2])
2044    {
2045          nHistos1++;
2046          TH1D* histPhi = new TH1D("#phi\nSingle Event", "AliEve #phi histogram", 100, 0.0, 2*TMath::Pi());
2047    }
2048
2049    if(gDrawHistograms[3])
2050    {
2051          nHistos2++;
2052          TH2D* histPhiPt = new TH2D("#phi-Pt\nSingle Event", "AliEve #phi-Pt histogram", 100, 0.0, 2*TMath::Pi(), 100, 0.0, 5.0);
2053    }
2054
2055    if(gDrawHistograms[4])
2056    {
2057          nHistos2++;
2058          TH2D* histPtY = new TH2D("Pt-Y\nSingle Event", "AliEve Pt-y histogram", 100, 0.0, 5.0, 100, -1.5, 1.5);
2059    }
2060
2061    if(gDrawHistograms[5])
2062    {
2063          nHistos2++;
2064          TH2D* histEtaPhi = new TH2D("#eta-#phi\nSingle Event", "AliEve #eta-#phi histogram", 100, -1.5, 1.5, 100, 0.0, 2*TMath::Pi());
2065    }
2066
2067    AliESDEvent* esd = AliEveEventManager::AssertESD();
2068
2069    if(esd->GetNumberOfTracks())
2070    {
2071
2072       for(Int_t j = 0; j < esd->GetNumberOfTracks(); j++)
2073       {
2074
2075          AliESDtrack* track = esd->GetTrack(j);
2076
2077          if(gDrawHistograms[0])
2078             histPt->Fill(track->Pt());
2079          if(gDrawHistograms[1])
2080             histEta->Fill(track->Eta());
2081          if(gDrawHistograms[2])
2082             histPhi->Fill(track->Phi());
2083          if(gDrawHistograms[3])
2084             histPhiPt->Fill(track->Phi(),track->Pt());
2085          if(gDrawHistograms[4])
2086             histPtY->Fill(track->Pt(),track->Y());
2087          if(gDrawHistograms[5])
2088             histEtaPhi->Fill(track->Eta(),track->Phi());
2089
2090       }
2091
2092    }
2093
2094    switch(nHistos1)
2095    {
2096       case 1:
2097          pad1 = new TCanvas("AliEve 1D histograms - Single Event","AliEve 1D histograms - Single Event",800,600);
2098          if(gDrawHistograms[0])
2099             histPt->Draw();
2100          if(gDrawHistograms[1])
2101             histEta->Draw();
2102          if(gDrawHistograms[2])
2103             histPhi->Draw();
2104          break;
2105
2106       case 2:
2107          pad1 = new TCanvas("AliEve 1D histograms - Single Event","AliEve 1D histograms - Single Event",1200,500);
2108          pad1->Divide(2,1);
2109          if(!gDrawHistograms[0])
2110          {
2111             pad1->cd(1);
2112             histEta->Draw();
2113             pad1->cd(2);
2114             histPhi->Draw();
2115          }
2116          if(!gDrawHistograms[1])
2117          {
2118             pad1->cd(1);
2119             histPt->Draw();
2120             pad1->cd(2);
2121             histPhi->Draw();
2122          }
2123          if(!gDrawHistograms[2])
2124          {
2125             pad1->cd(1);
2126             histPt->Draw();
2127             pad1->cd(2);
2128             histEta->Draw();
2129          }
2130          break;
2131
2132       case 3:
2133          pad1 = new TCanvas("AliEve 1D histograms - Single Event","AliEve 1D histograms - Single Event",1200,500);
2134          pad1->Divide(3,1);
2135          pad1->cd(1);
2136          histPt->Draw();
2137          pad1->cd(2);
2138          histEta->Draw();
2139          pad1->cd(3);
2140          histPhi->Draw();
2141          break;
2142
2143       default:
2144          break;
2145    }
2146
2147    switch(nHistos2)
2148    {
2149       case 1:
2150          pad2 = new TCanvas("AliEve 2D histograms - Single Event","AliEve 2D histograms - Single Event",800,600);
2151          if(gDrawHistograms[3])
2152             histPhiPt->Draw();
2153          if(gDrawHistograms[4])
2154             histPtY->Draw();
2155          if(gDrawHistograms[5])
2156             histEtaPhi->Draw();
2157          break;
2158
2159       case 2:
2160          pad2 = new TCanvas("AliEve 2D histograms - Single Event","AliEve 2D histograms - Single Event",1200,500);
2161          pad2->Divide(2,1);
2162          if(!gDrawHistograms[3])
2163          {
2164             pad2->cd(1);
2165             histPtY->Draw();
2166             pad2->cd(2);
2167             histEtaPhi->Draw();
2168          }
2169          if(!gDrawHistograms[4])
2170          {
2171             pad2->cd(1);
2172             histPhiPt->Draw();
2173             pad2->cd(2);
2174             histEtaPhi->Draw();
2175          }
2176          if(!gDrawHistograms[5])
2177          {
2178             pad2->cd(1);
2179             histPhiPt->Draw();
2180             pad2->cd(2);
2181             histPtY->Draw();
2182          }
2183          break;
2184
2185       case 3:
2186          pad2 = new TCanvas("AliEve 2D histograms - Single Event","AliEve 2D histograms - Single Event",1200,500);
2187          pad2->Divide(3,1);
2188          pad2->cd(1);
2189          histPhiPt->Draw();
2190          pad2->cd(2);
2191          histPtY->Draw();
2192          pad2->cd(3);
2193          histEtaPhi->Draw();
2194          break;
2195
2196       default:
2197          break;
2198    }
2199
2200    return;
2201
2202 }
2203
2204 //______________________________________________________________________________
2205
2206 void SetCutsWindow::DrawHistosAll()
2207 {
2208
2209    Int_t nHistos1 = 0;
2210    Int_t nHistos2 = 0;
2211
2212    TCanvas* pad1 = 0;
2213    TCanvas* pad2 = 0;
2214
2215    if(gDrawHistograms[6])
2216    {
2217          nHistos1++;
2218          TH1D* histPt = new TH1D("Pt\nAll Events", "AliEve Pt histogram", 100, 0.0, 5.0);
2219    }
2220
2221    if(gDrawHistograms[7])
2222    {
2223          nHistos1++;
2224          TH1D* histEta = new TH1D("#eta\nAll Events", "AliEve #eta histogram", 100, -1.5, 1.5);
2225    }
2226
2227    if(gDrawHistograms[8])
2228    {
2229          nHistos1++;
2230          TH1D* histPhi = new TH1D("#phi\nAll Events", "AliEve #phi histogram", 100, 0.0, 2*TMath::Pi());
2231    }
2232
2233    if(gDrawHistograms[9])
2234    {
2235          nHistos2++;
2236          TH2D* histPhiPt = new TH2D("#phi-Pt\nAll Events", "AliEve #phi-Pt histogram", 100, 0.0, 2*TMath::Pi(), 100, 0.0, 5.0);
2237    }
2238
2239    if(gDrawHistograms[10])
2240    {
2241          nHistos2++;
2242          TH2D* histPtY = new TH2D("Pt-Y\nAll Events", "AliEve Pt-y histogram", 100, 0.0, 5.0, 100, -1.5, 1.5);
2243    }
2244
2245    if(gDrawHistograms[11])
2246    {
2247          nHistos2++;
2248          TH2D* histEtaPhi = new TH2D("#eta-#phi\nAll Events", "AliEve #eta-#phi histogram", 100, 1.5, 1.5, 100, 0.0, 2*TMath::Pi());
2249    }
2250
2251    Int_t nEvents = AliEveEventManager::GetMaster()->GetMaxEventId();
2252
2253    AliEveEventManager::GetMaster()->GotoEvent(0);
2254
2255    for(Int_t i = 0; i <= nEvents; i++)
2256    {
2257
2258    AliESDEvent* esd = AliEveEventManager::AssertESD();
2259
2260    if(esd->GetNumberOfTracks())
2261    {
2262
2263       for(Int_t j = 0; j < esd->GetNumberOfTracks(); j++)
2264       {
2265
2266          AliESDtrack* track = esd->GetTrack(j);
2267
2268          if(gDrawHistograms[6])
2269             histPt->Fill(track->Pt());
2270          if(gDrawHistograms[7])
2271             histEta->Fill(track->Eta());
2272          if(gDrawHistograms[8])
2273             histPhi->Fill(track->Phi());
2274          if(gDrawHistograms[9])
2275             histPhiPt->Fill(track->Phi(),track->Pt());
2276          if(gDrawHistograms[10])
2277             histPtY->Fill(track->Pt(),track->Y());
2278          if(gDrawHistograms[11])
2279             histEtaPhi->Fill(track->Eta(),track->Phi());
2280
2281       }
2282
2283    }
2284
2285       AliEveEventManager::GetMaster()->NextEvent();
2286
2287    }
2288
2289    switch(nHistos1)
2290    {
2291       case 1:
2292          pad1 = new TCanvas("AliEve 1D histograms - All Events","AliEve 1D histograms - All Events",800,600);
2293          if(gDrawHistograms[6])
2294             histPt->Draw();
2295          if(gDrawHistograms[7])
2296             histEta->Draw();
2297          if(gDrawHistograms[8])
2298             histPhi->Draw();
2299          break;
2300
2301       case 2:
2302          pad1 = new TCanvas("AliEve 1D histograms - All Events","AliEve 1D histograms - All Events",1200,500);
2303          pad1->Divide(2,1);
2304          if(!gDrawHistograms[6])
2305          {
2306             pad1->cd(1);
2307             histEta->Draw();
2308             pad1->cd(2);
2309             histPhi->Draw();
2310          }
2311          if(!gDrawHistograms[7])
2312          {
2313             pad1->cd(1);
2314             histPt->Draw();
2315             pad1->cd(2);
2316             histPhi->Draw();
2317          }
2318          if(!gDrawHistograms[8])
2319          {
2320             pad1->cd(1);
2321             histPt->Draw();
2322             pad1->cd(2);
2323             histEta->Draw();
2324          }
2325          break;
2326
2327       case 3:
2328          pad1 = new TCanvas("AliEve 1D histograms - All Events","AliEve 1D histograms - All Events",1200,500);
2329          pad1->Divide(3,1);
2330          pad1->cd(1);
2331          histPt->Draw();
2332          pad1->cd(2);
2333          histEta->Draw();
2334          pad1->cd(3);
2335          histPhi->Draw();
2336          break;
2337
2338       default:
2339          break;
2340    }
2341
2342    switch(nHistos2)
2343    {
2344       case 1:
2345          pad2 = new TCanvas("AliEve 2D histograms - All Events","AliEve 2D histograms - All Events",800,600);
2346          if(gDrawHistograms[9])
2347             histPt->Draw();
2348          if(gDrawHistograms[10])
2349             histEta->Draw();
2350          if(gDrawHistograms[11])
2351             histPhi->Draw();
2352          break;
2353
2354       case 2:
2355          pad2 = new TCanvas("AliEve 2D histograms - All Events","AliEve 2D histograms - All Events",1200,500);
2356          pad2->Divide(2,1);
2357          if(!gDrawHistograms[9])
2358          {
2359             pad2->cd(1);
2360             histPtY->Draw();
2361             pad2->cd(2);
2362             histEtaPhi->Draw();
2363          }
2364          if(!gDrawHistograms[10])
2365          {
2366             pad2->cd(1);
2367             histPhiPt->Draw();
2368             pad2->cd(2);
2369             histEtaPhi->Draw();
2370          }
2371          if(!gDrawHistograms[11])
2372          {
2373             pad2->cd(1);
2374             histPhiPt->Draw();
2375             pad2->cd(2);
2376             histPtY->Draw();
2377          }
2378          break;
2379
2380       case 3:
2381          pad2 = new TCanvas("AliEve 2D histograms - All Events","AliEve 2D histograms - All Events",1200,500);
2382          pad2->Divide(3,1);
2383          pad2->cd(1);
2384          histPhiPt->Draw();
2385          pad2->cd(2);
2386          histPtY->Draw();
2387          pad2->cd(3);
2388          histEtaPhi->Draw();
2389          break;
2390
2391       default:
2392          break;
2393    }
2394
2395    return;
2396
2397 }
2398
2399 //______________________________________________________________________________
2400
2401 void SetCutsWindow::DrawResiduals()
2402 {
2403
2404    TEveUtil::Macro("make_residuals.C");
2405
2406    return;
2407
2408 }
2409
2410 //______________________________________________________________________________
2411
2412 Int_t SetCutsWindow::GetTrackColorByMomentum(Double_t momentum, Int_t size)
2413 {
2414
2415
2416    Double_t step = 3.0/size;
2417
2418    for(Int_t i = 0; i < size; i++)
2419    {
2420
2421       switch(gTrackColorScale->GetSelected())
2422       {
2423
2424          case 1:
2425             if(momentum > i*step && momentum <= (i+1)*step)
2426                return i;
2427             break;
2428
2429          case 2:
2430             if(momentum > TMath::Log(1+i*step) && momentum <= TMath::Log(1+(i+1)*step))
2431                return i;
2432             break;
2433
2434          case 3:
2435             if(momentum > TMath::Power(i*step,0.5) && momentum <= TMath::Power((i+1)*step,0.5))
2436                return i;
2437             break;
2438
2439          default:
2440             if(momentum > i*step && momentum <= (i+1)*step)
2441                return i;
2442             break;
2443       }
2444
2445    }
2446
2447    return i;
2448
2449 }
2450
2451 //______________________________________________________________________________
2452
2453 void SetCutsWindow::SetStandardCuts()
2454 {
2455
2456    gDrawV0s->SetOn(kFALSE,kFALSE);
2457    gDrawCascades->SetOn(kFALSE,kFALSE);
2458    gDrawKinks->SetOn(kFALSE,kFALSE);
2459    gDrawVertex->SetOn(kFALSE,kFALSE);
2460    gDrawTracklets->SetOn(kFALSE,kFALSE);
2461    gDrawTracks->SetOn(kTRUE,kFALSE);
2462    gDrawClusters->SetOn(kFALSE,kFALSE);
2463    gDrawTracksType1->SetOn(kTRUE,kFALSE);
2464    gDrawTracksType2->SetOn(kTRUE,kFALSE);
2465    gDrawTracksType3->SetOn(kTRUE,kFALSE);
2466    gDrawTracksType4->SetOn(kFALSE,kFALSE);
2467    gDrawTracksType5->SetOn(kFALSE,kFALSE);
2468    gDrawTracksType6->SetOn(kFALSE,kFALSE);
2469    gDrawTracksType7->SetOn(kFALSE,kFALSE);
2470    gCutOnP->SetOn(kFALSE,kFALSE);
2471    gCutOnPt->SetOn(kTRUE,kFALSE);
2472    gCutOnEta->SetOn(kTRUE,kFALSE);
2473    gCutOnMult->SetOn(kFALSE,kFALSE);
2474    gCutOnCls->SetOn(kTRUE,kFALSE);
2475    gPtRange->SetValues(0.15,gPtRange->GetLimitMax());
2476    gEtaRange->SetValues(-0.9,0.9);
2477    gClsRangeNE->SetNumber(70);
2478    gClsRange->SetPosition(70);
2479
2480 }
2481
2482 //______________________________________________________________________________
2483
2484 void SetCutsWindow::AddMomentumVectors()
2485 {
2486
2487 //   Bool_t drawWithTracks = kTRUE;
2488
2489    if(gEve->GetEventScene()->FirstChild()->FindChild("Momentum Vectors"))
2490       gEve->GetEventScene()->FirstChild()->FindChild("Momentum Vectors")->Destroy();
2491
2492    TString str1 = 0;
2493    TString str2 = 0;
2494
2495    TEveElement::List_i i = gEve->GetEventScene()->FirstChild()->BeginChildren();
2496    TEveElement::List_i j = gEve->GetEventScene()->FirstChild()->EndChildren();
2497    TEveElement::List_i k;
2498
2499    TEveElementList* momentumVectorList = new TEveElementList("Momentum Vectors");
2500
2501    Double_t maxMomentum = 0;
2502    Double_t vectorLength = 600.0;
2503
2504    Double_t x1 = 0;
2505    Double_t y1 = 0;
2506    Double_t z1 = 0;
2507
2508    Double_t x2 = 0;
2509    Double_t y2 = 0;
2510    Double_t z2 = 0;
2511
2512    Bool_t draw = kFALSE;
2513
2514    Int_t mode = gVectorMode->GetSelected();
2515    Double_t cut = 0.1*gPMVRange->GetPosition();
2516
2517    //==============================================
2518    // find highest momentum (to normalize)
2519    //==============================================
2520
2521    if(mode != 3)
2522    {
2523    for(k = i; k != j; k++)
2524    {
2525       TEveElement* element = (TEveElement*) *k;
2526
2527       str1 = element->GetElementName();
2528
2529       if(str1.Contains("Tracks") || str1.Contains("tracks"))
2530       {
2531
2532          TEveElement::List_i m = element->BeginChildren();
2533          TEveElement::List_i n = element->EndChildren();
2534          TEveElement::List_i l;
2535
2536          for(l = m; l != n; l++)
2537          {
2538             TEveElement* trackType = (TEveElement*) *l;
2539             str2 = trackType->GetElementName();
2540
2541             if(str2.Contains("Sigma < 3"))
2542             {
2543                if(trackType->HasChildren())
2544                {
2545
2546                   TEveElement::List_i x = trackType->BeginChildren();
2547                   TEveElement::List_i y = trackType->EndChildren();
2548                   TEveElement::List_i z;
2549
2550                   for(z = x; z != y; z++)
2551                   {
2552
2553                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2554
2555                      if(trackSingle1->GetESDTrack()->P() > maxMomentum)
2556                        maxMomentum = trackSingle1->GetESDTrack()->P();
2557
2558                   }
2559                }
2560             }
2561
2562
2563             if(str2.Contains("3 < Sigma < 5"))
2564             {
2565
2566                if(trackType->HasChildren())
2567                {
2568
2569                   TEveElement::List_i x = trackType->BeginChildren();
2570                   TEveElement::List_i y = trackType->EndChildren();
2571                   TEveElement::List_i z;
2572
2573                   for(z = x; z != y; z++)
2574                   {
2575
2576                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2577
2578                      if(trackSingle1->GetESDTrack()->P() > maxMomentum)
2579                        maxMomentum = trackSingle1->GetESDTrack()->P();
2580
2581                   }
2582                }
2583             }
2584
2585             if(str2.Contains("5 < Sigma"))
2586             {
2587
2588                if(trackType->HasChildren())
2589                {
2590
2591                   TEveElement::List_i x = trackType->BeginChildren();
2592                   TEveElement::List_i y = trackType->EndChildren();
2593                   TEveElement::List_i z;
2594
2595                   for(z = x; z != y; z++)
2596                   {
2597
2598                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2599
2600                      if(trackSingle1->GetESDTrack()->P() > maxMomentum)
2601                        maxMomentum = trackSingle1->GetESDTrack()->P();
2602
2603
2604                   }
2605                }
2606             }
2607          }
2608       }
2609    }
2610    }
2611    //==============================================
2612    // clean the display
2613    //==============================================
2614 /*
2615    if(!drawWithTracks)
2616
2617       for(k = i; k != j; k++)
2618       {
2619          TEveElement* element = (TEveElement*) *k;
2620
2621          str1 = element->GetElementName();
2622
2623          element->SetRnrSelf(kFALSE);
2624
2625          if(element->HasChildren())
2626             element->SetRnrChildren(kFALSE);
2627
2628       }
2629
2630    }
2631 */
2632    //==============================================
2633    // draw momentum vectors
2634    //==============================================
2635
2636    if(mode == 1 && maxMomentum > 1)
2637       vectorLength = 100/TMath::Log(100*maxMomentum);
2638    if(mode == 2 && maxMomentum)
2639       vectorLength = vectorLength/maxMomentum;
2640    if(mode == 3)
2641       vectorLength = 100;
2642
2643    for(k = i; k != j; k++)
2644    {
2645       TEveElement* element = (TEveElement*) *k;
2646
2647       str1 = element->GetElementName();
2648
2649       if(str1.Contains("Tracks") || str1.Contains("tracks"))
2650       {
2651
2652          TEveElement::List_i m = element->BeginChildren();
2653          TEveElement::List_i n = element->EndChildren();
2654          TEveElement::List_i l;
2655
2656          for(l = m; l != n; l++)
2657          {
2658             TEveElement* trackType = (TEveElement*) *l;
2659             str2 = trackType->GetElementName();
2660
2661 //            trackType->SetRnrSelf(kFALSE);
2662
2663 //            if(trackType->HasChildren())
2664 //               trackType->SetRnrChildren(kFALSE);
2665
2666             if(str2.Contains("Sigma < 3"))
2667             {
2668
2669                if(trackType->HasChildren())
2670                {
2671
2672                   TEveElementList* momentumVectorList1 = new TEveElementList("sigma < 3");
2673
2674                   TEveElement::List_i x = trackType->BeginChildren();
2675                   TEveElement::List_i y = trackType->EndChildren();
2676                   TEveElement::List_i z;
2677
2678                   for(z = x; z != y; z++)
2679                   {
2680
2681                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2682
2683                      TEveLine* momentumVector = new TEveLine(TString::Format("Momentum Vector"));
2684
2685                      if(trackSingle1->GetESDTrack()->P() > cut)
2686                      {
2687
2688                         x1 = trackSingle1->GetESDTrack()->Xv();
2689                         y1 = trackSingle1->GetESDTrack()->Yv();
2690                         z1 = trackSingle1->GetESDTrack()->Zv();
2691
2692                         momentumVector->SetPoint(0, x1, y1, z1);
2693
2694                         if(mode == 1)
2695                         {
2696                            x2 = x1+vectorLength*TMath::Log(100*trackSingle1->GetESDTrack()->P())*trackSingle1->GetESDTrack()->Px();
2697                            y2 = y1+vectorLength*TMath::Log(100*trackSingle1->GetESDTrack()->P())*trackSingle1->GetESDTrack()->Py();
2698                            z2 = z1+vectorLength*TMath::Log(100*trackSingle1->GetESDTrack()->P())*trackSingle1->GetESDTrack()->Pz();
2699                         }
2700
2701                         if(mode == 2)
2702                         {
2703                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
2704                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
2705                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
2706                         }
2707
2708                         if(mode == 3)
2709                         {
2710                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
2711                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
2712                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
2713                         }
2714
2715                         if((mode != 1 && mode!= 2 && mode != 3) ||
2716                           ( mode == 3 && trackSingle1->GetESDTrack()->P() <= 0.01))
2717                            continue;
2718
2719                         momentumVector->SetPoint(1, x2, y2, z2);
2720
2721 /*
2722                         if(trackSingle1->GetESDTrack()->Charge() == -1)
2723                            momentumVector->SetLineColor(kGreen);
2724                         else
2725                            momentumVector->SetLineColor(kRed);
2726 */
2727                         momentumVector->SetLineColor(kRed);
2728
2729                         momentumVector->SetLineWidth(1);
2730                         momentumVector->SetLineStyle(0);
2731                         momentumVector->SetTitle(Form("%f GeV/c", trackSingle1->GetESDTrack()->P()));
2732
2733                         momentumVectorList1->AddElement(momentumVector);
2734
2735                      }
2736
2737                   }
2738
2739                   momentumVectorList->AddElement(momentumVectorList1);
2740
2741                   draw = kTRUE;
2742
2743                }
2744             }
2745
2746
2747             if(str2.Contains("3 < Sigma < 5"))
2748             {
2749
2750                if(trackType->HasChildren())
2751                {
2752
2753                   TEveElement::List_i x = trackType->BeginChildren();
2754                   TEveElement::List_i y = trackType->EndChildren();
2755                   TEveElement::List_i z;
2756
2757                   TEveElementList* momentumVectorList2 = new TEveElementList("3 < sigma < 5");
2758
2759                   for(z = x; z != y; z++)
2760                   {
2761
2762                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2763
2764                      TEveLine* momentumVector = new TEveLine(TString::Format("Momentum Vector"));
2765
2766                      if(trackSingle1->GetESDTrack()->P() > cut)
2767                      {
2768
2769                         x1 = trackSingle1->GetESDTrack()->Xv();
2770                         y1 = trackSingle1->GetESDTrack()->Yv();
2771                         z1 = trackSingle1->GetESDTrack()->Zv();
2772
2773                         momentumVector->SetPoint(0, x1, y1, z1);
2774
2775                         if(mode == 1)
2776                         {
2777                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px()*TMath::Log(trackSingle1->GetESDTrack()->P());
2778                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py()*TMath::Log(trackSingle1->GetESDTrack()->P());
2779                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz()*TMath::Log(trackSingle1->GetESDTrack()->P());
2780                         }
2781
2782                         if(mode == 2)
2783                         {
2784                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
2785                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
2786                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
2787                         }
2788
2789                         if(mode == 3)
2790                         {
2791                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
2792                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
2793                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
2794                         }
2795
2796                         if(mode != 1 && mode!= 2 && mode != 3)
2797                            continue;
2798
2799                         momentumVector->SetPoint(1, x2, y2, z2);
2800
2801 /*
2802                         if(trackSingle1->GetESDTrack()->Charge() == -1)
2803                            momentumVector->SetLineColor(kGreen+2);
2804                         else
2805                            momentumVector->SetLineColor(kRed+2);
2806 */
2807                         momentumVector->SetLineColor(kRed+2);
2808
2809                         momentumVector->SetLineWidth(1);
2810                         momentumVector->SetLineStyle(0);
2811                         momentumVector->SetTitle(Form("%f GeV/c", trackSingle1->GetESDTrack()->P()));
2812
2813                         momentumVectorList2->AddElement(momentumVector);
2814
2815                      }
2816
2817                   }
2818
2819                   momentumVectorList->AddElement(momentumVectorList2);
2820
2821                   draw = kTRUE;
2822
2823                }
2824             }
2825
2826             if(str2.Contains("5 < Sigma"))
2827             {
2828
2829                if(trackType->HasChildren())
2830                {
2831
2832                   TEveElementList* momentumVectorList3 = new TEveElementList("5 < sigma");
2833
2834                   TEveElement::List_i x = trackType->BeginChildren();
2835                   TEveElement::List_i y = trackType->EndChildren();
2836                   TEveElement::List_i z;
2837
2838                   for(z = x; z != y; z++)
2839                   {
2840
2841                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2842
2843                      TEveLine* momentumVector = new TEveLine(TString::Format("Momentum Vector"));
2844
2845                      if(trackSingle1->GetESDTrack()->P() > cut)
2846                      {
2847
2848                         x1 = trackSingle1->GetESDTrack()->Xv();
2849                         y1 = trackSingle1->GetESDTrack()->Yv();
2850                         z1 = trackSingle1->GetESDTrack()->Zv();
2851
2852                         momentumVector->SetPoint(0, x1, y1, z1);
2853
2854                         if(mode == 1)
2855                         {
2856                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px()*TMath::Log(trackSingle1->GetESDTrack()->P());
2857                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py()*TMath::Log(trackSingle1->GetESDTrack()->P());
2858                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz()*TMath::Log(trackSingle1->GetESDTrack()->P());
2859                         }
2860
2861                         if(mode == 2)
2862                         {
2863                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
2864                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
2865                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
2866                         }
2867
2868                         if(mode == 3)
2869                         {
2870                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
2871                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
2872                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
2873                         }
2874
2875                         if(mode != 1 && mode!= 2 && mode != 3)
2876                            continue;
2877
2878                         momentumVector->SetPoint(1, x2, y2, z2);
2879 /*
2880                         if(trackSingle1->GetESDTrack()->Charge() == -1)
2881                            momentumVector->SetLineColor(kGreen+3);
2882                         else
2883                            momentumVector->SetLineColor(kRed+3);
2884 */
2885                         momentumVector->SetLineColor(kRed+3);
2886
2887                         momentumVector->SetLineWidth(1);
2888                         momentumVector->SetLineStyle(0);
2889                         momentumVector->SetTitle(Form("%f GeV/c", trackSingle1->GetESDTrack()->P()));
2890
2891                         momentumVectorList3->AddElement(momentumVector);
2892
2893                      }
2894
2895                   }
2896
2897                   momentumVectorList->AddElement(momentumVectorList3);
2898
2899                   draw = kTRUE;
2900
2901                }
2902             }
2903          }
2904       }
2905    }
2906
2907   gEve->AddElement(momentumVectorList);
2908
2909   TEveElement* top = gEve->GetCurrentEvent();
2910
2911   AliEveMultiView *mv = AliEveMultiView::Instance();
2912
2913   mv->DestroyEventRPhi();
2914   mv->DestroyEventRhoZ();
2915
2916   mv->ImportEventRPhi(top);
2917   mv->ImportEventRhoZ(top);
2918
2919   gEve->FullRedraw3D(kFALSE, kTRUE);
2920
2921 }
2922
2923 //______________________________________________________________________________
2924
2925 void SetCutsWindow::SetCuts()
2926 {
2927
2928    TString str1 = 0;
2929    TString str2 = 0;
2930
2931    Int_t posTrackColor= gPosColorList->GetSelected();
2932    Int_t negTrackColor= gNegColorList->GetSelected();
2933
2934    TEveElement::List_i i = gEve->GetEventScene()->FirstChild()->BeginChildren();
2935    TEveElement::List_i j = gEve->GetEventScene()->FirstChild()->EndChildren();
2936    TEveElement::List_i k;
2937
2938    Double_t x1, y1, z1, x2, y2, z2;
2939
2940    for(k = i; k != j; k++)
2941    {
2942       TEveElement* element = (TEveElement*) *k;
2943
2944       str1 = element->GetElementName();
2945
2946       if(gDrawV0s->IsOn())
2947       {
2948          if(str1.Contains("ESD v0") || str1.Contains("ESD V0"))
2949          {
2950             element->SetRnrSelf(kTRUE);
2951
2952             if(element->HasChildren())
2953                element->SetRnrChildren(kTRUE);
2954
2955             continue;
2956          }
2957       }
2958
2959       if(gDrawCascades->IsOn())
2960       {
2961          if(str1.Contains("ESD cascade") || str1.Contains("ESD Cascade"))
2962          {
2963             element->SetRnrSelf(kTRUE);
2964
2965             if(element->HasChildren())
2966                element->SetRnrChildren(kTRUE);
2967
2968             continue;
2969          }
2970       }
2971
2972       if(gDrawKinks->IsOn())
2973       {
2974          if(str1.Contains("ESD kink") || str1.Contains("ESD Kink"))
2975          {
2976             element->SetRnrSelf(kTRUE);
2977
2978             if(element->HasChildren())
2979                element->SetRnrChildren(kTRUE);
2980
2981             continue;
2982          }
2983       }
2984
2985       if(gDrawVertex->IsOn())
2986       {
2987          if(str1.Contains("Primary Vertex") || str1.Contains("primary Vertex") || str1.Contains("Primary vertex") || str1.Contains("primary vertex"))
2988          {
2989             element->SetRnrSelf(kTRUE);
2990
2991             if(element->HasChildren())
2992                element->SetRnrChildren(kTRUE);
2993
2994             continue;
2995          }
2996       }
2997
2998       if(gDrawTracklets->IsOn())
2999       {
3000          if(str1.Contains("Tracklets") || str1.Contains("tracklets"))
3001          {
3002             element->SetRnrSelf(kTRUE);
3003
3004             if(element->HasChildren())
3005                element->SetRnrChildren(kTRUE);
3006
3007             continue;
3008          }
3009       }
3010
3011       if(gDrawTracks->IsOn())
3012       {
3013
3014 Int_t colorNeg[27][10] =
3015 {
3016    { kRed, kBlue, kOrange, kCyan, kGreen, kGray, kViolet, kMagenta, kSpring, kYellow },
3017    { kCyan-4, kCyan, kAzure+10, kAzure+8, kAzure+5, kAzure, kBlue, kBlue+1, kBlue+2, kBlue+3 },
3018    { kYellow-4, kYellow, kOrange+10, kOrange, kOrange+7, kOrange+10, kRed, kRed+1, kRed+2, kRed+3 },
3019    { kRed, kRed-1, kRed-2, kRed-3, kRed-4, kRed-5, kRed-6, kRed-7, kRed-8, kRed-9},
3020    { kRed, kRed, kRed+1, kRed+1, kRed+2, kRed+2, kRed+3, kRed+3, kRed+4, kRed+4},
3021    { kOrange, kOrange-1, kOrange-2, kOrange-3, kOrange-4, kOrange-5, kOrange-6, kOrange-7, kOrange-8, kOrange-9},
3022    { kOrange, kOrange+1, kOrange+2, kOrange+3, kOrange+4, kOrange+5, kOrange+6, kOrange+7, kOrange+8, kOrange+9},
3023    { kYellow, kYellow-1, kYellow-2, kYellow-3, kYellow-4, kYellow-5, kYellow-6, kYellow-7, kYellow-8, kYellow-9},
3024    { kYellow, kYellow, kYellow+1, kYellow+1, kYellow+2, kYellow+2, kYellow+3, kYellow+3, kYellow+4, kYellow+4},
3025    { kSpring, kSpring-1, kSpring-2, kSpring-3, kSpring-4, kSpring-5, kSpring-6, kSpring-7, kSpring-8, kSpring-9},
3026    { kSpring, kSpring+1, kSpring+2, kSpring+3, kSpring+4, kSpring+5, kSpring+6, kSpring+7, kSpring+8, kSpring+9},
3027    { kGreen, kGreen-1, kGreen-2, kGreen-3, kGreen-4, kGreen-5, kGreen-6, kGreen-7, kGreen-8, kGreen-9},
3028    { kGreen, kGreen, kGreen+1, kGreen+1, kGreen+2, kGreen+2, kGreen+3, kGreen+3, kGreen+4, kGreen+4},
3029    { kTeal, kTeal-1, kTeal-2, kTeal-3, kTeal-4, kTeal-5, kTeal-6, kTeal-7, kTeal-8, kTeal-9},
3030    { kTeal, kTeal+1, kTeal+2, kTeal+3, kTeal+4, kTeal+5, kTeal+6, kTeal+7, kTeal+8, kTeal+9},
3031    { kCyan, kCyan-1, kCyan-2, kCyan-3, kCyan-4, kCyan-5, kCyan-6, kCyan-7, kCyan-8, kCyan-9},
3032    { kCyan, kCyan, kCyan+1, kCyan+1, kCyan+2, kCyan+2, kCyan+3, kCyan+3, kCyan+4, kCyan+4},
3033    { kAzure, kAzure-1, kAzure-2, kAzure-3, kAzure-4, kAzure-5, kAzure-6, kAzure-7, kAzure-8, kAzure-9},
3034    { kAzure, kAzure+1, kAzure+2, kAzure+3, kAzure+4, kAzure+5, kAzure+6, kAzure+7, kAzure+8, kAzure+9},
3035    { kBlue, kBlue-1, kBlue-2, kBlue-3, kBlue-4, kBlue-5, kBlue-6, kBlue-7, kBlue-8, kBlue-9},
3036    { kBlue, kBlue, kBlue+1, kBlue+1, kBlue+2, kBlue+2, kBlue+3, kBlue+3, kBlue+4, kBlue+4},
3037    { kViolet, kViolet-1, kViolet-2, kViolet-3, kViolet-4, kViolet-5, kViolet-6, kViolet-7, kViolet-8, kViolet-9},
3038    { kViolet, kViolet+1, kViolet+2, kViolet+3, kViolet+4, kViolet+5, kViolet+6, kViolet+7, kViolet+8, kViolet+9},
3039    { kMagenta, kMagenta-1, kMagenta-2, kMagenta-3, kMagenta-4, kMagenta-5, kMagenta-6, kMagenta-7, kMagenta-8, kMagenta-9},
3040    { kMagenta, kMagenta, kMagenta+1, kMagenta+1, kMagenta+2, kMagenta+2, kMagenta+3, kMagenta+3, kMagenta+4, kMagenta+4},
3041    { kPink, kPink-1, kPink-2, kPink-3, kPink-4, kPink-5, kPink-6, kPink-7, kPink-8, kPink-9},
3042    { kPink, kPink+1, kPink+2, kPink+3, kPink+4, kPink+5, kPink+6, kPink+7, kPink+8, kPink+9},
3043 };
3044
3045 Int_t colorAll[22] =
3046 {
3047 kBlue+4, kBlue+2, kBlue, kAzure, kAzure-3, kAzure+7, kCyan, kCyan-7, kGreen-7, kGreen-4, kGreen, kSpring,
3048 kSpring+7, kSpring+8, kYellow, kOrange, kOrange-3, kOrange+7, kOrange+4, kRed, kRed+2, kMagenta
3049 };
3050
3051          if(str1.Contains("Tracks") || str1.Contains("tracks"))
3052          {
3053             element->SetRnrSelf(kTRUE);
3054
3055             if(element->HasChildren())
3056                element->SetRnrChildren(kTRUE);
3057
3058             TEveElement::List_i m = element->BeginChildren();
3059             TEveElement::List_i n = element->EndChildren();
3060             TEveElement::List_i l;
3061
3062             for(l = m; l != n; l++)
3063             {
3064                TEveElement* trackType = (TEveElement*) *l;
3065                str2 = trackType->GetElementName();
3066
3067                trackType->SetRnrSelf(kFALSE);
3068
3069                (dynamic_cast<TEveTrackList*>trackType)->GetPropagator()->SetMaxR(250);
3070
3071                if(trackType->HasChildren())
3072                   trackType->SetRnrChildren(kFALSE);
3073
3074                if(gDrawTracksType1->IsOn() && str2.Contains("Sigma < 3"))
3075                {
3076                   trackType->SetRnrSelf(kTRUE);
3077
3078                   if(trackType->HasChildren())
3079                   {
3080
3081                      trackType->SetRnrChildren(kTRUE);
3082                      TEveElement::List_i x = trackType->BeginChildren();
3083                      TEveElement::List_i y = trackType->EndChildren();
3084                      TEveElement::List_i z;
3085
3086                      for(z = x; z != y; z++)
3087                      {
3088
3089                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3090
3091                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3092                         {
3093                            if(posTrackColor == 0)
3094                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3095                            else
3096                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3097                         }
3098                         else
3099                         {
3100                            if(negTrackColor == 0)
3101                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3102                            else
3103                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3104                         }
3105
3106                         trackSingle1->SetLineStyle(1);
3107                         trackSingle1->SetRnrSelf(kTRUE);
3108
3109
3110                      }
3111
3112                   }
3113
3114                }
3115
3116
3117                if(gDrawTracksType2->IsOn() && str2.Contains("3 < Sigma < 5"))
3118                {
3119                   trackType->SetRnrSelf(kTRUE);
3120
3121                   if(trackType->HasChildren())
3122                   {
3123                      trackType->SetRnrChildren(kTRUE);
3124                      TEveElement::List_i x = trackType->BeginChildren();
3125                      TEveElement::List_i y = trackType->EndChildren();
3126                      TEveElement::List_i z;
3127
3128                      for(z = x; z != y; z++)
3129                      {
3130
3131                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3132
3133                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3134                         {
3135                            if(posTrackColor == 0)
3136                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3137                            else
3138                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3139                         }
3140                         else
3141                         {
3142                            if(negTrackColor == 0)
3143                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3144                            else
3145                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3146                         }
3147
3148                         trackSingle1->SetLineStyle(2);
3149                         trackSingle1->SetRnrSelf(kTRUE);
3150
3151                      }
3152                   }
3153                }
3154
3155                if(gDrawTracksType3->IsOn() && str2.Contains("5 < Sigma"))
3156                {
3157                   trackType->SetRnrSelf(kTRUE);
3158
3159                   if(trackType->HasChildren())
3160                   {
3161
3162                      trackType->SetRnrChildren(kTRUE);
3163                      TEveElement::List_i x = trackType->BeginChildren();
3164                      TEveElement::List_i y = trackType->EndChildren();
3165                      TEveElement::List_i z;
3166
3167                      for(z = x; z != y; z++)
3168                      {
3169
3170                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3171
3172                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3173                         {
3174                            if(posTrackColor == 0)
3175                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3176                            else
3177                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3178                         }
3179                         else
3180                         {
3181                            if(negTrackColor == 0)
3182                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3183                            else
3184                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3185                         }
3186
3187                         trackSingle1->SetLineStyle(3);
3188                         trackSingle1->SetRnrSelf(kTRUE);
3189
3190                      }
3191                   }
3192                }
3193
3194                if(gDrawTracksType4->IsOn() && str2.Contains("no ITS refit"))
3195                {
3196                   trackType->SetRnrSelf(kTRUE);
3197
3198                   if(trackType->HasChildren())
3199                   {
3200
3201                      trackType->SetRnrChildren(kTRUE);
3202                      TEveElement::List_i x = trackType->BeginChildren();
3203                      TEveElement::List_i y = trackType->EndChildren();
3204                      TEveElement::List_i z;
3205
3206                      for(z = x; z != y; z++)
3207                      {
3208                         TEveElement* trackSingle = (TEveElement*) *z;
3209                         trackSingle->SetRnrSelf(kTRUE);
3210                      }
3211                   }
3212                }
3213
3214                if(gDrawTracksType5->IsOn() && str2.Contains("no TPC refit"))
3215                {
3216                   trackType->SetRnrSelf(kTRUE);
3217
3218                   if(trackType->HasChildren())
3219                   {
3220
3221                      trackType->SetRnrChildren(kTRUE);
3222                      TEveElement::List_i x = trackType->BeginChildren();
3223                      TEveElement::List_i y = trackType->EndChildren();
3224                      TEveElement::List_i z;
3225
3226                      for(z = x; z != y; z++)
3227                      {
3228                         TEveElement* trackSingle = (TEveElement*) *z;
3229                         trackSingle->SetRnrSelf(kTRUE);
3230                      }
3231                   }
3232                }
3233
3234                if(gDrawTracksType6->IsOn() && str2.Contains("ITS ncl>=3"))
3235                {
3236                   trackType->SetRnrSelf(kTRUE);
3237
3238                   if(trackType->HasChildren())
3239                   {
3240
3241                      trackType->SetRnrChildren(kTRUE);
3242                      TEveElement::List_i x = trackType->BeginChildren();
3243                      TEveElement::List_i y = trackType->EndChildren();
3244                      TEveElement::List_i z;
3245
3246                      for(z = x; z != y; z++)
3247                      {
3248                         TEveElement* trackSingle = (TEveElement*) *z;
3249                         trackSingle->SetRnrSelf(kTRUE);
3250                      }
3251                   }
3252                }
3253
3254                if(gDrawTracksType7->IsOn() && str2.Contains("ITS others"))
3255                {
3256                   trackType->SetRnrSelf(kTRUE);
3257
3258                   if(trackType->HasChildren())
3259                   {
3260
3261                      trackType->SetRnrChildren(kTRUE);
3262                      TEveElement::List_i x = trackType->BeginChildren();
3263                      TEveElement::List_i y = trackType->EndChildren();
3264                      TEveElement::List_i z;
3265
3266                      for(z = x; z != y; z++)
3267                      {
3268                         TEveElement* trackSingle = (TEveElement*) *z;
3269                         trackSingle->SetRnrSelf(kTRUE);
3270                      }
3271                   }
3272                }
3273
3274             }
3275
3276             continue;
3277          }
3278
3279       }
3280
3281       if(gDrawClusters->IsOn())
3282       {
3283
3284          TEvePointSetArray * cc = 0;
3285          TEvePointSet* clusters = 0;
3286
3287          if((str1.Contains("Clusters") && !str1.Contains("TPC")) || str1.Contains("Colorized"))
3288          {
3289
3290             if(!gCutOnEta->IsOn())
3291             {
3292                element->SetRnrSelf(kTRUE);
3293                element->SetRnrChildren(kTRUE);
3294
3295                   if(gEve->GetEventScene()->FirstChild()->FindChild("ITS ClCut"))
3296                      gEve->GetEventScene()->FirstChild()->FindChild("ITS ClCut")->Destroy();
3297
3298                continue;
3299             }
3300             else
3301             {
3302                element->SetRnrSelf(kFALSE);
3303                element->SetRnrChildren(kFALSE);
3304
3305                if(str1.Contains("ITS"))
3306                {
3307
3308                   clusters = dynamic_cast<TEvePointSet*>(element);
3309
3310                   if(gEve->GetEventScene()->FirstChild()->FindChild("ITS ClCut"))
3311                      gEve->GetEventScene()->FirstChild()->FindChild("ITS ClCut")->Destroy();
3312
3313                   pointset = new TEvePointSet(clusters->GetLastPoint());
3314                   pointset->SetMarkerStyle(4);
3315                   pointset->SetMarkerColor(kBlue);
3316                   pointset->SetMarkerSize(0.4);
3317                   pointset->SetName("ITS ClCut");
3318
3319                   for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3320                   {
3321
3322                      clusters->GetPoint(iCluster, x1, y1, z1);
3323
3324                      if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3325                      {
3326                         Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3327
3328                         if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3329                         {
3330                            pointset->SetNextPoint(x1, y1, z1);
3331                         }
3332                      }
3333                   }
3334
3335                   pointset->SetRnrSelf(kTRUE);
3336                   pointset->SetRnrChildren(kTRUE);
3337
3338                   gEve->AddElement(pointset);
3339
3340                }
3341
3342                if(str1.Contains("TPC"))
3343                {
3344
3345                   cc = new TEvePointSetArray("TPC ClCut");
3346                   cc->SetMainColor(kRed);
3347                   cc->SetMarkerStyle(4);
3348                   cc->SetMarkerSize(0.4);
3349                   cc->InitBins("Cluster Charge",
3350                                (dynamic_cast<TEvePointSetArray*>(element))->GetNBins()-2,
3351                                (dynamic_cast<TEvePointSetArray*>(element))->GetMin(),
3352                                (dynamic_cast<TEvePointSetArray*>(element))->GetMax());
3353
3354                   cc->GetBin(0)->SetMainColor(kGray);
3355                   cc->GetBin(0)->SetMarkerSize(0.4);
3356                   cc->GetBin(1)->SetMainColor(kBlue);
3357                   cc->GetBin(1)->SetMarkerSize(0.42);
3358                   cc->GetBin(2)->SetMainColor(kCyan);
3359                   cc->GetBin(2)->SetMarkerSize(0.44);
3360                   cc->GetBin(3)->SetMainColor(kGreen);
3361                   cc->GetBin(3)->SetMarkerSize(0.46);
3362                   cc->GetBin(4)->SetMainColor(kYellow);
3363                   cc->GetBin(4)->SetMarkerSize(0.48);
3364                   cc->GetBin(5)->SetMainColor(kRed);
3365                   cc->GetBin(5)->SetMarkerSize(0.50);
3366                   cc->GetBin(6)->SetMainColor(kMagenta);
3367                   cc->GetBin(6)->SetMarkerSize(0.52);
3368
3369                   Double_t range = (cc->GetMax()) - (cc->GetMin());
3370
3371                   if(gEve->GetEventScene()->FirstChild()->FindChild("TPC ClCut"))
3372                      gEve->GetEventScene()->FirstChild()->FindChild("TPC ClCut")->Destroy();
3373
3374                   for(Int_t iBin = 0; iBin < cc->GetNBins(); iBin++)
3375                   {
3376
3377                      clusters =(dynamic_cast<TEvePointSetArray*>(element))->GetBin(iBin);
3378
3379                      for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3380                      {
3381
3382                         clusters->GetPoint(iCluster, x1, y1, z1);
3383
3384                         if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3385                         {
3386                            Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3387
3388                            if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3389                            {
3390                               cc->Fill(x1, y1, z1,(range/(cc->GetNBins())*iBin)-1);
3391                            }
3392                         }
3393                      }
3394
3395                   }
3396
3397                   cc->SetRnrSelf(kTRUE);
3398                   cc->SetRnrChildren(kTRUE);
3399
3400                   gEve->AddElement(cc);
3401
3402                }
3403
3404                if(str1.Contains("TRD"))
3405                {
3406
3407                   clusters = dynamic_cast<TEvePointSet*>(element);
3408
3409                   if(gEve->GetEventScene()->FirstChild()->FindChild("TRD ClCut"))
3410                      gEve->GetEventScene()->FirstChild()->FindChild("TRD ClCut")->Destroy();
3411
3412                   pointset = new TEvePointSet(clusters->GetLastPoint());
3413                   pointset->SetMarkerStyle(4);
3414                   pointset->SetMarkerColor(kCyan);
3415                   pointset->SetMarkerSize(0.4);
3416                   pointset->SetName("TRD ClCut");
3417
3418                   for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3419                   {
3420
3421                      clusters->GetPoint(iCluster, x1, y1, z1);
3422
3423                      if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3424                      {
3425                         Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3426
3427                         if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3428                         {
3429                            pointset->SetNextPoint(x1, y1, z1);
3430                         }
3431                      }
3432                   }
3433
3434                   pointset->SetRnrSelf(kTRUE);
3435                   pointset->SetRnrChildren(kTRUE);
3436
3437                   gEve->AddElement(pointset);
3438
3439                   }
3440
3441                   if(str1.Contains("TOF"))
3442                   {
3443
3444                      clusters = dynamic_cast<TEvePointSet*>(element);
3445
3446                      if(gEve->GetEventScene()->FirstChild()->FindChild("TOF ClCut"))
3447                         gEve->GetEventScene()->FirstChild()->FindChild("TOF ClCut")->Destroy();
3448
3449                      pointset = new TEvePointSet(clusters->GetLastPoint());
3450                      pointset->SetMarkerStyle(4);
3451                      pointset->SetMarkerColor(kOrange+9);
3452                      pointset->SetMarkerSize(0.4);
3453                      pointset->SetName("TOF ClCut");
3454
3455                      for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3456                      {
3457
3458                         clusters->GetPoint(iCluster, x1, y1, z1);
3459
3460                         if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3461                         {
3462                            Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3463
3464                            if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3465                            {
3466                               pointset->SetNextPoint(x1, y1, z1);
3467                            }
3468                         }
3469                      }
3470
3471                      pointset->SetRnrSelf(kTRUE);
3472                      pointset->SetRnrChildren(kTRUE);
3473
3474                      gEve->AddElement(pointset);
3475
3476                   }
3477
3478                continue;
3479
3480             }
3481
3482          }
3483 /*
3484          if(str1.Contains("Colorized"))
3485          {
3486
3487            cout << "\n\n\n" << (dynamic_cast<TEvePointSetArray*>(element))->GetNBins() << "\n\n\n" << endl;
3488
3489             if(!gCutOnEta->IsOn())
3490             {
3491                element->SetRnrSelf(kTRUE);
3492                element->SetRnrChildren(kTRUE);
3493             }
3494             else
3495             {
3496                element->SetRnrSelf(kFALSE);
3497                element->SetRnrChildren(kFALSE);
3498             }
3499
3500             continue;
3501
3502          }
3503 */
3504       }
3505 /*
3506       if(str1.Contains("TPC") && str1.Contains("Clusters") && !str1.Contains("Colorized"))
3507       {
3508
3509          element->SetRnrChildren(kFALSE);
3510          element->SetRnrSelf(kFALSE);
3511
3512          if(gEve->GetEventScene()->FirstChild()->FindChild("TPC ClCut"))
3513             gEve->GetEventScene()->FirstChild()->FindChild("TPC ClCut")->Destroy();
3514
3515          if(gCutOnEta->IsOn())
3516          {
3517             clusters = dynamic_cast<TEvePointSet*>(element);
3518
3519             pointset = new TEvePointSet(clusters->GetLastPoint());
3520             pointset->SetMarkerStyle(4);
3521             pointset->SetMarkerColor(kBlue);
3522             pointset->SetMarkerSize(0.4);
3523             pointset->SetName("TPC ClCut");
3524
3525             for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3526             {
3527
3528                clusters->GetPoint(iCluster, x1, y1, z1);
3529
3530                if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3531                {
3532                   Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3533
3534                   if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3535                   {
3536                      pointset->SetNextPoint(x1, y1, z1);
3537                   }
3538                }
3539             }
3540
3541             pointset->SetRnrSelf(kTRUE);
3542             pointset->SetRnrChildren(kTRUE);
3543
3544             gEve->AddElement(pointset);
3545
3546          }
3547
3548          continue;
3549
3550       }
3551 */
3552       if(!str1.Contains("ClCut"))
3553       {
3554          element->SetRnrChildren(kFALSE);
3555          element->SetRnrSelf(kFALSE);
3556       }
3557
3558    }
3559
3560    if(gDrawTracks->IsOn() || gDrawV0s->IsOn() || gDrawCascades->IsOn() || gDrawKinks->IsOn())
3561    {
3562
3563       i = gEve->GetEventScene()->FirstChild()->FindChild("ESD Tracks by category")->BeginChildren();
3564       j = gEve->GetEventScene()->FirstChild()->FindChild("ESD Tracks by category")->EndChildren();
3565
3566       for(k = i; k != j; k++)
3567       {
3568
3569          TEveElement* trackList = (TEveElement*) *k;
3570
3571          TEveElement::List_i m = trackList->BeginChildren();
3572          TEveElement::List_i n = trackList->EndChildren();
3573          TEveElement::List_i l;
3574
3575          for(l = m; l != n; l++)
3576          {
3577
3578             AliEveTrack *track = dynamic_cast<AliEveTrack*>((TEveElement*) *l);
3579
3580             if(gCutOnMult->IsOn())
3581             {
3582
3583                Double_t draw = gRandom->Rndm();
3584
3585                if(draw > (gMultRangeNE->GetNumber())/100)
3586                {
3587
3588                   track->SetRnrSelf(kFALSE);
3589                   continue;
3590
3591                }
3592             }
3593
3594             if(gCutOnCls->IsOn())
3595             {
3596
3597                if(track->GetESDTrack()->GetTPCNcls() < gClsRangeNE->GetNumber())
3598                {
3599                      track->SetRnrSelf(kFALSE);
3600                      continue;
3601                }
3602
3603             }
3604
3605             if(gCutOnP->IsOn())
3606             {
3607
3608                if(gPRange->GetMax() == gPRange->GetLimitMax())
3609                {
3610
3611                   if(track->GetESDTrack()->P() < gPRange->GetMin())
3612                   {
3613                      track->SetRnrSelf(kFALSE);
3614                      continue;
3615                   }
3616
3617                }
3618
3619                else
3620                {
3621                   if(track->GetESDTrack()->P() < gPRange->GetMin() || track->GetESDTrack()->P() > gPRange->GetMax())
3622                   {
3623                      track->SetRnrSelf(kFALSE);
3624                      continue;
3625                   }
3626
3627                }
3628
3629             }
3630
3631             if(gCutOnPt->IsOn())
3632             {
3633
3634                if(gPtRange->GetMax() == gPtRange->GetLimitMax())
3635                {
3636
3637                   if(track->GetESDTrack()->Pt() < gPtRange->GetMin())
3638                   {
3639                      track->SetRnrSelf(kFALSE);
3640                      continue;
3641                   }
3642
3643                }
3644
3645                else
3646                {
3647                   if(track->GetESDTrack()->Pt() < gPtRange->GetMin() || track->GetESDTrack()->Pt() > gPtRange->GetMax())
3648                   {
3649                      track->SetRnrSelf(kFALSE);
3650                      continue;
3651                   }
3652
3653                }
3654
3655             }
3656
3657             if(gCutOnEta->IsOn())
3658             {
3659
3660                if(gEtaRange->GetMax() == gEtaRange->GetLimitMax() && gEtaRange->GetMin() == gEtaRange->GetLimitMin())
3661                   continue;
3662
3663                if(gEtaRange->GetMax() == gEtaRange->GetLimitMax())
3664                {
3665
3666                   if(track->GetESDTrack()->Eta() < gEtaRange->GetMin())
3667                   {
3668                      track->SetRnrSelf(kFALSE);
3669                      continue;
3670                   }
3671
3672                }
3673
3674                if(gEtaRange->GetMin() == gEtaRange->GetLimitMin())
3675                {
3676
3677                   if(track->GetESDTrack()->Eta() > gEtaRange->GetMax())
3678                   {
3679                      track->SetRnrSelf(kFALSE);
3680                      continue;
3681                   }
3682
3683                }
3684
3685                if(track->GetESDTrack()->Eta() < gEtaRange->GetMin() || track->GetESDTrack()->Eta() > gEtaRange->GetMax())
3686                {
3687                   track->SetRnrSelf(kFALSE);
3688                   continue;
3689                }
3690
3691             }
3692
3693          }
3694
3695       }
3696
3697 /*
3698       i = gEve->GetEventScene()->FirstChild()->FindChild("ESD v0")->BeginChildren();
3699       j = gEve->GetEventScene()->FirstChild()->FindChild("ESD v0")->EndChildren();
3700
3701       for(k = i; k != j; k++)
3702       {
3703
3704          AliEveV0 *v0 = dynamic_cast<AliEveV0*>((TEveElement*) *k);
3705
3706          if(gCutOnP->IsOn())
3707          {
3708
3709             if(gPRange->GetMax() == gPRange->GetLimitMax())
3710             {
3711
3712                if(v0->GetP() < gPRange->GetMin())
3713                {
3714                   v0->SetRnrSelf(kFALSE);
3715                   v0->SetRnrChildren(kFALSE);
3716                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
3717                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
3718                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
3719                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
3720                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
3721                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
3722                   continue;
3723                }
3724
3725             }
3726
3727             else
3728             {
3729                if(v0->GetP() < gPRange->GetMin() || v0->GetP() > gPRange->GetMax())
3730                {
3731                   v0->SetRnrSelf(kFALSE);
3732                   v0->SetRnrChildren(kFALSE);
3733                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
3734                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
3735                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
3736                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
3737                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
3738                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
3739                   continue;
3740                }
3741
3742             }
3743
3744          }
3745
3746          if(gCutOnPt->IsOn())
3747          {
3748
3749             if(gPtRange->GetMax() == gPtRange->GetLimitMax())
3750             {
3751
3752                if(v0->GetPt() < gPtRange->GetMin())
3753                {
3754                   v0->SetRnrSelf(kFALSE);
3755                   v0->SetRnrChildren(kFALSE);
3756                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
3757                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
3758                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
3759                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
3760                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
3761                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
3762                   continue;
3763                }
3764
3765             }
3766
3767             else
3768             {
3769                if(v0->GetPt() < gPtRange->GetMin() || v0->GetPt() > gPtRange->GetMax())
3770                {
3771                   v0->SetRnrSelf(kFALSE);
3772                   v0->SetRnrChildren(kFALSE);
3773                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
3774                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
3775                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
3776                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
3777                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
3778                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
3779                   continue;
3780                }
3781
3782             }
3783
3784          }
3785
3786          if(gCutOnEta->IsOn())
3787          {
3788
3789             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax() && gEtaRange->GetMax() == gEtaRange->GetLimitMax())
3790                continue;
3791
3792             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax())
3793             {
3794                if(v0->GetEta() < gEtaRange->GetMin())
3795                {
3796                   v0->SetRnrSelf(kFALSE);
3797                   v0->SetRnrChildren(kFALSE);
3798                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
3799                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
3800                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
3801                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
3802                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
3803                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
3804                   continue;
3805                }
3806
3807             }
3808
3809             if(gEtaRange->GetMin() == gEtaRange->GetLimitMin())
3810             {
3811
3812                if(v0->GetEta() > gEtaRange->GetMax())
3813                {
3814                   v0->SetRnrSelf(kFALSE);
3815                   v0->SetRnrChildren(kFALSE);
3816                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
3817                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
3818                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
3819                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
3820                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
3821                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
3822                   continue;
3823                }
3824
3825             }
3826
3827             if(v0->GetEta() < gEtaRange->GetMin() || v0->GetEta() > gEtaRange->GetMax())
3828             {
3829                v0->SetRnrSelf(kFALSE);
3830                v0->SetRnrChildren(kFALSE);
3831                v0->GetPosTrack()->SetRnrSelf(kFALSE);
3832                v0->GetNegTrack()->SetRnrSelf(kFALSE);
3833                v0->GetPointingLine()->SetRnrSelf(kFALSE);
3834                v0->GetPosTrack()->SetRnrChildren(kFALSE);
3835                v0->GetNegTrack()->SetRnrChildren(kFALSE);
3836                v0->GetPointingLine()->SetRnrChildren(kFALSE);
3837
3838                continue;
3839             }
3840
3841          }
3842
3843          v0->SetRnrSelf(kTRUE);
3844          v0->SetRnrChildren(kTRUE);
3845                v0->GetPosTrack()->SetRnrSelf(kTRUE);
3846                v0->GetNegTrack()->SetRnrSelf(kTRUE);
3847                v0->GetPointingLine()->SetRnrSelf(kTRUE);
3848                v0->GetPosTrack()->SetRnrChildren(kTRUE);
3849                v0->GetNegTrack()->SetRnrChildren(kTRUE);
3850                v0->GetPointingLine()->SetRnrChildren(kTRUE);
3851
3852       }
3853
3854
3855       i = gEve->GetEventScene()->FirstChild()->FindChild("ESD cascade")->BeginChildren();
3856       j = gEve->GetEventScene()->FirstChild()->FindChild("ESD cascade")->EndChildren();
3857
3858       for(k = i; k != j; k++)
3859       {
3860
3861          AliEveCascade *cascade = dynamic_cast<AliEveCascade*>((TEveElement*) *k);
3862
3863          if(gCutOnP->IsOn())
3864          {
3865
3866             if(gPRange->GetMax() == gPRange->GetLimitMax())
3867             {
3868
3869                if(cascade->GetPtot() < gPRange->GetMin())
3870                {
3871                   cascade->SetRnrSelf(kFALSE);
3872                   cascade->SetRnrChildren(kFALSE);
3873                   continue;
3874                }
3875
3876             }
3877
3878             else
3879             {
3880                if(cascade->GetPtot() < gPRange->GetMin() || cascade->GetPtot() > gPRange->GetMax())
3881                {
3882                   cascade->SetRnrSelf(kFALSE);
3883                   cascade->SetRnrChildren(kFALSE);
3884                   continue;
3885                }
3886
3887             }
3888
3889          }
3890
3891          if(gCutOnPt->IsOn())
3892          {
3893
3894             if(gPtRange->GetMax() == gPtRange->GetLimitMax())
3895             {
3896
3897                if(cascade->GetPt() < gPtRange->GetMin())
3898                {
3899                   cascade->SetRnrSelf(kFALSE);
3900                   cascade->SetRnrChildren(kFALSE);
3901                   continue;
3902                }
3903
3904             }
3905
3906             else
3907             {
3908                if(cascade->GetPt() < gPtRange->GetMin() || cascade->GetPt() > gPtRange->GetMax())
3909                {
3910                   cascade->SetRnrSelf(kFALSE);
3911                   cascade->SetRnrChildren(kFALSE);
3912                   continue;
3913                }
3914
3915             }
3916
3917          }
3918
3919          if(gCutOnEta->IsOn())
3920          {
3921
3922             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax() && gEtaRange->GetMax() == gEtaRange->GetLimitMax())
3923                continue;
3924
3925             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax())
3926             {
3927                if(cascade->GetEta() < gEtaRange->GetMin())
3928                {
3929                   cascade->SetRnrSelf(kFALSE);
3930                   cascade->SetRnrChildren(kFALSE);
3931                   continue;
3932                }
3933
3934             }
3935
3936             if(gEtaRange->GetMin() == gEtaRange->GetLimitMin())
3937             {
3938
3939                if(cascade->GetEta() > gEtaRange->GetMax())
3940                {
3941                   cascade->SetRnrSelf(kFALSE);
3942                   cascade->SetRnrChildren(kFALSE);
3943                   continue;
3944                }
3945
3946             }
3947
3948             if(cascade->GetEta() < gEtaRange->GetMin() || cascade->GetEta() > gEtaRange->GetMax())
3949             {
3950                cascade->SetRnrSelf(kFALSE);
3951                cascade->SetRnrChildren(kFALSE);
3952                continue;
3953             }
3954
3955          }
3956
3957          cascade->SetRnrSelf(kTRUE);
3958          cascade->SetRnrChildren(kTRUE);
3959
3960       }
3961
3962
3963       i = gEve->GetEventScene()->FirstChild()->FindChild("ESD kink")->BeginChildren();
3964       j = gEve->GetEventScene()->FirstChild()->FindChild("ESD kink")->EndChildren();
3965
3966       for(k = i; k != j; k++)
3967       {
3968
3969          AliEveKink *kink = dynamic_cast<AliEveKink*>((TEveElement*) *k);
3970
3971          if(gCutOnP->IsOn())
3972          {
3973
3974             if(gPRange->GetMax() == gPRange->GetLimitMax())
3975             {
3976
3977                if(kink->GetESDTrack()->P() < gPRange->GetMin())
3978                {
3979                   kink->SetRnrSelf(kFALSE);
3980                   kink->SetRnrChildren(kFALSE);
3981                   continue;
3982                }
3983
3984             }
3985
3986             else
3987             {
3988                if(kink->GetESDTrack()->P() < gPRange->GetMin() || kink->GetESDTrack()->P() > gPRange->GetMax())
3989                {
3990                   kink->SetRnrSelf(kFALSE);
3991                   kink->SetRnrChildren(kFALSE);
3992                   continue;
3993                }
3994
3995             }
3996
3997          }
3998
3999          if(gCutOnPt->IsOn())
4000          {
4001
4002             if(gPtRange->GetMax() == gPtRange->GetLimitMax())
4003             {
4004
4005                if(kink->GetESDTrack()->Pt() < gPtRange->GetMin())
4006                {
4007                   kink->SetRnrSelf(kFALSE);
4008                   kink->SetRnrChildren(kFALSE);
4009                   continue;
4010                }
4011
4012             }
4013
4014             else
4015             {
4016                if(kink->GetESDTrack()->Pt() < gPtRange->GetMin() || kink->GetESDTrack()->Pt() > gPtRange->GetMax())
4017                {
4018                   kink->SetRnrSelf(kFALSE);
4019                   kink->SetRnrChildren(kFALSE);
4020                   continue;
4021                }
4022
4023             }
4024
4025          }
4026
4027          if(gCutOnEta->IsOn())
4028          {
4029
4030             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax() && gEtaRange->GetMax() == gEtaRange->GetLimitMax())
4031                continue;
4032
4033             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax())
4034             {
4035                if(kink->GetESDTrack()->Eta() < gEtaRange->GetMin())
4036                {
4037                   kink->SetRnrSelf(kFALSE);
4038                   kink->SetRnrChildren(kFALSE);
4039                   continue;
4040                }
4041
4042             }
4043
4044             if(gEtaRange->GetMin() == gEtaRange->GetLimitMin())
4045             {
4046
4047                if(kink->GetESDTrack()->Eta() > gEtaRange->GetMax())
4048                {
4049                   kink->SetRnrSelf(kFALSE);
4050                   kink->SetRnrChildren(kFALSE);
4051                   continue;
4052                }
4053
4054             }
4055
4056             if(kink->GetESDTrack()->Eta() < gEtaRange->GetMin() || kink->GetESDTrack()->Eta() > gEtaRange->GetMax())
4057             {
4058                kink->SetRnrSelf(kFALSE);
4059                kink->SetRnrChildren(kFALSE);
4060                continue;
4061             }
4062
4063          }
4064
4065          kink->SetRnrSelf(kTRUE);
4066          kink->SetRnrChildren(kTRUE);
4067
4068       }
4069 */
4070
4071   }
4072
4073   TEveElement* top = gEve->GetCurrentEvent();
4074
4075   AliEveMultiView *mv = AliEveMultiView::Instance();
4076
4077   mv->DestroyEventRPhi();
4078   mv->DestroyEventRhoZ();
4079
4080   mv->ImportEventRPhi(top);
4081   mv->ImportEventRhoZ(top);
4082
4083   gEve->FullRedraw3D(kFALSE, kTRUE);
4084
4085 }
4086
4087 //______________________________________________________________________________
4088
4089 void SetCutsWindow::CloseTab()
4090 {
4091
4092       TEveBrowser *browser = gEve->GetBrowser();
4093       Int_t current = browser->GetTabLeft()->GetCurrent();
4094
4095       browser->GetTabLeft()->RemoveTab(current);
4096
4097 }
4098
4099 //______________________________________________________________________________
4100
4101 void alieve_set_cuts()
4102 {
4103
4104       TEveBrowser *browser = gEve->GetBrowser();
4105
4106       browser->StartEmbedding(TRootBrowser::kLeft);
4107
4108       new SetCutsWindow();
4109
4110       browser->StopEmbedding("Cut Selection");
4111
4112 }