]>
Commit | Line | Data |
---|---|---|
6f388e0d | 1 | /**************************************************************************** |
2 | * This macro performs track and vertex reconstruction in TPC and ITS. * | |
3 | * The ITS Kalman tracker V2 is feeded "with" parameterized TPC tracks. * | |
4 | * * | |
5 | * Reconstruction is performed in the following steps: * | |
6 | * 1) TPC tracking parameterization * | |
7 | * 2) ITS clusters: slow or fast * | |
8 | * 3) Primary vertex reconstruction * | |
9 | * - read from event header for Pb-Pb events * | |
10 | * - determined using points in pixels for pp/pA events * | |
11 | * 4) ITS track finding V2 * | |
12 | * - in pp/pA, redetermine the position of primary vertex * | |
13 | * using the reconstructed tracks * | |
14 | * 5) Create a reference file with simulation info (p,PDG...) * | |
15 | * * | |
16 | * If mode='A' all 5 steps are executed * | |
17 | * If mode='B' only steps 4-5 are executed * | |
18 | * * | |
19 | * Origin: A.Dainese, Padova, andrea.dainese@pd.infn.it * | |
20 | * (from AliTPCtest.C & AliITStestV2.C by I.Belikov) * | |
21 | ****************************************************************************/ | |
22 | ||
23 | // structure for track references | |
24 | typedef struct { | |
25 | Int_t lab; | |
26 | Int_t pdg; | |
27 | Int_t mumlab; | |
28 | Int_t mumpdg; | |
29 | Float_t Vx,Vy,Vz; | |
30 | Float_t Px,Py,Pz; | |
31 | } RECTRACK; | |
32 | ||
33 | //===== Functions definition ================================================= | |
34 | ||
35 | void CopyVtx(const Char_t *inName,const Char_t *outName); | |
36 | ||
37 | void ITSFindClustersV2(Char_t SlowOrFast,Char_t* path[1024]); | |
38 | ||
39 | void ITSFindTracksV2(Int_t *skipEvt,Char_t* path[1024]); | |
40 | ||
41 | void ITSMakeRefFile(Int_t *skipEvt,Char_t* path[1024]); | |
42 | ||
43 | void MarkEvtsToSkip(const Char_t *evtsName,Int_t *skipEvt); | |
44 | ||
45 | void PrimaryVertex(const Char_t *outName,Char_t vtxMode,Char_t* path[1024]); | |
46 | ||
47 | void TPCParamTracks(Int_t coll,Double_t Bfield,Char_t* path[1024]); | |
48 | ||
49 | Int_t UpdateEvtsToSkip(const Char_t *logName,const Char_t *evtsName); | |
50 | ||
51 | void VtxFromHeader(const Char_t *outName,Bool_t smear,Char_t* path[1024]); | |
52 | ||
53 | void VtxFromTracks(const Char_t *outName,Char_t* path[1024]); | |
54 | ||
55 | void ZvtxFromSPD(const Char_t *outName,Char_t* path[1024]); | |
56 | ||
57 | //============================================================================= | |
58 | ||
59 | // number of events to be processed | |
60 | Int_t gNevents; | |
61 | // magnetic field | |
62 | Double_t gBfieldValue; | |
63 | ||
64 | void AliBarrelRec_TPCparam(Int_t n=-1,Char_t mode='A',Char_t* path="./") { | |
65 | ||
66 | //--------------------------------------------------------------------- | |
67 | // CONFIGURATION | |
68 | // | |
69 | // _Magnetic_field_ | |
70 | gBfieldValue = 0.4; | |
71 | // | |
72 | // _Type_of_collision_ (needed for TPC tracking parameterization) | |
73 | // Available choices: !!! ONLY B = 0.4 TESLA !!! | |
74 | // collcode = 0 -> PbPb6000 (HIJING with b<2fm) | |
75 | // collcode = 1 -> low multiplicity: pp or pA | |
76 | Int_t collcode = 0; | |
77 | // | |
78 | // _ITS_clusters_reconstruction_ | |
79 | // Available choices: (from AliITStestV2.C) | |
80 | // SlowOrFast = 's' slow points | |
81 | // SlowOrFast = 'f' fast points | |
82 | Char_t SlowOrFast = 'f'; | |
83 | // | |
84 | // _Primary_vertex_for_ITS_tracking_ | |
85 | // Available choices: | |
86 | // Vtx4Tracking = 'H' from event Header | |
87 | // --- for Pb-Pb --- | |
88 | // Vtx4Tracking = 'S' from event header + Smearing | |
89 | // (x=15,y=15,z=10) micron | |
90 | // --- for pp/pA --- | |
91 | // Vtx4Tracking = 'P' z from pixels, x,y in(0,0) | |
92 | Char_t Vtx4Tracking = 'H'; | |
93 | // _Primary_vertex_for_analysis_ (AliITSVertex stored in tracks file) | |
94 | // Available choices: | |
95 | // Vtx4Analysis = 'C' Copy the same used for tracking | |
96 | // --- for pp/pA --- | |
97 | // Vtx4Analysis = 'T' x,y,z from Tracks | |
98 | Char_t Vtx4Analysis = 'C'; | |
99 | // | |
100 | // END CONFIGURATION | |
101 | //--------------------------------------------------------------------- | |
102 | ||
103 | const Char_t *name=" AliBarrelRec_TPCparam"; | |
104 | printf("\n %s\n",name); | |
105 | gBenchmark->Start(name); | |
106 | ||
107 | if(n==-1) { // read number of events to be processed from file | |
108 | Char_t falice[1024]; | |
109 | sprintf(falice,"%s/galice.root",path); | |
110 | TFile *f = new TFile(falice); | |
111 | gAlice = (AliRun*)f->Get("gAlice"); | |
112 | n = gAlice->GetEventsPerRun(); | |
113 | delete gAlice; | |
114 | gAlice=0; | |
115 | f->Close(); | |
116 | delete f; | |
117 | printf(" All %d events in file will be processed\n",n); | |
118 | } | |
119 | gNevents = n; | |
120 | ||
121 | ||
122 | // conversion constant for kalman tracks | |
123 | AliKalmanTrack::SetConvConst(100/0.299792458/gBfieldValue); | |
124 | ||
125 | // Selection of execution mode | |
126 | switch(mode) { | |
127 | case 'A': | |
128 | // Build TPC tracks with parameterization | |
129 | TPCParamTracks(collcode,gBfieldValue,path); | |
130 | ||
131 | // ITS clusters | |
132 | ITSFindClustersV2(SlowOrFast,path); | |
133 | ||
134 | // Vertex for ITS tracking | |
135 | Char_t fvertex[1024]; | |
136 | sprintf(fvertex,"%s/Vtx4Tracking.root",path); | |
137 | PrimaryVertex(fvertex,Vtx4Tracking,path); | |
138 | ||
139 | break; | |
140 | ||
141 | case 'B': | |
142 | printf(" ---> only tracking in ITS <---\n"); | |
143 | ||
144 | // Update list of events to be skipped | |
145 | if(!UpdateEvtsToSkip("itstracking.log","evtsToSkip.dat")) return; | |
146 | ||
147 | break; | |
148 | } | |
149 | ||
150 | // Mark events that have to be skipped (if any) | |
151 | Int_t *skipEvt = new Int_t[gNevents]; | |
152 | for(Int_t i=0; i<gNevents; i++) skipEvt[i] = 0; | |
153 | if(!gSystem->AccessPathName("evtsToSkip.dat",kFileExists)) | |
154 | MarkEvtsToSkip("evtsToSkip.dat",skipEvt); | |
155 | ||
156 | // Tracking in ITS | |
157 | ITSFindTracksV2(skipEvt,path); | |
158 | ||
159 | // Vertex for analysis | |
160 | Char_t ftrack[1024]; | |
161 | sprintf(ftrack,"%s/AliITStracksV2.root",path); | |
162 | PrimaryVertex(ftrack,Vtx4Analysis,path); | |
163 | ||
164 | // Create ITS tracks reference file | |
165 | ITSMakeRefFile(skipEvt,path); | |
166 | delete [] skipEvt; | |
167 | ||
168 | gBenchmark->Stop(name); | |
169 | gBenchmark->Show(name); | |
170 | ||
171 | return; | |
172 | } | |
173 | //----------------------------------------------------------------------------- | |
174 | void CopyVtx(const Char_t *inName,const Char_t *outName) { | |
175 | ||
176 | // Open input and output files | |
177 | TFile *inFile = new TFile(inName); | |
178 | TFile *outFile = new TFile(outName,"update"); | |
179 | ||
180 | TDirectory *curdir; | |
181 | Char_t vname[20]; | |
182 | ||
183 | ||
184 | for(Int_t ev=0; ev<gNevents; ev++) { | |
185 | sprintf(vname,"Vertex_%d",ev); | |
186 | AliITSVertex *vertex = (AliITSVertex*)inFile->Get(vname); | |
187 | if(!vertex) continue; | |
188 | curdir = gDirectory; | |
189 | outFile->cd(); | |
190 | vertex->Write(); | |
191 | curdir->cd(); | |
192 | vertex = 0; | |
193 | } | |
194 | ||
195 | inFile->Close(); | |
196 | outFile->Close(); | |
197 | delete inFile; | |
198 | delete outFile; | |
199 | ||
200 | return; | |
201 | } | |
202 | //----------------------------------------------------------------------------- | |
203 | void ITSFindClustersV2(Char_t SlowOrFast,Char_t* path="./") { | |
204 | ||
205 | printf("\n------------------------------------\n"); | |
206 | ||
207 | const Char_t *name="ITSFindClustersV2"; | |
208 | printf("\n %s\n",name); | |
209 | gBenchmark->Start(name); | |
210 | ||
211 | //--- taken from AliITStestV2.C-------------------------------------- | |
212 | // | |
213 | if (SlowOrFast=='f') { | |
214 | //cerr<<"Fast AliITSRecPoint(s) !\n"; | |
215 | //gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliITSHits2FastRecPoints.C"); | |
216 | //AliITSHits2FastRecPoints(); | |
217 | } else { | |
218 | gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliITSHits2SDigits.C"); | |
219 | AliITSHits2SDigits(); | |
220 | gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliITSSDigits2Digits.C"); | |
221 | AliITSSDigits2Digits(); | |
222 | //gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliITSDigits2RecPoints.C"); | |
223 | //AliITSDigits2RecPoints(); | |
224 | } | |
225 | gROOT->LoadMacro("./AliITSFindClustersV2.C"); | |
226 | AliITSFindClustersV2(SlowOrFast,gNevents,path); | |
227 | // | |
228 | //-------------------------------------------------------------------- | |
229 | ||
230 | ||
231 | gBenchmark->Stop(name); | |
232 | gBenchmark->Show(name); | |
233 | ||
234 | return; | |
235 | } | |
236 | //----------------------------------------------------------------------------- | |
237 | Int_t ITSFindTracksV2(Int_t *skipEvt,Char_t* path="./") { | |
238 | ||
239 | printf("\n------------------------------------\n"); | |
240 | ||
241 | const Char_t *name="ITSFindTracksV2"; | |
242 | printf("\n %s\n",name); | |
243 | gBenchmark->Start(name); | |
244 | ||
245 | Char_t ftrack[1024]; | |
246 | sprintf(ftrack,"%s/AliITStracksV2.root",path); | |
247 | TFile *outFile = new TFile(ftrack,"recreate"); | |
248 | Char_t fparam[1024]; | |
249 | sprintf(fparam,"%s/AliTPCtracksParam.root",path); | |
250 | TFile *inTPCtrks = new TFile(fparam); | |
251 | Char_t fvertex[1024]; | |
252 | sprintf(fvertex,"%s/Vtx4Tracking.root",path); | |
253 | TFile *inVertex = new TFile(fvertex); | |
254 | Char_t fcluster[1024]; | |
255 | sprintf(fcluster,"%s/AliITSclustersV2.root",path); | |
256 | TFile *inClusters = new TFile(fcluster); | |
257 | ||
258 | AliITSgeom *geom=(AliITSgeom*)inClusters->Get("AliITSgeom"); | |
259 | if(!geom) { printf("can't get ITS geometry !\n"); return;} | |
260 | ||
261 | Double_t vtx[3]; | |
262 | Int_t flag1stPass,flag2ndPass; | |
263 | Char_t vname[20]; | |
264 | ||
265 | // open logfile for done events | |
266 | FILE *logfile = fopen("itstracking.log","w"); | |
267 | ||
268 | // Instantiate AliITStrackerV2 | |
269 | AliITStrackerV2 tracker(geom); | |
270 | ||
271 | // loop on events | |
272 | for(Int_t ev=0; ev<gNevents; ev++){ | |
273 | // write to logfile of begun events | |
274 | fprintf(logfile,"%d\n",ev); | |
275 | ||
276 | if(skipEvt[ev]) continue; | |
277 | printf(" --- Processing event %d ---\n",ev); | |
278 | ||
279 | // pass event number to the tracker | |
280 | tracker.SetEventNumber(ev); | |
281 | ||
282 | // set position of primary vertex | |
283 | sprintf(vname,"Vertex_%d",ev); | |
284 | AliITSVertex *vertex = (AliITSVertex*)inVertex->Get(vname); | |
285 | if(vertex) { | |
286 | vertex->GetXYZ(vtx); | |
287 | delete vertex; | |
288 | } else { | |
289 | printf(" AliITSVertex not found for event %d\n",ev); | |
290 | printf(" Using (0,0,0) for ITS tracking\n"); | |
291 | vtx[0] = vtx[1] = vtx[2] = 0.; | |
292 | } | |
293 | ||
294 | flag1stPass=1; // vtx constraint | |
295 | flag2ndPass=0; // no vtx constraint | |
296 | ||
297 | // no vtx constraint if vertex not found | |
298 | if(vtx[2]<-999.) { | |
299 | flag1stPass=0; | |
300 | vtx[2]=0.; | |
301 | } | |
302 | ||
303 | tracker.SetVertex(vtx); | |
304 | ||
305 | // setup vertex constraint in the two tracking passes | |
306 | Int_t flags[2]; | |
307 | flags[0]=flag1stPass; | |
308 | tracker.SetupFirstPass(flags); | |
309 | flags[0]=flag2ndPass; | |
310 | tracker.SetupSecondPass(flags); | |
311 | ||
312 | // find the tracks | |
313 | tracker.Clusters2Tracks(inTPCtrks,outFile); | |
314 | ||
315 | } // loop on events | |
316 | ||
317 | fprintf(logfile,"%d\n",gNevents); //this means all evts are successfully completed | |
318 | fclose(logfile); | |
319 | ||
320 | delete geom; | |
321 | ||
322 | inTPCtrks->Close(); | |
323 | inClusters->Close(); | |
324 | inVertex->Close(); | |
325 | outFile->Close(); | |
326 | ||
327 | ||
328 | gBenchmark->Stop(name); | |
329 | gBenchmark->Show(name); | |
330 | ||
331 | return; | |
332 | } | |
333 | //----------------------------------------------------------------------------- | |
334 | void ITSMakeRefFile(Int_t *skipEvt,Char_t* path="./") { | |
335 | ||
336 | printf("\n------------------------------------\n"); | |
337 | ||
338 | const Char_t *name="ITSMakeRefFile"; | |
339 | printf("\n %s\n",name); | |
340 | gBenchmark->Start(name); | |
341 | ||
342 | Char_t fref[1024]; | |
343 | sprintf(fref,"%s/ITStracksRefFile.root",path); | |
344 | TFile *out = TFile::Open(fref,"recreate"); | |
345 | Char_t ftrack[1024]; | |
346 | sprintf(ftrack,"%s/AliITStracksV2.root",path); | |
347 | TFile *trk = TFile::Open(ftrack); | |
348 | Char_t falice[1024]; | |
349 | sprintf(falice,"%s/galice.root",path); | |
350 | TFile *kin = TFile::Open(falice); | |
351 | ||
352 | ||
353 | // Get gAlice object from file | |
354 | gAlice=(AliRun*)kin->Get("gAlice"); | |
355 | ||
356 | Int_t label; | |
357 | TParticle *Part; | |
358 | TParticle *Mum; | |
359 | RECTRACK rectrk; | |
360 | ||
361 | ||
362 | for(Int_t ev=0; ev<gNevents; ev++){ | |
363 | if(skipEvt[ev]) continue; | |
364 | printf(" --- Processing event %d ---\n",ev); | |
365 | ||
366 | gAlice->GetEvent(ev); | |
367 | ||
368 | trk->cd(); | |
369 | ||
370 | // Tree with ITS tracks | |
371 | char tname[100]; | |
372 | sprintf(tname,"TreeT_ITS_%d",ev); | |
373 | ||
374 | TTree *tracktree=(TTree*)trk->Get(tname); | |
375 | if(!tracktree) continue; | |
376 | AliITStrackV2 *itstrack=new AliITStrackV2; | |
377 | tracktree->SetBranchAddress("tracks",&itstrack); | |
378 | Int_t nentr=(Int_t)tracktree->GetEntries(); | |
379 | ||
380 | // Tree for true track parameters | |
381 | char ttname[100]; | |
382 | sprintf(ttname,"Tree_Ref_%d",ev); | |
383 | TTree *reftree = new TTree(ttname,"Tree with true track params"); | |
384 | reftree->Branch("rectracks",&rectrk,"lab/I:pdg:mumlab:mumpdg:Vx/F:Vy:Vz:Px:Py:Pz"); | |
385 | ||
386 | for(Int_t i=0; i<nentr; i++) { | |
387 | tracktree->GetEvent(i); | |
388 | label = TMath::Abs(itstrack->GetLabel()); | |
389 | ||
390 | Part = (TParticle*)gAlice->Particle(label); | |
391 | rectrk.lab=label; | |
392 | rectrk.pdg=Part->GetPdgCode(); | |
393 | rectrk.mumlab = Part->GetFirstMother(); | |
394 | if(Part->GetFirstMother()>=0) { | |
395 | Mum = (TParticle*)gAlice->Particle(Part->GetFirstMother()); | |
396 | rectrk.mumpdg=Mum->GetPdgCode(); | |
397 | } else { | |
398 | rectrk.mumpdg=-1; | |
399 | } | |
400 | rectrk.Vx=Part->Vx(); | |
401 | rectrk.Vy=Part->Vy(); | |
402 | rectrk.Vz=Part->Vz(); | |
403 | rectrk.Px=Part->Px(); | |
404 | rectrk.Py=Part->Py(); | |
405 | rectrk.Pz=Part->Pz(); | |
406 | ||
407 | reftree->Fill(); | |
408 | } // loop on tracks | |
409 | ||
410 | out->cd(); | |
411 | reftree->Write(); | |
412 | ||
413 | delete itstrack; | |
414 | delete reftree; | |
415 | } // loop on events | |
416 | ||
417 | trk->Close(); | |
418 | kin->Close(); | |
419 | out->Close(); | |
420 | ||
421 | gBenchmark->Stop(name); | |
422 | gBenchmark->Show(name); | |
423 | ||
424 | ||
425 | return; | |
426 | } | |
427 | //----------------------------------------------------------------------------- | |
428 | void MarkEvtsToSkip(const Char_t *evtsName,Int_t *skipEvt) { | |
429 | ||
430 | printf("\n------------------------------------\n"); | |
431 | printf("\nChecking for events to skip...\n"); | |
432 | ||
433 | Int_t evt,ncol; | |
434 | ||
435 | FILE *f = fopen(evtsName,"r"); | |
436 | while(1) { | |
437 | ncol = fscanf(f,"%d",&evt); | |
438 | if(ncol<1) break; | |
439 | skipEvt[evt] = 1; | |
440 | printf(" event %d will be skipped\n",evt); | |
441 | } | |
442 | fclose(f); | |
443 | ||
444 | return; | |
445 | } | |
446 | //----------------------------------------------------------------------------- | |
447 | void PrimaryVertex(const Char_t *outName,Char_t vtxMode,Char_t* path="./") { | |
448 | ||
449 | printf("\n------------------------------------\n"); | |
450 | ||
451 | const Char_t *name="PrimaryVertex"; | |
452 | printf("\n %s\n",name); | |
453 | gBenchmark->Start(name); | |
454 | ||
455 | switch(vtxMode) { | |
456 | case 'H': | |
457 | printf(" ... from event header\n"); | |
458 | VtxFromHeader(outName,kFALSE,path); | |
459 | break; | |
460 | case 'S': | |
461 | printf(" ... from event header + smearing\n"); | |
462 | VtxFromHeader(outName,kTRUE); | |
463 | break; | |
464 | case 'P': | |
465 | printf(" ... z from pixels for pp/pA\n"); | |
466 | ZvtxFromSPD(outName); | |
467 | break; | |
468 | case 'T': | |
469 | printf(" ... from tracks for pp/pA\n"); | |
470 | VtxFromTracks(outName); | |
471 | break; | |
472 | case 'C': | |
473 | Char_t fvertex[1024]; | |
474 | sprintf(fvertex,"%s/Vtx4Tracking.root",path); | |
475 | printf(" ... copied from Vtx4Tracking.root to AliITStracksV2.root\n"); | |
476 | CopyVtx(fvertex,outName); | |
477 | break; | |
478 | } | |
479 | ||
480 | gBenchmark->Stop(name); | |
481 | gBenchmark->Show(name); | |
482 | ||
483 | return; | |
484 | } | |
485 | //----------------------------------------------------------------------------- | |
486 | void TPCParamTracks(Int_t coll,Double_t Bfield,Char_t* path="./") { | |
487 | ||
488 | printf("\n------------------------------------\n"); | |
489 | ||
490 | const Char_t *name="TPCParamTracks"; | |
491 | printf("\n %s\n",name); | |
492 | gBenchmark->Start(name); | |
493 | ||
494 | Char_t fparam[1024]; | |
495 | sprintf(fparam,"%s/AliTPCtracksParam.root",path); | |
496 | TFile *outFile=TFile::Open(fparam,"recreate"); | |
497 | Char_t falice[1024]; | |
498 | sprintf(falice,"%s/galice.root",path); | |
499 | TFile *inFile =TFile::Open(falice); | |
500 | ||
501 | AliTPCtrackerParam tracker(coll,Bfield,gNevents); | |
502 | tracker.BuildTPCtracks(inFile,outFile); | |
503 | ||
504 | delete gAlice; gAlice=0; | |
505 | ||
506 | inFile->Close(); | |
507 | outFile->Close(); | |
508 | ||
509 | gBenchmark->Stop(name); | |
510 | gBenchmark->Show(name); | |
511 | ||
512 | return; | |
513 | } | |
514 | //----------------------------------------------------------------------------- | |
515 | Int_t UpdateEvtsToSkip(const Char_t *logName,const Char_t *evtsName) { | |
516 | ||
517 | if(!gSystem->AccessPathName(logName,kFileExists)) { | |
518 | FILE *ifile = fopen(logName,"r"); | |
519 | Int_t lEvt=0,nCol=1; | |
520 | while(nCol>0) { | |
521 | nCol = fscanf(ifile,"%d",&lEvt); | |
522 | } | |
523 | fclose(ifile); | |
524 | if(lEvt==gNevents) { | |
525 | printf(" All events already reconstructed\n"); | |
526 | return 0; | |
527 | } else { | |
528 | FILE *ofile = fopen("evtsToSkip.dat","a"); | |
529 | fprintf(ofile,"%d\n",lEvt); | |
530 | fclose(ofile); | |
531 | } | |
532 | } else { | |
533 | printf("File itstracking.log not found\n"); | |
534 | } | |
535 | ||
536 | return 1; | |
537 | } | |
538 | //----------------------------------------------------------------------------- | |
539 | void VtxFromHeader(const Char_t *outName,Bool_t smear,Char_t* path="./") { | |
540 | ||
541 | TDatime t; | |
542 | UInt_t seed = t.Get(); | |
543 | gRandom->SetSeed(seed); | |
544 | ||
545 | Char_t falice[1024]; | |
546 | sprintf(falice,"%s/galice.root",path); | |
547 | TFile *galice = new TFile(falice); | |
548 | TFile *outFile = new TFile(outName,"update"); | |
549 | ||
550 | TDirectory *curdir; | |
551 | Double_t pos[3],sigma[3]; | |
552 | if(smear) { | |
553 | sigma[0]=15.e-4; | |
554 | sigma[1]=15.e-4; | |
555 | sigma[2]=10.e-4; | |
556 | } else { | |
557 | sigma[0]=0.; | |
558 | sigma[1]=0.; | |
559 | sigma[2]=0.; | |
560 | } | |
561 | Char_t vname[20]; | |
562 | ||
563 | galice->cd(); | |
564 | ||
565 | for(Int_t ev=0; ev<gNevents; ev++){ | |
566 | printf(" event %d\n",ev); | |
567 | sprintf(vname,"Vertex_%d",ev); | |
568 | TArrayF o = 0; | |
569 | o.Set(3); | |
570 | AliHeader* header = 0; | |
571 | TTree* treeE = (TTree*)gDirectory->Get("TE"); | |
572 | treeE->SetBranchAddress("Header",&header); | |
573 | treeE->GetEntry(ev); | |
574 | AliGenEventHeader* genHeader = header->GenEventHeader(); | |
575 | if(genHeader) { | |
576 | // get primary vertex position | |
577 | genHeader->PrimaryVertex(o); | |
578 | pos[0] = (Double_t)o[0]; | |
579 | pos[1] = (Double_t)o[1]; | |
580 | pos[2] = (Double_t)o[2]; | |
581 | ||
582 | if(smear) { | |
583 | pos[0] = gRandom->Gaus(pos[0],sigma[0]); | |
584 | pos[1] = gRandom->Gaus(pos[1],sigma[1]); | |
585 | pos[2] = gRandom->Gaus(pos[2],sigma[2]); | |
586 | } | |
587 | // create AliITSVertex | |
588 | AliITSVertex *vertex = new AliITSVertex(pos,sigma,vname); | |
589 | } else { | |
590 | printf(" ! event header not found : setting vertex to (0,0,0) !"); | |
591 | pos[0] = 0.; | |
592 | pos[1] = 0.; | |
593 | pos[2] = 0.; | |
594 | // create AliITSVertex | |
595 | AliITSVertex *vertex = new AliITSVertex(pos,sigma,vname); | |
596 | } | |
597 | delete header; | |
598 | // write AliITSVertex to file | |
599 | curdir = gDirectory; | |
600 | outFile->cd(); | |
601 | if(smear) { | |
602 | vertex->SetTitle("vertex from header, smeared"); | |
603 | } else { | |
604 | vertex->SetTitle("vertex from header"); | |
605 | } | |
606 | vertex->Write(); | |
607 | curdir->cd(); | |
608 | vertex = 0; | |
609 | } | |
610 | ||
611 | outFile->Close(); | |
612 | galice->Close(); | |
613 | ||
614 | delete outFile; | |
615 | delete galice; | |
616 | ||
617 | return; | |
618 | } | |
619 | //----------------------------------------------------------------------------- | |
620 | void VtxFromTracks(const Char_t *outName,Char_t* path="./") { | |
621 | ||
622 | // Open input and output files | |
623 | Char_t ftrack[1024]; | |
624 | sprintf(ftrack,"%s/AliITStracksV2.root",path); | |
625 | TFile *inFile = new TFile(ftrack); | |
626 | TFile *outFile = new TFile(outName,"update"); | |
627 | ||
628 | // set AliRun object to 0 | |
629 | if(gAlice) gAlice = 0; | |
630 | ||
631 | // Create vertexer | |
632 | AliITSVertexerTracks *vertexer = | |
633 | new AliITSVertexerTracks(inFile,outFile,gBfieldValue); | |
634 | vertexer->SetFirstEvent(0); | |
635 | vertexer->SetLastEvent(gNevents-1); | |
636 | vertexer->SetDebug(0); | |
637 | vertexer->PrintStatus(); | |
638 | // Find vertices | |
639 | vertexer->FindVertices(); | |
640 | ||
641 | delete vertexer; | |
642 | ||
643 | inFile->Close(); | |
644 | outFile->Close(); | |
645 | delete inFile; | |
646 | delete outFile; | |
647 | ||
648 | return; | |
649 | } | |
650 | //----------------------------------------------------------------------------- | |
651 | void ZvtxFromSPD(const Char_t *outName,Char_t* path="./") { | |
652 | ||
653 | // create fast RecPoints, which are used for vertex finding | |
654 | cerr<<"Fast AliITSRecPoint(s) !\n"; | |
655 | gROOT->LoadMacro("$(ALICE_ROOT)/ITS/AliITSHits2FastRecPoints.C"); | |
656 | AliITSHits2FastRecPoints(0,gNevents-1); | |
657 | ||
658 | // delphi ---> azimuthal range to accept tracklets | |
659 | // window ---> window in Z around the peak of tracklets proj. in mm | |
660 | Float_t delphi=0.05; | |
661 | Float_t window=3.; | |
662 | Float_t initx=0.; | |
663 | Float_t inity=0.; | |
664 | ||
665 | Char_t falice[1024]; | |
666 | sprintf(falice,"%s/galice.root",path); | |
667 | TFile *infile = new TFile(falice); | |
668 | TFile *outfile = new TFile(outName,"update"); | |
669 | ||
670 | AliITSVertexerPPZ *vertexer = new AliITSVertexerPPZ(infile,outfile,initx,inity); | |
671 | vertexer->SetFirstEvent(0); | |
672 | vertexer->SetLastEvent(gNevents-1); | |
673 | vertexer->SetDebug(0); | |
674 | vertexer->SetDiffPhiMax(delphi); | |
675 | vertexer->SetWindow(window); | |
676 | vertexer->PrintStatus(); | |
677 | vertexer->FindVertices(); | |
678 | delete vertexer; | |
679 | vertexer=0; | |
680 | ||
681 | outfile->Close(); | |
682 | infile->Close(); | |
683 | delete infile; | |
684 | delete outfile; | |
685 | ||
686 | ||
687 | return; | |
688 | } | |
689 | //----------------------------------------------------------------------------- | |
690 | ||
691 | ||
692 | ||
693 | ||
694 | ||
695 | ||
696 | ||
697 | ||
698 |