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