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