fESDIndex(-1),
fOnFlyStatus(kFALSE),
fDaughterDCA(999),
- fChi2V0(-1)
+ fChi2V0(-1),
+ fNegMaxProbPdg(0),
+ fPosMaxProbPdg(0),
+ fNegMaxProbPid(0),
+ fPosMaxProbPid(0)
{
// Default constructor.
fESDIndex(-1),
fOnFlyStatus(kFALSE),
fDaughterDCA(999),
- fChi2V0(-1)
+ fChi2V0(-1),
+ fNegMaxProbPdg(0),
+ fPosMaxProbPdg(0),
+ fNegMaxProbPid(0),
+ fPosMaxProbPid(0)
{
// Constructor with full V0 specification.
}
//______________________________________________________________________________
-Float_t AliEveV0::GetInvMass(Float_t nPdgCode, Float_t pPdgCode) const
+void AliEveV0::SetMaxProbPdgPid(Int_t iDaughter, Int_t rPdg, Float_t rPid)
+{
+ // Sets the maximum probability Pdg value and Pid for one daughter
+ // Should be moved to TEveTrack property eventually (or AliEveTrack creation)
+
+ if(iDaughter==0){
+ fNegMaxProbPdg = rPdg;
+ fNegMaxProbPid = rPid;
+ }
+ else if (iDaughter==1){
+ fPosMaxProbPdg = rPdg;
+ fPosMaxProbPid = rPid;
+ }
+
+}
+//______________________________________________________________________________
+Float_t AliEveV0::GetInvMass(Int_t nPdgCode, Int_t pPdgCode) const
{
// Returns Invariant Mass assuming the masses of the daughter particles
TEveVector lNegMomentum = fNegTrack->GetMomentum();
fMinDaughterDCA(0),
fMaxDaughterDCA(1),
fMinPt(0),
- fMaxPt(20)
+ fMaxPt(20),
+ fNegCheckedPid(211),
+ fPosCheckedPid(211),
+ fNegCheckedProb(0.5),
+ fPosCheckedProb(0.5),
+ fMinInvariantMass(0),
+ fMaxInvariantMass(1.2)
{
// Default constructor.
fMinDaughterDCA(0),
fMaxDaughterDCA(1),
fMinPt(0),
- fMaxPt(20)
+ fMaxPt(20),
+ fNegCheckedPid(211),
+ fPosCheckedPid(211),
+ fNegCheckedProb(0.5),
+ fPosCheckedProb(0.5),
+ fMinInvariantMass(0),
+ fMaxInvariantMass(1.2)
{
// Constructor with given track-propagator..
fMinDaughterDCA(0),
fMaxDaughterDCA(1),
fMinPt(0),
- fMaxPt(20)
+ fMaxPt(20),
+ fNegCheckedPid(211),
+ fPosCheckedPid(211),
+ fNegCheckedProb(0.5),
+ fPosCheckedProb(0.5),
+ fMinInvariantMass(0),
+ fMaxInvariantMass(1.2)
{
// Standard constructor.
ElementChanged();
gEve->Redraw3D();
}
+
+//______________________________________________________________________________
+void AliEveV0List::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)
+ {
+ AliEveV0* v0 = (AliEveV0*) *i;
+ Int_t pid = 0;
+ Float_t prob = 0.0;
+ Bool_t show = 0;
+ if (!rDaughter) {// Negative daughter checked
+ pid = v0->GetNegMaxProbPdg();
+ prob = v0->GetNegMaxProbPid();
+ show = (pid == fNegCheckedPid && prob > fNegCheckedProb) || !rFlag ;
+ }
+ else if (rDaughter) {// Positive daughter checked
+ pid = v0->GetPosMaxProbPdg();
+ prob = v0->GetPosMaxProbPid();
+ show = (pid == fPosCheckedPid && prob > fPosCheckedProb) || !rFlag ;
+ }
+ v0->SetRnrState(show);
+ }
+ ElementChanged();
+ gEve->Redraw3D();
+}
+
+//______________________________________________________________________________
+void AliEveV0List::FilterByInvariantMass(Float_t minInvariantMass, Float_t maxInvariantMass, Int_t nPdgCode, Int_t pPdgCode)
+{
+ // Select visibility of elements based on the V0 invariant mass.
+
+ fMinInvariantMass = minInvariantMass;
+ fMaxInvariantMass = maxInvariantMass;
+
+ for(List_i i = fChildren.begin(); i != fChildren.end(); ++i)
+ {
+ AliEveV0* v0 = (AliEveV0*) *i;
+ Float_t invMass = v0->GetInvMass(nPdgCode, pPdgCode);
+ Bool_t show = invMass >= fMinInvariantMass && invMass <= fMaxInvariantMass;
+ v0->SetRnrState(show);
+ }
+ ElementChanged();
+ gEve->Redraw3D();
+}
Float_t GetRadius() const { return fRecDecayV.Perp(); }
Float_t GetPt() const { return fRecDecayP.Perp(); }
- Float_t GetInvMass(Float_t nPdgCode, Float_t pPdgCode) const;
+ Float_t GetInvMass(Int_t nPdgCode, Int_t pPdgCode) const;
Float_t GetK0sInvMass() const { return GetInvMass(kPiMinus,kPiPlus); }
Float_t GetLambdaInvMass() const { return GetInvMass(kPiMinus,kProton); }
Float_t GetAntiLambdaInvMass() const { return GetInvMass(kProton,kPiPlus); }
Bool_t GetOnFlyStatus() const { return fOnFlyStatus; }
void SetOnFlyStatus(Bool_t fs) { fOnFlyStatus = fs; }
+ void SetMaxProbPdgPid(Int_t iDaughter, Int_t rPdg, Float_t rPid);
+ Int_t GetNegMaxProbPdg() const { return fNegMaxProbPdg; }
+ Int_t GetPosMaxProbPdg() const { return fPosMaxProbPdg; }
+ Float_t GetNegMaxProbPid() const { return fNegMaxProbPid; }
+ Float_t GetPosMaxProbPid() const { return fPosMaxProbPid; }
+
Int_t GetESDIndex() const { return fESDIndex; }
void SetESDIndex(Int_t ind) { fESDIndex = ind;}
Float_t fDaughterDCA; // Distance at the point of closest approach.
Float_t fChi2V0; // Some Chi-square.
+ Int_t fNegMaxProbPdg; // Maximum PDG probability for the negative daughter
+ Int_t fPosMaxProbPdg; // Maximum PDG probability for the positive daughter
+ Float_t fNegMaxProbPid; // Maximum PID probability for the negative daughter
+ Float_t fPosMaxProbPid; // Maximum PID probability for the positive daughter
+
private:
AliEveV0(const AliEveV0&); // Not implemented
AliEveV0& operator=(const AliEveV0&); // Not implemented
void FilterByRadius(Float_t minR, Float_t maxR);
void FilterByDaughterDCA(Float_t minDaughterDCA, Float_t maxDaughterDCA);
void FilterByPt(Float_t minPt, Float_t maxPt);
+ void FilterByCheckedPidMinProb(Int_t rFlag, Int_t rDaughter, Int_t rPid, Float_t rProb);
+ void SetNegCheckedPid(Int_t rNegCheckedPid) {fNegCheckedPid = rNegCheckedPid;}
+ void SetPosCheckedPid(Int_t rPosCheckedPid) {fPosCheckedPid = rPosCheckedPid;}
+ Int_t GetNegCheckedPid() {return fNegCheckedPid;}
+ Int_t GetPosCheckedPid() {return fPosCheckedPid;}
+
+ void SetNegCheckedProb(Float_t rNegCheckedProb) {fNegCheckedProb = rNegCheckedProb;}
+ void SetPosCheckedProb(Float_t rPosCheckedProb) {fPosCheckedProb = rPosCheckedProb;}
+ Float_t GetNegCheckedProb() {return fNegCheckedProb;}
+ Float_t GetPosCheckedProb() {return fPosCheckedProb;}
+
+ void FilterByInvariantMass(Float_t minPt, Float_t maxPt, Int_t nPdgCode, Int_t pPdgCode);
protected:
TString fTitle;
Float_t fMinPt;
Float_t fMaxPt;
+ Int_t fNegCheckedPid;
+ Int_t fPosCheckedPid;
+
+ Float_t fNegCheckedProb;
+ Float_t fPosCheckedProb;
+
+ Float_t fMinInvariantMass;
+ Float_t fMaxInvariantMass;
+
private:
void Init();
fM(0),
fInfoLabel0(0),
fInfoLabel1(0),
+ fInfoLabelNegDaughter(0),
+ fInfoLabelPosDaughter(0),
fXButton(0)
// Initialize widget pointers to 0
{
AddFrame(fInfoLabel1, new TGLayoutHints(kLHintsLeft|kLHintsExpandX,
8, 0, 2, 0));
+ fInfoLabelNegDaughter = new TGLabel(this);
+ fInfoLabelNegDaughter->SetTextJustify(kTextLeft);
+ AddFrame(fInfoLabelNegDaughter, new TGLayoutHints(kLHintsLeft|kLHintsExpandX,
+ 8, 0, 2, 0));
+
+ fInfoLabelPosDaughter = new TGLabel(this);
+ fInfoLabelPosDaughter->SetTextJustify(kTextLeft);
+ AddFrame(fInfoLabelPosDaughter, new TGLayoutHints(kLHintsLeft|kLHintsExpandX,
+ 8, 0, 2, 0));
+
fXButton = new TGTextButton(this, "Detailed View");
AddFrame(fXButton, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
fXButton->Connect("Clicked()", "AliEveV0Editor", this, "DisplayDetailed()");
// Set values of widgets
fInfoLabel0->SetText(Form("Radius = %f, DCA = %f", fM->GetRadius(), fM->GetDaughterDCA()));
fInfoLabel1->SetText(Form("Pt = %f", fM->GetPt()));
+ fInfoLabelNegDaughter->SetText(Form("Neg. Daughter Prob= %.2f for Pdg= %d", fM->GetNegMaxProbPid(), fM->GetNegMaxProbPdg()));
+ fInfoLabelPosDaughter->SetText(Form("Pos. Daughter Prob= %.2f for Pdg= %d", fM->GetPosMaxProbPid(), fM->GetPosMaxProbPdg()));
+
}
/******************************************************************************/
TGLabel *fInfoLabel0; // label
TGLabel *fInfoLabel1; // label
+ TGLabel *fInfoLabelNegDaughter; // label
+ TGLabel *fInfoLabelPosDaughter; // label
TGButton *fXButton;
#include "TGNumberEntry.h"
#include "TGColorSelect.h"
#include "TGDoubleSlider.h"
-
+#include "TGComboBox.h"
+#include "TGLabel.h"
//______________________________________________________________________________
// GUI editor for AliEveV0List.
fM(0),
fMinMaxRCut(0),
fMinMaxDaughterDCA(0),
- fMinMaxPt(0)
+ fMinMaxPt(0),
+ fNegativeSpecies(0),
+ fPositiveSpecies(0),
+ fNegativeCheckMaxPidProbability(0),
+ fPositiveCheckMaxPidProbability(0),
+ fNegativeLevelPidProbability(0),
+ fPositiveLevelPidProbability(0),
+ fMinMaxInvariantMass(0)
{
// Constructor.
fMinMaxDaughterDCA->Connect("ValueSet()", "AliEveV0ListEditor", this, "DoMinMaxDaughterDCA()");
AddFrame(fMinMaxDaughterDCA, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
- fMinMaxPt = new TEveGDoubleValuator(this,"pT:", 130, 0);
+ fMinMaxPt = new TEveGDoubleValuator(this,"pT:", 80, 0);
fMinMaxPt->SetNELength(5);
fMinMaxPt->SetLabelWidth(74);
fMinMaxPt->Build();
fMinMaxPt->SetLimits(0, 20, TGNumberFormat::kNESRealOne);
fMinMaxPt->Connect("ValueSet()", "AliEveV0ListEditor", this, "DoMinMaxPt()");
AddFrame(fMinMaxPt, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
+
+ TGHorizontalFrame* fNegFrame = new TGHorizontalFrame(this);
+ TGLabel* labNeg = new TGLabel(fNegFrame, "Neg:");
+ fNegFrame->AddFrame(labNeg, new TGLayoutHints(kLHintsLeft|kLHintsBottom, 1, 1, 1, 1));
+ fNegativeSpecies = new TGComboBox(fNegFrame);
+ fNegativeSpecies->AddEntry("e", 11);
+ fNegativeSpecies->AddEntry("mu", 13);
+ fNegativeSpecies->AddEntry("pi", 211);
+ fNegativeSpecies->AddEntry("K", 321);
+ fNegativeSpecies->AddEntry("p", 2212);
+ TGListBox* lbNeg = fNegativeSpecies->GetListBox();
+ lbNeg->Resize(lbNeg->GetWidth(), 2*18);
+ fNegativeSpecies->Resize(45, 20);
+ fNegativeSpecies->Connect("Selected(Int_t)", "AliEveV0ListEditor", this, "DoSelectNegPid(Int_t)");
+ fNegFrame->AddFrame(fNegativeSpecies, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
+ AddFrame(fNegFrame);
+
+ fNegativeCheckMaxPidProbability = new TGCheckButton(fNegFrame, "Check");
+ fNegFrame->AddFrame(fNegativeCheckMaxPidProbability, new TGLayoutHints(kLHintsLeft, 0, 2, 1, 1));
+ fNegativeCheckMaxPidProbability->Connect("Toggled(Bool_t)", "AliEveV0ListEditor", this, "DoCheckNegPid()");
+
+ fNegativeLevelPidProbability = new TGNumberEntry(fNegFrame, 0.5, 3, -1, TGNumberFormat::kNESRealTwo, TGNumberFormat::kNEANonNegative,TGNumberFormat::kNELLimitMinMax, 0, 1);
+ fNegativeLevelPidProbability->Resize(50,20);
+ fNegativeLevelPidProbability->Connect("ValueSet(Long_t)", "AliEveV0ListEditor", this, "DoSelectNegProb()");
+ fNegFrame->AddFrame(fNegativeLevelPidProbability, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 1, 1));
+
+ TGHorizontalFrame* fPosFrame = new TGHorizontalFrame(this);
+ TGLabel* labPos = new TGLabel(fPosFrame, "Pos:");
+ fPosFrame->AddFrame(labPos, new TGLayoutHints(kLHintsLeft|kLHintsBottom, 1, 1, 1, 1));
+ fPositiveSpecies = new TGComboBox(fPosFrame);
+ fPositiveSpecies->AddEntry("e", 11);
+ fPositiveSpecies->AddEntry("mu", 13);
+ fPositiveSpecies->AddEntry("pi", 211);
+ fPositiveSpecies->AddEntry("K", 321);
+ fPositiveSpecies->AddEntry("p", 2212);
+ TGListBox* lbPos = fPositiveSpecies->GetListBox();
+ lbPos->Resize(lbPos->GetWidth(), 2*18);
+ fPositiveSpecies->Resize(45, 20);
+ fPositiveSpecies->Connect("Selected(Int_t)", "AliEveV0ListEditor", this, "DoSelectPosPid(Int_t)");
+ fPosFrame->AddFrame(fPositiveSpecies, new TGLayoutHints(kLHintsTop, 3, 1, 1, 1));
+ AddFrame(fPosFrame);
+
+ fPositiveCheckMaxPidProbability = new TGCheckButton(fPosFrame, "Check");
+ fPosFrame->AddFrame(fPositiveCheckMaxPidProbability, new TGLayoutHints(kLHintsLeft, 0, 2, 1, 1));
+ fPositiveCheckMaxPidProbability->Connect("Toggled(Bool_t)", "AliEveV0ListEditor", this, "DoCheckPosPid()");
+
+ fPositiveLevelPidProbability = new TGNumberEntry(fPosFrame, 0.5, 3, -1, TGNumberFormat::kNESRealTwo, TGNumberFormat::kNEANonNegative,TGNumberFormat::kNELLimitMinMax, 0, 1);
+ fPositiveLevelPidProbability->Resize(50,20);
+ fPositiveLevelPidProbability->Connect("ValueSet(Long_t)", "AliEveV0ListEditor", this, "DoSelectPosProb()");
+ fPosFrame->AddFrame(fPositiveLevelPidProbability, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 1, 1));
+
+ fMinMaxInvariantMass = new TEveGDoubleValuator(this,"Inv. Mass:", 80, 0);
+ fMinMaxInvariantMass->SetNELength(5);
+ fMinMaxInvariantMass->SetLabelWidth(74);
+ fMinMaxInvariantMass->Build();
+ fMinMaxInvariantMass->GetSlider()->SetWidth(200);
+ fMinMaxInvariantMass->SetLimits(0, 1.2, TGNumberFormat::kNESRealThree);
+ fMinMaxInvariantMass->Connect("ValueSet()", "AliEveV0ListEditor", this, "DoMinMaxInvariantMass()");
+ AddFrame(fMinMaxInvariantMass, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
}
/******************************************************************************/
fMinMaxRCut->SetValues(fM->fMinRCut, fM->fMaxRCut);
fMinMaxDaughterDCA->SetValues(fM->fMinDaughterDCA, fM->fMaxDaughterDCA);
fMinMaxPt->SetValues(fM->fMinPt, fM->fMaxPt);
+ fMinMaxInvariantMass->SetValues(fM->fMinInvariantMass, fM->fMaxInvariantMass);
}
/******************************************************************************/
{
fM->FilterByPt(fMinMaxPt->GetMin(), fMinMaxPt->GetMax());
}
+
+void AliEveV0ListEditor::DoSelectNegPid(Int_t rNegPid)
+{
+ fM->SetNegCheckedPid(rNegPid);
+ Update();
+}
+
+void AliEveV0ListEditor::DoCheckNegPid()
+{
+ Int_t lNegPid = fM->GetNegCheckedPid();
+ Float_t lNegProb = fM->GetNegCheckedProb();
+ if (lNegPid) {
+ fM->FilterByCheckedPidMinProb(fNegativeCheckMaxPidProbability->IsOn(),0,lNegPid,lNegProb);
+ printf("Selection for negative daughter pid %d prob %.2f \n",lNegPid,lNegProb);
+ Update();
+ }
+}
+
+void AliEveV0ListEditor::DoSelectNegProb()
+{
+ Float_t rMinNegProb = (Float_t)fNegativeLevelPidProbability->GetNumber();
+ fM->SetNegCheckedProb(rMinNegProb);
+ Update();
+}
+
+void AliEveV0ListEditor::DoSelectPosPid(Int_t rPosPid)
+{
+ fM->SetPosCheckedPid(rPosPid);
+ Update();
+}
+
+void AliEveV0ListEditor::DoCheckPosPid()
+{
+ Int_t lPosPid = fM->GetPosCheckedPid();
+ Float_t lPosProb = fM->GetPosCheckedProb();
+ if (lPosPid) {
+ fM->FilterByCheckedPidMinProb(fPositiveCheckMaxPidProbability->IsOn(),1,lPosPid,lPosProb);
+ printf("Selection for positive daughter pid %d prob %.2f \n",lPosPid,lPosProb);
+ Update();
+ }
+}
+
+void AliEveV0ListEditor::DoSelectPosProb()
+{
+ Float_t rMinPosProb = (Float_t)fPositiveLevelPidProbability->GetNumber();
+ fM->SetPosCheckedProb(rMinPosProb);
+ Update();
+}
+
+void AliEveV0ListEditor::DoMinMaxInvariantMass()
+{
+ Int_t lNegPid = fM->GetNegCheckedPid();
+ Int_t lPosPid = fM->GetPosCheckedPid();
+ if( lNegPid && lPosPid)
+ fM->FilterByInvariantMass(fMinMaxInvariantMass->GetMin(), fMinMaxInvariantMass->GetMax(),lNegPid,lPosPid);
+ else
+ fM->FilterByInvariantMass(fMinMaxInvariantMass->GetMin(), fMinMaxInvariantMass->GetMax(),211,-211);
+}
class TGNumberEntry;
class TGColorSelect;
class TEveGDoubleValuator;
+class TGComboBox;
class AliEveV0List;
void DoMinMaxRCut();
void DoMinMaxDaughterDCA();
void DoMinMaxPt();
+ void DoSelectNegPid(Int_t rNegPid);
+ void DoCheckNegPid();
+ void DoSelectNegProb();
+ void DoSelectPosPid(Int_t rPosPid);
+ void DoCheckPosPid();
+ void DoSelectPosProb();
+ void DoMinMaxInvariantMass();
protected:
AliEveV0List *fM; // Model object.
TEveGDoubleValuator* fMinMaxRCut;
TEveGDoubleValuator* fMinMaxDaughterDCA;
TEveGDoubleValuator* fMinMaxPt;
+ TGComboBox* fNegativeSpecies;
+ TGComboBox* fPositiveSpecies;
+ TGCheckButton* fNegativeCheckMaxPidProbability;
+ TGCheckButton* fPositiveCheckMaxPidProbability;
+ TGNumberEntry* fNegativeLevelPidProbability;
+ TGNumberEntry* fPositiveLevelPidProbability;
+ TEveGDoubleValuator* fMinMaxInvariantMass;
private:
AliEveV0ListEditor(const AliEveV0ListEditor&); // Not implemented
myV0->SetOnFlyStatus(v0->GetOnFlyStatus());
myV0->SetDaughterDCA(v0->GetDcaV0Daughters());
+ Double_t negProbability[10], posProbability[10];
+ Double_t negP = 0.0, posP = 0.0;
+ neg->GetESDpid(negProbability);
+ pos->GetESDpid(posProbability);
+ negP = neg->P();
+ posP = pos->P();
+
+ // ****** Tentative particle type "concentrations"
+ Double_t c[5]={0.01, 0.01, 0.85, 0.10, 0.05};
+ AliPID::SetPriors(c);
+
+ AliPID negPid(negProbability);
+ AliPID posPid(posProbability);
+
+ Int_t negMostProbPdg = 0;
+ Int_t posMostProbPdg = 0;
+
+ switch (negPid.GetMostProbable()){
+ case 0:
+ negMostProbPdg = 11; break;
+ case 1:
+ negMostProbPdg = 13; break;
+ case 2:
+ negMostProbPdg = 211; break;
+ case 3:
+ negMostProbPdg = 321; break;
+ case 4:
+ negMostProbPdg = 2212; break;
+ default :
+ negMostProbPdg = 211; break;
+ }
+
+ switch (posPid.GetMostProbable()){
+ case 0:
+ posMostProbPdg = 11; break;
+ case 1:
+ posMostProbPdg = 13; break;
+ case 2:
+ posMostProbPdg = 211; break;
+ case 3:
+ posMostProbPdg = 321; break;
+ case 4:
+ posMostProbPdg = 2212; break;
+ default :
+ posMostProbPdg = 211; break;
+ }
+
+ Float_t negMaxProbPid = negPid.GetProbability(negPid.GetMostProbable());
+ Float_t posMaxProbPid = posPid.GetProbability(posPid.GetMostProbable());
+
+ myV0->SetMaxProbPdgPid(0,negMostProbPdg,negMaxProbPid);
+ myV0->SetMaxProbPdgPid(1,posMostProbPdg,posMaxProbPid);
+
return myV0;
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff