This commit was generated by cvs2svn to compensate for changes in r1018,
authorfca <fca@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 3 May 2000 06:53:21 +0000 (06:53 +0000)
committerfca <fca@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 3 May 2000 06:53:21 +0000 (06:53 +0000)
which included commits to RCS files with non-trunk default branches.

29 files changed:
ALIFAST/ALIFASTLinkDef.h [new file with mode: 0644]
ALIFAST/AliFBigBang.cxx [new file with mode: 0644]
ALIFAST/AliFBigBang.h [new file with mode: 0644]
ALIFAST/AliFBrowsable.cxx [new file with mode: 0644]
ALIFAST/AliFBrowsable.h [new file with mode: 0644]
ALIFAST/AliFDet.cxx [new file with mode: 0644]
ALIFAST/AliFDet.h [new file with mode: 0644]
ALIFAST/AliFDisplay.cxx [new file with mode: 0644]
ALIFAST/AliFDisplay.h [new file with mode: 0644]
ALIFAST/AliFFruit.cxx [new file with mode: 0644]
ALIFAST/AliFFruit.h [new file with mode: 0644]
ALIFAST/AliFHistBrowser.cxx [new file with mode: 0644]
ALIFAST/AliFHistBrowser.h [new file with mode: 0644]
ALIFAST/AliFMaker.cxx [new file with mode: 0644]
ALIFAST/AliFMaker.h [new file with mode: 0644]
ALIFAST/AliFParticle.cxx [new file with mode: 0644]
ALIFAST/AliFParticle.h [new file with mode: 0644]
ALIFAST/AliFTrack.cxx [new file with mode: 0644]
ALIFAST/AliFTrack.h [new file with mode: 0644]
ALIFAST/AliFTrackMaker.cxx [new file with mode: 0644]
ALIFAST/AliFTrackMaker.h [new file with mode: 0644]
ALIFAST/AliFVirtualDisplay.cxx [new file with mode: 0644]
ALIFAST/AliFVirtualDisplay.h [new file with mode: 0644]
ALIFAST/AliFast.cxx [new file with mode: 0644]
ALIFAST/AliFast.h [new file with mode: 0644]
ALIFAST/Makefile [new file with mode: 0644]
ALIFAST/alifast.C [new file with mode: 0644]
ALIFAST/alifasttest.C [new file with mode: 0644]
ALIFAST/user.C [new file with mode: 0644]

diff --git a/ALIFAST/ALIFASTLinkDef.h b/ALIFAST/ALIFASTLinkDef.h
new file mode 100644 (file)
index 0000000..f9d4171
--- /dev/null
@@ -0,0 +1,26 @@
+#ifdef __CINT__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ global gAliFast;
+
+#pragma link C++ class AliFast-;
+#pragma link C++ class AliFMaker-;
+
+#pragma link C++ class AliFTrackMaker;
+#pragma link C++ class AliFTrack;
+#pragma link C++ class AliFHistBrowser;
+#pragma link C++ class AliFBigBang;
+#pragma link C++ class AliFBrowsable;
+#pragma link C++ class AliFVirtualDisplay;
+#pragma link C++ class AliFDet;
+
+//
+// #pragma link C++ class AliFDisplay;
+// #pragma link C++ class AliFParticle;
+// #pragma link C++ class AliFFruit;
+
+
+#endif
diff --git a/ALIFAST/AliFBigBang.cxx b/ALIFAST/AliFBigBang.cxx
new file mode 100644 (file)
index 0000000..628246f
--- /dev/null
@@ -0,0 +1,80 @@
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFBigBang                                                          //
+//                                                                      //
+// helper class to browse generated particles.                          //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include <TBrowser.h>
+#include <TParticle.h>
+#include <TClonesArray.h>
+#include "AliFast.h"
+#include "AliFBigBang.h"
+
+#include "AliFBrowsable.h"
+
+ClassImp(AliFBigBang)
+
+
+
+//_____________________________________________________________________________
+AliFBigBang::AliFBigBang() 
+                : TNamed("Histograms","Generated particles browser")
+{
+   fBrowsables = 0;
+}
+
+//_____________________________________________________________________________
+AliFBigBang::~AliFBigBang() 
+{
+  if (fBrowsables) {
+     fBrowsables->Delete();
+     delete fBrowsables;
+     fBrowsables = 0;
+  }
+}
+
+//_____________________________________________________________________________
+void AliFBigBang::Browse(TBrowser *b)
+{
+  /*
+
+  TClonesArray *particles = mcarlo->Fruits();
+  Int_t nparticles = particles->GetEntriesFast();
+  TParticle *part;
+  AliFBrowsable *brow;
+  char name[64];
+  if (!fBrowsables) fBrowsables = new TObjArray(2*nparticles);
+  if (fBrowsables->GetSize() < nparticles) fBrowsables->Expand(nparticles);
+  for (Int_t i=0;i<nparticles;i++) {
+     part = (TParticle*)particles->UncheckedAt(i);
+     if (part->GetMother(i)) continue;
+     brow = GetBrowsable(i);
+     sprintf(name,"%s_%d",part->GetName(),i);
+     brow->SetName(name);
+     brow->SetRefObject(part);
+     b->Add(brow,name);
+  }
+  */
+}
+
+//_____________________________________________________________________________
+AliFBrowsable *AliFBigBang::GetBrowsable(Int_t i)
+{
+  AliFBrowsable *brow = (AliFBrowsable*)fBrowsables->At(i);
+  if (!brow) {
+     brow = new AliFBrowsable();
+     fBrowsables->AddAt(brow, i);
+     brow->SetBigBang(this);
+  } 
+  return brow;
+}
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFBigBang.h b/ALIFAST/AliFBigBang.h
new file mode 100644 (file)
index 0000000..33a1a6e
--- /dev/null
@@ -0,0 +1,45 @@
+#ifndef AliFBigBang_H
+#define AliFBigBang_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFBigBang                                                          //
+//                                                                      //
+// helper class to browse generated particles.                          //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TNamed
+#include <TNamed.h>
+#endif
+#ifndef ROOT_TObjArray
+#include <TObjArray.h>
+#endif
+
+class AliFBrowsable;
+
+class AliFBigBang : public TNamed {
+
+private:
+   TObjArray     *fBrowsables;      //List of browsable particles
+
+public:
+                     AliFBigBang();
+   virtual          ~AliFBigBang();
+   virtual void      Browse(TBrowser *b);
+   AliFBrowsable    *GetBrowsable(Int_t i);
+   Bool_t            IsFolder() {return kTRUE;}
+
+   ClassDef(AliFBigBang, 0)   //helper class to browse generated particles.
+};
+
+#endif
+
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFBrowsable.cxx b/ALIFAST/AliFBrowsable.cxx
new file mode 100644 (file)
index 0000000..b29f043
--- /dev/null
@@ -0,0 +1,68 @@
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFBrowsable                                                          //
+//                                                                      //
+// helper class to browse generated particles.                          //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include <TBrowser.h>
+#include <TParticle.h>
+#include <TClonesArray.h>
+#include "AliFast.h"
+#include "AliFBrowsable.h"
+#include "AliFBigBang.h"
+//#include "AliFMCMaker.h"
+
+ClassImp(AliFBrowsable)
+
+
+
+//_____________________________________________________________________________
+AliFBrowsable::AliFBrowsable() 
+{
+
+}
+
+//_____________________________________________________________________________
+void AliFBrowsable::Browse(TBrowser *b)
+{
+  /*
+  AliFMCMaker *mcarlo = gAliFast->MCMaker();
+  TClonesArray *particles = mcarlo->Fruits();
+  Int_t nparticles = particles->GetEntriesFast();
+  TParticle *refpart = (TParticle*)fRefObject;
+  TParticle *part;
+  AliFBrowsable *brow;
+  char name[64];
+  Int_t iparent;
+
+  for (Int_t i=0;i<nparticles;i++) {
+     part = (TParticle*)particles->UncheckedAt(i);
+     iparent = part->GetMother(0);
+     if (!iparent) continue;
+     if (particles->UncheckedAt(iparent-1) != refpart) continue;
+     brow = fBigBang->GetBrowsable(i);
+     sprintf(name,"%s_%d",part->GetName(),i);
+     brow->SetName(name);
+     brow->SetRefObject(part);
+     b->Add(brow,name);
+  }
+  */
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFBrowsable.h b/ALIFAST/AliFBrowsable.h
new file mode 100644 (file)
index 0000000..ccf4204
--- /dev/null
@@ -0,0 +1,46 @@
+#ifndef AliFBrowsable_H
+#define AliFBrowsable_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFBrowsable                                                        //
+//                                                                      //
+// helper class to browse generated particles.                          //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TNamed
+#include <TNamed.h>
+#endif
+
+class AliFBigBang;
+
+class AliFBrowsable : public TNamed {
+
+private:
+   TObject          *fRefObject;       //Referenced object
+   AliFBigBang      *fBigBang;         //Pointer to control bigbang object
+
+public:
+                     AliFBrowsable();
+   virtual          ~AliFBrowsable() {;}
+   virtual void      Browse(TBrowser *b);
+   Bool_t            IsFolder() {return kTRUE;}
+   virtual void      SetBigBang(AliFBigBang *bigbang) {fBigBang = bigbang;}
+   virtual void      SetRefObject(TObject *obj) {fRefObject = obj;}
+
+   ClassDef(AliFBrowsable, 0)   //helper class to browse generated particles.
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFDet.cxx b/ALIFAST/AliFDet.cxx
new file mode 100644 (file)
index 0000000..02ca256
--- /dev/null
@@ -0,0 +1,320 @@
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+// AliFast Detector Class                                                 //
+//                                                                        //
+// to provide information of effective material (X/Xo) of the detector    //
+// needed for the multiple scattering formula used in AliFTrackMaker.     // 
+//                                                                        // 
+// the number and dimensions of cylindrical layers of material are        //
+// initialised here for the TP status and are to be updated accordingly.  //
+//                                                                        //
+//                                                                        //
+// origin: "init_geometry" routine in "res.f" fortran by Karel Safarik    //
+//         which was used to calculate the track resolution for TP.       // 
+//                                                                        // 
+//                                                                        //
+// AliFast: E. Richter-Was and Y. Foka                                    //
+//          following general structure of Makers in ATLFast              //
+//          by R. Brun  and E. R. Was                                     //
+//                                                                        //
+////////////////////////////////////////////////////////////////////////////
+
+#include "AliFDet.h"
+#include "TMath.h"
+
+ClassImp(AliFDet)
+
+
+//_____________________________________________________________________________
+AliFDet::AliFDet(const char *name, const char *title) : TNamed(name,title)
+{
+   for(Int_t idDet=0; idDet<kNMaxDet; idDet++){
+      fRDet[idDet]       = 0;
+      fRDetSQ[idDet]     = 0;
+      fThickDet[idDet]   = 0;
+      fErrorRPhi[idDet]  = 0;
+      fErrorZ[idDet]     = 0;
+      fErrorR[idDet]     = 0;
+      fIFlagDet[idDet]   = 0;
+      fIFlagGas[idDet]   = 0;
+   }
+   fBMag       = 0;
+   fConstMag   = 0;
+   fNDetActive = 0;
+   fNDet       = 0;
+}
+
+//_____________________________________________________________________________
+void AliFDet::InitDetParam()
+{
+  //initialisation of the detector material to the TP status.
+  //needed for multiple scattering formula used in AliFTrackMaker 
+  //for track resolution calculation
+  //  
+  //errorRPhi, errorZ:    
+  //the errors in bending and r direction are due to detector precision and alignement
+  //the error  in radial direction r is due to alignement only
+  //the errors are momentum dependent; for iFlagDet=2 as for TPC are calculated properly
+  //
+  //fErrorVertexX,fErrorVertexY, fErrorVertexZ
+  //errors of vertex  
+  //the vertex precision depends on particle multiplicity mult_density
+  //optimistic errors for/high multiplicity
+   Double_t   rDet[kNMaxDet];         // radius of detector material in cm
+   Double_t   thickDet[kNMaxDet];     // thickness divided by X
+   Double_t   errorRPhi[kNMaxDet];    // error in bending direction
+   Double_t   errorZ[kNMaxDet];       // error in z direction
+   Double_t   errorR[kNMaxDet];       // error in r direction,from alignement only
+   Int_t      iFlagDet[kNMaxDet];     // 1: sensitive detector 
+                                      // 2: errors will be calculated
+   Int_t      iFlagGas[kNMaxDet];     // for gas detectors
+
+   Int_t     nDet;
+
+   //dummy
+   nDet            = 0;
+   rDet[nDet]      = 0;
+   thickDet[nDet]  = 0;
+   iFlagDet[nDet]  = 0;
+   iFlagGas[nDet]  = 0;
+   //vacum pipe
+   nDet            = 1;
+   rDet[nDet]      = 3.0;
+   thickDet[nDet]  = 0.06/35.3;       // berylium
+   iFlagDet[nDet]  = 0;               // no detection
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 2;
+   rDet[nDet]      = 3.5;
+   thickDet[nDet]  = 1.0000/30420.0;  // air
+   iFlagDet[nDet]  = 0;               // no detection
+   iFlagGas[nDet]  = 1;
+   //
+   nDet            = 3;
+   rDet[nDet]      = 4.0;
+   thickDet[nDet]  = 0.06/9.36;       // silicon
+   errorRPhi[nDet] = 0.0015 + 0.0005;
+   errorZ[nDet]    = 0.009  + 0.0005;
+   errorR[nDet]    = 0.001;
+   iFlagDet[nDet]  = 1;              
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 4;
+   rDet[nDet]      = 5.75;
+   thickDet[nDet]  = 3.5/30420.0;       // silicon
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   //
+   nDet            = 5;
+   rDet[nDet]      = 7.5;
+   thickDet[nDet]  = 0.06/9.36;          // silicon
+   errorRPhi[nDet] = 0.0015 + 0.0005;
+   errorZ[nDet]    = 0.009  + 0.0005;
+   errorR[nDet]    = 0.001;
+   iFlagDet[nDet]  = 1;              
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 6;
+   rDet[nDet]      = 10.75;
+   thickDet[nDet]  = 6.5/30420.0;        // air
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   // first silicon drift
+   nDet            = 7;
+   rDet[nDet]      = 14.0;
+   thickDet[nDet]  = 0.06/9.36;          // silicon
+   errorRPhi[nDet] = 0.0025 + 0.0005;
+   errorZ[nDet]    = 0.0025  + 0.0005;
+   errorR[nDet]    = 0.001;
+   iFlagDet[nDet]  = 1;              
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 8;
+   rDet[nDet]      = 19.0;
+   thickDet[nDet]  = 10.0/30420.0;        // air
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   // second silicon drift
+   nDet            =  9;
+   rDet[nDet]      = 24.0;
+   thickDet[nDet]  = 0.06/9.36;          // silicon
+   errorRPhi[nDet] = 0.0025 + 0.0005;
+   errorZ[nDet]    = 0.0025  + 0.0005;
+   errorR[nDet]    = 0.001;
+   iFlagDet[nDet]  = 1;              
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 10;
+   rDet[nDet]      = 32.0;
+   thickDet[nDet]  = 16.0/30420.0;        // air
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   // first silicon strips
+   nDet            = 11;
+   rDet[nDet]      = 40.0;
+   thickDet[nDet]  = 0.06/9.36;          // silicon
+   errorRPhi[nDet] = 0.003 + 0.0005;
+   errorZ[nDet]    = 0.100 + 0.0005;
+   errorR[nDet]    = 0.001;
+   iFlagDet[nDet]  = 1;              
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 12;
+   rDet[nDet]      = 42.5;
+   thickDet[nDet]  = 5.0/30420.0;        // air
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   // second silicon strips
+   nDet            = 13;
+   rDet[nDet]      = 45.0;
+   thickDet[nDet]  = 0.06/9.36;          // silicon
+   errorRPhi[nDet] = 0.003 + 0.0005;
+   errorZ[nDet]    = 0.100 + 0.0005;
+   errorR[nDet]    = 0.001;
+   iFlagDet[nDet]  = 1;              
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 14;
+   rDet[nDet]      = 47.5;
+   thickDet[nDet]  = 5.0/30420.0;        // air
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   //
+   nDet            = 15;
+   rDet[nDet]      = 50.0;
+   thickDet[nDet]  = 0.01;              // 1% of something ITS
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 16;
+   rDet[nDet]      = 51.0;
+   thickDet[nDet]  = 2.0/30420.0;        // air
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   // TPC HV degrager
+   nDet            = 17;
+   rDet[nDet]      = 52.0;
+   thickDet[nDet]  = 0.0018;           // 0.18 % of something TPC
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 18;
+   rDet[nDet]      = 68.75;
+   thickDet[nDet]  = 12.5/18310.0;          // CO2
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   //
+   nDet            = 19;
+   rDet[nDet]      = 71.25;
+   thickDet[nDet]  = 12.5/18310.0;          // CO2
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   // TPC inner field cage
+   nDet            = 20;
+   rDet[nDet]      = 78.0;
+   thickDet[nDet]  = 0.0041;                // 0.41 % of something
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 0;
+   //
+   nDet            = 21;
+   rDet[nDet]      = 83.5;
+   thickDet[nDet]  = 11.0/32155.6;          // neon
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   //
+   nDet            = 22;
+   rDet[nDet]      = 94.5;
+   thickDet[nDet]  = 11.0/32155.6;          // neon
+   iFlagDet[nDet]  = 0;              
+   iFlagGas[nDet]  = 1;
+   // TPC
+   Int_t    nPadRow = 75;
+   Double_t rCurrent = 99.0;
+   Double_t deltaR   =  2.0;
+   for(Int_t ipad=1; ipad<nPadRow+1; ipad++){
+      nDet=nDet+1;
+      rCurrent = rCurrent + deltaR;
+      rDet[nDet] = rCurrent;
+      thickDet[nDet]  = 2.0/32155.6;        // neon
+      errorRPhi[nDet] = 0.0;                //errors are momentum dependent
+      errorZ[nDet]    = 0.0;                //to be calculated latter
+      errorR[nDet]    = 0.0075;
+      iFlagDet[nDet]  = 2;                  //means error defined latter              
+      iFlagGas[nDet]  = 1;
+   }
+
+   // vertex precision
+   Double_t multDensity = 3906.25;
+
+   fErrorVertexX = 0.010/TMath::Sqrt(multDensity) + 0.00060;
+   fErrorVertexY = fErrorVertexX;
+   fErrorVertexZ = 0.025/TMath::Sqrt(multDensity) + 0.00075;
+
+
+   // magnetic field
+   fBMag = 2.0;
+   fConstMag = 1.0/(fBMag*0.297792458e-3);
+
+
+   // prepare more suitables variables
+
+   Int_t nDetActive = 0;
+     
+   for(Int_t idDet=0; idDet<nDet+1; idDet++){
+      fRDet[idDet]     = rDet[idDet]; 
+      fRDetSQ[idDet]   = rDet[idDet]*rDet[idDet];
+      fThickDet[idDet] = 0.0136* TMath::Sqrt(thickDet[idDet]);
+      fIFlagDet[idDet]    = iFlagDet[idDet];
+      fIFlagGas[idDet]    = iFlagGas[idDet];
+      if(iFlagDet[idDet] > 0){
+         nDetActive = nDetActive+1;
+         fErrorR[idDet] = errorR[idDet]*errorR[idDet];
+         if(iFlagDet[idDet] == 1){
+            fErrorRPhi[idDet] = errorRPhi[idDet]*errorRPhi[idDet];
+            fErrorZ[idDet] = errorZ[idDet]*errorZ[idDet];
+        }
+      }
+   }
+
+   fErrorVertexX = fErrorVertexX*fErrorVertexX;
+   fErrorVertexY = fErrorVertexY*fErrorVertexY;
+   fErrorVertexZ = fErrorVertexZ*fErrorVertexZ;
+
+   fNDetActive   = nDetActive;
+   fNDet         = nDet;
+
+  
+}
+
+//_____________________________________________________________________________
+void AliFDet::PrintDetInfo()
+{
+  //to print information for the initialisation of the detector 
+   printf("**************************************************************\n");
+   printf("*                                                            *\n");
+   printf("*                        ALICE detector                      *\n");
+   printf("*                                                            *\n");
+   printf("**************************************************************\n");
+
+   for(Int_t idDet=0; idDet<fNDet+1; idDet++){
+     if(fIFlagDet[idDet] == 0){
+       printf("%5s %3d %8.1f %2s %10.5f %20s\n",
+              "det=",idDet,fRDet[idDet],"cm",
+              TMath::Power(fThickDet[idDet]/0.0136,2),
+              "of X0 <---- pasive material");
+     } else{
+       printf("%5s %3d %8.1f %2s %10.5f %6s  %6.4f %6.4f \n",
+              "det=",idDet,fRDet[idDet],"cm",
+              TMath::Power(fThickDet[idDet]/0.0136,2),"of X0, errors",
+              TMath::Sqrt(fErrorRPhi[idDet]),TMath::Sqrt(fErrorZ[idDet]));
+     } 
+   }
+   printf("%20s %10.4f %10.4f %10.4f\n","vertex precision(x,y,z)",
+          TMath::Sqrt(fErrorVertexX),
+          TMath::Sqrt(fErrorVertexY),
+          TMath::Sqrt(fErrorVertexZ));
+   printf("%20s %10.4f %10s %8.1f %5s\n","magnetic field (kGauss)",fBMag,
+          "(constant",fConstMag,")");
+
+}
diff --git a/ALIFAST/AliFDet.h b/ALIFAST/AliFDet.h
new file mode 100644 (file)
index 0000000..612d602
--- /dev/null
@@ -0,0 +1,91 @@
+#ifndef AliFDet_H
+#define AliFDet_H
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+// AliFast Detector Class                                                 //
+//                                                                        //
+// to provide information of effective material (X/Xo) of the detector    //
+// needed for the multiple scattering formula used in AliFTrackMaker.     // 
+//                                                                        // 
+// the number and dimensions of cylindrical layers of material are        //
+// initialised here for the TP status and are to be updated accordingly.  //
+//                                                                        //
+// this class is replacing the "init_geometry" routine of program "res.f  //
+//                                                                        // 
+////////////////////////////////////////////////////////////////////////////
+
+//#ifndef ROOT_TObject
+#include <TNamed.h>
+//#endif
+
+enum { kNMaxDet  = 100 };
+enum { kNMaxDet2 = 200 };
+
+
+class AliFDet : public TNamed {
+  
+private:
+   //geometry parameters
+   Double_t        fRDet[kNMaxDet];         // radius of detector material in cm
+   Double_t        fRDetSQ[kNMaxDet];       // and the sq root of it
+   Double_t        fThickDet[kNMaxDet];     // thickness divided by Xo
+   //errors due to detector precision plus alignement given by groups. 
+   //they are momentum dependent; for TPC are calculated properly.
+   Double_t        fErrorRPhi[kNMaxDet];    // error in bending direction
+   Double_t        fErrorZ[kNMaxDet];       // error in z direction
+   Double_t        fErrorR[kNMaxDet];       // error in r direction,from alignement only 
+   Int_t           fIFlagDet[kNMaxDet];     // 1: sensitive detector 
+                                            // 2: errors will be calculated
+   Int_t           fIFlagGas[kNMaxDet];     // for gas detectors  
+   //vertex precision calculated for particle multiplicity mult_density
+   //high multiplicity results in optimistic errors for vertex   
+   Double_t        fErrorVertexX;           // vertex precision in x
+   Double_t        fErrorVertexY;           // vertex precision in y
+   Double_t        fErrorVertexZ;           // vertex precision in z
+   Double_t        fBMag;                   // magnetic field in KGauss
+   Double_t        fConstMag;               //
+   Int_t           fNDetActive;             // n. of active detector layers
+   Int_t           fNDet;                   // n. of detectors layers
+
+public:
+                  AliFDet() {}
+                  AliFDet(const char *name, const char *title);
+   virtual       ~AliFDet() {}
+
+   // Initialise parameters for detector geometry
+   void           InitDetParam();
+   void           PrintDetInfo();
+
+
+   // Getters
+   Double_t        RDet(Int_t idDet) {return fRDet[idDet];}         
+   Double_t        RDetSQ(Int_t idDet) {return fRDetSQ[idDet];}     
+   Double_t        ThickDet(Int_t idDet) {return fThickDet[idDet];}    
+   Double_t        ErrorRPhi(Int_t idDet) {return fErrorRPhi[idDet];}  
+   Double_t        ErrorZ(Int_t idDet) {return fErrorZ[idDet];}     
+   Double_t        ErrorR(Int_t idDet) {return fErrorR[idDet];} 
+   Int_t           IFlagDet(Int_t idDet) {return fIFlagDet[idDet];}   
+   Int_t           IFlagGas(Int_t idDet) {return fIFlagGas[idDet];}   
+   Double_t        ErrorVertexX() {return fErrorVertexX;} 
+   Double_t        ErrorVertexY() {return fErrorVertexY;} 
+   Double_t        ErrorVertexZ() {return fErrorVertexZ;} 
+   Double_t        BMag() {return fBMag;}                  
+   Double_t        ConstMag() {return fConstMag;}         
+   Int_t           NDetActive() {return fNDetActive;}      
+   Int_t           NDet() {return fNDet;}                 
+
+
+   ClassDef(AliFDet,1)   //AliFast Detector intialisation for AliFTrackMaker
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFDisplay.cxx b/ALIFAST/AliFDisplay.cxx
new file mode 100644 (file)
index 0000000..acb0dfc
--- /dev/null
@@ -0,0 +1,537 @@
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFDisplay                                                          //
+//                                                                      //
+// Utility class to display ALICE outline, tracks, clusters, jets,..    //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include <TROOT.h>
+#include <TButton.h>
+#include <TCanvas.h>
+#include <TView.h>
+#include <TArc.h>
+#include <TText.h>
+#include <TPaveLabel.h>
+#include <TPaveText.h>
+#include <TList.h>
+#include <TDiamond.h>
+#include <TNode.h>
+#include <TTUBE.h>
+#include <TMath.h>
+#include <X3DBuffer.h>
+
+#include "AliFDisplay.h"
+#include "AliFFruit.h"
+#include "AliFParticle.h"
+#include "AliFast.h"
+#include "AliFMCMaker.h"
+
+
+ClassImp(AliFDisplay)
+
+
+//_____________________________________________________________________________
+AliFDisplay::AliFDisplay() : AliFVirtualDisplay()
+{
+   fParticle  = 0;
+   fFruits    = 0;
+}
+
+//_____________________________________________________________________________
+AliFDisplay::AliFDisplay(const char *title) : AliFVirtualDisplay()
+{
+
+   gAliFast->SetDisplay(this);
+
+   // Initialize display default parameters
+   SetPTcut();
+   SetPTcutEGMUNU();
+   SetGeometry();
+
+   // Set front view by default
+   fTheta = 0;
+   fPhi   = -90;
+   fDrawAllViews  = kFALSE;
+   fDrawParticles = kTRUE;
+
+   // Create display canvas
+   fCanvas = new TCanvas("Canvas", (char*)title,14,47,740,650);
+   fCanvas->SetEditable(kIsNotEditable);
+
+   // Create main display pad
+   fPad = new TPad("viewpad", "AliFast display",0.15,0,1,1);
+   fPad->Draw();
+   fPad->Modified();
+   fPad->SetFillColor(1);
+   fPad->SetBorderSize(2);
+
+   // Create user interface control pad
+   DisplayButtons();
+   fCanvas->cd();
+
+   // Create trigger view pad
+   Float_t dxtr = 0.15;
+   Float_t dytr = 0.45;
+   Float_t xt   = 0.3*dxtr;
+   Float_t yt   = 0.8*dytr;
+   Float_t dyt  = 0.07*dytr;
+   Float_t xarc = 0.7*dxtr;
+   Float_t rarc = 0.3*dyt;
+   fTrigPad = new TPad("TrigPad", "trigger pad",0,0,dxtr,dytr);
+   fTrigPad->Range(0,0,dxtr,dytr);
+   fTrigPad->Draw();
+   fTrigPad->cd();
+   fTrigPad->SetFillColor(22);
+   fTrigPad->SetBorderSize(2);
+
+   TText *t = new TText();
+   t->SetTextFont(61);
+   t->SetTextSize(0.2);
+   t->SetTextAlign(22);
+   t->DrawText(0.5*dxtr, 0.93*dytr,"Trigger");
+   t->SetTextSize(0.14);
+   t->SetTextAlign(22);
+   t->DrawText(xt,yt,      "EM1");
+   t->DrawText(xt,yt-dyt,  "PH1");
+   t->DrawText(xt,yt-2*dyt,"EM2");
+   t->DrawText(xt,yt-3*dyt,"MU1");
+   t->DrawText(xt,yt-4*dyt,"MU2");
+   t->DrawText(xt,yt-5*dyt,"EMU");
+   t->DrawText(xt,yt-6*dyt,"JT1");
+   t->DrawText(xt,yt-7*dyt,"JT2");
+   t->DrawText(xt,yt-8*dyt,"JT3");
+   t->DrawText(xt,yt-9*dyt,"ALL");
+   AppendPad(); // append display object as last object to force selection
+
+   fTubin = new TTUBE("tubin","inner tube"," ", fRin, fRin+5, fZin);
+   fNodin = new TNode("nodin","ALIAS outline","tubin",0,0,0," ");
+   fNodin->SetLineColor(7);
+         
+
+   // Create list to support list of fruits
+   fFruits = new TList();
+
+   // Create particle manager
+   fParticle = new AliFParticle("particle_manager");
+
+   fCanvas->cd();
+   fCanvas->Update();
+
+}
+
+
+//_____________________________________________________________________________
+AliFDisplay::~AliFDisplay()
+{
+   delete fParticle;
+   if (fFruits) fFruits->Delete();
+   delete fFruits;
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::Clear(Option_t *)
+{
+//    Delete graphics temporary objects
+
+   fFruits->Delete();
+
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::DisplayButtons()
+{
+//    Create the user interface buttons
+
+   fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
+   fButtons->Draw();
+   fButtons->SetFillColor(38);
+   fButtons->SetBorderSize(2);
+   fButtons->cd();
+
+   Int_t butcolor = 33;
+   Float_t dbutton = 0.08;
+   Float_t y  = 0.96;
+   Float_t dy = 0.014;
+   Float_t x0 = 0.05;
+   Float_t x1 = 0.95;
+
+   TButton *button;
+   char *but1 = "gAliFast->Display()->ShowNextEvent(1)";
+   button = new TButton("Next",but1,x0,y-dbutton,x1,y);
+   button->SetFillColor(38);
+   button->Draw();
+
+   y -= dbutton +dy;
+   char *but2 = "gAliFast->Display()->ShowNextEvent(-1)";
+   button = new TButton("Previous",but2,x0,y-dbutton,x1,y);
+   button->SetFillColor(38);
+   button->Draw();
+
+   y -= dbutton +dy;
+   char *but3 = "gAliFast->Display()->SetView(90,-90)";
+   button = new TButton("Top View",but3,x0,y-dbutton,x1,y);
+   button->SetFillColor(butcolor);
+   button->Draw();
+
+   y -= dbutton +dy;
+   char *but4 = "gAliFast->Display()->SetView(90,0)";
+   button = new TButton("Side View",but4,x0,y-dbutton,x1,y);
+   button->SetFillColor(butcolor);
+   button->Draw();
+
+   y -= dbutton +dy;
+   char *but5 = "gAliFast->Display()->SetView(0,-90)";
+   button = new TButton("Front View",but5,x0,y-dbutton,x1,y);
+   button->SetFillColor(butcolor);
+   button->Draw();
+
+   y -= dbutton +dy;
+   char *but6 = "gAliFast->Display()->DrawAllViews()";
+   button = new TButton("All Views",but6,x0,y-dbutton,x1,y);
+   button->SetFillColor(butcolor);
+   button->Draw();
+
+   y -= dbutton +dy;
+   char *but7 = "gAliFast->Display()->DrawViewGL()";
+   button = new TButton("OpenGL",but7,x0,y-dbutton,x1,y);
+   button->SetFillColor(38);
+   button->Draw();
+
+   y -= dbutton +dy;
+   char *but8 = "gAliFast->Display()->DrawViewX3D()";
+   button = new TButton("X3D",but8,x0,y-dbutton,x1,y);
+   button->SetFillColor(38);
+   button->Draw();
+
+   // display logo
+   TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
+   diamond->SetFillColor(50);
+   diamond->SetTextAlign(22);
+   diamond->SetTextColor(5);
+   diamond->SetTextSize(0.11);
+   diamond->Draw();
+   diamond->AddText(".. ");
+   diamond->AddText("ROOT");
+   diamond->AddText("AliFAST");
+   diamond->AddText("... ");
+   diamond->AddText(" ");
+}
+
+//_____________________________________________________________________________
+
+Int_t AliFDisplay::DistancetoPrimitive(Int_t px, Int_t py)
+{
+// Compute distance from point px,py to objects in event
+
+   if (gPad == fTrigPad) {gPad->SetCursor(kCross); return 0;}
+
+   const Int_t big = 9999;
+   Int_t dist = big;
+   Float_t xmin = gPad->GetX1();
+   Float_t xmax = gPad->GetX2();
+   Float_t dx   = 0.05*(xmax - xmin);
+   Float_t x    = gPad->AbsPixeltoX(px);
+   if (x < xmin+dx || x > xmax-dx) return dist;
+
+    // scan list of particles
+   dist = fParticle->DistancetoPrimitive(px, py);
+   if (dist <= 0) return 0;
+
+    // scan list of fruits
+   TIter nextf(fFruits);
+   AliFFruit *fruit;
+   while((fruit=(AliFFruit*)nextf())) {
+      dist = fruit->DistancetoPrimitive(px, py);
+      if (dist < 5) {
+         gPad->SetSelected(fruit->Fruit());
+         gPad->SetCursor(kCross);
+         return 0;
+      }
+   }
+
+    // scan list of detectors (currently only one tube)
+   dist = fNodin->DistancetoPrimitive(px, py);
+   if (gPad->GetCanvas()->GetSelected() == gPad->GetView()) {
+      gPad->SetSelected(this);
+   }
+   return 0;
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::Draw(Option_t *)
+{
+//    Insert current event in graphics pad list
+
+   if (fDrawAllViews) {
+      DrawAllViews();
+      return;
+   }
+
+   fPad->cd();
+
+   DrawView(fTheta, fPhi);
+
+   // Display the event number and title
+   fPad->cd();
+   DrawTitle();
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::DrawAllViews()
+{
+//    Draw front,top,side and 30 deg views
+
+   fDrawAllViews = kTRUE;
+   fPad->cd();
+   fPad->SetFillColor(15);
+   fPad->Clear();
+   fPad->Divide(2,2);
+
+   // draw 30 deg view
+   fPad->cd(1);
+   DrawView(30, 30);
+   DrawTitle();
+
+   // draw front view
+   fPad->cd(2);
+   DrawView(0, -90);
+   DrawTitle("Front");
+
+   // draw top view
+   fPad->cd(3);
+   DrawView(90, -90);
+   DrawTitle("Top");
+
+   // draw side view
+   fPad->cd(4);
+   DrawView(90, 0);
+   DrawTitle("Side");
+
+   fPad->cd(2);
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::DrawTitle(Option_t *option)
+{
+//    Draw the event title
+
+   Float_t xmin = gPad->GetX1();
+   Float_t xmax = gPad->GetX2();
+   Float_t ymin = gPad->GetY1();
+   Float_t ymax = gPad->GetY2();
+   Float_t dx   = xmax-xmin;
+   Float_t dy   = ymax-ymin;
+   if (strlen(option) == 0) {
+      TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
+      title->SetBit(kCanDelete);
+      title->SetFillColor(42);
+      title->Draw();
+      char ptitle[100];
+      sprintf(ptitle,"Pythia event: %d, Run:%d",gAliFast->Event(), gAliFast->Run());
+      title->AddText(ptitle);
+      sprintf(ptitle,"Pythia Mode: %s",gAliFast->MCMaker()->GetTitle());
+      title->AddText(ptitle);
+   } else {
+      TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
+      label->SetBit(kCanDelete);
+      label->SetFillColor(42);
+      label->Draw();
+   }
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::DrawView(Float_t theta, Float_t phi)
+{
+//    Draw a view of ALIAS
+
+   gPad->SetFillColor(1);
+   // Display ALIAS outline
+   gPad->Clear();
+
+   Int_t iret;
+   TView *view = new TView(1);
+   view->SetRange(-fRin, -fRin, -fZin, fRin, fRin, fZin);
+
+   fNodin->Draw("same");
+
+    // add itself to the list
+   AppendPad();
+   
+   //Loop on all makers to add their products to the pad
+   TIter next(gAliFast->Makers());
+   AliFMaker *maker;
+   while ((maker = (AliFMaker*)next())) {
+      maker->Draw();
+   }
+   view->SetView(phi, theta, 0, iret);
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::DrawViewGL()
+{
+//    Draw current view using OPENGL
+
+   TPad *pad = (TPad*)gPad->GetPadSave();
+   pad->cd();
+   TView *view = pad->GetView();
+   if (!view) return;
+   pad->x3d("OPENGL");
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::DrawViewX3D()
+{
+//    Draw current view using X3D
+
+   TPad *pad = (TPad*)gPad->GetPadSave();
+   pad->cd();
+   TView *view = pad->GetView();
+   if (!view) return;
+   pad->x3d();
+}
+
+//______________________________________________________________________________
+void AliFDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
+{
+//*-*-*-*-*-*-*-*-*-*-*Execute action corresponding to one event*-*-*-*
+//*-*                  =========================================
+
+   if (gPad->GetView()) {
+      gPad->GetView()->ExecuteRotateView(event, px, py);
+   }
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::GetEvent(Int_t event)
+{
+//    Read event in memory
+
+   gAliFast->GetTreeEvent(event);
+
+   Draw();
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::Paint(Option_t *)
+{
+//    Paint miscellaneous items
+
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::PaintFruit(TObject *obj, Float_t eta, Float_t phi, Float_t
+pt, Int_t type, Option_t *option)
+{
+//    Display fruit from obj
+
+   AliFFruit *fruit = new AliFFruit(obj, eta, phi, pt, type);
+   fFruits->Add(fruit);
+   fruit->Paint(option);
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::PaintParticles(Option_t *option)
+{
+   if (fDrawParticles) fParticle->Paint(option);
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::SetGeometry(Float_t rin)
+{
+//  Set ALIAS in/out outline parameters
+
+   fRin  = rin;
+   fRout = 1.2*rin;
+   fZin  = 600;
+   fZout = 680;
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::SetPTcut(Float_t ptcut)
+{
+   fPTcut = ptcut;
+
+   if (fDrawAllViews) {
+      fPad->cd(1); gPad->Modified();
+      fPad->cd(2); gPad->Modified();
+      fPad->cd(3); gPad->Modified();
+      fPad->cd(4); gPad->Modified();
+      fPad->cd();
+   }
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::SetPTcutEGMUNU(Float_t ptcut)
+{
+   fPTcutEGMUNU = ptcut;
+
+   if (fDrawAllViews) {
+      fPad->cd(1); gPad->Modified();
+      fPad->cd(2); gPad->Modified();
+      fPad->cd(3); gPad->Modified();
+      fPad->cd(4); gPad->Modified();
+      fPad->cd();
+   }
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::SetView(Float_t theta, Float_t phi)
+{
+//  change viewing angles for current event
+
+   fPad->cd();
+   fDrawAllViews = kFALSE;
+   fPhi   = phi;
+   fTheta = theta;
+   Int_t iret;
+
+   TView *view = gPad->GetView();
+   if (view) view->SetView(fPhi, fTheta, 0, iret);
+   else      Draw();
+
+   gPad->Modified();
+}
+
+//_____________________________________________________________________________
+void AliFDisplay::ShowNextEvent(Int_t delta)
+{
+//  Display (current event_number+delta)
+//    delta =  1  shown next event
+//    delta = -1 show previous event
+
+  if (delta) {
+     gAliFast->Clear();
+     Int_t current_event = gAliFast->Event();
+     Int_t new_event     = current_event + delta;
+     gAliFast->GetTreeEvent(new_event); 
+   }
+  fPad->cd(); 
+  Draw();
+}
+
+//______________________________________________________________________________
+void AliFDisplay::SizeFruit() const
+{
+   const Int_t npoints = 2;
+   gSize3D.numPoints += npoints;
+   gSize3D.numSegs   += (npoints-1);
+   gSize3D.numPolys  += 0;
+}
+
+//______________________________________________________________________________
+void AliFDisplay::SizeParticles() const
+{
+   if (fDrawParticles)  fParticle->SizeParticles();
+}
+
+
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFDisplay.h b/ALIFAST/AliFDisplay.h
new file mode 100644 (file)
index 0000000..8ecb17b
--- /dev/null
@@ -0,0 +1,96 @@
+#ifndef AliFDisplay_H
+#define AliFDisplay_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFDisplay                                                          //
+//                                                                      //
+// Utility class to display ALICE outline, tracks, clusters, jets,..    //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef AliFVirtualDisplay_H
+#include "AliFVirtualDisplay.h"
+#endif
+
+class TCanvas;
+class TPad;
+class TArc;
+class TTUBE;
+class TNode;
+class TPolyLine3D;
+class TList;
+class AliFParticle;
+
+class AliFDisplay : public AliFVirtualDisplay {
+
+private:
+   Bool_t            fDrawAllViews;         //Flag True if AllViews selected
+   Bool_t            fDrawParticles;        //Flag True if particles to be drawn
+   Float_t           fPTcut;                //PT cut to display objects
+   Float_t           fPTcutEGMUNU;          //PT cut for Electrons, Gammas, MUons, Neutrinos
+   Float_t           fRin;                  //Inner ALIAS radius
+   Float_t           fRout;                 //Outer ALIAS radius
+   Float_t           fZin;                  //Inner ALIAS length along Z
+   Float_t           fZout;                 //Outer ALIAS length along Z
+   Float_t           fTheta;                //Viewing angle theta
+   Float_t           fPhi;                  //Viewing angle phi
+   TCanvas          *fCanvas;               //Pointer to the display canvas
+   TPad             *fTrigPad;              //Pointer to the trigger pad 
+   TPad             *fButtons;              //Pointer to the buttons pad
+   TPad             *fPad;                  //Pointer to the event display main pad
+   TTUBE            *fTubin;                //Inner tube
+   TTUBE            *fTubout;               //outer tube
+   TNode            *fNodin;                //Node for detector outline
+   TList            *fFruits;               //List for fruits
+   AliFParticle     *fParticle;             //Pointer to Particle graphics manager
+   
+public:
+                     AliFDisplay();
+                     AliFDisplay(const char *title);
+   virtual          ~AliFDisplay();
+   virtual Bool_t    AllViews() {return fDrawAllViews;}
+   virtual void      Clear(Option_t *option="");
+   virtual void      DisplayButtons();
+   virtual Int_t     DistancetoPrimitive(Int_t px, Int_t py);
+   virtual void      Draw(Option_t *option="");
+   virtual void      DrawAllViews();
+   Bool_t            DrawParticles() {return fDrawParticles;}
+   virtual void      DrawTitle(Option_t *option="");
+   virtual void      DrawView(Float_t theta, Float_t phi);
+   virtual void      DrawViewGL();
+   virtual void      DrawViewX3D();
+   virtual void      ExecuteEvent(Int_t event, Int_t px, Int_t py);
+   virtual void      GetEvent(Int_t event); //*MENU*
+   TNode            *Nodin() {return fNodin;}
+   TTUBE            *Tubin() {return fTubin;}
+   TPad             *Pad() {return fPad;}
+   virtual void      Paint(Option_t *option="");
+   virtual void      PaintFruit(TObject *obj, Float_t eta, Float_t phi, Float_t pt, Int_t type, Option_t *option="");
+   virtual void      PaintParticles(Option_t *option="");
+   Float_t           PTcut() {return fPTcut;}
+   Float_t           PTcutEGMUNU() {return fPTcutEGMUNU;}
+   Float_t           Rin() {return fRin;}
+   Float_t           Rout() {return fRout;}
+   virtual void      SetDrawParticles(Bool_t draw=kTRUE) {fDrawParticles=draw;} // *MENU*
+   virtual void      SetPTcut(Float_t ptcut=0.4); // *MENU*
+   virtual void      SetPTcutEGMUNU(Float_t ptcut=5); // *MENU*
+   virtual void      SetGeometry(Float_t rin=115); // *MENU*
+   virtual void      SetView(Float_t theta, Float_t phi);
+   virtual void      ShowNextEvent(Int_t delta=1);
+   virtual void      SizeFruit() const;
+   virtual void      SizeParticles() const;
+   Float_t           Zin() {return fZin;}
+   Float_t           Zout() {return fZout;}
+
+   ClassDef(AliFDisplay, 0)   //Utility class to display ALIAS outline, tracks, clusters, jets,..
+};
+
+#endif
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFFruit.cxx b/ALIFAST/AliFFruit.cxx
new file mode 100644 (file)
index 0000000..7335bd6
--- /dev/null
@@ -0,0 +1,93 @@
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFFruit                                                            //
+//                                                                      //
+// Utility class to draw Electrons, photons, Jets, Clusters,etc         //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include <TROOT.h>
+#include <TMath.h>
+
+#include "AliFDisplay.h"
+#include "AliFFruit.h"
+#include "AliFast.h"
+
+ClassImp(AliFFruit)
+
+
+//_____________________________________________________________________________
+AliFFruit::AliFFruit(TObject *obj, Float_t eta, Float_t phi, Float_t pt, Int_t type)
+          : TPolyLine3D(2)
+{
+  // Create a fruit object.
+  // Current implementation uses a 3-d polyline to visualize this fruit
+
+   fFruit = obj;
+   SetBit(kCanDelete);
+
+   const Int_t color[7] = {0,7,3,2,6,4,0};
+   const Int_t width[7] = {8,8,8,8,8,8,8};
+   Int_t lwidth = width[type];
+   AliFDisplay *display = (AliFDisplay*)gAliFast->Display();
+   if (display->AllViews()) lwidth /= 2;
+   const Float_t PTMAX = 100;
+   if (pt <= 0) return;
+   Float_t rin    = display->Rin();
+   Float_t rout   = display->Rout();
+   Float_t theta  = 2*TMath::ATan(TMath::Exp(-eta));
+   Float_t tantet = TMath::Tan(theta);
+   Float_t cosphi = TMath::Cos(phi);
+   Float_t sinphi = TMath::Sin(phi);
+   Float_t zz = pt/PTMAX;
+   if (zz > 3) zz = 3;
+   Float_t rex = rin + 3*zz*(rout - rin);
+   Float_t z1,z2;
+   if (eta != 0) {
+      z1 = rin/tantet;
+      z2 = rex/tantet;
+   } else {
+      z1 = z2 = 0;
+   }
+   SetPoint(0, rin*cosphi,rin*sinphi, z1);
+   SetPoint(1, rex*cosphi,rex*sinphi, z2);
+   SetLineColor(color[type]);
+   SetLineWidth(width[type]);
+}
+
+//_____________________________________________________________________________
+void AliFFruit::Delete(Option_t *)
+{
+//    Dummy
+
+}
+
+//______________________________________________________________________________
+char *AliFFruit::GetObjectInfo(Int_t px, Int_t py)
+{
+   return fFruit->GetObjectInfo(px, py);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFFruit.h b/ALIFAST/AliFFruit.h
new file mode 100644 (file)
index 0000000..6903354
--- /dev/null
@@ -0,0 +1,34 @@
+#ifndef AliFFruit_H
+#define AliFFruit_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFFruit                                                            //
+//                                                                      //
+// Utility class to draw Electrons, photons, Jets, Clusters,etc         //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TPolyLine3D
+#include <TPolyLine3D.h>
+#endif
+
+class AliFDisplay;
+
+class AliFFruit : public TPolyLine3D {
+
+private:
+   TObject          *fFruit;            //Pointer to original fruit
+   
+public:
+                     AliFFruit() {;}
+                     AliFFruit(TObject *obj, Float_t eta, Float_t phi, Float_t pt, Int_t type);
+   virtual          ~AliFFruit() {;}
+   virtual void      Delete(Option_t *option="");
+   TObject          *Fruit() {return fFruit;}
+   virtual char     *GetObjectInfo(Int_t px, Int_t py);
+
+   ClassDef(AliFFruit, 0)   //Utility class to draw Electrons, photons, Jets, Clusters,etc
+};
+
+#endif
diff --git a/ALIFAST/AliFHistBrowser.cxx b/ALIFAST/AliFHistBrowser.cxx
new file mode 100644 (file)
index 0000000..e1477b5
--- /dev/null
@@ -0,0 +1,36 @@
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFHistBrowser                                                      //
+//                                                                      //
+// helper class to browse AliFast Makers histograms.                    //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include <TBrowser.h>
+#include "AliFast.h"
+#include "AliFMaker.h"
+#include "AliFHistBrowser.h"
+
+ClassImp(AliFHistBrowser)
+
+
+
+//_____________________________________________________________________________
+AliFHistBrowser::AliFHistBrowser() 
+                : TNamed("Histograms","ALIfast Histograms browser")
+{
+
+}
+
+//_____________________________________________________________________________
+void AliFHistBrowser::Browse(TBrowser *b)
+{
+
+  TIter next(gAliFast->Makers());
+  AliFMaker *maker;
+  while ((maker = (AliFMaker*)next())) {
+     b->Add(maker->Histograms(),maker->GetName());
+   }
+
+}
diff --git a/ALIFAST/AliFHistBrowser.h b/ALIFAST/AliFHistBrowser.h
new file mode 100644 (file)
index 0000000..77c83da
--- /dev/null
@@ -0,0 +1,27 @@
+#ifndef AliFHistBrowser_H
+#define AliFHistBrowser_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFHistBrowser                                                      //
+//                                                                      //
+// helper class to browse AliFast Makers histograms.                    //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TNamed
+#include <TNamed.h>
+#endif
+
+class AliFHistBrowser : public TNamed {
+
+public:
+                     AliFHistBrowser();
+   virtual          ~AliFHistBrowser() {;}
+   virtual void      Browse(TBrowser *b);
+   Bool_t            IsFolder() {return kTRUE;}
+
+   ClassDef(AliFHistBrowser, 0)   //helper class to browse AliFast Makers histograms
+};
+
+#endif
diff --git a/ALIFAST/AliFMaker.cxx b/ALIFAST/AliFMaker.cxx
new file mode 100644 (file)
index 0000000..cc711f0
--- /dev/null
@@ -0,0 +1,216 @@
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFast virtual base class for Makers                                //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include <TChain.h>
+#include <TTree.h>
+#include <TList.h>
+#include <TClonesArray.h>
+#include <TBrowser.h>
+
+#include "AliFMaker.h"
+#include "AliFast.h"
+
+ClassImp(AliFMaker)
+
+//_____________________________________________________________________________
+AliFMaker::AliFMaker()
+{
+   fBranchName = "";
+   fSave       = 0;
+   fHistograms = 0;
+   fFruits     = 0;
+   fClones     = 0;
+   fIsClonable = kTRUE;
+}
+
+//_____________________________________________________________________________
+AliFMaker::AliFMaker(const char *name, const char *title)
+       :TNamed(name,title)
+{
+   fBranchName = "";
+   fSave       = 0;
+   fHistograms = new TList();
+   fClones     = 0;
+   fIsClonable = kTRUE;
+   
+   gAliFast->Makers()->Add(this);
+}
+
+//_____________________________________________________________________________
+AliFMaker::~AliFMaker()
+{
+  delete fFruits;
+  delete fClones;
+}
+
+//______________________________________________________________________________
+void AliFMaker::Browse(TBrowser *b)
+{
+//  Insert Maker objects in the list of objects to browsed.
+
+  char name[64];
+  if( b == 0  || fFruits == 0) return;
+  TObject *obj;
+
+// If fFruits is a ClonesArray, insert all the objects in the list
+// of browsable objects
+  if (fFruits->InheritsFrom("TClonesArray")) {
+     TClonesArray *clones = (TClonesArray*)fFruits;
+     Int_t nobjects = clones->GetEntries();
+     for (Int_t i=0;i<nobjects;i++) {
+        obj = clones->At(i);
+        sprintf(name,"%s_%d",obj->GetName(),i);
+        if (strstr(name,"AliF")) b->Add(obj, &name[4]);
+        else                     b->Add(obj, &name[0]);
+     }
+// fFruits points to an object in general. Insert this object in the browser
+  } else {
+      b->Add( fFruits, fFruits->GetName());
+  }
+}
+
+//_____________________________________________________________________________
+void AliFMaker::Clear(Option_t *option)
+{
+  if (fFruits) fFruits->Clear(option);
+  delete fClones;
+  fClones = 0;
+}
+
+//_____________________________________________________________________________
+void AliFMaker::Draw(Option_t *)
+{
+//    Insert products of this maker in graphics pad list
+
+  TObject *obj;
+
+// If fFruits is a ClonesArray, insert all the objects in the list
+// of objects to be painted
+  if (fFruits->InheritsFrom("TClonesArray")) {
+     TClonesArray *clones = (TClonesArray*)fFruits;
+     Int_t nobjects = clones->GetEntries();
+     for (Int_t i=0;i<nobjects;i++) {
+        obj = clones->At(i);
+        if (obj) obj->AppendPad();
+     }
+// fFruits points to an object in general. Insert this object in the pad
+  } else {
+     fFruits->AppendPad();
+  }
+}
+
+//_____________________________________________________________________________
+void AliFMaker::FillClone()
+{
+//   Copy original fruits in a separate list (clones)
+
+   if (!fIsClonable || fFruits == 0) return;
+   fClones = fFruits->Clone();
+}
+
+//_____________________________________________________________________________
+void AliFMaker::Init()
+{
+   //dummy
+}
+
+//_____________________________________________________________________________
+void AliFMaker::Finish()
+{
+
+   //dummy
+}
+
+//_____________________________________________________________________________
+void AliFMaker::Make()
+{
+
+   Warning("Make","Dummy function called");
+}
+
+//_____________________________________________________________________________
+void AliFMaker::PrintInfo()
+{
+   printf("*************************************************************\n");
+   printf("*                                                           *\n");
+   printf("*            %25s                      *\n",GetName());
+   printf("*                                                           *\n");
+   printf("*************************************************************\n");
+
+   Dump();
+}
+
+//_____________________________________________________________________________
+void AliFMaker::MakeBranch()
+{
+//   Adds the list of physics objects to the AliFast tree as a new branch
+
+   if (fSave == 0) return;
+
+   TTree *tree = gAliFast->Tree();
+   if (tree == 0  || fFruits == 0  || fBranchName.Length() == 0) return;
+
+//  Make a branch tree if a branch name has been set
+   Int_t buffersize = 4000;
+   if (fFruits->InheritsFrom("TClonesArray")) {
+      tree->Branch(fBranchName.Data(), &fFruits, buffersize);
+   } else {
+      tree->Branch(fBranchName.Data(),fFruits->ClassName(), &fFruits, buffersize);
+   }
+}
+
+//_____________________________________________________________________________
+void AliFMaker::SetChainAddress(TChain *chain)
+{
+//   Set branch address in a chain of files
+
+   if (chain == 0) return;
+
+   chain->SetBranchAddress(fBranchName.Data(), &fFruits);
+}
+
+//______________________________________________________________________________
+void AliFMaker::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AliFMaker.
+
+   if (R__b.IsReading()) {
+      R__b.ReadVersion(); // Version_t R__v = R__b.ReadVersion();
+      TNamed::Streamer(R__b);
+      R__b >> fSave;
+      R__b >> fFruits;
+      fBranchName.Streamer(R__b);
+      R__b >> fHistograms;
+          //this is an addition to the standard rootcint version of Streamer
+          //branch address for this maker is set automatically
+      TTree *tree = gAliFast->Tree();
+      if (tree == 0  || fFruits == 0  || fBranchName.Length() == 0) return;
+      TBranch *branch = tree->GetBranch(fBranchName.Data());
+      if (branch)  branch->SetAddress(&fFruits);
+   } else {
+      R__b.WriteVersion(AliFMaker::IsA());
+      TNamed::Streamer(R__b);
+      R__b << fSave;
+      R__b << fFruits;
+      fBranchName.Streamer(R__b);
+      R__b << fHistograms;
+   }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFMaker.h b/ALIFAST/AliFMaker.h
new file mode 100644 (file)
index 0000000..65fd111
--- /dev/null
@@ -0,0 +1,69 @@
+#ifndef AliFMaker_H
+#define AliFMaker_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFast virtual base class for Makers                                //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TNamed
+#include <TNamed.h>
+#endif
+#ifndef ROOT_TClonesArray
+#include <TClonesArray.h>
+#endif
+
+class TList;
+class TBrowser;
+class TChain;
+
+class AliFMaker : public TNamed {
+
+protected:
+
+   Bool_t         fIsClonable;  //!True if Maker objects are clonable
+   Int_t          fSave;        // = 1 if m-Maker to be saved in the Tree
+   TObject       *fFruits;      //Pointer to maker fruits (result)
+   TObject       *fClones;      //Pointer to clones of fruits
+   TString        fBranchName;  //Name of branch (if any)
+   TList         *fHistograms;  //Pointer to list supporting Maker histograms
+
+public:
+                  AliFMaker();
+                  AliFMaker(const char *name, const char *title);
+   virtual       ~AliFMaker();
+   virtual void   Browse(TBrowser *b);
+   virtual void   Clear(Option_t *option="");
+   virtual void   Draw(Option_t *option="");
+   virtual void   Finish();
+   TList         *Histograms() {return fHistograms;}
+   virtual void   Init();
+   Bool_t         IsFolder() {return kTRUE;}
+   TObject       *Fruit() {return fFruits;}
+   TClonesArray  *Fruits() {return (TClonesArray*)fFruits;}
+   TObject       *Clones() {return fClones;}
+   virtual void   FillClone();
+   virtual void   Make() = 0;
+   virtual void   PrintInfo();
+   virtual void   MakeBranch();
+   virtual void   Save(Int_t save=1) {fSave = save;}
+   virtual void   SetChainAddress(TChain *chain);
+
+   ClassDef(AliFMaker, 1)   //AliFast virtual base class for Makers
+};
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFParticle.cxx b/ALIFAST/AliFParticle.cxx
new file mode 100644 (file)
index 0000000..dacac0b
--- /dev/null
@@ -0,0 +1,291 @@
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFParticle                                                         //
+//                                                                      //
+//  Graphics interface to event generators particle                     //
+//////////////////////////////////////////////////////////////////////////
+
+#include <TROOT.h>
+#include "TMCParticle.h"
+#include "TClonesArray.h"
+#include "TPolyLine3D.h"
+#include "TCanvas.h"
+#include <TList.h>
+#include <TMath.h>
+
+#include "AliFParticle.h"
+#include "AliFMCMaker.h"
+#include "AliFast.h"
+#include "AliFDisplay.h"
+
+const Int_t kRECONS = BIT(16);
+
+ClassImp(AliFParticle)
+
+
+//_____________________________________________________________________________
+AliFParticle::AliFParticle(const char * name) :TNamed(name,name)
+{
+   // Create list to support list of particles
+   fParticles = new TList();
+   fDisplay   = (AliFDisplay*)gAliFast->Display();
+}
+
+//_____________________________________________________________________________
+AliFParticle::~AliFParticle()
+{
+   if (fParticles) fParticles->Delete();
+   delete fParticles;
+}
+
+//_____________________________________________________________________________
+void AliFParticle::Clear(Option_t *)
+{
+//    Delete graphics temporary objects
+
+   fParticles->Delete();
+
+}
+
+//_____________________________________________________________________________
+void AliFParticle::Delete(Option_t *)
+{
+//    Dummy
+
+}
+
+//_____________________________________________________________________________
+Int_t AliFParticle::DistancetoPrimitive(Int_t px, Int_t py)
+{
+    // scan list of particles
+   TClonesArray *particles = gAliFast->MCMaker()->Fruits();
+   Int_t uid, dist;
+   TIter next(fParticles);
+   TPolyLine3D *line;
+   while((line=(TPolyLine3D*)next())) {
+      dist = line->DistancetoPrimitive(px, py);
+      if (dist < 2) {
+         uid = line->GetUniqueID();
+         fMCParticle = (TMCParticle*)particles->UncheckedAt(uid);
+         if (!fMCParticle) continue;
+         fLine = line;
+         SetName(fMCParticle->GetName());
+         gPad->SetSelected(this);
+         gPad->SetCursor(kCross);
+         return 0;
+      }
+   }
+   return 999;
+}
+
+//______________________________________________________________________________
+void AliFParticle::ExecuteEvent(Int_t event, Int_t , Int_t )
+{
+   switch (event) {
+
+   case kButton1Down:
+      gGXW->SetLineColor(-1);
+      gPad->AbsCoordinates(kTRUE);
+      fLine->SetLineColor(6);
+      fLine->SetLineWidth(6);
+      fLine->Paint(); 
+      break;
+
+   case kMouseMotion:
+      break;
+
+   case kButton1Motion:
+      break;
+
+   case kButton1Up:
+      gGXW->SetLineColor(-1);
+      fLine->SetLineColor(kYellow);
+      fLine->SetLineWidth(1);
+      fLine->Paint(); 
+      gPad->AbsCoordinates(kFALSE);
+   }
+}
+
+//______________________________________________________________________________
+char *AliFParticle::GetObjectInfo(Int_t , Int_t )
+{
+   static char info[100];
+   sprintf(info,"px=%f, py=%f, pz=%f, E=%f",
+            fMCParticle->GetPx(),
+            fMCParticle->GetPy(),
+            fMCParticle->GetPz(),
+            fMCParticle->GetEnergy());
+
+
+   return info;
+}
+
+
+//______________________________________________________________________________
+TPolyLine3D *AliFParticle::HelixCurve(Float_t field, Float_t pmom, Float_t *vin)
+{
+//    Estimate step size in function of field.
+//    Create a 3-D polyline with points computed with this step size
+
+   Float_t step = 10;
+   const Int_t kMAXSTEP = 2000;
+   Float_t sx[kMAXSTEP], sy[kMAXSTEP], sz[kMAXSTEP];
+   if (pmom > 0)   step = 10*pmom;
+   if (step > 100) step = 100;
+   if (step <  .5) step = .5;
+
+   Float_t vout[6];
+   Int_t i,j;
+   sx[0] = vin[0];
+   sy[0] = vin[1];
+   sz[0] = vin[2];
+   Int_t nsteps = 1;
+   Float_t rin  = Display()->Rin();
+   Float_t zout = Display()->Zout();
+   for (i=1;i<kMAXSTEP;i++) {
+      HelixStep(field,step,pmom,vin,vout);
+      if (TMath::Abs(vout[2]) > zout) break;
+      if (vout[0]*vout[0] + vout[1]*vout[1] > 1.1*rin*rin) break;
+      sx[nsteps] = vout[0];
+      sy[nsteps] = vout[1];
+      sz[nsteps] = vout[2];
+      nsteps++;
+      for (j=0;j<6;j++) vin[j] = vout[j];
+   }
+   if (nsteps < 2) return 0;
+   TPolyLine3D *line = new TPolyLine3D(nsteps,sx, sy,sz);
+   line->SetBit(kCanDelete);
+   return line;
+}
+
+//______________________________________________________________________________
+void AliFParticle::HelixStep(Float_t field, Float_t step, Float_t pmom, Float_t *vin, Float_t *vout)
+{
+//     extrapolate track with parameters in vector vin in a constant field
+//     oriented along Z axis (in tesla/meters).
+//     Output in vector vout
+//     vin[0-->6] = x,y,z,px,py,pz
+//     translated to C++ from GEANT3 routine GHELX3
+
+   Float_t sint, sintt, tsint, cos1t, sin2;
+//      units are tesla,centimeters,gev/c
+   const Float_t ec = 2.9979251e-3;
+   Float_t h4  = field*ec;
+   Float_t hp  = vin[2];
+   Float_t tet = -h4*step/pmom;
+   if (TMath::Abs(tet) > 0.15) {
+      sint  = TMath::Sin(tet);
+      sintt = sint/tet;
+      tsint = (tet-sint)/tet;
+      sin2  = TMath::Sin(0.5*tet);
+      cos1t = 2*sin2*sin2/tet;
+   } else {
+      tsint = tet*tet/6;
+      sintt = 1 - tsint;
+      sint  = tet*sintt;
+      cos1t = 0.5*tet;
+   }
+   Float_t f1 = step*sintt;
+   Float_t f2 = step*cos1t;
+   Float_t f3 = step*tsint*hp;
+   Float_t f4 = -tet*cos1t;
+   Float_t f5 = sint;
+   Float_t f6 = tet*cos1t*hp;
+
+   vout[0] = vin[0] + (f1*vin[3] - f2*vin[4]);
+   vout[1] = vin[1] + (f1*vin[4] + f2*vin[3]);
+   vout[2] = vin[2] + (f1*vin[5] + f3);
+
+   vout[3] = vin[3] + (f4*vin[3] - f5*vin[4]);
+   vout[4] = vin[4] + (f4*vin[4] + f5*vin[3]);
+   vout[5] = vin[5] + (f4*vin[5] + f6);
+}
+
+//_____________________________________________________________________________
+void AliFParticle::Paint(Option_t *option)
+{
+//    Paint particles generated by AliFMCMaker
+//    Only particles above fPTcut are drawn
+//    Particle trajectory is computed along an helix in a constant field
+
+
+   // clean list of particles
+   fParticles->Delete();
+
+   TClonesArray *particles = gAliFast->MCMaker()->Fruits();
+   Int_t nparticles = particles->GetEntriesFast();
+   TMCParticle *part;
+   Float_t pmom, vx, vy, vz, pt;
+   Float_t vin[6];
+   Float_t field = 2; // 2 tesla
+   Int_t KF, aKF, charge;
+   for (Int_t i=0;i<nparticles;i++) {
+      part = (TMCParticle*)particles->UncheckedAt(i);     
+      if (part->GetKS() != 1) continue;
+      KF = part->GetKF();
+      aKF = TMath::Abs(KF);
+      charge = gAliFast->MCMaker()->Charge(KF);
+      pt = TMath::Sqrt(part->GetPx()*part->GetPx() + part->GetPy()*part->GetPy());
+      if (pt < gAliFast->Display()->PTcut()) continue;
+      if (charge == 0 && pt < gAliFast->Display()->PTcutEGMUNU()) continue;
+      pmom = TMath::Sqrt(part->GetPx()*part->GetPx() + part->GetPy()*part->GetPy() + part->GetPz()*part->GetPz());
+      vx = part->GetVx();
+      vy = part->GetVy();
+      vz = part->GetVz();
+      vin[0] = vx;
+      vin[1] = vy;
+      vin[2] = vz;
+      vin[3] = part->GetPx()/pmom;
+      vin[4] = part->GetPy()/pmom;
+      vin[5] = part->GetPz()/pmom;
+      TPolyLine3D *line = HelixCurve(charge*field/3, pmom, vin);
+      if (line == 0) continue;
+      fParticles->Add(line);
+      if (part->GetLineColor() == 1) {
+         if (charge == 0) part->SetLineStyle(2);
+         part->SetLineColor(kYellow);
+         if (aKF == 11) part->SetLineColor(kRed);
+         if (aKF == 13) part->SetLineColor(kMagenta);
+         if (aKF == 22) part->SetLineColor(kGreen);
+      }
+      line->SetUniqueID(i);
+      if (!part->TestBit(kRECONS)) {
+         part->SetLineColor(7);
+         part->SetLineWidth(1);
+      }
+      line->SetLineColor(part->GetLineColor());
+      line->SetLineStyle(part->GetLineStyle());
+      line->SetLineWidth(part->GetLineWidth());
+      line->Paint(option);
+   }
+}
+
+//______________________________________________________________________________
+void AliFParticle::SetLineAttributes()
+{
+//*-*-*-*-*-*-*-*-*Invoke the DialogCanvas Line attributes*-*-*-*-*-*-*
+//*-*              =======================================
+
+   gROOT->SetSelectedPrimitive(fMCParticle);
+   fMCParticle->SetLineAttributes();
+}
+
+
+//______________________________________________________________________________
+void AliFParticle::SizeParticles() const
+{
+   TIter next(fParticles);
+   TPolyLine3D *line;
+   while((line=(TPolyLine3D*)next())) {
+      line->Sizeof3D();
+   }
+}
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFParticle.h b/ALIFAST/AliFParticle.h
new file mode 100644 (file)
index 0000000..48d2fe3
--- /dev/null
@@ -0,0 +1,48 @@
+#ifndef AliFParticle_H
+#define AliFParticle_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFParticle                                                         //
+//                                                                      //
+// Graphics interface to event generators particle                      //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TNamed
+#include <TNamed.h>
+#endif
+
+class TMCParticle;
+class TPolyLine3D;
+class TList;
+class AliFDisplay;
+
+class AliFParticle : public TNamed {
+
+private:
+   TList            *fParticles;            //List for particles
+   AliFDisplay      *fDisplay;              //pointer to AliFDisplay object
+   TMCParticle      *fMCParticle;           //pointer to selected particle
+   TPolyLine3D      *fLine;                 //pointer to line3D
+   
+public:
+                     AliFParticle() {;}
+                     AliFParticle(const char *name);
+   virtual          ~AliFParticle();
+   virtual void      Clear(Option_t *option="");
+   virtual void      Delete(Option_t *option="");
+   virtual Int_t     DistancetoPrimitive(Int_t px, Int_t py);
+   AliFDisplay      *Display() {return fDisplay;}
+   virtual void      ExecuteEvent(Int_t event, Int_t px, Int_t py);
+   virtual char     *GetObjectInfo(Int_t px, Int_t py);
+   TPolyLine3D      *HelixCurve(Float_t field, Float_t pmom, Float_t *vin);
+   virtual void      HelixStep(Float_t field, Float_t step, Float_t pmom, Float_t *vin, Float_t *vout);
+   virtual void      Paint(Option_t *option="");
+   virtual void      SetLineAttributes(); // *MENU*
+   virtual void      SizeParticles() const;
+
+   ClassDef(AliFParticle, 0)   //Graphics interface to event generators particle
+};
+
+#endif
diff --git a/ALIFAST/AliFTrack.cxx b/ALIFAST/AliFTrack.cxx
new file mode 100644 (file)
index 0000000..20cdcf1
--- /dev/null
@@ -0,0 +1,45 @@
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFast Track class                                                  //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include "AliFTrack.h"
+#include "AliFast.h"
+
+ClassImp(AliFTrack)
+
+//_____________________________________________________________________________
+AliFTrack::AliFTrack(Int_t code, Double_t charge,
+                     Double_t pT, Double_t eta, Double_t phi,
+                     Double_t v11, Double_t v22,Double_t v33,
+                     Double_t v12, Double_t v13, Double_t v23, Int_t iFlag)
+{
+   fIdTrack    = code;
+   fChTrack    = charge;
+   fPT         = pT;
+   fEta        = eta;
+   fPhi        = phi;
+   fV11        = v11;
+   fV22        = v22;
+   fV33        = v33;
+   fV13        = v13;
+   fV12        = v12;
+   fV23        = v23;
+   fIFlag      = iFlag;
+}
+
+
+//_____________________________________________________________________________
+void AliFTrack::Draw(Option_t *)
+{
+
+}
+
+//_____________________________________________________________________________
+void AliFTrack::Paint(Option_t *)
+{
+
+}
+
diff --git a/ALIFAST/AliFTrack.h b/ALIFAST/AliFTrack.h
new file mode 100644 (file)
index 0000000..645bac3
--- /dev/null
@@ -0,0 +1,57 @@
+#ifndef AliFTrack_H
+#define AliFTrack_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFast track class                                                  //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TObject
+#include <TObject.h>
+#endif
+
+class AliFTrack : public TObject {
+
+private:
+   Int_t          fIdTrack;       //Track code
+   Double_t       fChTrack;       //Track charge
+   Double_t       fPT;            //Track transverse momenta
+   Double_t       fEta;           //Track eta
+   Double_t       fPhi;           //Track phi
+   Double_t       fV11;           //
+   Double_t       fV22;           //
+   Double_t       fV33;           //
+   Double_t       fV12;           //
+   Double_t       fV13;           //
+   Double_t       fV23;           //
+   Int_t          fIFlag;         //
+
+public:
+                  AliFTrack() {;}
+                  AliFTrack(Int_t code, Double_t charge, Double_t pT, Double_t eta, Double_t phi,
+                            Double_t v11, Double_t v22, Double_t v33,
+                            Double_t v12, Double_t v13, Double_t v23, Int_t iFlag);
+   virtual       ~AliFTrack() {;}
+   virtual void   Draw(Option_t *option="");
+   virtual void   Paint(Option_t *option="");
+
+   //getters
+   Int_t          IdTrack() {return fIdTrack;}
+   Double_t       ChTrack() {return fChTrack;}
+   Double_t       PT()  {return fPT;}
+   Double_t       Eta() {return fEta;}
+   Double_t       Phi() {return fPhi;}
+   Double_t       V11() {return fV11;}
+   Double_t       V22() {return fV22;}
+   Double_t       V33() {return fV33;}
+   Double_t       V12() {return fV12;}
+   Double_t       V13() {return fV13;}
+   Double_t       V23() {return fV23;}
+   Int_t          IFlag() {return fIFlag;}
+
+
+   ClassDef(AliFTrack, 1)   //AliFast track class
+};
+
+#endif
diff --git a/ALIFAST/AliFTrackMaker.cxx b/ALIFAST/AliFTrackMaker.cxx
new file mode 100644 (file)
index 0000000..17bd12f
--- /dev/null
@@ -0,0 +1,1062 @@
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFast TrackMaker class.                                            //
+//                                                                      //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+// ---------------------------------------------------------------------//
+//                                                                      //
+// origin: "res.f" fortran by Karel Safarik which was used to           //
+//         calculate the track resolution for TP.                       //
+//         Different detectors and material can be selected.            //
+//         The basic routines compute information and error matrices    //
+//         used for the calculation of momentum resolution.             //
+//         see references: ASK KAREL??                                  //
+//                                                                      //
+// C++ in AliFast framework: Elzbieta Richter-Was and Yiota Foka        //
+//                           following general structure od Makers in   //
+//                           ATLFast by R. Brun.                        //
+//                                                                      //
+// purpose: provide a Maker which by using general basic routines of    //
+//          "res.f" computes the necessary elements of covariance matrix// 
+//          for the calculation of Track Resolution.                    //
+//          Those elements are the product of the TrackResolMaker and   //
+//          are hold in TrackResol class. They are expected to be used  //
+//          together with additional information for the calculation of //
+//          the smeared momenta.                                        //
+//          Additional information necessary for this calculation       //
+//          will be provided via classes or functions specific to the   //
+//          specific study and/or detectors.                            //
+//          One can select the detector and/or material for a specific  //
+//          study.                                                      //
+//                                                                      //
+// starting point: res.f will be initialy partially contained in        // 
+//                 AliFTrackResolMaker and in AliFDet                   // 
+//                 It will be reorganised further in the framework of   //
+//                 AliFast according to the needs.                      //
+//                 Names of variables are kept as in fortran code.      //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+
+#ifdef WIN32
+// there is a bug in the Microsoft VisualC++ compiler
+// this class must be compiled with optimization off on Windows
+# pragma optimize( "", off )
+#endif
+
+#include <TParticle.h>
+#include <TFile.h>
+#include <TSystem.h>
+#include <TRandom.h>
+#include <TROOT.h>
+#include <TMath.h>
+#include <TH1.h>
+#include <TH2.h>
+#include <TH3.h>
+
+#include "AliFast.h"
+//#include "AliFMCMaker.h"
+#include "AliFTrackMaker.h"
+#include "AliFTrack.h"
+#include "AliFDet.h"
+
+const Double_t kPi       = TMath::Pi();
+const Double_t k2Pi      = 2*kPi;
+const Double_t kPiHalf   = kPi/2.;
+extern  AliFast * gAliFast;
+ClassImp(AliFTrackMaker)
+
+//_____________________________________________________________________________
+AliFTrackMaker::AliFTrackMaker()
+{
+   fNTracks = 0;
+}
+
+//_____________________________________________________________________________
+AliFTrackMaker::AliFTrackMaker(const char *name, const char *title)
+                 :AliFMaker(name,title)
+{
+//    Default Setters for tracks
+
+   fFruits     = new TClonesArray("AliFTrack",100, kFALSE);
+   fBranchName = "Tracks";
+   fNTracks    = 0;
+// Please, how to do this optionally ??!!!
+   Save();
+}
+
+//_____________________________________________________________________________
+AliFTrackMaker::~AliFTrackMaker()
+{
+   //dummy
+}
+
+//_____________________________________________________________________________
+AliFTrack *AliFTrackMaker::AddTrack(Int_t code, Double_t charge, 
+                                    Double_t pT, Double_t eta,Double_t phi,
+                                    Double_t v11, Double_t v22, Double_t v33,
+                                    Double_t v12, Double_t v13, Double_t v23, Int_t iFlag)
+{
+//            Add a new track to the list of tracks
+
+ //Note the use of the "new with placement" to create a new track object.
+ //This complex "new" works in the following way:
+ //   tracks[i] is the value of the pointer for track number i in the TClonesArray
+ //   if it is zero, then a new track must be generated. This typically
+ //   will happen only at the first events
+ //   If it is not zero, then the already existing object is overwritten
+ //   by the new track parameters.
+ // This technique should save a huge amount of time otherwise spent
+ // in the operators new and delete.
+
+   TClonesArray &tracks = *(TClonesArray*)fFruits;
+   return new(tracks[fNTracks++]) AliFTrack(code,charge,pT,eta,phi,
+                                  v11, v22, v33, v12, v13, v23, iFlag);
+}
+
+//_____________________________________________________________________________
+void AliFTrackMaker::Clear(Option_t *option)
+{
+   //Reset Track Maker
+
+   fNTracks = 0;
+   AliFMaker::Clear(option);
+}
+
+//_____________________________________________________________________________
+void AliFTrackMaker::Draw(Option_t *)
+{
+//    Dummy Draw
+
+}
+
+//_____________________________________________________________________________
+void AliFTrackMaker::Init()
+{
+  //Create control histograms 
+  if(gAliFast->TestTrack() == 0){
+
+     fResID11 = new TH1D("ResID11","Elec: delta(1/pTotal)*pTotal",1000,-0.5,0.5); 
+     fResID12 = new TH1D("ResID12","Elec: delta(lambda)/lambda",1000,-0.01,0.01); 
+     fResID13 = new TH1D("ResID13","Elec: delta(phi)/phi",1000,-0.01,0.01); 
+
+     fResID21 = new TH1D("ResID21","Pion: delta(1/pTotal)*pTotal",1000,-1.0,1.0); 
+     fResID22 = new TH1D("ResID22","Pion: delta(lambda)/lambda",1000,-1.0,1.0); 
+     fResID23 = new TH1D("ResID23","Pion: delta(phi)/phi",1000,-1.0,1.0); 
+
+     fResID31 = new TH1D("ResID31","Kaon: delta(1/pTotal)*pTotal",1000,-1.0,1.0); 
+     fResID32 = new TH1D("ResID32","Kaon: delta(lambda)/lambda",1000,-1.0,1.0); 
+     fResID33 = new TH1D("ResID33","Kaon: delta(phi)/phi",1000,-1.0,1.0); 
+
+     fResID41 = new TH1D("ResID41","Proton: delta(1/pTotal)*pTotal",1000,-1.0,1.0); 
+     fResID42 = new TH1D("ResID42","Proton: delta(lambda)/lambda",1000,-1.0,1.0); 
+     fResID43 = new TH1D("ResID43","Proton: delta(phi)/phi",1000,-1.0,1.0); 
+
+  }   
+  //Create test histograms for TestJob only  
+  if(gAliFast->TestTrack() == 1){
+     fResID1Test  = new TH1D("ResID1Test","histogram21 from res.f",1000,0.075,10.075); 
+     fResID2Test  = new TH1D("ResID2Test","histogram21 from res.f",1000,0.075,10.075); 
+     fResID3Test  = new TH1D("ResID3Test","histogram21 from res.f",1000,0.075,10.075); 
+     fResID4Test  = new TH1D("ResID4Test","histogram21 from res.f",1000,0.075,10.075); 
+     fResID5Test  = new TH1D("ResID5Test","histogram21 from res.f",1000,0.075,10.075); 
+  }
+
+  //Set particle masses
+   SetPionMass();
+   SetKaonMass();
+   SetElectronMass();
+   SetProtonMass();
+
+  //Switch on/off tracks reconstruction
+   SetRecTrack();
+
+}
+
+//_____________________________________________________________________________
+// Calculate track and its resolution
+//_____________________________________________________________________________
+void AliFTrackMaker::Make()
+{
+  Double_t v11, v22, v33, v12, v13, v23;
+  Int_t iFlag;
+
+  fNTracks = 0; 
+
+  // Check if it is a TestJob
+  if(gAliFast->TestTrack() == 1){
+     // Run test job
+     MakeTest(10);
+  }else{
+     // Run production job  
+     // Get pointers to Particles arrays and TClonesArray
+
+     TClonesArray *particles = gAliFast->Particles();  
+     Int_t idPart, idTrack;
+     Double_t  charge, pT, eta, phi;
+     TParticle *part;
+     Int_t  nparticles = particles->GetEntriesFast();
+     printf("%10s%10d\n","nparticles",nparticles);
+     for(Int_t ind=0;ind<nparticles;ind++) {       
+       part = (TParticle*)particles->UncheckedAt(ind);
+       idPart  = part->GetPdgCode();
+       charge  = part->GetPDG()->Charge();
+       pT      = part->Pt();  
+       eta     = part->Eta();
+       phi     = part->Phi();
+       printf("%10s%10d%20.5e%20.5e%20.5e%20.5e\n","Particle",idPart,charge,pT,eta,phi);
+       // Check convention for tracks reconstruction
+       idTrack = 0;
+       if(TMath::Abs(idPart) ==   11)                 idTrack = 1;
+       if(TMath::Abs(idPart) == 111 || TMath::Abs(idPart) == 211) idTrack = 2;
+       if(TMath::Abs(idPart) == 311 || TMath::Abs(idPart) == 321) idTrack = 3;
+       if(TMath::Abs(idPart) == 2212)                 idTrack = 4;
+       
+       if(idTrack > 0 && fRecTrack > 0){
+        // Check if track should be reconstructed
+        if((fRecTrack == 1 && idTrack == 1) ||
+           (fRecTrack == 2 && idTrack == 2) ||
+           (fRecTrack == 3 && idTrack == 3) ||
+           (fRecTrack == 4 && idTrack == 4) ||
+           fRecTrack == 100 ) {
+          // Tracks are  reconstructed
+          ErrorMatrix(idTrack,pT,eta, v11, v22, v33, v12, v13, v23, iFlag);
+          
+          // Calculate and smear track parameters
+          Double_t lambda, cosLambda, pTotal,pInverse;
+          Double_t pInverseSmea, lambdaSmea, phiSmea;
+          Double_t a1, a2, a3, b2, b3, c3;
+          Double_t rn1, rn2, rn3;
+          
+          lambda    = kPiHalf -2.0*TMath::ATan(TMath::Exp(-eta));
+          cosLambda = TMath::Cos(lambda);
+          pTotal    = pT/cosLambda;
+          pInverse  = 1.0/pTotal;
+          
+          a1  = TMath::Sqrt(v11);
+          if(a1 == 0.){
+            a2 = 0;
+            a3 = 0;
+          }else{
+            a2  = v12/a1;
+            a3  = v13/a1;
+          }
+          b2  = TMath::Sqrt(v22-a2*a2);
+          if(b2 == 0.){
+            b3 = 0;
+          }else{
+            b3  = (v23 - a2*a3)/b2;
+          }
+          c3  = TMath::Sqrt(v33 - a3*a3 -b3*b3);
+          rn1 = gRandom->Gaus(0,1);
+          rn2 = gRandom->Gaus(0,1);
+          rn3 = gRandom->Gaus(0,1);
+          
+          pInverseSmea  = pInverse + a1*rn1;
+          lambdaSmea    = lambda + a2*rn1 + b2*rn2;
+          phiSmea       = phi + a3*rn1 + b3*rn2 + c3*rn3; 
+          
+          // Fill control histograms
+          if(idTrack == 1){
+            fResID11->Fill((pInverseSmea-pInverse)/pInverse);
+            fResID12->Fill((lambdaSmea-lambda)/lambda);
+            fResID13->Fill((phiSmea-phi)/phi);
+          }
+          else if(idTrack == 2){
+            fResID21->Fill((pInverseSmea-pInverse)/pInverse);
+            fResID22->Fill((lambdaSmea-lambda)/lambda);
+            fResID23->Fill((phiSmea-phi)/phi);
+          }
+          else if(idTrack == 3){
+            fResID31->Fill((pInverseSmea-pInverse)/pInverse);
+            fResID32->Fill((lambdaSmea-lambda)/lambda);
+            fResID33->Fill((phiSmea-phi)/phi);
+          }
+          else if(idTrack == 4){
+            fResID41->Fill((pInverseSmea-pInverse)/pInverse);
+            fResID42->Fill((lambdaSmea-lambda)/lambda);
+            fResID43->Fill((phiSmea-phi)/phi);
+          }
+        }else{
+          // Tracks are not reconstructed
+          v11=0.;
+          v12=0.;
+          v13=0.;
+          v22=0.;
+          v23=0.;
+          v33=0.;
+          iFlag=0;
+        }
+        // Store resolution variables  to AliFTrack  ClonesArray
+        AddTrack(idTrack, charge, pT, eta, phi, v11, v22, v33, v12, v13, v23, iFlag);
+         printf("%10s%10d%20.5e%20.5e%20.5e%20.5e%20.5e%20.5e%20.5e%20.5e%20.5e%20.5e%10d\n",
+              "Track",idTrack,charge,pT,eta,phi,v11, v22, v33, v12, v13, v23, iFlag);
+       }
+       
+     }
+  }
+}
+
+//_____________________________________________________________________________
+void AliFTrackMaker::Finish()
+{
+  // For TestJob only  
+  if(gAliFast->TestTrack() == 1){
+    /*
+    // Draw test histograms
+    TCanvas *c1 = new TCanvas("c1"," ",200,10,600,480);
+    c1->Divide(2,3);
+    c1->cd(1);   fResID1Test->Draw();
+    c1->cd(2);   fResID2Test->Draw();
+    c1->cd(3);   fResID3Test->Draw();
+    c1->cd(4);   fResID4Test->Draw();
+    c1->cd(5);   fResID5Test->Draw();
+    c1->Update();
+    // Store TestRes.eps file
+    c1->Print("TestRes.eps");
+    */
+    // Store histograms on file
+    TFile f2("TestRes.root","RECREATE","Test Res.f");
+    fResID1Test->Write();
+    fResID2Test->Write();
+    fResID3Test->Write();
+    fResID4Test->Write();
+    fResID5Test->Write();
+    f2.Close();
+  } 
+}
+//_____________________________________________________________________________
+void AliFTrackMaker::ErrorMatrix(Int_t idTrack, Double_t pT,  Double_t eta,
+  Double_t &v11, Double_t &v22, Double_t &v33, Double_t &v12, Double_t &v13, Double_t &v23,
+  Int_t &iFlag)
+{
+  ///////////////////////////////////////////////
+  //idTrack      track type            input   //
+  //pT           transverse mom        input   //
+  //lambda       deep angle            input   //
+  //v11,v22,v23  error matrix          output  //
+  //v12,v13,v23                        output  //
+  //iFlag                              output  //
+  ///////////////////////////////////////////////
+  AliFDet *detector = gAliFast->Detector();
+  Int_t nDet = detector->NDet();
+  Int_t nDetActive = detector->NDetActive();
+  Int_t nTwice = nDetActive + nDetActive;
+
+  Double_t rTrack, rTrackInverse, pTotal, pInverse, diffPInverse;
+  Double_t safety;
+  Double_t cosLambda, tanLambda, diffLambda;
+  Double_t rDet;
+  Double_t hh0[kNMaxDet2][kNMaxDet2], hhi0[kNMaxDet2][kNMaxDet2];  
+  Double_t hh1[kNMaxDet2][kNMaxDet2], hhi1[kNMaxDet2][kNMaxDet2];  
+  Double_t dhhiOverPInverse[kNMaxDet2][kNMaxDet2];  
+  Double_t dhhiOverLambda[kNMaxDet2][kNMaxDet2];  
+  Double_t a1[kNMaxDet2][kNMaxDet2], a2[kNMaxDet2][kNMaxDet2];  
+  Double_t a0PInverse[kNMaxDet2];  
+  Double_t a0Lambda[kNMaxDet2];  
+  Double_t a0Phi[kNMaxDet2]; 
+
+  Double_t vF11, vF12, vF13, vF22, vF23, vF33, d1, d2, d3, det; 
+  Int_t   idet, icyl, im, in;
+  Double_t phiHalf;
+  Double_t lambda;
+
+  lambda = kPiHalf -2.0*TMath::ATan(TMath::Exp(-eta));
+  rTrack    = detector->ConstMag()*pT;
+  safety    = 10.0;
+  if(2.0*rTrack < (detector->RDet(nDet) + safety)){
+      iFlag     = 0;
+      v11 = 0;
+      v22 = 0;
+      v33 = 0;
+      v12 = 0;
+      v13 = 0;
+      v23 = 0;
+      return;
+  }
+  iFlag        = 1;
+  cosLambda    = TMath::Cos(lambda);
+  pTotal       = pT/cosLambda;
+  pInverse     = 1.0/pTotal;
+  diffPInverse = pInverse*1.0e-5;
+  diffLambda   = 1.0e-4; 
+
+  // Compute likelihood and derivatives
+
+  LogLikelyhood(idTrack, pInverse, lambda);
+  for(icyl=1; icyl<nTwice+1; icyl++){
+     for(im=1; im<nTwice+1; im++){
+      hh0[icyl][im]  = HH(icyl,im); 
+      hhi0[icyl][im] = HHI(icyl,im);
+     }
+  }
+  LogLikelyhood(idTrack, pInverse+diffPInverse,lambda);
+  for(icyl=1; icyl<nTwice+1; icyl++){   
+     for(im=1; im<nTwice+1; im++){
+      hh1[icyl][im]  = HH(icyl,im);
+      hhi1[icyl][im] = HHI(icyl,im);
+     }
+  }  
+  for(icyl=1; icyl<nTwice+1; icyl++){
+     for(im=1; im<icyl+1; im++){
+        dhhiOverPInverse[icyl][im] = (hhi1[icyl][im]-hhi0[icyl][im])/diffPInverse; 
+     }
+  }
+  LogLikelyhood(idTrack, pInverse, lambda+diffLambda);
+  for(icyl=1; icyl<nTwice+1; icyl++){
+     for(im=1; im<nTwice+1; im++){
+      hh1[icyl][im]  = HH(icyl,im);
+      hhi1[icyl][im] = HHI(icyl,im);
+     }
+  }
+  for(icyl=1; icyl<nTwice+1; icyl++){
+     for(im=1; im<icyl+1; im++){
+        dhhiOverLambda[icyl][im] = (hhi1[icyl][im]-hhi0[icyl][im])/diffLambda; 
+     }
+  }
+
+  // Compute additional derivatives
+  rTrackInverse = 1.0/rTrack;
+  tanLambda    = TMath::Tan(lambda);
+  icyl = 0;
+  for(idet=1; idet<nDet+1;idet++){
+     if(detector->IFlagDet(idet) > 0){
+        icyl = icyl + 1;
+        rDet = detector->RDet(idet);
+        phiHalf = TMath::ASin(0.5*rDet*rTrackInverse);
+        Double_t rHelp   = rDet /
+                          (2.0 * TMath::Sqrt(1.0-(0.5 *rDet*rTrackInverse)*
+                                                 (0.5 *rDet*rTrackInverse)));
+        a0PInverse[icyl] = - rDet* rHelp
+                           /(detector->ConstMag()*cosLambda);
+        a0Lambda[icyl]   = - rDet* rHelp
+                           * tanLambda * rTrackInverse;
+        a0Phi[icyl]      =   rDet;
+        a0PInverse[nDetActive+icyl] = 2.0 * tanLambda
+                           *rTrack*(rHelp-rTrack*phiHalf)
+                           /(detector->ConstMag()*cosLambda);
+        a0Lambda[nDetActive+icyl]   = 2.0 * (  rHelp*tanLambda*tanLambda
+                                             + rTrack*phiHalf);
+        a0Phi[nDetActive+icyl] = 0.0 ;
+    }
+  }
+  // Compute information matrix
+
+    vF11=0.0;
+    vF12=0.0;
+    vF13=0.0;
+    vF22=0.0;
+    vF23=0.0;
+    vF33=0.0;
+    for(icyl=1; icyl<nTwice+1; icyl++){
+       d1=0.0;     
+       d2=0.0;     
+       d3=0.0; 
+       for(im=1; im < icyl+1; im++){
+          d1 = d1 + hhi0[icyl][im]*a0PInverse[im];
+          d2 = d2 + hhi0[icyl][im]*a0Lambda[im];
+          d3 = d3 + hhi0[icyl][im]*a0Phi[im];
+       }
+       vF11 =vF11 + d1*d1;
+       vF12 =vF12 + d1*d2;
+       vF13 =vF13 + d1*d3;
+       vF22 =vF22 + d2*d2;
+       vF23 =vF23 + d2*d3;
+       vF33 =vF33 + d3*d3;
+    }
+    for(icyl=1; icyl<nTwice+1; icyl++){
+       for(im=1; im<icyl+1; im++){
+          a1[icyl][im] = 0;
+          a2[icyl][im] = 0;
+          for(in=im; in<icyl+1;in++){
+             a1[icyl][im]=a1[icyl][im]+dhhiOverPInverse[icyl][in]*hh0[im][in];
+             a2[icyl][im]=a2[icyl][im]+dhhiOverLambda[icyl][in]*hh0[im][in];
+         }
+          vF11=vF11+a1[icyl][im]*a1[icyl][im];
+          vF12=vF12+a1[icyl][im]*a2[icyl][im];
+          vF22=vF22+a2[icyl][im]*a2[icyl][im];
+       }
+       vF11=vF11+a1[icyl][icyl]*a1[icyl][icyl];
+       vF12=vF12+a1[icyl][icyl]*a2[icyl][icyl];
+       vF22=vF22+a2[icyl][icyl]*a2[icyl][icyl];
+       }
+  // Invert information matrix
+
+    det=( vF11*vF22 - vF12*vF12 ) *vF33 + (vF12*vF23 - vF13*vF22)*vF13
+                                        + (vF12*vF13 - vF11*vF23)*vF23;
+
+    v11 = (vF22*vF33 - vF23*vF23)/det;
+    v22 = (vF11*vF33 - vF13*vF13)/det;
+    v33 = (vF11*vF22 - vF12*vF12)/det;
+    v12 = (vF13*vF23 - vF12*vF33)/det;
+    v13 = (vF12*vF23 - vF13*vF22)/det;
+    v23 = (vF12*vF13 - vF11*vF23)/det;
+  
+    }
+//_____________________________________________________________________________//
+void AliFTrackMaker::LogLikelyhood(Int_t idTrack, Double_t pInverse,Double_t lambda)
+{
+  ///////////////////////////////////////////////
+  //hh           ??                    output  //
+  //hhi          ??                    output  //
+  //idTrack       track type           input   //
+  //pInverse      inverse  momentum    input   //
+  //lambda       polar angle of track  input   //
+  ///////////////////////////////////////////////
+
+  AliFDet *detector = gAliFast->Detector();
+  Int_t nDet = detector->NDet();
+  Int_t nDetActive = detector->NDetActive();
+  Int_t nTwice = nDetActive + nDetActive;
+
+  Double_t    rDet, rDetSQ;
+  Int_t      idet, icyl, im, imc;
+  Double_t    cosLambda, tanLambda, pTotal, pT, rTrack, rTrackSQ;
+  Double_t    beta, overPBeta, rTrackInv, thickCorr, temp1, temp2;
+  Double_t    partMassSQ;
+  Double_t    aShelp[kNMaxDet2], dShelp[kNMaxDet2];
+  Double_t    projXVXT[kNMaxDet2],projYVXT[kNMaxDet2], projZVXT[kNMaxDet2]; 
+  Double_t    proj[kNMaxDet2][kNMaxDet2]; 
+  Double_t    erroScatt[kNMaxDet2], variance[kNMaxDet2][kNMaxDet2];
+  Double_t    erroSQ[kNMaxDet2];
+  Double_t    hh[kNMaxDet2][kNMaxDet2];
+  Double_t    hhi[kNMaxDet2][kNMaxDet2];
+  Double_t    errorVX, errorVY, errorVZ;
+
+  cosLambda = TMath::Cos(lambda);
+  tanLambda = TMath::Tan(lambda);
+  pTotal    = 1.0/pInverse;
+  pT        = pTotal * cosLambda;
+  rTrack    = detector->ConstMag() * pTotal * cosLambda;
+  rTrackSQ  = rTrack * rTrack;
+  partMassSQ= ParticleMass(idTrack)*ParticleMass(idTrack);
+  beta      = pTotal / TMath::Sqrt(partMassSQ+pTotal*pTotal);
+  overPBeta = 1./(pTotal*beta);
+  rTrackInv = 1./rTrack;
+  errorVX   = detector->ErrorVertexX();
+  errorVY   = detector->ErrorVertexY();
+  errorVZ   = detector->ErrorVertexZ();
+
+    
+  erroScatt[0]=0.0;
+  erroScatt[1]=0.0;
+  for(idet=1; idet < nDet; idet++){
+     thickCorr = detector->ThickDet(idet)/TMath::Sqrt(cosLambda*
+                 TMath::Sqrt(1.0-0.25*(detector->RDetSQ(idet)/rTrackSQ)));
+     if(detector->IFlagGas(idet) == 0){
+         thickCorr = thickCorr * (1.3266 + 0.076 * TMath::Log(thickCorr));}
+     thickCorr = overPBeta * thickCorr;
+     erroScatt[idet+1]=thickCorr*thickCorr;
+  }
+
+
+  icyl = 0;
+  for(idet=1; idet<nDet+1; idet++){
+    rDet   = detector->RDet(idet);
+    rDetSQ = rDet*rDet;
+    dShelp[idet] = TMath::Sqrt(4.0*rTrackSQ-rDetSQ);
+    aShelp[idet] = TMath::ASin(rDet/(rTrack+rTrack));
+    if(detector->IFlagDet(idet) > 0) {
+       icyl = icyl + 1;
+       projXVXT[icyl] = rDet * rTrackInv;
+       projXVXT[nDetActive+icyl] = -tanLambda;
+       temp1 = (rTrackSQ + rTrackSQ - rDetSQ)/dShelp[idet];
+       temp2 = rDet/dShelp[idet];
+       projYVXT[icyl] = temp1*rTrackInv;
+       projYVXT[nDetActive+icyl] = tanLambda * temp2;
+       projZVXT[icyl] = 0.0;
+       projZVXT[nDetActive+icyl] = 1.0;
+       proj[icyl][1] = 0.0;
+       proj[nDetActive+icyl][0] = 0.0;
+       proj[nDetActive+icyl][nDet] = 0.0;
+       proj[icyl][nDet] = 0.0;
+       for(im=2; im<idet+1; im++){
+          proj[icyl][im]= (( rDet
+                           *(rTrackSQ+rTrackSQ-detector->RDetSQ(im-1))
+                           - detector->RDet(im-1)*temp1*dShelp[im-1])
+                         /((rTrackSQ + rTrackSQ)*cosLambda));
+          proj[nDetActive+icyl][im]= 0.5 * detector->RDet(im-1)
+                                   * rTrackInv
+                                   * tanLambda * (detector->RDet(im-1)
+                                   - dShelp[im-1]*temp2)/cosLambda;
+          proj[nDetActive+icyl][nDet+im]= (rTrack+rTrack) * (aShelp[idet] - aShelp[im-1])
+            + ( rDet*dShelp[im-1]-detector->RDet(im-1)*dShelp[idet])
+            *  dShelp[im-1] * tanLambda * tanLambda
+              / (dShelp[idet] * (rTrack+rTrack));
+          proj[icyl][nDet+im]= tanLambda 
+                        *  (rDet*detector->RDet(im-1)*dShelp[im-1]
+                        / (rTrackSQ+rTrackSQ)
+                        - (rDetSQ + detector->RDetSQ(im-1)
+                        -  rDetSQ * detector->RDetSQ(im-1)
+                        / (rTrackSQ+rTrackSQ))
+                        / dShelp[idet]);
+       }
+       for(im=idet+1; im < nDet+1; im++){
+          proj[icyl][im] = 0.0;
+          proj[nDetActive+icyl][im] = 0.0;
+          proj[nDetActive+icyl][nDet+im] = 0.0;
+          proj[icyl][nDet+im] = 0.0;
+       }
+       if(detector->IFlagDet(idet) == 1){
+          erroSQ[icyl] = detector->ErrorRPhi(idet);
+          erroSQ[nDetActive+icyl] = detector->ErrorZ(idet);
+       }else{
+                 TPCResolution(pT, rDet, lambda);
+          erroSQ[icyl]            = SigmaRPhiSQ();
+          erroSQ[nDetActive+icyl] = SigmaZSQ();
+       }
+       erroSQ[icyl] = erroSQ[icyl] + detector->ErrorR(idet)*temp2*temp2;
+       erroSQ[nDetActive+icyl] =  erroSQ[nDetActive+icyl] 
+                                + detector->ErrorR(idet)*tanLambda*tanLambda;
+    }
+  }
+    for(icyl=1; icyl<nTwice+1; icyl++){
+      for(im=1; im<icyl+1; im++){
+          variance[icyl][im]=
+               projXVXT[icyl]*projXVXT[im]*errorVX
+              +projYVXT[icyl]*projYVXT[im]*errorVY
+              +projZVXT[icyl]*projZVXT[im]*errorVZ;
+         for(imc=1; imc<nDet+1; imc++){
+             variance[icyl][im]=variance[icyl][im]
+                    +(proj[icyl][imc]*proj[im][imc]
+                    + proj[icyl][nDet+imc]*proj[im][nDet+imc])
+                    * erroScatt[imc];
+         }
+      }
+      variance[icyl][icyl] = variance[icyl][icyl]+erroSQ[icyl];
+    }
+   
+    for(icyl=1; icyl<nTwice+1; icyl++){
+      for(im=icyl; im<nTwice+1; im++){
+          hh[icyl][im]=variance[im][icyl];
+          for(imc=1; imc<icyl;imc++){
+               hh[icyl][im]=hh[icyl][im]-hh[imc][icyl]*hh[imc][im];
+           }
+            if(im == icyl){
+               hh[icyl][im] = TMath::Sqrt(hh[icyl][im]);
+            }  else {
+              hh[icyl][im] = hh[icyl][im]/hh[icyl][icyl];
+            }
+          }
+    }
+       
+    for(icyl=1; icyl<nTwice+1; icyl++){
+        hhi[icyl][icyl] = 1.0 / hh[icyl][icyl];
+        for(im=1; im<icyl; im++){
+           hhi[icyl][im] = 0.0;
+           for(imc=im; imc<icyl; imc++){
+             hhi[icyl][im] = hhi[icyl][im]-hh[imc][icyl]*hhi[imc][im];
+           }
+          hhi[icyl][im] = hhi[icyl][im]*hhi[icyl][icyl];
+       }
+    }
+    
+    for(icyl=1; icyl<nTwice+1; icyl++){
+      for(im=1; im<nTwice+1; im++){
+         SetHH(icyl,im,hh[icyl][im]);
+          SetHHI(icyl,im,hhi[icyl][im]);
+      }
+    }
+
+  
+}
+//_____________________________________________________________________________
+// translation of routine tpc_resolution of res.f
+//_____________________________________________________________________________
+void AliFTrackMaker::TPCResolution(Double_t pTransv, Double_t radiPad, Double_t lambda)
+{
+  ///////////////////////////////////////////////
+  //sigmaRPhiSQ  resolution in r-phi   output  //
+  //sigmaZSQ     resolution in z       output  //
+  //pTransv      transverse momentum   input   //
+  //radiPad      radius of pad row     input   //
+  //lambda       polar angle of track  input   //
+  //
+  //units: cm, GeV/c, radian                   //
+  //parametrisation of TPC resolution          //
+  //version of 03.07.1995                      //
+  //source: Marek Kowalski, Karel Safarik      //
+  ///////////////////////////////////////////////
+
+  Double_t aRCoeff=0.41818e-2;
+  Double_t bRCoeff=0.17460e-4;
+  Double_t cRCoeff=0.30993e-8;
+  Double_t dRCoeff=0.41061e-6;
+  Double_t aZCoeff=0.39610e-2;
+  Double_t bZCoeff=0.22443e-4;
+  Double_t cZCoeff=0.51504e-1;
+
+  Double_t sigmaRPhiSQ;
+  Double_t sigmaZSQ;
+
+  sigmaRPhiSQ = aRCoeff - bRCoeff * radiPad * TMath::Tan(lambda)+
+               (cRCoeff * (radiPad/pTransv) + dRCoeff) * radiPad/pTransv;
+
+  sigmaZSQ    = aZCoeff - bZCoeff * radiPad * TMath::Tan(lambda)+
+                cZCoeff * TMath::Tan(lambda)*TMath::Tan(lambda);
+
+  if(sigmaRPhiSQ < 1.0e-6 ) sigmaRPhiSQ = 1.0e-6;
+  if(sigmaZSQ    < 1.0e-6 ) sigmaZSQ    = 1.0e-6;
+
+  sigmaRPhiSQ =   (TMath::Sqrt(sigmaRPhiSQ) + 0.005)
+                * (TMath::Sqrt(sigmaRPhiSQ) + 0.005);
+  sigmaZSQ    =   (TMath::Sqrt(sigmaZSQ)    + 0.005)
+                * (TMath::Sqrt(sigmaZSQ)    + 0.005);
+
+  SetSigmaRPhiSQ(sigmaRPhiSQ);
+  SetSigmaZSQ(sigmaZSQ); 
+
+  
+}
+
+//_____________________________________________________________________________
+// returns the mass given particle ID 
+//-----------------------------------------------------------------------------
+Double_t AliFTrackMaker::ParticleMass(Int_t idTrack)
+{
+  Double_t mass = 0.0;
+
+       if(idTrack == 2){ mass = fPionMass;}
+  else if(idTrack == 3){ mass = fKaonMass;}
+  else if(idTrack == 1) {mass = fElectronMass;}
+  else if(idTrack == 4) {mass = fProtonMass;}
+
+  return mass;
+
+}
+
+//_____________________________________________________________________________
+// returns the rapidity given particle pT, pz 
+//-----------------------------------------------------------------------------
+Double_t AliFTrackMaker::Rapidity(Double_t pt, Double_t pz)
+{
+//   Compute rapidity
+
+   Double_t etalog = TMath::Log((TMath::Sqrt(pt*pt + pz*pz) + TMath::Abs(pz))/pt);
+   if (pz < 0 ) return -TMath::Abs(etalog);
+   else         return  TMath::Abs(etalog);
+}
+
+//_____________________________________________________________________________
+// returns the phi angle given particle px, py 
+//-----------------------------------------------------------------------------
+Double_t AliFTrackMaker::Angle(Double_t x, Double_t y)
+{
+//   Compute phi angle of particle
+// ... this is a copy of function ULANGL
+//  .. sign(a,b) = -abs(a) if b <  0
+//               =  abs(a) if b >= 0
+
+   Double_t angle = 0;
+   Double_t r = TMath::Sqrt(x*x + y*y);
+   if (r < 1e-20) return angle;
+   if (TMath::Abs(x)/r < 0.8) {
+      angle = TMath::Sign((Double_t)TMath::Abs(TMath::ACos(x/r)), y);
+   } else {
+      angle = TMath::ASin(y/r);
+      if (x < 0 ) {
+         if(angle >= 0) angle =  kPi - angle;
+         else           angle = -kPi - angle;
+      }
+   }
+   return angle;
+}
+//_____________________________________________________________________________
+Int_t AliFTrackMaker::Charge(Int_t kf)
+{
+//...this is copy of function LUCHGE 
+//...Purpose: to give three times the charge for a particle/parton. 
+
+  static Int_t kchg[500] = { -1,2,-1,2,-1,2,-1,2,0,0,-3,0,-3,0,-3,0,-3,0,
+        0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,3,0,0,3,0,-1,0,0,0,0,0,0,0,0,0,0,0,
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       2,-1,2,-1,2,3,0,0,0,0,0,0,0,0,0,0,0,3,0,3,3,0,3,0,3,0,3,0,0,0,0,0,
+       0,0,0,0,0,3,0,3,3,0,3,0,3,0,3,0,0,0,0,0,0,0,0,0,0,3,0,3,3,0,3,0,3,
+       0,3,0,0,0,0,0,0,0,0,0,0,3,0,3,3,0,3,0,3,0,3,0,0,0,0,0,0,0,0,0,0,3,
+       0,3,3,0,3,0,3,0,3,0,0,0,0,0,0,0,0,0,0,3,0,3,3,0,3,0,3,0,3,0,0,0,0,
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,
+       0,3,0,0,0,0,0,0,0,0,-3,0,0,0,0,0,0,0,0,3,0,-3,0,3,-3,0,0,0,3,6,0,
+       3,0,0,0,0,0,-3,0,3,-3,0,-3,0,0,0,0,-3,0,3,6,-3,0,3,-3,0,-3,0,3,6,
+       0,3,0,0,0,0,0,-3,0,3,-3,0,-3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
+
+//    extern integer kfcomp_(integer *);
+  Int_t ipower;
+  Int_t ret = 0;
+  Int_t kfa = TMath::Abs(kf);
+  Int_t kc  = Compress(kfa);
+
+//...Initial values. Simple case of direct readout. 
+  if (kc == 0) {
+  } else if (kfa <= 100 || kc <= 80 || kc > 100) {
+     ret = kchg[kc-1];
+
+// ...Construction from quark content for heavy meson, diquark, baryon.
+  } else if (kfa/1000 % 10 == 0) {
+       ipower = kfa/100 % 10;
+       ret = (kchg[kfa / 100 % 10 - 1] - kchg[kfa/10 % 10 - 1])*Int_t(TMath::Power(-1, ipower));
+  } else if (kfa / 10 % 10 == 0) {
+       ret = kchg[kfa/1000 % 10 - 1] + kchg[kfa/100 % 10 - 1];
+  } else {
+       ret = kchg[kfa/1000 % 10 - 1] + kchg[kfa/100 % 10 - 1] + kchg[kfa/10 % 10 - 1];
+  }
+
+// ...Add on correct sign.
+  if (kf > 0) return ret;
+  else        return -ret;
+}
+//_____________________________________________________________________________
+Int_t AliFTrackMaker::Compress(Int_t kf)
+{
+//...this is copy of function LUCOMP 
+//...Purpose: to compress the standard KF codes for use in mass and decay 
+//...arrays; also to check whether a given code actually is defined.
+//     from BLOCK LUDATA
+  static Int_t  kchg[500] = { 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,0,0,0,0,
+        0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1,
+        1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,
+        1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,
+        0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,
+        1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,
+        0,0,1,0,1,1,0,0,0,0,0,0,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,0,0,0,0,1,1,
+        1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,
+        1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
+  static Int_t kftab[25] = { 211,111,221,311,321,130,310,213,113,223,313,
+           323,2112,2212,210,2110,2210,110,220,330,440,30443,30553,0,0 };
+  static Int_t kctab[25] = { 101,111,112,102,103,221,222,121,131,132,122,
+           123,332,333,281,282,283,284,285,286,287,231,235,0,0 };
+
+  Int_t ret = 0;
+  Int_t kfla, kflb, kflc, kflr, kfls, kfa, ikf;
+
+  kfa = TMath::Abs(kf);
+//...Simple cases: direct translation or table.
+  if (kfa == 0 || kfa >= 100000) {
+     return ret;
+  } else if (kfa <= 100) {
+     ret = kfa;
+     if (kf < 0 && kchg[kfa - 1] == 0)  ret = 0;
+     return ret;
+  } else {
+     for (ikf = 1; ikf <= 23; ++ikf) {
+        if (kfa == kftab[ikf-1]) {
+           ret = kctab[ikf-1];
+           if (kf < 0 && kchg[ret-1] == 0)  ret = 0;
+           return ret;
+        }
+     }
+  }
+// ...Subdivide KF code into constituent pieces.
+  kfla = kfa / 1000%10;
+  kflb = kfa / 100%10;
+  kflc = kfa / 10%10;
+  kfls = kfa%10;
+  kflr = kfa / 10000%10;
+// ...Mesons.
+  if (kfa - kflr*10000 < 1000) {
+     if (kflb == 0 || kflb == 9 || kflc == 0 || kflc == 9) {
+     } else if (kflb < kflc) {
+     } else if (kf < 0 && kflb == kflc) {
+     } else if (kflb == kflc) {
+        if (kflr == 0 && kfls == 1) {        ret = kflb + 110;
+        } else if (kflr == 0 && kfls == 3) { ret = kflb + 130;
+        } else if (kflr == 1 && kfls == 3) { ret = kflb + 150;
+        } else if (kflr == 1 && kfls == 1) { ret = kflb + 170;
+        } else if (kflr == 2 && kfls == 3) { ret = kflb + 190;
+        } else if (kflr == 0 && kfls == 5) { ret = kflb + 210;
+        }
+     } else if (kflb <= 5) {
+        if (kflr == 0 && kfls == 1) {        ret = (kflb-1)*(kflb-2)/2 + 100 + kflc;
+        } else if (kflr == 0 && kfls == 3) { ret = (kflb-1)*(kflb-2)/2 + 120 + kflc;
+        } else if (kflr == 1 && kfls == 3) { ret = (kflb-1)*(kflb-2)/2 + 140 + kflc;
+        } else if (kflr == 1 && kfls == 1) { ret = (kflb-1)*(kflb-2)/2 + 160 + kflc;
+        } else if (kflr == 2 && kfls == 3) { ret = (kflb-1)*(kflb-2)/2 + 180 + kflc;
+        } else if (kflr == 0 && kfls == 5) { ret = (kflb-1)*(kflb-2)/2 + 200 + kflc;
+        }
+     } else if (kfls == 1 && kflr <= 1 || kfls == 3 && kflr <= 2 || kfls == 5 && kflr == 0) {
+        ret = kflb + 80;
+     }
+// ...Diquarks.
+  } else if ((kflr == 0 || kflr == 1) && kflc == 0) {
+     if (kfls != 1 && kfls != 3) {
+     } else if (kfla == 9 || kflb == 0 || kflb == 9) {
+     } else if (kfla < kflb) {
+     } else if (kfls == 1 && kfla == kflb) {
+     } else { ret = 90;
+     }
+// ...Spin 1/2 baryons.
+  } else if (kflr == 0 && kfls == 2) {
+     if (kfla == 9 || kflb == 0 || kflb == 9 || kflc == 9) {
+     } else if (kfla <= kflc || kfla < kflb) {
+     } else if (kfla >= 6 || kflb >= 4 || kflc >= 4) {
+         ret = kfla + 80;
+     } else if (kflb < kflc) {
+         ret = (kfla+1)*kfla*(kfla-1)/6 + 300 + kflc*(kflc-1)/2 + kflb;
+     } else {
+         ret = (kfla+1)*kfla*(kfla-1)/6 + 330 + kflb*(kflb-1)/2 + kflc;
+     }
+// ...Spin 3/2 baryons.
+  } else if (kflr == 0 && kfls == 4) {
+     if (kfla == 9 || kflb == 0 || kflb == 9 || kflc == 9) {
+     } else if (kfla < kflb || kflb < kflc) {
+     } else if (kfla >= 6 || kflb >= 4) {
+         ret = kfla + 80;
+     } else {
+         ret = (kfla+1)*kfla*(kfla-1) / 6 + 360 + kflb*(kflb -1) / 2 + kflc;
+     }
+  }
+    return ret;
+}
+
+//_____________________________________________________________________________
+// TEST JOB: Calculate tracks resolution
+//_____________________________________________________________________________
+void AliFTrackMaker::MakeTest(Int_t n)
+{
+  Double_t v11, v22, v33, v12, v13, v23;
+  Int_t iFlag;
+  Int_t idTrack;
+  Double_t  pTStart, pT, eta;
+
+  Double_t sumDPop,sumDDip,sumDPhi;
+  Double_t isum,fm;
+  Double_t pTotal,partMassSQ,beta,lambda;
+  Double_t dPop,dLop,dDip,dPhi,rho12,rho13,rho23;
+  Double_t dPPStrag,dPPTot;
+  //  Double_t resol1[1001][11],resol2[10001][11],resol3[1001][11],
+  //           resol4[1001][11],resol5[10001][11]
+  Double_t store1[1001],store2[10001],store3[1001],
+           store4[1001],store5[10001];
+
+
+  idTrack  = 2;
+  pTStart = 0.07;
+  for(Int_t istep=1; istep<n; istep++){
+      if(istep < 100 && istep >  20) istep = istep -1 +  5;
+      if(istep < 500 && istep > 100) istep = istep -1 + 25;
+      if(istep <1000 && istep > 500) istep = istep -1 + 100;
+      pT = pTStart + 0.01*istep;
+      eta = - 0.044;
+      sumDPop = 0;
+      sumDDip = 0;
+      sumDPhi = 0;
+      isum    = 0;
+      for(Int_t in=1; in<11; in++){
+         eta    = eta + 0.088;
+         lambda = kPiHalf -2.0*TMath::ATan(TMath::Exp(-eta));
+         pTotal = pT / TMath::Cos(lambda);
+         if(idTrack == 1){
+           dPPStrag = 0.055 /pT;}
+         else{
+           partMassSQ = ParticleMass(idTrack)*ParticleMass(idTrack);
+           beta       = pTotal/ TMath::Sqrt(pTotal*pTotal + partMassSQ); 
+           dPPStrag   = 0.04/(pT*TMath::Power(beta,2.6666666667));
+         }
+        ErrorMatrix(idTrack,pT,eta, v11, v22, v33, v12, v13, v23, iFlag);
+         if(iFlag == 1){
+           dLop   = TMath::Sqrt(v11);
+            dDip   = TMath::Sqrt(v22);
+            dPhi   = TMath::Sqrt(v33);
+            rho12  = v12/(dLop*dDip);
+            rho13  = v13/(dLop*dPhi);
+            rho23  = v23/(dDip*dPhi);
+            dPop   = 100. *dLop * pTotal;
+            dDip   = 1000. * dDip;
+            dPhi   = 1000. * dPhi;
+            dPPTot = TMath::Sqrt(dPop*dPop + dPPStrag*dPPStrag);
+           //            resol1[istep][in] = dPop;
+           //            resol2[istep][in] = dDip;
+           //            resol3[istep][in] = dPhi;
+           //            resol4[istep][in] = dPPTot;
+           //            resol5[istep][in] = dPPStrag;
+            sumDPop = sumDPop + dPop;
+            sumDDip = sumDDip + dDip;
+            sumDPhi = sumDPhi + dPhi;
+            isum    = isum + 1;}
+         else{
+            printf("%20s %10.5f %10.5f %20s\n","pT,eta",pT,eta,"cannot smear");
+         }
+       }
+       if(isum > 0){
+         dPop   = sumDPop/isum;
+         dDip   = sumDDip/isum;
+         dPhi   = sumDPhi/isum;
+         dPPTot = TMath::Sqrt(dPop*dPop + dPPStrag*dPPStrag);}
+       else{
+         dPop   = 0;
+         dDip   = 0;
+         dPhi   = 0;
+       }
+       store1[istep] = dPop;
+       store2[istep] = dDip;
+       store3[istep] = dPhi;
+       store4[istep] = dPPTot;
+       store5[istep] = dPPStrag;
+       if(istep > 20 ){
+          Int_t im = 5;
+          if(istep > 100) {im =  25;}
+          if(istep > 500) {im = 100;}
+          fm = 1./(1.*im);
+          for(Int_t ist=1; ist<im; ist++){
+             //               for(Int_t in=1; in < 11; in++){
+             //                   resol1[istep-im+ist][in] = resol1[istep-im][in]+
+             //                         ist*fm*(resol1[istep][in]-resol1[istep-im][in]);
+             //                   resol2[istep-im+ist][in] = resol2[istep-im][in]+
+             //                         ist*fm*(resol2[istep][in]-resol2[istep-im][in]);
+             //                   resol3[istep-im+ist][in] = resol3[istep-im][in]+
+             //                         ist*fm*(resol3[istep][in]-resol3[istep-im][in]);
+             //                   resol4[istep-im+ist][in] = resol4[istep-im][in]+
+             //                         ist*fm*(resol4[istep][in]-resol4[istep-im][in]);
+             //                   resol5[istep-im+ist][in] = resol5[istep-im][in]+
+             //                         ist*fm*(resol5[istep][in]-resol5[istep-im][in]);
+             //             }
+           store1[istep-im+ist]=store1[istep-im]+
+                                ist*fm*(store1[istep]-store1[istep-im]);
+           store2[istep-im+ist]=store2[istep-im]+
+                                ist*fm*(store2[istep]-store2[istep-im]);
+           store3[istep-im+ist]=store3[istep-im]+
+                                ist*fm*(store3[istep]-store3[istep-im]);
+            store4[istep-im+ist]=store4[istep-im]+
+                                ist*fm*(store4[istep]-store4[istep-im]);
+            store5[istep-im+ist]=store5[istep-im]+
+                                ist*fm*(store5[istep]-store5[istep-im]);
+            // Fill control histograms
+           fResID1Test->Fill(pTStart + 0.01*(istep-im+ist),store1[istep-im+ist]);
+           fResID2Test->Fill(pTStart + 0.01*(istep-im+ist),store2[istep-im+ist]);
+           fResID3Test->Fill(pTStart + 0.01*(istep-im+ist),store3[istep-im+ist]);
+           fResID4Test->Fill(pTStart + 0.01*(istep-im+ist),store4[istep-im+ist]);
+           fResID5Test->Fill(pTStart + 0.01*(istep-im+ist),store5[istep-im+ist]);
+          }
+         printf("%10s %10d %20.15f %20.15f %20.15f %20.15f %20.15f \n", 
+                      "TestTrack:",istep,store1[istep],store2[istep],store3[istep],
+                                    store4[istep],store5[istep]);
+       } else {     
+         printf("%10s %10d %20.15f %20.15f %20.15f %20.15f %20.15f \n", 
+                      "TestTrack:",istep,store1[istep],store2[istep],store3[istep],
+                                    store4[istep],store5[istep]);
+         fResID1Test->Fill(pT,store1[istep]);
+         fResID2Test->Fill(pT,store2[istep]);
+         fResID3Test->Fill(pT,store3[istep]);
+         fResID4Test->Fill(pT,store4[istep]);
+         fResID5Test->Fill(pT,store5[istep]);
+       }
+  }
+}
+//_____________________________________________________________________________
diff --git a/ALIFAST/AliFTrackMaker.h b/ALIFAST/AliFTrackMaker.h
new file mode 100644 (file)
index 0000000..7214961
--- /dev/null
@@ -0,0 +1,124 @@
+#ifndef AliFTrackMaker_H
+#define AliFTrackMaker_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFast TrackMaker class.                                            //
+//                                                                      //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef AliFMaker_H
+#include "AliFMaker.h"
+#endif
+#ifndef ROOT_TMatrix
+#include <TMatrix.h>
+#endif
+#ifndef ROOT_TH1
+#include <TH1.h>
+#endif
+
+class AliFTrack;
+#include "AliFDet.h"
+
+
+class AliFTrackMaker : public AliFMaker {
+
+protected:
+   Int_t           fNTracks;          //Number of tracks
+   Int_t           fRecTrack;        //Tracks reconstruction  on/off
+   //masses
+   Double_t        fPionMass;
+   Double_t        fKaonMass;
+   Double_t        fElectronMass;
+   Double_t        fProtonMass;
+   //matrices
+   Double_t        fHH[kNMaxDet2][kNMaxDet2];   
+   Double_t        fHHI[kNMaxDet2][kNMaxDet2];
+   //TPC resolution
+   Double_t        fSigmaRPhiSQ;   
+   Double_t        fSigmaZSQ;   
+   //     Tracks histograms (control)
+   TH1D          *fResID11;          //histogram ID11 Elec: delta(1/pTot)/pTot
+   TH1D          *fResID12;          //histogram ID12 Elec: delta(lambda)/lambda
+   TH1D          *fResID13;          //histogram ID13 Elec: delta(phi)/phi
+   TH1D          *fResID21;          //histogram ID21 Pion: delta(1/pTot)/pTot
+   TH1D          *fResID22;          //histogram ID22 Pion: delta(lambda)/lambda
+   TH1D          *fResID23;          //histogram ID23 Pion: delta(phi)/phi
+   TH1D          *fResID31;          //histogram ID31 Kaon: delta(1/pTot)/pTot
+   TH1D          *fResID32;          //histogram ID32 Kaon: delta(lambda)/lambda
+   TH1D          *fResID33;          //histogram ID33 Kaon: delta(phi)/phi
+   TH1D          *fResID41;          //histogram ID41 Proton: delta(1/pTot)/pTot
+   TH1D          *fResID42;          //histogram ID42 Proton: delta(lambda)/lambda
+   TH1D          *fResID43;          //histogram ID43 Proton: delta(phi)/phi
+   //     Tracks histograms (Test job)
+   TH1D          *fResID1Test;       //histogram ID1 in res.f 
+   TH1D          *fResID2Test;       //histogram ID2 in res.f 
+   TH1D          *fResID3Test;       //histogram ID3 in res.f 
+   TH1D          *fResID4Test;       //histogram ID4 in res.f 
+   TH1D          *fResID5Test;       //histogram ID5 in res.f 
+
+public:
+                  AliFTrackMaker();
+                  AliFTrackMaker(const char *name, const char *title);
+   virtual       ~AliFTrackMaker();
+   virtual void   Clear(Option_t *option="");
+   virtual void   Draw(Option_t *option="");
+   virtual void   Finish();
+   virtual void   Init();
+   virtual void   Make();
+   virtual void   MakeTest(Int_t n);
+   virtual void   PrintInfo() {}
+   AliFTrack     *AddTrack(Int_t code, Double_t charge, Double_t pT, Double_t eta, Double_t phi,
+                  Double_t v11, Double_t v22, Double_t v33, 
+                  Double_t v12, Double_t v13, Double_t v23, Int_t iFlag);
+           void   LogLikelyhood(Int_t idTrack, Double_t pInvers,  Double_t lambda);
+           void   TPCResolution(Double_t ptransv, Double_t radiPad, Double_t lambda); 
+   Double_t       ParticleMass(Int_t idTrack);  
+   Double_t       Rapidity(Double_t pT, Double_t pZ);  
+   Double_t       Angle(Double_t pX, Double_t pY);  
+   Int_t          Charge(Int_t kf);
+   Int_t          Compress(Int_t kf);
+           void   ErrorMatrix(Int_t idTrack, Double_t pT,  Double_t eta,
+                              Double_t &v11, Double_t &v22, Double_t &v33, 
+                              Double_t &v12, Double_t &v13, Double_t &v23, Int_t &iFlag);
+
+//    Getters
+   Double_t       HH(Int_t id1, Int_t id2) {return fHH[id1][id2];}
+   Double_t       HHI(Int_t id1, Int_t id2) {return fHHI[id1][id2];}
+   Double_t       SigmaRPhiSQ() {return fSigmaRPhiSQ;}
+   Double_t       SigmaZSQ() {return fSigmaZSQ;}
+   Int_t          NTracks() {return fNTracks;}
+
+
+//     Getters Tracks histograms
+
+
+
+//    Setters for tracks
+   //masses
+   void           SetPionMass(Double_t val=0.1395679e0) {fPionMass=val;}
+   void           SetKaonMass(Double_t val=0.493646e0) {fKaonMass=val;}
+   void           SetElectronMass(Double_t val=0.51099906e-3) {fElectronMass=val;}
+   void           SetProtonMass(Double_t val=0.93827231e0) {fProtonMass=val;}
+   void           SetHH(Int_t id1, Int_t id2, Double_t hh) {fHH[id1][id2]=hh;}
+   void           SetHHI(Int_t id1, Int_t id2, Double_t hhi) {fHHI[id1][id2]=hhi;}
+   void           SetSigmaRPhiSQ(Double_t val){fSigmaRPhiSQ=val;}
+   void           SetSigmaZSQ(Double_t val){fSigmaZSQ=val;}
+   void           SetRecTrack(Int_t val=100){fRecTrack=val;}
+
+
+
+   // 
+   ClassDef(AliFTrackMaker, 1)   //AliFast TrackMaker
+};
+
+#endif
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/AliFVirtualDisplay.cxx b/ALIFAST/AliFVirtualDisplay.cxx
new file mode 100644 (file)
index 0000000..13a44ab
--- /dev/null
@@ -0,0 +1,35 @@
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFVirtualDisplay                                                   //
+//                                                                      //
+// Virtual base class for AliFast event display                         //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include "AliFVirtualDisplay.h"
+
+ClassImp(AliFVirtualDisplay)
+
+
+//_____________________________________________________________________________
+AliFVirtualDisplay::AliFVirtualDisplay() : TObject()
+{
+}
+
+//_____________________________________________________________________________
+AliFVirtualDisplay::~AliFVirtualDisplay()
+{
+
+}
+
+//_____________________________________________________________________________
+void AliFVirtualDisplay::SizeFruit() const
+{
+
+}
+
+//_____________________________________________________________________________
+void AliFVirtualDisplay::SizeParticles() const
+{
+
+}
diff --git a/ALIFAST/AliFVirtualDisplay.h b/ALIFAST/AliFVirtualDisplay.h
new file mode 100644 (file)
index 0000000..173d3b0
--- /dev/null
@@ -0,0 +1,47 @@
+#ifndef AliFVirtualDisplay_H
+#define AliFVirtualDisplay_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFVirtualDisplay                                                   //
+//                                                                      //
+// Virtual base class for AliFast event display                         //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TObject
+#include <TObject.h>
+#endif
+
+class AliFTrigger;
+
+class AliFVirtualDisplay : public TObject {
+
+public:
+                     AliFVirtualDisplay();
+   virtual          ~AliFVirtualDisplay();
+   virtual void      Clear(Option_t *option="") = 0;
+   virtual void      DisplayButtons() = 0;
+   virtual Int_t     DistancetoPrimitive(Int_t px, Int_t py) = 0;
+   virtual void      Draw(Option_t *option="") = 0;
+   virtual void      DrawAllViews()  = 0;
+   virtual Bool_t    DrawParticles() = 0;
+   virtual void      DrawTitle(Option_t *option="") = 0;
+   virtual void      DrawView(Float_t theta, Float_t phi) = 0;
+   virtual void      DrawViewGL() = 0;
+   virtual void      DrawViewX3D() = 0;
+   virtual void      ExecuteEvent(Int_t event, Int_t px, Int_t py) = 0;
+   virtual void      Paint(Option_t *option="") = 0;
+   virtual void      PaintFruit(TObject *obj, Float_t eta, Float_t phi, Float_t pt, Int_t type, Option_t *option="") = 0;
+   virtual void      PaintParticles(Option_t *option="") = 0;
+   virtual Float_t   PTcut() = 0;
+   virtual Float_t   PTcutEGMUNU() = 0;
+   virtual void      SetView(Float_t theta, Float_t phi) = 0;
+   virtual void      ShowNextEvent(Int_t delta=1) = 0;
+   virtual void      SizeFruit() const;
+   virtual void      SizeParticles() const;
+
+   ClassDef(AliFVirtualDisplay, 0)   //Virtual base class for AliFast event display
+};
+
+#endif
diff --git a/ALIFAST/AliFast.cxx b/ALIFAST/AliFast.cxx
new file mode 100644 (file)
index 0000000..2e75a4b
--- /dev/null
@@ -0,0 +1,563 @@
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFast                                                              //
+//                                                                      //
+// Main class to control the AliFast program.                           //
+//                                                                      //
+// This class is a general framework for programs that needs to:        //
+//    - Initialise some parameters                                      //
+//    - Loop on events                                                  //
+//    - Print results and save histograms, etc                          //
+//                                                                      //
+// The event processor AliFast::Make loops on a list of Makers          //
+// where each maker performs some task on the event data and generates  //
+// results.                                                             //
+// New Makers can be inserted by a user without modifying this class.   //
+// Note that the order in which the Makers are called is the order      //
+// of insertion in the list of Makers.                                  //
+// Each Maker is responsible for creating its branch of the Tree.       //
+// The following table shows the list of makers currently implemented   //
+// The default option to Save the Maker info in the Tree is mentioned.  //
+//                                                                      //
+//    Maker name        Save in Tree                                    //
+//    ==========        ============                                    //
+//    MCMaker             NO                                            //
+//    TrackMaker          NO                                            //
+//                                                                      //
+// Makers must derive from the base class AliFMaker.                    //
+// AliFMaker provides a common interface to all Makers.                 //
+// Each Maker is responsible for defining its own parameters and        //
+// histograms.                                                          //
+// Each Maker has its own list of histograms.                           //
+// Each Maker has an associated companion class corresponding to the    //
+// type of physics object reconstructed by the Maker.                   //
+// For example, AliFClusterMaker creates AliFCluster objects.           //
+//              AliFTriggerMaker creates one single AliFTrigger object. //
+// The pointer supporting the created object(s) is defined in AliFMaker //
+//   fFruits may point to a single object (eg. AliFTrigger) or to a    //
+//           TClonesArray of objects (eg. AliFCluster).                 //
+//                                                                      //
+// The function AliFast::Maketree must be called after the creation     //
+// of the AliFast object to create a Root Tree.                         //
+//                                                                      //
+// An example of main program/macro to use AliFast is given below:      //
+//========================================================================
+//void umain(Int_t nevents=100)
+//{
+//   gROOT->Reset();
+//   gSystem->Load("libalifast.so");  // dynamically link the compiled shared library
+//
+//   // Open the root output file
+//   TFile file("alifast.root","recreate","AliFast root file",2);
+//   
+//   AliFast alifast("alifast");     // create main object to run alifast
+//
+//   User user;           // create an object of the User class defined in user.C
+//
+//   alifast.Init();      // Initialise event (maker histograms,etc)
+//   alifast.MakeTree();  // Create the Root tree
+//
+//   gROOT->LoadMacro("user.C");  // compile/interpret user file
+//
+//   for (Int_t i=0; i<nevents; i++) {
+//      if (i%100 == 0) printf("In loop:%d\n",i);
+//      alifast.Make(i);       // Generate and reconstruct event
+//      user.FillHistograms(); // User has possibility to decide if store event here!
+//      alifast.FillTree();
+//      alifast.Clear();       // Clear all event lists
+//   }
+//   alifast.Finish();
+//
+//   // save objects in Root file
+//   alifast.Write();  //save main alifast object (and run parameters)
+//}
+//========================================================================
+//                                                                      //
+// This example illustrates how to:                                     //
+//    - Load a shared library                                           //
+//    - Open a Root file                                                //
+//    - Initialise AliFast                                              //
+//    - Load some user code (interpreted)                               //
+//      This user code may redefine some Maker parameters               //
+//    - Make a loop on events                                           //
+//    - Save histograms and the main AliFast object and its Makers      //
+//                                                                      //
+//========================================================================
+//  An example of a User class is given below:                          //
+//========================================================================
+//
+//#ifndef user_H
+//#define user_H
+//
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// User                                                                 //
+//                                                                      //
+// Example of a user class to perform user specific tasks when running  //
+// the ALIfast program.                                                 //
+//                                                                      //
+// This class illustrates:                                              //
+//   - How to set run parameters                                        //
+//   - How to create and fill histograms                                //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+//
+//class TH1F;
+//class AliFast;
+//class AliFClusterMaker;
+//class AliFPhotonMaker;
+//
+//class User {
+//
+//private:
+//   TH1F             *fhist1;       //pointer to histogram
+//   TH1F             *fhist2;       //pointer to histogram
+//   TH1F             *fhist3;       //pointer to histogram
+//public:
+//               User();
+//   void        FillHistograms();
+//   void        SetRunParameters();
+//
+//#endif
+//};
+//
+//_________________________________________________________________________
+//User::User() 
+//{
+//   SetRunParameters();  //change default parameters
+//
+//         Create a few histograms
+//   fhist1 = new TH1F("hist1","Number of tracks per event",100,0,100);
+//   fhist2 = new TH1F("hist2","Number of clusters",100,0,100);
+//   fhist3 = new TH1F("hist3","Number of isolated muons",20,0,20);
+//}
+//
+//_________________________________________________________________________
+//void User::FillHistograms()
+//{
+////   fhist1.Fill(event->GetNtracks());
+////   fhist2.Fill(event->GetNclusters));
+////   fhist3.Fill(event->GetNIsoMuons());
+//}
+//
+//_________________________________________________________________________
+//void User::SetRunParameters()
+//{
+//  // change Alifast default parameters
+//
+//   gAliFast->SetSmearMuonOpt(0);
+//   gAliFast->ClusterMaker()->SetGranBarrelEta(0.12);
+//   gAliFast->PhotonMaker()->SetMinPT(6.);
+//   gAliFast->TriggerMaker()->SetMuoEtaCoverage(2.8);
+//
+//}
+//======================end of User class=================================
+//
+//////////////////////////////////////////////////////////////////////////
+
+#include <TROOT.h>
+#include <TChain.h>
+#include <TTree.h>
+#include <TBrowser.h>
+#include <TClonesArray.h>
+#include "AliRun.h"
+#include "AliFast.h"
+//#include "AliFMCMaker.h"
+#include "AliFTrackMaker.h"
+#include "AliFHistBrowser.h"
+#include "AliFBigBang.h"
+#include "AliFVirtualDisplay.h"
+
+
+R__EXTERN AliRun * gAlice;
+AliFast *gAliFast;
+
+ClassImp(AliFast)
+
+
+//_____________________________________________________________________________
+  //AliFast::AliFast() : TNamed("alifast","The ALICE fast simulation")
+  AliFast::AliFast() : AliRun("alifast","The ALICE fast simulation")
+{
+
+   fTree          = 0;
+   fMakers        = 0;
+   fMode          = 0;
+   //   fMCMaker       = 0;
+   fTrackMaker    = 0;
+   fDisplay       = 0;
+   fDet           = new AliFDet("Detector","Make AliFast detector");
+   gAliFast     = this;
+   gAlice       = (AliRun*)this;
+}
+
+//_____________________________________________________________________________
+//AliFast::AliFast(const char *name, const char *title): TNamed(name,title)
+AliFast::AliFast(const char *name, const char *title): AliRun(name,title)
+{
+
+   gAliFast      = this;
+   fVersion     = 001;       //AliFAST  version number and release date
+   fVersionDate = 150399;
+   fTree        = 0;
+   fMode        = 0;
+   fDisplay     = 0;
+   
+   SetDefaultParameters();
+
+   gROOT->GetListOfBrowsables()->Add(this,"AliFast");
+
+// create the support list for the various lists of AliFast objects
+   fMakers  = new TList();
+
+// create "standard" makers and add them to the list of makers (in AliFMaker constructor
+// Note that the order in which makers are added to the list of makers is important
+// makers will be processed in this order !!
+
+   //fMCMaker       = new AliFMCMaker("MCMaker","Make MC events");
+   fTrackMaker    = new AliFTrackMaker("TrackMaker","Make AliFast tracks");
+//create detector
+   fDet           = new AliFDet("Detector","Make AliFast detector");
+}
+
+//_____________________________________________________________________________
+AliFast::~AliFast()
+{
+//   fMakers->Delete();
+//   delete fMakers;
+}
+
+
+//______________________________________________________________________________
+void AliFast::Browse(TBrowser *b)
+{
+
+  if( b == 0) return;
+
+  if (fTree) b->Add(fTree,fTree->GetName());
+  // fca
+  b->Add(&fHistBrowser, "Histograms");
+  b->Add(&fBigBang, "BigBang");
+  // fca
+
+  TIter next(fMakers);
+  AliFMaker *maker;
+  while ((maker = (AliFMaker*)next())) {
+     b->Add(maker,maker->GetName());
+   }
+}
+
+//_____________________________________________________________________________
+void AliFast::Clear(Option_t *option)
+{
+//    Reset lists of event objects
+   TIter next(fMakers);
+   AliFMaker *maker;
+   while ((maker = (AliFMaker*)next())) {
+      maker->Clear(option);
+   }
+   //fca   if (fDisplay) fDisplay->Clear();
+}
+
+//_____________________________________________________________________________
+void AliFast::Draw(Option_t *option)
+{
+//    Insert current event in graphics pad list
+
+    // Check if the Event Display object has been created
+   if (!fDisplay) {
+      Error("Draw","You must create an AliFDisplay object first");
+      return;
+   }
+
+   //fca   fDisplay->Draw(option);
+}
+
+//_____________________________________________________________________________
+void  AliFast::GetTreeEvent(Int_t event)
+{
+//    Read event from Tree
+   if (fTree) fTree->GetEvent(event);
+   fEvent = event;  
+}
+
+//_____________________________________________________________________________
+void AliFast::Init()
+{
+//  Initialise detector
+   AliFDet *detector=gAliFast->Detector();  
+   detector->InitDetParam(); 
+
+//    Initialise makers
+   TIter next(fMakers);
+   AliFMaker *maker;
+   TObject *objfirst, *objlast;
+   while ((maker = (AliFMaker*)next())) {
+     // save last created histogram in current Root directory
+      objlast = gDirectory->GetList()->Last();
+
+     // Initialise maker
+      maker->Init();
+
+     // Add Maker histograms in Maker list of histograms
+      if (objlast) objfirst = gDirectory->GetList()->After(objlast);
+      else         objfirst = gDirectory->GetList()->First();
+      while (objfirst) {
+         maker->Histograms()->Add(objfirst);
+         objfirst = gDirectory->GetList()->After(objfirst);
+      }
+   }
+
+}
+
+//_____________________________________________________________________________
+void AliFast::Paint(Option_t *option)
+{
+//    Paint AliFast objects
+
+  //fca   fDisplay->Paint(option);
+}
+
+//_____________________________________________________________________________
+void AliFast::PrintInfo()
+{
+//     Gives information about versions etc.
+   printf("\n\n");
+   printf("**************************************************************\n");
+   printf("*             AliFast version:00%1d     last update  %6d    *\n",
+                                                       fVersion, fVersionDate);
+   printf("**************************************************************\n");
+   printf("*                                                            *\n");
+   printf("*     Simulates and reconstructs  events on particle level   *\n");
+   printf("*     Package by: Yiota Foka and Elzbieta Richter-Was        *\n");
+   printf("*           Design based on ATLFast++                        *\n");
+   printf("*         by R. Brun and E. Richter-Was                      *\n");
+   printf("**************************************************************\n");
+   printf("\n\n");
+
+//     Print info for detector geometry
+   AliFDet *detector=gAliFast->Detector();
+   detector->PrintDetInfo(); 
+
+//     Print info for all defined Makers
+   TIter next(fMakers);
+   AliFMaker *maker;
+   while ((maker = (AliFMaker*)next())) {
+      maker->PrintInfo();
+   }
+}
+
+//_____________________________________________________________________________
+void AliFast::FillTree()
+{
+//  Fill the ROOT tree, looping on all active branches
+
+  // Clean generated particles (depending on option Save)
+  //MCMaker()->CleanParticles();
+
+  // Now ready to fill the Root Tree
+   if(fTree) fTree->Fill();
+}
+
+//_____________________________________________________________________________
+void AliFast::InitChain(TChain *chain)
+{
+//  Initialize branch addresses for all makers in a TChain
+
+   if (chain == 0) return;
+
+   fTree = chain;
+
+   TIter next(fMakers);
+   AliFMaker *maker;
+   while ((maker = (AliFMaker*)next())) {
+      maker->SetChainAddress(chain);
+   }
+}
+
+//_____________________________________________________________________________
+void AliFast::MakeTree(const char* name, const char*title)
+{
+//  Create a ROOT tree
+//  Loop on all makers to create the Root branch (if any)
+
+   if (fTree) return;
+
+   fTree = new TTree(name,title);
+
+   TIter next(fMakers);
+   AliFMaker *maker;
+   while ((maker = (AliFMaker*)next())) {
+      maker->MakeBranch();
+   }
+}
+
+//_____________________________________________________________________________
+void AliFast::SetDefaultParameters()
+{
+
+//    Setters for flags and switches
+   SetLuminosity();
+   SetBfield();
+   SetSmearing();
+   SetSUSYcodeLSP();
+   SetTrackFinding();
+}
+
+//_____________________________________________________________________________
+void AliFast::Make(Int_t i)
+{
+   fEvent = i;
+
+//   Loop on all makers
+   TIter next(fMakers);
+   AliFMaker *maker;
+   while ((maker = (AliFMaker*)next())) {
+      maker->Make();
+   }
+
+}
+
+//_____________________________________________________________________________
+void AliFast::FillClone()
+{
+   // Fill Makers fruits clones
+   
+   TIter next(fMakers);
+   AliFMaker *maker;
+   while ((maker = (AliFMaker*)next())) {
+      maker->FillClone();
+   }
+}
+
+//_____________________________________________________________________________
+void AliFast::Finish()
+{
+//    Terminate a run
+//   place to make operations on histograms, normalization,etc.
+
+   TIter next(fMakers);
+   AliFMaker *maker;
+   while ((maker = (AliFMaker*)next())) {
+      maker->Finish();
+   }
+}
+
+//_____________________________________________________________________________
+void AliFast::SortDown(Int_t n1, Float_t *a, Int_t *index, Bool_t down)
+{
+//  sort the n1 elements of array a.
+//  In output the array index contains the indices of the sorted array.
+//  if down is false sort in increasing order (default is decreasing order)
+//   This is a translation of the CERNLIB routine sortzv (M101)
+//   based on the quicksort algorithm
+
+   Int_t i,i1,n,i2,i3,i33,i222,iswap,n2;
+   Int_t i22 = 0;
+   Float_t ai;
+   n = n1;
+   if (n <= 0) return;
+   if (n == 1) {index[0] = 0; return;}
+   for (i=0;i<n;i++) index[i] = i+1;
+   for (i1=2;i1<=n;i1++) {
+      i3 = i1;
+      i33 = index[i3-1];
+      ai  = a[i33-1];
+      while(1) {
+         i2 = i3/2;
+         if (i2 <= 0) break;
+         i22 = index[i2-1];
+         if (ai <= a[i22-1]) break;
+         index[i3-1] = i22;
+         i3 = i2;
+      }
+      index[i3-1] = i33;
+   }
+
+   while(1) {
+      i3 = index[n-1];
+      index[n-1] = index[0];
+      ai = a[i3-1];
+      n--;
+      if(n-1 < 0) {index[0] = i3; break;}
+      i1 = 1;
+      while(2) {
+         i2 = i1+i1;
+         if (i2 <= n) i22 = index[i2-1];
+         if (i2-n > 0) {index[i1-1] = i3; break;}
+         if (i2-n < 0) {
+            i222 = index[i2];
+            if (a[i22-1] - a[i222-1] < 0) {
+                i2++;
+                i22 = i222;
+            }
+         }
+         if (ai - a[i22-1] > 0) {index[i1-1] = i3; break;}
+         index[i1-1] = i22;
+         i1 = i2;
+      }
+   }
+   if (!down) return;
+   n2 = n1/2;
+   for (i=0;i<n1;i++) index[i]--;
+   for (i=0;i<n2;i++) {
+      iswap         = index[i];
+      index[i]      = index[n1-i-1];
+      index[n1-i-1] = iswap;
+   }
+}
+//______________________________________________________________________________
+void AliFast::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AliFast.
+
+   if (R__b.IsReading()) {
+      R__b.ReadVersion(); //  Version_t R__v = R__b.ReadVersion();
+      TNamed::Streamer(R__b);
+      if (!gAliFast) gAliFast = this;
+      gROOT->GetListOfBrowsables()->Add(this,"AliFast");
+      R__b >> fVersion;
+      R__b >> fVersionDate;
+      R__b >> fRun;
+      R__b >> fEvent;
+      R__b >> fMode;
+      fTree = (TTree*)gDirectory->Get("T");
+      R__b >> fMakers;
+      //      R__b >> fMCMaker;
+      R__b >> fTrackMaker;
+      R__b >> fLuminosity;
+      R__b >> fBfield;
+      R__b >> fSmearing;
+      R__b >> fSUSYcodeLSP;
+      R__b >> fTrackFinding;
+      // fca
+      fHistBrowser.Streamer(R__b);
+      // fca
+   } else {
+      R__b.WriteVersion(AliFast::IsA());
+      TNamed::Streamer(R__b);
+      R__b << fVersion;
+      R__b << fVersionDate;
+      R__b << fRun;
+      R__b << fEvent;
+      R__b << fMode;
+      fTree->Write();
+      R__b << fMakers;
+      //R__b << fMCMaker;
+      R__b << fTrackMaker;
+      R__b << fLuminosity;
+      R__b << fBfield;
+      R__b << fSmearing;
+      R__b << fSUSYcodeLSP;
+      R__b << fTrackFinding;
+      // fca
+      fHistBrowser.Streamer(R__b);
+      // fca
+   }
+}
+
+
+
+
+
diff --git a/ALIFAST/AliFast.h b/ALIFAST/AliFast.h
new file mode 100644 (file)
index 0000000..585cc2b
--- /dev/null
@@ -0,0 +1,147 @@
+#ifndef AliFast_H
+#define AliFast_H
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliFast                                                              //
+//                                                                      //
+// Main class to control the AliFast program.                           //
+//                                                                      //
+// This class :                                                         //
+//   - Initialises the run default parameters                           //
+//   - Provides API to Set/Get run parameters                           //
+//   - Creates the support lists (TClonesArrays) for the Event structure//
+//   - Creates the physics objects makers                               //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include "AliRun.h"
+//#ifndef ROOT_TTree
+#include <TTree.h>
+//#endif
+//#ifndef AliFHistBrowser_H
+#include "AliFHistBrowser.h"
+//#endif
+//#ifndef AliFBigBang_H
+#include "AliFBigBang.h"
+//#endif
+//#ifndef AliFMaker_H
+#include "AliFMaker.h"
+//#endif
+//#ifndef AliFDet_H
+//#include "AliFDet.h"
+//#endif
+
+class TBrowser;
+class TChain;
+class AliFMCMaker;
+class AliFTrackMaker;
+class AliFDet;
+class AliFVirtualDisplay;
+
+class AliFast : public AliRun {
+
+private:
+   Int_t               fVersion;           //AliFast version number
+   Int_t               fVersionDate;       //AliFast version date
+   Int_t               fMode;              //Run mode
+   Int_t               fTestTrack;         //Test mode for TrackMaker
+   TTree              *fTree;              //Pointer to the Root tree
+   TList              *fMakers;            //List of Makers
+//    pointers to standard Makers
+   AliFMCMaker        *fMCMaker;           //Pointer to MCMaker
+   AliFTrackMaker     *fTrackMaker;        //Pointer to TrackMaker
+   AliFDet            *fDet;               //Pointer to Detector
+//    flags and switches
+   Int_t               fLuminosity;        //Luminosity option (low=1, high=2)
+   Bool_t              fBfield;            //B-field (on=1,off=0)
+   Bool_t              fSmearing;          //Smearing on=1, off=0
+   Int_t               fSUSYcodeLSP;       //Code for SUSY LSP particle
+   Int_t               fTrackFinding;      //Track/finding on=1,off=0
+   AliFHistBrowser     fHistBrowser;       //Object to Browse Maker histograms
+   AliFBigBang         fBigBang;           //!Object to Browse generated particles
+   AliFVirtualDisplay *fDisplay;           //!Pointer to Event display object
+
+public:
+                      AliFast();
+                      AliFast(const char *name, const char *title="The ALIAS fast MonteCarlo");
+   virtual           ~AliFast();
+   virtual void       Browse(TBrowser *b);
+   virtual void       Draw(Option_t *option="");  // *MENU*
+   Int_t              GetVersion() {return fVersion;}
+   Int_t              GetVersionDate() {return fVersionDate;}
+   virtual void       Clear(Option_t *option="");
+   AliFVirtualDisplay *Display() {return fDisplay;}
+   virtual void       FillClone();
+   virtual void       Finish();
+   virtual void       GetTreeEvent(Int_t event);  // *MENU*
+   virtual void       Init();
+   Bool_t             IsFolder() {return kTRUE;}
+   virtual void       Make(Int_t i=0);
+   virtual void       Paint(Option_t *option="");
+   virtual void       PrintInfo();
+   virtual void       SetDefaultParameters();
+
+   TList             *Makers()    {return fMakers;}
+   AliFMaker         *Maker(const char *name) {return (AliFMaker*)fMakers->FindObject(name);}
+   AliFMCMaker       *MCMaker()       {return fMCMaker;}
+   AliFTrackMaker    *TrackMaker()    {return fTrackMaker;}
+   AliFDet           *Detector()    {return fDet;}
+   TTree             *Tree() {return fTree;}
+
+   Int_t             Run()   {return fRun;}
+   Int_t             Event() {return fEvent;}
+   Int_t             Mode()  {return fMode;}
+   Int_t             TestTrack()  {return fTestTrack;}
+
+//    Getters for flags and switches
+   Int_t             Luminosity()   {return fLuminosity;}
+   Bool_t            Bfield()       {return fBfield;}
+   Bool_t            Smearing()     {return fSmearing;} 
+   Int_t             SUSYcodeLSP()  {return fSUSYcodeLSP;}
+   Bool_t            TrackFinding() {return fTrackFinding;}
+
+
+//    Setter for Event Display
+   void           SetDisplay(AliFVirtualDisplay *display) {fDisplay=display;}
+//    Setters for flags and switches
+   void           SetLuminosity(Int_t lumi=1)   {fLuminosity=lumi;}
+   void           SetBfield(Bool_t field=1)     {fBfield=field;}
+   void           SetSmearing(Bool_t val=1)     {fSmearing=val;} 
+   void           SetSUSYcodeLSP(Int_t val=66)  {fSUSYcodeLSP=val;}
+   void           SetTrackFinding(Bool_t val=0) {fTrackFinding=val;}
+
+   virtual void   SetRun(Int_t run=1)     {fRun=run;}
+   virtual void   SetEvent(Int_t event=1) {fEvent=event;}
+   virtual void   SetMode(Int_t mode=0)   {fMode=mode;}
+   virtual void   SetTestTrack(Int_t test=0)   {fTestTrack=test;}
+
+   void           FillTree();
+   void           InitChain(TChain *chain);
+   void           MakeTree(const char* name="T", const char*title="AliFast tree");
+
+   void           SortDown(Int_t n, Float_t *a, Int_t *index, Bool_t down=kTRUE);
+
+   ClassDef(AliFast, 1)   //AliFast control class
+};
+
+R__EXTERN AliFast *gAliFast;
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ALIFAST/Makefile b/ALIFAST/Makefile
new file mode 100644 (file)
index 0000000..a55414e
--- /dev/null
@@ -0,0 +1,82 @@
+############################### ALIFAST Makefile ##################################
+
+# Include machine specific definitions
+
+include $(ALICE_ROOT)/conf/GeneralDef
+include $(ALICE_ROOT)/conf/MachineDef.$(ALICE_TARGET)
+
+PACKAGE = ALIFAST
+
+# C++ sources
+
+SRCS          = AliFast.cxx AliFMaker.cxx AliFDet.cxx AliFTrackMaker.cxx \
+               AliFTrack.cxx AliFHistBrowser.cxx AliFBigBang.cxx \
+               AliFBrowsable.cxx AliFVirtualDisplay.cxx
+
+# C++ Headers
+
+HDRS          = $(SRCS:.cxx=.h) ALIFASTLinkDef.h
+
+# Library dictionary
+
+DICT          = ALIFASTCint.cxx
+DICTH         = $(DICT:.cxx=.h)
+DICTO         = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(DICT))
+
+# FORTRAN Objectrs
+
+FOBJS         = $(FSRCS:.f=.o)
+
+# C Objects
+
+COBJS         = $(CSRCS:.c=.o)
+
+# C++ Objects
+
+OBJS          = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(SRCS)) $(DICTO)
+
+# C++ compilation flags
+
+CXXFLAGS      = $(CXXOPTS) -I$(ROOTSYS)/include -I. -I$(ALICE_ROOT)/include/
+# FORTRAN compilation flags
+
+FFLAGS      = $(FOPT)
+##### TARGETS #####
+# Target
+
+SLIBRARY       = $(LIBDIR)/libALIFAST.$(SL)
+
+default:       $(SLIBRARY)
+
+$(LIBDIR)/libALIFAST.$(SL):  $(OBJS)
+
+$(DICT):               $(HDRS)
+
+depend:                        $(SRCS)
+
+TOCLEAN                        = $(OBJS) *Cint.h *Cint.cxx
+
+############################### General Macros ################################
+
+include $(ALICE_ROOT)/conf/GeneralMacros
+
+############################ Dependencies #####################################
+
+-include tgt_$(ALICE_TARGET)/Make-depend 
+
+
+
+
+
+### Target check creates violation reports (.viol), which depend on
+### stripped files (.ii), which in turn depend on preprocessed
+### files (.i). Dependences are in conf/GeneralDef.
+
+CHECKS        = $(patsubst %.cxx,check/%.viol,$(SRCS))
+
+check:          $(CHECKS)
+
+
diff --git a/ALIFAST/alifast.C b/ALIFAST/alifast.C
new file mode 100644 (file)
index 0000000..8f07437
--- /dev/null
@@ -0,0 +1,18 @@
+void alifast()
+{
+
+  AliFast * fast =new AliFast("blabla","blabla");
+  gAliFast->Init("Config.C");
+
+  TFile file("alifast.root","recreate","ALIFast root file",2);
+  gAliFast.Init();
+  gAliFast.MakeTree();
+  gAliFast->Generator()->Generate();
+
+  gAliFast.Make(0);       // Generate and Reconstruct event
+  gAliFast.FillTree();    
+  gAliFast.Clear();       // Clear reconstructed event lists
+
+  gAliFast.Finish();
+  gAliFast.Write(); 
+}
diff --git a/ALIFAST/alifasttest.C b/ALIFAST/alifasttest.C
new file mode 100644 (file)
index 0000000..ec974c8
--- /dev/null
@@ -0,0 +1,19 @@
+void alifasttest()
+{
+
+  AliFast * fast =new AliFast("blabla","blabla");
+  gAliFast->Init("Config.C");
+
+  TFile file("alifasttest.root","recreate","ALIFast root file",2);
+  gAliFast.Init();
+  gAliFast.SetTestTrack(1);
+  gAliFast.MakeTree();
+  gAliFast->Generator()->Generate();
+
+  gAliFast.Make();       // Generate and Reconstruct event
+  gAliFast.FillTree();    
+  gAliFast.Clear();       // Clear reconstructed event lists
+
+  gAliFast.Finish();
+  gAliFast.Write(); 
+}
diff --git a/ALIFAST/user.C b/ALIFAST/user.C
new file mode 100644 (file)
index 0000000..7c39a7a
--- /dev/null
@@ -0,0 +1,9 @@
+{
+  // change AliFast default parameters
+
+   gAliFast->SetSmearing(1);
+   gAliFast->SetTrackFinding(1);
+   gAliFast->MCMaker()->Save(2);     //give 2 to save all particles
+   gAliFast->TrackMaker()->Save(1);  // give 1 to save tracks
+}
+