Line data Source code
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 to read events from external (TNtupla) file
18 : // Events -> neutron removal by EM dissociation of Pb nuclei
19 : // Data from RELDIS code (by I. Pshenichov)
20 :
21 : #include <TFile.h>
22 : #include <TParticle.h>
23 : #include <TTree.h>
24 : #include <TVirtualMC.h>
25 : #include <TDatabasePDG.h>
26 : #include <TPDGCode.h>
27 : #include "AliGenReaderEMD.h"
28 : #include "AliStack.h"
29 :
30 :
31 6 : ClassImp(AliGenReaderEMD)
32 :
33 0 : AliGenReaderEMD::AliGenReaderEMD():
34 0 : fStartEvent(0),
35 0 : fNcurrent(0),
36 0 : fNparticle(0),
37 0 : fTreeNtuple(0),
38 0 : fPcToTrack(0),
39 0 : fOffset(0),
40 0 : fNnAside(0),
41 0 : fEnAside(0),
42 0 : fnPDGCode(0),
43 0 : fNnCside(0),
44 0 : fEnCside(0),
45 0 : fNpAside(0),
46 0 : fEtapAside(0),
47 0 : fpPDGCode(0),
48 0 : fNpCside(0),
49 0 : fEtapCside(0),
50 0 : fNppAside(0),
51 0 : fEtappAside(0),
52 0 : fppPDGCode(0),
53 0 : fNppCside(0),
54 0 : fEtappCside(0),
55 0 : fNpmAside(0),
56 0 : fEtapmAside(0),
57 0 : fpmPDGCode(0),
58 0 : fNpmCside(0),
59 0 : fEtapmCside(0),
60 0 : fNp0Aside(0),
61 0 : fEtap0Aside(0),
62 0 : fp0PDGCode(0),
63 0 : fNp0Cside(0),
64 0 : fEtap0Cside(0),
65 0 : fNetaAside(0),
66 0 : fEtaetaAside(0),
67 0 : fetaPDGCode(0),
68 0 : fNetaCside(0),
69 0 : fEtaetaCside(0),
70 0 : fNomegaAside(0),
71 0 : fEtaomegaAside(0),
72 0 : fomegaPDGCode(0),
73 0 : fNomegaCside(0),
74 0 : fEtaomegaCside(0)
75 0 : {
76 : // Std constructor
77 0 : for(int i=0; i<70; i++){
78 0 : fPxnAside[i] = fPynAside[i] = fPznAside[i] = 0.;
79 0 : fPxnCside[i] = fPynCside[i] = fPznCside[i] = 0.;
80 0 : if(i<50){
81 0 : fPxpAside[i] = fPypAside[i] = fPzpAside[i] = 0.;
82 0 : fPxpCside[i] = fPypCside[i] = fPzpCside[i] = 0.;
83 0 : if(i<30){
84 0 : fPxppAside[i] = fPyppAside[i] = fPzppAside[i] = 0.;
85 0 : fPxppCside[i] = fPyppCside[i] = fPzppCside[i] = 0.;
86 0 : fPxpmAside[i] = fPypmAside[i] = fPzpmAside[i] = 0.;
87 0 : fPxpmCside[i] = fPypmCside[i] = fPzpmCside[i] = 0.;
88 0 : fPxp0Aside[i] = fPyp0Aside[i] = fPzp0Aside[i] = 0.;
89 0 : fPxp0Cside[i] = fPyp0Cside[i] = fPzp0Cside[i] = 0.;
90 0 : if(i<15){
91 0 : fPxetaAside[i] = fPyetaAside[i] = fPzetaAside[i] = 0.;
92 0 : fPxetaCside[i] = fPyetaCside[i] = fPzetaCside[i] = 0.;
93 0 : fPxomegaAside[i] = fPyomegaAside[i] = fPzomegaAside[i] = 0.;
94 0 : fPxomegaCside[i] = fPyomegaCside[i] = fPzomegaCside[i] = 0.;
95 0 : }
96 : }
97 : }
98 : }
99 0 : if(fPcToTrack==kAll) printf("\n\t *** AliGenReaderEMD will track all produced particles \n\n");
100 0 : else if(fPcToTrack==kNotNucleons) printf("\n\t *** AliGenReaderEMD will track all produced particles except nucleons\n\n");
101 0 : else if(fPcToTrack==kOnlyNucleons) printf("\n\t *** AliGenReaderEMD will track only nucleons\n\n");
102 0 : }
103 :
104 :
105 : AliGenReaderEMD::AliGenReaderEMD(const AliGenReaderEMD &reader):
106 0 : AliGenReader(reader),
107 0 : fStartEvent(0),
108 0 : fNcurrent(0),
109 0 : fNparticle(0),
110 0 : fTreeNtuple(0),
111 0 : fPcToTrack(0),
112 0 : fOffset(0),
113 0 : fNnAside(0),
114 0 : fEnAside(0),
115 0 : fnPDGCode(0),
116 0 : fNnCside(0),
117 0 : fEnCside(0),
118 0 : fNpAside(0),
119 0 : fEtapAside(0),
120 0 : fpPDGCode(0),
121 0 : fNpCside(0),
122 0 : fEtapCside(0),
123 0 : fNppAside(0),
124 0 : fEtappAside(0),
125 0 : fppPDGCode(0),
126 0 : fNppCside(0),
127 0 : fEtappCside(0),
128 0 : fNpmAside(0),
129 0 : fEtapmAside(0),
130 0 : fpmPDGCode(0),
131 0 : fNpmCside(0),
132 0 : fEtapmCside(0),
133 0 : fNp0Aside(0),
134 0 : fEtap0Aside(0),
135 0 : fp0PDGCode(0),
136 0 : fNp0Cside(0),
137 0 : fEtap0Cside(0),
138 0 : fNetaAside(0),
139 0 : fEtaetaAside(0),
140 0 : fetaPDGCode(0),
141 0 : fNetaCside(0),
142 0 : fEtaetaCside(0),
143 0 : fNomegaAside(0),
144 0 : fEtaomegaAside(0),
145 0 : fomegaPDGCode(0),
146 0 : fNomegaCside(0),
147 0 : fEtaomegaCside(0)
148 0 : {
149 : // Copy Constructor
150 0 : for(int i=0; i<70; i++){
151 0 : fPxnAside[i] = fPynAside[i] = fPznAside[i] = 0.;
152 0 : fPxnCside[i] = fPynCside[i] = fPznCside[i] = 0.;
153 0 : if(i<50){
154 0 : fPxpAside[i] = fPypAside[i] = fPzpAside[i] = 0.;
155 0 : fPxpCside[i] = fPypCside[i] = fPzpCside[i] = 0.;
156 0 : if(i<30){
157 0 : fPxppAside[i] = fPyppAside[i] = fPzppAside[i] = 0.;
158 0 : fPxppCside[i] = fPyppCside[i] = fPzppCside[i] = 0.;
159 0 : fPxpmAside[i] = fPypmAside[i] = fPzpmAside[i] = 0.;
160 0 : fPxpmCside[i] = fPypmCside[i] = fPzpmCside[i] = 0.;
161 0 : fPxp0Aside[i] = fPyp0Aside[i] = fPzp0Aside[i] = 0.;
162 0 : fPxp0Cside[i] = fPyp0Cside[i] = fPzp0Cside[i] = 0.;
163 0 : if(i<15){
164 0 : fPxetaAside[i] = fPyetaAside[i] = fPzetaAside[i] = 0.;
165 0 : fPxetaCside[i] = fPyetaCside[i] = fPzetaCside[i] = 0.;
166 0 : fPxomegaAside[i] = fPyomegaAside[i] = fPzomegaAside[i] = 0.;
167 0 : fPxomegaCside[i] = fPyomegaCside[i] = fPzomegaCside[i] = 0.;
168 0 : }
169 : }
170 : }
171 : }
172 0 : reader.Copy(*this);
173 0 : }
174 : // -----------------------------------------------------------------------------------
175 : AliGenReaderEMD::~AliGenReaderEMD()
176 0 : {
177 0 : delete fTreeNtuple;
178 0 : }
179 :
180 : // -----------------------------------------------------------------------------------
181 : AliGenReaderEMD& AliGenReaderEMD::operator=(const AliGenReaderEMD& rhs)
182 : {
183 : // Assignment operator
184 0 : rhs.Copy(*this);
185 0 : return *this;
186 : }
187 :
188 : // -----------------------------------------------------------------------------------
189 : void AliGenReaderEMD::Copy(TObject&) const
190 : {
191 : //
192 : // Copy
193 : //
194 0 : Fatal("Copy","Not implemented!\n");
195 0 : }
196 :
197 : // -----------------------------------------------------------------------------------
198 : void AliGenReaderEMD::Init()
199 : {
200 : //
201 : // Reset the existing file environment and open a new root file
202 :
203 : TFile *pFile=0;
204 0 : if (!pFile) {
205 0 : pFile = new TFile(fFileName);
206 0 : pFile->cd();
207 0 : printf("\n %s file opened to read RELDIS EMD events\n\n", fFileName);
208 0 : }
209 0 : fTreeNtuple = (TTree*)gDirectory->Get("h2032");
210 0 : fNcurrent = fStartEvent;
211 :
212 0 : TTree *Ntu=fTreeNtuple;
213 : //
214 : // Set branch addresses
215 : // **** neutrons
216 0 : Ntu->SetBranchAddress("Nleft",&fNnAside);
217 0 : Ntu->SetBranchAddress("Eleft",&fEnAside);
218 0 : Ntu->SetBranchAddress("Ipdg_l_n",&fnPDGCode);
219 0 : Ntu->SetBranchAddress("Pxl", fPxnAside);
220 0 : Ntu->SetBranchAddress("Pyl", fPynAside);
221 0 : Ntu->SetBranchAddress("Pzl", fPznAside);
222 0 : Ntu->SetBranchAddress("Nright",&fNnCside);
223 0 : Ntu->SetBranchAddress("Eright",&fEnCside);
224 0 : Ntu->SetBranchAddress("Pxr", fPxnCside);
225 0 : Ntu->SetBranchAddress("Pyr", fPynCside);
226 0 : Ntu->SetBranchAddress("Pzr", fPznCside);
227 : // **** protons
228 0 : Ntu->SetBranchAddress("Nleft_p",&fNpAside);
229 0 : Ntu->SetBranchAddress("Etaleft_p",&fEtapAside);
230 0 : Ntu->SetBranchAddress("Ipdg_l_p",&fpPDGCode);
231 0 : Ntu->SetBranchAddress("Pxl_p", fPxpAside);
232 0 : Ntu->SetBranchAddress("Pyl_p", fPypAside);
233 0 : Ntu->SetBranchAddress("Pzl_p", fPzpAside);
234 0 : Ntu->SetBranchAddress("Nright_p",&fNpCside);
235 0 : Ntu->SetBranchAddress("Etaright_p",&fEtapCside);
236 0 : Ntu->SetBranchAddress("Pxr_p", fPxpCside);
237 0 : Ntu->SetBranchAddress("Pyr_p", fPypCside);
238 0 : Ntu->SetBranchAddress("Pzr_p", fPzpCside);
239 : // **** pi+
240 0 : Ntu->SetBranchAddress("Nleft_pp",&fNppAside);
241 0 : Ntu->SetBranchAddress("Etaleft_pp",&fEtappAside);
242 0 : Ntu->SetBranchAddress("Ipdg_l_pp",&fppPDGCode);
243 0 : Ntu->SetBranchAddress("Pxl_pp", fPxppAside);
244 0 : Ntu->SetBranchAddress("Pyl_pp", fPyppAside);
245 0 : Ntu->SetBranchAddress("Pzl_pp", fPzppAside);
246 0 : Ntu->SetBranchAddress("Nright_pp",&fNppCside);
247 0 : Ntu->SetBranchAddress("Etaright_pp",&fEtappCside);
248 0 : Ntu->SetBranchAddress("Pxr_pp", fPxppCside);
249 0 : Ntu->SetBranchAddress("Pyr_pp", fPyppCside);
250 0 : Ntu->SetBranchAddress("Pzr_pp", fPzppCside);
251 : // **** pi-
252 0 : Ntu->SetBranchAddress("Nleft_pm",&fNpmAside);
253 0 : Ntu->SetBranchAddress("Etaleft_pm",&fEtapmAside);
254 0 : Ntu->SetBranchAddress("Ipdg_l_pm",&fpmPDGCode);
255 0 : Ntu->SetBranchAddress("Pxl_pm", fPxpmAside);
256 0 : Ntu->SetBranchAddress("Pyl_pm", fPypmAside);
257 0 : Ntu->SetBranchAddress("Pzl_pm", fPzpmAside);
258 0 : Ntu->SetBranchAddress("Nright_pm",&fNpmCside);
259 0 : Ntu->SetBranchAddress("Etaright_pm",&fEtapmCside);
260 0 : Ntu->SetBranchAddress("Pxr_pm", fPxpmCside);
261 0 : Ntu->SetBranchAddress("Pyr_pm", fPypmCside);
262 0 : Ntu->SetBranchAddress("Pzr_pm", fPzpmCside);
263 : // **** pi0
264 0 : Ntu->SetBranchAddress("Nleft_p0",&fNp0Aside);
265 0 : Ntu->SetBranchAddress("Etaleft_p0",&fEtap0Aside);
266 0 : Ntu->SetBranchAddress("Ipdg_l_p0",&fp0PDGCode);
267 0 : Ntu->SetBranchAddress("Pxl_p0", fPxp0Aside);
268 0 : Ntu->SetBranchAddress("Pyl_p0", fPyp0Aside);
269 0 : Ntu->SetBranchAddress("Pzl_p0", fPzp0Aside);
270 0 : Ntu->SetBranchAddress("Nright_p0",&fNp0Cside);
271 0 : Ntu->SetBranchAddress("Etaright_p0",&fEtap0Cside);
272 0 : Ntu->SetBranchAddress("Pxr_p0", fPxp0Cside);
273 0 : Ntu->SetBranchAddress("Pyr_p0", fPyp0Cside);
274 0 : Ntu->SetBranchAddress("Pzr_p0", fPzp0Cside);
275 : // **** eta
276 0 : Ntu->SetBranchAddress("Nleft_et",&fNetaAside);
277 0 : Ntu->SetBranchAddress("Etaleft_et",&fEtaetaAside);
278 0 : Ntu->SetBranchAddress("Ipdg_l_et",&fetaPDGCode);
279 0 : Ntu->SetBranchAddress("Pxl_et", fPxetaAside);
280 0 : Ntu->SetBranchAddress("Pyl_et", fPyetaAside);
281 0 : Ntu->SetBranchAddress("Pzl_et", fPzetaAside);
282 0 : Ntu->SetBranchAddress("Nright_et",&fNetaCside);
283 0 : Ntu->SetBranchAddress("Etaright_et",&fEtaetaCside);
284 0 : Ntu->SetBranchAddress("Pxr_et", fPxetaCside);
285 0 : Ntu->SetBranchAddress("Pyr_et", fPyetaCside);
286 0 : Ntu->SetBranchAddress("Pzr_et", fPzetaCside);
287 : // **** omega
288 0 : Ntu->SetBranchAddress("Nleft_om",&fNomegaAside);
289 0 : Ntu->SetBranchAddress("Etaleft_om",&fEtaomegaAside);
290 0 : Ntu->SetBranchAddress("Ipdg_l_om",&fomegaPDGCode);
291 0 : Ntu->SetBranchAddress("Pxl_om", fPxomegaAside);
292 0 : Ntu->SetBranchAddress("Pyl_om", fPyomegaAside);
293 0 : Ntu->SetBranchAddress("Pzl_om", fPzomegaAside);
294 0 : Ntu->SetBranchAddress("Nright_om",&fNomegaCside);
295 0 : Ntu->SetBranchAddress("Etaright_om",&fEtaomegaCside);
296 0 : Ntu->SetBranchAddress("Pxr_om", fPxomegaCside);
297 0 : Ntu->SetBranchAddress("Pyr_om", fPyomegaCside);
298 0 : Ntu->SetBranchAddress("Pzr_om", fPzomegaCside);
299 0 : }
300 :
301 : // -----------------------------------------------------------------------------------
302 : Int_t AliGenReaderEMD::NextEvent()
303 : {
304 : // Read the next event
305 : Int_t nTracks=0;
306 0 : fNparticle = 0; fOffset=0;
307 :
308 0 : TFile* pFile = fTreeNtuple->GetCurrentFile();
309 0 : pFile->cd();
310 :
311 :
312 0 : Int_t nentries = (Int_t) fTreeNtuple->GetEntries();
313 0 : if(fNcurrent < nentries) {
314 0 : fTreeNtuple->GetEvent(fNcurrent);
315 0 : if(fNcurrent%100 == 0) printf("\n *** Reading event %d ***\n",fNcurrent);
316 : //
317 0 : if(fPcToTrack==kAll || fPcToTrack==kOnlyNucleons){ // nucleons
318 0 : nTracks = fNnCside+fNnAside+fNpCside+fNpAside;
319 0 : }
320 0 : if(fPcToTrack==kAll || fPcToTrack==kNotNucleons){ //pions,eta,omega
321 0 : nTracks += fNppCside+fNpmCside+fNppAside+fNpmAside+fNp0Aside+fNp0Cside+
322 0 : fNetaAside+fNetaCside+fNomegaAside+fNomegaCside;
323 0 : }
324 0 : fNcurrent++;
325 0 : printf("\t #### Putting %d particles in the stack\n", nTracks);
326 : /*if(fPcToTrack==kAll || fPcToTrack==kOnlyNucleons) printf("\t\t %d+%d neutrons, %d+%d protons\n",
327 : fNnAside,fNnCside, fNpAside,fNpCside);
328 : if(fPcToTrack==kAll || fPcToTrack==kNotNucleons) printf("\t %d+%d pi+, %d+%d pi-, %d+%d pi0, %d+%d eta, %d+%d omega\n",
329 : fNppAside,fNppCside,fNpmAside,fNpmCside,
330 : fNp0Aside,fNp0Cside,fNetaAside,fNetaCside, fNomegaAside,fNomegaCside);*/
331 0 : return nTracks;
332 : }
333 :
334 0 : return 0;
335 0 : }
336 :
337 : // -----------------------------------------------------------------------------------
338 : TParticle* AliGenReaderEMD::NextParticle()
339 : {
340 : // Read the next particle
341 : Float_t p[4]={0.,0.,0.,0.};
342 : int pdgCode=0;
343 :
344 0 : if(fPcToTrack==kAll || fPcToTrack==kOnlyNucleons){//***********************************************
345 0 : if(fNparticle<fNnAside){
346 0 : p[0] = fPxnAside[fNparticle];
347 0 : p[1] = fPynAside[fNparticle];
348 0 : p[2] = fPznAside[fNparticle];
349 0 : pdgCode = fnPDGCode;
350 : // printf(" pc%d n sideA: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
351 0 : }
352 0 : else if(fNparticle>=fNnAside && fNparticle<(fNnAside+fNnCside)){
353 0 : p[0] = fPxnCside[fNparticle];
354 0 : p[1] = fPynCside[fNparticle];
355 0 : p[2] = fPznCside[fNparticle];
356 0 : pdgCode = fnPDGCode;
357 : // printf(" pc%d n sideC: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
358 0 : }
359 0 : else if(fNparticle>=fNnAside+fNnCside && fNparticle<(fNnAside+fNnCside+fNpAside)){
360 0 : p[0] = fPxpAside[fNparticle];
361 0 : p[1] = fPypAside[fNparticle];
362 0 : p[2] = fPzpAside[fNparticle];
363 0 : pdgCode = fpPDGCode;
364 : // printf(" pc%d p sideA: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
365 0 : }
366 0 : else if(fNparticle>=fNnAside+fNnCside+fNpAside && fNparticle<(fNnAside+fNnCside+fNpCside+fNpAside)){
367 0 : p[0] = fPxpCside[fNparticle];
368 0 : p[1] = fPypCside[fNparticle];
369 0 : p[2] = fPzpCside[fNparticle];
370 0 : pdgCode = fpPDGCode;
371 : // printf(" pc%d p sideC: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
372 0 : }
373 0 : fOffset = fNnAside+fNnCside+fNpCside+fNpAside;
374 0 : } //**********************************************************************************************
375 0 : if(fPcToTrack==kAll || fPcToTrack==kNotNucleons){
376 0 : if(fNparticle>=fOffset && fNparticle<fOffset+fNppAside){ // *** pi +
377 0 : p[0] = fPxppAside[fNparticle];
378 0 : p[1] = fPyppAside[fNparticle];
379 0 : p[2] = fPzppAside[fNparticle];
380 0 : pdgCode = fppPDGCode;
381 : // printf(" pc%d pi+ sideA: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
382 0 : }
383 0 : if(fNparticle>=fOffset+fNppAside && fNparticle<fOffset+fNppAside+fNppCside){
384 0 : p[0] = fPxppCside[fNparticle];
385 0 : p[1] = fPyppCside[fNparticle];
386 0 : p[2] = fPzppCside[fNparticle];
387 0 : pdgCode = fppPDGCode;
388 : // printf(" pc%d pi+ sideC: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
389 0 : }
390 0 : if(fNparticle>=fOffset+fNppAside+fNppCside && fNparticle<fOffset+fNppAside+fNppCside+fNpmAside){ // *** pi -
391 0 : p[0] = fPxpmAside[fNparticle];
392 0 : p[1] = fPypmAside[fNparticle];
393 0 : p[2] = fPzpmAside[fNparticle];
394 0 : pdgCode = fpmPDGCode;
395 : // printf(" pc%d pi- sideA: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
396 0 : }
397 0 : if(fNparticle>=fOffset+fNppAside+fNppCside+fNpmAside && fNparticle<fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside){
398 0 : p[0] = fPxpmCside[fNparticle];
399 0 : p[1] = fPypmCside[fNparticle];
400 0 : p[2] = fPzpmCside[fNparticle];
401 0 : pdgCode = fpmPDGCode;
402 : // printf(" pc%d pi- sideC: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
403 0 : }
404 0 : if(fNparticle>=fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside &&
405 0 : fNparticle<fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside){ // *** pi 0
406 0 : p[0] = fPxp0Aside[fNparticle];
407 0 : p[1] = fPyp0Aside[fNparticle];
408 0 : p[2] = fPzp0Aside[fNparticle];
409 0 : pdgCode = fp0PDGCode;
410 : // printf(" pc%d pi0 sideA: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
411 0 : }
412 0 : if(fNparticle>=fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside &&
413 0 : fNparticle<fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside+fNp0Cside){
414 0 : p[0] = fPxp0Cside[fNparticle];
415 0 : p[1] = fPyp0Cside[fNparticle];
416 0 : p[2] = fPzp0Cside[fNparticle];
417 0 : pdgCode = fp0PDGCode;
418 : // printf(" pc%d pi0 sideC: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
419 0 : }
420 0 : if(fNparticle>=fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside+fNp0Cside &&
421 0 : fNparticle<fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside+fNp0Cside+fNetaAside){ // *** eta
422 0 : p[0] = fPxetaAside[fNparticle];
423 0 : p[1] = fPyetaAside[fNparticle];
424 0 : p[2] = fPzetaAside[fNparticle];
425 0 : pdgCode = fetaPDGCode;
426 : // printf(" pc%d eta sideA: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
427 0 : }
428 0 : if(fNparticle>=fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside+fNp0Cside+fNetaAside &&
429 0 : fNparticle<fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside+fNp0Cside+fNetaAside+fNetaCside){
430 0 : p[0] = fPxetaCside[fNparticle];
431 0 : p[1] = fPyetaCside[fNparticle];
432 0 : p[2] = fPzetaCside[fNparticle];
433 0 : pdgCode = fetaPDGCode;
434 : // printf(" pc%d eta sideC: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
435 0 : }
436 0 : if(fNparticle>=fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside+fNp0Cside+fNetaAside+fNetaCside &&
437 0 : fNparticle<fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside+fNp0Cside+fNetaAside+fNetaCside+fNomegaAside){ // *** omega
438 0 : p[0] = fPxomegaAside[fNparticle];
439 0 : p[1] = fPyomegaAside[fNparticle];
440 0 : p[2] = fPzomegaAside[fNparticle];
441 0 : pdgCode = fomegaPDGCode;
442 : // printf(" pc%d omega sideA: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
443 0 : }
444 0 : if(fNparticle>=fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside+fNp0Cside+fNetaAside+fNetaCside+fNomegaAside
445 0 : && fNparticle<fOffset+fNppAside+fNppCside+fNpmAside+fNpmCside+fNp0Aside+fNp0Cside+fNetaAside+fNetaCside+fNomegaAside+fNomegaCside){
446 0 : p[0] = fPxomegaCside[fNparticle];
447 0 : p[1] = fPyomegaCside[fNparticle];
448 0 : p[2] = fPzomegaCside[fNparticle];
449 0 : pdgCode = fomegaPDGCode;
450 : // printf(" pc%d omega sideC: PDG code %d, momentum (%f, %f, %f) \n", fNparticle, pdgCode, p[0],p[1],p[2]);
451 0 : }
452 :
453 : }
454 :
455 0 : Float_t ptot = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2]);
456 0 : Double_t amass = TDatabasePDG::Instance()->GetParticle(pdgCode)->Mass();
457 0 : p[3] = TMath::Sqrt(ptot*ptot+amass*amass);
458 :
459 0 : if(p[3]<=amass){
460 0 : Warning("Generate","Particle %d E = %f GeV mass = %f GeV ",pdgCode,p[3],amass);
461 0 : }
462 :
463 : //printf(" Pc %d: PDGcode %d p(%1.2f, %1.2f, %1.2f, %1.3f)\n",
464 : // fNparticle,pdgCode,p[0], p[1], p[2], p[3]);
465 :
466 0 : TParticle* particle = new TParticle(pdgCode, 0, -1, -1, -1, -1,
467 0 : p[0], p[1], p[2], p[3], 0., 0., 0., 0.);
468 0 : if((p[0]*p[0]+p[1]*p[1]+p[2]*p[2])>1e-5) particle->SetBit(kTransportBit);
469 0 : fNparticle++;
470 0 : return particle;
471 0 : }
472 :
473 : //___________________________________________________________
474 : void AliGenReaderEMD::RewindEvent()
475 : {
476 : // Go back to the first particle of the event
477 0 : fNparticle = 0;
478 0 : }
|
