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 //   TCanvas* pad3 = 0;
2358
2359 //   TH1D* histMult = new TH1D("Multiplicity\n", "AliEve Multiplicity histogram", 1000, 0.0, 1000.0);
2360 //   TH1D* histNcls = new TH1D("Number of ITS clusters\n", "AliEve Multiplicity histogram", 10000, 0.0, 10000.0);
2361
2362    if(gDrawHistograms[6])
2363    {
2364          nHistos1++;
2365          TH1D* histPt = new TH1D("Pt\n", "AliEve Pt histogram", 1000, 0.0, 1000.0);
2366    }
2367
2368    if(gDrawHistograms[7])
2369    {
2370          nHistos1++;
2371          TH1D* histEta = new TH1D("#eta\nAll Events", "AliEve #eta histogram", 100, -1.5, 1.5);
2372    }
2373
2374    if(gDrawHistograms[8])
2375    {
2376          nHistos1++;
2377          TH1D* histPhi = new TH1D("#phi\nAll Events", "AliEve #phi histogram", 100, 0.0, 2*TMath::Pi());
2378    }
2379
2380    if(gDrawHistograms[9])
2381    {
2382          nHistos2++;
2383          TH2D* histPhiPt = new TH2D("#phi-Pt\nAll Events", "AliEve #phi-Pt histogram", 100, 0.0, 2*TMath::Pi(), 100, 0.0, 5.0);
2384    }
2385
2386    if(gDrawHistograms[10])
2387    {
2388          nHistos2++;
2389          TH2D* histPtY = new TH2D("Pt-Y\nAll Events", "AliEve Pt-y histogram", 100, 0.0, 5.0, 100, -1.5, 1.5);
2390    }
2391
2392    if(gDrawHistograms[11])
2393    {
2394          nHistos2++;
2395          TH2D* histEtaPhi = new TH2D("#eta-#phi\nAll Events", "AliEve #eta-#phi histogram", 100, 1.5, 1.5, 100, 0.0, 2*TMath::Pi());
2396    }
2397
2398    Int_t nEvents = AliEveEventManager::GetMaster()->GetMaxEventId();
2399
2400    AliEveEventManager::GetMaster()->GotoEvent(0);
2401
2402   ofstream myresult1(TString::Format("foundMultiplicity.txt"));
2403
2404    for(Int_t i = 0; i <= nEvents; i++)
2405    {
2406
2407    AliESDEvent* esd = AliEveEventManager::AssertESD();
2408 /*
2409    if(esd->GetMultiplicity())
2410      histMult->Fill(esd->GetMultiplicity()->GetNumberOfTracklets());
2411
2412    if(esd->GetMultiplicity())
2413       histNcls->Fill(esd->GetMultiplicity()->GetNumberOfITSClusters(0));
2414
2415    if(esd->GetMultiplicity()->GetNumberOfTracklets())
2416        myresult1 << i << "   " << esd->GetMultiplicity()->GetNumberOfTracklets() << endl;
2417 */
2418    if(esd->GetNumberOfTracks())
2419    {
2420
2421       for(Int_t j = 0; j < esd->GetNumberOfTracks(); j++)
2422       {
2423
2424          AliESDtrack* track = esd->GetTrack(j);
2425
2426          if(gDrawHistograms[6])
2427             histPt->Fill(track->Pt());
2428          if(gDrawHistograms[7])
2429             histEta->Fill(track->Eta());
2430          if(gDrawHistograms[8])
2431             histPhi->Fill(track->Phi());
2432          if(gDrawHistograms[9])
2433             histPhiPt->Fill(track->Phi(),track->Pt());
2434          if(gDrawHistograms[10])
2435             histPtY->Fill(track->Pt(),track->Y());
2436          if(gDrawHistograms[11])
2437             histEtaPhi->Fill(track->Eta(),track->Phi());
2438
2439       }
2440
2441    }
2442
2443       AliEveEventManager::GetMaster()->NextEvent();
2444
2445    }
2446
2447    switch(nHistos1)
2448    {
2449       case 1:
2450          pad1 = new TCanvas("AliEve 1D histograms - All Events","AliEve 1D histograms - All Events",800,600);
2451          if(gDrawHistograms[6])
2452             histPt->Draw();
2453          if(gDrawHistograms[7])
2454             histEta->Draw();
2455          if(gDrawHistograms[8])
2456             histPhi->Draw();
2457          break;
2458
2459       case 2:
2460          pad1 = new TCanvas("AliEve 1D histograms - All Events","AliEve 1D histograms - All Events",1200,500);
2461          pad1->Divide(2,1);
2462          if(!gDrawHistograms[6])
2463          {
2464             pad1->cd(1);
2465             histEta->Draw();
2466             pad1->cd(2);
2467             histPhi->Draw();
2468          }
2469          if(!gDrawHistograms[7])
2470          {
2471             pad1->cd(1);
2472             histPt->Draw();
2473             pad1->cd(2);
2474             histPhi->Draw();
2475          }
2476          if(!gDrawHistograms[8])
2477          {
2478             pad1->cd(1);
2479             histPt->Draw();
2480             pad1->cd(2);
2481             histEta->Draw();
2482          }
2483          break;
2484
2485       case 3:
2486          pad1 = new TCanvas("AliEve 1D histograms - All Events","AliEve 1D histograms - All Events",1200,500);
2487          pad1->Divide(3,1);
2488          pad1->cd(1);
2489          histPt->Draw();
2490          pad1->cd(2);
2491          histEta->Draw();
2492          pad1->cd(3);
2493          histPhi->Draw();
2494          break;
2495
2496       default:
2497          break;
2498    }
2499
2500    switch(nHistos2)
2501    {
2502       case 1:
2503          pad2 = new TCanvas("AliEve 2D histograms - All Events","AliEve 2D histograms - All Events",800,600);
2504          if(gDrawHistograms[9])
2505             histPt->Draw();
2506          if(gDrawHistograms[10])
2507             histEta->Draw();
2508          if(gDrawHistograms[11])
2509             histPhi->Draw();
2510          break;
2511
2512       case 2:
2513          pad2 = new TCanvas("AliEve 2D histograms - All Events","AliEve 2D histograms - All Events",1200,500);
2514          pad2->Divide(2,1);
2515          if(!gDrawHistograms[9])
2516          {
2517             pad2->cd(1);
2518             histPtY->Draw();
2519             pad2->cd(2);
2520             histEtaPhi->Draw();
2521          }
2522          if(!gDrawHistograms[10])
2523          {
2524             pad2->cd(1);
2525             histPhiPt->Draw();
2526             pad2->cd(2);
2527             histEtaPhi->Draw();
2528          }
2529          if(!gDrawHistograms[11])
2530          {
2531             pad2->cd(1);
2532             histPhiPt->Draw();
2533             pad2->cd(2);
2534             histPtY->Draw();
2535          }
2536          break;
2537
2538       case 3:
2539          pad2 = new TCanvas("AliEve 2D histograms - All Events","AliEve 2D histograms - All Events",1200,500);
2540          pad2->Divide(3,1);
2541          pad2->cd(1);
2542          histPhiPt->Draw();
2543          pad2->cd(2);
2544          histPtY->Draw();
2545          pad2->cd(3);
2546          histEtaPhi->Draw();
2547          break;
2548
2549       default:
2550          break;
2551    }
2552
2553 /*
2554    pad3 = new TCanvas("AliEve 1D histograms - All Events","AliEve 1D histograms - All Events",1200,500);
2555    pad3->Divide(2,1);
2556    pad3->cd(1);
2557    histMult->Draw();
2558    pad3->cd(2);
2559    histNcls->Draw();
2560 */
2561
2562   myresult1.close();
2563
2564    return;
2565
2566 }
2567
2568 //______________________________________________________________________________
2569
2570 void SetCutsWindow::DrawResiduals()
2571 {
2572
2573    TEveUtil::Macro("make_residuals.C");
2574
2575    return;
2576
2577 }
2578
2579 //______________________________________________________________________________
2580
2581 Int_t SetCutsWindow::GetTrackColorByMomentum(Double_t momentum, Int_t size)
2582 {
2583
2584
2585    Double_t step = 1.0/size;
2586
2587    for(Int_t i = 0; i < size; i++)
2588    {
2589
2590       switch(gTrackColorScale->GetSelected())
2591       {
2592
2593          case 1:
2594             if(momentum > i*step && momentum <= (i+1)*step)
2595                return i;
2596             break;
2597
2598          case 2:
2599             if(momentum > TMath::Log(1+i*step) && momentum <= TMath::Log(1+(i+1)*step))
2600                return i;
2601             break;
2602
2603          case 3:
2604             if(momentum > TMath::Power(i*step,0.5) && momentum <= TMath::Power((i+1)*step,0.5))
2605                return i;
2606             break;
2607
2608          default:
2609             if(momentum > i*step && momentum <= (i+1)*step)
2610                return i;
2611             break;
2612       }
2613
2614    }
2615
2616    return i-1;
2617
2618 }
2619
2620 //______________________________________________________________________________
2621
2622 void SetCutsWindow::SetStandardCuts()
2623 {
2624
2625    gDrawV0s->SetOn(kFALSE,kFALSE);
2626    gDrawCascades->SetOn(kFALSE,kFALSE);
2627    gDrawKinks->SetOn(kFALSE,kFALSE);
2628    gDrawVertex->SetOn(kFALSE,kFALSE);
2629    gDrawTracklets->SetOn(kFALSE,kFALSE);
2630    gDrawTracks->SetOn(kTRUE,kFALSE);
2631    gDrawClusters->SetOn(kFALSE,kFALSE);
2632    gDrawTracksType1->SetOn(kTRUE,kFALSE);
2633    gDrawTracksType2->SetOn(kTRUE,kFALSE);
2634    gDrawTracksType3->SetOn(kTRUE,kFALSE);
2635    gDrawTracksType4->SetOn(kFALSE,kFALSE);
2636    gDrawTracksType5->SetOn(kFALSE,kFALSE);
2637    gDrawTracksType6->SetOn(kFALSE,kFALSE);
2638    gDrawTracksType7->SetOn(kFALSE,kFALSE);
2639    gCutOnP->SetOn(kFALSE,kFALSE);
2640    gCutOnPt->SetOn(kTRUE,kFALSE);
2641    gCutOnEta->SetOn(kTRUE,kFALSE);
2642    gCutOnMult->SetOn(kFALSE,kFALSE);
2643    gCutOnCls->SetOn(kTRUE,kFALSE);
2644    gPtRange->SetValues(0.15,gPtRange->GetLimitMax());
2645    gEtaRange->SetValues(-0.9,0.9);
2646    gClsRangeNE->SetNumber(70);
2647    gClsRange->SetPosition(70);
2648
2649 }
2650
2651 //______________________________________________________________________________
2652
2653 void SetCutsWindow::AddMomentumVectors()
2654 {
2655
2656    Int_t posTrackColor= gPosColorList->GetSelected();
2657    Int_t negTrackColor= gNegColorList->GetSelected();
2658
2659 Int_t colorNeg[27][10] =
2660 {
2661    { kRed, kBlue, kOrange, kCyan, kGreen, kGray, kViolet, kMagenta, kSpring, kYellow },
2662    { kCyan-4, kCyan, kAzure+10, kAzure+8, kAzure+5, kAzure, kBlue, kBlue+1, kBlue+2, kBlue+3 },
2663    { kYellow-4, kYellow, kOrange+10, kOrange, kOrange+7, kOrange+10, kRed, kRed+1, kRed+2, kRed+3 },
2664    { kRed, kRed-1, kRed-2, kRed-3, kRed-4, kRed-5, kRed-6, kRed-7, kRed-8, kRed-9},
2665    { kRed, kRed, kRed+1, kRed+1, kRed+2, kRed+2, kRed+3, kRed+3, kRed+4, kRed+4},
2666    { kOrange, kOrange-1, kOrange-2, kOrange-3, kOrange-4, kOrange-5, kOrange-6, kOrange-7, kOrange-8, kOrange-9},
2667    { kOrange, kOrange+1, kOrange+2, kOrange+3, kOrange+4, kOrange+5, kOrange+6, kOrange+7, kOrange+8, kOrange+9},
2668    { kYellow, kYellow-1, kYellow-2, kYellow-3, kYellow-4, kYellow-5, kYellow-6, kYellow-7, kYellow-8, kYellow-9},
2669    { kYellow, kYellow, kYellow+1, kYellow+1, kYellow+2, kYellow+2, kYellow+3, kYellow+3, kYellow+4, kYellow+4},
2670    { kSpring, kSpring-1, kSpring-2, kSpring-3, kSpring-4, kSpring-5, kSpring-6, kSpring-7, kSpring-8, kSpring-9},
2671    { kSpring, kSpring+1, kSpring+2, kSpring+3, kSpring+4, kSpring+5, kSpring+6, kSpring+7, kSpring+8, kSpring+9},
2672    { kGreen, kGreen-1, kGreen-2, kGreen-3, kGreen-4, kGreen-5, kGreen-6, kGreen-7, kGreen-8, kGreen-9},
2673    { kGreen, kGreen, kGreen+1, kGreen+1, kGreen+2, kGreen+2, kGreen+3, kGreen+3, kGreen+4, kGreen+4},
2674    { kTeal, kTeal-1, kTeal-2, kTeal-3, kTeal-4, kTeal-5, kTeal-6, kTeal-7, kTeal-8, kTeal-9},
2675    { kTeal, kTeal+1, kTeal+2, kTeal+3, kTeal+4, kTeal+5, kTeal+6, kTeal+7, kTeal+8, kTeal+9},
2676    { kCyan, kCyan-1, kCyan-2, kCyan-3, kCyan-4, kCyan-5, kCyan-6, kCyan-7, kCyan-8, kCyan-9},
2677    { kCyan, kCyan, kCyan+1, kCyan+1, kCyan+2, kCyan+2, kCyan+3, kCyan+3, kCyan+4, kCyan+4},
2678    { kAzure, kAzure-1, kAzure-2, kAzure-3, kAzure-4, kAzure-5, kAzure-6, kAzure-7, kAzure-8, kAzure-9},
2679    { kAzure, kAzure+1, kAzure+2, kAzure+3, kAzure+4, kAzure+5, kAzure+6, kAzure+7, kAzure+8, kAzure+9},
2680    { kBlue, kBlue-1, kBlue-2, kBlue-3, kBlue-4, kBlue-5, kBlue-6, kBlue-7, kBlue-8, kBlue-9},
2681    { kBlue, kBlue, kBlue+1, kBlue+1, kBlue+2, kBlue+2, kBlue+3, kBlue+3, kBlue+4, kBlue+4},
2682    { kViolet, kViolet-1, kViolet-2, kViolet-3, kViolet-4, kViolet-5, kViolet-6, kViolet-7, kViolet-8, kViolet-9},
2683    { kViolet, kViolet+1, kViolet+2, kViolet+3, kViolet+4, kViolet+5, kViolet+6, kViolet+7, kViolet+8, kViolet+9},
2684    { kMagenta, kMagenta-1, kMagenta-2, kMagenta-3, kMagenta-4, kMagenta-5, kMagenta-6, kMagenta-7, kMagenta-8, kMagenta-9},
2685    { kMagenta, kMagenta, kMagenta+1, kMagenta+1, kMagenta+2, kMagenta+2, kMagenta+3, kMagenta+3, kMagenta+4, kMagenta+4},
2686    { kPink, kPink-1, kPink-2, kPink-3, kPink-4, kPink-5, kPink-6, kPink-7, kPink-8, kPink-9},
2687    { kPink, kPink+1, kPink+2, kPink+3, kPink+4, kPink+5, kPink+6, kPink+7, kPink+8, kPink+9},
2688 };
2689
2690 Int_t colorAll[22] =
2691 {
2692 kBlue+4, kBlue+2, kBlue, kAzure, kAzure-3, kAzure+7, kCyan, kCyan-7, kGreen-7, kGreen-4, kGreen, kSpring,
2693 kSpring+7, kSpring+8, kYellow, kOrange, kOrange-3, kOrange+7, kOrange+4, kRed, kRed+2, kMagenta
2694 };
2695
2696 //   Bool_t drawWithTracks = kTRUE;
2697
2698    if(gEve->GetEventScene()->FirstChild()->FindChild("Momentum Vectors"))
2699       gEve->GetEventScene()->FirstChild()->FindChild("Momentum Vectors")->Destroy();
2700
2701    TString str1 = 0;
2702    TString str2 = 0;
2703
2704    TEveElement::List_i i = gEve->GetEventScene()->FirstChild()->BeginChildren();
2705    TEveElement::List_i j = gEve->GetEventScene()->FirstChild()->EndChildren();
2706    TEveElement::List_i k;
2707
2708    TEveElementList* momentumVectorList = new TEveElementList("Momentum Vectors");
2709
2710    Double_t maxMomentum = 0;
2711    Double_t vectorLength = 600.0;
2712
2713    Double_t x1 = 0;
2714    Double_t y1 = 0;
2715    Double_t z1 = 0;
2716
2717    Double_t x2 = 0;
2718    Double_t y2 = 0;
2719    Double_t z2 = 0;
2720
2721    Bool_t draw = kFALSE;
2722
2723    Int_t mode = gVectorMode->GetSelected();
2724    Double_t cut = 0.1*gPMVRange->GetPosition();
2725
2726    //==============================================
2727    // find highest momentum (to normalize)
2728    //==============================================
2729
2730    if(mode != 3)
2731    {
2732    for(k = i; k != j; k++)
2733    {
2734       TEveElement* element = (TEveElement*) *k;
2735
2736       str1 = element->GetElementName();
2737
2738       if(str1.Contains("Tracks") || str1.Contains("tracks"))
2739       {
2740
2741          TEveElement::List_i m = element->BeginChildren();
2742          TEveElement::List_i n = element->EndChildren();
2743          TEveElement::List_i l;
2744
2745          for(l = m; l != n; l++)
2746          {
2747             TEveElement* trackType = (TEveElement*) *l;
2748             str2 = trackType->GetElementName();
2749
2750             if(str2.Contains("Sigma < 3"))
2751             {
2752                if(trackType->HasChildren())
2753                {
2754
2755                   TEveElement::List_i x = trackType->BeginChildren();
2756                   TEveElement::List_i y = trackType->EndChildren();
2757                   TEveElement::List_i z;
2758
2759                   for(z = x; z != y; z++)
2760                   {
2761
2762                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2763
2764                      if(trackSingle1->GetESDTrack()->P() > maxMomentum)
2765                        maxMomentum = trackSingle1->GetESDTrack()->P();
2766
2767                   }
2768                }
2769             }
2770
2771
2772             if(str2.Contains("3 < Sigma < 5"))
2773             {
2774
2775                if(trackType->HasChildren())
2776                {
2777
2778                   TEveElement::List_i x = trackType->BeginChildren();
2779                   TEveElement::List_i y = trackType->EndChildren();
2780                   TEveElement::List_i z;
2781
2782                   for(z = x; z != y; z++)
2783                   {
2784
2785                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2786
2787                      if(trackSingle1->GetESDTrack()->P() > maxMomentum)
2788                        maxMomentum = trackSingle1->GetESDTrack()->P();
2789
2790                   }
2791                }
2792             }
2793
2794             if(str2.Contains("5 < Sigma"))
2795             {
2796
2797                if(trackType->HasChildren())
2798                {
2799
2800                   TEveElement::List_i x = trackType->BeginChildren();
2801                   TEveElement::List_i y = trackType->EndChildren();
2802                   TEveElement::List_i z;
2803
2804                   for(z = x; z != y; z++)
2805                   {
2806
2807                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2808
2809                      if(trackSingle1->GetESDTrack()->P() > maxMomentum)
2810                        maxMomentum = trackSingle1->GetESDTrack()->P();
2811
2812
2813                   }
2814                }
2815             }
2816          }
2817       }
2818    }
2819    }
2820    //==============================================
2821    // clean the display
2822    //==============================================
2823 /*
2824    if(!drawWithTracks)
2825
2826       for(k = i; k != j; k++)
2827       {
2828          TEveElement* element = (TEveElement*) *k;
2829
2830          str1 = element->GetElementName();
2831
2832          element->SetRnrSelf(kFALSE);
2833
2834          if(element->HasChildren())
2835             element->SetRnrChildren(kFALSE);
2836
2837       }
2838
2839    }
2840 */
2841    //==============================================
2842    // draw momentum vectors
2843    //==============================================
2844
2845    TEveRecTrack rcNeg;
2846
2847    TEveTrackList* fTrackListV0Neg = new TEveTrackList("V0 Tracks Neg");
2848    fTrackListV0Neg->SetMainColor(kGreen-4);
2849    fTrackListV0Neg->SetMarkerColor(kYellow);
2850    fTrackListV0Neg->SetMarkerStyle(10);
2851    fTrackListV0Neg->SetMarkerSize(5);
2852
2853     TEveTrackPropagator* trkProp = fTrackListV0Neg->GetPropagator();
2854     trkProp->SetMagField(0.5);
2855     trkProp->SetMaxR(250);
2856
2857    if(mode == 1 && maxMomentum > 1)
2858       vectorLength = 100/TMath::Log(100*maxMomentum);
2859    if(mode == 2 && maxMomentum)
2860       vectorLength = vectorLength/maxMomentum;
2861    if(mode == 3)
2862       vectorLength = 100;
2863
2864    for(k = i; k != j; k++)
2865    {
2866       TEveElement* element = (TEveElement*) *k;
2867
2868       str1 = element->GetElementName();
2869
2870       if(str1.Contains("Tracks") || str1.Contains("tracks"))
2871       {
2872
2873          TEveElement::List_i m = element->BeginChildren();
2874          TEveElement::List_i n = element->EndChildren();
2875          TEveElement::List_i l;
2876
2877          for(l = m; l != n; l++)
2878          {
2879             TEveElement* trackType = (TEveElement*) *l;
2880             str2 = trackType->GetElementName();
2881
2882             if(str2.Contains("Sigma < 3"))
2883             {
2884
2885                if(trackType->HasChildren())
2886                {
2887
2888                   TEveElementList* momentumVectorList1 = new TEveElementList("sigma < 3");
2889
2890                   TEveElement::List_i x = trackType->BeginChildren();
2891                   TEveElement::List_i y = trackType->EndChildren();
2892                   TEveElement::List_i z;
2893
2894                   for(z = x; z != y; z++)
2895                   {
2896
2897                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
2898
2899                      Double_t p[3];
2900                      Double_t pos[3];
2901
2902                      trackSingle1->GetESDTrack()->GetTPCInnerParam()->GetPxPyPzAt(80,-5.01,p);
2903                      trackSingle1->GetESDTrack()->GetTPCInnerParam()->GetXYZAt(80,-5.01,pos);
2904
2905 //                     printf("%f %f %f\n",p[0],p[1],p[2]);
2906 //                     printf("%f %f %f\n",pos[0],pos[1],pos[2]);
2907
2908 //                     printf("%f %f %f %f\n",trackSingle1->GetESDTrack()->GetTPCPoints(0),trackSingle1->GetESDTrack()->GetTPCPoints(1),trackSingle1->GetESDTrack()->GetTPCPoints(2),trackSingle1->GetESDTrack()->GetTPCPoints(3));
2909
2910                      rcNeg.fP.Set(p);
2911                      rcNeg.fV.Set(pos);
2912                      rcNeg.fStatus = trackSingle1->GetESDTrack()->GetStatus();
2913                      rcNeg.fLabel = trackSingle1->GetESDTrack()->GetLabel();
2914                      Double_t momentum = trackSingle1->GetESDTrack()->P();
2915                      rcNeg.fBeta = momentum/TMath::Sqrt(momentum*momentum + TMath::C()*TMath::C()*trackSingle1->GetESDTrack()->M()*trackSingle1->GetESDTrack()->M());
2916                      rcNeg.fSign = trackSingle1->GetESDTrack()->GetSign();
2917
2918                      TEveTrack* track1 = new TEveTrack(&rcNeg, trkProp);
2919
2920                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
2921                         {
2922                            if(posTrackColor == 0)
2923                               track1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
2924                            else
2925                               track1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
2926                         }
2927                         else
2928                         {
2929                            if(negTrackColor == 0)
2930                               track1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
2931                            else
2932                               track1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
2933                         }
2934
2935                         track1->SetLineStyle(1);
2936                         track1->SetRnrSelf(kTRUE);
2937
2938                      fTrackListV0Neg->AddElement(track1);
2939
2940                      TEveLine* momentumVector = new TEveLine(TString::Format("Momentum Vector"));
2941
2942                      if(trackSingle1->GetESDTrack()->P() > cut)
2943                      {
2944
2945                         x1 = trackSingle1->GetESDTrack()->Xv();
2946                         y1 = trackSingle1->GetESDTrack()->Yv();
2947                         z1 = trackSingle1->GetESDTrack()->Zv();
2948
2949                         momentumVector->SetPoint(0, x1, y1, z1);
2950
2951                         if(mode == 1)
2952                         {
2953                            x2 = x1+vectorLength*TMath::Log(100*trackSingle1->GetESDTrack()->P())*trackSingle1->GetESDTrack()->Px();
2954                            y2 = y1+vectorLength*TMath::Log(100*trackSingle1->GetESDTrack()->P())*trackSingle1->GetESDTrack()->Py();
2955                            z2 = z1+vectorLength*TMath::Log(100*trackSingle1->GetESDTrack()->P())*trackSingle1->GetESDTrack()->Pz();
2956                         }
2957
2958                         if(mode == 2)
2959                         {
2960                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
2961                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
2962                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
2963                         }
2964
2965                         if(mode == 3)
2966                         {
2967                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
2968                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
2969                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
2970                         }
2971
2972                         if((mode != 1 && mode!= 2 && mode != 3) ||
2973                           ( mode == 3 && trackSingle1->GetESDTrack()->P() <= 0.01))
2974                            continue;
2975
2976                         momentumVector->SetPoint(1, x2, y2, z2);
2977
2978 /*
2979                         if(trackSingle1->GetESDTrack()->Charge() == -1)
2980                            momentumVector->SetLineColor(kGreen);
2981                         else
2982                            momentumVector->SetLineColor(kRed);
2983 */
2984                         momentumVector->SetLineColor(kRed);
2985
2986                         momentumVector->SetLineWidth(1);
2987                         momentumVector->SetLineStyle(0);
2988                         momentumVector->SetTitle(Form("%f GeV/c", trackSingle1->GetESDTrack()->P()));
2989
2990                         momentumVectorList1->AddElement(momentumVector);
2991
2992                      }
2993
2994                   }
2995
2996                   momentumVectorList->AddElement(momentumVectorList1);
2997
2998                   draw = kTRUE;
2999
3000                }
3001             }
3002
3003
3004             if(str2.Contains("3 < Sigma < 5"))
3005             {
3006
3007                if(trackType->HasChildren())
3008                {
3009
3010                   TEveElement::List_i x = trackType->BeginChildren();
3011                   TEveElement::List_i y = trackType->EndChildren();
3012                   TEveElement::List_i z;
3013
3014                   TEveElementList* momentumVectorList2 = new TEveElementList("3 < sigma < 5");
3015
3016                   for(z = x; z != y; z++)
3017                   {
3018
3019                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3020
3021                      TEveLine* momentumVector = new TEveLine(TString::Format("Momentum Vector"));
3022
3023                      Double_t p[3];
3024                      Double_t pos[3];
3025
3026                      trackSingle1->GetESDTrack()->GetTPCInnerParam()->GetPxPyPzAt(80,-5.01,p);
3027                      trackSingle1->GetESDTrack()->GetTPCInnerParam()->GetXYZAt(80,-5.01,pos);
3028
3029 //                     printf("%f %f %f\n",p[0],p[1],p[2]);
3030 //                     printf("%f %f %f\n",pos[0],pos[1],pos[2]);
3031
3032 //                     printf("%f %f %f %f\n",trackSingle1->GetESDTrack()->GetTPCPoints(0),trackSingle1->GetESDTrack()->GetTPCPoints(1),trackSingle1->GetESDTrack()->GetTPCPoints(2),trackSingle1->GetESDTrack()->GetTPCPoints(3));
3033
3034                      rcNeg.fP.Set(p);
3035                      rcNeg.fV.Set(pos);
3036                      rcNeg.fStatus = trackSingle1->GetESDTrack()->GetStatus();
3037                      rcNeg.fLabel = trackSingle1->GetESDTrack()->GetLabel();
3038                      Double_t momentum = trackSingle1->GetESDTrack()->P();
3039                      rcNeg.fBeta = momentum/TMath::Sqrt(momentum*momentum + TMath::C()*TMath::C()*trackSingle1->GetESDTrack()->M()*trackSingle1->GetESDTrack()->M());
3040                      rcNeg.fSign = trackSingle1->GetESDTrack()->GetSign();
3041
3042                      TEveTrack* track1 = new TEveTrack(&rcNeg, trkProp);
3043
3044                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3045                         {
3046                            if(posTrackColor == 0)
3047                               track1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3048                            else
3049                               track1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3050                         }
3051                         else
3052                         {
3053                            if(negTrackColor == 0)
3054                               track1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3055                            else
3056                               track1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3057                         }
3058
3059                         track1->SetLineStyle(1);
3060                         track1->SetRnrSelf(kTRUE);
3061
3062                      fTrackListV0Neg->AddElement(track1);
3063
3064
3065                      if(trackSingle1->GetESDTrack()->P() > cut)
3066                      {
3067
3068                         x1 = trackSingle1->GetESDTrack()->Xv();
3069                         y1 = trackSingle1->GetESDTrack()->Yv();
3070                         z1 = trackSingle1->GetESDTrack()->Zv();
3071
3072                         momentumVector->SetPoint(0, x1, y1, z1);
3073
3074                         if(mode == 1)
3075                         {
3076                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px()*TMath::Log(trackSingle1->GetESDTrack()->P());
3077                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py()*TMath::Log(trackSingle1->GetESDTrack()->P());
3078                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz()*TMath::Log(trackSingle1->GetESDTrack()->P());
3079                         }
3080
3081                         if(mode == 2)
3082                         {
3083                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
3084                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
3085                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
3086                         }
3087
3088                         if(mode == 3)
3089                         {
3090                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
3091                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
3092                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
3093                         }
3094
3095                         if(mode != 1 && mode!= 2 && mode != 3)
3096                            continue;
3097
3098                         momentumVector->SetPoint(1, x2, y2, z2);
3099
3100 /*
3101                         if(trackSingle1->GetESDTrack()->Charge() == -1)
3102                            momentumVector->SetLineColor(kGreen+2);
3103                         else
3104                            momentumVector->SetLineColor(kRed+2);
3105 */
3106                         momentumVector->SetLineColor(kRed+2);
3107
3108                         momentumVector->SetLineWidth(1);
3109                         momentumVector->SetLineStyle(0);
3110                         momentumVector->SetTitle(Form("%f GeV/c", trackSingle1->GetESDTrack()->P()));
3111
3112                         momentumVectorList2->AddElement(momentumVector);
3113
3114
3115                      }
3116
3117                   }
3118
3119                   momentumVectorList->AddElement(momentumVectorList2);
3120
3121                   draw = kTRUE;
3122
3123                }
3124             }
3125
3126             if(str2.Contains("5 < Sigma"))
3127             {
3128
3129                if(trackType->HasChildren())
3130                {
3131
3132                   TEveElementList* momentumVectorList3 = new TEveElementList("5 < sigma");
3133
3134                   TEveElement::List_i x = trackType->BeginChildren();
3135                   TEveElement::List_i y = trackType->EndChildren();
3136                   TEveElement::List_i z;
3137
3138                   for(z = x; z != y; z++)
3139                   {
3140
3141                      AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3142
3143                      TEveLine* momentumVector = new TEveLine(TString::Format("Momentum Vector"));
3144
3145                      Double_t p[3];
3146                      Double_t pos[3];
3147
3148                      trackSingle1->GetESDTrack()->GetTPCInnerParam()->GetPxPyPzAt(80,-5.01,p);
3149                      trackSingle1->GetESDTrack()->GetTPCInnerParam()->GetXYZAt(80,-5.01,pos);
3150
3151 //                     printf("%f %f %f\n",p[0],p[1],p[2]);
3152 //                     printf("%f %f %f\n",pos[0],pos[1],pos[2]);
3153
3154 //                     printf("%f %f %f %f\n",trackSingle1->GetESDTrack()->GetTPCPoints(0),trackSingle1->GetESDTrack()->GetTPCPoints(1),trackSingle1->GetESDTrack()->GetTPCPoints(2),trackSingle1->GetESDTrack()->GetTPCPoints(3));
3155
3156                      rcNeg.fP.Set(p);
3157                      rcNeg.fV.Set(pos);
3158                      rcNeg.fStatus = trackSingle1->GetESDTrack()->GetStatus();
3159                      rcNeg.fLabel = trackSingle1->GetESDTrack()->GetLabel();
3160                      Double_t momentum = trackSingle1->GetESDTrack()->P();
3161                      rcNeg.fBeta = momentum/TMath::Sqrt(momentum*momentum + TMath::C()*TMath::C()*trackSingle1->GetESDTrack()->M()*trackSingle1->GetESDTrack()->M());
3162                      rcNeg.fSign = trackSingle1->GetESDTrack()->GetSign();
3163
3164                      TEveTrack* track1 = new TEveTrack(&rcNeg, trkProp);
3165
3166                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3167                         {
3168                            if(posTrackColor == 0)
3169                               track1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3170                            else
3171                               track1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3172                         }
3173                         else
3174                         {
3175                            if(negTrackColor == 0)
3176                               track1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3177                            else
3178                               track1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3179                         }
3180
3181                         track1->SetLineStyle(2);
3182                         track1->SetRnrSelf(kTRUE);
3183
3184                      fTrackListV0Neg->AddElement(track1);
3185
3186                      if(trackSingle1->GetESDTrack()->P() > cut)
3187                      {
3188
3189                         x1 = trackSingle1->GetESDTrack()->Xv();
3190                         y1 = trackSingle1->GetESDTrack()->Yv();
3191                         z1 = trackSingle1->GetESDTrack()->Zv();
3192
3193                         momentumVector->SetPoint(0, x1, y1, z1);
3194
3195                         if(mode == 1)
3196                         {
3197                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px()*TMath::Log(trackSingle1->GetESDTrack()->P());
3198                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py()*TMath::Log(trackSingle1->GetESDTrack()->P());
3199                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz()*TMath::Log(trackSingle1->GetESDTrack()->P());
3200                         }
3201
3202                         if(mode == 2)
3203                         {
3204                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
3205                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
3206                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
3207                         }
3208
3209                         if(mode == 3)
3210                         {
3211                            x2 = x1+vectorLength*trackSingle1->GetESDTrack()->Px();
3212                            y2 = y1+vectorLength*trackSingle1->GetESDTrack()->Py();
3213                            z2 = z1+vectorLength*trackSingle1->GetESDTrack()->Pz();
3214                         }
3215
3216                         if(mode != 1 && mode!= 2 && mode != 3)
3217                            continue;
3218
3219                         momentumVector->SetPoint(1, x2, y2, z2);
3220 /*
3221                         if(trackSingle1->GetESDTrack()->Charge() == -1)
3222                            momentumVector->SetLineColor(kGreen+3);
3223                         else
3224                            momentumVector->SetLineColor(kRed+3);
3225 */
3226                         momentumVector->SetLineColor(kRed+3);
3227
3228                         momentumVector->SetLineWidth(1);
3229                         momentumVector->SetLineStyle(0);
3230                         momentumVector->SetTitle(Form("%f GeV/c", trackSingle1->GetESDTrack()->P()));
3231
3232                         momentumVectorList3->AddElement(momentumVector);
3233
3234                      }
3235
3236                   }
3237
3238                   momentumVectorList->AddElement(momentumVectorList3);
3239
3240                   draw = kTRUE;
3241
3242                }
3243             }
3244          }
3245       }
3246    }
3247
3248 //  fTrackListV0Neg->MakeTracks();
3249 //  fTrackListV0Neg->SetRnrChildren(kFALSE);
3250 //  gEve->AddElement(fTrackListV0Neg);
3251
3252   gEve->AddElement(momentumVectorList);
3253
3254   TEveElement* top = gEve->GetCurrentEvent();
3255
3256   AliEveMultiView *mv = AliEveMultiView::Instance();
3257
3258   mv->DestroyEventRPhi();
3259   mv->DestroyEventRhoZ();
3260
3261   mv->ImportEventRPhi(top);
3262   mv->ImportEventRhoZ(top);
3263
3264   gEve->FullRedraw3D(kFALSE, kTRUE);
3265
3266 }
3267
3268 //______________________________________________________________________________
3269
3270 void SetCutsWindow::SetCuts()
3271 {
3272
3273    TString str1 = 0;
3274    TString str2 = 0;
3275
3276    Int_t posTrackColor= gPosColorList->GetSelected();
3277    Int_t negTrackColor= gNegColorList->GetSelected();
3278
3279    TEveElement::List_i i = gEve->GetEventScene()->FirstChild()->BeginChildren();
3280    TEveElement::List_i j = gEve->GetEventScene()->FirstChild()->EndChildren();
3281    TEveElement::List_i k;
3282
3283    Double_t x1, y1, z1, x2, y2, z2;
3284
3285    for(k = i; k != j; k++)
3286    {
3287       TEveElement* element = (TEveElement*) *k;
3288
3289       str1 = element->GetElementName();
3290
3291       if(gDrawV0s->IsOn())
3292       {
3293          if(str1.Contains("ESD v0") || str1.Contains("ESD V0"))
3294          {
3295             element->SetRnrSelf(kTRUE);
3296
3297             if(element->HasChildren())
3298                element->SetRnrChildren(kTRUE);
3299
3300             continue;
3301          }
3302       }
3303
3304       if(gDrawCascades->IsOn())
3305       {
3306          if(str1.Contains("ESD cascade") || str1.Contains("ESD Cascade"))
3307          {
3308             element->SetRnrSelf(kTRUE);
3309
3310             if(element->HasChildren())
3311                element->SetRnrChildren(kTRUE);
3312
3313             continue;
3314          }
3315       }
3316
3317       if(gDrawKinks->IsOn())
3318       {
3319          if(str1.Contains("ESD kink") || str1.Contains("ESD Kink"))
3320          {
3321             element->SetRnrSelf(kTRUE);
3322
3323             if(element->HasChildren())
3324                element->SetRnrChildren(kTRUE);
3325
3326             continue;
3327          }
3328       }
3329
3330       if(gDrawVertex->IsOn())
3331       {
3332          if(str1.Contains("Primary Vertex") || str1.Contains("primary Vertex") || str1.Contains("Primary vertex") || str1.Contains("primary vertex"))
3333          {
3334             element->SetRnrSelf(kTRUE);
3335
3336             if(element->HasChildren())
3337                element->SetRnrChildren(kTRUE);
3338
3339             continue;
3340          }
3341       }
3342
3343       if(gDrawTracklets->IsOn())
3344       {
3345          if(str1.Contains("Tracklets") || str1.Contains("tracklets"))
3346          {
3347             element->SetRnrSelf(kTRUE);
3348
3349             if(element->HasChildren())
3350                element->SetRnrChildren(kTRUE);
3351
3352             continue;
3353          }
3354       }
3355
3356       if(gDrawTracks->IsOn())
3357       {
3358
3359 Int_t colorNeg[27][10] =
3360 {
3361    { kRed, kBlue, kOrange, kCyan, kGreen, kGray, kViolet, kMagenta, kSpring, kYellow },
3362    { kCyan-4, kCyan, kAzure+10, kAzure+8, kAzure+5, kAzure, kBlue, kBlue+1, kBlue+2, kBlue+3 },
3363    { kYellow-4, kYellow, kOrange+10, kOrange, kOrange+7, kOrange+10, kRed, kRed+1, kRed+2, kRed+3 },
3364    { kRed, kRed-1, kRed-2, kRed-3, kRed-4, kRed-5, kRed-6, kRed-7, kRed-8, kRed-9},
3365    { kRed, kRed, kRed+1, kRed+1, kRed+2, kRed+2, kRed+3, kRed+3, kRed+4, kRed+4},
3366    { kOrange, kOrange-1, kOrange-2, kOrange-3, kOrange-4, kOrange-5, kOrange-6, kOrange-7, kOrange-8, kOrange-9},
3367    { kOrange, kOrange+1, kOrange+2, kOrange+3, kOrange+4, kOrange+5, kOrange+6, kOrange+7, kOrange+8, kOrange+9},
3368    { kYellow, kYellow-1, kYellow-2, kYellow-3, kYellow-4, kYellow-5, kYellow-6, kYellow-7, kYellow-8, kYellow-9},
3369    { kYellow, kYellow, kYellow+1, kYellow+1, kYellow+2, kYellow+2, kYellow+3, kYellow+3, kYellow+4, kYellow+4},
3370    { kSpring, kSpring-1, kSpring-2, kSpring-3, kSpring-4, kSpring-5, kSpring-6, kSpring-7, kSpring-8, kSpring-9},
3371    { kSpring, kSpring+1, kSpring+2, kSpring+3, kSpring+4, kSpring+5, kSpring+6, kSpring+7, kSpring+8, kSpring+9},
3372    { kGreen, kGreen-1, kGreen-2, kGreen-3, kGreen-4, kGreen-5, kGreen-6, kGreen-7, kGreen-8, kGreen-9},
3373    { kGreen, kGreen, kGreen+1, kGreen+1, kGreen+2, kGreen+2, kGreen+3, kGreen+3, kGreen+4, kGreen+4},
3374    { kTeal, kTeal-1, kTeal-2, kTeal-3, kTeal-4, kTeal-5, kTeal-6, kTeal-7, kTeal-8, kTeal-9},
3375    { kTeal, kTeal+1, kTeal+2, kTeal+3, kTeal+4, kTeal+5, kTeal+6, kTeal+7, kTeal+8, kTeal+9},
3376    { kCyan, kCyan-1, kCyan-2, kCyan-3, kCyan-4, kCyan-5, kCyan-6, kCyan-7, kCyan-8, kCyan-9},
3377    { kCyan, kCyan, kCyan+1, kCyan+1, kCyan+2, kCyan+2, kCyan+3, kCyan+3, kCyan+4, kCyan+4},
3378    { kAzure, kAzure-1, kAzure-2, kAzure-3, kAzure-4, kAzure-5, kAzure-6, kAzure-7, kAzure-8, kAzure-9},
3379    { kAzure, kAzure+1, kAzure+2, kAzure+3, kAzure+4, kAzure+5, kAzure+6, kAzure+7, kAzure+8, kAzure+9},
3380    { kBlue, kBlue-1, kBlue-2, kBlue-3, kBlue-4, kBlue-5, kBlue-6, kBlue-7, kBlue-8, kBlue-9},
3381    { kBlue, kBlue, kBlue+1, kBlue+1, kBlue+2, kBlue+2, kBlue+3, kBlue+3, kBlue+4, kBlue+4},
3382    { kViolet, kViolet-1, kViolet-2, kViolet-3, kViolet-4, kViolet-5, kViolet-6, kViolet-7, kViolet-8, kViolet-9},
3383    { kViolet, kViolet+1, kViolet+2, kViolet+3, kViolet+4, kViolet+5, kViolet+6, kViolet+7, kViolet+8, kViolet+9},
3384    { kMagenta, kMagenta-1, kMagenta-2, kMagenta-3, kMagenta-4, kMagenta-5, kMagenta-6, kMagenta-7, kMagenta-8, kMagenta-9},
3385    { kMagenta, kMagenta, kMagenta+1, kMagenta+1, kMagenta+2, kMagenta+2, kMagenta+3, kMagenta+3, kMagenta+4, kMagenta+4},
3386    { kPink, kPink-1, kPink-2, kPink-3, kPink-4, kPink-5, kPink-6, kPink-7, kPink-8, kPink-9},
3387    { kPink, kPink+1, kPink+2, kPink+3, kPink+4, kPink+5, kPink+6, kPink+7, kPink+8, kPink+9},
3388 };
3389
3390 Int_t colorAll[22] =
3391 {
3392 kBlue+4, kBlue+2, kBlue, kAzure, kAzure-3, kAzure+7, kCyan, kCyan-7, kGreen-7, kGreen-4, kGreen, kSpring,
3393 kSpring+7, kSpring+8, kYellow, kOrange, kOrange-3, kOrange+7, kOrange+4, kRed, kRed+2, kMagenta
3394 };
3395
3396          if(str1.Contains("Tracks") || str1.Contains("tracks"))
3397          {
3398             element->SetRnrSelf(kTRUE);
3399
3400             if(element->HasChildren())
3401                element->SetRnrChildren(kTRUE);
3402
3403             TEveElement::List_i m = element->BeginChildren();
3404             TEveElement::List_i n = element->EndChildren();
3405             TEveElement::List_i l;
3406
3407             for(l = m; l != n; l++)
3408             {
3409                TEveElement* trackType = (TEveElement*) *l;
3410                str2 = trackType->GetElementName();
3411
3412                trackType->SetRnrSelf(kFALSE);
3413
3414 //               (dynamic_cast<TEveTrackList*>trackType)->GetPropagator()->SetMaxR(250);
3415
3416                if(trackType->HasChildren())
3417                   trackType->SetRnrChildren(kFALSE);
3418
3419                if(gDrawTracksType1->IsOn() && str2.Contains("Sigma < 3"))
3420                {
3421                   trackType->SetRnrSelf(kTRUE);
3422
3423                   if(trackType->HasChildren())
3424                   {
3425
3426                      trackType->SetRnrChildren(kTRUE);
3427                      TEveElement::List_i x = trackType->BeginChildren();
3428                      TEveElement::List_i y = trackType->EndChildren();
3429                      TEveElement::List_i z;
3430
3431                      for(z = x; z != y; z++)
3432                      {
3433
3434                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3435
3436                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3437                         {
3438                            if(posTrackColor == 0)
3439                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3440                            else
3441                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3442                         }
3443                         else
3444                         {
3445                            if(negTrackColor == 0)
3446                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3447                            else
3448                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3449                         }
3450
3451                         trackSingle1->SetLineStyle(1);
3452                         trackSingle1->SetRnrSelf(kTRUE);
3453
3454
3455                      }
3456
3457                   }
3458
3459                }
3460
3461
3462                if(gDrawTracksType2->IsOn() && str2.Contains("3 < Sigma < 5"))
3463                {
3464                   trackType->SetRnrSelf(kTRUE);
3465
3466                   if(trackType->HasChildren())
3467                   {
3468                      trackType->SetRnrChildren(kTRUE);
3469                      TEveElement::List_i x = trackType->BeginChildren();
3470                      TEveElement::List_i y = trackType->EndChildren();
3471                      TEveElement::List_i z;
3472
3473                      for(z = x; z != y; z++)
3474                      {
3475
3476                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3477
3478                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3479                         {
3480                            if(posTrackColor == 0)
3481                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3482                            else
3483                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3484                         }
3485                         else
3486                         {
3487                            if(negTrackColor == 0)
3488                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3489                            else
3490                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3491                         }
3492
3493                         trackSingle1->SetLineStyle(2);
3494                         trackSingle1->SetRnrSelf(kTRUE);
3495
3496                      }
3497                   }
3498                }
3499
3500                if(gDrawTracksType3->IsOn() && str2.Contains("5 < Sigma"))
3501                {
3502                   trackType->SetRnrSelf(kTRUE);
3503
3504                   if(trackType->HasChildren())
3505                   {
3506
3507                      trackType->SetRnrChildren(kTRUE);
3508                      TEveElement::List_i x = trackType->BeginChildren();
3509                      TEveElement::List_i y = trackType->EndChildren();
3510                      TEveElement::List_i z;
3511
3512                      for(z = x; z != y; z++)
3513                      {
3514
3515                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3516
3517                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3518                         {
3519                            if(posTrackColor == 0)
3520                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3521                            else
3522                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3523                         }
3524                         else
3525                         {
3526                            if(negTrackColor == 0)
3527                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3528                            else
3529                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3530                         }
3531
3532                         trackSingle1->SetLineStyle(3);
3533                         trackSingle1->SetRnrSelf(kTRUE);
3534
3535                      }
3536                   }
3537                }
3538
3539                if(gDrawTracksType4->IsOn() && str2.Contains("no ITS refit"))
3540                {
3541                   trackType->SetRnrSelf(kTRUE);
3542
3543                   if(trackType->HasChildren())
3544                   {
3545
3546                      trackType->SetRnrChildren(kTRUE);
3547                      TEveElement::List_i x = trackType->BeginChildren();
3548                      TEveElement::List_i y = trackType->EndChildren();
3549                      TEveElement::List_i z;
3550
3551                      for(z = x; z != y; z++)
3552                      {
3553
3554                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3555
3556                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3557                         {
3558                            if(posTrackColor == 0)
3559                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3560                            else
3561                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3562                         }
3563                         else
3564                         {
3565                            if(negTrackColor == 0)
3566                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3567                            else
3568                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3569                         }
3570
3571 //                        trackSingle1->SetLineStyle(3);
3572                         trackSingle1->SetRnrSelf(kTRUE);
3573
3574 //                        TEveElement* trackSingle = (TEveElement*) *z;
3575 //                        trackSingle->SetRnrSelf(kTRUE);
3576                      }
3577                   }
3578                }
3579
3580                if(gDrawTracksType5->IsOn() && str2.Contains("no TPC refit"))
3581                {
3582                   trackType->SetRnrSelf(kTRUE);
3583
3584                   if(trackType->HasChildren())
3585                   {
3586
3587                      trackType->SetRnrChildren(kTRUE);
3588                      TEveElement::List_i x = trackType->BeginChildren();
3589                      TEveElement::List_i y = trackType->EndChildren();
3590                      TEveElement::List_i z;
3591
3592                      for(z = x; z != y; z++)
3593                      {
3594
3595                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3596
3597                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3598                         {
3599                            if(posTrackColor == 0)
3600                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3601                            else
3602                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3603                         }
3604                         else
3605                         {
3606                            if(negTrackColor == 0)
3607                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3608                            else
3609                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3610                         }
3611
3612 //                        trackSingle1->SetLineStyle(3);
3613                         trackSingle1->SetRnrSelf(kTRUE);
3614
3615
3616 //                        TEveElement* trackSingle = (TEveElement*) *z;
3617 //                        trackSingle->SetRnrSelf(kTRUE);
3618                      }
3619                   }
3620                }
3621
3622                if(gDrawTracksType6->IsOn() && str2.Contains("ITS ncl>=3"))
3623                {
3624                   trackType->SetRnrSelf(kTRUE);
3625
3626                   if(trackType->HasChildren())
3627                   {
3628
3629                      trackType->SetRnrChildren(kTRUE);
3630                      TEveElement::List_i x = trackType->BeginChildren();
3631                      TEveElement::List_i y = trackType->EndChildren();
3632                      TEveElement::List_i z;
3633
3634                      for(z = x; z != y; z++)
3635                      {
3636
3637                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3638
3639                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3640                         {
3641                            if(posTrackColor == 0)
3642                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3643                            else
3644                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3645                         }
3646                         else
3647                         {
3648                            if(negTrackColor == 0)
3649                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3650                            else
3651                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3652                         }
3653
3654 //                        trackSingle1->SetLineStyle(3);
3655                         trackSingle1->SetRnrSelf(kTRUE);
3656
3657
3658
3659 //                        TEveElement* trackSingle = (TEveElement*) *z;
3660 //                        trackSingle->SetRnrSelf(kTRUE);
3661                      }
3662                   }
3663                }
3664
3665                if(gDrawTracksType7->IsOn() && str2.Contains("ITS others"))
3666                {
3667                   trackType->SetRnrSelf(kTRUE);
3668
3669                   if(trackType->HasChildren())
3670                   {
3671
3672                      trackType->SetRnrChildren(kTRUE);
3673                      TEveElement::List_i x = trackType->BeginChildren();
3674                      TEveElement::List_i y = trackType->EndChildren();
3675                      TEveElement::List_i z;
3676
3677                      for(z = x; z != y; z++)
3678                      {
3679
3680                         AliEveTrack* trackSingle1 = dynamic_cast<AliEveTrack*>((TEveElement*) *z);
3681
3682                         if(trackSingle1->GetESDTrack()->GetSign() > 0)
3683                         {
3684                            if(posTrackColor == 0)
3685                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3686                            else
3687                               trackSingle1->SetLineColor(colorNeg[posTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3688                         }
3689                         else
3690                         {
3691                            if(negTrackColor == 0)
3692                               trackSingle1->SetLineColor(colorAll[GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),22)]);
3693                            else
3694                               trackSingle1->SetLineColor(colorNeg[negTrackColor-1][GetTrackColorByMomentum(trackSingle1->GetESDTrack()->Pt(),10)]);
3695                         }
3696
3697 //                        trackSingle1->SetLineStyle(3);
3698                         trackSingle1->SetRnrSelf(kTRUE);
3699
3700
3701 //                        TEveElement* trackSingle = (TEveElement*) *z;
3702 //                        trackSingle->SetRnrSelf(kTRUE);
3703                      }
3704                   }
3705                }
3706
3707             }
3708
3709             continue;
3710          }
3711
3712       }
3713
3714       if(gDrawClusters->IsOn())
3715       {
3716
3717          TEvePointSetArray * cc = 0;
3718          TEvePointSet* clusters = 0;
3719
3720          if((str1.Contains("Clusters") && !str1.Contains("TPC")) || str1.Contains("Colorized"))
3721          {
3722
3723             if(!gCutOnEta->IsOn())
3724             {
3725                element->SetRnrSelf(kTRUE);
3726                element->SetRnrChildren(kTRUE);
3727
3728                   if(gEve->GetEventScene()->FirstChild()->FindChild("ITS ClCut"))
3729                      gEve->GetEventScene()->FirstChild()->FindChild("ITS ClCut")->Destroy();
3730
3731                continue;
3732             }
3733             else
3734             {
3735                element->SetRnrSelf(kFALSE);
3736                element->SetRnrChildren(kFALSE);
3737
3738                if(str1.Contains("ITS"))
3739                {
3740
3741                   clusters = dynamic_cast<TEvePointSet*>(element);
3742
3743                   if(gEve->GetEventScene()->FirstChild()->FindChild("ITS ClCut"))
3744                      gEve->GetEventScene()->FirstChild()->FindChild("ITS ClCut")->Destroy();
3745
3746                   pointset = new TEvePointSet(clusters->GetLastPoint());
3747                   pointset->SetMarkerStyle(4);
3748                   pointset->SetMarkerColor(kBlue);
3749                   pointset->SetMarkerSize(0.4);
3750                   pointset->SetName("ITS ClCut");
3751
3752                   for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3753                   {
3754
3755                      clusters->GetPoint(iCluster, x1, y1, z1);
3756
3757                      if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3758                      {
3759                         Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3760
3761                         if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3762                         {
3763                            pointset->SetNextPoint(x1, y1, z1);
3764                         }
3765                      }
3766                   }
3767
3768                   pointset->SetRnrSelf(kTRUE);
3769                   pointset->SetRnrChildren(kTRUE);
3770
3771                   gEve->AddElement(pointset);
3772
3773                }
3774
3775                if(str1.Contains("TPC"))
3776                {
3777
3778                   cc = new TEvePointSetArray("TPC ClCut");
3779                   cc->SetMainColor(kRed);
3780                   cc->SetMarkerStyle(4);
3781                   cc->SetMarkerSize(0.4);
3782                   cc->InitBins("Cluster Charge",
3783                                (dynamic_cast<TEvePointSetArray*>(element))->GetNBins()-2,
3784                                (dynamic_cast<TEvePointSetArray*>(element))->GetMin(),
3785                                (dynamic_cast<TEvePointSetArray*>(element))->GetMax());
3786
3787                   cc->GetBin(0)->SetMainColor(kGray);
3788                   cc->GetBin(0)->SetMarkerSize(0.4);
3789                   cc->GetBin(1)->SetMainColor(kBlue);
3790                   cc->GetBin(1)->SetMarkerSize(0.42);
3791                   cc->GetBin(2)->SetMainColor(kCyan);
3792                   cc->GetBin(2)->SetMarkerSize(0.44);
3793                   cc->GetBin(3)->SetMainColor(kGreen);
3794                   cc->GetBin(3)->SetMarkerSize(0.46);
3795                   cc->GetBin(4)->SetMainColor(kYellow);
3796                   cc->GetBin(4)->SetMarkerSize(0.48);
3797                   cc->GetBin(5)->SetMainColor(kRed);
3798                   cc->GetBin(5)->SetMarkerSize(0.50);
3799                   cc->GetBin(6)->SetMainColor(kMagenta);
3800                   cc->GetBin(6)->SetMarkerSize(0.52);
3801
3802                   Double_t range = (cc->GetMax()) - (cc->GetMin());
3803
3804                   if(gEve->GetEventScene()->FirstChild()->FindChild("TPC ClCut"))
3805                      gEve->GetEventScene()->FirstChild()->FindChild("TPC ClCut")->Destroy();
3806
3807                   for(Int_t iBin = 0; iBin < cc->GetNBins(); iBin++)
3808                   {
3809
3810                      clusters =(dynamic_cast<TEvePointSetArray*>(element))->GetBin(iBin);
3811
3812                      for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3813                      {
3814
3815                         clusters->GetPoint(iCluster, x1, y1, z1);
3816
3817                         if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3818                         {
3819                            Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3820
3821                            if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3822                            {
3823                               cc->Fill(x1, y1, z1,(range/(cc->GetNBins())*iBin)-1);
3824                            }
3825                         }
3826                      }
3827
3828                   }
3829
3830                   cc->SetRnrSelf(kTRUE);
3831                   cc->SetRnrChildren(kTRUE);
3832
3833                   gEve->AddElement(cc);
3834
3835                }
3836
3837                if(str1.Contains("TRD"))
3838                {
3839
3840                   clusters = dynamic_cast<TEvePointSet*>(element);
3841
3842                   if(gEve->GetEventScene()->FirstChild()->FindChild("TRD ClCut"))
3843                      gEve->GetEventScene()->FirstChild()->FindChild("TRD ClCut")->Destroy();
3844
3845                   pointset = new TEvePointSet(clusters->GetLastPoint());
3846                   pointset->SetMarkerStyle(4);
3847                   pointset->SetMarkerColor(kCyan);
3848                   pointset->SetMarkerSize(0.4);
3849                   pointset->SetName("TRD ClCut");
3850
3851                   for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3852                   {
3853
3854                      clusters->GetPoint(iCluster, x1, y1, z1);
3855
3856                      if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3857                      {
3858                         Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3859
3860                         if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3861                         {
3862                            pointset->SetNextPoint(x1, y1, z1);
3863                         }
3864                      }
3865                   }
3866
3867                   pointset->SetRnrSelf(kTRUE);
3868                   pointset->SetRnrChildren(kTRUE);
3869
3870                   gEve->AddElement(pointset);
3871
3872                   }
3873
3874                   if(str1.Contains("TOF"))
3875                   {
3876
3877                      clusters = dynamic_cast<TEvePointSet*>(element);
3878
3879                      if(gEve->GetEventScene()->FirstChild()->FindChild("TOF ClCut"))
3880                         gEve->GetEventScene()->FirstChild()->FindChild("TOF ClCut")->Destroy();
3881
3882                      pointset = new TEvePointSet(clusters->GetLastPoint());
3883                      pointset->SetMarkerStyle(4);
3884                      pointset->SetMarkerColor(kOrange+9);
3885                      pointset->SetMarkerSize(0.4);
3886                      pointset->SetName("TOF ClCut");
3887
3888                      for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3889                      {
3890
3891                         clusters->GetPoint(iCluster, x1, y1, z1);
3892
3893                         if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3894                         {
3895                            Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3896
3897                            if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3898                            {
3899                               pointset->SetNextPoint(x1, y1, z1);
3900                            }
3901                         }
3902                      }
3903
3904                      pointset->SetRnrSelf(kTRUE);
3905                      pointset->SetRnrChildren(kTRUE);
3906
3907                      gEve->AddElement(pointset);
3908
3909                   }
3910
3911                continue;
3912
3913             }
3914
3915          }
3916 /*
3917          if(str1.Contains("Colorized"))
3918          {
3919
3920            cout << "\n\n\n" << (dynamic_cast<TEvePointSetArray*>(element))->GetNBins() << "\n\n\n" << endl;
3921
3922             if(!gCutOnEta->IsOn())
3923             {
3924                element->SetRnrSelf(kTRUE);
3925                element->SetRnrChildren(kTRUE);
3926             }
3927             else
3928             {
3929                element->SetRnrSelf(kFALSE);
3930                element->SetRnrChildren(kFALSE);
3931             }
3932
3933             continue;
3934
3935          }
3936 */
3937       }
3938 /*
3939       if(str1.Contains("TPC") && str1.Contains("Clusters") && !str1.Contains("Colorized"))
3940       {
3941
3942          element->SetRnrChildren(kFALSE);
3943          element->SetRnrSelf(kFALSE);
3944
3945          if(gEve->GetEventScene()->FirstChild()->FindChild("TPC ClCut"))
3946             gEve->GetEventScene()->FirstChild()->FindChild("TPC ClCut")->Destroy();
3947
3948          if(gCutOnEta->IsOn())
3949          {
3950             clusters = dynamic_cast<TEvePointSet*>(element);
3951
3952             pointset = new TEvePointSet(clusters->GetLastPoint());
3953             pointset->SetMarkerStyle(4);
3954             pointset->SetMarkerColor(kBlue);
3955             pointset->SetMarkerSize(0.4);
3956             pointset->SetName("TPC ClCut");
3957
3958             for(Int_t iCluster = 0; iCluster < clusters->GetLastPoint(); iCluster++)
3959             {
3960
3961                clusters->GetPoint(iCluster, x1, y1, z1);
3962
3963                if(TMath::Sqrt(x1*x1 + y1*y1 + z1*z1) != 0 && z1 != 0)
3964                {
3965                   Double_t eta = -TMath::Log(TMath::Tan(0.5*TMath::ACos(z1/TMath::Sqrt(x1*x1 + y1*y1 + z1*z1))));
3966
3967                   if(eta > gEtaRange->GetMin() && eta < gEtaRange->GetMax())
3968                   {
3969                      pointset->SetNextPoint(x1, y1, z1);
3970                   }
3971                }
3972             }
3973
3974             pointset->SetRnrSelf(kTRUE);
3975             pointset->SetRnrChildren(kTRUE);
3976
3977             gEve->AddElement(pointset);
3978
3979          }
3980
3981          continue;
3982
3983       }
3984 */
3985       if(!str1.Contains("ClCut"))
3986       {
3987          element->SetRnrChildren(kFALSE);
3988          element->SetRnrSelf(kFALSE);
3989       }
3990
3991    }
3992
3993    if(gDrawTracks->IsOn() || gDrawV0s->IsOn() || gDrawCascades->IsOn() || gDrawKinks->IsOn())
3994    {
3995
3996       i = gEve->GetEventScene()->FirstChild()->FindChild("ESD Tracks by category")->BeginChildren();
3997       j = gEve->GetEventScene()->FirstChild()->FindChild("ESD Tracks by category")->EndChildren();
3998
3999       for(k = i; k != j; k++)
4000       {
4001
4002          TEveElement* trackList = (TEveElement*) *k;
4003
4004          TEveElement::List_i m = trackList->BeginChildren();
4005          TEveElement::List_i n = trackList->EndChildren();
4006          TEveElement::List_i l;
4007
4008          for(l = m; l != n; l++)
4009          {
4010
4011             AliEveTrack *track = dynamic_cast<AliEveTrack*>((TEveElement*) *l);
4012
4013             if(gCutOnMult->IsOn())
4014             {
4015
4016                Double_t draw = gRandom->Rndm();
4017
4018                if(draw > (gMultRangeNE->GetNumber())/100)
4019                {
4020
4021                   track->SetRnrSelf(kFALSE);
4022                   continue;
4023
4024                }
4025             }
4026
4027             if(gCutOnCls->IsOn())
4028             {
4029
4030                if(track->GetESDTrack()->GetTPCNcls() < gClsRangeNE->GetNumber())
4031                {
4032                      track->SetRnrSelf(kFALSE);
4033                      continue;
4034                }
4035
4036             }
4037
4038             if(gCutOnP->IsOn())
4039             {
4040
4041                if(gPRange->GetMax() == gPRange->GetLimitMax())
4042                {
4043
4044                   if(track->GetESDTrack()->P() < gPRange->GetMin())
4045                   {
4046                      track->SetRnrSelf(kFALSE);
4047                      continue;
4048                   }
4049
4050                }
4051
4052                else
4053                {
4054                   if(track->GetESDTrack()->P() < gPRange->GetMin() || track->GetESDTrack()->P() > gPRange->GetMax())
4055                   {
4056                      track->SetRnrSelf(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(track->GetESDTrack()->Pt() < gPtRange->GetMin())
4071                   {
4072                      track->SetRnrSelf(kFALSE);
4073                      continue;
4074                   }
4075
4076                }
4077
4078                else
4079                {
4080                   if(track->GetESDTrack()->Pt() < gPtRange->GetMin() || track->GetESDTrack()->Pt() > gPtRange->GetMax())
4081                   {
4082                      track->SetRnrSelf(kFALSE);
4083                      continue;
4084                   }
4085
4086                }
4087
4088             }
4089
4090             if(gCutOnEta->IsOn())
4091             {
4092
4093                if(gEtaRange->GetMax() == gEtaRange->GetLimitMax() && gEtaRange->GetMin() == gEtaRange->GetLimitMin())
4094                   continue;
4095
4096                if(gEtaRange->GetMax() == gEtaRange->GetLimitMax())
4097                {
4098
4099                   if(track->GetESDTrack()->Eta() < gEtaRange->GetMin())
4100                   {
4101                      track->SetRnrSelf(kFALSE);
4102                      continue;
4103                   }
4104
4105                }
4106
4107                if(gEtaRange->GetMin() == gEtaRange->GetLimitMin())
4108                {
4109
4110                   if(track->GetESDTrack()->Eta() > gEtaRange->GetMax())
4111                   {
4112                      track->SetRnrSelf(kFALSE);
4113                      continue;
4114                   }
4115
4116                }
4117
4118                if(track->GetESDTrack()->Eta() < gEtaRange->GetMin() || track->GetESDTrack()->Eta() > gEtaRange->GetMax())
4119                {
4120                   track->SetRnrSelf(kFALSE);
4121                   continue;
4122                }
4123
4124             }
4125
4126          }
4127
4128       }
4129
4130 /*
4131       i = gEve->GetEventScene()->FirstChild()->FindChild("ESD v0")->BeginChildren();
4132       j = gEve->GetEventScene()->FirstChild()->FindChild("ESD v0")->EndChildren();
4133
4134       for(k = i; k != j; k++)
4135       {
4136
4137          AliEveV0 *v0 = dynamic_cast<AliEveV0*>((TEveElement*) *k);
4138
4139          if(gCutOnP->IsOn())
4140          {
4141
4142             if(gPRange->GetMax() == gPRange->GetLimitMax())
4143             {
4144
4145                if(v0->GetP() < gPRange->GetMin())
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                   continue;
4156                }
4157
4158             }
4159
4160             else
4161             {
4162                if(v0->GetP() < gPRange->GetMin() || v0->GetP() > gPRange->GetMax())
4163                {
4164                   v0->SetRnrSelf(kFALSE);
4165                   v0->SetRnrChildren(kFALSE);
4166                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
4167                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
4168                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
4169                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
4170                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
4171                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
4172                   continue;
4173                }
4174
4175             }
4176
4177          }
4178
4179          if(gCutOnPt->IsOn())
4180          {
4181
4182             if(gPtRange->GetMax() == gPtRange->GetLimitMax())
4183             {
4184
4185                if(v0->GetPt() < gPtRange->GetMin())
4186                {
4187                   v0->SetRnrSelf(kFALSE);
4188                   v0->SetRnrChildren(kFALSE);
4189                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
4190                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
4191                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
4192                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
4193                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
4194                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
4195                   continue;
4196                }
4197
4198             }
4199
4200             else
4201             {
4202                if(v0->GetPt() < gPtRange->GetMin() || v0->GetPt() > gPtRange->GetMax())
4203                {
4204                   v0->SetRnrSelf(kFALSE);
4205                   v0->SetRnrChildren(kFALSE);
4206                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
4207                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
4208                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
4209                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
4210                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
4211                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
4212                   continue;
4213                }
4214
4215             }
4216
4217          }
4218
4219          if(gCutOnEta->IsOn())
4220          {
4221
4222             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax() && gEtaRange->GetMax() == gEtaRange->GetLimitMax())
4223                continue;
4224
4225             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax())
4226             {
4227                if(v0->GetEta() < gEtaRange->GetMin())
4228                {
4229                   v0->SetRnrSelf(kFALSE);
4230                   v0->SetRnrChildren(kFALSE);
4231                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
4232                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
4233                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
4234                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
4235                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
4236                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
4237                   continue;
4238                }
4239
4240             }
4241
4242             if(gEtaRange->GetMin() == gEtaRange->GetLimitMin())
4243             {
4244
4245                if(v0->GetEta() > gEtaRange->GetMax())
4246                {
4247                   v0->SetRnrSelf(kFALSE);
4248                   v0->SetRnrChildren(kFALSE);
4249                   v0->GetPosTrack()->SetRnrSelf(kFALSE);
4250                   v0->GetNegTrack()->SetRnrSelf(kFALSE);
4251                   v0->GetPointingLine()->SetRnrSelf(kFALSE);
4252                   v0->GetPosTrack()->SetRnrChildren(kFALSE);
4253                   v0->GetNegTrack()->SetRnrChildren(kFALSE);
4254                   v0->GetPointingLine()->SetRnrChildren(kFALSE);
4255                   continue;
4256                }
4257
4258             }
4259
4260             if(v0->GetEta() < gEtaRange->GetMin() || v0->GetEta() > gEtaRange->GetMax())
4261             {
4262                v0->SetRnrSelf(kFALSE);
4263                v0->SetRnrChildren(kFALSE);
4264                v0->GetPosTrack()->SetRnrSelf(kFALSE);
4265                v0->GetNegTrack()->SetRnrSelf(kFALSE);
4266                v0->GetPointingLine()->SetRnrSelf(kFALSE);
4267                v0->GetPosTrack()->SetRnrChildren(kFALSE);
4268                v0->GetNegTrack()->SetRnrChildren(kFALSE);
4269                v0->GetPointingLine()->SetRnrChildren(kFALSE);
4270
4271                continue;
4272             }
4273
4274          }
4275
4276          v0->SetRnrSelf(kTRUE);
4277          v0->SetRnrChildren(kTRUE);
4278                v0->GetPosTrack()->SetRnrSelf(kTRUE);
4279                v0->GetNegTrack()->SetRnrSelf(kTRUE);
4280                v0->GetPointingLine()->SetRnrSelf(kTRUE);
4281                v0->GetPosTrack()->SetRnrChildren(kTRUE);
4282                v0->GetNegTrack()->SetRnrChildren(kTRUE);
4283                v0->GetPointingLine()->SetRnrChildren(kTRUE);
4284
4285       }
4286
4287
4288       i = gEve->GetEventScene()->FirstChild()->FindChild("ESD cascade")->BeginChildren();
4289       j = gEve->GetEventScene()->FirstChild()->FindChild("ESD cascade")->EndChildren();
4290
4291       for(k = i; k != j; k++)
4292       {
4293
4294          AliEveCascade *cascade = dynamic_cast<AliEveCascade*>((TEveElement*) *k);
4295
4296          if(gCutOnP->IsOn())
4297          {
4298
4299             if(gPRange->GetMax() == gPRange->GetLimitMax())
4300             {
4301
4302                if(cascade->GetPtot() < gPRange->GetMin())
4303                {
4304                   cascade->SetRnrSelf(kFALSE);
4305                   cascade->SetRnrChildren(kFALSE);
4306                   continue;
4307                }
4308
4309             }
4310
4311             else
4312             {
4313                if(cascade->GetPtot() < gPRange->GetMin() || cascade->GetPtot() > gPRange->GetMax())
4314                {
4315                   cascade->SetRnrSelf(kFALSE);
4316                   cascade->SetRnrChildren(kFALSE);
4317                   continue;
4318                }
4319
4320             }
4321
4322          }
4323
4324          if(gCutOnPt->IsOn())
4325          {
4326
4327             if(gPtRange->GetMax() == gPtRange->GetLimitMax())
4328             {
4329
4330                if(cascade->GetPt() < gPtRange->GetMin())
4331                {
4332                   cascade->SetRnrSelf(kFALSE);
4333                   cascade->SetRnrChildren(kFALSE);
4334                   continue;
4335                }
4336
4337             }
4338
4339             else
4340             {
4341                if(cascade->GetPt() < gPtRange->GetMin() || cascade->GetPt() > gPtRange->GetMax())
4342                {
4343                   cascade->SetRnrSelf(kFALSE);
4344                   cascade->SetRnrChildren(kFALSE);
4345                   continue;
4346                }
4347
4348             }
4349
4350          }
4351
4352          if(gCutOnEta->IsOn())
4353          {
4354
4355             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax() && gEtaRange->GetMax() == gEtaRange->GetLimitMax())
4356                continue;
4357
4358             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax())
4359             {
4360                if(cascade->GetEta() < gEtaRange->GetMin())
4361                {
4362                   cascade->SetRnrSelf(kFALSE);
4363                   cascade->SetRnrChildren(kFALSE);
4364                   continue;
4365                }
4366
4367             }
4368
4369             if(gEtaRange->GetMin() == gEtaRange->GetLimitMin())
4370             {
4371
4372                if(cascade->GetEta() > gEtaRange->GetMax())
4373                {
4374                   cascade->SetRnrSelf(kFALSE);
4375                   cascade->SetRnrChildren(kFALSE);
4376                   continue;
4377                }
4378
4379             }
4380
4381             if(cascade->GetEta() < gEtaRange->GetMin() || cascade->GetEta() > gEtaRange->GetMax())
4382             {
4383                cascade->SetRnrSelf(kFALSE);
4384                cascade->SetRnrChildren(kFALSE);
4385                continue;
4386             }
4387
4388          }
4389
4390          cascade->SetRnrSelf(kTRUE);
4391          cascade->SetRnrChildren(kTRUE);
4392
4393       }
4394
4395
4396       i = gEve->GetEventScene()->FirstChild()->FindChild("ESD kink")->BeginChildren();
4397       j = gEve->GetEventScene()->FirstChild()->FindChild("ESD kink")->EndChildren();
4398
4399       for(k = i; k != j; k++)
4400       {
4401
4402          AliEveKink *kink = dynamic_cast<AliEveKink*>((TEveElement*) *k);
4403
4404          if(gCutOnP->IsOn())
4405          {
4406
4407             if(gPRange->GetMax() == gPRange->GetLimitMax())
4408             {
4409
4410                if(kink->GetESDTrack()->P() < gPRange->GetMin())
4411                {
4412                   kink->SetRnrSelf(kFALSE);
4413                   kink->SetRnrChildren(kFALSE);
4414                   continue;
4415                }
4416
4417             }
4418
4419             else
4420             {
4421                if(kink->GetESDTrack()->P() < gPRange->GetMin() || kink->GetESDTrack()->P() > gPRange->GetMax())
4422                {
4423                   kink->SetRnrSelf(kFALSE);
4424                   kink->SetRnrChildren(kFALSE);
4425                   continue;
4426                }
4427
4428             }
4429
4430          }
4431
4432          if(gCutOnPt->IsOn())
4433          {
4434
4435             if(gPtRange->GetMax() == gPtRange->GetLimitMax())
4436             {
4437
4438                if(kink->GetESDTrack()->Pt() < gPtRange->GetMin())
4439                {
4440                   kink->SetRnrSelf(kFALSE);
4441                   kink->SetRnrChildren(kFALSE);
4442                   continue;
4443                }
4444
4445             }
4446
4447             else
4448             {
4449                if(kink->GetESDTrack()->Pt() < gPtRange->GetMin() || kink->GetESDTrack()->Pt() > gPtRange->GetMax())
4450                {
4451                   kink->SetRnrSelf(kFALSE);
4452                   kink->SetRnrChildren(kFALSE);
4453                   continue;
4454                }
4455
4456             }
4457
4458          }
4459
4460          if(gCutOnEta->IsOn())
4461          {
4462
4463             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax() && gEtaRange->GetMax() == gEtaRange->GetLimitMax())
4464                continue;
4465
4466             if(gEtaRange->GetMax() == gEtaRange->GetLimitMax())
4467             {
4468                if(kink->GetESDTrack()->Eta() < gEtaRange->GetMin())
4469                {
4470                   kink->SetRnrSelf(kFALSE);
4471                   kink->SetRnrChildren(kFALSE);
4472                   continue;
4473                }
4474
4475             }
4476
4477             if(gEtaRange->GetMin() == gEtaRange->GetLimitMin())
4478             {
4479
4480                if(kink->GetESDTrack()->Eta() > gEtaRange->GetMax())
4481                {
4482                   kink->SetRnrSelf(kFALSE);
4483                   kink->SetRnrChildren(kFALSE);
4484                   continue;
4485                }
4486
4487             }
4488
4489             if(kink->GetESDTrack()->Eta() < gEtaRange->GetMin() || kink->GetESDTrack()->Eta() > gEtaRange->GetMax())
4490             {
4491                kink->SetRnrSelf(kFALSE);
4492                kink->SetRnrChildren(kFALSE);
4493                continue;
4494             }
4495
4496          }
4497
4498          kink->SetRnrSelf(kTRUE);
4499          kink->SetRnrChildren(kTRUE);
4500
4501       }
4502 */
4503
4504   }
4505
4506   TEveElement* top = gEve->GetCurrentEvent();
4507
4508   AliEveMultiView *mv = AliEveMultiView::Instance();
4509
4510   mv->DestroyEventRPhi();
4511   mv->DestroyEventRhoZ();
4512
4513   mv->ImportEventRPhi(top);
4514   mv->ImportEventRhoZ(top);
4515
4516   gEve->FullRedraw3D(kFALSE, kTRUE);
4517
4518 }
4519
4520 //______________________________________________________________________________
4521
4522 void SetCutsWindow::CloseTab()
4523 {
4524
4525       TEveBrowser *browser = gEve->GetBrowser();
4526       Int_t current = browser->GetTabLeft()->GetCurrent();
4527
4528       browser->GetTabLeft()->RemoveTab(current);
4529
4530 }
4531
4532 //______________________________________________________________________________
4533
4534 void SetCutsWindow::Macro1()
4535 {
4536
4537    SetStandardCuts();
4538
4539    gPosColorList->Select(2, kTRUE);
4540    gNegColorList->Select(2, kTRUE);
4541
4542    gEve->GetScenes()->FirstChild()->SetRnrSelf(kFALSE);
4543    gEve->GetScenes()->FirstChild()->SetRnrChildren(kFALSE);
4544
4545    SetCuts();
4546
4547    gEve->FullRedraw3D(kTRUE);
4548
4549 }
4550
4551 //______________________________________________________________________________
4552
4553 void SetCutsWindow::Macro2()
4554 {
4555
4556    gDrawV0s->SetOn(kFALSE,kFALSE);
4557    gDrawCascades->SetOn(kFALSE,kFALSE);
4558    gDrawKinks->SetOn(kFALSE,kFALSE);
4559    gDrawVertex->SetOn(kFALSE,kFALSE);
4560    gDrawTracklets->SetOn(kFALSE,kFALSE);
4561    gDrawTracks->SetOn(kTRUE,kFALSE);
4562    gDrawClusters->SetOn(kTRUE,kFALSE);
4563    gDrawTracksType1->SetOn(kTRUE,kFALSE);
4564    gDrawTracksType2->SetOn(kTRUE,kFALSE);
4565    gDrawTracksType3->SetOn(kTRUE,kFALSE);
4566    gDrawTracksType4->SetOn(kTRUE,kFALSE);
4567    gDrawTracksType5->SetOn(kFALSE,kFALSE);
4568    gDrawTracksType6->SetOn(kFALSE,kFALSE);
4569    gDrawTracksType7->SetOn(kFALSE,kFALSE);
4570    gCutOnP->SetOn(kFALSE,kFALSE);
4571    gCutOnPt->SetOn(kFALSE,kFALSE);
4572    gCutOnEta->SetOn(kTRUE,kFALSE);
4573    gCutOnMult->SetOn(kFALSE,kFALSE);
4574    gCutOnCls->SetOn(kFALSE,kFALSE);
4575    gPtRange->SetValues(0.15,gPtRange->GetLimitMax());
4576    gEtaRange->SetValues(-0.9,0.9);
4577    gClsRangeNE->SetNumber(70);
4578    gClsRange->SetPosition(70);
4579
4580    gEve->GetScenes()->FirstChild()->SetRnrSelf(kTRUE);
4581    gEve->GetScenes()->FirstChild()->SetRnrChildren(kTRUE);
4582
4583    SetCuts();
4584
4585    gEve->FullRedraw3D(kTRUE);
4586
4587 }
4588
4589 //______________________________________________________________________________
4590
4591 void SetCutsWindow::Macro3()
4592 {
4593
4594    SetStandardCuts();
4595
4596    gDrawVertex->SetOn(kTRUE,kFALSE);
4597    gDrawTracklets->SetOn(kFALSE,kFALSE);
4598    gDrawClusters->SetOn(kTRUE,kFALSE);
4599
4600    gPosColorList->Select(3, kTRUE);
4601    gNegColorList->Select(2, kTRUE);
4602
4603    gEve->GetScenes()->FirstChild()->SetRnrSelf(kFALSE);
4604    gEve->GetScenes()->FirstChild()->SetRnrSelf(kFALSE);
4605
4606    SetCuts();
4607
4608    gEve->FullRedraw3D(kTRUE);
4609
4610 }
4611
4612 //______________________________________________________________________________
4613
4614 void SetCutsWindow::Macro4()
4615 {
4616
4617    gDrawV0s->SetOn(kTRUE,kFALSE);
4618    gDrawCascades->SetOn(kTRUE,kFALSE);
4619    gDrawKinks->SetOn(kTRUE,kFALSE);
4620    gDrawVertex->SetOn(kTRUE,kFALSE);
4621    gDrawTracklets->SetOn(kFALSE,kFALSE);
4622    gDrawTracks->SetOn(kFALSE,kFALSE);
4623    gDrawClusters->SetOn(kFALSE,kFALSE);
4624    gDrawTracksType1->SetOn(kFALSE,kFALSE);
4625    gDrawTracksType2->SetOn(kFALSE,kFALSE);
4626    gDrawTracksType3->SetOn(kFALSE,kFALSE);
4627    gDrawTracksType4->SetOn(kFALSE,kFALSE);
4628    gDrawTracksType5->SetOn(kFALSE,kFALSE);
4629    gDrawTracksType6->SetOn(kFALSE,kFALSE);
4630    gDrawTracksType7->SetOn(kFALSE,kFALSE);
4631    gCutOnP->SetOn(kFALSE,kFALSE);
4632    gCutOnPt->SetOn(kFALSE,kFALSE);
4633    gCutOnEta->SetOn(kFALSE,kFALSE);
4634    gCutOnMult->SetOn(kFALSE,kFALSE);
4635    gCutOnCls->SetOn(kFALSE,kFALSE);
4636
4637    gEve->GetScenes()->FirstChild()->SetRnrSelf(kTRUE);
4638    gEve->GetScenes()->FirstChild()->SetRnrSelf(kTRUE);
4639
4640    SetCuts();
4641
4642    gEve->FullRedraw3D(kTRUE);
4643
4644 }
4645
4646 //______________________________________________________________________________
4647
4648 void SetCutsWindow::Macro5()
4649 {
4650
4651    SetStandardCuts();
4652
4653    gPosColorList->Select(1, kTRUE);
4654    gNegColorList->Select(1, kTRUE);
4655
4656    gEve->GetScenes()->FirstChild()->SetRnrSelf(kFALSE);
4657    gEve->GetScenes()->FirstChild()->SetRnrChildren(kFALSE);
4658
4659    gMultRangeNE->SetNumber(50);
4660
4661    SetCuts();
4662
4663    AddMomentumVectors();
4664
4665    gEve->FullRedraw3D(kTRUE);
4666
4667 }
4668
4669 //______________________________________________________________________________
4670
4671 void SetCutsWindow::SetValues()
4672 {
4673
4674 }
4675
4676 //______________________________________________________________________________
4677
4678 void SetCutsWindow::SaveMacro()
4679 {
4680
4681   TGFileInfo fi;
4682   fi.fFileTypes   = gMacroSaveAsTypes;
4683   fi.fIniDir      = StrDup(""); // current directory
4684   fi.fFileTypeIdx = 0;
4685   fi.fOverwrite   = kTRUE;
4686   new TGFileDialog(gClient->GetDefaultRoot(), gEve->GetMainWindow(), kFDSave, &fi);
4687   if (!fi.fFilename) return;
4688
4689   TPMERegexp filere(".*/([^/]+$)");
4690   if (filere.Match(fi.fFilename) != 2)
4691   {
4692     Warning("AliEvePopupHandler", "file '%s' bad.", fi.fFilename);
4693     return;
4694   }
4695   printf("Saving...\n");
4696
4697   TString file(filere[1]);
4698   TString file1;
4699   if (!file.EndsWith(".alieve"))
4700   file1 = file + ".alieve";
4701   gSystem->ChangeDirectory(fi.fIniDir);
4702   ofstream myfile;
4703   myfile.open (file1);
4704
4705   myfile << gDrawV0s->IsOn() << endl;
4706   myfile << gDrawCascades->IsOn() << endl;
4707   myfile << gDrawKinks->IsOn() << endl;
4708   myfile << gDrawVertex->IsOn() << endl;
4709   myfile << gDrawTracklets->IsOn() << endl;
4710   myfile << gDrawTracks->IsOn() << endl;
4711   myfile << gDrawClusters->IsOn() << endl;
4712   myfile << gDrawTracksType1->IsOn() << endl;
4713   myfile << gDrawTracksType2->IsOn() << endl;
4714   myfile << gDrawTracksType3->IsOn() << endl;
4715   myfile << gDrawTracksType4->IsOn() << endl;
4716   myfile << gDrawTracksType5->IsOn() << endl;
4717   myfile << gDrawTracksType6->IsOn() << endl;
4718   myfile << gDrawTracksType7->IsOn() << endl;
4719   myfile << gCutOnP->IsOn() << endl;
4720   myfile << gCutOnPt->IsOn() << endl;
4721   myfile << gCutOnEta->IsOn() << endl;
4722   myfile << gCutOnMult->IsOn() << endl;
4723   myfile << gCutOnCls->IsOn() << endl;
4724   myfile << gEve->GetScenes()->FirstChild()->GetRnrSelf() << endl;
4725   myfile << gEve->GetScenes()->FirstChild()->GetRnrChildren() << endl;
4726   myfile << gPRange->GetMin() << endl;
4727   myfile << gPRange->GetMax() << endl;
4728   myfile << gPtRange->GetMin() << endl;
4729   myfile << gPtRange->GetMax() << endl;
4730   myfile << gEtaRange->GetMin() << endl;
4731   myfile << gEtaRange->GetMax() << endl;
4732   myfile << gMultRange->GetPosition() << endl;
4733   myfile << gMultRange->GetPosition() << endl;
4734   myfile << gClsRange->GetPosition() << endl;
4735   myfile << gPMVRange->GetPosition() << endl;
4736
4737   myfile << gVectorMode->GetSelected() << endl;
4738   myfile << gPosColorList->GetSelected() << endl;
4739   myfile << gNegColorList->GetSelected() << endl;
4740   myfile << gTrackColorScale->GetSelected() << endl;
4741   myfile << gBkgColorList->GetSelected() << endl;
4742
4743   if(gEve->GetEventScene()->FindChild("Momentum Vectors"))
4744     myfile << 1 << endl;
4745   else
4746     myfile << 0 << endl;
4747
4748 /*
4749   myfile <<"//Macro with display settings generated automatically by AliEve\n\n";
4750
4751   myfile <<"void "<<file<<"(){\n" << endl;
4752   myfile << "  gDrawV0s->SetOn(" << gDrawV0s->IsOn() << ",kFALSE);" << endl;
4753   myfile << "  gDrawCascades->SetOn(" << gDrawCascades->IsOn() << ",kFALSE);" << endl;
4754   myfile << "  gDrawKinks->SetOn(" << gDrawKinks->IsOn() << ",kFALSE);" << endl;
4755   myfile << "  gDrawVertex->SetOn(" << gDrawVertex->IsOn() << ",kFALSE);" << endl;
4756   myfile << "  gDrawTracklets->SetOn(" << gDrawTracklets->IsOn() << ",kFALSE);" << endl;
4757   myfile << "  gDrawTracks->SetOn(" << gDrawTracks->IsOn() << ",kFALSE);" << endl;
4758   myfile << "  gDrawClusters->SetOn(" << gDrawClusters->IsOn() << ",kFALSE);" << endl;
4759   myfile << "  gDrawTracksType1->SetOn(" << gDrawTracksType1->IsOn() << ",kFALSE);" << endl;
4760   myfile << "  gDrawTracksType2->SetOn(" << gDrawTracksType2->IsOn() << ",kFALSE);" << endl;
4761   myfile << "  gDrawTracksType3->SetOn(" << gDrawTracksType3->IsOn() << ",kFALSE);" << endl;
4762   myfile << "  gDrawTracksType4->SetOn(" << gDrawTracksType4->IsOn() << ",kFALSE);" << endl;
4763   myfile << "  gDrawTracksType5->SetOn(" << gDrawTracksType5->IsOn() << ",kFALSE);" << endl;
4764   myfile << "  gDrawTracksType6->SetOn(" << gDrawTracksType6->IsOn() << ",kFALSE);" << endl;
4765   myfile << "  gDrawTracksType7->SetOn(" << gDrawTracksType7->IsOn() << ",kFALSE);" << endl;
4766   myfile << "  gCutOnP->SetOn(" << gCutOnP->IsOn() << ",kFALSE);" << endl;
4767   myfile << "  gCutOnPt->SetOn(" << gCutOnPt->IsOn() << ",kFALSE);" << endl;
4768   myfile << "  gCutOnEta->SetOn(" << gCutOnEta->IsOn() << ",kFALSE);" << endl;
4769   myfile << "  gCutOnMult->SetOn(" << gCutOnMult->IsOn() << ",kFALSE);" << endl;
4770   myfile << "  gCutOnCls->SetOn(" << gCutOnCls->IsOn() << ",kFALSE);" << endl;
4771
4772   myfile << "  gEve->GetScenes()->FirstChild()->SetRnrSelf(" << gEve->GetScenes()->FirstChild()->GetRnrSelf() << ");" << endl;
4773   myfile << "  gEve->GetScenes()->FirstChild()->SetRnrChildren(" << gEve->GetScenes()->FirstChild()->GetRnrChildren() << ");" << endl;
4774
4775   myfile << "  gPRange->SetValues(" << gPRange->GetMin() << "," << gPRange->GetMax() << ",kFALSE);" << endl;
4776   myfile << "  gPtRange->SetValues(" << gPtRange->GetMin() << "," << gPtRange->GetMax() << ",kFALSE);" << endl;
4777   myfile << "  gEtaRange->SetValues(" << gEtaRange->GetMin() << "," << gEtaRange->GetMax() << ",kFALSE);" << endl;
4778   myfile << "  gMultRange->SetPosition(" << gMultRange->GetPosition() << ");" << endl;
4779   myfile << "  gMultRange->SetPosition(" << gMultRange->GetPosition() << ");" << endl;
4780   myfile << "  gClsRange->SetPosition(" << gClsRange->GetPosition() << ");" << endl;
4781   myfile << "  gPMVRange->SetPosition(" << gPMVRange->GetPosition() << ");" << endl;
4782
4783   myfile << "  SetCuts();" << endl;
4784   if(gEve->GetEventScene()->FindChild("Momentum Vectors"))
4785     myfile << "  AddMomentumVectors();" << endl;
4786
4787   myfile << "  gEve->FullRedraw3D(kTRUE);" << endl;
4788   myfile << "\n}" << endl;
4789
4790 */
4791
4792 }
4793
4794 //______________________________________________________________________________
4795
4796 void SetCutsWindow::LoadMacro()
4797 {
4798
4799    TGFileInfo fi;
4800    fi.fFileTypes   = gMacroSaveAsTypes;
4801    fi.fIniDir      = StrDup(""); // current directory
4802    fi.fFileTypeIdx = 0;
4803    fi.fOverwrite   = kTRUE;
4804    new TGFileDialog(gClient->GetDefaultRoot(), gEve->GetMainWindow(), kFDOpen, &fi);//dialog
4805    if (!fi.fFilename) return;
4806
4807    TPMERegexp filere(".*/([^/]+$)");
4808    if (filere.Match(fi.fFilename) != 2)
4809    {
4810      Warning("AliEvePopupHandler", "file '%s' bad.", fi.fFilename);
4811      return;
4812    }
4813    printf("Loading...\n");
4814
4815    TString file(filere[1]);
4816    gSystem->ChangeDirectory(fi.fIniDir);
4817
4818    Bool_t boolValue = kFALSE;
4819    Int_t intValue = 0;
4820    Double_t doubleValue1 = 0.0, doubleValue2 = 0.0;
4821
4822    ifstream myfile(file);
4823
4824    if(myfile.is_open())
4825    {
4826       myfile >> boolValue;
4827       gDrawV0s->SetOn(boolValue,kFALSE);
4828       myfile >> boolValue;
4829       gDrawCascades->SetOn(boolValue,kFALSE);
4830       myfile >> boolValue;
4831       gDrawKinks->SetOn(boolValue,kFALSE);
4832       myfile >> boolValue;
4833       gDrawVertex->SetOn(boolValue,kFALSE);
4834       myfile >> boolValue;
4835       gDrawTracklets->SetOn(boolValue,kFALSE);
4836       myfile >> boolValue;
4837       gDrawTracks->SetOn(boolValue,kFALSE);
4838       myfile >> boolValue;
4839       gDrawClusters->SetOn(boolValue,kFALSE);
4840       myfile >> boolValue;
4841       gDrawTracksType1->SetOn(boolValue,kFALSE);
4842       myfile >> boolValue;
4843       gDrawTracksType2->SetOn(boolValue,kFALSE);
4844       myfile >> boolValue;
4845       gDrawTracksType3->SetOn(boolValue,kFALSE);
4846       myfile >> boolValue;
4847       gDrawTracksType4->SetOn(boolValue,kFALSE);
4848       myfile >> boolValue;
4849       gDrawTracksType5->SetOn(boolValue,kFALSE);
4850       myfile >> boolValue;
4851       gDrawTracksType6->SetOn(boolValue,kFALSE);
4852       myfile >> boolValue;
4853       gDrawTracksType7->SetOn(boolValue,kFALSE);
4854       myfile >> boolValue;
4855       gCutOnP->SetOn(boolValue,kFALSE);
4856       myfile >> boolValue;
4857       gCutOnPt->SetOn(boolValue,kFALSE);
4858       myfile >> boolValue;
4859       gCutOnEta->SetOn(boolValue,kFALSE);
4860       myfile >> boolValue;
4861       gCutOnMult->SetOn(boolValue,kFALSE);
4862       myfile >> boolValue;
4863       gCutOnCls->SetOn(boolValue,kFALSE);
4864       myfile >> boolValue;
4865       gEve->GetScenes()->FirstChild()->SetRnrSelf(boolValue);
4866       myfile >> boolValue;
4867       gEve->GetScenes()->FirstChild()->SetRnrChildren(boolValue);
4868       myfile >> doubleValue1;
4869       myfile >> doubleValue2;
4870       gPRange->SetValues(doubleValue1,doubleValue2,kFALSE);
4871       myfile >> doubleValue1;
4872       myfile >> doubleValue2;
4873       gPtRange->SetValues(doubleValue1,doubleValue2,kFALSE);
4874       myfile >> doubleValue1;
4875       myfile >> doubleValue2;
4876       gEtaRange->SetValues(doubleValue1,doubleValue2,kFALSE);
4877       myfile >> intValue;
4878       gMultRange->SetPosition(intValue);
4879       myfile >> intValue;
4880       gMultRange->SetPosition(intValue);
4881       myfile >> intValue;
4882       gClsRange->SetPosition(intValue);
4883       myfile >> intValue;
4884       gPMVRange->SetPosition(intValue);
4885       myfile >> intValue;
4886       gVectorMode->Select(intValue);
4887       myfile >> intValue;
4888       gPosColorList->Select(intValue);
4889       myfile >> intValue;
4890       gNegColorList->Select(intValue);
4891       myfile >> intValue;
4892       gTrackColorScale->Select(intValue);
4893       myfile >> intValue;
4894       gBkgColorList->Select(intValue);
4895
4896       myfile >> boolValue;
4897       if(boolValue) AddMomentumVectors();
4898
4899       SetCuts();
4900       gEve->FullRedraw3D(kTRUE);
4901
4902    }
4903
4904 /*
4905       TGFileInfo fi;
4906       fi.fFileTypes   = gMacroSaveAsTypes;
4907       fi.fIniDir      = StrDup(""); // current directory
4908       fi.fFileTypeIdx = 0;
4909       fi.fOverwrite   = kTRUE;
4910       new TGFileDialog(gClient->GetDefaultRoot(), gEve->GetMainWindow(), kFDOpen, &fi);//dialog
4911       if (!fi.fFilename) return;
4912 */
4913 //      TPMERegexp filere(".*/([^/]+$)");
4914 /*
4915       if (filere.Match(fi.fFilename) != 2)
4916       {
4917         Warning("AliEvePopupHandler", "file '%s' bad.", fi.fFilename);
4918         return;
4919       }
4920       printf("Loading...\n");
4921
4922       TString file(filere[1]);
4923       gSystem->ChangeDirectory(fi.fIniDir);
4924
4925       TEveUtil::Macro(file);//run macro
4926
4927 */
4928
4929 }
4930
4931 //______________________________________________________________________________
4932
4933 void alieve_set_cuts()
4934 {
4935
4936       TEveBrowser *browser = gEve->GetBrowser();
4937
4938       browser->StartEmbedding(TRootBrowser::kLeft);
4939
4940       new SetCutsWindow();
4941
4942       browser->StopEmbedding("Cut Selection");
4943
4944 }