]>
Commit | Line | Data |
---|---|---|
88cb7938 | 1 | #ifndef __MAKECINT__ |
2 | #ifndef __CINT__ | |
3 | #include <TROOT.h> | |
4 | #include <TRint.h> | |
5 | #include <TMath.h> | |
6 | #include <TRandom.h> | |
7 | #include <TVector.h> | |
8 | #include <TMatrix.h> | |
9 | #include <TGeometry.h> | |
10 | #include <TNode.h> | |
11 | #include <TTUBS.h> | |
12 | #include <TObjectTable.h> | |
13 | #include <iostream.h> | |
14 | #include <fstream.h> | |
15 | #include "AliMC.h" | |
16 | #include <TFile.h> | |
17 | #include <TStyle.h> | |
18 | #include <TCanvas.h> | |
19 | #include <TPad.h> | |
20 | #include <TLine.h> | |
21 | #include <TText.h> | |
22 | #include <TTree.h> | |
23 | #include <TBranch.h> | |
24 | #include "AliModule.h" | |
25 | #include "AliRunLoader.h" | |
26 | #include "AliHeader.h" | |
27 | #include "AliDetector.h" | |
28 | #include "AliConfig.h" | |
29 | #include "AliRun.h" | |
30 | #include "AliRunLoader.h" | |
31 | #include <TParticle.h> | |
32 | #include "TBranchClones.h" | |
33 | #include "TBranchElement.h" | |
34 | ||
35 | #include "PHOS/AliPHOSClusterizerv1.h" | |
36 | #include "PHOS/AliPHOSDigitizer.h" | |
37 | #include "PHOS/AliPHOSSDigitizer.h" | |
38 | #include "PHOS/AliPHOSTrackSegmentMakerv1.h" | |
39 | #include "PHOS/AliPHOSPIDv1.h" | |
40 | ||
41 | #endif | |
42 | #endif | |
43 | ||
44 | void ConvertPHOSToNewIO(const char* name = "galice.root", TString branch ="Event" ) | |
45 | { | |
46 | // AliLoader::SetDebug(); | |
47 | AliConfig* conf = AliConfig::Instance(); | |
48 | TClass* detclass = AliDetector::Class(); | |
49 | void * pbuf[100]; | |
50 | TBranch* branches[100]; | |
51 | Int_t nbranches = 0; | |
52 | // AliLoader::SetDebug(5); | |
53 | AliRunLoader* rl = AliRunLoader::Open("galiceNewIO.root",branch,"recreate"); | |
54 | rl->SetCompressionLevel(2); | |
55 | rl->SetNumberOfEventsPerFile(1000); | |
56 | ||
57 | AliRun* outAliRun; | |
58 | ||
59 | if (gAlice == 0x0) | |
60 | { | |
61 | outAliRun = new AliRun("OutgAlice","Output gAlice"); | |
62 | } | |
63 | else | |
64 | { | |
65 | outAliRun = gAlice; | |
66 | } | |
67 | gAlice = 0x0; | |
68 | ||
69 | outAliRun->SetRunLoader(rl); | |
70 | TString fSdig = "PHOS.SDigits."+branch+".root"; | |
71 | TString fDig = "PHOS.Digits."+branch+".root"; | |
72 | TString fRec = "PHOS.RecData."+branch+".root"; | |
73 | ||
74 | TFile* insdfile = TFile::Open(fSdig); | |
75 | TFile* indigfile = TFile::Open(fDig); | |
76 | TFile* inrecfile = TFile::Open(fRec); | |
77 | TFile* infile = TFile::Open(name); | |
78 | ||
79 | if (infile == 0x0) | |
80 | { | |
81 | ::Error("ConvertToNewIO.C","Can not open input file %s",name); | |
82 | return; | |
83 | } | |
84 | ||
85 | AliRun* inAliRun = (AliRun*)infile->Get("gAlice"); | |
86 | ||
87 | if(inAliRun == 0x0) | |
88 | { | |
89 | ::Error("ConvertToNewIO.C","Can not find gAlice in input file"); | |
90 | return; | |
91 | } | |
92 | gAlice = inAliRun; | |
93 | ||
94 | TObjArray* modules = inAliRun->Modules(); | |
95 | if (modules == 0x0) | |
96 | { | |
97 | ::Error("ConvertToNewIO.C","Can not get array with modules from AliRun"); | |
98 | return; | |
99 | } | |
100 | TIter next(modules); | |
101 | AliModule* module; | |
102 | while ((module = (AliModule*)next())) | |
103 | { | |
104 | outAliRun->AddModule(module); | |
105 | ||
106 | TClass* modclass = module->IsA(); | |
107 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
108 | if (det) | |
109 | { | |
110 | ////::Info("ConvertToNewIO.C"," Adding %s to RL.",det->GetName()); | |
111 | conf->Add(det,branch); | |
112 | rl->AddLoader(det); | |
113 | } | |
114 | } | |
115 | ||
116 | TParticle* particleBuffer = new TParticle(); | |
117 | /***************************************************/ | |
118 | /**** Event to Event **************/ | |
119 | /***************************************************/ | |
120 | ||
121 | TTree* treeE = (TTree*)infile->Get("TE"); | |
122 | ||
123 | if (treeE == 0x0) | |
124 | { | |
125 | ::Error("ConvertToNewIO.C","Can not get TreeE from AliRun"); | |
126 | return; | |
127 | } | |
128 | rl->MakeTree("E"); | |
129 | ||
130 | AliHeader* inheader = new AliHeader(); | |
131 | treeE->SetBranchAddress("Header",&inheader); | |
132 | ||
133 | Int_t nevents = (Int_t)treeE->GetEntries(); | |
134 | for (Int_t i = 0; i<nevents; i++) | |
135 | { | |
136 | ::Info("ConvertToNewIO.C","Converting Event %d.",i); | |
137 | rl->SetEventNumber(i); | |
138 | treeE->GetEvent(i); | |
139 | /*****************************************/ | |
140 | /* H E A D E R */ | |
141 | /*****************************************/ | |
142 | ||
143 | ////::Info("ConvertToNewIO.C","Copying Header"); | |
144 | AliHeader* outheader = rl->GetHeader(); | |
145 | ||
146 | outheader->SetEvent(inheader->GetEvent()); | |
147 | outheader->SetNvertex(inheader->GetNvertex()); | |
148 | outheader->SetNprimary(inheader->GetNprimary()); | |
149 | outheader->SetNtrack(inheader->GetNtrack()); | |
150 | outheader->SetRun(inheader->GetRun()); | |
151 | outheader->SetEventNrInRun(inheader->GetEventNrInRun()); | |
152 | outheader->SetStack(inheader->Stack()); | |
153 | outheader->SetGenEventHeader(inheader->GenEventHeader()); | |
154 | rl->TreeE()->Fill(); | |
155 | rl->SetNumberOfEventsPerFile(1000); | |
156 | /*****************************************/ | |
157 | /* K I N E M A T I C S */ | |
158 | /*****************************************/ | |
159 | ////::Info("ConvertToNewIO.C","Copying Kinematics."); | |
160 | TString treeKname("TreeK"); | |
161 | treeKname+=i; | |
162 | TTree* treeK = (TTree*)infile->Get(treeKname); | |
163 | if (treeK) | |
164 | { | |
165 | if (treeK->GetEntries() > 0) | |
166 | { | |
167 | //I do this gimnastics to set directory correctly, without changing NewIO code | |
168 | //only for this purpose | |
169 | rl->SetNumberOfEventsPerFile(1000); | |
170 | rl->LoadKinematics("update"); | |
171 | rl->MakeTree("K"); | |
172 | rl->GetEventFolder()->Remove(rl->TreeK()); | |
173 | delete rl->TreeK(); | |
174 | ||
175 | treeK->SetBranchAddress("Particles",&particleBuffer); | |
176 | ////::Info("ConvertToNewIO.C","Cloning TreeK ..."); | |
177 | TTree* tk = treeK->CloneTree(); | |
178 | ////::Info("ConvertToNewIO.C","Cloning TreeK ... Done"); | |
179 | tk->SetName(AliRunLoader::fgkKineContainerName); | |
180 | rl->GetEventFolder()->Add(tk); | |
181 | rl->WriteKinematics("OVERWRITE"); | |
182 | rl->UnloadKinematics(); | |
183 | } | |
184 | else | |
185 | { | |
186 | Info("ConvertToNewIO.C","Kinematics Tree is Empty"); | |
187 | } | |
188 | } | |
189 | else | |
190 | { | |
191 | Error("ConvertToNewIO.C","Could not find Kinematics tree named %s",treeKname.Data()); | |
192 | } | |
193 | delete treeK; | |
194 | /*****************************************/ | |
195 | /* T R A C K R E F E R E N C E S */ | |
196 | /*****************************************/ | |
197 | ////::Info("ConvertToNewIO.C","Copying Track Refs."); | |
198 | TString treeTRname("TreeTR"); | |
199 | treeTRname+=i; | |
200 | TTree* treeTR = (TTree*)infile->Get(treeTRname); | |
201 | if (treeTR) | |
202 | { | |
203 | if (treeTR->GetEntries() > 0) | |
204 | { | |
205 | next.Reset(); | |
206 | while ((module = (AliModule*)next())) | |
207 | { | |
208 | TClass* modclass = module->IsA(); | |
209 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
210 | if (det) | |
211 | { | |
212 | TClonesArray* trbuffer = new TClonesArray("AliTrackReference", 100); | |
213 | treeTR->SetBranchAddress(det->GetName(),&trbuffer); | |
214 | } | |
215 | } | |
216 | ||
217 | //I do this gimnastics to set directory correctly, without changing NewIO code | |
218 | //only for this purpose | |
219 | rl->SetNumberOfEventsPerFile(1000); | |
220 | rl->LoadTrackRefs("update"); | |
221 | rl->MakeTrackRefsContainer(); | |
222 | rl->GetEventFolder()->Remove(rl->TreeTR()); | |
223 | delete rl->TreeTR(); | |
224 | ||
225 | ////::Info("ConvertToNewIO.C","Cloning TreeTR ..."); | |
226 | TTree* tr = treeTR->CloneTree(); | |
227 | ////::Info("ConvertToNewIO.C","Cloning TreeTR ... Done"); | |
228 | ||
229 | tr->SetName(AliRunLoader::fgkTrackRefsContainerName); | |
230 | rl->GetEventFolder()->Add(tr); | |
231 | rl->WriteTrackRefs("OVERWRITE"); | |
232 | rl->UnloadTrackRefs(); | |
233 | } | |
234 | else | |
235 | { | |
236 | Info("ConvertToNewIO.C","Track References Tree is Empty"); | |
237 | } | |
238 | } | |
239 | else | |
240 | { | |
241 | Error("ConvertToNewIO.C","Could not find Track Refs tree named %s",treeTRname.Data()); | |
242 | } | |
243 | delete treeTR; | |
244 | ||
245 | /*****************************************/ | |
246 | /* H I T S */ | |
247 | /*****************************************/ | |
248 | ////::Info("ConvertToNewIO.C","Copying Hits."); | |
249 | TString treeHname("TreeH"); | |
250 | treeHname+=i; | |
251 | TTree* treeH = (TTree*)infile->Get(treeHname); | |
252 | ||
253 | if (treeH) | |
254 | { | |
255 | if (treeH->GetEntries() > 0) | |
256 | { | |
257 | TObjArray* lob = treeH->GetListOfBranches(); | |
258 | TObjArray* loaders = new TObjArray(); | |
259 | TIter nextnewmodule(outAliRun->Modules()); | |
260 | ||
261 | while ((module = (AliModule*)nextnewmodule())) | |
262 | { | |
263 | TClass* modclass = module->IsA(); | |
264 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
265 | //TClonesArray* ca = 0; | |
266 | if (det) | |
267 | { | |
268 | AliLoader* loader = det->GetLoader(); | |
269 | if (loader == 0x0) | |
270 | { | |
271 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
272 | continue; | |
273 | } | |
274 | ||
275 | TString mask(det->GetName()); | |
276 | ||
277 | loader->LoadHits("update"); | |
278 | loader->MakeTree("H"); | |
279 | loaders->Add(loader); | |
280 | for(Int_t b=0; b<lob->GetEntries();b++) | |
281 | { | |
282 | TBranch* branch = (TBranch*)lob->At(b); | |
283 | TString bname(branch->GetName());// | |
284 | if ( bname.BeginsWith(det->GetName()) ) | |
285 | { | |
286 | ////::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
287 | ////::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
288 | TString contname(branch->GetClassName()); | |
289 | ||
290 | Int_t splitlvl = branch->GetSplitLevel(); | |
291 | // if (splitlvl) splitlvl = 99; | |
292 | ||
293 | if( contname.CompareTo("TClonesArray") == 0) | |
294 | { | |
295 | TBranchElement* belem = (TBranchElement*)branch; | |
296 | //::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
297 | ||
298 | TClonesArray *ca = new TClonesArray(belem->GetClonesName()); | |
299 | pbuf[nbranches] = ca; | |
300 | ||
301 | branch->SetAddress(&(pbuf[nbranches])); | |
302 | //::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
303 | ||
304 | //::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
305 | branches[nbranches] = loader->TreeH()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
306 | nbranches++; | |
307 | } | |
308 | else | |
309 | { | |
310 | //::Info("ConvertToNewIO.C","Class Nmme is %s",branch->GetClassName()); | |
311 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
312 | if (bcl == 0x0) | |
313 | { | |
314 | ::Error("ConvertToNewIO.C","Can not get TClass object of class named %s",branch->GetClassName()); | |
315 | continue; | |
316 | } | |
317 | pbuf[nbranches] = bcl->New(); | |
318 | //::Info("ConvertToNewIO.C","Dumping buffer:"); | |
319 | //((TObject*)pbuf[nbranches])->Dump(); | |
320 | //::Info("ConvertToNewIO.C","Setting Adress:"); | |
321 | branch->SetAddress(&(pbuf[nbranches])); | |
322 | //::Info("ConvertToNewIO.C","Creating branch SpliLvl = %d",splitlvl); | |
323 | branches[nbranches] =loader->TreeH()->Branch(branch->GetName(),branch->GetClassName(),&(pbuf[nbranches]),4000,splitlvl); | |
324 | nbranches++; | |
325 | } | |
326 | } | |
327 | }//loop over branches | |
328 | }//if module is detector | |
329 | }//while loop over modules | |
330 | Int_t nentr = (Int_t)treeH->GetEntries(); | |
331 | //::Info("ConvertToNewIO.C","Copying Hits . Number of entries %d ... ",nentr); | |
332 | ||
333 | ||
334 | Int_t nl = loaders->GetEntries(); | |
335 | for (Int_t e = 0; e < nentr; e++) | |
336 | { | |
337 | //printf("%d\n",e); | |
338 | treeH->GetEntry(e); | |
339 | ||
340 | for (Int_t l = 0; l < nbranches; l++) | |
341 | { | |
342 | //printf("Branch %d addr %#x\n",l,pbuf[l]); | |
343 | //printf("%s %#x \n", branches[l]->GetName(),pbuf[l]); | |
344 | branches[l]->SetAddress(&(pbuf[l])); | |
345 | } | |
346 | ||
347 | for (Int_t l = 0; l < nl; l++) | |
348 | { | |
349 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
350 | //printf("Filling %s\n",loader->GetName()); | |
351 | loader->TreeH()->Fill(); | |
352 | } | |
353 | #ifndef __MAKECINT__ | |
354 | #ifndef __CINT__ | |
355 | fflush(0); | |
356 | #endif | |
357 | #endif | |
358 | } | |
359 | ////printf("\n"); | |
360 | ||
361 | ////::Info("ConvertToNewIO.C","Copying Hits ... Done"); | |
362 | for (Int_t l = 0; l < nl; l++) | |
363 | { | |
364 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
365 | loader->WriteHits("OVERWRITE"); | |
366 | loader->UnloadHits(); | |
367 | } | |
368 | delete loaders; | |
369 | for (Int_t l = 0; l < nbranches; l++) | |
370 | { | |
371 | delete (TObject*)pbuf[l]; | |
372 | } | |
373 | nbranches = 0; | |
374 | } | |
375 | else //tree has any entries | |
376 | { | |
377 | Info("ConvertToNewIO.C","Hits Tree is Empty"); | |
378 | } | |
379 | } | |
380 | else //treeH | |
381 | { | |
382 | ::Warning("ConvertToNewIO.C","Could not get TreeH from in AliRun."); | |
383 | } | |
384 | delete treeH; | |
385 | ||
386 | /*****************************************/ | |
387 | /* S D i g i t s */ | |
388 | /*****************************************/ | |
389 | //::Info("ConvertToNewIO.C","Copying S Digits.\n\n\n"); | |
390 | TString treeSname("TreeS"); | |
391 | treeSname+=i; | |
392 | ||
393 | TTree* treeS = (TTree*)insdfile->Get(treeSname); | |
394 | if (treeS) | |
395 | { | |
396 | TObjArray* lob = treeS->GetListOfBranches(); | |
397 | TObjArray* loaders = new TObjArray(); | |
398 | TIter nextnewmodule(outAliRun->Modules()); | |
399 | ||
400 | while ((module = (AliModule*)nextnewmodule())) | |
401 | { | |
402 | TClass* modclass = module->IsA(); | |
403 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
404 | //TClonesArray* ca = 0; | |
405 | if (det) | |
406 | { | |
407 | AliLoader* loader = det->GetLoader(); | |
408 | if (loader == 0x0) | |
409 | { | |
410 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
411 | continue; | |
412 | } | |
413 | ||
414 | TString mask(det->GetName()); | |
415 | ||
416 | loader->LoadSDigits("update"); | |
417 | loader->MakeTree("S"); | |
418 | loaders->Add(loader); | |
419 | for(Int_t b=0; b<lob->GetEntries();b++) | |
420 | { | |
421 | TBranch* branch = (TBranch*)lob->At(b); | |
422 | ||
423 | TString bname(branch->GetName());// | |
424 | if ( bname.BeginsWith(det->GetName()) ) | |
425 | { | |
426 | ||
427 | ////::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
428 | ////::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
429 | TString contname(branch->GetClassName()); | |
430 | ||
431 | Int_t splitlvl = branch->GetSplitLevel(); | |
432 | // if (splitlvl) splitlvl = 99; | |
433 | ||
434 | if ( contname.CompareTo("TClonesArray") == 0) | |
435 | { | |
436 | TBranchElement* belem = (TBranchElement*)branch; | |
437 | //::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
438 | ||
439 | TClonesArray * ca = new TClonesArray(belem->GetClonesName()); | |
440 | pbuf[nbranches] = ca; | |
441 | ||
442 | branch->SetAddress(&(pbuf[nbranches])); | |
443 | //::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
444 | ||
445 | //::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
446 | branches[nbranches] = loader->TreeS()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
447 | nbranches++; | |
448 | } | |
449 | else | |
450 | { | |
451 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
452 | pbuf[nbranches] = bcl->New(); | |
453 | //::Info("ConvertToNewIO.C","Dumping buffer:"); | |
454 | //((TObject*)pbuf[nbranches])->Dump(); | |
455 | //::Info("ConvertToNewIO.C","Setting Adress:"); | |
456 | branch->SetAddress(&(pbuf[nbranches])); | |
457 | //::Info("ConvertToNewIO.C","Creating branch SpliLvl = %d",splitlvl); | |
458 | branches[nbranches] =loader->TreeS()->Branch(branch->GetName(),branch->GetClassName(),&(pbuf[nbranches]),4000,splitlvl); | |
459 | nbranches++; | |
460 | } | |
461 | } | |
462 | }//loop over branches | |
463 | }//if module is detector | |
464 | }//while loop over modules | |
465 | TBranch* bbb = treeS->GetBranch("PHOS"); | |
466 | Int_t nentr = (Int_t)bbb->GetEntries(); | |
467 | ////::Info("ConvertToNewIO.C","Copying SDigits. Number of entries in PHSO branch %d ... ",nentr); | |
468 | ||
469 | Int_t nl = loaders->GetEntries(); | |
470 | for (Int_t e = 0; e < nentr; e++) | |
471 | { | |
472 | ////printf("%d\r",e); | |
473 | // treeS->GetEntry(e); | |
474 | bbb->GetEntry(e); | |
475 | ||
476 | for (Int_t l = 0; l < nbranches; l++) | |
477 | { | |
478 | // //printf("%s %#x \n", branches[l]->GetName(),pbuf[l]); | |
479 | branches[l]->SetAddress(&(pbuf[l])); | |
480 | } | |
481 | ||
482 | for (Int_t l = 0; l < nl; l++) | |
483 | { | |
484 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
485 | // //printf("Filling %s\n",loader->GetName()); | |
486 | loader->TreeS()->Fill(); | |
487 | } | |
488 | #ifndef __MAKECINT__ | |
489 | #ifndef __CINT__ | |
490 | fflush(0); | |
491 | #endif | |
492 | #endif | |
493 | } | |
494 | ////printf("\n"); | |
495 | ||
496 | ////::Info("ConvertToNewIO.C","Copying SDigits ... Done"); | |
497 | for (Int_t l = 0; l < nl; l++) | |
498 | { | |
499 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
500 | loader->WriteSDigits("OVERWRITE"); | |
501 | loader->UnloadSDigits(); | |
502 | } | |
503 | delete loaders; | |
504 | for (Int_t l = 0; l < nbranches; l++) | |
505 | { | |
506 | delete (TObject*)pbuf[l]; | |
507 | } | |
508 | nbranches = 0; | |
509 | ||
510 | } | |
511 | else //treeS | |
512 | { | |
513 | ::Warning("ConvertToNewIO.C","Could not get TreeS from in AliRun."); | |
514 | } | |
515 | delete treeS; | |
516 | ||
517 | /*****************************************/ | |
518 | /* D i g i t s */ | |
519 | /*****************************************/ | |
520 | //::Info("ConvertToNewIO.C","Copying Digits.\n\n\n"); | |
521 | TString treeDname("TreeD"); | |
522 | treeDname+=i; | |
523 | ||
524 | TTree* treeD = (TTree*)indigfile->Get(treeDname); | |
525 | if (treeD) | |
526 | { | |
527 | TObjArray* lob = treeD->GetListOfBranches(); | |
528 | TObjArray* loaders = new TObjArray(); | |
529 | TIter nextnewmodule(outAliRun->Modules()); | |
530 | ||
531 | while ((module = (AliModule*)nextnewmodule())) | |
532 | { | |
533 | TClass* modclass = module->IsA(); | |
534 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
535 | //TClonesArray* ca = 0; | |
536 | if (det) | |
537 | { | |
538 | AliLoader* loader = det->GetLoader(); | |
539 | if (loader == 0x0) | |
540 | { | |
541 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
542 | continue; | |
543 | } | |
544 | ||
545 | TString mask(det->GetName()); | |
546 | ||
547 | loader->LoadDigits("update"); | |
548 | loader->MakeTree("D"); | |
549 | loaders->Add(loader); | |
550 | for(Int_t b=0; b<lob->GetEntries();b++) | |
551 | { | |
552 | TBranch* branch = (TBranch*)lob->At(b); | |
553 | ||
554 | TString bname(branch->GetName());// | |
555 | if ( bname.BeginsWith(det->GetName()) ) | |
556 | { | |
557 | ||
558 | ////::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
559 | ////::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
560 | TString contname(branch->GetClassName()); | |
561 | ||
562 | Int_t splitlvl = branch->GetSplitLevel(); | |
563 | // if (splitlvl) splitlvl = 99; | |
564 | ||
565 | if ( contname.CompareTo("TClonesArray") == 0) | |
566 | { | |
567 | TBranchElement* belem = (TBranchElement*)branch; | |
568 | ////::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
569 | ||
570 | TClonesArray * ca = new TClonesArray(belem->GetClonesName()); | |
571 | pbuf[nbranches] = ca; | |
572 | ||
573 | branch->SetAddress(&(pbuf[nbranches])); | |
574 | ////::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
575 | ||
576 | ////::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
577 | branches[nbranches] = loader->TreeD()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
578 | nbranches++; | |
579 | } | |
580 | else | |
581 | { | |
582 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
583 | pbuf[nbranches] = bcl->New(); | |
584 | ////::Info("ConvertToNewIO.C","Dumping buffer:"); | |
585 | //((TObject*)pbuf[nbranches])->Dump(); | |
586 | ////::Info("ConvertToNewIO.C","Setting Adress:"); | |
587 | branch->SetAddress(&(pbuf[nbranches])); | |
588 | ////::Info("ConvertToNewIO.C","Creating branch SpliLvl = %d",splitlvl); | |
589 | branches[nbranches] =loader->TreeD()->Branch(branch->GetName(),branch->GetClassName(),&(pbuf[nbranches]),4000,splitlvl); | |
590 | nbranches++; | |
591 | } | |
592 | } | |
593 | }//loop over branches | |
594 | }//if module is detector | |
595 | }//while loop over modules | |
596 | TBranch* bbb = treeD->GetBranch("PHOS"); | |
597 | Int_t nentr = (Int_t)bbb->GetEntries(); | |
598 | ////::Info("ConvertToNewIO.C","Copying Digits. Number of entries %d ... ",nentr); | |
599 | ||
600 | Int_t nl = loaders->GetEntries(); | |
601 | for (Int_t e = 0; e < nentr; e++) | |
602 | { | |
603 | ////printf("%d\r",e); | |
604 | //treeD->GetEntry(e); | |
605 | bbb->GetEntry(e); | |
606 | ||
607 | for (Int_t l = 0; l < nbranches; l++) | |
608 | { | |
609 | // //printf("%s %#x \n", branches[l]->GetName(),pbuf[l]); | |
610 | branches[l]->SetAddress(&(pbuf[l])); | |
611 | } | |
612 | ||
613 | for (Int_t l = 0; l < nl; l++) | |
614 | { | |
615 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
616 | // //printf("Filling %s\n",loader->GetName()); | |
617 | loader->TreeD()->Fill(); | |
618 | } | |
619 | #ifndef __MAKECINT__ | |
620 | #ifndef __CINT__ | |
621 | fflush(0); | |
622 | #endif | |
623 | #endif | |
624 | } | |
625 | ////printf("\n"); | |
626 | ||
627 | ////::Info("ConvertToNewIO.C","Copying Digits ... Done"); | |
628 | for (Int_t l = 0; l < nl; l++) | |
629 | { | |
630 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
631 | loader->WriteDigits("OVERWRITE"); | |
632 | loader->UnloadDigits(); | |
633 | } | |
634 | delete loaders; | |
635 | for (Int_t l = 0; l < nbranches; l++) | |
636 | { | |
637 | delete (TObject*)pbuf[l]; | |
638 | } | |
639 | nbranches = 0; | |
640 | } | |
641 | else //treeD | |
642 | { | |
643 | ::Warning("ConvertToNewIO.C","Could not get TreeD from in AliRun."); | |
644 | } | |
645 | delete treeD; | |
646 | ||
647 | ||
648 | /*****************************************/ | |
649 | /* R e c P o i n t s */ | |
650 | /*****************************************/ | |
651 | ////::Info("ConvertToNewIO.C","Copying RecPoints."); | |
652 | TString treeRname("TreeR"); | |
653 | treeRname+=i; | |
654 | ||
655 | TTree* treeR = (TTree*)inrecfile->Get(treeRname); | |
656 | if (treeR) | |
657 | { | |
658 | TObjArray* lob = treeR->GetListOfBranches(); | |
659 | TObjArray* loaders = new TObjArray(); | |
660 | TIter nextnewmodule(outAliRun->Modules()); | |
661 | ||
662 | while ((module = (AliModule*)nextnewmodule())) | |
663 | { | |
664 | TClass* modclass = module->IsA(); | |
665 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
666 | ||
667 | if (det) | |
668 | { | |
669 | AliLoader* loader = det->GetLoader(); | |
670 | if (loader == 0x0) | |
671 | { | |
672 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
673 | continue; | |
674 | } | |
675 | ||
676 | TString mask(det->GetName()); | |
677 | ||
678 | loader->LoadRecPoints("update"); | |
679 | loader->MakeTree("R"); | |
680 | loaders->Add(loader); | |
681 | for(Int_t b=0; b<lob->GetEntries();b++) | |
682 | { | |
683 | TBranch* branch = (TBranch*)lob->At(b); | |
684 | ||
685 | TString bname(branch->GetName());// | |
686 | if ( bname.Contains(det->GetName()) ) | |
687 | { | |
688 | if(bname.Contains("Emc")||bname.Contains("Cpv")) | |
689 | { | |
690 | ////::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
691 | ////::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
692 | TString contname(branch->GetClassName()); | |
693 | ||
694 | Int_t splitlvl = branch->GetSplitLevel(); | |
695 | // if (splitlvl) splitlvl = 99; | |
696 | ||
697 | if ( contname.CompareTo("TClonesArray") == 0) | |
698 | { | |
699 | TBranchElement* belem = (TBranchElement*)branch; | |
700 | ////::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
701 | ||
702 | TClonesArray * ca = new TClonesArray(belem->GetClonesName()); | |
703 | pbuf[nbranches] = ca; | |
704 | ||
705 | branch->SetAddress(&(pbuf[nbranches])); | |
706 | ////::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
707 | ||
708 | ////::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
709 | branches[nbranches] = loader->TreeR()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
710 | nbranches++; | |
711 | } | |
712 | else | |
713 | { | |
714 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
715 | pbuf[nbranches] = bcl->New(); | |
716 | ////::Info("ConvertToNewIO.C","Dumping buffer:"); | |
717 | //((TObject*)pbuf[nbranches])->Dump(); | |
718 | ////::Info("ConvertToNewIO.C","Setting Adress:"); | |
719 | branch->SetAddress(&(pbuf[nbranches])); | |
720 | ////::Info("ConvertToNewIO.C","Creating branch SpliLvl = %d",splitlvl); | |
721 | branches[nbranches] =loader->TreeR()->Branch(branch->GetName(),branch->GetClassName(),&(pbuf[nbranches]),4000,splitlvl); | |
722 | nbranches++; | |
723 | } | |
724 | } | |
725 | } | |
726 | }//loop over branches | |
727 | }//if module is detector | |
728 | }//while loop over modules | |
729 | TBranch* bbb = treeR->GetBranch("PHOSEmcRP"); | |
730 | Int_t nentr = (Int_t)bbb->GetEntries(); | |
731 | ////::Info("ConvertToNewIO.C","Copying RecPoints. Number of entries %d ... ",nentr); | |
732 | ||
733 | ||
734 | //Int_t nl = loaders->GetEntries(); | |
735 | // //printf(">>>>>>>>>>>>>>>>>>>>%d\n",nl); | |
736 | bbb->SetAddress(&(pbuf[0])); | |
737 | ||
738 | for (Int_t e = 0; e < nentr; e++) | |
739 | { | |
740 | ////printf("%d\r",e); | |
741 | ||
742 | bbb->GetEntry(e); | |
743 | AliLoader* loader = (AliLoader*)loaders->At(0); | |
744 | ||
745 | TBranch* bbb = treeR->GetBranch("PHOSCpvRP"); | |
746 | Int_t nentr = (Int_t)bbb->GetEntries(); | |
747 | ////::Info("ConvertToNewIO.C","Copying RecPoints. Number of entries %d ... ",nentr); | |
748 | ||
749 | bbb->SetAddress(&(pbuf[1])); | |
750 | ||
751 | for (Int_t e = 0; e < nentr; e++) | |
752 | { | |
753 | // //printf("%d\r",e); | |
754 | bbb->GetEntry(e); | |
755 | // AliLoader* loader = (AliLoader*)loaders->At(0); | |
756 | } | |
757 | ////printf("Filling %s\n",loader->GetName()); | |
758 | loader->TreeR()->Fill(); | |
759 | ||
760 | #ifndef __MAKECINT__ | |
761 | #ifndef __CINT__ | |
762 | fflush(0); | |
763 | #endif | |
764 | #endif | |
765 | } | |
766 | ////printf("\n"); | |
767 | ||
768 | ||
769 | ////::Info("ConvertToNewIO.C","Copying RecPoints ... Done"); | |
770 | Int_t nl = loaders->GetEntries(); | |
771 | for (Int_t l = 0; l < nl; l++) | |
772 | { | |
773 | ||
774 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
775 | loader->WriteRecPoints("OVERWRITE"); | |
776 | loader->UnloadRecPoints(); | |
777 | } | |
778 | delete loaders; | |
779 | for (Int_t l = 0; l < nbranches; l++) | |
780 | { | |
781 | delete (TObject*)pbuf[l];//delete branches buffers | |
782 | } | |
783 | nbranches = 0; | |
784 | ||
785 | } | |
786 | else //treeR | |
787 | { | |
788 | ::Warning("ConvertToNewIO.C","Could not get TreeR from in AliRun."); | |
789 | } | |
790 | delete treeR; | |
791 | ||
792 | /*****************************************/ | |
793 | /* Track Segments */ | |
794 | /*****************************************/ | |
795 | ////::Info("ConvertToNewIO.C","Copying Tracks."); | |
796 | TString treeTname("TreeR"); | |
797 | treeTname+=i; | |
798 | ||
799 | TTree* treeT = (TTree*)inrecfile->Get(treeTname); | |
800 | if (treeT) | |
801 | { | |
802 | TObjArray* lob = treeT->GetListOfBranches(); | |
803 | TObjArray* loaders = new TObjArray(); | |
804 | TIter nextnewmodule(outAliRun->Modules()); | |
805 | ||
806 | while ((module = (AliModule*)nextnewmodule())) | |
807 | { | |
808 | TClass* modclass = module->IsA(); | |
809 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
810 | //TClonesArray* ca = 0; | |
811 | if (det) | |
812 | { | |
813 | AliLoader* loader = det->GetLoader(); | |
814 | if (loader == 0x0) | |
815 | { | |
816 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
817 | continue; | |
818 | } | |
819 | ||
820 | TString mask(det->GetName()); | |
821 | ||
822 | loader->LoadTracks("update"); | |
823 | loader->MakeTree("T"); | |
824 | loaders->Add(loader); | |
825 | for(Int_t b=0; b<lob->GetEntries();b++) | |
826 | { | |
827 | TBranch* branch = (TBranch*)lob->At(b); | |
828 | ||
829 | TString bname(branch->GetName());// | |
830 | if ( bname.Contains(det->GetName()) ) | |
831 | { | |
832 | if(bname.Contains("TS")) | |
833 | { | |
834 | ////::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
835 | ////::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
836 | TString contname(branch->GetClassName()); | |
837 | ||
838 | Int_t splitlvl = branch->GetSplitLevel(); | |
839 | // if (splitlvl) splitlvl = 99; | |
840 | ||
841 | if ( contname.CompareTo("TClonesArray") == 0) | |
842 | { | |
843 | TBranchElement* belem = (TBranchElement*)branch; | |
844 | ////::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
845 | ||
846 | TClonesArray * ca = new TClonesArray(belem->GetClonesName()); | |
847 | pbuf[nbranches] = ca; | |
848 | ||
849 | branch->SetAddress(&(pbuf[nbranches])); | |
850 | ////::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
851 | ||
852 | ////::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
853 | branches[nbranches] = loader->TreeT()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
854 | nbranches++; | |
855 | } | |
856 | else | |
857 | { | |
858 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
859 | pbuf[nbranches] = bcl->New(); | |
860 | ////::Info("ConvertToNewIO.C","Dumping buffer:"); | |
861 | //((TObject*)pbuf[nbranches])->Dump(); | |
862 | ////::Info("ConvertToNewIO.C","Setting Adress:"); | |
863 | branch->SetAddress(&(pbuf[nbranches])); | |
864 | ////::Info("ConvertToNewIO.C","Creating branch SpliLvl = %d",splitlvl); | |
865 | branches[nbranches] =loader->TreeT()->Branch(branch->GetName(),branch->GetClassName(),&(pbuf[nbranches]),4000,splitlvl); | |
866 | nbranches++; | |
867 | } | |
868 | } | |
869 | } | |
870 | }//loop over branches | |
871 | }//if module is detector | |
872 | }//while loop over modules | |
873 | TBranch* bbb = treeT->GetBranch("PHOSTS"); | |
874 | Int_t nentr = (Int_t)bbb->GetEntries(); | |
875 | ////::Info("ConvertToNewIO.C","Copying Tracks. Number of entries %d ... ",nentr); | |
876 | ||
877 | ||
878 | Int_t nl = loaders->GetEntries(); | |
879 | for (Int_t e = 0; e < nentr; e++) | |
880 | { | |
881 | // //printf("%d\r",e); | |
882 | //bbb->GetEntry(e); | |
883 | //treeR->GetEntry(e); | |
884 | ||
885 | for (Int_t l = 0; l < nbranches; l++) | |
886 | { | |
887 | // //printf("%s %#x \n", branches[l]->GetName(),pbuf[l]); | |
888 | branches[l]->SetAddress(&(pbuf[l])); | |
889 | } | |
890 | bbb->GetEntry(e); | |
891 | for (Int_t l = 0; l < nl; l++) | |
892 | { | |
893 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
894 | ////printf("Filling %s\n",loader->GetName()); | |
895 | loader->TreeT()->Fill(); | |
896 | } | |
897 | ||
898 | ||
899 | #ifndef __MAKECINT__ | |
900 | #ifndef __CINT__ | |
901 | fflush(0); | |
902 | #endif | |
903 | #endif | |
904 | } | |
905 | ////printf("\n"); | |
906 | ||
907 | ////::Info("ConvertToNewIO.C","Copying Tracks ... Done"); | |
908 | for (Int_t l = 0; l < nl; l++) | |
909 | { | |
910 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
911 | loader->WriteTracks("OVERWRITE"); | |
912 | loader->UnloadTracks(); | |
913 | } | |
914 | delete loaders; | |
915 | for (Int_t l = 0; l < nbranches; l++) | |
916 | { | |
917 | delete (TObject*)pbuf[l];//delete branches buffers | |
918 | } | |
919 | nbranches = 0; | |
920 | ||
921 | } | |
922 | else //treeT | |
923 | { | |
924 | ::Warning("ConvertToNewIO.C","Could not get TreeR from in AliRun."); | |
925 | } | |
926 | delete treeT; | |
927 | ||
928 | ||
929 | ||
930 | ||
931 | ||
932 | /*****************************************/ | |
933 | /* Rec Particles */ | |
934 | /*****************************************/ | |
935 | ////::Info("ConvertToNewIO.C","Copying RecParticles."); | |
936 | TString treePname("TreeR"); | |
937 | treePname+=i; | |
938 | ||
939 | TTree* treeP = (TTree*)inrecfile->Get(treeTname); | |
940 | if (treeP) | |
941 | { | |
942 | TObjArray* lob = treeP->GetListOfBranches(); | |
943 | TObjArray* loaders = new TObjArray(); | |
944 | TIter nextnewmodule(outAliRun->Modules()); | |
945 | ||
946 | while ((module = (AliModule*)nextnewmodule())) | |
947 | { | |
948 | TClass* modclass = module->IsA(); | |
949 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
950 | //TClonesArray* ca = 0; | |
951 | if (det) | |
952 | { | |
953 | AliLoader* loader = det->GetLoader(); | |
954 | if (loader == 0x0) | |
955 | { | |
956 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
957 | continue; | |
958 | } | |
959 | ||
960 | TString mask(det->GetName()); | |
961 | ||
962 | loader->LoadRecParticles("update"); | |
963 | loader->MakeTree("P"); | |
964 | loaders->Add(loader); | |
965 | for(Int_t b=0; b<lob->GetEntries();b++) | |
966 | { | |
967 | TBranch* branch = (TBranch*)lob->At(b); | |
968 | ||
969 | TString bname(branch->GetName());// | |
970 | if ( bname.Contains(det->GetName()) ) | |
971 | { | |
972 | if(bname.Contains("PHOSRP")) | |
973 | { | |
974 | ////::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
975 | ////::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
976 | TString contname(branch->GetClassName()); | |
977 | ||
978 | Int_t splitlvl = branch->GetSplitLevel(); | |
979 | // if (splitlvl) splitlvl = 99; | |
980 | ||
981 | if ( contname.CompareTo("TClonesArray") == 0) | |
982 | { | |
983 | TBranchElement* belem = (TBranchElement*)branch; | |
984 | ////::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
985 | ||
986 | TClonesArray * ca = new TClonesArray(belem->GetClonesName()); | |
987 | pbuf[nbranches] = ca; | |
988 | ||
989 | branch->SetAddress(&(pbuf[nbranches])); | |
990 | ////::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
991 | ||
992 | ////::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
993 | branches[nbranches] = loader->TreeP()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
994 | nbranches++; | |
995 | } | |
996 | else | |
997 | { | |
998 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
999 | pbuf[nbranches] = bcl->New(); | |
1000 | ////::Info("ConvertToNewIO.C","Dumping buffer:"); | |
1001 | //((TObject*)pbuf[nbranches])->Dump(); | |
1002 | ////::Info("ConvertToNewIO.C","Setting Adress:"); | |
1003 | branch->SetAddress(&(pbuf[nbranches])); | |
1004 | ////::Info("ConvertToNewIO.C","Creating branch SpliLvl = %d",splitlvl); | |
1005 | branches[nbranches] =loader->TreeP()->Branch(branch->GetName(),branch->GetClassName(),&(pbuf[nbranches]),4000,splitlvl); | |
1006 | nbranches++; | |
1007 | } | |
1008 | } | |
1009 | } | |
1010 | }//loop over branches | |
1011 | }//if module is detector | |
1012 | }//while loop over modules | |
1013 | TBranch* bbb = treeP->GetBranch("PHOSRP"); | |
1014 | Int_t nentr = (Int_t)bbb->GetEntries(); | |
1015 | ////::Info("ConvertToNewIO.C","Copying RecParticles. Number of entries %d ... ",nentr); | |
1016 | ||
1017 | ||
1018 | Int_t nl = loaders->GetEntries(); | |
1019 | for (Int_t e = 0; e < nentr; e++) | |
1020 | { | |
1021 | ////printf("%d\r",e); | |
1022 | bbb->GetEntry(e); | |
1023 | //treeR->GetEntry(e); | |
1024 | ||
1025 | for (Int_t l = 0; l < nbranches; l++) | |
1026 | { | |
1027 | // //printf("%s %#x \n", branches[l]->GetName(),pbuf[l]); | |
1028 | branches[l]->SetAddress(&(pbuf[l])); | |
1029 | } | |
1030 | ||
1031 | for (Int_t l = 0; l < nl; l++) | |
1032 | { | |
1033 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
1034 | ////printf("Filling %s\n",loader->GetName()); | |
1035 | loader->TreeP()->Fill(); | |
1036 | } | |
1037 | ||
1038 | ||
1039 | #ifndef __MAKECINT__ | |
1040 | #ifndef __CINT__ | |
1041 | fflush(0); | |
1042 | #endif | |
1043 | #endif | |
1044 | } | |
1045 | ////printf("\n"); | |
1046 | ||
1047 | ////::Info("ConvertToNewIO.C","Copying RecParticles ... Done"); | |
1048 | for (Int_t l = 0; l < nl; l++) | |
1049 | { | |
1050 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
1051 | loader->WriteRecParticles("OVERWRITE"); | |
1052 | loader->UnloadRecParticles(); | |
1053 | } | |
1054 | delete loaders; | |
1055 | for (Int_t l = 0; l < nbranches; l++) | |
1056 | { | |
1057 | delete (TObject*)pbuf[l];//delete branches buffers | |
1058 | } | |
1059 | nbranches = 0; | |
1060 | ||
1061 | } | |
1062 | else //treeP | |
1063 | { | |
1064 | ::Warning("ConvertToNewIO.C","Could not get TreeR from in AliRun."); | |
1065 | } | |
1066 | delete treeP; | |
1067 | ||
1068 | ||
1069 | ||
1070 | }//end of loop over events | |
1071 | /***************************************************/ | |
1072 | /**** Write Tasks *************/ | |
1073 | /***************************************************/ | |
1074 | ||
1075 | AliLoader * loader = rl->GetLoader("PHOSLoader"); | |
1076 | /**** S Digits *************/ | |
1077 | TTree * s = (TTree*)insdfile->Get("TreeS0"); | |
1078 | TBranch * bsd = s->GetBranch("AliPHOSSDigitizer"); | |
1079 | AliPHOSSDigitizer * sdig = 0; | |
1080 | bsd->SetAddress(&sdig); | |
1081 | bsd->GetEntry(0) ; | |
1082 | sdig->SetEventFolderName(sdig->GetName()) ; | |
1083 | sdig->SetName("PHOSSDigitizer"); | |
1084 | sdig->Print() ; | |
1085 | TFile fsd(loader->GetSDigitsFileName(), "update") ; | |
1086 | sdig->Write() ; | |
1087 | fsd.Print() ; | |
1088 | fsd.Close() ; | |
1089 | delete s ; | |
1090 | ||
1091 | /**** Digits *************/ | |
1092 | TTree * d = (TTree*)indigfile->Get("TreeD0"); | |
1093 | TBranch * bd = d->GetBranch("AliPHOSDigitizer"); | |
1094 | AliPHOSDigitizer * dig = 0 ; | |
1095 | bd->SetAddress(&dig) ; | |
1096 | bd->GetEntry(0) ; | |
1097 | dig->SetEventFolderName(dig->GetName()) ; | |
1098 | dig->SetName("PHOSDigitizer"); | |
1099 | dig->Print() ; | |
1100 | //dig->Dump() ; | |
1101 | ////::Info("Digitizer","Print done"); | |
1102 | TFile fd(loader->GetDigitsFileName(), "update") ; | |
1103 | dig->Write() ; | |
1104 | fd.Print() ; | |
1105 | fd.Close() ; | |
1106 | delete d; | |
1107 | /**** Rec Data *************/ | |
1108 | TTree * t = (TTree*)inrecfile->Get("TreeR0"); | |
1109 | /**** Clusterizer *************/ | |
1110 | TBranch * bclu = t->GetBranch("AliPHOSClusterizer"); | |
1111 | AliPHOSClusterizerv1 * clu = 0; | |
1112 | bclu->SetAddress(&clu); | |
1113 | bclu->GetEntry(0) ; | |
1114 | clu->SetEventFolderName(clu->GetName()) ; | |
1115 | clu->SetName("PHOSReconstructioner"); | |
1116 | clu->Print() ; | |
1117 | TFile fclu(loader->GetRecPointsFileName(), "update") ; | |
1118 | clu->Write() ; | |
1119 | fclu.Print() ; | |
1120 | fclu.Close() ; | |
1121 | /**** TrackSegmentMaker *************/ | |
1122 | TBranch * btr = t->GetBranch("AliPHOSTrackSegmentMaker"); | |
1123 | AliPHOSTrackSegmentMakerv1 * tra = 0 ; | |
1124 | btr->SetAddress(&tra); | |
1125 | btr->GetEntry(0) ; | |
1126 | tra->SetEventFolderName(tra->GetName()) ; | |
1127 | tra->SetName("PHOSTracker"); | |
1128 | tra->Print() ; | |
1129 | TFile ftr(loader->GetTracksFileName(), "update") ; | |
1130 | tra->Write() ; | |
1131 | ftr.Print() ; | |
1132 | ftr.Close() ; | |
1133 | ||
1134 | /**** PID *************/ | |
1135 | ||
1136 | TBranch * bpid = t->GetBranch("AliPHOSPID"); | |
1137 | AliPHOSPIDv1 * pid = 0 ; | |
1138 | bpid->SetAddress(&pid); | |
1139 | bpid->GetEntry(0) ; | |
1140 | pid->SetEventFolderName(pid->GetName()) ; | |
1141 | pid->SetName("PHOSPIDTask"); | |
1142 | pid->Print() ; | |
1143 | TFile fpid(loader->GetRecParticlesFileName(), "update") ; | |
1144 | pid->Write() ; | |
1145 | fpid.Print() ; | |
1146 | fpid.Close() ; | |
1147 | delete t; | |
1148 | ||
1149 | ||
1150 | ||
1151 | /***************************************************/ | |
1152 | /**** Run to Run *************/ | |
1153 | /***************************************************/ | |
1154 | ||
1155 | rl->WriteHeader("OVERWRITE"); | |
1156 | ||
1157 | infile->cd(); | |
1158 | TGeometry* geo = inAliRun->GetGeometry(); | |
1159 | rl->CdGAFile(); | |
1160 | geo->Write(); | |
1161 | ||
1162 | rl->WriteAliRun(); | |
1163 | rl->WriteRunLoader(); | |
1164 | ||
1165 | ////::Info("ConvertToNewIO.C","Done"); | |
1166 | ||
1167 | } | |
1168 |