[u/mrichter/AliRoot.git] / EVE / EveDet / blacklisted-classes / AliEveV0Editors.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.                                                 *
 **************************************************************************/
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/


/***********************************************************************
  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 "AliEveV0Editors.h"
#include <EveDet/AliEveV0.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>


//______________________________________________________________________________
// V0ListEditor
//

ClassImp(V0ListEditor)

V0ListEditor::V0ListEditor(const TGWindow *p,
                                 Int_t width, Int_t height,
                                 UInt_t options, Pixel_t back) :
  TGedFrame(p, width, height, options | kVerticalFrame, back),
  fMList(0),
  fRnrV0sDaugh(0),
  fRnrV0vtx(0),
  fRnrV0path(0),
  fMainTabA(0),
  fMainTabB(0)
{
  MakeTitle("V0List");

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

  // --- Rendering control

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

  fRnrV0vtx = new TGCheckButton(this, "Render v0 vertices");
  AddFrame(fRnrV0vtx, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fRnrV0vtx->Connect("Toggled(Bool_t)",
		     "V0ListEditor", this, "DoRnrV0vtx()");

  fRnrV0sDaugh = new TGCheckButton(this, "Render v0 daughters");
  AddFrame(fRnrV0sDaugh, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
  fRnrV0sDaugh->Connect("Toggled(Bool_t)",
			"V0ListEditor", this, "DoRnrDaughters()");

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

  AddSelectTab();
  AddSeeTab();

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

V0ListEditor::~V0ListEditor() {}


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

  for (Int_t i=0; i<fgkNRange; i++)
    if (fRange[i]) {
      fRange[i]->SetValues( fMList->GetMin(i), fMList->GetMax(i) );
    }
  fRnrV0sDaugh->SetState(fMList->GetRnrDaughters() ? kButtonDown : kButtonUp);
  fRnrV0vtx->SetState(fMList->GetRnrV0vtx() ? kButtonDown : kButtonUp);
  fRnrV0path->SetState(fMList->GetRnrV0path() ? kButtonDown : kButtonUp);

  FillCanvas();
}


//______________________________________________________________________________
TGCompositeFrame* V0ListEditor::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** V0ListEditor::CreateTab(TGTab **pMainTab, TGTab **ptab, Int_t can) {

  //------
  // tab widget
  pMainTab[0] = new TGTab(this,0,0);
  pMainTab[0]->Connect("Selected(Int_t)", "V0ListEditor", 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)", "V0ListEditor", this, "UpdateSelectedTab()");
  frameTab1->AddFrame(ptab[0], new TGLayoutHints(kLHintsLeft| kLHintsExpandX,0,0,0,0));

  //------
  // container of "Tab2"
  TGCompositeFrame *frameTab2 = pMainTab[0]->AddTab("v0");
  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)", "V0ListEditor", this, "UpdateSelectedTab()");
  frameTab2->AddFrame(ptab[1], new TGLayoutHints(kLHintsLeft| kLHintsExpandX ,0,0,0,0));

  //------
  // container of "Tab3"
  TGCompositeFrame *frameTab3 = pMainTab[0]->AddTab("daughters");
  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)", "V0ListEditor", 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, "K0s");
  frameTab[1] = AddTab(ptab[0], 1, can, "Lambda");
  frameTab[2] = AddTab(ptab[0], 2, can, "Anti-Lambda");
  frameTab[3] = AddTab(ptab[0], 3, can, "Arm-Podo");
  frameTab[4] = AddTab(ptab[0], 4, can, "Index");
  frameTab[5] = AddTab(ptab[1], 5, can, "cosPointing");
  frameTab[6] = AddTab(ptab[1], 6, can, "daughterDCA");
  frameTab[7] = AddTab(ptab[1], 7, can, "radius");
  frameTab[8] = AddTab(ptab[1], 8, can, "Pt");
  frameTab[9] = AddTab(ptab[1], 9, can, "eta");
  frameTab[10] = AddTab(ptab[2], 10, can, "neg Pt");
  frameTab[11] = AddTab(ptab[2], 11, can, "neg eta");
  frameTab[12] = AddTab(ptab[2], 12, can, "pos Pt");
  frameTab[13] = AddTab(ptab[2], 13, can, "pos 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 V0ListEditor::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()",
			 "V0ListEditor", 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()", "V0ListEditor", this, ch);
  downFrame->AddFrame(adjustButton, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));

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


//______________________________________________________________________________
void V0ListEditor::AddSelectTab() {

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

  AddValuator(tab[0],  "mass K0s",           0,  5, 3, "MassK0sRange()",     1);
  AddValuator(tab[1],  "mass Lambda",        0,  5, 3, "MassLamRange()",     2);
  AddValuator(tab[2],  "mass Anti-Lambda",   0,  5, 3, "MassAntiLamRange()", 3);
  AddValuator(tab[4],  "ESD v0 index",       0,1e5, 0, "ESDv0IndexRange()", 12);
  AddValuator(tab[5],  "cos pointing angle", 0.8,1, 5, "CosPointingRange()", 5);
  AddValuator(tab[6],  "daughter DCA",       0, 10, 2, "DaughterDcaRange()", 4);
  AddValuator(tab[7],  "radius",             0,100, 2, "RadiusRange()",      6);
  AddValuator(tab[8],  "Pt range",           0, 10, 2, "PtRange()",          0);
  AddValuator(tab[9],  "eta",               -2,  2, 2, "EtaRange()",         7);
  AddValuator(tab[10],  "neg Pt",            0, 10, 2, "NegPtRange()",       8);
  AddValuator(tab[11], "neg eta",           -2,  2, 2, "NegEtaRange()",      9);
  AddValuator(tab[12], "pos Pt",             0, 10, 2, "PosPtRange()",       10);
  AddValuator(tab[13], "pos eta",           -2,  2, 2, "PosEtaRange()",      11);

  delete[] tab;
}


//______________________________________________________________________________
void V0ListEditor::AddSeeTab() {

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


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

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

  FillCanvas();
}

//______________________________________________________________________________
void V0ListEditor::ResetCuts() {

  if (! fMList) return;

  Float_t min,max;

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

    if (i==12) 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->GetV0IndexRange(imin, imax);
  if (imin<imax) {
    Int_t minH = imin - (imax-imin)/20;
    Int_t maxH = imax + (imax-imin)/20;
    fMList->SetMin(12, minH);
    fMList->SetMax(12, maxH);
    fRange[12]->SetLimits(minH, maxH, TGNumberFormat::kNESInteger);
    fRange[12]->SetValues(minH, maxH);
    fMList->AdjustHist(12);

  }
  FillCanvas();
  Update();
}


//______________________________________________________________________________
void V0ListEditor::FillCanvas() {

  fMList->FilterAll();

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

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

  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 V0ListEditor::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 V0ListEditor::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 V0ListEditor::DoRnrV0vtx()
{
  fMList->SetRnrV0vtx(fRnrV0vtx->IsOn());
  Update();
}

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

void V0ListEditor::DoRnrDaughters()
{
  fMList->SetRnrDaughters(fRnrV0sDaugh->IsOn());
  Update();
}


//______________________________________________________________________________
void V0ListEditor::MassK0sRange() {

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

//______________________________________________________________________________
  void V0ListEditor::MassLamRange() {
  fMList->LamMFilter(fRange[2]->GetMin(), fRange[2]->GetMax());
  UpdateAll(1);
}

//______________________________________________________________________________
  void V0ListEditor::MassAntiLamRange() {
  fMList->ALamMFilter(fRange[3]->GetMin(), fRange[3]->GetMax());
  UpdateAll(2);
}

//______________________________________________________________________________
void V0ListEditor::ESDv0IndexRange() {
  fMList->IndexFilter(fRange[12]->GetMin(), fRange[12]->GetMax());
  UpdateAll(4);
}

//______________________________________________________________________________
  void V0ListEditor::CosPointingRange() {
  fMList->CosPointingFilter(fRange[5]->GetMin(), fRange[5]->GetMax());
  UpdateAll(5);
}

//______________________________________________________________________________
  void V0ListEditor::DaughterDcaRange() {
  fMList->DaughterDCAFilter(fRange[4]->GetMin(), fRange[4]->GetMax());
  UpdateAll(6);
}

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

//______________________________________________________________________________
void V0ListEditor::PtRange()
{
  fMList->PtFilter(fRange[0]->GetMin(), fRange[0]->GetMax());
  UpdateAll(8);
}

//______________________________________________________________________________
  void V0ListEditor::EtaRange() {
  fMList->EtaFilter(fRange[7]->GetMin(), fRange[7]->GetMax());
  UpdateAll(9);
}

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

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

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

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