cerr<<"Doing comparison...\n";
const Double_t cascadeWindow=0.05, cascadeWidth=0.015;
- Double_t cascadeMass=0.5;
+ Double_t ptncut=0.12, ptpcut=0.33, kine0cut=0.003;
+ Double_t ptbcut=0.11, kinecut=0.002;
+ Double_t cascadeMass=1.32131;
switch (code) {
case kXiMinus:
- case kXiPlusBar: cascadeMass=1.32131; break;
+ break;
+ case kXiPlusBar:
+ ptncut=0.33; ptpcut=0.12;
+ break;
case kOmegaMinus:
- case kOmegaPlusBar: cascadeMass=1.67245; break;
+ cascadeMass=1.67245;
+ kine0cut=0.001;
+ ptbcut=0.22; kinecut=0.006;
+ break;
+ case kOmegaPlusBar:
+ cascadeMass=1.67245;
+ kine0cut=0.001;
+ ptncut=0.33; ptpcut=0.12;
+ ptbcut=0.22; kinecut=0.006;
+ break;
default: cerr<<"Invalid PDG code !\n"; return 1;
}
Double_t mmin=cascadeMass-cascadeWindow, mmax=cascadeMass+cascadeWindow;
TH1F *cs =new TH1F("cs","Cascade Effective Mass",40, mmin, mmax);
- cs->SetXTitle("(GeV)"); cs->SetFillColor(6);
+ cs->SetXTitle("(GeV)");
+ cs->SetLineColor(4); cs->SetLineWidth(4);
+ TH1F *csf =new TH1F("csf","Fake Cascade Effective Mass",40, mmin, mmax);
+ csf->SetXTitle("(GeV)"); csf->SetFillColor(6);
Double_t pxg=0.,pyg=0.,ptg=0.;
Int_t nlab=-1, plab=-1, blab=-1;
Int_t i;
for (i=0; i<nentr; i++) {
AliCascadeVertex *cascade=(AliCascadeVertex*)carray.UncheckedAt(i);
- cascade->GetV0labels(nlab,plab);
- nlab=TMath::Abs(nlab); plab=TMath::Abs(plab);
- blab=TMath::Abs(cascade->GetBachelorLabel());
-
- cascade->ChangeMassHypothesis(code);
+ nlab=TMath::Abs(cascade->GetNlabel());
+ plab=TMath::Abs(cascade->GetPlabel());
+ blab=TMath::Abs(cascade->GetBlabel());
+
+ /** Kinematical cuts **/
+ Double_t pxn,pyn,pzn; cascade->GetNPxPyPz(pxn,pyn,pzn);
+ Double_t ptn=TMath::Sqrt(pxn*pxn + pyn*pyn);
+ if (ptn < ptncut) continue;
+ Double_t pxp,pyp,pzp; cascade->GetPPxPyPz(pxp,pyp,pzp);
+ Double_t ptp=TMath::Sqrt(pxp*pxp + pyp*pyp);
+ if (ptp < ptpcut) continue;
+ Double_t pxb,pyb,pzb; cascade->GetBPxPyPz(pxb,pyb,pzb);
+ Double_t ptb=TMath::Sqrt(pxb*pxb + pyb*pyb);
+ if (ptb < ptbcut) continue;
+ Double_t kine0;
+ Double_t kine=cascade->ChangeMassHypothesis(kine0,code);
+ if (TMath::Abs(kine0)>kine0cut) continue;
+ //if (TMath::Abs(kine)>kinecut) continue;
Double_t mass=cascade->GetEffMass();
cs->Fill(mass);
+ csf->Fill(mass);
if (TMath::Abs(mass-cascadeMass)>cascadeWidth) continue;
cerr<<"Fake cascade: ("<<nlab<<","<<plab<<","<<blab<<")\n";
continue;
}
+ csf->Fill(mass,-1);
pxg=gc[j].px; pyg=gc[j].py; ptg=TMath::Sqrt(pxg*pxg+pyg*pyg);
Double_t phig=TMath::ATan2(pyg,pxg), phi=TMath::ATan2(py,px);
c2->cd(2);
gPad->SetFillColor(42); gPad->SetFrameFillColor(10);
- cs->SetXTitle("(GeV/c)");
//cs->Fit("gaus","","",cascadeMass-cascadeWidth,cascadeMass+cascadeWidth);
cs->Draw();
+ csf->Draw("same");
Double_t max=cs->GetMaximum();
TLine *line3 =
new TLine(cascadeMass-cascadeWidth,0.,cascadeMass-cascadeWidth,max);
if (!file->IsOpen()) {
cerr<<"Can't open AliV0vertices.root !\n";return 3;
}
- Double_t cuts[]={33., // max. allowed chi2
- 0.015,// min. allowed V0 impact parameter
- 0.05, // window around the Lambda mass
- 0.015,// min. allowed track impact parameter
- 0.060,// max. allowed DCA between a V0 and a track
- 0.997,// max. allowed cosine of the cascade pointing angle
- 0.9, // min. radius of the fiducial volume
- 2.9 // max. radius of the fiducial volume
+ Double_t cuts[]={33., // max. allowed chi2
+ 0.05, // min. allowed V0 impact parameter
+ 0.008, // window around the Lambda mass
+ 0.035, // min. allowed bachelor's impact parameter
+ 0.10, // max. allowed DCA between a V0 and a track
+ 0.9985, // max. allowed cosine of the cascade pointing angle
+ 0.9, // min. radius of the fiducial volume
+ 2.9 // max. radius of the fiducial volume
};
TStopwatch timer;
AliCascadeVertexer *vertexer=new AliCascadeVertexer(cuts);
// position of the cascade decay
fPos[0]=0.5*(x1+xm); fPos[1]=0.5*(y1+ym); fPos[2]=0.5*(z1+zm);
-
-
- // momenta of the bachelor and the V0
-
- fBachMom[0]=px1; fBachMom[1]=py1; fBachMom[2]=pz1;
- fV0mom[0]=px2; fV0mom[1]=py2; fV0mom[2]=pz2;
-
+
+
// invariant mass of the cascade (default is Ximinus)
Double_t e1=TMath::Sqrt(0.13957*0.13957 + px1*px1 + py1*py1 + pz1*pz1);
fEffMass=TMath::Sqrt((e1+e2)*(e1+e2)-
(px1+px2)*(px1+px2)-(py1+py2)*(py1+py2)-(pz1+pz2)*(pz1+pz2));
+
+ // momenta of the bachelor and the V0
+
+ fBachMom[0]=px1; fBachMom[1]=py1; fBachMom[2]=pz1;
+ v.GetNPxPyPz(px2,py2,pz2);
+ fV0mom[0][0]=px2; fV0mom[0][1]=py2; fV0mom[0][2]=pz2;
+ v.GetPPxPyPz(px2,py2,pz2);
+ fV0mom[1][0]=px2; fV0mom[1][1]=py2; fV0mom[1][2]=pz2;
+
+
fChi2=7.;
}
-void AliCascadeVertex::ChangeMassHypothesis(Int_t code) {
+/*
+Double_t AliCascadeVertex::ChangeMassHypothesis(Double_t &v0q, Int_t code) {
//--------------------------------------------------------------------
// This function changes the mass hypothesis for this cascade
+ // and returns the "kinematical quality" of this hypothesis
+ // together with the "quality" of associated V0 (argument v0q)
//--------------------------------------------------------------------
-
- // HOW TO DISTINGUISH BETWEEN A XIMINUS AND A XIPLUS ??????????
- // SAME QUESTION FOR (ANTI-)OMEGA'S (here) ... AND FOR (ANTI-)LAMBDAS (in AliV0vertex) ??
- // -> NEED ADDITIONAL CONDITION ON BACHELOR AND V0 PDGCODE !!!! BUT in the ANALYSIS MACROS !!!
-
- Double_t massBach, massV0;
+ Double_t nmass=0.13957, pmass=0.93827, des0=0.9437-0.1723;
+ Double_t bmass=0.13957, mass =1.3213, des =1.1243-0.1970;
- switch (code) {
+ fPdgCode=code;
+ switch (code) {
+ case 213:
+ bmass=0.93827;
+ break;
case kXiMinus:
- massBach=0.13957; massV0=1.11568; break;
+ break;
case kXiPlusBar:
- massBach=0.13957; massV0=1.11568; break;
+ nmass=0.93827; pmass=0.13957; des0=-des0;
+ des=-des;
+ break;
case kOmegaMinus:
- massBach=0.49368; massV0=1.11568; break;
+ bmass=0.49368; mass=1.67245; des=1.1355-0.5369;
+ break;
case kOmegaPlusBar:
- massBach=0.49368; massV0=1.11568; break;
-
+ nmass=0.93827; pmass=0.13957; des0=-des0;
+ bmass=0.49368; mass=1.67245; des=0.5369-1.1355;
+ break;
default:
- cerr<<"AliCascadeVertex::ChangeMassHypothesis: ";
- cerr<<"invalide PDG code ! Assuming XiMinus's...\n";
- massBach=0.13957; massV0=1.11568; break;
+ cerr<<"AliCascadeVertex::ChangeMassHypothesis: ";
+ cerr<<"Invalide PDG code ! Assuming XiMinus's...\n";
+ fPdgCode=kXiMinus;
+ break;
}
- Double_t px1=fBachMom[0], py1=fBachMom[1], pz1=fBachMom[2];
- Double_t px2=fV0mom[0], py2=fV0mom[1], pz2=fV0mom[2];
+ Double_t pxn=fV0mom[0][0], pyn=fV0mom[0][1], pzn=fV0mom[0][2];
+ Double_t pxp=fV0mom[1][0], pyp=fV0mom[1][1], pzp=fV0mom[1][2];
+ Double_t en=TMath::Sqrt(nmass*nmass + pxn*pxn + pyn*pyn + pzn*pzn);
+ Double_t ep=TMath::Sqrt(pmass*pmass + pxp*pxp + pyp*pyp + pzp*pzp);
+ Double_t px0=pxn+pxp, py0=pyn+pyp, pz0=pzn+pzp;
+ Double_t p0=TMath::Sqrt(px0*px0 + py0*py0 + pz0*pz0);
- Double_t e1=TMath::Sqrt(massBach*massBach + px1*px1 + py1*py1 + pz1*pz1);
- Double_t e2=TMath::Sqrt(massV0*massV0 + px2*px2 + py2*py2 + pz2*pz2);
- fEffMass=TMath::Sqrt((e1+e2)*(e1+e2)-
- (px1+px2)*(px1+px2)-(py1+py2)*(py1+py2)-(pz1+pz2)*(pz1+pz2));
+ Double_t gamma0=(en+ep)/1.11568, betagamma0=p0/1.11568;
+ Double_t pln=(pxn*px0 + pyn*py0 + pzn*pz0)/p0;
+ Double_t plp=(pxp*px0 + pyp*py0 + pzp*pz0)/p0;
+ Double_t plps=gamma0*plp - betagamma0*ep;
+
+ Double_t diff0=2*gamma0*plps + betagamma0*des0;
+
+
+ v0q=plp-pln-diff0;
+
+
+ Double_t pxb=fBachMom[0], pyb=fBachMom[1], pzb=fBachMom[2];
+
+ Double_t e0=TMath::Sqrt(1.11568*1.11568 + p0*p0);
+ Double_t eb=TMath::Sqrt(bmass*bmass + pxb*pxb + pyb*pyb + pzb*pzb);
+ Double_t pxl=px0+pxb, pyl=py0+pyb, pzl=pz0+pzb;
+ Double_t pl=TMath::Sqrt(pxl*pxl + pyl*pyl + pzl*pzl);
+ fEffMass=TMath::Sqrt((e0+eb)*(e0+eb) - pl*pl);
+
+ Double_t gamma=(e0+eb)/mass, betagamma=pl/mass;
+ Double_t pl0=(px0*pxl + py0*pyl + pz0*pzl)/pl;
+ Double_t plb=(pxb*pxl + pyb*pyl + pzb*pzl)/pl;
+ Double_t pl0s=gamma*pl0 - betagamma*e0;
+
+ Double_t diff=2*gamma*pl0s + betagamma*des;
+
+ return (pl0-plb-diff);
+}
+*/
+
+Double_t AliCascadeVertex::ChangeMassHypothesis(Double_t &v0q, Int_t code) {
+ //--------------------------------------------------------------------
+ // This function changes the mass hypothesis for this cascade
+ // and returns the "kinematical quality" of this hypothesis
+ // together with the "quality" of associated V0 (argument v0q)
+ //--------------------------------------------------------------------
+ Double_t nmass=0.13957, pmass=0.93827, ps0=0.101;
+ Double_t bmass=0.13957, mass =1.3213, ps =0.139;
+
fPdgCode=code;
+
+ switch (code) {
+ case 213:
+ bmass=0.93827;
+ break;
+ case kXiMinus:
+ break;
+ case kXiPlusBar:
+ nmass=0.93827; pmass=0.13957;
+ break;
+ case kOmegaMinus:
+ bmass=0.49368; mass=1.67245; ps=0.211;
+ break;
+ case kOmegaPlusBar:
+ nmass=0.93827; pmass=0.13957;
+ bmass=0.49368; mass=1.67245; ps=0.211;
+ break;
+ default:
+ cerr<<"AliCascadeVertex::ChangeMassHypothesis: ";
+ cerr<<"Invalide PDG code ! Assuming XiMinus's...\n";
+ fPdgCode=kXiMinus;
+ break;
+ }
+
+ Double_t pxn=fV0mom[0][0], pyn=fV0mom[0][1], pzn=fV0mom[0][2];
+ Double_t pxp=fV0mom[1][0], pyp=fV0mom[1][1], pzp=fV0mom[1][2];
+ Double_t px0=pxn+pxp, py0=pyn+pyp, pz0=pzn+pzp;
+ Double_t p0=TMath::Sqrt(px0*px0 + py0*py0 + pz0*pz0);
+
+ Double_t e0=TMath::Sqrt(1.11568*1.11568 + p0*p0);
+ Double_t beta0=p0/e0;
+ Double_t pln=(pxn*px0 + pyn*py0 + pzn*pz0)/p0;
+ Double_t plp=(pxp*px0 + pyp*py0 + pzp*pz0)/p0;
+ Double_t pt2=pxp*pxp + pyp*pyp + pzp*pzp - plp*plp;
+
+ Double_t a=(plp-pln)/(plp+pln);
+ a -= (pmass*pmass-nmass*nmass)/(1.11568*1.11568);
+ a = 0.25*beta0*beta0*1.11568*1.11568*a*a + pt2;
+
+
+ v0q=a - ps0*ps0;
+
+
+ Double_t pxb=fBachMom[0], pyb=fBachMom[1], pzb=fBachMom[2];
+
+ Double_t eb=TMath::Sqrt(bmass*bmass + pxb*pxb + pyb*pyb + pzb*pzb);
+ Double_t pxl=px0+pxb, pyl=py0+pyb, pzl=pz0+pzb;
+ Double_t pl=TMath::Sqrt(pxl*pxl + pyl*pyl + pzl*pzl);
+
+ fEffMass=TMath::Sqrt((e0+eb)*(e0+eb) - pl*pl);
+
+ Double_t beta=pl/(e0+eb);
+ Double_t pl0=(px0*pxl + py0*pyl + pz0*pzl)/pl;
+ Double_t plb=(pxb*pxl + pyb*pyl + pzb*pzl)/pl;
+ pt2=p0*p0 - pl0*pl0;
+
+ a=(pl0-plb)/(pl0+plb);
+ a -= (1.11568*1.11568-bmass*bmass)/(mass*mass);
+ a = 0.25*beta*beta*mass*mass*a*a + pt2;
+
+ return (a - ps*ps);
}
void
//--------------------------------------------------------------------
// This function returns the cascade momentum (global)
//--------------------------------------------------------------------
- px=fV0mom[0]+fBachMom[0];
- py=fV0mom[1]+fBachMom[1];
- pz=fV0mom[2]+fBachMom[2];
+ px=fV0mom[0][0]+fV0mom[1][0]+fBachMom[0];
+ py=fV0mom[0][1]+fV0mom[1][1]+fBachMom[1];
+ pz=fV0mom[0][2]+fV0mom[1][2]+fBachMom[2];
}
void AliCascadeVertex::GetXYZ(Double_t &x, Double_t &y, Double_t &z) const {
//--------------------------------------------------------------------
Double_t x=fPos[0],y=fPos[1],z=fPos[2];
- Double_t px=fV0mom[0]+fBachMom[0];
- Double_t py=fV0mom[1]+fBachMom[1];
- Double_t pz=fV0mom[2]+fBachMom[2];
+ Double_t px=fV0mom[0][0]+fV0mom[1][0]+fBachMom[0];
+ Double_t py=fV0mom[0][1]+fV0mom[1][1]+fBachMom[1];
+ Double_t pz=fV0mom[0][2]+fV0mom[1][2]+fBachMom[2];
Double_t dx=(y0-y)*pz - (z0-z)*py;
Double_t dy=(x0-x)*pz - (z0-z)*px;
return d;
}
+
AliCascadeVertex();
AliCascadeVertex(const AliV0vertex &vtx, const AliITStrackV2 &trk);
- void ChangeMassHypothesis(Int_t code=kXiMinus);
+ Double_t ChangeMassHypothesis(Double_t &v0q, Int_t code=kXiMinus);
Int_t GetPdgCode() const {return fPdgCode;}
Double_t GetEffMass() const {return fEffMass;}
void GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
void GetXYZ(Double_t &x, Double_t &y, Double_t &z) const;
Double_t GetD(Double_t x0=0.,Double_t y0=0.,Double_t z0=0.) const;
- void GetV0labels(Int_t &n, Int_t &p) const {n=fV0lab[0]; p=fV0lab[1];}
- Int_t GetBachelorLabel() const {return fBachLab;}
+
+ void GetNPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const {
+ px=fV0mom[0][0]; py=fV0mom[0][1]; pz=fV0mom[0][2];
+ }
+ Int_t GetNlabel() const {return fV0lab[0];}
+ void GetPPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const {
+ px=fV0mom[1][0]; py=fV0mom[1][1]; pz=fV0mom[1][2];
+ }
+ Int_t GetPlabel() const {return fV0lab[1];}
+ void GetBPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const {
+ px=fBachMom[0]; py=fBachMom[1]; pz=fBachMom[2];
+ }
+ Int_t GetBlabel() const {return fBachLab;}
private:
Int_t fPdgCode; // reconstructed cascade type (PDG code)
Double_t fPosCov[6]; // covariance matrix of the vertex position
Int_t fV0lab[2]; // labels of the V0 daughter tracks
- Double_t fV0mom[3]; // V0 momentum (global)
+ Double_t fV0mom[2][3]; // V0 daughters' momenta (global)
Double_t fV0momCov[6]; // covariance matrix of the V0 momentum.
Int_t fBachLab; // label of the bachelor track
};
const Double_t kChi2PerCluster=5.;//7.;
- const Double_t kMaxChi2=17.;//15.;
+ const Double_t kMaxChi2=15.;//17.;
const Double_t kMaxRoad=3.0;
const Double_t kSigmaYV=0.005e+0;
gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliITSComparisonV2.C");
if (rc=AliITSComparisonV2()) return rc;
+ gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliV0FindVertices.C");
+ if (rc=AliV0FindVertices()) return rc;
+
+ gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliV0Comparison.C");
+ if (rc=AliV0Comparison()) return rc;
+
+ gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliCascadeFindVertices.C");
+ if (rc=AliCascadeFindVertices()) return rc;
+
+ gROOT->ProcessLine(".L $(ALICE_ROOT)/ITS/AliCascadeComparison.C+");
+ if (rc=AliCascadeComparison()) return rc;
+
return rc;
}
Int_t AliV0Comparison(Int_t code=310) { //Lambda=3122, LambdaBar=-3122
cerr<<"Doing comparison...\n";
- const Double_t V0window=0.05, V0width=0.015;
- Double_t V0mass=0.5;
+ const Double_t V0window=0.05;
+ Double_t ptncut=0.13, ptpcut=0.13, kinecut=0.03;
+ Double_t V0mass=0.497672, V0width=0.020;
switch (code) {
- case kK0Short: V0mass=0.497672; break;
- case kLambda0: V0mass=1.115683; break;
- case kLambda0Bar: V0mass=1.115683; break;
+ case kK0Short:
+ break;
+ case kLambda0:
+ V0mass=1.115683; V0width=0.015; ptpcut=0.50; kinecut=0.002;
+ break;
+ case kLambda0Bar:
+ V0mass=1.115683; V0width=0.015; ptncut=0.50; kinecut=0.002;
+ break;
default: cerr<<"Invalid PDG code !\n"; return 1;
}
Double_t mmin=V0mass-V0window, mmax=V0mass+V0window;
TH1F *v0s =new TH1F("v0s","V0s Effective Mass",40, mmin, mmax);
- v0s->SetXTitle("(GeV)"); v0s->SetFillColor(6);
+ v0s->SetXTitle("(GeV)");
+ v0s->SetLineColor(4); v0s->SetLineWidth(4);
+ TH1F *v0sf =new TH1F("v0sf","Fake V0s Effective Mass",40, mmin, mmax);
+ v0sf->SetXTitle("(GeV)"); v0sf->SetFillColor(6);
Double_t pxg=0.,pyg=0.,ptg=0.;
nlab=TMath::Abs(vertex->GetNlabel());
plab=TMath::Abs(vertex->GetPlabel());
- vertex->ChangeMassHypothesis(code);
+ /** Kinematical cuts **/
+ Double_t pxn,pyn,pzn; vertex->GetNPxPyPz(pxn,pyn,pzn);
+ Double_t ptn=TMath::Sqrt(pxn*pxn + pyn*pyn);
+ if (ptn < ptncut) continue;
+ Double_t pxp,pyp,pzp; vertex->GetPPxPyPz(pxp,pyp,pzp);
+ Double_t ptp=TMath::Sqrt(pxp*pxp + pyp*pyp);
+ if (ptp < ptpcut) continue;
+ Double_t kine=vertex->ChangeMassHypothesis(code);
+ //if (TMath::Abs(kine)>kinecut) continue;
Double_t mass=vertex->GetEffMass();
v0s->Fill(mass);
+ v0sf->Fill(mass);
Int_t j;
for (j=0; j<ngood; j++) {
cerr<<"Fake vertex: ("<<nlab<<","<<plab<<")\n";
continue;
}
+ v0sf->Fill(mass,-1);
pxg=gv[j].px; pyg=gv[j].py; ptg=TMath::Sqrt(pxg*pxg+pyg*pyg);
Double_t phig=TMath::ATan2(pyg,pxg), phi=TMath::ATan2(py,px);
c2->cd(2);
gPad->SetFillColor(42); gPad->SetFrameFillColor(10);
- v0s->SetXTitle("(GeV/c)");
- v0s->Fit("gaus","","",V0mass-V0width,V0mass+V0width);
+ //v0s->Fit("gaus","","",V0mass-V0width,V0mass+V0width);
+ v0s->Draw();
+ v0sf->Draw("same");
Double_t max=v0s->GetMaximum();
TLine *line3 = new TLine(V0mass-V0width,0.,V0mass-V0width,max);
line3->Draw("same");
if (!in->IsOpen()) {cerr<<"Can't open AliITStracksV2.root !\n"; return 2;}
Double_t cuts[]={33, // max. allowed chi2
- 0.12,// min. allowed negative daughter's impact parameter
- 0.06,// min. allowed positive daughter's impact parameter
+ 0.16,// min. allowed negative daughter's impact parameter
+ 0.05,// min. allowed positive daughter's impact parameter
0.080,// max. allowed DCA between the daughter tracks
0.998,// max. allowed cosine of V0's pointing angle
0.9, // min. radius of the fiducial volume
fChi2=7.;
}
-
-void AliV0vertex::ChangeMassHypothesis(Int_t code) {
+/*
+Double_t AliV0vertex::ChangeMassHypothesis(Int_t code) {
//--------------------------------------------------------------------
// This function changes the mass hypothesis for this V0
+ // and returns the "kinematical quality" of this hypothesis
//--------------------------------------------------------------------
- Double_t nmass, pmass;
+ Double_t nmass=0.13957, pmass=0.13957, mass=0.49767, des=0;
+
+ fPdgCode=code;
switch (code) {
case kLambda0:
- nmass=0.13957; pmass=0.93827; break;
+ nmass=0.13957; pmass=0.93827; mass=1.1157; des=0.9437-0.1723; break;
case kLambda0Bar:
- pmass=0.13957; nmass=0.93827; break;
+ pmass=0.13957; nmass=0.93827; mass=1.1157; des=0.1723-0.9437; break;
case kK0Short:
- nmass=0.13957; pmass=0.13957; break;
+ break;
default:
cerr<<"AliV0vertex::ChangeMassHypothesis: ";
cerr<<"invalide PDG code ! Assuming K0s...\n";
- nmass=0.13957; pmass=0.13957; break;
+ fPdgCode=kK0Short;
+ break;
}
- Double_t px1=fNmom[0], py1=fNmom[1], pz1=fNmom[2];
- Double_t px2=fPmom[0], py2=fPmom[1], pz2=fPmom[2];
+ Double_t pxn=fNmom[0], pyn=fNmom[1], pzn=fNmom[2];
+ Double_t pxp=fPmom[0], pyp=fPmom[1], pzp=fPmom[2];
- Double_t e1=TMath::Sqrt(nmass*nmass + px1*px1 + py1*py1 + pz1*pz1);
- Double_t e2=TMath::Sqrt(pmass*pmass + px2*px2 + py2*py2 + pz2*pz2);
- fEffMass=TMath::Sqrt((e1+e2)*(e1+e2)-
- (px1+px2)*(px1+px2)-(py1+py2)*(py1+py2)-(pz1+pz2)*(pz1+pz2));
+ Double_t en=TMath::Sqrt(nmass*nmass + pxn*pxn + pyn*pyn + pzn*pzn);
+ Double_t ep=TMath::Sqrt(pmass*pmass + pxp*pxp + pyp*pyp + pzp*pzp);
+ Double_t pxl=pxn+pxp, pyl=pyn+pyp, pzl=pzn+pzp;
+ Double_t pl=TMath::Sqrt(pxl*pxl + pyl*pyl + pzl*pzl);
+
+ fEffMass=TMath::Sqrt((en+ep)*(en+ep)-pl*pl);
+
+ Double_t gamma=(en+ep)/mass, betagamma=pl/mass;
+ Double_t pln=(pxn*pxl + pyn*pyl + pzn*pzl)/pl;
+ Double_t plp=(pxp*pxl + pyp*pyl + pzp*pzl)/pl;
+ Double_t plps=gamma*plp - betagamma*ep;
+
+ Double_t diff=2*gamma*plps + betagamma*des;
+
+ return (plp-pln-diff);
+}
+*/
+Double_t AliV0vertex::ChangeMassHypothesis(Int_t code) {
+ //--------------------------------------------------------------------
+ // This function changes the mass hypothesis for this V0
+ // and returns the "kinematical quality" of this hypothesis
+ //--------------------------------------------------------------------
+ Double_t nmass=0.13957, pmass=0.13957, mass=0.49767, ps=0.206;
+
fPdgCode=code;
+
+ switch (code) {
+ case kLambda0:
+ nmass=0.13957; pmass=0.93827; mass=1.1157; ps=0.101; break;
+ case kLambda0Bar:
+ pmass=0.13957; nmass=0.93827; mass=1.1157; ps=0.101; break;
+ case kK0Short:
+ break;
+ default:
+ cerr<<"AliV0vertex::ChangeMassHypothesis: ";
+ cerr<<"invalide PDG code ! Assuming K0s...\n";
+ fPdgCode=kK0Short;
+ break;
+ }
+
+ Double_t pxn=fNmom[0], pyn=fNmom[1], pzn=fNmom[2];
+ Double_t pxp=fPmom[0], pyp=fPmom[1], pzp=fPmom[2];
+
+ Double_t en=TMath::Sqrt(nmass*nmass + pxn*pxn + pyn*pyn + pzn*pzn);
+ Double_t ep=TMath::Sqrt(pmass*pmass + pxp*pxp + pyp*pyp + pzp*pzp);
+ Double_t pxl=pxn+pxp, pyl=pyn+pyp, pzl=pzn+pzp;
+ Double_t pl=TMath::Sqrt(pxl*pxl + pyl*pyl + pzl*pzl);
+
+ fEffMass=TMath::Sqrt((en+ep)*(en+ep)-pl*pl);
+
+ Double_t beta=pl/(en+ep);
+ Double_t pln=(pxn*pxl + pyn*pyl + pzn*pzl)/pl;
+ Double_t plp=(pxp*pxl + pyp*pyl + pzp*pzl)/pl;
+
+ Double_t pt2=pxp*pxp + pyp*pyp + pzp*pzp - plp*plp;
+
+ Double_t a=(plp-pln)/(plp+pln);
+ a -= (pmass*pmass-nmass*nmass)/(mass*mass);
+ a = 0.25*beta*beta*mass*mass*a*a + pt2;
+
+ return (a - ps*ps);
+
}
void AliV0vertex::GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const {
AliV0vertex();
AliV0vertex(const AliITStrackV2 &neg, const AliITStrackV2 &pos);
- void ChangeMassHypothesis(Int_t code=kLambda0);
+ Double_t ChangeMassHypothesis(Int_t code=kK0Short);
Int_t GetPdgCode() const {return fPdgCode;}
Double_t GetEffMass() const {return fEffMass;}
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff