Added event cut set for MC
[u/mrichter/AliRoot.git] / PWGLF / RESONANCES / AliRsnMother.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 //
18 //  This class implements a candidate resonance. It has two pointers to its
19 //  two candidate daughters, whose 4-momenta are combined to obtain the mother
20 //  invariant mass and other kinematical quantities.
21 //  This class contains also some methods used to compute kinematical relations
22 //  between the candidate resonance and other particles.
23 //
24 //  authors: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
25 //           M. Vala (martin.vala@cern.ch)
26 //
27 ////////////////////////////////////////////////////////////////////////////////
28
29 #include <Riostream.h>
30 #include <TVector3.h>
31
32 #include "AliAODMCParticle.h"
33 #include "AliMCParticle.h"
34 #include "AliRsnEvent.h"
35
36 #include "AliRsnMother.h"
37
38 ClassImp(AliRsnMother)
39
40 //__________________________________________________________________________________________________
41 AliRsnMother::AliRsnMother(const AliRsnMother &obj) :
42    TObject(obj),
43    fRefEvent(obj.fRefEvent),
44    fSum(obj.fSum),
45    fSumMC(obj.fSumMC),
46    fRef(obj.fRef),
47    fRefMC(obj.fRefMC)
48 {
49 //
50 // Copy constructor.
51 // Does not duplicate pointers.
52 //
53
54    Int_t i;
55    for (i = 0; i < 2; i++) fDaughter[i] = obj.fDaughter[i];
56 }
57
58 //__________________________________________________________________________________________________
59 AliRsnMother &AliRsnMother::operator=(const AliRsnMother &obj)
60 {
61 //
62 // Assignment operator.
63 // Does not duplicate pointers.
64 //
65    if (this == &obj)
66       return *this;
67
68    fSum = obj.fSum;
69    fRef = obj.fRef;
70    fSumMC = obj.fSumMC;
71    fRefMC = obj.fRefMC;
72    fRefEvent = obj.fRefEvent;
73    fDaughter[0] = obj.fDaughter[0];
74    fDaughter[1] = obj.fDaughter[1];
75
76    return (*this);
77 }
78
79 //__________________________________________________________________________________________________
80 AliRsnMother::~AliRsnMother()
81 {
82 //
83 // Desctructor.
84 // Does nothing, since pointers are not created in this class.
85 //
86 }
87
88 //_______________________________________________________________________________________________________________________
89 void AliRsnMother::Reset()
90 {
91 //
92 // Resets the mother, zeroing all data members.
93 //
94
95    Int_t i;
96    for (i = 0; i < 2; i++) fDaughter[i] = 0x0;
97    fRefEvent = 0x0;
98    fSum.SetXYZM(0.0, 0.0, 0.0, 0.0);
99    fRef.SetXYZM(0.0, 0.0, 0.0, 0.0);
100 }
101
102 //__________________________________________________________________________________________________
103 Int_t AliRsnMother::CommonMother() const
104 {
105 //
106 // If MC info is available, checks if the two tracks in the pair have the same mother.
107 // If the mother label is the same, the function returns the PDG code of mother,
108 // otherwise it returns 0.
109 // The two arguments passed by reference contain the GEANT labels of the mother
110 // of the two particles to which the two daughters point. This is for being able
111 // to check if they are really coming from a resonance (indexes >= 0) or not.
112 //
113
114    Int_t m1  = fDaughter[0]->GetMother();
115    Int_t m2  = fDaughter[1]->GetMother();
116    Int_t out = 0;
117
118    // a true mother makes sense only if both mothers
119    // are not-negative and equal
120    if (m1 >= 0 && m2 >= 0 && m1 == m2) {
121       out = TMath::Abs(fDaughter[0]->GetMotherPDG());
122       AliDebugClass(1, Form("Mothers are: %d %d --> EQUAL (PDG = %d)", m1, m2, out));
123    }
124
125    return out;
126 }
127
128 //__________________________________________________________________________________________________
129 Double_t AliRsnMother::AngleToLeading(Bool_t &success)
130 {
131 //
132 // Compute the angle betwee this and the leading particls
133 // of the reference event (if this was set properly).
134 // In case one of the two daughters is the leading, return
135 // a meaningless value, in order to skip this pair.
136 // if second argument is kTRUE, use MC values.
137 //
138
139    if (!fRefEvent) {
140       success = kFALSE;
141       return -99.0;
142    }
143
144    Int_t id1 = fDaughter[0]->GetID();
145    Int_t id2 = fDaughter[1]->GetID();
146    Int_t idL = fRefEvent->GetLeadingIndex();
147
148    if (id1 == idL || id2 == idL) {
149       success = kFALSE;
150       return -99.0;
151    }
152
153    AliRsnDaughter leading = fRefEvent->GetDaughter(idL, kFALSE);
154    AliVParticle  *ref     = leading.GetRef();
155    Double_t       angle   = ref->Phi() - fSum.Phi();
156
157    //return angle w.r.t. leading particle in the range -pi/2, 3/2pi
158    while (angle >= 1.5 * TMath::Pi()) angle -= 2 * TMath::Pi();
159    while (angle < -0.5 * TMath::Pi()) angle += 2 * TMath::Pi();
160    success = kTRUE;
161
162    return angle;
163 }
164
165 //__________________________________________________________________________________________________
166 void AliRsnMother::ComputeSum(Double_t mass0, Double_t mass1, Double_t motherMass)
167 {
168 //
169 // Sets the masses for the 4-momenta of the daughters and then
170 // sums them, taking into account that the space part is set to
171 // each of them when the reference object is set (see AliRsnDaughter::SetRef)
172 //
173
174    fDaughter[0]->FillP(mass0);
175    fDaughter[1]->FillP(mass1);
176
177    // sum
178    fSum   = fDaughter[0]->Prec() + fDaughter[1]->Prec();
179    fSumMC = fDaughter[0]->Psim() + fDaughter[1]->Psim();
180
181    // reference
182    fRef.SetXYZM(fSum.X(), fSum.Y(), fSum.Z(), motherMass);
183    fRefMC.SetXYZM(fSumMC.X(), fSumMC.Y(), fSumMC.Z(), motherMass);
184 }
185
186 //__________________________________________________________________________________________________
187 Double_t AliRsnMother::CosThetaStar(Bool_t first, Bool_t useMC)
188 {
189 //
190 // Computes the cosine of theta*, which is the angle of one of the daughters
191 // with respect to the total momentum of the resonance, in its rest frame.
192 // The arguments are needed to choose which of the daughters one want to use
193 // and if reconstructed or MC momentum must be used.
194 // [Contribution from Z. Feckova]
195 //
196
197    TLorentzVector &mother    = Sum(useMC);
198    TLorentzVector &daughter0 = (first ? fDaughter[0]->P(useMC) : fDaughter[1]->P(useMC));
199 //    TLorentzVector &daughter1 = (first ? fDaughter[1]->P(useMC) : fDaughter[0]->P(useMC));
200    TVector3 momentumM(mother.Vect());
201    TVector3 normal(mother.Y() / momentumM.Mag(), -mother.X() / momentumM.Mag(), 0.0);
202
203 //    // Computes first the invariant mass of the mother
204 //    Double_t mass0      = fDaughter[0]->P(useMC).M();
205 //    Double_t mass1      = fDaughter[1]->P(useMC).M();
206 //    Double_t p0         = daughter0.Vect().Mag();
207 //    Double_t p1         = daughter1.Vect().Mag();
208 //    Double_t E0         = TMath::Sqrt(mass0 * mass0 + p0 * p0);
209 //    Double_t E1         = TMath::Sqrt(mass1 * mass1 + p1 * p1);
210 //    Double_t MotherMass = TMath::Sqrt((E0 + E1) * (E0 + E1) - (p0 * p0 + 2.0 * daughter0.Vect().Dot(daughter1.Vect()) + p1 * p1));
211 //    MotherMass = fSum.M();
212
213    // Computes components of beta
214    Double_t betaX = -mother.X() / mother.E();
215    Double_t betaY = -mother.Y() / mother.E();
216    Double_t betaZ = -mother.Z() / mother.E();
217
218    // Computes Lorentz transformation of the momentum of the first daughter
219    // into the rest frame of the mother and theta*
220    daughter0.Boost(betaX, betaY, betaZ);
221    TVector3 momentumD = daughter0.Vect();
222
223    Double_t cosThetaStar = normal.Dot(momentumD) / momentumD.Mag();
224
225    return cosThetaStar;
226 }
227
228 //__________________________________________________________________________________________________
229 void AliRsnMother::PrintInfo(const Option_t * /*option*/) const
230 {
231 //
232 // Print some info of the pair.
233 // The options are passed to the AliRsnDaughter::Print() method
234 //
235
236    AliInfo("======== BEGIN PAIR INFO ===========");
237    AliInfo("Track #1");
238    fDaughter[0]->Print();
239    AliInfo("Track #2");
240    fDaughter[1]->Print();
241    AliInfo("========= END PAIR INFO ===========");
242 }
243
244 //__________________________________________________________________________________________________
245 Bool_t AliRsnMother::CheckPair(Bool_t checkMC) const
246 {
247 //
248 // Checks that the pair is well initialized:
249 // - both daughters are good pointers
250 // - if MC is required, both daughters have a MC reference
251 //
252
253    if (!fDaughter[0] || !fDaughter[1]) {
254       AliError("One of the two tracks is NULL in this pair!");
255       return kFALSE;
256    }
257
258    if (checkMC) {
259       if (fDaughter[0]->GetRefMC() == 0x0 || fDaughter[1]->GetRefMC() == 0x0) {
260          AliError("Required MC info but not all MC refs are available");
261          return kFALSE;
262       }
263    }
264
265    return kTRUE;
266 }