STEER/AliRun.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 //  Control class for Alice C++                                              //
  21 //  Only one single instance of this class exists.                           //
  22 //  The object is created in main program aliroot                            //
  23 //  and is pointed by the global gAlice.                                     //
  24 //                                                                           //
  25 //   -Supports the list of all Alice Detectors (fModules).                 //
  26 //   -Supports the list of particles (fParticles).                           //
  27 //   -Supports the Trees.                                                    //
  28 //   -Supports the geometry.                                                 //
  29 //   -Supports the event display.                                            //
  30 //Begin_Html
  31 /*
  32 <img src="picts/AliRunClass.gif">
  33 */
  34 //End_Html
  35 //Begin_Html
  36 /*
  37 <img src="picts/alirun.gif">
  38 */
  39 //End_Html
  40 //                                                                           //
  41 ///////////////////////////////////////////////////////////////////////////////
  42
  43 #include <TBRIK.h>
  44 #include <TCint.h>
  45 #include <TDatabasePDG.h>
  46 #include <TGeometry.h>
  47 #include <TNode.h>
  48 #include <TROOT.h>
  49 #include <TRandom3.h>
  50 #include <TSystem.h>
  51 #include <TVirtualMC.h>
  52 //
  53 #include "AliDetector.h"
  54 #include "AliDisplay.h"
  55 #include "AliHeader.h"
  56 #include "AliLego.h"
  57 #include "AliLegoGenerator.h"
  58 #include "AliMC.h"
  59 #include "AliMagFC.h"
  60 #include "AliMagFCM.h"
  61 #include "AliMagFDM.h"
  62 #include "AliPDG.h"
  63 #include "AliRun.h"
  64 #include "AliStack.h"
  65
  66 AliRun *gAlice;
  67
  68
  69 ClassImp(AliRun)
  70
  71 //_______________________________________________________________________
  72 AliRun::AliRun():
  73   fRun(0),
  74   fEvent(0),
  75   fEventNrInRun(0),
  76   fEventsPerRun(0),
  77   fDebug(0),
  78   fModules(0),
  79   fGeometry(0),
  80   fMCApp(0),
  81   fDisplay(0),
  82   //  fTimer(),
  83   fField(0),
  84   fMC(0),
  85   fNdets(0),
  86   fInitDone(kFALSE),
  87   fLego(0),
  88   fPDGDB(0),  //Particle factory object
  89   fConfigFunction("\0"),
  90   fRandom(0),
  91   fRunLoader(0x0)
  92 {
  93   //
  94   // Default constructor for AliRun
  95   //
  96   AliConfig::Instance();//skowron 29 Feb 2002
  97                         //ensures that the folder structure is build
  98 }
  99
 100 //_______________________________________________________________________
 101 AliRun::AliRun(const AliRun& arun):
 102   TNamed(arun),
 103   fRun(0),
 104   fEvent(0),
 105   fEventNrInRun(0),
 106   fEventsPerRun(0),
 107   fDebug(0),
 108   fModules(0),
 109   fGeometry(0),
 110   fMCApp(0),
 111   fDisplay(0),
 112   //  fTimer(),
 113   fField(0),
 114   fMC(0),
 115   fNdets(0),
 116   fInitDone(kFALSE),
 117   fLego(0),
 118   fPDGDB(0),  //Particle factory object
 119   fConfigFunction("\0"),
 120   fRandom(0),
 121   fRunLoader(0x0)
 122 {
 123   //
 124   // Copy constructor for AliRun
 125   //
 126   arun.Copy(*this);
 127 }
 128
 129 //_____________________________________________________________________________
 130 AliRun::AliRun(const char *name, const char *title):
 131   TNamed(name,title),
 132   fRun(0),
 133   fEvent(0),
 134   fEventNrInRun(0),
 135   fEventsPerRun(0),
 136   fDebug(0),
 137   fModules(new TObjArray(77)), // Support list for the Detectors
 138   fGeometry(0),
 139   fMCApp(0),
 140   fDisplay(0),
 141   //  fTimer(),
 142   fField(0),
 143   fMC(gMC),
 144   fNdets(0),
 145   fInitDone(kFALSE),
 146   fLego(0),
 147   fPDGDB(TDatabasePDG::Instance()),        //Particle factory object!
 148   fConfigFunction("Config();"),
 149   fRandom(new TRandom3()),
 150   fRunLoader(0x0)
 151 {
 152   //
 153   //  Constructor for the main processor.
 154   //  Creates the geometry
 155   //  Creates the list of Detectors.
 156   //  Creates the list of particles.
 157   //
 158
 159   gAlice     = this;
 160
 161   // Set random number generator
 162   gRandom = fRandom;
 163
 164   if (gSystem->Getenv("CONFIG_SEED")) {
 165      gRandom->SetSeed(static_cast<UInt_t>(atoi(gSystem->Getenv("CONFIG_SEED"))));
 166   }
 167
 168   // Add to list of browsable
 169   gROOT->GetListOfBrowsables()->Add(this,name);
 170   // Create the TNode geometry for the event display
 171   BuildSimpleGeometry();
 172
 173   // Create default mag field
 174   SetField();
 175
 176   // Add particle list to configuration
 177   AliConfig::Instance()->Add(fPDGDB);
 178
 179 }
 180
 181
 182 //_______________________________________________________________________
 183 AliRun::~AliRun()
 184 {
 185   //
 186   // Default AliRun destructor
 187   //
 188   gROOT->GetListOfBrowsables()->Remove(this);
 189
 190   if (fRunLoader)
 191    {
 192     TFolder* evfold = fRunLoader->GetEventFolder();
 193     TFolder* modfold = dynamic_cast<TFolder*>(evfold->FindObjectAny(AliConfig::GetModulesFolderName()));
 194     TIter next(fModules);
 195     AliModule *mod;
 196     while((mod = (AliModule*)next()))
 197      {
 198        modfold->Remove(mod);
 199      }
 200    }
 201
 202
 203   delete fField;
 204   delete fMCApp;
 205   delete gMC; gMC=0;
 206   delete fGeometry;
 207   delete fDisplay;
 208   delete fLego;
 209   if (fModules) {
 210     fModules->Delete();
 211     delete fModules;
 212   }
 213
 214   delete fPDGDB;
 215 }
 216
 217 //_______________________________________________________________________
 218 void AliRun::Copy(TObject &) const
 219 {
 220   Fatal("Copy","Not implemented!\n");
 221 }
 222
 223 //_______________________________________________________________________
 224 void AliRun::Build()
 225 {
 226   //
 227   // Initialize Alice geometry
 228   // Dummy routine
 229   //
 230 }
 231
 232 //_______________________________________________________________________
 233 void AliRun::BuildSimpleGeometry()
 234 {
 235   //
 236   // Create a simple TNode geometry used by Root display engine
 237   //
 238   // Initialise geometry
 239   //
 240   fGeometry = new TGeometry("AliceGeom","Galice Geometry for Hits");
 241   new TMaterial("void","Vacuum",0,0,0);  //Everything is void
 242   TBRIK *brik = new TBRIK("S_alice","alice volume","void",2000,2000,3000);
 243   brik->SetVisibility(0);
 244   new TNode("alice","alice","S_alice");
 245 }
 246
 247 //_______________________________________________________________________
 248 void AliRun::CleanDetectors()
 249 {
 250   //
 251   // Clean Detectors at the end of event
 252   //
 253    fRunLoader->CleanDetectors();
 254 }
 255
 256 //_______________________________________________________________________
 257 void AliRun::ResetHits()
 258 {
 259   fMCApp->ResetHits();
 260 }
 261
 262 //_______________________________________________________________________
 263 AliGenerator* AliRun::Generator() const
 264 {
 265   return fMCApp->Generator();
 266 }
 267
 268 //_______________________________________________________________________
 269 void  AliRun::SetField(AliMagF* magField)
 270 {
 271   //
 272   // Set Magnetic Field Map
 273   //
 274   fField = magField;
 275   fField->ReadField();
 276 }
 277
 278 //_______________________________________________________________________
 279 void AliRun::SetField(Int_t type, Int_t version, Float_t scale,
 280                       Float_t maxField, const char* filename)
 281 {
 282   //
 283   //  Set magnetic field parameters
 284   //  type      Magnetic field transport flag 0=no field, 2=helix, 3=Runge Kutta
 285   //  version   Magnetic field map version (only 1 active now)
 286   //  scale     Scale factor for the magnetic field
 287   //  maxField  Maximum value for the magnetic field
 288
 289   //
 290   // --- Sanity check on mag field flags
 291   if(fField) delete fField;
 292   if(version==1) {
 293     fField = new AliMagFC("Map1"," ",type,scale,maxField);
 294   } else if(version<=2) {
 295     fField = new AliMagFCM("Map2-3",filename,type,scale,maxField);
 296     fField->ReadField();
 297   } else if(version==3) {
 298     fField = new AliMagFDM("Map4",filename,type,scale,maxField);
 299     fField->ReadField();
 300   } else {
 301     Warning("SetField","Invalid map %d\n",version);
 302   }
 303 }
 304
 305 //_____________________________________________________________________________
 306
 307 void AliRun::InitLoaders()
 308 {
 309   //creates list of getters
 310   if (GetDebug()) Info("InitLoaders","");
 311   TIter next(fModules);
 312   AliModule *mod;
 313   while((mod = (AliModule*)next()))
 314    {
 315      mod->SetRunLoader(fRunLoader);
 316      AliDetector *det = dynamic_cast<AliDetector*>(mod);
 317      if (det)
 318       {
 319         if (GetDebug()) Info("InitLoaders"," Adding %s ",det->GetName());
 320         fRunLoader->AddLoader(det);
 321       }
 322    }
 323   if (GetDebug()) Info("InitLoaders","Done");
 324 }
 325 //_____________________________________________________________________________
 326
 327 void AliRun::FinishRun()
 328 {
 329   //
 330   // Called at the end of the run.
 331   //
 332
 333   if(fLego)
 334    {
 335     if (GetDebug()) Info("FinishRun"," Finish Lego");
 336     fRunLoader->CdGAFile();
 337     fLego->FinishRun();
 338    }
 339
 340   // Clean detector information
 341   TIter next(fModules);
 342   AliModule *detector;
 343   while((detector = dynamic_cast<AliModule*>(next()))) {
 344     if (GetDebug()) Info("FinishRun"," %s->FinishRun()",detector->GetName());
 345     detector->FinishRun();
 346   }
 347
 348   if (GetDebug()) Info("FinishRun"," fRunLoader->WriteHeader(OVERWRITE)");
 349   fRunLoader->WriteHeader("OVERWRITE");
 350
 351   // Write AliRun info and all detectors parameters
 352   fRunLoader->CdGAFile();
 353   Write(0,TObject::kOverwrite);//write AliRun
 354   fRunLoader->Write(0,TObject::kOverwrite);//write RunLoader itself
 355
 356   // Clean tree information
 357   if (GetDebug()) Info("FinishRun"," fRunLoader->Stack()->FinishRun()");
 358   fRunLoader->Stack()->FinishRun();
 359
 360   if(fMCApp) fMCApp->FinishRun();
 361
 362   fRunLoader->Synchronize();
 363 }
 364
 365 //_______________________________________________________________________
 366 void AliRun::Announce() const
 367 {
 368   //
 369   // Announce the current version of AliRoot
 370   //
 371   printf("%70s",
 372          "****************************************************************\n");
 373   printf("%6s","*");printf("%64s","*\n");
 374
 375   printf("%6s","*");
 376   printf("    You are running AliRoot version NewIO\n");
 377
 378   printf("%6s","*");
 379   printf("    The cvs tag for the current program is $Name$\n");
 380
 381   printf("%6s","*");printf("%64s","*\n");
 382   printf("%70s",
 383          "****************************************************************\n");
 384 }
 385
 386 //_______________________________________________________________________
 387 AliModule *AliRun::GetModule(const char *name) const
 388 {
 389   //
 390   // Return pointer to detector from name
 391   //
 392   return dynamic_cast<AliModule*>(fModules->FindObject(name));
 393 }
 394
 395 //_______________________________________________________________________
 396 AliDetector *AliRun::GetDetector(const char *name) const
 397 {
 398   //
 399   // Return pointer to detector from name
 400   //
 401   return dynamic_cast<AliDetector*>(fModules->FindObject(name));
 402 }
 403
 404 //_______________________________________________________________________
 405 Int_t AliRun::GetModuleID(const char *name) const
 406 {
 407   //
 408   // Return galice internal detector identifier from name
 409   //
 410   Int_t i=-1;
 411   TObject *mod=fModules->FindObject(name);
 412   if(mod) i=fModules->IndexOf(mod);
 413   return i;
 414 }
 415
 416 //_______________________________________________________________________
 417 Int_t AliRun::GetEvent(Int_t event)
 418 {
 419 //
 420 // Reloads data containers in folders # event
 421 // Set branch addresses
 422 //
 423   if (fRunLoader == 0x0)
 424    {
 425      Error("GetEvent","RunLoader is not set. Can not load data.");
 426      return -1;
 427    }
 428 /*****************************************/
 429 /****   P R E    R E L O A D I N G    ****/
 430 /*****************************************/
 431 // Reset existing structures
 432   fMCApp->ResetHits();
 433   fMCApp->ResetTrackReferences();
 434   ResetDigits();
 435   ResetSDigits();
 436
 437 /*****************************************/
 438 /****       R  E  L  O  A  D          ****/
 439 /*****************************************/
 440
 441   fRunLoader->GetEvent(event);
 442
 443 /*****************************************/
 444 /****  P O S T    R E L O A D I N G   ****/
 445 /*****************************************/
 446
 447   // Set Trees branch addresses
 448   TIter next(fModules);
 449   AliModule *detector;
 450   while((detector = dynamic_cast<AliModule*>(next())))
 451    {
 452      detector->SetTreeAddress();
 453    }
 454
 455   return fRunLoader->GetHeader()->GetNtrack();
 456 }
 457
 458 //_______________________________________________________________________
 459 TGeometry *AliRun::GetGeometry()
 460 {
 461   //
 462   // Import Alice geometry from current file
 463   // Return pointer to geometry object
 464   //
 465   if (!fGeometry) fGeometry = dynamic_cast<TGeometry*>(gDirectory->Get("AliceGeom"));
 466   //
 467   // Unlink and relink nodes in detectors
 468   // This is bad and there must be a better way...
 469   //
 470
 471   TIter next(fModules);
 472   AliModule *detector;
 473   while((detector = dynamic_cast<AliModule*>(next()))) {
 474     TList *dnodes=detector->Nodes();
 475     Int_t j;
 476     TNode *node, *node1;
 477     for ( j=0; j<dnodes->GetSize(); j++) {
 478       node = dynamic_cast<TNode*>(dnodes->At(j));
 479       node1 = fGeometry->GetNode(node->GetName());
 480       dnodes->Remove(node);
 481       dnodes->AddAt(node1,j);
 482     }
 483   }
 484   return fGeometry;
 485 }
 486
 487 //_______________________________________________________________________
 488 void AliRun::SetBaseFile(const char *filename)
 489 {
 490   fBaseFileName = filename;
 491 }
 492
 493 //_______________________________________________________________________
 494 void AliRun::ResetDigits()
 495 {
 496   //
 497   //  Reset all Detectors digits
 498   //
 499   TIter next(fModules);
 500   AliModule *detector;
 501   while((detector = dynamic_cast<AliModule*>(next()))) {
 502      detector->ResetDigits();
 503   }
 504 }
 505
 506 //_______________________________________________________________________
 507 void AliRun::ResetSDigits()
 508 {
 509   //
 510   //  Reset all Detectors digits
 511   //
 512   TIter next(fModules);
 513   AliModule *detector;
 514   while((detector = dynamic_cast<AliModule*>(next()))) {
 515      detector->ResetSDigits();
 516   }
 517 }
 518
 519
 520 //_______________________________________________________________________
 521
 522 void AliRun::ResetPoints()
 523 {
 524   //
 525   // Reset all Detectors points
 526   //
 527   TIter next(fModules);
 528   AliModule *detector;
 529   while((detector = dynamic_cast<AliModule*>(next()))) {
 530      detector->ResetPoints();
 531   }
 532 }
 533 //_______________________________________________________________________
 534
 535 void AliRun::InitMC(const char *setup)
 536 {
 537   //
 538   // Initialize ALICE Simulation run
 539   //
 540   Announce();
 541
 542   if(fInitDone) {
 543     Warning("Init","Cannot initialise AliRun twice!\n");
 544     return;
 545   }
 546
 547   fMCApp=new AliMC(GetName(),GetTitle());
 548
 549   gROOT->LoadMacro(setup);
 550   gInterpreter->ProcessLine(fConfigFunction.Data());
 551
 552   fRunLoader->CdGAFile();
 553
 554   AliPDG::AddParticlesToPdgDataBase();
 555
 556   fNdets = fModules->GetLast()+1;
 557
 558   // Added also after in case of interactive initialisation of modules
 559   fNdets = fModules->GetLast()+1;
 560
 561   TIter next(fModules);
 562   for(Int_t i=0; i<fNdets; ++i)
 563    {
 564      TObject *objfirst, *objlast;
 565      AliModule *detector=dynamic_cast<AliModule*>(fModules->At(i));
 566      objlast = gDirectory->GetList()->Last();
 567
 568      // Add Detector histograms in Detector list of histograms
 569      if (objlast) objfirst = gDirectory->GetList()->After(objlast);
 570      else         objfirst = gDirectory->GetList()->First();
 571      while (objfirst)
 572       {
 573         detector->Histograms()->Add(objfirst);
 574         objfirst = gDirectory->GetList()->After(objfirst);
 575       }
 576    }
 577
 578    fMCApp->Init();
 579
 580    //Must be here because some MCs (G4) adds detectors here and not in Config.C
 581    InitLoaders();
 582    fRunLoader->MakeTree("E");
 583    if (fLego == 0x0)
 584     {
 585       fRunLoader->LoadKinematics("RECREATE");
 586       fRunLoader->LoadTrackRefs("RECREATE");
 587       fRunLoader->LoadHits("all","RECREATE");
 588     }
 589    fInitDone = kTRUE;
 590    //
 591    // Save stuff at the beginning of the file to avoid file corruption
 592    fRunLoader->CdGAFile();
 593    Write();
 594    fEventNrInRun = -1; //important - we start Begin event from increasing current number in run
 595 }
 596
 597 //_______________________________________________________________________
 598
 599 void AliRun::RunMC(Int_t nevent, const char *setup)
 600 {
 601   //
 602   // Main function to be called to process a galice run
 603   // example
 604   //    Root > gAlice.Run();
 605   // a positive number of events will cause the finish routine
 606   // to be called
 607   //
 608   fEventsPerRun = nevent;
 609   // check if initialisation has been done
 610   if (!fInitDone) InitMC(setup);
 611
 612   // Create the Root Tree with one branch per detector
 613   //Hits moved to begin event -> now we are crating separate tree for each event
 614
 615   gMC->ProcessRun(nevent);
 616
 617   // End of this run, close files
 618   if(nevent>0) FinishRun();
 619 }
 620
 621 //_______________________________________________________________________
 622 void AliRun::RunReco(const char *selected, Int_t first, Int_t last)
 623 {
 624   //
 625   // Main function to be called to reconstruct Alice event
 626   //
 627    Int_t nev = fRunLoader->GetNumberOfEvents();
 628    if (GetDebug()) Info("RunReco","Found %d events",nev);
 629    Int_t nFirst = first;
 630    Int_t nLast  = (last < 0)? nev : last;
 631
 632    for (Int_t nevent = nFirst; nevent <= nLast; nevent++) {
 633      if (GetDebug()) Info("RunReco","Processing event %d",nevent);
 634      GetEvent(nevent);
 635      Digits2Reco(selected);
 636    }
 637 }
 638
 639 //_______________________________________________________________________
 640
 641 void AliRun::Hits2Digits(const char *selected)
 642 {
 643
 644    // Convert Hits to sumable digits
 645    //
 646    for (Int_t nevent=0; nevent<gAlice->TreeE()->GetEntries(); nevent++) {
 647      GetEvent(nevent);
 648      Hits2SDigits(selected);
 649      SDigits2Digits(selected);
 650    }
 651 }
 652
 653
 654 //_______________________________________________________________________
 655
 656 void AliRun::Tree2Tree(Option_t *option, const char *selected)
 657 {
 658   //
 659   // Function to transform the content of
 660   //
 661   // - TreeH to TreeS (option "S")
 662   // - TreeS to TreeD (option "D")
 663   // - TreeD to TreeR (option "R")
 664   //
 665   // If multiple options are specified ("SDR"), transformation will be done in sequence for
 666   // selected detector and for all detectors if none is selected (detector string
 667   // can contain blank separated list of detector names).
 668
 669
 670    const char *oS = strstr(option,"S");
 671    const char *oD = strstr(option,"D");
 672    const char *oR = strstr(option,"R");
 673
 674    TObjArray *detectors = Detectors();
 675
 676    TIter next(detectors);
 677
 678    AliDetector *detector = 0;
 679
 680    while((detector = dynamic_cast<AliDetector*>(next()))) {
 681      if (selected)
 682        if (strcmp(detector->GetName(),selected)) continue;
 683      if (detector->IsActive())
 684       {
 685
 686        AliLoader* loader = detector->GetLoader();
 687        if (loader == 0x0) continue;
 688
 689        if (oS)
 690         {
 691           if (GetDebug()) Info("Tree2Tree","Processing Hits2SDigits for %s ...",detector->GetName());
 692           loader->LoadHits("read");
 693           if (loader->TreeS() == 0x0) loader->MakeTree("S");
 694           detector->MakeBranch(option);
 695           detector->SetTreeAddress();
 696           detector->Hits2SDigits();
 697           loader->UnloadHits();
 698           loader->UnloadSDigits();
 699         }
 700        if (oD)
 701         {
 702           if (GetDebug()) Info("Tree2Tree","Processing SDigits2Digits for %s ...",detector->GetName());
 703           loader->LoadSDigits("read");
 704           if (loader->TreeD() == 0x0) loader->MakeTree("D");
 705           detector->MakeBranch(option);
 706           detector->SetTreeAddress();
 707           detector->SDigits2Digits();
 708           loader->UnloadSDigits();
 709           loader->UnloadDigits();
 710         }
 711        if (oR)
 712         {
 713           if (GetDebug()) Info("Tree2Tree","Processing Digits2Reco for %s ...",detector->GetName());
 714           loader->LoadDigits("read");
 715           if (loader->TreeR() == 0x0) loader->MakeTree("R");
 716           detector->MakeBranch(option);
 717           detector->SetTreeAddress();
 718           detector->Digits2Reco();
 719           loader->UnloadDigits();
 720           loader->UnloadRecPoints();
 721
 722         }
 723      }
 724    }
 725 }
 726
 727 //_______________________________________________________________________
 728 void AliRun::RunLego(const char *setup, Int_t nc1, Float_t c1min,
 729                      Float_t c1max,Int_t nc2,Float_t c2min,Float_t c2max,
 730                      Float_t rmin,Float_t rmax,Float_t zmax, AliLegoGenerator* gener)
 731 {
 732   //
 733   // Generates lego plots of:
 734   //    - radiation length map phi vs theta
 735   //    - radiation length map phi vs eta
 736   //    - interaction length map
 737   //    - g/cm2 length map
 738   //
 739   //  ntheta    bins in theta, eta
 740   //  themin    minimum angle in theta (degrees)
 741   //  themax    maximum angle in theta (degrees)
 742   //  nphi      bins in phi
 743   //  phimin    minimum angle in phi (degrees)
 744   //  phimax    maximum angle in phi (degrees)
 745   //  rmin      minimum radius
 746   //  rmax      maximum radius
 747   //
 748   //
 749   //  The number of events generated = ntheta*nphi
 750   //  run input parameters in macro setup (default="Config.C")
 751   //
 752   //  Use macro "lego.C" to visualize the 3 lego plots in spherical coordinates
 753   //Begin_Html
 754   /*
 755     <img src="picts/AliRunLego1.gif">
 756   */
 757   //End_Html
 758   //Begin_Html
 759   /*
 760     <img src="picts/AliRunLego2.gif">
 761   */
 762   //End_Html
 763   //Begin_Html
 764   /*
 765     <img src="picts/AliRunLego3.gif">
 766   */
 767   //End_Html
 768   //
 769
 770   // check if initialisation has been done
 771   // If runloader has been initialized, set the number of events per file to nc1 * nc2
 772
 773   // Set new generator
 774   if (!gener) gener  = new AliLegoGenerator();
 775   //
 776   // Configure Generator
 777   gener->SetRadiusRange(rmin, rmax);
 778   gener->SetZMax(zmax);
 779   gener->SetCoor1Range(nc1, c1min, c1max);
 780   gener->SetCoor2Range(nc2, c2min, c2max);
 781
 782
 783   //Create Lego object
 784   fLego = new AliLego("lego",gener);
 785
 786   if (!fInitDone) InitMC(setup);
 787   //Save current generator
 788
 789   AliGenerator *gen=fMCApp->Generator();
 790   fMCApp->ResetGenerator(gener);
 791   //Prepare MC for Lego Run
 792   gMC->InitLego();
 793
 794   //Run Lego Object
 795
 796   if (fRunLoader) fRunLoader->SetNumberOfEventsPerFile(nc1 * nc2);
 797   //gMC->ProcessRun(nc1*nc2+1);
 798   gMC->ProcessRun(nc1*nc2);
 799
 800   // End of this run, close files
 801   FinishRun();
 802   // Restore current generator
 803   fMCApp->ResetGenerator(gen);
 804   // Delete Lego Object
 805   delete fLego; fLego=0;
 806 }
 807
 808 //_______________________________________________________________________
 809 void AliRun::SetConfigFunction(const char * config)
 810 {
 811   //
 812   // Set the signature of the function contained in Config.C to configure
 813   // the run
 814   //
 815   fConfigFunction=config;
 816 }
 817
 818 //
 819 // MC Application
 820 //
 821
 822 //_______________________________________________________________________
 823 void AliRun::Field(const Double_t* x, Double_t *b) const
 824 {
 825   //
 826   // Return the value of the magnetic field
 827   //
 828   Float_t xfloat[3];
 829   for (Int_t i=0; i<3; i++) xfloat[i] = x[i];
 830
 831   if (Field()) {
 832     Float_t bfloat[3];
 833     Field()->Field(xfloat,bfloat);
 834     for (Int_t j=0; j<3; j++) b[j] = bfloat[j];
 835   }
 836   else {
 837     printf("No mag field defined!\n");
 838     b[0]=b[1]=b[2]=0.;
 839   }
 840 }
 841
 842 //
 843 // End of MC Application
 844 //
 845
 846 //_______________________________________________________________________
 847 void AliRun::Streamer(TBuffer &R__b)
 848 {
 849   // Stream an object of class AliRun.
 850
 851   if (R__b.IsReading()) {
 852     if (!gAlice) gAlice = this;
 853     AliRun::Class()->ReadBuffer(R__b, this);
 854     gROOT->GetListOfBrowsables()->Add(this,"Run");
 855
 856     gRandom = fRandom;
 857   } else {
 858     AliRun::Class()->WriteBuffer(R__b, this);
 859   }
 860 }
 861 //_______________________________________________________________________
 862
 863 void AliRun::SetGenEventHeader(AliGenEventHeader* header)
 864 {
 865   fRunLoader->GetHeader()->SetGenEventHeader(header);
 866 }
 867 //_______________________________________________________________________
 868
 869 Int_t AliRun::GetEvNumber() const
 870 {
 871 //Returns number of current event
 872   if (fRunLoader == 0x0)
 873    {
 874      Error("GetEvent","RunLoader is not set. Can not load data.");
 875      return -1;
 876    }
 877
 878   return fRunLoader->GetEventNumber();
 879 }
 880 //_______________________________________________________________________
 881
 882 void AliRun::SetRunLoader(AliRunLoader* rloader)
 883 {
 884   //
 885   // Set the loader of the run
 886   //
 887   fRunLoader = rloader;
 888   if (fRunLoader == 0x0) return;
 889
 890   TString evfoldname;
 891   TFolder* evfold = fRunLoader->GetEventFolder();
 892   if (evfold) evfoldname = evfold->GetName();
 893   else Warning("SetRunLoader","Did not get Event Folder from Run Loader");
 894
 895   if ( fRunLoader->GetAliRun() )
 896    {//if alrun already exists in folder
 897     if (fRunLoader->GetAliRun() != this )
 898      {//and is different than this - crash
 899        Fatal("AliRun","AliRun is already in Folder and it is not this object");
 900        return;//pro forma
 901      }//else do nothing
 902    }
 903   else
 904    {
 905      evfold->Add(this);//Post this AliRun to Folder
 906    }
 907
 908   TIter next(fModules);
 909   AliModule *module;
 910   while((module = (AliModule*)next()))
 911    {
 912      if (evfold) AliConfig::Instance()->Add(module,evfoldname);
 913      module->SetRunLoader(fRunLoader);
 914      AliDetector* detector = dynamic_cast<AliDetector*>(module);
 915      if (detector)
 916       {
 917         AliLoader* loader = fRunLoader->GetLoader(detector);
 918         if (loader == 0x0)
 919          {
 920            Error("SetRunLoader","Can not get loader for detector %s",detector->GetName());
 921          }
 922         else
 923          {
 924            if (GetDebug()) Info("SetRunLoader","Setting loader for detector %s",detector->GetName());
 925            detector->SetLoader(loader);
 926          }
 927       }
 928    }
 929 }
 930
 931 void AliRun::AddModule(AliModule* mod)
 932 {
 933   //
 934   // Add a module to the module list
 935   //
 936   if (mod == 0x0) return;
 937   if (strlen(mod->GetName()) == 0) return;
 938   if (GetModuleID(mod->GetName()) >= 0) return;
 939
 940   if (GetDebug()) Info("AddModule","%s",mod->GetName());
 941   if (fRunLoader == 0x0) AliConfig::Instance()->Add(mod);
 942   else AliConfig::Instance()->Add(mod,fRunLoader->GetEventFolder()->GetName());
 943
 944   Modules()->Add(mod);
 945 }