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