EVGEN/AliGenCocktailAfterBurner.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 //
  17 // Container class for AliGenerator and AfterBurners
  18 // (which are AliGenerators as well) through recursion.
  19 // The container is itself an AliGenerator a
  20 // what is stored are not the pointers to the generators directly
  21 // but to objects of type
  22 // AliGenCocktailAfterBurner entry.
  23 // The class provides also iterator functionality.
  24 // Author: andreas.morsch@cern.ch and piotr.skowronski@cern.ch
  25 //
  26
  27 #include "AliGenCocktailAfterBurner.h"
  28 #include "AliGenCocktailEntry.h"
  29 #include "AliRun.h"
  30 #include "AliStack.h"
  31 #include <TObjArray.h>
  32 #include <TList.h>
  33 #include <TParticle.h>
  34 #include <iostream.h>
  35
  36 static const Bool_t debug = kFALSE;
  37 ClassImp(AliGenCocktailAfterBurner)
  38
  39 AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()
  40 {
  41 // Constructor
  42     if (debug)
  43         cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
  44     SetName("AliGenCocktailAfterBurner");
  45     SetTitle("AliGenCocktailAfterBurner");
  46     fInternalStacks =0;
  47     fCurrentEvent =0;
  48     fAfterBurnerEntries = new TList();
  49     fNAfterBurners = 0;
  50     fGenerationDone = kFALSE;
  51
  52     fActiveEvent = -1;
  53 }
  54
  55
  56 AliGenCocktailAfterBurner::~AliGenCocktailAfterBurner()
  57   {
  58     fInternalStacks->SetOwner();
  59     delete fInternalStacks;
  60     delete fAfterBurnerEntries;
  61   }
  62
  63 void AliGenCocktailAfterBurner::
  64 AddAfterBurner(AliGenerator *AfterBurner, char* Name, Float_t RateExp)
  65 {
  66 //
  67 //  Forward parameters to the new AfterBurner
  68
  69     if (debug)cout<<"AliGenCocktailAfterBurner::AddAfterBurner  Named "<<Name<<endl;
  70
  71     if(TestBit(kPtRange))
  72         AfterBurner->SetPtRange(fPtMin,fPtMax);
  73     if(TestBit(kMomentumRange))
  74         AfterBurner->SetMomentumRange(fPMin,fPMax);
  75
  76     AfterBurner->SetYRange(fYMin,fYMax);
  77     AfterBurner->
  78         SetPhiRange(fPhiMin*180/TMath::Pi(),fPhiMax*180/TMath::Pi());
  79     AfterBurner->
  80         SetThetaRange(fThetaMin*180/TMath::Pi(),fThetaMax*180/TMath::Pi());
  81     AfterBurner->
  82         SetOrigin(fOrigin[0], fOrigin[1], fOrigin[2]);
  83     AfterBurner->
  84         SetSigma(fOsigma[0], fOsigma[1], fOsigma[2]);
  85     AfterBurner->SetVertexSmear(fVertexSmear);
  86     AfterBurner->SetTrackingFlag(fTrackIt);
  87 //
  88 //  Add AfterBurner to list
  89
  90     AliGenCocktailEntry *entry =
  91         new AliGenCocktailEntry(AfterBurner, Name, RateExp);
  92     fAfterBurnerEntries->Add(entry);
  93     fNAfterBurners++;
  94 //
  95     SetNumberOfEvents(gAlice->GetEventsPerRun());
  96
  97 }
  98
  99 void AliGenCocktailAfterBurner::Init()
 100 {
 101 // Initialisation
 102     this->AliGenCocktail::Init();
 103
 104     if (debug) cout<<"AliGenCocktailAfterBurner::Init"<<endl;
 105     TIter next(fAfterBurnerEntries);
 106     AliGenCocktailEntry *entry;
 107     //
 108     // Loop over generators and initialize
 109     while((entry = (AliGenCocktailEntry*)next())) {
 110         entry->Generator()->Init();
 111     }
 112 }
 113
 114 void AliGenCocktailAfterBurner::Generate()
 115 {
 116 //
 117 // Generate event
 118     if (debug)cout<<"#####################################"<<endl
 119                   <<"#AliGenCocktailAfterBurner::Generate#"
 120                   <<endl<<"#####################################"<<endl;
 121
 122     Int_t i; //iterator
 123     AliStack * stack;
 124     if (fGenerationDone)
 125     {
 126         SetTracks(++fCurrentEvent);
 127         cout<<"Returning event "<<fCurrentEvent<<endl;
 128         return;
 129     }
 130     else
 131     {
 132         fCurrentEvent=0;
 133         fInternalStacks = new TObjArray(fNumberOfEvents); //Create array of internal stacks
 134         for(i=0;i<fNumberOfEvents;i++)
 135         {
 136             stack = new AliStack(10000);
 137             stack->Reset();
 138             fInternalStacks->Add(stack);
 139         }
 140 /*********************************************************************/
 141         TIter next(fEntries);
 142         AliGenCocktailEntry *entry;
 143         AliGenCocktailEntry *e1;
 144         AliGenCocktailEntry *e2;
 145         TObjArray *partArray;
 146         //
 147         // Loop over generators and generate events
 148         Int_t igen=0;
 149         while((entry = (AliGenCocktailEntry*)next()))
 150         {
 151             igen++;
 152             cout<<"Generator number "<<igen<<endl;
 153             /***********************************************/
 154 //First generator for all evenets, than second for all events, etc...
 155             for(i=0;i<fNumberOfEvents;i++)
 156             {
 157
 158                 cout<<"                  EVENT "<<i<<endl;
 159                 stack = GetStack(i);
 160                 partArray = stack->Particles();
 161                 fCurrentGenerator = entry->Generator();
 162                 fCurrentGenerator->SetStack(stack);
 163
 164                 if (igen ==1)
 165                 {
 166                     entry->SetFirst(0);
 167                 }
 168                 else
 169                 {
 170                     entry->SetFirst((partArray->GetEntriesFast())+1);
 171                 }
 172                 fCurrentGenerator->Generate();
 173                 entry->SetLast(partArray->GetEntriesFast());
 174             }
 175             /***********************************************/
 176         }
 177         next.Reset();
 178         while((entry = (AliGenCocktailEntry*)next()))
 179         {
 180             entry->PrintInfo();
 181         }
 182         for ( entry=FirstGenerator();entry;entry=NextGenerator() )
 183         {
 184             entry->PrintInfo();
 185         }
 186
 187         for (FirstGeneratorPair(e1,e2); (e1&&e2); NextGeneratorPair(e1,e2) )
 188         {
 189             printf("\n -----------------------------");
 190             e1->PrintInfo();
 191             e2->PrintInfo();
 192         }
 193
 194         /***********************************************/
 195         /*******After Burners Processing****************/
 196         /***********************************************/
 197         TIter nextAfterBurner(fAfterBurnerEntries);
 198         AliGenCocktailEntry *afterBurnerEntry;
 199         Int_t iab =0;
 200         cout<<"\n\nRunning After Burners"<<endl;
 201         while((afterBurnerEntry = (AliGenCocktailEntry*)nextAfterBurner()))
 202         {
 203             cout<<"After Burner number "<<iab++<<endl;
 204             fCurrentGenerator = afterBurnerEntry->Generator();
 205             fCurrentGenerator->Generate();
 206         }
 207         cout<<endl<<"Finished. Processed "<<iab<<" After Burners"<<endl;
 208
 209         /***********************************************/
 210         /***********************************************/
 211         /***********************************************/
 212
 213         fGenerationDone=kTRUE;
 214         SetTracks(0); //copy event 0 to gAlice stack
 215
 216 /*********************************************************************/
 217
 218     }//else generated
 219 }
 220
 221
 222 AliGenCocktailAfterBurner& AliGenCocktailAfterBurner::operator=(const  AliGenCocktailAfterBurner& rhs)
 223 {
 224 // Assignment operator
 225     return *this;
 226 }
 227
 228
 229 AliStack* AliGenCocktailAfterBurner::GetStack(Int_t n)
 230 {
 231     if( (n<0) || (n>=fNumberOfEvents) )
 232     {
 233         Fatal("AliGenCocktailAfterBurner::GetStack","Asked for non existing stack (%d)",n);
 234         return 0;
 235     }
 236     return ((AliStack*) ((*fInternalStacks)[n]) );
 237 }
 238
 239 void AliGenCocktailAfterBurner::SetActiveEventNumber(Int_t actev)
 240 {
 241     fActiveEvent = actev;
 242     fActiveStack = GetStack(actev);
 243 }
 244
 245 void AliGenCocktailAfterBurner::SetTracks(Int_t stackno)
 246 {
 247     AliStack* instack = GetStack(stackno);
 248     Int_t done;
 249     Int_t parent;
 250     Int_t pdg;
 251     Double_t px, py, pz, e, vx, vy, vz, tof, polx, poly, polz;
 252     AliMCProcess mech;
 253     Int_t ntr;
 254     Float_t weight;
 255     TVector3 pol;
 256
 257     TParticle * p;
 258     Int_t N = instack->GetNtrack();
 259     if (debug)
 260     {
 261         cout<<"AliGenCocktailAfterBurner::SetTracks("<<stackno<<"). Number of particles is: "<<N<<"\n";
 262     }
 263
 264     for(Int_t i = 0; i < N; i++)
 265     {
 266
 267         p = instack->Particle(i);
 268         done = !p->TestBit(kDoneBit);
 269         if (debug) {cout<<i<<"  "<<done<<"  "; fflush(0);}
 270         parent = p->GetMother(0);
 271         pdg = p->GetPdgCode();
 272         px = p->Px();
 273         py = p->Py();
 274         pz = p->Pz();
 275         e  = p->Energy();
 276         vx = p->Vx();
 277         vy = p->Vy();
 278         vz = p->Vz();
 279         tof = p->T();
 280         p->GetPolarisation(pol);
 281         polx = pol.X();
 282         poly = pol.Y();
 283         polz = pol.Z();
 284         mech = AliGenCocktailAfterBurner::IntToMCProcess(p->GetUniqueID());
 285         weight = p->GetWeight();
 286
 287         gAlice->SetTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
 288                          polx, poly, polz, mech, ntr, weight);
 289     }
 290 }
 291
 292 AliMCProcess AliGenCocktailAfterBurner::IntToMCProcess(Int_t no)
 293 {
 294     const AliMCProcess MCprocesses[kMaxMCProcess] =
 295     {kPNoProcess, kPMultipleScattering, kPEnergyLoss, kPMagneticFieldL,
 296      kPDecay, kPPair, kPCompton, kPPhotoelectric, kPBrem, kPDeltaRay,
 297      kPAnnihilation, kPHadronic, kPNoProcess, kPEvaporation, kPNuclearFission,
 298      kPNuclearAbsorption, kPPbarAnnihilation, kPNCapture, kPHElastic,
 299      kPHInhelastic, kPMuonNuclear, kPTOFlimit,kPPhotoFission, kPNoProcess,
 300      kPRayleigh, kPNoProcess, kPNoProcess, kPNoProcess, kPNull, kPStop};
 301
 302     for (Int_t i = 0;i<kMaxMCProcess;i++)
 303     {
 304         if (MCprocesses[i] == no)
 305         {
 306             //if (debug) cout<<"IntToMCProcess("<<no<<") returned AliMCProcess Named \""<<AliMCProcessName[MCprocesses[i]]<<"\""<<endl;
 307             return MCprocesses[i];
 308         }
 309     }
 310     return kPNoProcess;
 311 }