X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=EVGEN%2FAliGenCocktailAfterBurner.cxx;h=197ad618981c6b3524b099f716fc2ba6965ec23d;hb=856c0dbecf5d6c3231b0eaacfa24b11b2d51a30f;hp=98135ed14c953c0841c6acaa694b538098e2db6d;hpb=984c69bd8979f6e3af7f504f309f996665be628f;p=u%2Fmrichter%2FAliRoot.git

diff --git a/EVGEN/AliGenCocktailAfterBurner.cxx b/EVGEN/AliGenCocktailAfterBurner.cxx
index 98135ed14c9..197ad618981 100644
--- a/EVGEN/AliGenCocktailAfterBurner.cxx
+++ b/EVGEN/AliGenCocktailAfterBurner.cxx
@@ -13,6 +13,8 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
+
 // 
 // Container class for AliGenerator and AfterBurners 
 // (which are AliGenerators as well) through recursion.
@@ -23,42 +25,64 @@
 // The class provides also iterator functionality.  
 // Author: andreas.morsch@cern.ch and piotr.skowronski@cern.ch
 //
+// 24.09.2001  Piotr Skowronski
+//             debug -> gDebug,
+//             fNEvents replaced with gAlice->GetEventsPerRun()
+//
+
+
+#include <Riostream.h>
+
+#include <TList.h>
+#include <TObjArray.h>
+#include <TParticle.h>
 
 #include "AliGenCocktailAfterBurner.h"
 #include "AliGenCocktailEntry.h"
-#include "AliRun.h"
+#include "AliCollisionGeometry.h"
 #include "AliStack.h"
-#include <TObjArray.h>
-#include <TList.h>
-#include <TParticle.h>
-#include <iostream.h>
+#include "AliMC.h"
+
 
-static const Bool_t debug = kFALSE;
 ClassImp(AliGenCocktailAfterBurner)
+/*********************************************************************/ 
+/*********************************************************************/ 
 
-AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()
+    AliGenCocktailAfterBurner::AliGenCocktailAfterBurner():
+	fNAfterBurners(0),
+	fAfterBurnerEntries(new TList()),
+	fGenerationDone(kFALSE),
+	fInternalStacks(0),
+	fCollisionGeometries(0),
+	fCurrentEvent(0),
+	fActiveStack(0),
+	fActiveEvent(-1),
+	fCurrentGenerator(0),
+	fNBgEvents(0)
 {
 // Constructor
-    if (debug) 
+    if (gDebug > 0) 
 	cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
     SetName("AliGenCocktailAfterBurner");
     SetTitle("AliGenCocktailAfterBurner");
-    fInternalStacks =0;
-    fCurrentEvent =0;
-    fAfterBurnerEntries = new TList();
-    fNAfterBurners = 0;
-    fGenerationDone = kFALSE;
-    
-    fActiveEvent = -1;  
 }
 
+/*********************************************************************/ 
 
 AliGenCocktailAfterBurner::~AliGenCocktailAfterBurner()
   {
-    fInternalStacks->SetOwner();
-    delete fInternalStacks;
-    delete fAfterBurnerEntries;
+//destructor
+
+    if (fInternalStacks) //delete stacks
+     { 
+       fInternalStacks->SetOwner();
+       delete fInternalStacks;
+    }
+    if (fAfterBurnerEntries) delete fAfterBurnerEntries; //delete entries
+    delete[] fCollisionGeometries;
   }
+/*********************************************************************/ 
+/*********************************************************************/ 
 
 void AliGenCocktailAfterBurner::
 AddAfterBurner(AliGenerator *AfterBurner, char* Name, Float_t RateExp)
@@ -66,7 +90,7 @@ AddAfterBurner(AliGenerator *AfterBurner, char* Name, Float_t RateExp)
 //
 //  Forward parameters to the new AfterBurner
     
-    if (debug)cout<<"AliGenCocktailAfterBurner::AddAfterBurner  Named "<<Name<<endl;
+    if (gDebug>0)cout<<"AliGenCocktailAfterBurner::AddAfterBurner  Named "<<Name<<endl;
 
     if(TestBit(kPtRange)) 
 	AfterBurner->SetPtRange(fPtMin,fPtMax);
@@ -74,14 +98,10 @@ AddAfterBurner(AliGenerator *AfterBurner, char* Name, Float_t RateExp)
 	AfterBurner->SetMomentumRange(fPMin,fPMax);
     
     AfterBurner->SetYRange(fYMin,fYMax);
-    AfterBurner->
-	SetPhiRange(fPhiMin*180/TMath::Pi(),fPhiMax*180/TMath::Pi());
-    AfterBurner->
-	SetThetaRange(fThetaMin*180/TMath::Pi(),fThetaMax*180/TMath::Pi());
-    AfterBurner->
-	SetOrigin(fOrigin[0], fOrigin[1], fOrigin[2]);
-    AfterBurner->
-	SetSigma(fOsigma[0], fOsigma[1], fOsigma[2]);
+    AfterBurner->SetPhiRange(fPhiMin*180/TMath::Pi(),fPhiMax*180/TMath::Pi());
+    AfterBurner->SetThetaRange(fThetaMin*180/TMath::Pi(),fThetaMax*180/TMath::Pi());
+    AfterBurner->SetOrigin(fOrigin[0], fOrigin[1], fOrigin[2]);
+    AfterBurner->SetSigma(fOsigma[0], fOsigma[1], fOsigma[2]);
     AfterBurner->SetVertexSmear(fVertexSmear);
     AfterBurner->SetTrackingFlag(fTrackIt);    
 //
@@ -92,16 +112,28 @@ AddAfterBurner(AliGenerator *AfterBurner, char* Name, Float_t RateExp)
     fAfterBurnerEntries->Add(entry);
     fNAfterBurners++;
 //
-    SetNumberOfEvents(gAlice->GetEventsPerRun());
     
 }
+/*********************************************************************/ 
+/*********************************************************************/ 
 
 void AliGenCocktailAfterBurner::Init()
 {
 // Initialisation
+    fGenerationDone = kFALSE;
+    if (fInternalStacks) //delete stacks
+     { 
+       fInternalStacks->SetOwner();
+       fInternalStacks->Delete(); //clean after previous generation cycle
+     }
+
+// ANDREAS MORSCH ---------------------------------------------------(
+    if (fCollisionGeometries) delete[] fCollisionGeometries;
+// ANDREAS MORSCH ---------------------------------------------------)
+    
     this->AliGenCocktail::Init(); 
     
-    if (debug) cout<<"AliGenCocktailAfterBurner::Init"<<endl;
+    if (gDebug>0) cout<<"AliGenCocktailAfterBurner::Init"<<endl;
     TIter next(fAfterBurnerEntries);
     AliGenCocktailEntry *entry;
     //
@@ -110,202 +142,254 @@ void AliGenCocktailAfterBurner::Init()
 	entry->Generator()->Init();
     }  
 }
+/*********************************************************************/ 
+/*********************************************************************/ 
 
 void AliGenCocktailAfterBurner::Generate()
 {
 //
-// Generate event 
-    if (debug)cout<<"#####################################"<<endl
-                  <<"#AliGenCocktailAfterBurner::Generate#"
-		  <<endl<<"#####################################"<<endl;
+// Generate event
+//  Firsts runs each generator for all events
+//  than after burners ones for each event
+//
+//  It generates and processes all events during
+//  first call only.
+//  In next calls it just returns already generated 
+//  and processed events to the gAlice
+
+    if (gDebug>0)
+      cout<<"#####################################"<<endl
+          <<"#AliGenCocktailAfterBurner::Generate#"<<endl
+          <<"#####################################"<<endl;
     
     Int_t i; //iterator
     AliStack * stack;
+    
     if (fGenerationDone)
-    { 
-	SetTracks(++fCurrentEvent);
-	cout<<"Returning event "<<fCurrentEvent<<endl;
-	return;  
+    {//if generation is done (in first call) 
+     //just copy particles from the stack to the gAlice
+      SetTracks(++fCurrentEvent);
+      cout<<"Returning event "<<fCurrentEvent<<endl;
+      return;  
     }
     else
-    { 
-	fCurrentEvent=0;
-	fInternalStacks = new TObjArray(fNumberOfEvents); //Create array of internal stacks
-	for(i=0;i<fNumberOfEvents;i++) 
-	{	
-	    stack = new AliStack(10000);
-	    stack->Reset();
-	    fInternalStacks->Add(stack);
-	}
+    { //Here we are in the first call of the method
+      fCurrentEvent=0;
+      Int_t numberOfEvents = gAlice->GetEventsPerRun();
+      //Create stacks
+      fInternalStacks      = new TObjArray(numberOfEvents + fNBgEvents); //Create array of internal stacks
+      fCollisionGeometries = new AliCollisionGeometry*[numberOfEvents + fNBgEvents]; //Create array of collision geometries
+      for(i=0;i<numberOfEvents + fNBgEvents;i++) 
+       {	
+        stack = new AliStack(10000);
+        stack->Reset();
+        fInternalStacks->Add(stack);
+       }
 /*********************************************************************/ 
-	TIter next(fEntries);
-	AliGenCocktailEntry *entry;
-	AliGenCocktailEntry *e1;
-	AliGenCocktailEntry *e2;
-	TObjArray *partArray;
-	//
-	// Loop over generators and generate events
-	Int_t igen=0;
-	while((entry = (AliGenCocktailEntry*)next())) 
-	{
-	    igen++;
-	    cout<<"Generator number "<<igen<<endl;
-	    /***********************************************/
+      TIter next(fEntries);
+      AliGenCocktailEntry *entry;
+      AliGenCocktailEntry *e1;
+      AliGenCocktailEntry *e2;
+      const TObjArray *partArray;
+  //
+  // Loop over generators and generate events
+      Int_t igen=0;
+      while((entry = (AliGenCocktailEntry*)next())) 
+      {
+        igen++;
+        cout<<"Generator "<<igen<<"  : "<<entry->GetName()<<endl;
+/***********************************************/
 //First generator for all evenets, than second for all events, etc...
-	    for(i=0;i<fNumberOfEvents;i++) 
-	    {  
+        for(i=0;i<numberOfEvents + fNBgEvents;i++) 
+          {  
+            cout<<"                  EVENT "<<i<<endl;
+            stack = GetStack(i);
+            partArray = stack->Particles();
+            fCurrentGenerator = entry->Generator();
+            fCurrentGenerator->SetStack(stack);
+            if (igen ==1) 
+              {
+                entry->SetFirst(0);
+              } 
+            else 
+              {
+                entry->SetFirst((partArray->GetEntriesFast())+1);
+              }
+                fCurrentGenerator->Generate();
+                entry->SetLast(partArray->GetEntriesFast());
 		
-		cout<<"                  EVENT "<<i<<endl;
-		stack = GetStack(i);
-		partArray = stack->Particles();
-		fCurrentGenerator = entry->Generator();
-		fCurrentGenerator->SetStack(stack);
+// ANDREAS MORSCH ---------------------------------------------------(
+		if (fCurrentGenerator->ProvidesCollisionGeometry())  fCollisionGeometries[i] = fCurrentGenerator->CollisionGeometry();
+// ANDREAS MORSCH ---------------------------------------------------)
 		
-		if (igen ==1) 
-		{
-		    entry->SetFirst(0);
-		} 
-		else 
-		{
-		    entry->SetFirst((partArray->GetEntriesFast())+1);
-		}
-		fCurrentGenerator->Generate();
-		entry->SetLast(partArray->GetEntriesFast());
-	    }
-	    /***********************************************/
-	}
-	next.Reset();
-	while((entry = (AliGenCocktailEntry*)next())) 
-	{
-	    entry->PrintInfo();
-	}
-	for ( entry=FirstGenerator();entry;entry=NextGenerator() ) 
-	{
-	    entry->PrintInfo();
-	}
-	
-	for (FirstGeneratorPair(e1,e2); (e1&&e2); NextGeneratorPair(e1,e2) )
-	{
-	    printf("\n -----------------------------");
-	    e1->PrintInfo();
-	    e2->PrintInfo();
+           }
+/***********************************************/
+      }
+      next.Reset();
+      while((entry = (AliGenCocktailEntry*)next())) 
+        {
+          entry->PrintInfo();
+        }
+      for ( entry=FirstGenerator();entry;entry=NextGenerator() ) 
+        {
+          entry->PrintInfo();
+        }
+      for (FirstGeneratorPair(e1,e2); (e1&&e2); NextGeneratorPair(e1,e2) )
+        {
+          printf("\n -----------------------------");
+          e1->PrintInfo();
+          e2->PrintInfo();
         }
 	
-	/***********************************************/
-	/*******After Burners Processing****************/
-	/***********************************************/
-	TIter nextAfterBurner(fAfterBurnerEntries);
-	AliGenCocktailEntry *afterBurnerEntry;
-	Int_t iab =0;
-	cout<<"\n\nRunning After Burners"<<endl;
-	while((afterBurnerEntry = (AliGenCocktailEntry*)nextAfterBurner()))
-	{
-	    cout<<"After Burner number "<<iab++<<endl;
-	    fCurrentGenerator = afterBurnerEntry->Generator();
-	    fCurrentGenerator->Generate();
-	}
-	cout<<endl<<"Finished. Processed "<<iab<<" After Burners"<<endl;
 	
-	/***********************************************/
-	/***********************************************/
-	/***********************************************/       
+      /***********************************************/
+      /*******After Burners Processing****************/
+      /***********************************************/
+      TIter nextAfterBurner(fAfterBurnerEntries);
+      AliGenCocktailEntry *afterBurnerEntry;
+      Int_t iab =0; //number of current after burner / counter
+      
+      cout<<"\n\nRunning After Burners"<<endl;
+      while((afterBurnerEntry = (AliGenCocktailEntry*)nextAfterBurner()))
+        {
+          cout<<"After Burner "<<iab++<<"  :"<<afterBurnerEntry->GetName()<<endl;
+          fCurrentGenerator = afterBurnerEntry->Generator();
+          fCurrentGenerator->Generate();
+        }
+      cout<<endl<<"Finished. Processed "<<iab<<" After Burners"<<endl;
+
+      /***********************************************/
+      /***********************************************/
+      /***********************************************/       
         
-	fGenerationDone=kTRUE; 
-	SetTracks(0); //copy event 0 to gAlice stack
+      fGenerationDone=kTRUE; 
+      SetTracks(0); //copy event 0 to gAlice stack
 	
 /*********************************************************************/
 	
     }//else generated
 }
+/*********************************************************************/
+/*********************************************************************/ 
 
-
-AliGenCocktailAfterBurner& AliGenCocktailAfterBurner::operator=(const  AliGenCocktailAfterBurner& rhs)
+AliStack* AliGenCocktailAfterBurner::GetStack(Int_t n) const
 {
-// Assignment operator
-    return *this;
+//Returns the pointer to the N'th stack (event)
+  if( ( n<0 ) || ( n>=GetNumberOfEvents() ) )
+    {
+      Fatal("AliGenCocktailAfterBurner::GetStack","Asked for non existing stack (%d)",n);
+      return 0; 
+    }
+    return ((AliStack*) fInternalStacks->At(n) );
 }
 
+/*********************************************************************/ 
+/*********************************************************************/ 
+
+// ANDREAS MORSCH ---------------------------------------------------(
 
-AliStack* AliGenCocktailAfterBurner::GetStack(Int_t n)
+AliCollisionGeometry* AliGenCocktailAfterBurner::GetCollisionGeometry(Int_t n) const
 {
-    if( (n<0) || (n>=fNumberOfEvents) )
+//Returns the pointer to the N'th stack (event)
+  if( ( n<0 ) || ( n>=GetNumberOfEvents() ) )
     {
-	Fatal("AliGenCocktailAfterBurner::GetStack","Asked for non existing stack (%d)",n);
-	return 0; 
+      Fatal("AliGenCocktailAfterBurner::GetCollisionGeometry","Asked for non existing stack (%d)",n);
+      return 0; 
     }
-    return ((AliStack*) ((*fInternalStacks)[n]) );
+    return fCollisionGeometries[n];
 }
 
+// ANDREAS MORSCH ---------------------------------------------------)
+
+/*********************************************************************/ 
+/*********************************************************************/ 
+
 void AliGenCocktailAfterBurner::SetActiveEventNumber(Int_t actev)
 {
+//Set Active Events Number and Active Stack
+//There is only one active event number
+//Made fo convinience of work with AfterBurners (HBT processor)
+
     fActiveEvent = actev;
     fActiveStack = GetStack(actev);
 }
+/*********************************************************************/ 
+/*********************************************************************/ 
 
 void AliGenCocktailAfterBurner::SetTracks(Int_t stackno)
 {
+//Method which copies tracks from given stack to the
+//gAlice's stack
     AliStack* instack = GetStack(stackno);
     Int_t done;
     Int_t parent; 
     Int_t pdg;
     Double_t px, py, pz, e, vx, vy, vz, tof, polx, poly, polz;
-    AliMCProcess mech;
+    TMCProcess mech;
     Int_t ntr;
     Float_t weight;
     TVector3 pol;
     
     TParticle * p;
-    Int_t N = instack->GetNtrack();
-    if (debug) 
+    Int_t n = instack->GetNtrack();
+    if (gDebug) 
     {
-	cout<<"AliGenCocktailAfterBurner::SetTracks("<<stackno<<"). Number of particles is: "<<N<<"\n";
+      cout<<"AliGenCocktailAfterBurner::SetTracks("<<stackno<<"). Number of particles is: "<<n<<"\n";
     }
     
-    for(Int_t i = 0; i < N; i++)
+    for(Int_t i = 0; i < n; i++)
     {
 	
-	p = instack->Particle(i);
-	done = !p->TestBit(kDoneBit);
-	if (debug) {cout<<i<<"  "<<done<<"  "; fflush(0);}
-	parent = p->GetMother(0);
-	pdg = p->GetPdgCode();
-	px = p->Px();
-	py = p->Py();
-	pz = p->Pz();
-	e  = p->Energy();
-	vx = p->Vx();
-	vy = p->Vy();
-	vz = p->Vz();
-	tof = p->T();
-	p->GetPolarisation(pol);
-	polx = pol.X();
-	poly = pol.Y();
-	polz = pol.Z();
-	mech = AliGenCocktailAfterBurner::IntToMCProcess(p->GetUniqueID());
-	weight = p->GetWeight();
-	
-	gAlice->SetTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
-			 polx, poly, polz, mech, ntr, weight);
+      p = instack->Particle(i);
+      done = !p->TestBit(kDoneBit);
+      parent = p->GetMother(0);
+      pdg = p->GetPdgCode();
+      px = p->Px();
+      py = p->Py();
+      pz = p->Pz();
+      e  = p->Energy();
+      vx = p->Vx();
+      vy = p->Vy();
+      vz = p->Vz();
+      tof = p->T();
+      p->GetPolarisation(pol);
+      polx = pol.X();
+      poly = pol.Y();
+      polz = pol.Z();
+      mech = AliGenCocktailAfterBurner::IntToMCProcess(p->GetUniqueID());
+      weight = p->GetWeight();
+
+      gAlice->GetMCApp()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,polx, poly, polz, mech, ntr, weight);
+
+// ANDREAS MORSCH ---------------------------------------------------(
+      SetHighWaterMark(ntr) ; 
+// ANDREAS MORSCH ---------------------------------------------------)
+
     }
 }
+/*********************************************************************/ 
+/*********************************************************************/ 
 
-AliMCProcess AliGenCocktailAfterBurner::IntToMCProcess(Int_t no)
+TMCProcess AliGenCocktailAfterBurner::IntToMCProcess(Int_t no)
 {
-    const AliMCProcess MCprocesses[kMaxMCProcess] = 
-    {kPNoProcess, kPMultipleScattering, kPEnergyLoss, kPMagneticFieldL, 
+ //Mothod used to convert uniqueID (integer) to TMCProcess type
+    const TMCProcess kMCprocesses[kMaxMCProcess] = 
+    {
+     kPNoProcess, kPMultipleScattering, kPEnergyLoss, kPMagneticFieldL, 
      kPDecay, kPPair, kPCompton, kPPhotoelectric, kPBrem, kPDeltaRay,
      kPAnnihilation, kPHadronic, kPNoProcess, kPEvaporation, kPNuclearFission,
      kPNuclearAbsorption, kPPbarAnnihilation, kPNCapture, kPHElastic, 
      kPHInhelastic, kPMuonNuclear, kPTOFlimit,kPPhotoFission, kPNoProcess, 
-     kPRayleigh, kPNoProcess, kPNoProcess, kPNoProcess, kPNull, kPStop};
+     kPRayleigh, kPNoProcess, kPNoProcess, kPNoProcess, kPNull, kPStop
+    };
     
     for (Int_t i = 0;i<kMaxMCProcess;i++)
     {
-	if (MCprocesses[i] == no)
-	{
-	    //if (debug) cout<<"IntToMCProcess("<<no<<") returned AliMCProcess Named \""<<AliMCProcessName[MCprocesses[i]]<<"\""<<endl;
-	    return MCprocesses[i];
-	}
+      if (kMCprocesses[i] == no)
+        {
+          return kMCprocesses[i];
+        }
     } 
     return kPNoProcess;
 }
+