382c2aeb2d0892f368350935e692e24ede68ed8f
[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnDaughter.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15  
16 //-------------------------------------------------------------------------
17 //                      Class AliRsnDaughter
18 //                     ----------------------
19 //           A simple object which describes a reconstructed track
20 //           with some references to its related generated particle
21 //           and some facilities which could help in composing its
22 //           4-momentum, for resonance study.
23 // 
24 // author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
25 //-------------------------------------------------------------------------
26
27 #include <Riostream.h>
28
29 #include <TParticle.h>
30
31 #include "AliESDtrack.h"
32 #include "AliRsnDaughter.h"
33
34 ClassImp(AliRsnDaughter)
35
36 //--------------------------------------------------------------------------------------------------------
37 AliRsnDaughter::AliRsnDaughter()
38 {
39 // 
40 // Default constructor.
41 // Its unique argument defines how many PID weights are allowed. 
42 // Actually, it should be the same as AliESDtrack::kSPECIES (=5).
43 // 
44         fSign = (Char_t)0;
45         fPDG = (UShort_t)0;
46         fIndex = (UShort_t)0;
47         
48         fP[0] = fP[1] = fP[2] = 0.0;
49         fV[0] = fV[1] = fV[2] = 0.0;
50         fMass = 0.0;
51         
52         Int_t i;
53         for (i = 0; i < AliPID::kSPECIES; i++) {
54                 fPIDwgt[i] = 0.0;
55         }
56                         
57         fLabel = -1;
58         fTruePDG = 0;
59         fMother = -1;
60         fMotherPDG = 0;
61 }
62 //--------------------------------------------------------------------------------------------------------
63 AliRsnDaughter::AliRsnDaughter(const AliRsnDaughter &copy) : TObject(copy)
64 {
65 //
66 // Copy constructor
67 //
68         fSign = copy.fSign;
69         fPDG = copy.fPDG;
70         fIndex = copy.fIndex;
71         
72         Int_t i;
73         for (i = 0; i < 3; i++) {
74                 fP[i] = copy.fP[i];
75                 fV[i] = copy.fV[i];
76         }
77         fMass = copy.fMass;
78         
79         for (i = 0; i < AliPID::kSPECIES; i++) {
80                 fPIDwgt[i] = copy.fPIDwgt[i];
81         }
82                 
83         fLabel = copy.fLabel;
84         fTruePDG = copy.fTruePDG;
85         fMother = copy.fMother;
86         fMotherPDG = copy.fMotherPDG;
87 }
88 //--------------------------------------------------------------------------------------------------------
89 Bool_t AliRsnDaughter::Adopt(const AliESDtrack* esdTrack, Bool_t checkITSRefit)
90 {
91 //
92 // Copies reconstructed data from an AliESDtrack:
93 //
94 // - charge sign
95 // - momentum
96 // - point of closest approach to primary vertex
97 // - ESD pid weights
98 // - track label (AliESDtrack::GetLabel())
99 // 
100 // Makes the following checks:
101 //
102 // - if argument 'checkITSRefit' is TRUE and the "ITS refit" flag is FALSE
103 //   in the track, the "fIsOK" flag of (this) is set to "false" (track should be rejected)
104 // - if the passed label is negative, track is considered as "fake", and 
105 //   this info is kept to allow fake tracks exclusion when doing analysis
106 //
107         // check for refit in the ITS (if requested)
108         if (checkITSRefit) {
109                 if ( !(esdTrack->GetStatus() & AliESDtrack::kITSrefit) ) {
110                         return kFALSE;
111                 }
112         }
113         
114         // get sign and number of species allowed for PID
115         fSign = (Char_t)esdTrack->GetSign();
116         
117         // get (and check) momentum
118         esdTrack->GetPxPyPz(fP);
119         if (fP[0] == 0.0 || fP[1] == 0.0 || fP[2] == 0.0) {
120                 return kFALSE;
121         }
122         
123         // get (and check) vertex
124         esdTrack->GetXYZ(fV);
125         if (fV[0] == 0.0 || fV[1] == 0.0 || fV[2] == 0.0) {
126                 return kFALSE;
127         }
128         
129         // get label 
130         // (other kinematics informations are set to default and meaningless values)
131         fLabel = esdTrack->GetLabel();
132         
133         // get PID weights
134         esdTrack->GetESDpid(fPIDwgt);
135         
136         return kTRUE;
137 }
138 //--------------------------------------------------------------------------------------------------------
139 Bool_t AliRsnDaughter::Adopt(TParticle* particle)
140 {
141 //
142 // Copies data from a generated particle:
143 // 
144 // - PDG code
145 // - charge sign
146 // - momentum
147 // - production vertex
148 // - GEANT label of mother track
149 //
150 // When an AliRsnDaughter is copied from a TParticle, it is 
151 // considered always good for analysis and never fake.
152 //
153         // get particle sign form the sign of PDG code
154         Int_t pdg = particle->GetPdgCode();
155         if (TMath::Abs(pdg) < 20) {
156                 if (pdg > 0) fSign = -1; else fSign = 1;
157         }
158         else if (TMath::Abs(pdg) < 3000) {
159                 if (pdg > 0) fSign = 1; else fSign = -1;
160         }
161         
162         // get momentum
163         fP[0] = particle->Px();
164         fP[1] = particle->Py();
165         fP[2] = particle->Pz();
166         
167         // get vertex
168         fV[0] = particle->Vx();
169         fV[1] = particle->Vy();
170         fV[2] = particle->Vz();
171         
172         // set simulation data
173         fPDG = fTruePDG = (Short_t)particle->GetPdgCode();
174         fMother = particle->GetFirstMother();
175         fMotherPDG = 0;
176         
177         return kTRUE;
178 }
179 //--------------------------------------------------------------------------------------------------------
180 AliRsnDaughter AliRsnDaughter::Sum(AliRsnDaughter t1, AliRsnDaughter t2)
181 {
182 //
183 // Builds a new AliRsnDaughter object with the sum of momenta of two particles.
184 //
185         // create new AliRsnDaughter with default useless values for datamembers
186         AliRsnDaughter out;
187         
188         // if the summed particles are daughters of the same resonance
189         // their common mother label becomes the label of the sum
190         Int_t mum1 = t1.GetMother();
191         Int_t mum2 = t2.GetMother();
192         if (mum1 == mum2) {
193                 out.SetLabel(mum1);
194                 out.SetMotherPDG(t1.GetMotherPDG());
195         }
196         else {
197                 out.SetLabel(-1);
198                 out.SetMotherPDG(0);
199         }
200
201         // compute total 4-momentum
202         Double_t etot  = t1.GetEnergy() + t2.GetEnergy();
203         Double_t pxTot = t1.GetPx() + t2.GetPx();
204         Double_t pyTot = t1.GetPy() + t2.GetPy();
205         Double_t pzTot = t1.GetPz() + t2.GetPz();
206         Double_t mass  = TMath::Sqrt(etot*etot - pxTot*pxTot - pyTot*pyTot - pzTot*pzTot);
207         
208         //TLorentzVector v1 = track1.Get4Momentum();
209         //TLorentzVector v2 = track2.Get4Momentum();
210         //TLorentzVector sm = v1 + v2;
211         //Double_t pxTot = sum.X();
212         //Double_t pyTot = sum.Y();
213         //Double_t pzTot = sum.Z();
214         //Double_t mass = sm.M();
215         
216         out.SetPxPyPz(pxTot, pyTot, pzTot);
217         out.SetMass(mass);
218         
219         return out;
220 }