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