ALIFAST/AliFast.cxx

   1
   2 //////////////////////////////////////////////////////////////////////////
   3 //                                                                      //
   4 // AliFast                                                              //
   5 //                                                                      //
   6 // Main class to control the AliFast program.                           //
   7 //                                                                      //
   8 // This class is a general framework for programs that needs to:        //
   9 //    - Initialise some parameters                                      //
  10 //    - Loop on events                                                  //
  11 //    - Print results and save histograms, etc                          //
  12 //                                                                      //
  13 // The event processor AliFast::Make loops on a list of Makers          //
  14 // where each maker performs some task on the event data and generates  //
  15 // results.                                                             //
  16 // New Makers can be inserted by a user without modifying this class.   //
  17 // Note that the order in which the Makers are called is the order      //
  18 // of insertion in the list of Makers.                                  //
  19 // Each Maker is responsible for creating its branch of the Tree.       //
  20 // The following table shows the list of makers currently implemented   //
  21 // The default option to Save the Maker info in the Tree is mentioned.  //
  22 //                                                                      //
  23 //    Maker name        Save in Tree                                    //
  24 //    ==========        ============                                    //
  25 //    MCMaker             NO                                            //
  26 //    TrackMaker          NO                                            //
  27 //                                                                      //
  28 // Makers must derive from the base class AliFMaker.                    //
  29 // AliFMaker provides a common interface to all Makers.                 //
  30 // Each Maker is responsible for defining its own parameters and        //
  31 // histograms.                                                          //
  32 // Each Maker has its own list of histograms.                           //
  33 // Each Maker has an associated companion class corresponding to the    //
  34 // type of physics object reconstructed by the Maker.                   //
  35 // For example, AliFClusterMaker creates AliFCluster objects.           //
  36 //              AliFTriggerMaker creates one single AliFTrigger object. //
  37 // The pointer supporting the created object(s) is defined in AliFMaker //
  38 //   fFruits may point to a single object (eg. AliFTrigger) or to a    //
  39 //           TClonesArray of objects (eg. AliFCluster).                 //
  40 //                                                                      //
  41 // The function AliFast::Maketree must be called after the creation     //
  42 // of the AliFast object to create a Root Tree.                         //
  43 //                                                                      //
  44 // An example of main program/macro to use AliFast is given below:      //
  45 //========================================================================
  46 //void umain(Int_t nevents=100)
  47 //{
  48 //   gROOT->Reset();
  49 //   gSystem->Load("libalifast.so");  // dynamically link the compiled shared library
  50 //
  51 //   // Open the root output file
  52 //   TFile file("alifast.root","recreate","AliFast root file",2);
  53 //
  54 //   AliFast alifast("alifast");     // create main object to run alifast
  55 //
  56 //   User user;           // create an object of the User class defined in user.C
  57 //
  58 //   alifast.Init();      // Initialise event (maker histograms,etc)
  59 //   alifast.MakeTree();  // Create the Root tree
  60 //
  61 //   gROOT->LoadMacro("user.C");  // compile/interpret user file
  62 //
  63 //   for (Int_t i=0; i<nevents; i++) {
  64 //      if (i%100 == 0) printf("In loop:%d\n",i);
  65 //      alifast.Make(i);       // Generate and reconstruct event
  66 //      user.FillHistograms(); // User has possibility to decide if store event here!
  67 //      alifast.FillTree();
  68 //      alifast.Clear();       // Clear all event lists
  69 //   }
  70 //   alifast.Finish();
  71 //
  72 //   // save objects in Root file
  73 //   alifast.Write();  //save main alifast object (and run parameters)
  74 //}
  75 //========================================================================
  76 //                                                                      //
  77 // This example illustrates how to:                                     //
  78 //    - Load a shared library                                           //
  79 //    - Open a Root file                                                //
  80 //    - Initialise AliFast                                              //
  81 //    - Load some user code (interpreted)                               //
  82 //      This user code may redefine some Maker parameters               //
  83 //    - Make a loop on events                                           //
  84 //    - Save histograms and the main AliFast object and its Makers      //
  85 //                                                                      //
  86 //========================================================================
  87 //  An example of a User class is given below:                          //
  88 //========================================================================
  89 //
  90 //#ifndef user_H
  91 //#define user_H
  92 //
  93 //////////////////////////////////////////////////////////////////////////
  94 //                                                                      //
  95 // User                                                                 //
  96 //                                                                      //
  97 // Example of a user class to perform user specific tasks when running  //
  98 // the ALIfast program.                                                 //
  99 //                                                                      //
 100 // This class illustrates:                                              //
 101 //   - How to set run parameters                                        //
 102 //   - How to create and fill histograms                                //
 103 //                                                                      //
 104 //////////////////////////////////////////////////////////////////////////
 105 //
 106 //class TH1F;
 107 //class AliFast;
 108 //class AliFClusterMaker;
 109 //class AliFPhotonMaker;
 110 //
 111 //class User {
 112 //
 113 //private:
 114 //   TH1F             *fhist1;       //pointer to histogram
 115 //   TH1F             *fhist2;       //pointer to histogram
 116 //   TH1F             *fhist3;       //pointer to histogram
 117 //public:
 118 //               User();
 119 //   void        FillHistograms();
 120 //   void        SetRunParameters();
 121 //
 122 //#endif
 123 //};
 124 //
 125 //_________________________________________________________________________
 126 //User::User()
 127 //{
 128 //   SetRunParameters();  //change default parameters
 129 //
 130 //         Create a few histograms
 131 //   fhist1 = new TH1F("hist1","Number of tracks per event",100,0,100);
 132 //   fhist2 = new TH1F("hist2","Number of clusters",100,0,100);
 133 //   fhist3 = new TH1F("hist3","Number of isolated muons",20,0,20);
 134 //}
 135 //
 136 //_________________________________________________________________________
 137 //void User::FillHistograms()
 138 //{
 139 ////   fhist1.Fill(event->GetNtracks());
 140 ////   fhist2.Fill(event->GetNclusters));
 141 ////   fhist3.Fill(event->GetNIsoMuons());
 142 //}
 143 //
 144 //_________________________________________________________________________
 145 //void User::SetRunParameters()
 146 //{
 147 //  // change Alifast default parameters
 148 //
 149 //   gAliFast->SetSmearMuonOpt(0);
 150 //   gAliFast->ClusterMaker()->SetGranBarrelEta(0.12);
 151 //   gAliFast->PhotonMaker()->SetMinPT(6.);
 152 //   gAliFast->TriggerMaker()->SetMuoEtaCoverage(2.8);
 153 //
 154 //}
 155 //======================end of User class=================================
 156 //
 157 //////////////////////////////////////////////////////////////////////////
 158
 159 #include <TROOT.h>
 160 #include <TChain.h>
 161 #include <TTree.h>
 162 #include <TBrowser.h>
 163 #include <TClonesArray.h>
 164 #include "AliRun.h"
 165 #include "AliFast.h"
 166 //#include "AliFMCMaker.h"
 167 #include "AliFTrackMaker.h"
 168 #include "AliFHistBrowser.h"
 169 #include "AliFBigBang.h"
 170 #include "AliFVirtualDisplay.h"
 171
 172
 173 R__EXTERN AliRun * gAlice;
 174 AliFast *gAliFast;
 175
 176 ClassImp(AliFast)
 177
 178
 179 //_____________________________________________________________________________
 180   //AliFast::AliFast() : TNamed("alifast","The ALICE fast simulation")
 181   AliFast::AliFast() : AliRun("alifast","The ALICE fast simulation")
 182 {
 183
 184    fTree          = 0;
 185    fMakers        = 0;
 186    fMode          = 0;
 187    fMCMaker       = 0;
 188    fTrackMaker    = 0;
 189    fDisplay       = 0;
 190    fDet           = new AliFDet("Detector","Make AliFast detector");
 191    gAliFast     = this;
 192    gAlice       = (AliRun*)this;
 193 }
 194
 195 //_____________________________________________________________________________
 196 //AliFast::AliFast(const char *name, const char *title): TNamed(name,title)
 197 AliFast::AliFast(const char *name, const char *title): AliRun(name,title)
 198 {
 199
 200    gAliFast      = this;
 201    fVersion     = 001;       //AliFAST  version number and release date
 202    fVersionDate = 150399;
 203    fTree        = 0;
 204    fMode        = 0;
 205    fDisplay     = 0;
 206
 207    SetDefaultParameters();
 208
 209    gROOT->GetListOfBrowsables()->Add(this,"AliFast");
 210
 211 // create the support list for the various lists of AliFast objects
 212    fMakers  = new TList();
 213
 214 // create "standard" makers and add them to the list of makers (in AliFMaker constructor
 215 // Note that the order in which makers are added to the list of makers is important
 216 // makers will be processed in this order !!
 217
 218    //fMCMaker       = new AliFMCMaker("MCMaker","Make MC events");
 219    fTrackMaker    = new AliFTrackMaker("TrackMaker","Make AliFast tracks");
 220 //create detector
 221    fDet           = new AliFDet("Detector","Make AliFast detector");
 222 }
 223
 224 //_____________________________________________________________________________
 225 AliFast::~AliFast()
 226 {
 227 //   fMakers->Delete();
 228 //   delete fMakers;
 229 }
 230
 231
 232 //______________________________________________________________________________
 233 void AliFast::Browse(TBrowser *b)
 234 {
 235
 236   if( b == 0) return;
 237
 238   if (fTree) b->Add(fTree,fTree->GetName());
 239   // fca
 240   b->Add(&fHistBrowser, "Histograms");
 241   b->Add(&fBigBang, "BigBang");
 242   // fca
 243
 244   TIter next(fMakers);
 245   AliFMaker *maker;
 246   while ((maker = (AliFMaker*)next())) {
 247      b->Add(maker,maker->GetName());
 248    }
 249 }
 250
 251 //_____________________________________________________________________________
 252 void AliFast::Clear(Option_t *option)
 253 {
 254 //    Reset lists of event objects
 255    TIter next(fMakers);
 256    AliFMaker *maker;
 257    while ((maker = (AliFMaker*)next())) {
 258       maker->Clear(option);
 259    }
 260    //fca   if (fDisplay) fDisplay->Clear();
 261 }
 262
 263 //_____________________________________________________________________________
 264 void AliFast::Draw(Option_t *option)
 265 {
 266 //    Insert current event in graphics pad list
 267
 268     // Check if the Event Display object has been created
 269    if (!fDisplay) {
 270       Error("Draw","You must create an AliFDisplay object first");
 271       return;
 272    }
 273
 274    //fca   fDisplay->Draw(option);
 275 }
 276
 277 //_____________________________________________________________________________
 278 void  AliFast::GetTreeEvent(Int_t event)
 279 {
 280 //    Read event from Tree
 281    if (fTree) fTree->GetEvent(event);
 282    fEvent = event;
 283 }
 284
 285 //_____________________________________________________________________________
 286 void AliFast::Init()
 287 {
 288 //  Initialise detector
 289    AliFDet *detector=gAliFast->Detector();
 290    detector->InitDetParam();
 291
 292 //    Initialise makers
 293    TIter next(fMakers);
 294    AliFMaker *maker;
 295    TObject *objfirst, *objlast;
 296    while ((maker = (AliFMaker*)next())) {
 297      // save last created histogram in current Root directory
 298       objlast = gDirectory->GetList()->Last();
 299
 300      // Initialise maker
 301       maker->Init();
 302
 303      // Add Maker histograms in Maker list of histograms
 304       if (objlast) objfirst = gDirectory->GetList()->After(objlast);
 305       else         objfirst = gDirectory->GetList()->First();
 306       while (objfirst) {
 307          maker->Histograms()->Add(objfirst);
 308          objfirst = gDirectory->GetList()->After(objfirst);
 309       }
 310    }
 311
 312 }
 313
 314 //_____________________________________________________________________________
 315 void AliFast::Paint(Option_t *option)
 316 {
 317 //    Paint AliFast objects
 318
 319   //fca   fDisplay->Paint(option);
 320 }
 321
 322 //_____________________________________________________________________________
 323 void AliFast::PrintInfo()
 324 {
 325 //     Gives information about versions etc.
 326    printf("\n\n");
 327    printf("**************************************************************\n");
 328    printf("*             AliFast version:00%1d     last update  %6d    *\n",
 329                                                        fVersion, fVersionDate);
 330    printf("**************************************************************\n");
 331    printf("*                                                            *\n");
 332    printf("*     Simulates and reconstructs  events on particle level   *\n");
 333    printf("*     Package by: Yiota Foka and Elzbieta Richter-Was        *\n");
 334    printf("*           Design based on ATLFast++                        *\n");
 335    printf("*         by R. Brun and E. Richter-Was                      *\n");
 336    printf("**************************************************************\n");
 337    printf("\n\n");
 338
 339 //     Print info for detector geometry
 340    AliFDet *detector=gAliFast->Detector();
 341    detector->PrintDetInfo();
 342
 343 //     Print info for all defined Makers
 344    TIter next(fMakers);
 345    AliFMaker *maker;
 346    while ((maker = (AliFMaker*)next())) {
 347       maker->PrintInfo();
 348    }
 349 }
 350
 351 //_____________________________________________________________________________
 352 void AliFast::FillTree()
 353 {
 354 //  Fill the ROOT tree, looping on all active branches
 355
 356   // Clean generated particles (depending on option Save)
 357   //MCMaker()->CleanParticles();
 358
 359   // Now ready to fill the Root Tree
 360    if(fTree) fTree->Fill();
 361 }
 362
 363 //_____________________________________________________________________________
 364 void AliFast::InitChain(TChain *chain)
 365 {
 366 //  Initialize branch addresses for all makers in a TChain
 367
 368    if (chain == 0) return;
 369
 370    fTree = chain;
 371
 372    TIter next(fMakers);
 373    AliFMaker *maker;
 374    while ((maker = (AliFMaker*)next())) {
 375       maker->SetChainAddress(chain);
 376    }
 377 }
 378
 379 //_____________________________________________________________________________
 380 void AliFast::MakeTree(const char* name, const char*title)
 381 {
 382 //  Create a ROOT tree
 383 //  Loop on all makers to create the Root branch (if any)
 384
 385    if (fTree) return;
 386
 387    fTree = new TTree(name,title);
 388
 389    TIter next(fMakers);
 390    AliFMaker *maker;
 391    while ((maker = (AliFMaker*)next())) {
 392       maker->MakeBranch();
 393    }
 394 }
 395
 396 //_____________________________________________________________________________
 397 void AliFast::SetDefaultParameters()
 398 {
 399
 400 //    Setters for flags and switches
 401    SetLuminosity();
 402    SetBfield();
 403    SetSmearing();
 404    SetSUSYcodeLSP();
 405    SetTrackFinding();
 406 }
 407
 408 //_____________________________________________________________________________
 409 void AliFast::Make(Int_t i)
 410 {
 411    fEvent = i;
 412
 413 //   Loop on all makers
 414    TIter next(fMakers);
 415    AliFMaker *maker;
 416    while ((maker = (AliFMaker*)next())) {
 417       maker->Make();
 418    }
 419
 420 }
 421
 422 //_____________________________________________________________________________
 423 void AliFast::FillClone()
 424 {
 425    // Fill Makers fruits clones
 426
 427    TIter next(fMakers);
 428    AliFMaker *maker;
 429    while ((maker = (AliFMaker*)next())) {
 430       maker->FillClone();
 431    }
 432 }
 433
 434 //_____________________________________________________________________________
 435 void AliFast::Finish()
 436 {
 437 //    Terminate a run
 438 //   place to make operations on histograms, normalization,etc.
 439
 440    TIter next(fMakers);
 441    AliFMaker *maker;
 442    while ((maker = (AliFMaker*)next())) {
 443       maker->Finish();
 444    }
 445 }
 446
 447 //_____________________________________________________________________________
 448 void AliFast::SortDown(Int_t n1, Float_t *a, Int_t *index, Bool_t down)
 449 {
 450 //  sort the n1 elements of array a.
 451 //  In output the array index contains the indices of the sorted array.
 452 //  if down is false sort in increasing order (default is decreasing order)
 453 //   This is a translation of the CERNLIB routine sortzv (M101)
 454 //   based on the quicksort algorithm
 455
 456    Int_t i,i1,n,i2,i3,i33,i222,iswap,n2;
 457    Int_t i22 = 0;
 458    Float_t ai;
 459    n = n1;
 460    if (n <= 0) return;
 461    if (n == 1) {index[0] = 0; return;}
 462    for (i=0;i<n;i++) index[i] = i+1;
 463    for (i1=2;i1<=n;i1++) {
 464       i3 = i1;
 465       i33 = index[i3-1];
 466       ai  = a[i33-1];
 467       while(1) {
 468          i2 = i3/2;
 469          if (i2 <= 0) break;
 470          i22 = index[i2-1];
 471          if (ai <= a[i22-1]) break;
 472          index[i3-1] = i22;
 473          i3 = i2;
 474       }
 475       index[i3-1] = i33;
 476    }
 477
 478    while(1) {
 479       i3 = index[n-1];
 480       index[n-1] = index[0];
 481       ai = a[i3-1];
 482       n--;
 483       if(n-1 < 0) {index[0] = i3; break;}
 484       i1 = 1;
 485       while(2) {
 486          i2 = i1+i1;
 487          if (i2 <= n) i22 = index[i2-1];
 488          if (i2-n > 0) {index[i1-1] = i3; break;}
 489          if (i2-n < 0) {
 490             i222 = index[i2];
 491             if (a[i22-1] - a[i222-1] < 0) {
 492                 i2++;
 493                 i22 = i222;
 494             }
 495          }
 496          if (ai - a[i22-1] > 0) {index[i1-1] = i3; break;}
 497          index[i1-1] = i22;
 498          i1 = i2;
 499       }
 500    }
 501    if (!down) return;
 502    n2 = n1/2;
 503    for (i=0;i<n1;i++) index[i]--;
 504    for (i=0;i<n2;i++) {
 505       iswap         = index[i];
 506       index[i]      = index[n1-i-1];
 507       index[n1-i-1] = iswap;
 508    }
 509 }
 510 //______________________________________________________________________________
 511 void AliFast::Streamer(TBuffer &R__b)
 512 {
 513    // Stream an object of class AliFast.
 514
 515    if (R__b.IsReading()) {
 516       UInt_t R__s, R__c;
 517       if (!gAliFast) gAliFast = this;
 518       gROOT->GetListOfBrowsables()->Add(this,"AliFast");
 519
 520       Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
 521
 522       AliFast::Class()->ReadBuffer(R__b, this, R__v, R__s, R__c);
 523
 524       fTree = (TTree*)gDirectory->Get("T");
 525    } else {
 526        AliFast::Class()->WriteBuffer(R__b,this);
 527    }
 528 }
 529
 530
 531
 532
 533