[u/mrichter/AliRoot.git] / EVE / EveBase / AliEveHF.cxx

// $Id$
// Main author: Davide Caffarri 2009

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

#include "AliEveHF.h"
#include "AliAODRecoDecay.h"

#include <TEveTrack.h>
#include <TEveTrackPropagator.h>
#include <TEveManager.h>

#include <TPolyLine3D.h>
#include <TPolyMarker3D.h>
#include <TColor.h>

#include <TDatabasePDG.h>
#include <TParticlePDG.h>

#include <vector>


/***********************************************************************
*
*  AliEveHF class
*
************************************************************************/


ClassImp(AliEveHF)

//______________________________________________________________________________
AliEveHF::AliEveHF():
  TEvePointSet(),

  fAODobj(0x0),
  fRecBirthHF(0,0,0),
  fRecDecayHF(0,0,0),
  fRecDecayMomHF(0,0,0),
  fPointingAngleHF(0),

  fNegTrack(0),
  fPosTrack(0),
  fRnrStyle(0),
  fPointingLine(0),

  fnProng(0),
  fAODIndex(-1),
  fChi2SecondVtx(-1),

  fProngDCA(0x0),
  fProngd0(0x0),
  fProngMaxProbPdg(0x0),
  fProngMaxProbPid(0x0),
  fInvariantMassPart(0),
  fInvariantMassAntiPart(0),
  fDecay(0)

{
  // Default constructor.

  // Override from TEveElement.
  fPickable = kTRUE;
  fMainColorPtr = &fMarkerColor;
}

//______________________________________________________________________________
AliEveHF::AliEveHF(TEveRecTrack* tNeg, TEveRecTrack* tPos, Double_t primVtx[3], AliAODRecoDecay* aodObj, TEveTrackPropagator* rs) :

  TEvePointSet(),

  fAODobj(aodObj),
  fRecBirthHF(primVtx[0], primVtx[1], primVtx[2]),
  fRecDecayHF(aodObj->GetSecVtxX(), aodObj->GetSecVtxY(), aodObj->GetSecVtxZ()),
  fRecDecayMomHF(aodObj->Px(),aodObj->Py(),aodObj->Pz()),
  fPointingAngleHF(aodObj->CosPointingAngle(primVtx)),

  fNegTrack(new TEveTrack(tNeg, rs)),
  fPosTrack(new TEveTrack(tPos, rs)),
  fRnrStyle(rs),
  fPointingLine(new TEveLine("Pointing line")),

  fnProng(aodObj->GetNProngs()),
  fAODIndex(-1),
  fChi2SecondVtx(aodObj->GetReducedChi2()),

  fProngDCA(0),
  fProngd0(0),
  fProngMaxProbPdg(0),
  fProngMaxProbPid(0),
  fInvariantMassPart(0),
  fInvariantMassAntiPart(0),
  fDecay(0)
{

  // Constructor with full HF specification.
  // Override from TEveElement.
  fPickable = kTRUE;
  fMainColorPtr = &fMarkerColor;

  fMarkerStyle = 2;
  fMarkerColor = kSpring + 6;
  fMarkerSize  = 0.3;

  fPointingLine->SetLineColor(fMarkerColor);
  fPointingLine->SetLineWidth(2);
  fPointingLine->IncDenyDestroy();
  AddElement(fPointingLine);

  fPosTrack->SetLineColor(2);  // red
  fPosTrack->SetStdTitle();
  fNegTrack->SetLineColor(7);  // light blue
  fNegTrack->SetStdTitle();

  fNegTrack->IncDenyDestroy();
  AddElement(fNegTrack);
  fPosTrack->IncDenyDestroy();
  AddElement(fPosTrack);
}

//______________________________________________________________________________
AliEveHF::~AliEveHF()
{
  // Destructor. Dereferences pos/neg tracks and pointing-line objects.

  fNegTrack->DecDenyDestroy();
  fPosTrack->DecDenyDestroy();
  fPointingLine->DecDenyDestroy();
}

//_____________________________________________________________________________
void AliEveHF::SetProngDCA() const
{
  for(Int_t ip=0; ip<fnProng; ip++)
    fProngDCA[ip] = fAODobj->GetDCA(ip);
}

//______________________________________________________________________________
void AliEveHF::Setd0Prong() const
{
  for(Int_t ip=0; ip<fnProng; ip++)
    fProngd0[ip] = fAODobj->Getd0Prong(ip);
}


//______________________________________________________________________________
void AliEveHF::SetMaxProbPdgPid()
{
  // Sets the maximum probability Pdg value and Pid for one daughter
  // Should be moved to TEveTrack property eventually (or AliEveTrack creation)
  Double_t pid[5];
  Int_t    pos = -1;

  for (Int_t ip=0; ip<fnProng; ip++){
    fAODobj->GetPIDProng(ip, pid);

    fProngMaxProbPid[ip]=pid[0]; 
    for (Int_t pp=1; pp<5; pp++)
      if (pid[pp]>pid[pp-1]) {
	fProngMaxProbPid[ip]=pid[pp];
	pos = pp;}
    switch (pos)
      {
      case 0:
	fProngMaxProbPdg[ip] = -11;
	break;
      case 1:
	fProngMaxProbPdg[ip] = -13;
    break;
      case 2:
	fProngMaxProbPdg[ip] = 211;
    break;
      case 3:
	fProngMaxProbPdg[ip] = 321;
    break;
      case 4:
	fProngMaxProbPdg[ip] = 2212;
    break;
      }
  }

}

//________________________________________________________________________________________
void AliEveHF::CalculateInvMass(Int_t decay)
{

  //Method to calculate the invariant mass of the particle and the antiparticle. 
  UInt_t   pdg2[2];
  Double_t mPDG,minv;

  switch (decay)
    {
    case 0:                  // D0->Kpi
      pdg2[0]=211; pdg2[1]=321;
      mPDG=TDatabasePDG::Instance()->GetParticle(421)->Mass();
      minv = fAODobj->InvMass(fnProng,pdg2);
      fInvariantMassPart=minv;

      pdg2[0]=321; pdg2[1]=211;
      minv = fAODobj->InvMass(fnProng,pdg2);
      fInvariantMassAntiPart=minv;
      break;
    }

}

//______________________________________________________________________________
Bool_t AliEveHF::SelectInvMass(Int_t decay, Float_t decayCuts)
{

  //Member fuction to select particles using the invariant mass cuts. 
  UInt_t   pdg2[2];
  Double_t mPDG,minv;

  Bool_t retval=kFALSE;
  switch (decay)
    {
    case 0:                  // D0->Kpi
      pdg2[0]=211; pdg2[1]=321;
      mPDG=TDatabasePDG::Instance()->GetParticle(421)->Mass();
      minv = fAODobj->InvMass(fnProng,pdg2);
      fInvariantMassPart=minv;
      if(TMath::Abs(minv-mPDG)<decayCuts) retval=kTRUE;
      pdg2[0]=321; pdg2[1]=211;
      minv = fAODobj->InvMass(fnProng,pdg2);
      fInvariantMassAntiPart=minv;
      if(TMath::Abs(minv-mPDG)<decayCuts) retval=kTRUE;
      break;
    }
  return retval;

}


//______________________________________________________________________________
void AliEveHF::MakeHF()
{
  // Set all dependant components for drawing.

  SetPoint(0, fRecDecayHF.fX, fRecDecayHF.fY, fRecDecayHF.fZ);

  fNegTrack->MakeTrack();
  fPosTrack->MakeTrack();

  fPointingLine->SetPoint(0, fRecBirthHF.fX, fRecBirthHF.fY, fRecBirthHF.fZ);
  fPointingLine->SetPoint(1, fRecDecayHF.fX, fRecDecayHF.fY, fRecDecayHF.fZ);
}

/***********************************************************************
*
*  AliEveHFList class
*
************************************************************************/

ClassImp(AliEveHFList)

//______________________________________________________________________________
AliEveHFList::AliEveHFList() :
  TEveElementList(),
  fTitle(),
  fRnrStyle(0),
  fRnrDaughters(kTRUE),
  fRnrHFvtx(kTRUE),
  fRnrHFpath(kTRUE),
  fProngColor(0),
  fMinRCut(0),
  fMaxRCut(250),
  fMinDaughterDCA(0),
  fMaxDaughterDCA(1),
  fMinPt(0),
  fMaxPt(20),
  fMinCosPointingAngle(0),
  fMaxCosPointingAngle(1),
  fMind0(-3),
  fMaxd0(3),
  fProngCheckedPid(0x0),
  fProngCheckedProb(0x0),
  fDeltaInvariantMass(0),
  fDecay(0)
{
  // Default constructor.

  fChildClass = AliEveHF::Class(); // override member from base TEveElementList
}

//______________________________________________________________________________
AliEveHFList::AliEveHFList(TEveTrackPropagator* rs) :
  TEveElementList(),
  fTitle(),
  fRnrStyle(rs),
  fRnrDaughters(kTRUE),
  fRnrHFvtx(kTRUE),
  fRnrHFpath(kTRUE),
  fProngColor(0),
  fMinRCut(0),
  fMaxRCut(250),
  fMinDaughterDCA(0),
  fMaxDaughterDCA(1),
  fMinPt(0),
  fMaxPt(20),
  fMinCosPointingAngle(0),
  fMaxCosPointingAngle(1),
  fMind0(-3),
  fMaxd0(3),
  fProngCheckedPid(0x0),
  fProngCheckedProb(0x0),
  fDeltaInvariantMass(1),
  fDecay(0)
{
  // Constructor with given track-propagator..

  fChildClass = AliEveHF::Class(); // override member from base TEveElementList

  Init();
}

//______________________________________________________________________________
AliEveHFList::AliEveHFList(const Text_t* name, TEveTrackPropagator* rs) :
  TEveElementList(),
  fTitle(),
  fRnrStyle(rs),
  fRnrDaughters(kTRUE),
  fRnrHFvtx(kTRUE),
  fRnrHFpath(kTRUE),
  fProngColor(0),
  fMinRCut(0),
  fMaxRCut(100),
  fMinDaughterDCA(0),
  fMaxDaughterDCA(1),
  fMinPt(0),
  fMaxPt(20),
  fMinCosPointingAngle(0),
  fMaxCosPointingAngle(1),
  fMind0(-3),
  fMaxd0(3),
  fProngCheckedPid(0x0),
  fProngCheckedProb(0x0),
  fDeltaInvariantMass(1),
  fDecay(0)
{
  // Standard constructor.

  fChildClass = AliEveHF::Class(); // override member from base TEveElementList

  Init();
  SetName(name);
}

//______________________________________________________________________________
void AliEveHFList::Init()
{
  // Initialize members needed for drawing operations.

  if (fRnrStyle== 0) fRnrStyle = new TEveTrackPropagator;
}

/******************************************************************************/

//______________________________________________________________________________
void AliEveHFList::MakeHFs()
{
  // Call MakeHF() for all elements.

  for(List_i i=fChildren.begin(); i!=fChildren.end(); i++) {
    ((AliEveHF*)(*i))->MakeHF();
  }
  gEve->Redraw3D();
}

/******************************************************************************/


//______________________________________________________________________________
void AliEveHFList::FilterByPt(Float_t minPt, Float_t maxPt)
{

  //Select visibility of elements based on their Pt

  fMinPt = minPt;
  fMaxPt = maxPt;

  for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
    {
      AliEveHF *hf = (AliEveHF*) *i;
      Float_t  pt  = hf->GetPt();
      Bool_t  show = ((pt >= fMinPt) && (pt <= fMaxPt));
      hf->SetRnrState(show);
    }
  ElementChanged();
  gEve->Redraw3D();
}
//______________________________________________________________________________
void AliEveHFList::FilterByRadius(Float_t minR, Float_t maxR)
{
  // Select visibility of elements based on their axial radius.

  fMinRCut = minR;
  fMaxRCut = maxR;

  for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
    {
      AliEveHF *hf = (AliEveHF*) *i;
      Float_t  rad = hf->GetRadius();
      Bool_t  show = rad >= fMinRCut && rad <= fMaxRCut;
      hf->SetRnrState(show);
    }
  ElementChanged();
  gEve->Redraw3D();
}

/******************************************************************************/


//______________________________________________________________________________
void AliEveHFList::FilterByCosPointingAngle(Float_t minCosPointingAngle, Float_t maxCosPointingAngle)
{
  // Select visibility of elements based on the HF cosine of the pointing angle

  fMinCosPointingAngle = minCosPointingAngle;
  fMaxCosPointingAngle = maxCosPointingAngle;


  for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
    {
      AliEveHF *hf = (AliEveHF*) *i;
      Float_t  cosPointingAngle = hf->GetCosPointingAngle();
      Bool_t  show = cosPointingAngle >= fMinCosPointingAngle && cosPointingAngle <= fMaxCosPointingAngle;
      hf->SetRnrState(show);

      ElementChanged();
      gEve->Redraw3D();
    }
}
//______________________________________________________________________________
void AliEveHFList::FilterByd0(Float_t mind0, Float_t maxd0)
{
  // Select visibility of elements based on the HF impact parameter.

  fMind0 = mind0;
  fMaxd0 = maxd0;

  for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
    {
      AliEveHF *hf = (AliEveHF*) *i;
      Int_t nProng=(Int_t)hf->GetAODobj()->GetNProngs();
      for(Int_t ip = 1; ip < nProng; ++ip) {
	Double_t  d0 = hf->Getd0Prong(ip);
	Bool_t  show = d0 >= fMind0 && d0 <= fMaxd0;
	hf->SetRnrState(show);
      }
      ElementChanged();
      gEve->Redraw3D();
    }
}


 //______________________________________________________________________________
void AliEveHFList::FilterByDCA(Float_t minDaughterDCA, Float_t maxDaughterDCA)
{
  // Select visibility of elements based on the DCA between daughters.

  fMinDaughterDCA = minDaughterDCA;
  fMaxDaughterDCA = maxDaughterDCA;

  Double_t dca;
  AliEveHF *hf();


  for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
  {
    AliEveHF* hf = (AliEveHF*) *i;
    Int_t nProng=(Int_t)hf->GetAODobj()->GetNProngs();
    for(Int_t ip = 1; ip < nProng; ++ip) {
      dca = hf->GetProngDCA(ip);
      Bool_t  show = dca >= fMinDaughterDCA && dca <= fMaxDaughterDCA;
      hf->SetRnrState(show);
    }
  }
  ElementChanged();
  gEve->Redraw3D();
}

/******************************************************************************/
//______________________________________________________________________________
/*void AliEveHFList::FilterByCheckedPidMinProb(Int_t rFlag,Int_t rDaughter, Int_t rPid, Float_t rProb)
{

   if (!rDaughter){
    fNegCheckedPid  = rPid;
    fNegCheckedProb = rProb;
  }
  else {
    fPosCheckedPid  = rPid;
    fPosCheckedProb = rProb;
  }

  // Select visibility of elements based on one of the V0 daughters PID
  for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
  {
    AliEveHF* hf = (AliEveHF*) *i;
    Int_t   pid = 0;
    Float_t prob = 0.0;
    Bool_t  show = 0;
    if     (!rDaughter) {// Negative daughter checked
      pid  = hf->GetNegMaxProbPdg();
      prob = hf->GetNegMaxProbPid();
      show = (pid == fNegCheckedPid && prob > fNegCheckedProb) || !rFlag ;
    }
    else if (rDaughter) {// Positive daughter checked
      pid = hf->GetPosMaxProbPdg();
      prob = hf->GetPosMaxProbPid();
      show = (pid == fPosCheckedPid && prob > fPosCheckedProb) || !rFlag ;
    }
    hf->SetRnrState(show);
exit  }
  ElementChanged();
  gEve->Redraw3D();
  }*/

//______________________________________________________________________________

void AliEveHFList::FilterByInvariantMass(Int_t decay, Float_t deltaInvariantMass)
{
  // Select visibility of elements based on the HF  invariant mass.

  fDeltaInvariantMass = deltaInvariantMass;
  fDecay = decay;

  for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
  {
    AliEveHF* hf = (AliEveHF*) *i;
    Bool_t show  = hf->SelectInvMass(decay, fDeltaInvariantMass);
    // if (show) show = (invMass >= (fInvariantMass-fDeltaInvariantMass)) && (invMass <= (fInvariantMass+fDeltaInvariantMass));
    hf->SetRnrState(show);
  }
  ElementChanged();
  gEve->Redraw3D();
}
Commit	Line	Data
fa3634bd	1	// $Id$
	2	// Main author: Davide Caffarri 2009
	3
	4	/**************************************************************************
	5	* Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
	6	* ee http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
	7	* full copyright notice. *
	8	**************************************************************************/
	9
	10	#include "AliEveHF.h"
	11	#include "AliAODRecoDecay.h"
	12
	13	#include <TEveTrack.h>
	14	#include <TEveTrackPropagator.h>
	15	#include <TEveManager.h>
	16
	17	#include <TPolyLine3D.h>
	18	#include <TPolyMarker3D.h>
	19	#include <TColor.h>
	20
	21	#include <TDatabasePDG.h>
	22	#include <TParticlePDG.h>
	23
	24	#include <vector>
	25
	26
	27	/***********************************************************************
	28	*
	29	* AliEveHF class
	30	*
	31	************************************************************************/
	32
	33
	34	ClassImp(AliEveHF)
	35
	36	//______________________________________________________________________________
	37	AliEveHF::AliEveHF():
	38	TEvePointSet(),
	39
	40	fAODobj(0x0),
	41	fRecBirthHF(0,0,0),
f8d5a389	42	fRecDecayHF(0,0,0),
12cc265f	43	fRecDecayMomHF(0,0,0),
fa3634bd	44	fPointingAngleHF(0),
	45
	46	fNegTrack(0),
	47	fPosTrack(0),
	48	fRnrStyle(0),
	49	fPointingLine(0),
f8d5a389	50
fa3634bd	51	fnProng(0),
	52	fAODIndex(-1),
	53	fChi2SecondVtx(-1),
f8d5a389	54
fa3634bd	55	fProngDCA(0x0),
	56	fProngd0(0x0),
	57	fProngMaxProbPdg(0x0),
	58	fProngMaxProbPid(0x0),
	59	fInvariantMassPart(0),
	60	fInvariantMassAntiPart(0),
	61	fDecay(0)
	62
	63	{
	64	// Default constructor.
	65
	66	// Override from TEveElement.
	67	fPickable = kTRUE;
	68	fMainColorPtr = &fMarkerColor;
	69	}
	70
	71	//______________________________________________________________________________
12cc265f	72	AliEveHF::AliEveHF(TEveRecTrack* tNeg, TEveRecTrack* tPos, Double_t primVtx[3], AliAODRecoDecay* aodObj, TEveTrackPropagator* rs) :
f8d5a389	73
fa3634bd	74	TEvePointSet(),
	75
	76	fAODobj(aodObj),
	77	fRecBirthHF(primVtx[0], primVtx[1], primVtx[2]),
	78	fRecDecayHF(aodObj->GetSecVtxX(), aodObj->GetSecVtxY(), aodObj->GetSecVtxZ()),
12cc265f	79	fRecDecayMomHF(aodObj->Px(),aodObj->Py(),aodObj->Pz()),
fa3634bd	80	fPointingAngleHF(aodObj->CosPointingAngle(primVtx)),
	81
	82	fNegTrack(new TEveTrack(tNeg, rs)),
	83	fPosTrack(new TEveTrack(tPos, rs)),
	84	fRnrStyle(rs),
	85	fPointingLine(new TEveLine("Pointing line")),
f8d5a389	86
fa3634bd	87	fnProng(aodObj->GetNProngs()),
	88	fAODIndex(-1),
	89	fChi2SecondVtx(aodObj->GetReducedChi2()),
f8d5a389	90
fa3634bd	91	fProngDCA(0),
	92	fProngd0(0),
	93	fProngMaxProbPdg(0),
	94	fProngMaxProbPid(0),
	95	fInvariantMassPart(0),
	96	fInvariantMassAntiPart(0),
	97	fDecay(0)
	98	{
f8d5a389	99
fa3634bd	100	// Constructor with full HF specification.
	101	// Override from TEveElement.
	102	fPickable = kTRUE;
	103	fMainColorPtr = &fMarkerColor;
	104
	105	fMarkerStyle = 2;
	106	fMarkerColor = kSpring + 6;
	107	fMarkerSize = 0.3;
	108
	109	fPointingLine->SetLineColor(fMarkerColor);
	110	fPointingLine->SetLineWidth(2);
	111	fPointingLine->IncDenyDestroy();
	112	AddElement(fPointingLine);
	113
	114	fPosTrack->SetLineColor(2); // red
	115	fPosTrack->SetStdTitle();
	116	fNegTrack->SetLineColor(7); // light blue
	117	fNegTrack->SetStdTitle();
	118
	119	fNegTrack->IncDenyDestroy();
	120	AddElement(fNegTrack);
	121	fPosTrack->IncDenyDestroy();
	122	AddElement(fPosTrack);
	123	}
	124
	125	//______________________________________________________________________________
	126	AliEveHF::~AliEveHF()
	127	{
	128	// Destructor. Dereferences pos/neg tracks and pointing-line objects.
	129
	130	fNegTrack->DecDenyDestroy();
	131	fPosTrack->DecDenyDestroy();
	132	fPointingLine->DecDenyDestroy();
	133	}
	134
	135	//_____________________________________________________________________________
	136	void AliEveHF::SetProngDCA() const
f8d5a389	137	{
fa3634bd	138	for(Int_t ip=0; ip<fnProng; ip++)
	139	fProngDCA[ip] = fAODobj->GetDCA(ip);
	140	}
	141
	142	//______________________________________________________________________________
	143	void AliEveHF::Setd0Prong() const
f8d5a389	144	{
fa3634bd	145	for(Int_t ip=0; ip<fnProng; ip++)
	146	fProngd0[ip] = fAODobj->Getd0Prong(ip);
	147	}
	148
	149
	150	//______________________________________________________________________________
	151	void AliEveHF::SetMaxProbPdgPid()
	152	{
	153	// Sets the maximum probability Pdg value and Pid for one daughter
	154	// Should be moved to TEveTrack property eventually (or AliEveTrack creation)
	155	Double_t pid[5];
	156	Int_t pos = -1;
f8d5a389	157
fa3634bd	158	for (Int_t ip=0; ip<fnProng; ip++){
f8d5a389	159	fAODobj->GetPIDProng(ip, pid);
fa3634bd	160
12cc265f	161	fProngMaxProbPid[ip]=pid[0];
fa3634bd	162	for (Int_t pp=1; pp<5; pp++)
f8d5a389	163	if (pid[pp]>pid[pp-1]) {
fa3634bd	164	fProngMaxProbPid[ip]=pid[pp];
	165	pos = pp;}
	166	switch (pos)
f8d5a389	167	{
f8d5a389	168	case 0:
fa3634bd	169	fProngMaxProbPdg[ip] = -11;
9772b83b	170	break;
f8d5a389	171	case 1:
fa3634bd	172	fProngMaxProbPdg[ip] = -13;
9772b83b	173	break;
f8d5a389	174	case 2:
fa3634bd	175	fProngMaxProbPdg[ip] = 211;
9772b83b	176	break;
f8d5a389	177	case 3:
fa3634bd	178	fProngMaxProbPdg[ip] = 321;
9772b83b	179	break;
f8d5a389	180	case 4:
fa3634bd	181	fProngMaxProbPdg[ip] = 2212;
9772b83b	182	break;
fa3634bd	183	}
fa3634bd	184	}
f8d5a389	185
fa3634bd	186	}
	187
	188	//________________________________________________________________________________________
	189	void AliEveHF::CalculateInvMass(Int_t decay)
	190	{
12cc265f	191
12cc265f	192	//Method to calculate the invariant mass of the particle and the antiparticle.
fa3634bd	193	UInt_t pdg2[2];
fa3634bd	194	Double_t mPDG,minv;
f8d5a389	195
	196	switch (decay)
	197	{
fa3634bd	198	case 0: // D0->Kpi
	199	pdg2[0]=211; pdg2[1]=321;
	200	mPDG=TDatabasePDG::Instance()->GetParticle(421)->Mass();
	201	minv = fAODobj->InvMass(fnProng,pdg2);
	202	fInvariantMassPart=minv;
f8d5a389	203
fa3634bd	204	pdg2[0]=321; pdg2[1]=211;
	205	minv = fAODobj->InvMass(fnProng,pdg2);
	206	fInvariantMassAntiPart=minv;
	207	break;
	208	}
f8d5a389	209
fa3634bd	210	}
	211
	212	//______________________________________________________________________________
	213	Bool_t AliEveHF::SelectInvMass(Int_t decay, Float_t decayCuts)
	214	{
12cc265f	215
12cc265f	216	//Member fuction to select particles using the invariant mass cuts.
fa3634bd	217	UInt_t pdg2[2];
fa3634bd	218	Double_t mPDG,minv;
f8d5a389	219
fa3634bd	220	Bool_t retval=kFALSE;
f8d5a389	221	switch (decay)
f8d5a389	222	{
fa3634bd	223	case 0: // D0->Kpi
	224	pdg2[0]=211; pdg2[1]=321;
	225	mPDG=TDatabasePDG::Instance()->GetParticle(421)->Mass();
	226	minv = fAODobj->InvMass(fnProng,pdg2);
	227	fInvariantMassPart=minv;
	228	if(TMath::Abs(minv-mPDG)<decayCuts) retval=kTRUE;
	229	pdg2[0]=321; pdg2[1]=211;
	230	minv = fAODobj->InvMass(fnProng,pdg2);
	231	fInvariantMassAntiPart=minv;
	232	if(TMath::Abs(minv-mPDG)<decayCuts) retval=kTRUE;
	233	break;
	234	}
	235	return retval;
	236
	237	}
	238
	239
	240	//______________________________________________________________________________
	241	void AliEveHF::MakeHF()
	242	{
	243	// Set all dependant components for drawing.
	244
	245	SetPoint(0, fRecDecayHF.fX, fRecDecayHF.fY, fRecDecayHF.fZ);
	246
	247	fNegTrack->MakeTrack();
	248	fPosTrack->MakeTrack();
	249
	250	fPointingLine->SetPoint(0, fRecBirthHF.fX, fRecBirthHF.fY, fRecBirthHF.fZ);
	251	fPointingLine->SetPoint(1, fRecDecayHF.fX, fRecDecayHF.fY, fRecDecayHF.fZ);
	252	}
	253
	254	/***********************************************************************
	255	*
	256	* AliEveHFList class
	257	*
	258	************************************************************************/
	259
	260	ClassImp(AliEveHFList)
	261
	262	//______________________________________________________________________________
	263	AliEveHFList::AliEveHFList() :
	264	TEveElementList(),
	265	fTitle(),
	266	fRnrStyle(0),
	267	fRnrDaughters(kTRUE),
	268	fRnrHFvtx(kTRUE),
	269	fRnrHFpath(kTRUE),
	270	fProngColor(0),
	271	fMinRCut(0),
	272	fMaxRCut(250),
	273	fMinDaughterDCA(0),
	274	fMaxDaughterDCA(1),
	275	fMinPt(0),
	276	fMaxPt(20),
	277	fMinCosPointingAngle(0),
	278	fMaxCosPointingAngle(1),
	279	fMind0(-3),
	280	fMaxd0(3),
	281	fProngCheckedPid(0x0),
	282	fProngCheckedProb(0x0),
	283	fDeltaInvariantMass(0),
	284	fDecay(0)
	285	{
	286	// Default constructor.
287
288	fChildClass = AliEveHF::Class(); // override member from base TEveElementList
289	}
290
291	//______________________________________________________________________________
292	AliEveHFList::AliEveHFList(TEveTrackPropagator* rs) :
293	TEveElementList(),
294	fTitle(),
295	fRnrStyle(rs),
296	fRnrDaughters(kTRUE),
297	fRnrHFvtx(kTRUE),
298	fRnrHFpath(kTRUE),
299	fProngColor(0),
300	fMinRCut(0),
301	fMaxRCut(250),
302	fMinDaughterDCA(0),
303	fMaxDaughterDCA(1),
304	fMinPt(0),
305	fMaxPt(20),
306	fMinCosPointingAngle(0),
307	fMaxCosPointingAngle(1),
308	fMind0(-3),
309	fMaxd0(3),
310	fProngCheckedPid(0x0),
311	fProngCheckedProb(0x0),
312	fDeltaInvariantMass(1),
313	fDecay(0)
314	{
315	// Constructor with given track-propagator..
316
317	fChildClass = AliEveHF::Class(); // override member from base TEveElementList
318
319	Init();
320	}
321
322	//______________________________________________________________________________
323	AliEveHFList::AliEveHFList(const Text_t* name, TEveTrackPropagator* rs) :
324	TEveElementList(),
325	fTitle(),
326	fRnrStyle(rs),
327	fRnrDaughters(kTRUE),
328	fRnrHFvtx(kTRUE),
329	fRnrHFpath(kTRUE),
330	fProngColor(0),
331	fMinRCut(0),
332	fMaxRCut(100),
333	fMinDaughterDCA(0),
334	fMaxDaughterDCA(1),
335	fMinPt(0),
336	fMaxPt(20),
337	fMinCosPointingAngle(0),
338	fMaxCosPointingAngle(1),
339	fMind0(-3),
340	fMaxd0(3),
341	fProngCheckedPid(0x0),
342	fProngCheckedProb(0x0),
343	fDeltaInvariantMass(1),
344	fDecay(0)
345	{
346	// Standard constructor.
347
348	fChildClass = AliEveHF::Class(); // override member from base TEveElementList
349
350	Init();
351	SetName(name);
352	}
353
354	//______________________________________________________________________________
355	void AliEveHFList::Init()
356	{
357	// Initialize members needed for drawing operations.
358
359	if (fRnrStyle== 0) fRnrStyle = new TEveTrackPropagator;
360	}
361
362	/******************************************************************************/
363
364	//______________________________________________________________________________
365	void AliEveHFList::MakeHFs()
366	{
367	// Call MakeHF() for all elements.
368
369	for(List_i i=fChildren.begin(); i!=fChildren.end(); i++) {
370	((AliEveHF)(i))->MakeHF();
371	}
372	gEve->Redraw3D();
373	}
374
375	/******************************************************************************/
376
377
378	//______________________________________________________________________________
379	void AliEveHFList::FilterByPt(Float_t minPt, Float_t maxPt)
380	{
f8d5a389	381
12cc265f	382	//Select visibility of elements based on their Pt
fa3634bd	383
	384	fMinPt = minPt;
	385	fMaxPt = maxPt;
	386
12cc265f	387	for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
fa3634bd	388	{
	389	AliEveHF hf = (AliEveHF) *i;
	390	Float_t pt = hf->GetPt();
	391	Bool_t show = ((pt >= fMinPt) && (pt <= fMaxPt));
	392	hf->SetRnrState(show);
	393	}
	394	ElementChanged();
	395	gEve->Redraw3D();
	396	}
	397	//______________________________________________________________________________
	398	void AliEveHFList::FilterByRadius(Float_t minR, Float_t maxR)
	399	{
	400	// Select visibility of elements based on their axial radius.
	401
	402	fMinRCut = minR;
	403	fMaxRCut = maxR;
	404
12cc265f	405	for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
fa3634bd	406	{
	407	AliEveHF hf = (AliEveHF) *i;
	408	Float_t rad = hf->GetRadius();
	409	Bool_t show = rad >= fMinRCut && rad <= fMaxRCut;
	410	hf->SetRnrState(show);
	411	}
	412	ElementChanged();
	413	gEve->Redraw3D();
	414	}
	415
	416	/******************************************************************************/
	417
	418
	419	//______________________________________________________________________________
	420	void AliEveHFList::FilterByCosPointingAngle(Float_t minCosPointingAngle, Float_t maxCosPointingAngle)
	421	{
12cc265f	422	// Select visibility of elements based on the HF cosine of the pointing angle
fa3634bd	423
	424	fMinCosPointingAngle = minCosPointingAngle;
	425	fMaxCosPointingAngle = maxCosPointingAngle;
	426
	427
12cc265f	428	for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
fa3634bd	429	{
	430	AliEveHF hf = (AliEveHF) *i;
	431	Float_t cosPointingAngle = hf->GetCosPointingAngle();
	432	Bool_t show = cosPointingAngle >= fMinCosPointingAngle && cosPointingAngle <= fMaxCosPointingAngle;
	433	hf->SetRnrState(show);
f8d5a389	434
fa3634bd	435	ElementChanged();
	436	gEve->Redraw3D();
	437	}
	438	}
	439	//______________________________________________________________________________
	440	void AliEveHFList::FilterByd0(Float_t mind0, Float_t maxd0)
	441	{
12cc265f	442	// Select visibility of elements based on the HF impact parameter.
fa3634bd	443
	444	fMind0 = mind0;
	445	fMaxd0 = maxd0;
	446
	447	for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
	448	{
	449	AliEveHF hf = (AliEveHF) *i;
	450	Int_t nProng=(Int_t)hf->GetAODobj()->GetNProngs();
f8d5a389	451	for(Int_t ip = 1; ip < nProng; ++ip) {
fa3634bd	452	Double_t d0 = hf->Getd0Prong(ip);
	453	Bool_t show = d0 >= fMind0 && d0 <= fMaxd0;
	454	hf->SetRnrState(show);
	455	}
	456	ElementChanged();
	457	gEve->Redraw3D();
	458	}
	459	}
	460
	461
	462	//______________________________________________________________________________
	463	void AliEveHFList::FilterByDCA(Float_t minDaughterDCA, Float_t maxDaughterDCA)
	464	{
	465	// Select visibility of elements based on the DCA between daughters.
	466
	467	fMinDaughterDCA = minDaughterDCA;
	468	fMaxDaughterDCA = maxDaughterDCA;
	469
	470	Double_t dca;
	471	AliEveHF *hf();
f8d5a389	472
fa3634bd	473
	474	for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
	475	{
	476	AliEveHF* hf = (AliEveHF) i;
	477	Int_t nProng=(Int_t)hf->GetAODobj()->GetNProngs();
f8d5a389	478	for(Int_t ip = 1; ip < nProng; ++ip) {
fa3634bd	479	dca = hf->GetProngDCA(ip);
	480	Bool_t show = dca >= fMinDaughterDCA && dca <= fMaxDaughterDCA;
	481	hf->SetRnrState(show);
f8d5a389	482	}
fa3634bd	483	}
	484	ElementChanged();
	485	gEve->Redraw3D();
	486	}
f8d5a389	487
fa3634bd	488	/******************************************************************************/
	489	//______________________________________________________________________________
	490	/*void AliEveHFList::FilterByCheckedPidMinProb(Int_t rFlag,Int_t rDaughter, Int_t rPid, Float_t rProb)
	491	{
	492
	493	if (!rDaughter){
	494	fNegCheckedPid = rPid;
	495	fNegCheckedProb = rProb;
	496	}
	497	else {
	498	fPosCheckedPid = rPid;
	499	fPosCheckedProb = rProb;
	500	}
	501
	502	// Select visibility of elements based on one of the V0 daughters PID
	503	for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
	504	{
	505	AliEveHF* hf = (AliEveHF) i;
	506	Int_t pid = 0;
	507	Float_t prob = 0.0;
	508	Bool_t show = 0;
	509	if (!rDaughter) {// Negative daughter checked
	510	pid = hf->GetNegMaxProbPdg();
	511	prob = hf->GetNegMaxProbPid();
f8d5a389	512	show = (pid == fNegCheckedPid && prob > fNegCheckedProb) \|\| !rFlag ;
fa3634bd	513	}
	514	else if (rDaughter) {// Positive daughter checked
	515	pid = hf->GetPosMaxProbPdg();
	516	prob = hf->GetPosMaxProbPid();
f8d5a389	517	show = (pid == fPosCheckedPid && prob > fPosCheckedProb) \|\| !rFlag ;
fa3634bd	518	}
	519	hf->SetRnrState(show);
	520	exit }
	521	ElementChanged();
	522	gEve->Redraw3D();
	523	}*/
	524
	525	//______________________________________________________________________________
	526
	527	void AliEveHFList::FilterByInvariantMass(Int_t decay, Float_t deltaInvariantMass)
	528	{
	529	// Select visibility of elements based on the HF invariant mass.
	530
	531	fDeltaInvariantMass = deltaInvariantMass;
	532	fDecay = decay;
	533
	534	for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
	535	{
	536	AliEveHF* hf = (AliEveHF) i;
	537	Bool_t show = hf->SelectInvMass(decay, fDeltaInvariantMass);
	538	// if (show) show = (invMass >= (fInvariantMass-fDeltaInvariantMass)) && (invMass <= (fInvariantMass+fDeltaInvariantMass));
	539	hf->SetRnrState(show);
	540	}
	541	ElementChanged();
	542	gEve->Redraw3D();
	543	}