Allowing modularity of the MUON geometry during the generation (geant) phase with...
[u/mrichter/AliRoot.git] / EVGEN / AliGenExtFile.cxx
index 5691c68..a210198 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.7  2000/02/16 14:56:27  morsch
-Convert geant particle code into pdg code before putting particle on the stack.
+/* $Id$ */
 
-Revision 1.6  1999/11/09 07:38:48  fca
-Changes for compatibility with version 2.23 of ROOT
+// Event generator that using an instance of type AliGenReader
+// reads particles from a file and applies cuts.
+// Example: In your Config.C you can include the following lines
+//   AliGenExtFile *gener = new AliGenExtFile(-1);
+//  gener->SetMomentumRange(0,999);
+//  gener->SetPhiRange(-180.,180.);
+//  gener->SetThetaRange(0,180);
+//  gener->SetYRange(-999,999);
+//  AliGenReaderTreeK * reader = new AliGenReaderTreeK();
+//  reader->SetFileName("myFileWithTreeK.root");
+//  gener->SetReader(reader);
+//  gener->Init();
 
-Revision 1.5  1999/09/29 09:24:12  fca
-Introduction of the Copyright and cvs Log
 
-*/
-
-#include <iostream.h>
+#include <Riostream.h>
 
 #include "AliGenExtFile.h"
-#include "AliGenMUONlib.h"
-#include "AliMC.h"
 #include "AliRun.h"
-#include <TDirectory.h>
+
+#include <TParticle.h>
 #include <TFile.h>
 #include <TTree.h>
-#include <stdlib.h>
- ClassImp(AliGenExtFile)
-     AliGenExtFile::AliGenExtFile()
-        :AliGenerator(-1)
+
+
+ClassImp(AliGenExtFile)
+
+AliGenExtFile::AliGenExtFile()
+  :AliGenMC()
 {
 //  Constructor
-    fName="ExtFile";
-    fTitle="Primaries from ext. File";
-    fFileName="dtujet93.root";
-    fTreeNtuple=0;
-    fNcurrent=0;
 //
 //  Read all particles
-    fNpart=-1;
+    fNpart  =- 1;
+    fReader =  0;
 }
 
 AliGenExtFile::AliGenExtFile(Int_t npart)
-    :AliGenerator(npart)
+    :AliGenMC(npart)
 {
 //  Constructor
-    fName="ExtFile";
-    fTitle="Primaries from ext. File";
-    fFileName="dtujet93.root";
-    fTreeNtuple=0;
-    fNcurrent=0;
+    fName   = "ExtFile";
+    fTitle  = "Primaries from ext. File";
+    fReader = 0;
 }
 
-AliGenExtFile::AliGenExtFile(const AliGenExtFile & ExtFile)
+AliGenExtFile::AliGenExtFile(const AliGenExtFile & ExtFile):
+    AliGenMC(ExtFile)
 {
-// copy constructor
+// Copy constructor
+    ExtFile.Copy(*this);
 }
 //____________________________________________________________
 AliGenExtFile::~AliGenExtFile()
 {
 // Destructor
-    delete fTreeNtuple;
+    delete fReader;
 }
 
-//____________________________________________________________
-void AliGenExtFile::NtupleInit() 
+//___________________________________________________________
+void AliGenExtFile::Init()
 {
-//
-// reset the existing file environment and open a new root file if
-// the pointer to the Fluka tree is null
-    
-    TFile *pFile=0;
-    if (fTreeNtuple==0) {
-        if (!pFile) {
-           pFile = new TFile(fFileName);
-           pFile->cd();
-           cout<<"I have opened "<<fFileName<<" file "<<endl;
-        }
-// get the tree address in the Fluka boundary source file
-       fTreeNtuple = (TTree*)gDirectory->Get("h888");
-    } else {
-        pFile = fTreeNtuple->GetCurrentFile();
-        pFile->cd();
-    }
-
-    TTree *h2=fTreeNtuple;
-//Set branch addresses
-//Set branch addresses
-    h2->SetBranchAddress("Nihead",&fNihead);
-    h2->SetBranchAddress("Ihead",fIhead);
-    h2->SetBranchAddress("Nrhead",&fNrhead);
-    h2->SetBranchAddress("Rhead",fRhead);
-    h2->SetBranchAddress("Idpart",&fIdpart);
-    h2->SetBranchAddress("Theta",&fTheta);
-    h2->SetBranchAddress("Phi",&fPhi);
-    h2->SetBranchAddress("P",&fP);
-    h2->SetBranchAddress("E",&fE);
+// Initialize
+    if (fReader) fReader->Init();
 }
 
-
-//____________________________________________________________
+    
 void AliGenExtFile::Generate()
 {
 // Generate particles
 
-  Float_t polar[3]= {0,0,0};
+  Float_t polar[3]  = {0,0,0};
   //
-  Float_t origin[3]={0,0,0};
+  Float_t origin[3] = {0,0,0};
   Float_t p[3];
   Float_t random[6];
-  Float_t prwn;
-  Int_t i, j, nt, nTracks=0;
+  Int_t i = 0, j, nt;
   //
-  NtupleInit();
-  TTree *h2=fTreeNtuple;
-  Int_t nentries = (Int_t) h2->GetEntries();
-  // loop over number of particles
-  Int_t nb = (Int_t)h2->GetEvent(fNcurrent);
-  Int_t i5=fIhead[4];
-  Int_t i6=fIhead[5];
-
   for (j=0;j<3;j++) origin[j]=fOrigin[j];
-  if(fVertexSmear==perEvent) {
-    gMC->Rndm(random,6);
-    for (j=0;j<3;j++) {
-       origin[j]+=fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
+  if(fVertexSmear == kPerTrack) {
+    Rndm(random,6);
+    for (j = 0; j < 3; j++) {
+       origin[j] += fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
            TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
     }
   }
 
-  if (fNcurrent >= nentries) {
-      printf("\n No more entries !!! !\n");
+  while(1) {
+    Int_t nTracks = fReader->NextEvent();      
+    if (nTracks == 0) {
+      // printf("\n No more events !!! !\n");
+      Warning("AliGenExtFile::Generate","\nNo more events in external file!!!\nLast event may be empty or incomplete.\n");
       return;
-  }
-  
-         
-  if (i5==0) {
-      printf("\n This should never happen !\n");
-  } else {
-      printf("\n Next event contains %d tracks! \n", i6);
-      nTracks=i6;
-  }
-  for (i=0; i<nTracks; i++) {
-      fIdpart=gMC->PDGFromId(fIdpart);
-      Double_t amass = TDatabasePDG::Instance()->GetParticle(fIdpart)->Mass();
-      if(fE<=amass) {
-       Warning("Generate","Particle %d no %d E = %f mass = %f\n",
-               fIdpart,i,fE,amass);
-       prwn=0;
-      } else {
-       prwn=sqrt((fE+amass)*(fE-amass));
+    }
+
+    //
+    // Particle selection loop
+    //
+    // The selction criterium for the external file generator is as follows:
+    //
+    // 1) All tracks are subjects to the cuts defined by AliGenerator, i.e.
+    //    fThetaMin, fThetaMax, fPhiMin, fPhiMax, fPMin, fPMax, fPtMin, fPtMax,
+    //    fYMin, fYMax.
+    //    If the particle does not satisfy these cuts, it is not put on the
+    //    stack.
+    // 2) If fCutOnChild and some specific child is selected (e.g. if
+    //    fForceDecay==kSemiElectronic) the event is rejected if NOT EVEN ONE
+    //    child falls into the child-cuts.
+    TParticle* iparticle = 0x0;
+    
+    if(fCutOnChild) {
+      // Count the selected children
+      Int_t nSelected = 0;
+      while ( (iparticle=fReader->NextParticle()) ) {
+        ;
+       Int_t kf = CheckPDGCode(iparticle->GetPdgCode());
+       kf = TMath::Abs(kf);
+       if (ChildSelected(kf) && KinematicSelection(iparticle, 1)) {
+         nSelected++;
+       }
       }
+      if (!nSelected) continue;    // No particle selected:  Go to next event
+      fReader->RewindEvent();
+    }
 
-      fTheta *= TMath::Pi()/180.;
-      fPhi    = (fPhi-180)*TMath::Pi()/180.;      
-      if(fTheta<fThetaMin || fTheta>fThetaMax ||
-        fPhi<fPhiMin || fPhi>fPhiMax         ||
-        prwn<fPMin || prwn>fPMax)          
-      {
-         ;
-      } else {
-         p[0]=prwn*TMath::Sin(fTheta)*TMath::Cos(fPhi);
-         p[1]=prwn*TMath::Sin(fTheta)*TMath::Sin(fPhi);      
-         p[2]=prwn*TMath::Cos(fTheta);
-         
-         if(fVertexSmear==perTrack) {
-             gMC->Rndm(random,6);
-             for (j=0;j<3;j++) {
-                 origin[j]=fOrigin[j]
-                     +fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
-                     TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
-             }
-         }
-         gAlice->SetTrack(fTrackIt,-1,fIdpart,p,origin,polar,0,"Primary",nt);
+    //
+    // Stack filling loop
+    //
+    for (i = 0; i < nTracks; i++) {
+
+      TParticle* iparticle = fReader->NextParticle();
+      Bool_t selected = KinematicSelection(iparticle,0); 
+      if (!selected) {
+       Double_t  pz   = iparticle->Pz();
+       Double_t  e    = iparticle->Energy();
+       Double_t  y;
+       if ((e-pz) == 0) {
+         y = 20.;
+       } else if ((e+pz) == 0.) {
+         y = -20.;
+       } else {
+         y = 0.5*TMath::Log((e+pz)/(e-pz));      
+       }
+       printf("\n Not selected %d %f %f %f %f %f", i,
+              iparticle->Theta(),
+              iparticle->Phi(),
+              iparticle->P(),
+              iparticle->Pt(),
+              y);
+       //PH    delete iparticle;
+       //      continue;
+      }
+      p[0] = iparticle->Px();
+      p[1] = iparticle->Py();
+      p[2] = iparticle->Pz();
+      Int_t idpart = iparticle->GetPdgCode();
+      if(fVertexSmear==kPerTrack) 
+       {
+         Rndm(random,6);
+         for (j = 0; j < 3; j++) {
+            origin[j]=fOrigin[j]+
+                      fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
+                        TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
+         }
       }
-      fNcurrent++;
-      nb = (Int_t)h2->GetEvent(fNcurrent); 
+      Int_t decayed = iparticle->GetFirstDaughter();
+      Int_t doTracking = fTrackIt && (decayed < 0) &&
+                        (TMath::Abs(idpart) > 10) && selected;
+      // printf("*** pdg, first daughter, trk = %d, %d, %d\n",
+      //   idpart,decayed, doTracking);
+      //PH      PushTrack(doTracking,-1,idpart,p,origin,polar,0,kPPrimary,nt);
+      Int_t parent = iparticle->GetFirstMother();
+      PushTrack(doTracking,parent,idpart,p,origin,polar,0,kPPrimary,nt);
+      KeepTrack(nt);
+    } // track loop
+
+    break;
+
+  } // event loop
+
+  SetHighWaterMark(nt);
+  CdEventFile();
+}
+
+void AliGenExtFile::CdEventFile()
+{
+// CD back to the event file
+  TFile *pFile=0;
+  if (!gAlice) {
+      gAlice = (AliRun*)pFile->Get("gAlice");
+      if (gAlice) printf("AliRun object found on file\n");
+      if (!gAlice) gAlice = new AliRun("gAlice","Alice test program");
   }
-    TFile *pFile=0;
-// Get AliRun object or create it 
-    if (!gAlice) {
-       gAlice = (AliRun*)pFile->Get("gAlice");
-       if (gAlice) printf("AliRun object found on file\n");
-       if (!gAlice) gAlice = new AliRun("gAlice","Alice test program");
-    }
-    TTree *fAli=gAlice->TreeK();
-    if (fAli) pFile =fAli->GetCurrentFile();
-    pFile->cd();
+  TTree *fAli=gAlice->TreeK();
+  if (fAli) pFile =fAli->GetCurrentFile();
+  pFile->cd();    
 }
 
 
 AliGenExtFile& AliGenExtFile::operator=(const  AliGenExtFile& rhs)
 {
 // Assignment operator
+    rhs.Copy(*this);
     return *this;
 }
 
+void AliGenExtFile::Copy(TObject&) const
+{
+    //
+    // Copy 
+    //
+    Fatal("Copy","Not implemented!\n");
+}