]>
Commit | Line | Data |
---|---|---|
d88f97cc | 1 | #include "AliInvmass.h" |
2 | ||
3 | ClassImp(AliInvmass) // Class implementation to enable ROOT I/O | |
4 | ||
5 | AliInvmass::AliInvmass() | |
6 | { | |
7 | // Creation of an AliInvmass object and initialisation of parameters | |
8 | fPi=acos(-1.); | |
9 | fMode=2; | |
10 | fBkg=0; | |
11 | fNewtheta=1; | |
12 | fNewphi=1; | |
13 | fMinv=0; | |
14 | fMbkg=0; | |
15 | } | |
16 | //////////////////////////////////////////////////////////////////////////////// | |
17 | AliInvmass::~AliInvmass() | |
18 | { | |
19 | // Destructor to delete dynamically allocated memory | |
20 | if (fMinv) | |
21 | { | |
22 | fMinv->Delete(); | |
23 | delete fMinv; | |
24 | fMinv=0; | |
25 | } | |
26 | ||
27 | if (fMbkg) | |
28 | { | |
29 | fMbkg->Delete(); | |
30 | delete fMbkg; | |
31 | fMbkg=0; | |
32 | } | |
33 | } | |
34 | //////////////////////////////////////////////////////////////////////////////// | |
35 | void AliInvmass::SetStorageMode(Int_t m) | |
36 | { | |
37 | // Set storage mode for the result arrays for inv. mass and comb. background | |
38 | fMode=2; | |
39 | if (m==1) fMode=1; | |
40 | } | |
41 | //////////////////////////////////////////////////////////////////////////////// | |
42 | void AliInvmass::SetThetaSwitch(Int_t i) | |
43 | { | |
44 | // Enable/Disable (1/0) switching of theta angle in comb. bkg. reconstruction. | |
45 | // Default : Switching of theta is enabled. | |
46 | fNewtheta=1; | |
47 | if (i==0) fNewtheta=0; | |
48 | } | |
49 | //////////////////////////////////////////////////////////////////////////////// | |
50 | void AliInvmass::SetPhiSwitch(Int_t i) | |
51 | { | |
52 | // Enable/Disable (1/0) switching of phi angle in comb. bkg. reconstruction. | |
53 | // Default : Switching of phi is enabled. | |
54 | fNewphi=1; | |
55 | if (i==0) fNewphi=0; | |
56 | } | |
57 | //////////////////////////////////////////////////////////////////////////////// | |
58 | Int_t AliInvmass::GetStorageMode() | |
59 | { | |
60 | // Provide mode of storage for the result arrays for inv. mass and comb. background | |
61 | return fMode; | |
62 | } | |
63 | //////////////////////////////////////////////////////////////////////////////// | |
64 | Int_t AliInvmass::GetThetaSwitch() | |
65 | { | |
66 | // Provide the theta switching flag | |
67 | return fNewtheta; | |
68 | } | |
69 | //////////////////////////////////////////////////////////////////////////////// | |
70 | Int_t AliInvmass::GetPhiSwitch() | |
71 | { | |
72 | // Provide the phi switching flag | |
73 | return fNewphi; | |
74 | } | |
75 | //////////////////////////////////////////////////////////////////////////////// | |
76 | TObjArray* AliInvmass::Invmass(TObjArray* a1,TObjArray* a2) | |
77 | { | |
78 | // Perform two-particle invariant mass reconstruction | |
79 | fBkg=0; | |
80 | Combine(a1,a2); | |
81 | return fMinv; | |
82 | } | |
83 | //////////////////////////////////////////////////////////////////////////////// | |
84 | TObjArray* AliInvmass::CombBkg(TObjArray* a1,TObjArray* a2) | |
85 | { | |
86 | // Perform two-particle combinatorial background reconstruction | |
87 | fBkg=1; | |
88 | Combine(a1,a2); | |
89 | if (fMode != 1) | |
90 | { | |
91 | return fMbkg; | |
92 | } | |
93 | else | |
94 | { | |
95 | return fMinv; | |
96 | } | |
97 | } | |
98 | //////////////////////////////////////////////////////////////////////////////// | |
99 | void AliInvmass::Combine(TObjArray* a1,TObjArray* a2) | |
100 | { | |
101 | // Perform two-particle invariant mass reconstruction | |
102 | ||
103 | if ((!fBkg || fMode==1) && fMinv) | |
104 | { | |
105 | fMinv->Delete(); | |
106 | delete fMinv; | |
107 | fMinv=0; | |
108 | } | |
109 | ||
110 | if (fBkg && (fMode !=1) && fMbkg) | |
111 | { | |
112 | fMbkg->Delete(); | |
113 | delete fMbkg; | |
114 | fMbkg=0; | |
115 | } | |
116 | ||
117 | Int_t isame; // Indicates whether both lists are identical | |
118 | isame=0; | |
119 | if (a1==a2) isame=1; | |
120 | ||
121 | // Index i must loop over the shortest of a1 and a2 | |
122 | TObjArray* listi=a1; | |
123 | TObjArray* listj=a2; | |
124 | Int_t ni=a1->GetEntries(); | |
125 | Int_t nj=a2->GetEntries(); | |
126 | if (nj < ni) | |
127 | { | |
128 | ni=a2->GetEntries(); | |
129 | nj=a1->GetEntries(); | |
130 | listi=a2; | |
131 | listj=a1; | |
132 | } | |
133 | ||
134 | AliTrack* p1=0; | |
135 | AliTrack* p2=0; | |
136 | AliTrack* px=0; | |
137 | Ali4Vector ptot; | |
138 | AliTrack* t=0; | |
139 | Double_t v2[4],vx[4]; | |
140 | Float_t q1,q2; | |
141 | ||
142 | Int_t jmin; // Start index for list j | |
143 | Int_t jx; // Index for randomly picked particle for comb. bkg. reconstruction | |
144 | ||
145 | for (Int_t i=0; i<ni; i++) // Select first a particle from list i | |
146 | { | |
147 | p1=(AliTrack*)listi->At(i); | |
148 | p2=0; | |
149 | ||
150 | if (!p1) continue; | |
151 | ||
152 | jmin=0; | |
153 | if (isame) jmin=i+1; | |
154 | for (Int_t j=jmin; j<nj; j++) // Select also a particle from list j | |
155 | { | |
156 | p2=(AliTrack*)listj->At(j); | |
157 | if (p1==p2) p2=0; // Don't combine particle with itself | |
158 | ||
159 | if (!p2) continue; | |
160 | ||
161 | p2->GetVector(v2,"sph"); | |
162 | ||
163 | // Take theta and phi from randomly chosen other list j particle for bkg. reconstr. | |
164 | if (fBkg) | |
165 | { | |
166 | px=0; | |
167 | if ((!isame && nj>1) || (isame && nj>2)) | |
168 | { | |
169 | jx=int(fRndm.Uniform(0,float(nj))); | |
170 | px=(AliTrack*)listj->At(jx); | |
171 | ||
172 | while (!px || px==p2 || px==p1) | |
173 | { | |
174 | jx++; | |
175 | if (jx >= nj) jx=0; | |
176 | px=(AliTrack*)listj->At(jx); | |
177 | } | |
178 | ||
179 | px->GetVector(vx,"sph"); | |
180 | if (fNewtheta) v2[2]=vx[2]; // Replace the theta angle in the v2 vector | |
181 | if (fNewphi) v2[3]=vx[3]; // Replace the phi angle in the v2 vector | |
182 | } | |
183 | } | |
184 | ||
185 | if ((!fBkg && p2) || (fBkg && px)) | |
186 | { | |
187 | // Store the data of this two-particle combination | |
188 | ptot.SetVector(v2,"sph"); | |
189 | ptot=(Ali4Vector)(ptot+(*p1)); | |
190 | q1=p1->GetCharge(); | |
191 | q2=p2->GetCharge(); | |
192 | t=new AliTrack; | |
193 | t->Set4Momentum(ptot); | |
194 | t->SetCharge(q1+q2); | |
195 | if (!fBkg || fMode==1) | |
196 | { | |
197 | if (!fMinv) fMinv=new TObjArray(); | |
198 | fMinv->Add(t); | |
199 | } | |
200 | else | |
201 | { | |
202 | if (!fMbkg) fMbkg=new TObjArray(); | |
203 | fMbkg->Add(t); | |
204 | } | |
205 | } | |
206 | ||
207 | } // End of second particle loop | |
208 | ||
209 | } // End of first particle loop | |
210 | } | |
211 | //////////////////////////////////////////////////////////////////////////////// |