Using VZERO v6
[u/mrichter/AliRoot.git] / macros / ConvertToNewIO.C
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);
25   rl->SetNumberOfEventsPerFile(100);
26   
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;
67   TObject * object;
68   while ((object = next()))  
69    {
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
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();
178         TObject * object;
179         while ((object = next()))  
180          {
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            }
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());
289                         if (bcl == 0x0)
290                          {
291                            ::Error("ConvertToNewIO.C","Can not get TClass object of class named %s",branch->GetClassName());
292                            continue;
293                          }
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());
429                         if (bcl == 0x0)
430                          {
431                            ::Error("ConvertToNewIO.C","Can not get TClass object of class named %s",branch->GetClassName());
432                            continue;
433                          }
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        {
494          ::Info("ConvertToNewIO.C","S Digits Tree is Empty");
495        }
496       }
497      else //treeS
498       {
499         ::Warning("ConvertToNewIO.C","Could not get TreeS from AliRun.");
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());
570                        if (bcl == 0x0)
571                         {
572                           ::Error("ConvertToNewIO.C","Can not get TClass object of class named %s",branch->GetClassName());
573                           continue;
574                         }
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());
710                        if (bcl == 0x0)
711                         {
712                           ::Error("ConvertToNewIO.C","Can not get TClass object of class named %s",branch->GetClassName());
713                           continue;
714                         }
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