[u/mrichter/AliRoot.git] / EVE / EveDet / blacklisted-classes / AliEveCascadeEditors.cxx

// $Id$
// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/

/***********************************************************************
  This editor appears in the TEveUtil window when v0 are visualize.
It allows to select the v0 as a function of some useful parameters.

Ludovic Gaudichet (gaudichet@to.infn.it)
************************************************************************/

#include "AliEveCascadeEditors.h"
#include <EveDet/AliEveCascade.h>

#include <TEveGValuators.h>

#include <TVirtualPad.h>
#include <TColor.h>

#include <TGLabel.h>
#include <TGButton.h>
#include <TGNumberEntry.h>
#include <TGColorSelect.h>
#include <TGDoubleSlider.h>

#include <TGTab.h>
#include <TRootEmbeddedCanvas.h>
#include <TCanvas.h>
#include <TH1.h>
#include <TH1F.h>
#include <TH2F.h>


//______________________________________________________________________________
// CascadeListEditor
//

ClassImp(CascadeListEditor)

CascadeListEditor::CascadeListEditor(const TGWindow *p,
                                 Int_t width, Int_t height,
                                 UInt_t options, Pixel_t back) :
  TGedFrame(p, width, height, options | kVerticalFrame, back),
  fMList(0),
  fRnrV0Daughters(0),
  fRnrV0path(0),
  fRnrVtx(0),
  fRnrBach(0),
  fRnrCasPath(0),
  fMainTabA(0),
  fMainTabB(0)
{
  MakeTitle("CascadeList");

  //TGHorizontalFrame* frame = new TGHorizontalFrame(this);

  // --- Rendering control

  fRnrVtx = new TGCheckButton(this, "Render v0 and cascade vertices");
  AddFrame(fRnrVtx, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fRnrVtx->Connect("Toggled(Bool_t)",
		     "CascadeListEditor", this, "DoRnrVtx()");

  fRnrV0path = new TGCheckButton(this, "Render v0 path");
  AddFrame(fRnrV0path, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fRnrV0path->Connect("Toggled(Bool_t)",
		     "CascadeListEditor", this, "DoRnrV0path()");

  fRnrCasPath = new TGCheckButton(this, "Render cascade path");
  AddFrame(fRnrCasPath, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fRnrCasPath->Connect("Toggled(Bool_t)",
		       "CascadeListEditor", this, "DoRnrCasPath()");

  fRnrV0Daughters = new TGCheckButton(this, "Render v0 daughter tracks");
  AddFrame(fRnrV0Daughters, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fRnrV0Daughters->Connect("Toggled(Bool_t)",
			"CascadeListEditor", this, "DoRnrV0Daughters()");

  fRnrBach = new TGCheckButton(this, "Render bachelor track");
  AddFrame(fRnrBach, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fRnrBach->Connect("Toggled(Bool_t)",
			"CascadeListEditor", this, "DoRnrBach()");

  for (Int_t i=0; i<fgkNRange; i++) fRange[i]=0;
  for (Int_t i=0; i<fgkNCanvas; i++) fCanvasA[i]=0;
  for (Int_t i=0; i<fgkNCanvas; i++) fCanvasB[i]=0;

  AddSelectTab();
  AddSeeTab();

  TGTextButton* resetCutsButton = new TGTextButton(this, "Reset all cuts", 40);
  resetCutsButton->Connect("Clicked()", "CascadeListEditor", this, "ResetCuts()");
  AddFrame(resetCutsButton, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
}

CascadeListEditor::~CascadeListEditor()
{}


//______________________________________________________________________________
void CascadeListEditor::SetModel(TObject* obj)
{
  fMList = dynamic_cast<CascadeList*>(obj);

  for (Int_t i=0; i<fgkNRange; i++)
    if (fRange[i])
      fRange[i]->SetValues( fMList->GetMin(i), fMList->GetMax(i) );

  fRnrV0Daughters->SetState(fMList->GetRnrV0Daughters() ? kButtonDown : kButtonUp);
  fRnrV0path->SetState(fMList->GetRnrV0path() ? kButtonDown : kButtonUp);
  fRnrVtx->SetState(fMList->GetRnrCasVtx() ? kButtonDown : kButtonUp);
  fRnrBach->SetState(fMList->GetRnrBachelor() ? kButtonDown : kButtonUp);
  fRnrCasPath->SetState(fMList->GetRnrCasPath() ? kButtonDown : kButtonUp);

  FillCanvas();
}


//______________________________________________________________________________
TGCompositeFrame* CascadeListEditor::AddTab(TGTab* tab, Int_t i, Int_t can,
				       char *name) {

  TGCompositeFrame* frameTab = tab->AddTab(name);
  frameTab->SetLayoutManager(new TGVerticalLayout( frameTab ));

  TRootEmbeddedCanvas** embeddedCanvas = 0;

  if (can==1) embeddedCanvas = &fCanvasA[i];
  else if (can==2) embeddedCanvas = &fCanvasB[i];

  *embeddedCanvas = new TRootEmbeddedCanvas("EmbeddedCanvas", frameTab, 200, 200);
  TCanvas *c1 = (*embeddedCanvas)->GetCanvas();
  c1->SetBorderMode(0);
  c1->SetTicks(1,0);
  c1->SetGrid();
  c1->SetBorderMode(0);

  frameTab->AddFrame(*embeddedCanvas, new TGLayoutHints(kLHintsTop|kLHintsExpandX,
						       0, 0, 0, 0));
  return frameTab;
}


//______________________________________________________________________________
TGCompositeFrame** CascadeListEditor::CreateTab(TGTab **pMainTab, TGTab **ptab, Int_t can) {

  //------
  // tab widget
  pMainTab[0] = new TGTab(this,0,0);
  pMainTab[0]->Connect("Selected(Int_t)", "CascadeListEditor", this, "UpdateSelectedTab()");
  this->AddFrame(pMainTab[0], new TGLayoutHints( kLHintsTop | kLHintsExpandX,2,2,2,2));

  //------
  // container of "Tab1"
  TGCompositeFrame *frameTab1 = pMainTab[0]->AddTab("ident.");
  frameTab1->SetLayoutManager(new TGVerticalLayout(frameTab1));

  // tab widget
  ptab[0] = new TGTab(frameTab1,2,2);
  ptab[0]->Resize(ptab[0]->GetDefaultSize());
  // The following is for updating the canvas of a tab if this one is selected
  // (it updates every canvas)
  ptab[0]->Connect("Selected(Int_t)", "CascadeListEditor", this, "UpdateSelectedTab()");
  frameTab1->AddFrame(ptab[0], new TGLayoutHints(kLHintsLeft| kLHintsExpandX,0,0,0,0));

  //------
  // container of "Tab2"
  TGCompositeFrame *frameTab2 = pMainTab[0]->AddTab("cascade");
  frameTab2->SetLayoutManager(new TGVerticalLayout(frameTab2));

  // tab widget
  ptab[1] = new TGTab(frameTab2,440,299);
  ptab[1]->Resize(ptab[1]->GetDefaultSize());
  ptab[1]->Connect("Selected(Int_t)", "CascadeListEditor", this, "UpdateSelectedTab()");
  frameTab2->AddFrame(ptab[1], new TGLayoutHints(kLHintsLeft| kLHintsExpandX ,0,0,0,0));

  //------
  // container of "Tab3"
  TGCompositeFrame *frameTab3 = pMainTab[0]->AddTab("V0daugh/bach.");
  frameTab3->SetLayoutManager(new TGVerticalLayout(frameTab3));

  // tab widget
  ptab[2] = new TGTab(frameTab3,440,299);
  ptab[2]->Resize(ptab[2]->GetDefaultSize());
  ptab[2]->Connect("Selected(Int_t)", "CascadeListEditor", this, "UpdateSelectedTab()");
  frameTab3->AddFrame(ptab[2], new TGLayoutHints(kLHintsLeft| kLHintsExpandX ,0,0,0,0));

  //------
  TGCompositeFrame **frameTab = new TGCompositeFrame*[fgkNCanvas];

  frameTab[0] = AddTab(ptab[0], 0, can, "Xi");
  frameTab[1] = AddTab(ptab[0], 1, can, "Omega");
  frameTab[2] = AddTab(ptab[0], 2, can, "Arm.Podo.");
  frameTab[3] = AddTab(ptab[0], 3, can, "Index");

  frameTab[4] = AddTab(ptab[1], 4, can, "cosPointing");
  frameTab[5] = AddTab(ptab[1], 5, can, "bachV0DCA");
  frameTab[6] = AddTab(ptab[1], 6, can, "radius");
  frameTab[7] = AddTab(ptab[1], 7, can, "Pt");
  frameTab[8] = AddTab(ptab[1], 8, can, "eta");

  frameTab[9] = AddTab(ptab[2], 9, can, "neg Pt");
  frameTab[10] = AddTab(ptab[2], 10, can, "neg eta");
  frameTab[11] = AddTab(ptab[2], 11, can, "pos Pt");
  frameTab[12] = AddTab(ptab[2], 12, can, "pos eta");
  frameTab[13] = AddTab(ptab[2], 13, can, "bach Pt");
  frameTab[14] = AddTab(ptab[2], 14, can, "bach eta");

  pMainTab[0]->SetTab(0);
  ptab[0]->SetTab(0);
  ptab[1]->SetTab(0);
  ptab[2]->SetTab(0);

  Pixel_t darkgrey;
  gClient->GetColorByName("grey50", darkgrey);
  ptab[0]->SetBackgroundColor(darkgrey);
  ptab[1]->SetBackgroundColor(darkgrey);
  ptab[2]->SetBackgroundColor(darkgrey);

  return frameTab;
}


//______________________________________________________________________________
void CascadeListEditor::AddValuator(TGCompositeFrame* frame, char *name,
			       Float_t min, Float_t max, Int_t pres,
			       char *func, Int_t iHist) {

  TGCompositeFrame* downFrame = new TGCompositeFrame(frame,
				    60, 60, kHorizontalFrame);

   // --- Selectors
  fRange[iHist] = new TEveGDoubleValuator(downFrame, name, 200, 0);
  fRange[iHist]->SetNELength(6);
  fRange[iHist]->Build();
  fRange[iHist]->GetSlider()->SetWidth(200);

  fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESRealTwo);
  if (pres==0)
    fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESInteger);
  else if (pres==3)
    fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESRealThree);
  else if (pres==4)
    fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESRealFour);
  else if (pres==5)
    fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESReal);

  fRange[iHist]->Connect("ValueSet()",
			 "CascadeListEditor", this, func);
  downFrame->AddFrame(fRange[iHist], new TGLayoutHints(kLHintsLeft,
						      0, 0, 0, 0));

  TGTextButton* adjustButton = new TGTextButton(downFrame, "Adjust Hist", 40);

  char ch[40];
  sprintf(ch,"AdjustHist(=%i)",iHist);
  adjustButton->Connect("Clicked()", "CascadeListEditor", this, ch);
  downFrame->AddFrame(adjustButton, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));

  frame->AddFrame(downFrame, new TGLayoutHints(kLHintsTop| kLHintsExpandY,
						0, 0, 0, 0));
}


//______________________________________________________________________________
void CascadeListEditor::AddSelectTab() {

  TGCompositeFrame** tab = CreateTab(&fMainTabA, fTabA, 1);

  AddValuator(tab[0],  "mass Xi",       0,  5, 3, "MassXiRange()",     0);
  AddValuator(tab[1],  "mass Omega",    0,  5, 3, "MassOmegaRange()",  1);

  AddValuator(tab[3],  "Index",                  0,   1e5, 0, "IndexRange()",       2);
  AddValuator(tab[4],  "cos pointing angle",     0.8,   1, 5, "CosPointingRange()", 3);
  AddValuator(tab[5],  "bach-AliEveV0 DCA",            0,     5, 3, "BachV0DCARange()",   4);
  AddValuator(tab[6],  "radius",                 0,   100, 2, "RadiusRange()",      5);
  AddValuator(tab[7],  "Pt",                     0,    10, 2, "PtRange()",          6);
  AddValuator(tab[8],  "Pseudo-rapidity",       -2,     2, 2, "PseudoRapRange()",   7);

  AddValuator(tab[9],  "neg Pt",                 0,    10, 2, "NegPtRange()",       8);
  AddValuator(tab[10], "neg pseudo-rapidity",   -2,     2, 2, "NegEtaRange()",      9);
  AddValuator(tab[11], "pos Pt",                 0,    10, 2, "PosPtRange()",      10);
  AddValuator(tab[12], "pos pseudo-rapidity",   -2,     2, 2, "PosEtaRange()",     11);
  AddValuator(tab[13], "bach. Pt",               0,    10, 2, "BachPtRange()",     12);
  AddValuator(tab[14], "bach. pseudo-rapidity", -2,     2, 2, "BachEtaRange()",    13);

  delete[] tab;
}


//______________________________________________________________________________
void CascadeListEditor::AddSeeTab() {

  TGCompositeFrame** tab = CreateTab(&fMainTabB, fTabB, 2);
  delete[] tab;
}


//______________________________________________________________________________
void CascadeListEditor::AdjustHist(Int_t iHist) {

  if (! fMList) return;
  fMList->AdjustHist(iHist);

  FillCanvas();
}

//______________________________________________________________________________
void CascadeListEditor::ResetCuts() {

  if (! fMList) return;

  Float_t min,max;

  for (Int_t i=0; i<fgkNRange;i++) {

    if (i==2) continue;
    min = fRange[i]->GetLimitMin();
    max = fRange[i]->GetLimitMax();
    fMList->SetMin(i, min);
    fMList->SetMax(i, max);
    fRange[i]->SetValues(min, max);
    fMList->AdjustHist(i);
  }

  // for the Index we scan its actual range
  Int_t imin, imax;
  fMList->GetCasIndexRange(imin, imax);
  if (imin<imax) {
    Int_t minH = imin-(imax-imin)/20;
    Int_t maxH = imax+(imax-imin)/20;
    fMList->SetMin(2, minH);
    fMList->SetMax(2, maxH);
    fRange[2]->SetLimits(minH, maxH, TGNumberFormat::kNESInteger);
    fRange[2]->SetValues(minH, maxH);
    fMList->AdjustHist(2);

  }
  FillCanvas();
  Update();
}


//______________________________________________________________________________
void CascadeListEditor::FillCanvas() {

  fMList->FilterAll();

  TCanvas *c1, *c1b;
  TH1F *hist = 0;
  TH2F *hist2D = 0;
  Bool_t is2D;

  Int_t canvasMap[fgkNCanvas]={0,1,1000,2,3,4,5,6,7,8,9,10,11,12,13};

  for (Int_t i=0; i<fgkNCanvas; i++)
    if (fCanvasA[i]) {

      is2D = canvasMap[i]>999;

      if (is2D) hist2D = fMList->GetHist2D(canvasMap[i]-1000);
      else hist = fMList->GetHist(canvasMap[i]);

      c1 = fCanvasA[i]->GetCanvas();
      c1->cd();
      if (is2D) hist2D->Draw("colz"); else hist->Draw();
      c1->Modified();
      c1->Update();

      c1b = fCanvasB[i]->GetCanvas();
      c1b->cd();
      if (is2D) hist2D->Draw("colz"); else hist->Draw();
      c1b->Modified();
      c1b->Update();
  }
  UpdateSelectedTab();
}
//______________________________________________________________________________
void CascadeListEditor::UpdateSelectedTab() {

  Int_t i,j;
  Pixel_t yellow;
  Pixel_t grey;
  gClient->GetColorByName("yellow", yellow);
  gClient->GetColorByName("grey", grey);

  TGTabElement *tabElem;
  for (i=0; i<fMainTabA->GetNumberOfTabs(); i++) {

    tabElem = fMainTabA->GetTabTab(i);
    tabElem->ChangeBackground(grey);

    for (j=0; j<fTabA[i]->GetNumberOfTabs();j++) {
      tabElem = fTabA[i]->GetTabTab(j);
      tabElem->ChangeBackground(grey);
    }
  }

  Int_t currentTab = fMainTabA->GetCurrent();
  Int_t currentSubTab = fTabA[currentTab]->GetCurrent();
  tabElem = fMainTabA->GetTabTab(currentTab);
  tabElem->ChangeBackground(yellow);
  tabElem = fTabA[currentTab]->GetTabTab(currentSubTab);
  tabElem->ChangeBackground(yellow);

  TCanvas *c1;
  Int_t iCan = 0;
  i=0;

  while (currentTab>i) {
    iCan += fTabA[i]->GetNumberOfTabs();
    i++;
  }
  iCan += currentSubTab;
  c1 = fCanvasA[iCan]->GetCanvas();
  c1->GetCanvas()->Modified();
  c1->GetCanvas()->Update();

  //---

  for (i=0; i<fMainTabB->GetNumberOfTabs(); i++) {

    tabElem = fMainTabB->GetTabTab(i);
    tabElem->ChangeBackground(grey);

    for (j=0; j<fTabB[i]->GetNumberOfTabs();j++) {
      tabElem = fTabB[i]->GetTabTab(j);
      tabElem->ChangeBackground(grey);
    }
  }

  currentTab = fMainTabB->GetCurrent();
  currentSubTab = fTabB[currentTab]->GetCurrent();
  tabElem = fMainTabB->GetTabTab(currentTab);
  tabElem->ChangeBackground(yellow);
  tabElem = fTabB[currentTab]->GetTabTab(currentSubTab);
  tabElem->ChangeBackground(yellow);

  iCan = 0;
  i=0;

  while (currentTab>i) {
    iCan += fTabB[i]->GetNumberOfTabs();
    i++;
  }
  iCan += currentSubTab;
  c1 = fCanvasB[iCan]->GetCanvas();
  c1->GetCanvas()->Modified();
  c1->GetCanvas()->Update();
}


//______________________________________________________________________________
void CascadeListEditor::UpdateAll(Int_t iCanA) {

  TCanvas *c1 = fCanvasA[iCanA]->GetCanvas();
  c1->Modified();
  c1->Update();

  static Int_t iCan, i;
  iCan=0;
  i=0;
  while (fMainTabB->GetCurrent()>i) {
    iCan += fTabB[i]->GetNumberOfTabs();
    i++;
  }
  iCan += fTabB[i]->GetCurrent();
  c1 = fCanvasB[iCan]->GetCanvas();
  c1->GetCanvas()->Modified();
  c1->GetCanvas()->Update();

  Update();
}


//______________________________________________________________________________

void CascadeListEditor::DoRnrVtx()
{
  fMList->SetRnrCasVtx(fRnrVtx->IsOn());
  Update();
}

void CascadeListEditor::DoRnrV0path()
{
  fMList->SetRnrV0path(fRnrV0path->IsOn());
  Update();
}

void CascadeListEditor::DoRnrV0Daughters()
{
  fMList->SetRnrV0Daughters(fRnrV0Daughters->IsOn());
  Update();
}

void CascadeListEditor::DoRnrBach()
{
  fMList->SetRnrBachelor(fRnrBach->IsOn());
  Update();
}

void CascadeListEditor::DoRnrCasPath()
{
  fMList->SetRnrCasPath(fRnrCasPath->IsOn());
  Update();
}


//______________________________________________________________________________
void CascadeListEditor::MassXiRange() {

  fMList->XiMassFilter(fRange[0]->GetMin(), fRange[0]->GetMax());
  UpdateAll(0);
}

//______________________________________________________________________________
  void CascadeListEditor::MassOmegaRange() {
  fMList->OmegaMassFilter(fRange[1]->GetMin(), fRange[1]->GetMax());
  UpdateAll(1);
}

//______________________________________________________________________________
  void CascadeListEditor::IndexRange() {
  fMList->IndexFilter(fRange[2]->GetMin(), fRange[2]->GetMax());
  UpdateAll(3);
}
//______________________________________________________________________________
  void CascadeListEditor::CosPointingRange() {
  fMList->CosPointingFilter(fRange[3]->GetMin(), fRange[3]->GetMax());
  UpdateAll(4);
}

//______________________________________________________________________________
  void CascadeListEditor::BachV0DCARange() {
  fMList->BachV0DCAFilter(fRange[4]->GetMin(), fRange[4]->GetMax());
  UpdateAll(5);
}

//______________________________________________________________________________
  void CascadeListEditor::RadiusRange() {
  fMList->RadiusFilter(fRange[5]->GetMin(), fRange[5]->GetMax());
  UpdateAll(6);
}

//______________________________________________________________________________
  void CascadeListEditor::PtRange() {
  fMList->PtFilter(fRange[6]->GetMin(), fRange[6]->GetMax());
  UpdateAll(7);
}

//______________________________________________________________________________
  void CascadeListEditor::PseudoRapRange() {
  fMList->PseudoRapFilter(fRange[7]->GetMin(), fRange[7]->GetMax());
  UpdateAll(8);
}

//______________________________________________________________________________
  void CascadeListEditor::NegPtRange() {
  fMList->NegPtFilter(fRange[8]->GetMin(), fRange[8]->GetMax());
  UpdateAll(9);
}

//______________________________________________________________________________
  void CascadeListEditor::NegEtaRange() {
  fMList->NegEtaFilter(fRange[9]->GetMin(), fRange[9]->GetMax());
  UpdateAll(10);
}

//______________________________________________________________________________
  void CascadeListEditor::PosPtRange() {
  fMList->PosPtFilter(fRange[10]->GetMin(), fRange[10]->GetMax());
  UpdateAll(11);
}

//______________________________________________________________________________
  void CascadeListEditor::PosEtaRange() {
  fMList->PosEtaFilter(fRange[11]->GetMin(), fRange[11]->GetMax());
  UpdateAll(12);
}

//______________________________________________________________________________
  void CascadeListEditor::BachPtRange() {
  fMList->BachPtFilter(fRange[12]->GetMin(), fRange[12]->GetMax());
  UpdateAll(13);
}

//______________________________________________________________________________
  void CascadeListEditor::BachEtaRange() {
  fMList->BachEtaFilter(fRange[13]->GetMin(), fRange[13]->GetMax());
  UpdateAll(14);
}
Commit	Line	Data
7976039f	1	// $Id$
	2	// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
	3
	4	/**************************************************************************
	5	* Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
	6	* See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
51346b82	7	* full copyright notice. *
7976039f	8	**************************************************************************/
ed412809	9
ed412809	10	/***********************************************************************
7976039f	11	This editor appears in the TEveUtil window when v0 are visualize.
ed412809	12	It allows to select the v0 as a function of some useful parameters.
	13
	14	Ludovic Gaudichet (gaudichet@to.infn.it)
	15	************************************************************************/
	16
7976039f	17	#include "AliEveCascadeEditors.h"
cb4245bb	18	#include <EveDet/AliEveCascade.h>
ed412809	19
7976039f	20	#include <TEveGValuators.h>
ed412809	21
	22	#include <TVirtualPad.h>
	23	#include <TColor.h>
	24
	25	#include <TGLabel.h>
	26	#include <TGButton.h>
	27	#include <TGNumberEntry.h>
	28	#include <TGColorSelect.h>
	29	#include <TGDoubleSlider.h>
	30
	31	#include <TGTab.h>
	32	#include <TRootEmbeddedCanvas.h>
	33	#include <TCanvas.h>
	34	#include <TH1.h>
	35	#include <TH1F.h>
	36	#include <TH2F.h>
	37
	38
57ffa5fb	39	//______________________________________________________________________________
ed412809	40	// CascadeListEditor
	41	//
	42
7976039f	43	ClassImp(CascadeListEditor)
ed412809	44
	45	CascadeListEditor::CascadeListEditor(const TGWindow *p,
	46	Int_t width, Int_t height,
	47	UInt_t options, Pixel_t back) :
	48	TGedFrame(p, width, height, options \| kVerticalFrame, back),
	49	fMList(0),
	50	fRnrV0Daughters(0),
	51	fRnrV0path(0),
	52	fRnrVtx(0),
	53	fRnrBach(0),
	54	fRnrCasPath(0),
	55	fMainTabA(0),
	56	fMainTabB(0)
	57	{
	58	MakeTitle("CascadeList");
51346b82	59
ed412809	60	//TGHorizontalFrame* frame = new TGHorizontalFrame(this);
51346b82	61
ed412809	62	// --- Rendering control
	63
	64	fRnrVtx = new TGCheckButton(this, "Render v0 and cascade vertices");
	65	AddFrame(fRnrVtx, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	66	fRnrVtx->Connect("Toggled(Bool_t)",
7976039f	67	"CascadeListEditor", this, "DoRnrVtx()");
ed412809	68
	69	fRnrV0path = new TGCheckButton(this, "Render v0 path");
	70	AddFrame(fRnrV0path, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	71	fRnrV0path->Connect("Toggled(Bool_t)",
51346b82	72	"CascadeListEditor", this, "DoRnrV0path()");
ed412809	73
	74	fRnrCasPath = new TGCheckButton(this, "Render cascade path");
	75	AddFrame(fRnrCasPath, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	76	fRnrCasPath->Connect("Toggled(Bool_t)",
51346b82	77	"CascadeListEditor", this, "DoRnrCasPath()");
ed412809	78
	79	fRnrV0Daughters = new TGCheckButton(this, "Render v0 daughter tracks");
	80	AddFrame(fRnrV0Daughters, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	81	fRnrV0Daughters->Connect("Toggled(Bool_t)",
7976039f	82	"CascadeListEditor", this, "DoRnrV0Daughters()");
ed412809	83
	84	fRnrBach = new TGCheckButton(this, "Render bachelor track");
	85	AddFrame(fRnrBach, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	86	fRnrBach->Connect("Toggled(Bool_t)",
7976039f	87	"CascadeListEditor", this, "DoRnrBach()");
51346b82	88
ed412809	89	for (Int_t i=0; i<fgkNRange; i++) fRange[i]=0;
	90	for (Int_t i=0; i<fgkNCanvas; i++) fCanvasA[i]=0;
	91	for (Int_t i=0; i<fgkNCanvas; i++) fCanvasB[i]=0;
	92
	93	AddSelectTab();
	94	AddSeeTab();
	95
	96	TGTextButton* resetCutsButton = new TGTextButton(this, "Reset all cuts", 40);
7976039f	97	resetCutsButton->Connect("Clicked()", "CascadeListEditor", this, "ResetCuts()");
ed412809	98	AddFrame(resetCutsButton, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
	99	}
	100
	101	CascadeListEditor::~CascadeListEditor()
	102	{}
	103
	104
57ffa5fb	105	//______________________________________________________________________________
ed412809	106	void CascadeListEditor::SetModel(TObject* obj)
	107	{
	108	fMList = dynamic_cast<CascadeList*>(obj);
	109
	110	for (Int_t i=0; i<fgkNRange; i++)
	111	if (fRange[i])
	112	fRange[i]->SetValues( fMList->GetMin(i), fMList->GetMax(i) );
	113
	114	fRnrV0Daughters->SetState(fMList->GetRnrV0Daughters() ? kButtonDown : kButtonUp);
	115	fRnrV0path->SetState(fMList->GetRnrV0path() ? kButtonDown : kButtonUp);
	116	fRnrVtx->SetState(fMList->GetRnrCasVtx() ? kButtonDown : kButtonUp);
	117	fRnrBach->SetState(fMList->GetRnrBachelor() ? kButtonDown : kButtonUp);
	118	fRnrCasPath->SetState(fMList->GetRnrCasPath() ? kButtonDown : kButtonUp);
	119
	120	FillCanvas();
	121	}
	122
	123
57ffa5fb	124	//______________________________________________________________________________
ed412809	125	TGCompositeFrame* CascadeListEditor::AddTab(TGTab* tab, Int_t i, Int_t can,
	126	char *name) {
	127
	128	TGCompositeFrame* frameTab = tab->AddTab(name);
	129	frameTab->SetLayoutManager(new TGVerticalLayout( frameTab ));
	130
	131	TRootEmbeddedCanvas** embeddedCanvas = 0;
	132
	133	if (can==1) embeddedCanvas = &fCanvasA[i];
	134	else if (can==2) embeddedCanvas = &fCanvasB[i];
	135
	136	*embeddedCanvas = new TRootEmbeddedCanvas("EmbeddedCanvas", frameTab, 200, 200);
	137	TCanvas c1 = (embeddedCanvas)->GetCanvas();
	138	c1->SetBorderMode(0);
	139	c1->SetTicks(1,0);
	140	c1->SetGrid();
	141	c1->SetBorderMode(0);
51346b82	142
ed412809	143	frameTab->AddFrame(*embeddedCanvas, new TGLayoutHints(kLHintsTop\|kLHintsExpandX,
	144	0, 0, 0, 0));
	145	return frameTab;
	146	}
	147
	148
57ffa5fb	149	//______________________________________________________________________________
ed412809	150	TGCompositeFrame CascadeListEditor::CreateTab(TGTab pMainTab, TGTab **ptab, Int_t can) {
	151
	152	//------
	153	// tab widget
	154	pMainTab[0] = new TGTab(this,0,0);
7976039f	155	pMainTab[0]->Connect("Selected(Int_t)", "CascadeListEditor", this, "UpdateSelectedTab()");
ed412809	156	this->AddFrame(pMainTab[0], new TGLayoutHints( kLHintsTop \| kLHintsExpandX,2,2,2,2));
	157
	158	//------
	159	// container of "Tab1"
	160	TGCompositeFrame *frameTab1 = pMainTab[0]->AddTab("ident.");
	161	frameTab1->SetLayoutManager(new TGVerticalLayout(frameTab1));
51346b82	162
ed412809	163	// tab widget
	164	ptab[0] = new TGTab(frameTab1,2,2);
	165	ptab[0]->Resize(ptab[0]->GetDefaultSize());
	166	// The following is for updating the canvas of a tab if this one is selected
	167	// (it updates every canvas)
7976039f	168	ptab[0]->Connect("Selected(Int_t)", "CascadeListEditor", this, "UpdateSelectedTab()");
ed412809	169	frameTab1->AddFrame(ptab[0], new TGLayoutHints(kLHintsLeft\| kLHintsExpandX,0,0,0,0));
51346b82	170
ed412809	171	//------
	172	// container of "Tab2"
	173	TGCompositeFrame *frameTab2 = pMainTab[0]->AddTab("cascade");
	174	frameTab2->SetLayoutManager(new TGVerticalLayout(frameTab2));
51346b82	175
ed412809	176	// tab widget
	177	ptab[1] = new TGTab(frameTab2,440,299);
	178	ptab[1]->Resize(ptab[1]->GetDefaultSize());
7976039f	179	ptab[1]->Connect("Selected(Int_t)", "CascadeListEditor", this, "UpdateSelectedTab()");
ed412809	180	frameTab2->AddFrame(ptab[1], new TGLayoutHints(kLHintsLeft\| kLHintsExpandX ,0,0,0,0));
51346b82	181
ed412809	182	//------
	183	// container of "Tab3"
	184	TGCompositeFrame *frameTab3 = pMainTab[0]->AddTab("V0daugh/bach.");
	185	frameTab3->SetLayoutManager(new TGVerticalLayout(frameTab3));
51346b82	186
ed412809	187	// tab widget
	188	ptab[2] = new TGTab(frameTab3,440,299);
	189	ptab[2]->Resize(ptab[2]->GetDefaultSize());
7976039f	190	ptab[2]->Connect("Selected(Int_t)", "CascadeListEditor", this, "UpdateSelectedTab()");
ed412809	191	frameTab3->AddFrame(ptab[2], new TGLayoutHints(kLHintsLeft\| kLHintsExpandX ,0,0,0,0));
	192
	193	//------
	194	TGCompositeFrame *frameTab = new TGCompositeFrame[fgkNCanvas];
51346b82	195
ed412809	196	frameTab[0] = AddTab(ptab[0], 0, can, "Xi");
	197	frameTab[1] = AddTab(ptab[0], 1, can, "Omega");
	198	frameTab[2] = AddTab(ptab[0], 2, can, "Arm.Podo.");
	199	frameTab[3] = AddTab(ptab[0], 3, can, "Index");
	200
	201	frameTab[4] = AddTab(ptab[1], 4, can, "cosPointing");
	202	frameTab[5] = AddTab(ptab[1], 5, can, "bachV0DCA");
	203	frameTab[6] = AddTab(ptab[1], 6, can, "radius");
	204	frameTab[7] = AddTab(ptab[1], 7, can, "Pt");
	205	frameTab[8] = AddTab(ptab[1], 8, can, "eta");
	206
	207	frameTab[9] = AddTab(ptab[2], 9, can, "neg Pt");
	208	frameTab[10] = AddTab(ptab[2], 10, can, "neg eta");
	209	frameTab[11] = AddTab(ptab[2], 11, can, "pos Pt");
	210	frameTab[12] = AddTab(ptab[2], 12, can, "pos eta");
	211	frameTab[13] = AddTab(ptab[2], 13, can, "bach Pt");
	212	frameTab[14] = AddTab(ptab[2], 14, can, "bach eta");
	213
	214	pMainTab[0]->SetTab(0);
	215	ptab[0]->SetTab(0);
	216	ptab[1]->SetTab(0);
	217	ptab[2]->SetTab(0);
	218
	219	Pixel_t darkgrey;
	220	gClient->GetColorByName("grey50", darkgrey);
	221	ptab[0]->SetBackgroundColor(darkgrey);
	222	ptab[1]->SetBackgroundColor(darkgrey);
	223	ptab[2]->SetBackgroundColor(darkgrey);
	224
	225	return frameTab;
	226	}
	227
	228
57ffa5fb	229	//______________________________________________________________________________
ed412809	230	void CascadeListEditor::AddValuator(TGCompositeFrame* frame, char *name,
	231	Float_t min, Float_t max, Int_t pres,
	232	char *func, Int_t iHist) {
	233
	234	TGCompositeFrame* downFrame = new TGCompositeFrame(frame,
	235	60, 60, kHorizontalFrame);
	236
	237	// --- Selectors
7976039f	238	fRange[iHist] = new TEveGDoubleValuator(downFrame, name, 200, 0);
ed412809	239	fRange[iHist]->SetNELength(6);
	240	fRange[iHist]->Build();
	241	fRange[iHist]->GetSlider()->SetWidth(200);
	242
	243	fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESRealTwo);
	244	if (pres==0)
	245	fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESInteger);
	246	else if (pres==3)
	247	fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESRealThree);
	248	else if (pres==4)
	249	fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESRealFour);
	250	else if (pres==5)
	251	fRange[iHist]->SetLimits(min, max, TGNumberFormat::kNESReal);
	252
	253	fRange[iHist]->Connect("ValueSet()",
7976039f	254	"CascadeListEditor", this, func);
ed412809	255	downFrame->AddFrame(fRange[iHist], new TGLayoutHints(kLHintsLeft,
	256	0, 0, 0, 0));
	257
	258	TGTextButton* adjustButton = new TGTextButton(downFrame, "Adjust Hist", 40);
	259
	260	char ch[40];
	261	sprintf(ch,"AdjustHist(=%i)",iHist);
7976039f	262	adjustButton->Connect("Clicked()", "CascadeListEditor", this, ch);
ed412809	263	downFrame->AddFrame(adjustButton, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));
	264
	265	frame->AddFrame(downFrame, new TGLayoutHints(kLHintsTop\| kLHintsExpandY,
	266	0, 0, 0, 0));
	267	}
	268
	269
57ffa5fb	270	//______________________________________________________________________________
ed412809	271	void CascadeListEditor::AddSelectTab() {
51346b82	272
ed412809	273	TGCompositeFrame** tab = CreateTab(&fMainTabA, fTabA, 1);
	274
	275	AddValuator(tab[0], "mass Xi", 0, 5, 3, "MassXiRange()", 0);
	276	AddValuator(tab[1], "mass Omega", 0, 5, 3, "MassOmegaRange()", 1);
	277
	278	AddValuator(tab[3], "Index", 0, 1e5, 0, "IndexRange()", 2);
	279	AddValuator(tab[4], "cos pointing angle", 0.8, 1, 5, "CosPointingRange()", 3);
7976039f	280	AddValuator(tab[5], "bach-AliEveV0 DCA", 0, 5, 3, "BachV0DCARange()", 4);
ed412809	281	AddValuator(tab[6], "radius", 0, 100, 2, "RadiusRange()", 5);
	282	AddValuator(tab[7], "Pt", 0, 10, 2, "PtRange()", 6);
	283	AddValuator(tab[8], "Pseudo-rapidity", -2, 2, 2, "PseudoRapRange()", 7);
	284
	285	AddValuator(tab[9], "neg Pt", 0, 10, 2, "NegPtRange()", 8);
	286	AddValuator(tab[10], "neg pseudo-rapidity", -2, 2, 2, "NegEtaRange()", 9);
	287	AddValuator(tab[11], "pos Pt", 0, 10, 2, "PosPtRange()", 10);
	288	AddValuator(tab[12], "pos pseudo-rapidity", -2, 2, 2, "PosEtaRange()", 11);
	289	AddValuator(tab[13], "bach. Pt", 0, 10, 2, "BachPtRange()", 12);
	290	AddValuator(tab[14], "bach. pseudo-rapidity", -2, 2, 2, "BachEtaRange()", 13);
	291
	292	delete[] tab;
	293	}
	294
	295
57ffa5fb	296	//______________________________________________________________________________
ed412809	297	void CascadeListEditor::AddSeeTab() {
	298
	299	TGCompositeFrame** tab = CreateTab(&fMainTabB, fTabB, 2);
	300	delete[] tab;
	301	}
	302
	303
57ffa5fb	304	//______________________________________________________________________________
ed412809	305	void CascadeListEditor::AdjustHist(Int_t iHist) {
	306
	307	if (! fMList) return;
	308	fMList->AdjustHist(iHist);
	309
	310	FillCanvas();
	311	}
	312
57ffa5fb	313	//______________________________________________________________________________
ed412809	314	void CascadeListEditor::ResetCuts() {
	315
	316	if (! fMList) return;
	317
	318	Float_t min,max;
	319
	320	for (Int_t i=0; i<fgkNRange;i++) {
51346b82	321
ed412809	322	if (i==2) continue;
	323	min = fRange[i]->GetLimitMin();
	324	max = fRange[i]->GetLimitMax();
	325	fMList->SetMin(i, min);
	326	fMList->SetMax(i, max);
	327	fRange[i]->SetValues(min, max);
	328	fMList->AdjustHist(i);
	329	}
	330
	331	// for the Index we scan its actual range
	332	Int_t imin, imax;
	333	fMList->GetCasIndexRange(imin, imax);
	334	if (imin<imax) {
	335	Int_t minH = imin-(imax-imin)/20;
	336	Int_t maxH = imax+(imax-imin)/20;
	337	fMList->SetMin(2, minH);
	338	fMList->SetMax(2, maxH);
	339	fRange[2]->SetLimits(minH, maxH, TGNumberFormat::kNESInteger);
	340	fRange[2]->SetValues(minH, maxH);
	341	fMList->AdjustHist(2);
	342
	343	}
	344	FillCanvas();
	345	Update();
	346	}
	347
	348
57ffa5fb	349	//______________________________________________________________________________
ed412809	350	void CascadeListEditor::FillCanvas() {
	351
	352	fMList->FilterAll();
	353
	354	TCanvas c1, c1b;
	355	TH1F *hist = 0;
	356	TH2F *hist2D = 0;
	357	Bool_t is2D;
	358
	359	Int_t canvasMap[fgkNCanvas]={0,1,1000,2,3,4,5,6,7,8,9,10,11,12,13};
	360
	361	for (Int_t i=0; i<fgkNCanvas; i++)
	362	if (fCanvasA[i]) {
	363
	364	is2D = canvasMap[i]>999;
	365
	366	if (is2D) hist2D = fMList->GetHist2D(canvasMap[i]-1000);
	367	else hist = fMList->GetHist(canvasMap[i]);
	368
	369	c1 = fCanvasA[i]->GetCanvas();
	370	c1->cd();
	371	if (is2D) hist2D->Draw("colz"); else hist->Draw();
	372	c1->Modified();
	373	c1->Update();
51346b82	374
ed412809	375	c1b = fCanvasB[i]->GetCanvas();
	376	c1b->cd();
	377	if (is2D) hist2D->Draw("colz"); else hist->Draw();
	378	c1b->Modified();
	379	c1b->Update();
	380	}
	381	UpdateSelectedTab();
	382	}
57ffa5fb	383	//______________________________________________________________________________
ed412809	384	void CascadeListEditor::UpdateSelectedTab() {
	385
	386	Int_t i,j;
	387	Pixel_t yellow;
	388	Pixel_t grey;
	389	gClient->GetColorByName("yellow", yellow);
	390	gClient->GetColorByName("grey", grey);
	391
51346b82	392	TGTabElement *tabElem;
ed412809	393	for (i=0; i<fMainTabA->GetNumberOfTabs(); i++) {
	394
	395	tabElem = fMainTabA->GetTabTab(i);
	396	tabElem->ChangeBackground(grey);
	397
	398	for (j=0; j<fTabA[i]->GetNumberOfTabs();j++) {
	399	tabElem = fTabA[i]->GetTabTab(j);
	400	tabElem->ChangeBackground(grey);
	401	}
	402	}
	403
	404	Int_t currentTab = fMainTabA->GetCurrent();
	405	Int_t currentSubTab = fTabA[currentTab]->GetCurrent();
	406	tabElem = fMainTabA->GetTabTab(currentTab);
	407	tabElem->ChangeBackground(yellow);
	408	tabElem = fTabA[currentTab]->GetTabTab(currentSubTab);
	409	tabElem->ChangeBackground(yellow);
	410
	411	TCanvas *c1;
	412	Int_t iCan = 0;
	413	i=0;
	414
	415	while (currentTab>i) {
	416	iCan += fTabA[i]->GetNumberOfTabs();
	417	i++;
	418	}
	419	iCan += currentSubTab;
	420	c1 = fCanvasA[iCan]->GetCanvas();
	421	c1->GetCanvas()->Modified();
	422	c1->GetCanvas()->Update();
	423
	424	//---
	425
	426	for (i=0; i<fMainTabB->GetNumberOfTabs(); i++) {
	427
	428	tabElem = fMainTabB->GetTabTab(i);
	429	tabElem->ChangeBackground(grey);
	430
	431	for (j=0; j<fTabB[i]->GetNumberOfTabs();j++) {
	432	tabElem = fTabB[i]->GetTabTab(j);
	433	tabElem->ChangeBackground(grey);
	434	}
	435	}
	436
	437	currentTab = fMainTabB->GetCurrent();
	438	currentSubTab = fTabB[currentTab]->GetCurrent();
	439	tabElem = fMainTabB->GetTabTab(currentTab);
	440	tabElem->ChangeBackground(yellow);
	441	tabElem = fTabB[currentTab]->GetTabTab(currentSubTab);
	442	tabElem->ChangeBackground(yellow);
	443
	444	iCan = 0;
	445	i=0;
	446
	447	while (currentTab>i) {
	448	iCan += fTabB[i]->GetNumberOfTabs();
	449	i++;
	450	}
	451	iCan += currentSubTab;
	452	c1 = fCanvasB[iCan]->GetCanvas();
	453	c1->GetCanvas()->Modified();
	454	c1->GetCanvas()->Update();
	455	}
	456
457
57ffa5fb	458	//______________________________________________________________________________
ed412809	459	void CascadeListEditor::UpdateAll(Int_t iCanA) {
	460
	461	TCanvas *c1 = fCanvasA[iCanA]->GetCanvas();
	462	c1->Modified();
	463	c1->Update();
	464
	465	static Int_t iCan, i;
	466	iCan=0;
	467	i=0;
	468	while (fMainTabB->GetCurrent()>i) {
	469	iCan += fTabB[i]->GetNumberOfTabs();
	470	i++;
	471	}
	472	iCan += fTabB[i]->GetCurrent();
	473	c1 = fCanvasB[iCan]->GetCanvas();
	474	c1->GetCanvas()->Modified();
	475	c1->GetCanvas()->Update();
	476
	477	Update();
	478	}
	479
	480
57ffa5fb	481	//______________________________________________________________________________
ed412809	482
	483	void CascadeListEditor::DoRnrVtx()
	484	{
	485	fMList->SetRnrCasVtx(fRnrVtx->IsOn());
	486	Update();
	487	}
	488
	489	void CascadeListEditor::DoRnrV0path()
	490	{
	491	fMList->SetRnrV0path(fRnrV0path->IsOn());
	492	Update();
	493	}
	494
	495	void CascadeListEditor::DoRnrV0Daughters()
	496	{
	497	fMList->SetRnrV0Daughters(fRnrV0Daughters->IsOn());
	498	Update();
	499	}
	500
	501	void CascadeListEditor::DoRnrBach()
	502	{
	503	fMList->SetRnrBachelor(fRnrBach->IsOn());
	504	Update();
	505	}
	506
	507	void CascadeListEditor::DoRnrCasPath()
	508	{
	509	fMList->SetRnrCasPath(fRnrCasPath->IsOn());
	510	Update();
	511	}
	512
	513
57ffa5fb	514	//______________________________________________________________________________
ed412809	515	void CascadeListEditor::MassXiRange() {
	516
	517	fMList->XiMassFilter(fRange[0]->GetMin(), fRange[0]->GetMax());
	518	UpdateAll(0);
	519	}
	520
57ffa5fb	521	//______________________________________________________________________________
ed412809	522	void CascadeListEditor::MassOmegaRange() {
	523	fMList->OmegaMassFilter(fRange[1]->GetMin(), fRange[1]->GetMax());
	524	UpdateAll(1);
	525	}
	526
57ffa5fb	527	//______________________________________________________________________________
ed412809	528	void CascadeListEditor::IndexRange() {
	529	fMList->IndexFilter(fRange[2]->GetMin(), fRange[2]->GetMax());
	530	UpdateAll(3);
	531	}
57ffa5fb	532	//______________________________________________________________________________
ed412809	533	void CascadeListEditor::CosPointingRange() {
	534	fMList->CosPointingFilter(fRange[3]->GetMin(), fRange[3]->GetMax());
	535	UpdateAll(4);
	536	}
	537
57ffa5fb	538	//______________________________________________________________________________
ed412809	539	void CascadeListEditor::BachV0DCARange() {
	540	fMList->BachV0DCAFilter(fRange[4]->GetMin(), fRange[4]->GetMax());
	541	UpdateAll(5);
	542	}
	543
57ffa5fb	544	//______________________________________________________________________________
ed412809	545	void CascadeListEditor::RadiusRange() {
	546	fMList->RadiusFilter(fRange[5]->GetMin(), fRange[5]->GetMax());
	547	UpdateAll(6);
	548	}
	549
57ffa5fb	550	//______________________________________________________________________________
ed412809	551	void CascadeListEditor::PtRange() {
	552	fMList->PtFilter(fRange[6]->GetMin(), fRange[6]->GetMax());
	553	UpdateAll(7);
	554	}
	555
57ffa5fb	556	//______________________________________________________________________________
ed412809	557	void CascadeListEditor::PseudoRapRange() {
	558	fMList->PseudoRapFilter(fRange[7]->GetMin(), fRange[7]->GetMax());
	559	UpdateAll(8);
	560	}
	561
57ffa5fb	562	//______________________________________________________________________________
ed412809	563	void CascadeListEditor::NegPtRange() {
	564	fMList->NegPtFilter(fRange[8]->GetMin(), fRange[8]->GetMax());
	565	UpdateAll(9);
	566	}
	567
57ffa5fb	568	//______________________________________________________________________________
ed412809	569	void CascadeListEditor::NegEtaRange() {
	570	fMList->NegEtaFilter(fRange[9]->GetMin(), fRange[9]->GetMax());
	571	UpdateAll(10);
	572	}
	573
57ffa5fb	574	//______________________________________________________________________________
ed412809	575	void CascadeListEditor::PosPtRange() {
	576	fMList->PosPtFilter(fRange[10]->GetMin(), fRange[10]->GetMax());
	577	UpdateAll(11);
	578	}
	579
57ffa5fb	580	//______________________________________________________________________________
ed412809	581	void CascadeListEditor::PosEtaRange() {
	582	fMList->PosEtaFilter(fRange[11]->GetMin(), fRange[11]->GetMax());
	583	UpdateAll(12);
	584	}
	585
57ffa5fb	586	//______________________________________________________________________________
ed412809	587	void CascadeListEditor::BachPtRange() {
	588	fMList->BachPtFilter(fRange[12]->GetMin(), fRange[12]->GetMax());
	589	UpdateAll(13);
	590	}
	591
57ffa5fb	592	//______________________________________________________________________________
ed412809	593	void CascadeListEditor::BachEtaRange() {
	594	fMList->BachEtaFilter(fRange[13]->GetMin(), fRange[13]->GetMax());
	595	UpdateAll(14);
	596	}
	597
	598