]>
Commit | Line | Data |
---|---|---|
88cb7938 | 1 | #ifndef __MAKECINT__ |
2 | #ifndef __CINT__ | |
3 | #include "alles.h" | |
4 | #include "TInterpreter.h" | |
5 | #include "TBranchClones.h" | |
6 | #include "TBranchElement.h" | |
7 | #include "AliTPCTrackHits.h" | |
8 | #include "AliTRDtrackHits.h" | |
9 | #endif | |
10 | #endif | |
11 | ||
12 | void ConvertToNewIO(const char* name) | |
13 | { | |
14 | // AliLoader::SetDebug(); | |
15 | AliConfig* conf = AliConfig::Instance(); | |
16 | TClass* detclass = AliDetector::Class(); | |
17 | void* buff; | |
18 | Bool_t skipit = kFALSE; | |
19 | void * pbuf[100]; | |
20 | TBranch* branches[100]; | |
21 | Int_t nbranches = 0; | |
22 | ||
23 | AliRunLoader* rl = AliRunLoader::Open("galiceNewIO.root","Event","recreate"); | |
24 | rl->SetCompressionLevel(2); | |
8eed56ee | 25 | rl->SetNumberOfEventsPerFile(100); |
26 | ||
88cb7938 | 27 | AliRun* outAliRun; |
28 | ||
29 | if (gAlice == 0x0) | |
30 | { | |
31 | outAliRun = new AliRun("OutgAlice","Output gAlice"); | |
32 | } | |
33 | else | |
34 | { | |
35 | outAliRun = gAlice; | |
36 | } | |
37 | gAlice = 0x0; | |
38 | ||
39 | outAliRun->SetRunLoader(rl); | |
40 | ||
41 | TFile* infile = TFile::Open(name); | |
42 | ||
43 | if (infile == 0x0) | |
44 | { | |
45 | ::Error("ConvertToNewIO.C","Can not open input file %s",name); | |
46 | return; | |
47 | } | |
48 | ||
49 | AliRun* inAliRun = (AliRun*)infile->Get("gAlice"); | |
50 | ||
51 | if(inAliRun == 0x0) | |
52 | { | |
53 | ::Error("ConvertToNewIO.C","Can not find gAlice in input file"); | |
54 | return; | |
55 | } | |
56 | gAlice = inAliRun; | |
57 | // inAliRun->GetEvent(0); | |
58 | ||
59 | TObjArray* modules = inAliRun->Modules(); | |
60 | if (modules == 0x0) | |
61 | { | |
62 | ::Error("ConvertToNewIO.C","Can not get array with modules from AliRun"); | |
63 | return; | |
64 | } | |
65 | TIter next(modules); | |
66 | AliModule* module; | |
8eed56ee | 67 | TObject * object; |
68 | while ((object = next())) | |
88cb7938 | 69 | { |
8eed56ee | 70 | module = dynamic_cast<AliModule*>(object); |
71 | if (module == 0x0) { | |
72 | ::Error("ConvertToNewIO.C","Can not cast module %#x ",object); | |
73 | object->Dump(); | |
74 | continue; | |
75 | } | |
76 | ||
88cb7938 | 77 | outAliRun->AddModule(module); |
78 | ||
79 | TClass* modclass = module->IsA(); | |
80 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
81 | if (det) | |
82 | { | |
83 | ::Info("ConvertToNewIO.C"," Adding %s to RL.",det->GetName()); | |
84 | conf->Add(det,"Event"); | |
85 | rl->AddLoader(det); | |
86 | } | |
87 | } | |
88 | ||
89 | TParticle* particleBuffer = new TParticle(); | |
90 | /***************************************************/ | |
91 | /**** Event to Event **************/ | |
92 | /***************************************************/ | |
93 | ||
94 | TTree* treeE = (TTree*)infile->Get("TE"); | |
95 | if (treeE == 0x0) | |
96 | { | |
97 | ::Error("ConvertToNewIO.C","Can not get TreeE from AliRun"); | |
98 | return; | |
99 | } | |
100 | rl->MakeTree("E"); | |
101 | ||
102 | AliHeader* inheader = new AliHeader(); | |
103 | treeE->SetBranchAddress("Header",&inheader); | |
104 | ||
105 | Int_t nevents = (Int_t)treeE->GetEntries(); | |
106 | for (Int_t i = 0; i<nevents; i++) | |
107 | { | |
108 | ::Info("ConvertToNewIO.C","Converting Event %d.",i); | |
109 | rl->SetEventNumber(i); | |
110 | treeE->GetEvent(i); | |
111 | /*****************************************/ | |
112 | /* H E A D E R */ | |
113 | /*****************************************/ | |
114 | ||
115 | ::Info("ConvertToNewIO.C","Copying Header"); | |
116 | AliHeader* outheader = rl->GetHeader(); | |
117 | ||
118 | ||
119 | outheader->SetEvent(inheader->GetEvent()); | |
120 | outheader->SetNvertex(inheader->GetNvertex()); | |
121 | outheader->SetNprimary(inheader->GetNprimary()); | |
122 | outheader->SetNtrack(inheader->GetNtrack()); | |
123 | outheader->SetRun(inheader->GetRun()); | |
124 | outheader->SetEventNrInRun(inheader->GetEventNrInRun()); | |
125 | outheader->SetStack(inheader->Stack()); | |
126 | outheader->SetGenEventHeader(inheader->GenEventHeader()); | |
127 | rl->TreeE()->Fill(); | |
128 | ||
129 | /*****************************************/ | |
130 | /* K I N E M A T I C S */ | |
131 | /*****************************************/ | |
132 | ::Info("ConvertToNewIO.C","Copying Kinematics."); | |
133 | TString treeKname("TreeK"); | |
134 | treeKname+=i; | |
135 | TTree* treeK = (TTree*)infile->Get(treeKname); | |
136 | if (treeK) | |
137 | { | |
138 | if (treeK->GetEntries() > 0) | |
139 | { | |
140 | //I do this gimnastics to set directory correctly, without changing NewIO code | |
141 | //only for this purpose | |
142 | rl->LoadKinematics("update"); | |
143 | rl->MakeTree("K"); | |
144 | rl->GetEventFolder()->Remove(rl->TreeK()); | |
145 | delete rl->TreeK(); | |
146 | ||
147 | treeK->SetBranchAddress("Particles",&particleBuffer); | |
148 | ::Info("ConvertToNewIO.C","Cloning TreeK ..."); | |
149 | TTree* tk = treeK->CloneTree(); | |
150 | ::Info("ConvertToNewIO.C","Cloning TreeK ... Done"); | |
151 | tk->SetName(AliRunLoader::fgkKineContainerName); | |
152 | rl->GetEventFolder()->Add(tk); | |
153 | rl->WriteKinematics("OVERWRITE"); | |
154 | rl->UnloadKinematics(); | |
155 | } | |
156 | else | |
157 | { | |
158 | Info("ConvertToNewIO.C","Kinematics Tree is Empty"); | |
159 | } | |
160 | } | |
161 | else | |
162 | { | |
163 | Error("ConvertToNewIO.C","Could not find Kinematics tree named %s",treeKname.Data()); | |
164 | } | |
165 | delete treeK; | |
166 | /*****************************************/ | |
167 | /* T R A C K R E F E R E N C E S */ | |
168 | /*****************************************/ | |
169 | ::Info("ConvertToNewIO.C","Copying Track Refs."); | |
170 | TString treeTRname("TreeTR"); | |
171 | treeTRname+=i; | |
172 | TTree* treeTR = (TTree*)infile->Get(treeTRname); | |
173 | if (treeTR) | |
174 | { | |
175 | if (treeTR->GetEntries() > 0) | |
176 | { | |
177 | next.Reset(); | |
8eed56ee | 178 | TObject * object; |
179 | while ((object = next())) | |
88cb7938 | 180 | { |
8eed56ee | 181 | module = dynamic_cast<AliModule*>(object); |
182 | if (module == 0x0) { | |
183 | ::Error("ConvertToNewIO.C","Can not cast module %#x ",object); | |
184 | object->Dump(); | |
185 | continue; | |
186 | } | |
88cb7938 | 187 | TClass* modclass = module->IsA(); |
188 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
189 | if (det) | |
190 | { | |
191 | TClonesArray* trbuffer = new TClonesArray("AliTrackReference", 100); | |
192 | treeTR->SetBranchAddress(det->GetName(),&trbuffer); | |
193 | } | |
194 | } | |
195 | ||
196 | //I do this gimnastics to set directory correctly, without changing NewIO code | |
197 | //only for this purpose | |
198 | rl->LoadTrackRefs("update"); | |
199 | rl->MakeTrackRefsContainer(); | |
200 | rl->GetEventFolder()->Remove(rl->TreeTR()); | |
201 | delete rl->TreeTR(); | |
202 | ||
203 | ::Info("ConvertToNewIO.C","Cloning TreeTR ..."); | |
204 | TTree* tr = treeTR->CloneTree(); | |
205 | ::Info("ConvertToNewIO.C","Cloning TreeTR ... Done"); | |
206 | ||
207 | tr->SetName(AliRunLoader::fgkTrackRefsContainerName); | |
208 | rl->GetEventFolder()->Add(tr); | |
209 | rl->WriteTrackRefs("OVERWRITE"); | |
210 | rl->UnloadTrackRefs(); | |
211 | } | |
212 | else | |
213 | { | |
214 | Info("ConvertToNewIO.C","Track References Tree is Empty"); | |
215 | } | |
216 | } | |
217 | else | |
218 | { | |
219 | Error("ConvertToNewIO.C","Could not find Track Refs tree named %s",treeTRname.Data()); | |
220 | } | |
221 | delete treeTR; | |
222 | ||
223 | /*****************************************/ | |
224 | /* H I T S */ | |
225 | /*****************************************/ | |
226 | ::Info("ConvertToNewIO.C","Copying Hits."); | |
227 | TString treeHname("TreeH"); | |
228 | treeHname+=i; | |
229 | TTree* treeH = (TTree*)infile->Get(treeHname); | |
230 | ||
231 | if (treeH) | |
232 | { | |
233 | if (treeH->GetEntries() > 0) | |
234 | { | |
235 | TObjArray* lob = treeH->GetListOfBranches(); | |
236 | TObjArray* loaders = new TObjArray(); | |
237 | TIter nextnewmodule(outAliRun->Modules()); | |
238 | ||
239 | while ((module = (AliModule*)nextnewmodule())) | |
240 | { | |
241 | TClass* modclass = module->IsA(); | |
242 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
243 | TClonesArray* ca = 0; | |
244 | if (det) | |
245 | { | |
246 | AliLoader* loader = det->GetLoader(); | |
247 | if (loader == 0x0) | |
248 | { | |
249 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
250 | continue; | |
251 | } | |
252 | ||
253 | TString mask(det->GetName()); | |
254 | ||
255 | loader->LoadHits("update"); | |
256 | loader->MakeTree("H"); | |
257 | loaders->Add(loader); | |
258 | for(Int_t b=0; b<lob->GetEntries();b++) | |
259 | { | |
260 | TBranch* branch = (TBranch*)lob->At(b); | |
261 | TString bname(branch->GetName());// | |
262 | if ( bname.BeginsWith(det->GetName()) ) | |
263 | { | |
264 | ::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
265 | ::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
266 | TString contname(branch->GetClassName()); | |
267 | ||
268 | Int_t splitlvl = branch->GetSplitLevel(); | |
269 | // if (splitlvl) splitlvl = 99; | |
270 | ||
271 | if( contname.CompareTo("TClonesArray") == 0) | |
272 | { | |
273 | TBranchElement* belem = (TBranchElement*)branch; | |
274 | ::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
275 | ||
276 | ca = new TClonesArray(belem->GetClonesName()); | |
277 | pbuf[nbranches] = ca; | |
278 | ||
279 | branch->SetAddress(&(pbuf[nbranches])); | |
280 | ::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
281 | ||
282 | ::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
283 | branches[nbranches] = loader->TreeH()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
284 | nbranches++; | |
285 | } | |
286 | else | |
287 | { | |
288 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
8eed56ee | 289 | if (bcl == 0x0) |
290 | { | |
291 | ::Error("ConvertToNewIO.C","Can not get TClass object of class named %s",branch->GetClassName()); | |
292 | continue; | |
293 | } | |
88cb7938 | 294 | pbuf[nbranches] = bcl->New(); |
295 | ::Info("ConvertToNewIO.C","Dumping buffer:"); | |
296 | ((TObject*)pbuf[nbranches])->Dump(); | |
297 | ::Info("ConvertToNewIO.C","Setting Adress:"); | |
298 | branch->SetAddress(&(pbuf[nbranches])); | |
299 | ::Info("ConvertToNewIO.C","Creating branch SpliLvl = %d",splitlvl); | |
300 | branches[nbranches] =loader->TreeH()->Branch(branch->GetName(),branch->GetClassName(),&(pbuf[nbranches]),4000,splitlvl); | |
301 | nbranches++; | |
302 | } | |
303 | } | |
304 | }//loop over branches | |
305 | }//if module is detector | |
306 | }//while loop over modules | |
307 | Int_t nentr = (Int_t)treeH->GetEntries(); | |
308 | ::Info("ConvertToNewIO.C","Copying Hits . Number of entries %d ... ",nentr); | |
309 | ||
310 | // ::Info("ConvertToNewIO.C","Getting event:"); | |
311 | // nentr = 100; | |
312 | Int_t nl = loaders->GetEntries(); | |
313 | for (Int_t e = 0; e < nentr; e++) | |
314 | { | |
315 | printf("%d\r",e); | |
316 | treeH->GetEntry(e); | |
317 | ||
318 | for (Int_t l = 0; l < nbranches; l++) | |
319 | { | |
320 | // printf("%s %#x \n", branches[l]->GetName(),pbuf[l]); | |
321 | branches[l]->SetAddress(&(pbuf[l])); | |
322 | } | |
323 | ||
324 | for (Int_t l = 0; l < nl; l++) | |
325 | { | |
326 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
327 | // printf("Filling %s\n",loader->GetName()); | |
328 | loader->TreeH()->Fill(); | |
329 | } | |
330 | #ifndef __MAKECINT__ | |
331 | #ifndef __CINT__ | |
332 | fflush(0); | |
333 | #endif | |
334 | #endif | |
335 | } | |
336 | printf("\n"); | |
337 | ||
338 | ::Info("ConvertToNewIO.C","Copying Hits ... Done"); | |
339 | for (Int_t l = 0; l < nl; l++) | |
340 | { | |
341 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
342 | loader->WriteHits("OVERWRITE"); | |
343 | loader->UnloadHits(); | |
344 | } | |
345 | delete loaders; | |
346 | for (Int_t l = 0; l < nbranches; l++) | |
347 | { | |
348 | delete (TObject*)pbuf[l]; | |
349 | } | |
350 | nbranches = 0; | |
351 | } | |
352 | else //tree has any entries | |
353 | { | |
354 | Info("ConvertToNewIO.C","Hits Tree is Empty"); | |
355 | } | |
356 | } | |
357 | else //treeH | |
358 | { | |
359 | ::Warning("ConvertToNewIO.C","Could not get TreeH from in AliRun."); | |
360 | } | |
361 | delete treeH; | |
362 | ||
363 | /*****************************************/ | |
364 | /* S D i g i t s */ | |
365 | /*****************************************/ | |
366 | ::Info("ConvertToNewIO.C","Copying S Digits."); | |
367 | TString treeSname("TreeS"); | |
368 | treeSname+=i; | |
369 | TTree* treeS = (TTree*)infile->Get(treeSname); | |
370 | if (treeS) | |
371 | { | |
372 | if (treeS->GetEntries() > 0) | |
373 | { | |
374 | TObjArray* lob = treeS->GetListOfBranches(); | |
375 | TObjArray* loaders = new TObjArray(); | |
376 | TIter nextnewmodule(outAliRun->Modules()); | |
377 | ||
378 | while ((module = (AliModule*)nextnewmodule())) | |
379 | { | |
380 | TClass* modclass = module->IsA(); | |
381 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
382 | TClonesArray* ca = 0; | |
383 | if (det) | |
384 | { | |
385 | AliLoader* loader = det->GetLoader(); | |
386 | if (loader == 0x0) | |
387 | { | |
388 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
389 | continue; | |
390 | } | |
391 | ||
392 | TString mask(det->GetName()); | |
393 | ||
394 | loader->LoadSDigits("update"); | |
395 | loader->MakeTree("S"); | |
396 | loaders->Add(loader); | |
397 | for(Int_t b=0; b<lob->GetEntries();b++) | |
398 | { | |
399 | TBranch* branch = (TBranch*)lob->At(b); | |
400 | TString bname(branch->GetName());// | |
401 | if ( bname.BeginsWith(det->GetName()) ) | |
402 | { | |
403 | ||
404 | ::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
405 | ::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
406 | TString contname(branch->GetClassName()); | |
407 | ||
408 | Int_t splitlvl = branch->GetSplitLevel(); | |
409 | // if (splitlvl) splitlvl = 99; | |
410 | ||
411 | if ( contname.CompareTo("TClonesArray") == 0) | |
412 | { | |
413 | TBranchElement* belem = (TBranchElement*)branch; | |
414 | ::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
415 | ||
416 | ca = new TClonesArray(belem->GetClonesName()); | |
417 | pbuf[nbranches] = ca; | |
418 | ||
419 | branch->SetAddress(&(pbuf[nbranches])); | |
420 | ::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
421 | ||
422 | ::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
423 | branches[nbranches] = loader->TreeS()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
424 | nbranches++; | |
425 | } | |
426 | else | |
427 | { | |
428 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
8eed56ee | 429 | if (bcl == 0x0) |
430 | { | |
431 | ::Error("ConvertToNewIO.C","Can not get TClass object of class named %s",branch->GetClassName()); | |
432 | continue; | |
433 | } | |
88cb7938 | 434 | pbuf[nbranches] = bcl->New(); |
435 | ::Info("ConvertToNewIO.C","Dumping buffer:"); | |
436 | ((TObject*)pbuf[nbranches])->Dump(); | |
437 | ::Info("ConvertToNewIO.C","Setting Adress:"); | |
438 | branch->SetAddress(&(pbuf[nbranches])); | |
439 | ::Info("ConvertToNewIO.C","Creating branch SpliLvl = %d",splitlvl); | |
440 | branches[nbranches] =loader->TreeS()->Branch(branch->GetName(),branch->GetClassName(),&(pbuf[nbranches]),4000,splitlvl); | |
441 | nbranches++; | |
442 | } | |
443 | } | |
444 | }//loop over branches | |
445 | }//if module is detector | |
446 | }//while loop over modules | |
447 | Int_t nentr = (Int_t)treeS->GetEntries(); | |
448 | ::Info("ConvertToNewIO.C","Copying SDigits. Number of entries %d ... ",nentr); | |
449 | ||
450 | // ::Info("ConvertToNewIO.C","Getting event:"); | |
451 | // nentr = 100; | |
452 | Int_t nl = loaders->GetEntries(); | |
453 | for (Int_t e = 0; e < nentr; e++) | |
454 | { | |
455 | printf("%d\r",e); | |
456 | treeS->GetEntry(e); | |
457 | ||
458 | for (Int_t l = 0; l < nbranches; l++) | |
459 | { | |
460 | // printf("%s %#x \n", branches[l]->GetName(),pbuf[l]); | |
461 | branches[l]->SetAddress(&(pbuf[l])); | |
462 | } | |
463 | ||
464 | for (Int_t l = 0; l < nl; l++) | |
465 | { | |
466 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
467 | // printf("Filling %s\n",loader->GetName()); | |
468 | loader->TreeS()->Fill(); | |
469 | } | |
470 | #ifndef __MAKECINT__ | |
471 | #ifndef __CINT__ | |
472 | fflush(0); | |
473 | #endif | |
474 | #endif | |
475 | } | |
476 | printf("\n"); | |
477 | ||
478 | ::Info("ConvertToNewIO.C","Copying SDigits ... Done"); | |
479 | for (Int_t l = 0; l < nl; l++) | |
480 | { | |
481 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
482 | loader->WriteSDigits("OVERWRITE"); | |
483 | loader->UnloadSDigits(); | |
484 | } | |
485 | delete loaders; | |
486 | for (Int_t l = 0; l < nbranches; l++) | |
487 | { | |
488 | delete (TObject*)pbuf[l]; | |
489 | } | |
490 | nbranches = 0; | |
491 | } | |
492 | else //tree has any entries | |
493 | { | |
8eed56ee | 494 | ::Info("ConvertToNewIO.C","S Digits Tree is Empty"); |
88cb7938 | 495 | } |
496 | } | |
497 | else //treeS | |
498 | { | |
8eed56ee | 499 | ::Warning("ConvertToNewIO.C","Could not get TreeS from AliRun."); |
88cb7938 | 500 | } |
501 | delete treeS; | |
502 | ||
503 | /*****************************************/ | |
504 | /* D i g i t s */ | |
505 | /*****************************************/ | |
506 | ::Info("ConvertToNewIO.C","Copying Digits."); | |
507 | TString treeDname("TreeD"); | |
508 | treeDname+=i; | |
509 | TTree* treeD = (TTree*)infile->Get(treeDname); | |
510 | if (treeD) | |
511 | { | |
512 | if (treeD->GetEntries() > 0) | |
513 | { | |
514 | ||
515 | TObjArray* lob = treeD->GetListOfBranches(); | |
516 | TObjArray* loaders = new TObjArray(); | |
517 | TIter nextnewmodule(outAliRun->Modules()); | |
518 | ||
519 | while ((module = (AliModule*)nextnewmodule())) | |
520 | { | |
521 | TClass* modclass = module->IsA(); | |
522 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
523 | TClonesArray* ca = 0; | |
524 | if (det) | |
525 | { | |
526 | AliLoader* loader = det->GetLoader(); | |
527 | if (loader == 0x0) | |
528 | { | |
529 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
530 | continue; | |
531 | } | |
532 | ||
533 | TString mask(det->GetName()); | |
534 | ||
535 | loader->LoadDigits("update"); | |
536 | loader->MakeTree("D"); | |
537 | loaders->Add(loader); | |
538 | for(Int_t b=0; b<lob->GetEntries();b++) | |
539 | { | |
540 | TBranch* branch = (TBranch*)lob->At(b); | |
541 | TString bname(branch->GetName());// | |
542 | if ( bname.BeginsWith(det->GetName()) ) | |
543 | { | |
544 | ||
545 | ::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
546 | ::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
547 | TString contname(branch->GetClassName()); | |
548 | ||
549 | Int_t splitlvl = branch->GetSplitLevel(); | |
550 | // if (splitlvl) splitlvl = 99; | |
551 | ||
552 | if ( contname.CompareTo("TClonesArray") == 0) | |
553 | { | |
554 | TBranchElement* belem = (TBranchElement*)branch; | |
555 | ::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
556 | ||
557 | ca = new TClonesArray(belem->GetClonesName()); | |
558 | pbuf[nbranches] = ca; | |
559 | ||
560 | branch->SetAddress(&(pbuf[nbranches])); | |
561 | ::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
562 | ||
563 | ::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
564 | branches[nbranches] = loader->TreeD()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
565 | nbranches++; | |
566 | } | |
567 | else | |
568 | { | |
569 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
8eed56ee | 570 | if (bcl == 0x0) |
571 | { | |
572 | ::Error("ConvertToNewIO.C","Can not get TClass object of class named %s",branch->GetClassName()); | |
573 | continue; | |
574 | } | |
88cb7938 | 575 | pbuf[nbranches] = bcl->New(); |
576 | ::Info("ConvertToNewIO.C","Dumping buffer:"); | |
577 | ((TObject*)pbuf[nbranches])->Dump(); | |
578 | ::Info("ConvertToNewIO.C","Setting Adress:"); | |
579 | branch->SetAddress(&(pbuf[nbranches])); | |
580 | ::Info("ConvertToNewIO.C","Creating branch SpliLvl = %d",splitlvl); | |
581 | branches[nbranches] =loader->TreeD()->Branch(branch->GetName(),branch->GetClassName(),&(pbuf[nbranches]),4000,splitlvl); | |
582 | nbranches++; | |
583 | } | |
584 | } | |
585 | }//loop over branches | |
586 | }//if module is detector | |
587 | }//while loop over modules | |
588 | Int_t nentr = (Int_t)treeD->GetEntries(); | |
589 | ::Info("ConvertToNewIO.C","Copying Digits. Number of entries %d ... ",nentr); | |
590 | ||
591 | // ::Info("ConvertToNewIO.C","Getting event:"); | |
592 | // nentr = 100; | |
593 | Int_t nl = loaders->GetEntries(); | |
594 | for (Int_t e = 0; e < nentr; e++) | |
595 | { | |
596 | printf("%d\r",e); | |
597 | treeD->GetEntry(e); | |
598 | ||
599 | for (Int_t l = 0; l < nbranches; l++) | |
600 | { | |
601 | // printf("%s %#x \n", branches[l]->GetName(),pbuf[l]); | |
602 | branches[l]->SetAddress(&(pbuf[l])); | |
603 | } | |
604 | ||
605 | for (Int_t l = 0; l < nl; l++) | |
606 | { | |
607 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
608 | // printf("Filling %s\n",loader->GetName()); | |
609 | loader->TreeD()->Fill(); | |
610 | } | |
611 | #ifndef __MAKECINT__ | |
612 | #ifndef __CINT__ | |
613 | fflush(0); | |
614 | #endif | |
615 | #endif | |
616 | } | |
617 | printf("\n"); | |
618 | ||
619 | ::Info("ConvertToNewIO.C","Copying Digits ... Done"); | |
620 | for (Int_t l = 0; l < nl; l++) | |
621 | { | |
622 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
623 | loader->WriteDigits("OVERWRITE"); | |
624 | loader->UnloadDigits(); | |
625 | } | |
626 | delete loaders; | |
627 | } | |
628 | else //tree has any entries | |
629 | { | |
630 | Info("ConvertToNewIO.C","S Digits Tree is Empty"); | |
631 | } | |
632 | } | |
633 | else //treeD | |
634 | { | |
635 | ::Warning("ConvertToNewIO.C","Could not get TreeD from in AliRun."); | |
636 | } | |
637 | delete treeD; | |
638 | for (Int_t l = 0; l < nbranches; l++) | |
639 | { | |
640 | delete (TObject*)pbuf[l]; | |
641 | } | |
642 | nbranches = 0; | |
643 | ||
644 | /*****************************************/ | |
645 | /* R e c P o i n t s */ | |
646 | /*****************************************/ | |
647 | ::Info("ConvertToNewIO.C","Copying RecPoints."); | |
648 | TString treeRname("TreeR"); | |
649 | treeRname+=i; | |
650 | TTree* treeR = (TTree*)infile->Get(treeRname); | |
651 | if (treeR) | |
652 | { | |
653 | if (treeR->GetEntries() > 0) | |
654 | { | |
655 | TObjArray* lob = treeR->GetListOfBranches(); | |
656 | TObjArray* loaders = new TObjArray(); | |
657 | TIter nextnewmodule(outAliRun->Modules()); | |
658 | ||
659 | while ((module = (AliModule*)nextnewmodule())) | |
660 | { | |
661 | TClass* modclass = module->IsA(); | |
662 | AliDetector *det = (AliDetector*)(modclass->DynamicCast(detclass,module)); | |
663 | TClonesArray* ca = 0; | |
664 | if (det) | |
665 | { | |
666 | AliLoader* loader = det->GetLoader(); | |
667 | if (loader == 0x0) | |
668 | { | |
669 | ::Error("ConvertToNewIO.C","Can not find loader from %s.",det->GetName()); | |
670 | continue; | |
671 | } | |
672 | ||
673 | TString mask(det->GetName()); | |
674 | ||
675 | loader->LoadRecPoints("update"); | |
676 | loader->MakeTree("R"); | |
677 | loaders->Add(loader); | |
678 | for(Int_t b=0; b<lob->GetEntries();b++) | |
679 | { | |
680 | TBranch* branch = (TBranch*)lob->At(b); | |
681 | TString bname(branch->GetName());// | |
682 | if ( bname.BeginsWith(det->GetName()) ) | |
683 | { | |
684 | ||
685 | ::Info("ConvertToNewIO.C","Found branch %s.",branch->GetName()); | |
686 | ::Info("ConvertToNewIO.C","Buffer Class Name %s.",branch->GetClassName()); | |
687 | TString contname(branch->GetClassName()); | |
688 | ||
689 | Int_t splitlvl = branch->GetSplitLevel(); | |
690 | // if (splitlvl) splitlvl = 99; | |
691 | ||
692 | if ( contname.CompareTo("TClonesArray") == 0) | |
693 | { | |
694 | TBranchElement* belem = (TBranchElement*)branch; | |
695 | ::Info("ConvertToNewIO.C","Clones Class Name %s.",belem->GetClonesName()); | |
696 | ||
697 | ca = new TClonesArray(belem->GetClonesName()); | |
698 | pbuf[nbranches] = ca; | |
699 | ||
700 | branch->SetAddress(&(pbuf[nbranches])); | |
701 | ::Info("ConvertToNewIO.C","Buffer addrss %#x",pbuf[nbranches]); | |
702 | ||
703 | ::Info("ConvertToNewIO.C","Creating branch for Clones SpliLvl = %d",splitlvl); | |
704 | branches[nbranches] = loader->TreeR()->Branch(branch->GetName(),&(pbuf[nbranches]),4000,splitlvl); | |
705 | nbranches++; | |
706 | } | |
707 | else | |
708 | { | |
709 | TClass* bcl = gROOT->GetClass(branch->GetClassName()); | |
8eed56ee | 710 | if (bcl == 0x0) |
711 | { | |
712 | ::Error("ConvertToNewIO.C","Can not get TClass object of class named %s",branch->GetClassName()); | |
713 | continue; | |
714 | } | |
88cb7938 | 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 | }//loop over branches | |
726 | }//if module is detector | |
727 | }//while loop over modules | |
728 | Int_t nentr = (Int_t)treeR->GetEntries(); | |
729 | ::Info("ConvertToNewIO.C","Copying RecPoints. Number of entries %d ... ",nentr); | |
730 | ||
731 | // ::Info("ConvertToNewIO.C","Getting event:"); | |
732 | // nentr = 100; | |
733 | Int_t nl = loaders->GetEntries(); | |
734 | for (Int_t e = 0; e < nentr; e++) | |
735 | { | |
736 | printf("%d\r",e); | |
737 | treeR->GetEntry(e); | |
738 | ||
739 | for (Int_t l = 0; l < nbranches; l++) | |
740 | { | |
741 | // printf("%s %#x \n", branches[l]->GetName(),pbuf[l]); | |
742 | branches[l]->SetAddress(&(pbuf[l])); | |
743 | } | |
744 | ||
745 | for (Int_t l = 0; l < nl; l++) | |
746 | { | |
747 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
748 | // printf("Filling %s\n",loader->GetName()); | |
749 | loader->TreeR()->Fill(); | |
750 | } | |
751 | #ifndef __MAKECINT__ | |
752 | #ifndef __CINT__ | |
753 | fflush(0); | |
754 | #endif | |
755 | #endif | |
756 | } | |
757 | printf("\n"); | |
758 | ||
759 | ::Info("ConvertToNewIO.C","Copying RecPoints ... Done"); | |
760 | for (Int_t l = 0; l < nl; l++) | |
761 | { | |
762 | AliLoader* loader = (AliLoader*)loaders->At(l); | |
763 | loader->WriteRecPoints("OVERWRITE"); | |
764 | loader->UnloadRecPoints(); | |
765 | } | |
766 | delete loaders; | |
767 | for (Int_t l = 0; l < nbranches; l++) | |
768 | { | |
769 | delete (TObject*)pbuf[l];//delete branches buffers | |
770 | } | |
771 | nbranches = 0; | |
772 | } | |
773 | else //tree has any entries | |
774 | { | |
775 | Info("ConvertToNewIO.C","Rec Points Tree is Empty"); | |
776 | } | |
777 | } | |
778 | else //treeR | |
779 | { | |
780 | ::Warning("ConvertToNewIO.C","Could not get TreeR from in AliRun."); | |
781 | } | |
782 | delete treeR; | |
783 | ||
784 | }//end of loop over events | |
785 | ||
786 | /***************************************************/ | |
787 | /**** Run to Run *************/ | |
788 | /***************************************************/ | |
789 | ||
790 | rl->WriteHeader("OVERWRITE"); | |
791 | ||
792 | infile->cd(); | |
793 | TGeometry* geo = inAliRun->GetGeometry(); | |
794 | rl->CdGAFile(); | |
795 | geo->Write(); | |
796 | ||
797 | rl->WriteAliRun(); | |
798 | rl->WriteRunLoader(); | |
799 | ||
800 | ::Info("ConvertToNewIO.C","Done"); | |
801 | ||
802 | } | |
803 |