+++ /dev/null
-#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
+++ /dev/null
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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;
-}
-
-
-
-
-
-
-
+++ /dev/null
-#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() const {return kTRUE;}
-
- ClassDef(AliFBigBang, 0) //helper class to browse generated particles.
-};
-
-#endif
-
-
-
-
-
-
-
-
-
+++ /dev/null
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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()
-{
- fRefObject = 0;
- fBigBang = 0;
-}
-
-//_____________________________________________________________________________
-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);
- }
- */
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-#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() const {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
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-////////////////////////////////////////////////////////////////////////////
-// //
-// 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)
-{
- //
- // Standard constructor
- //
- 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,")");
-
-}
+++ /dev/null
-#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 {
-
-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) const {return fRDet[idDet];}
- Double_t RDetSQ(Int_t idDet) const {return fRDetSQ[idDet];}
- Double_t ThickDet(Int_t idDet) const {return fThickDet[idDet];}
- Double_t ErrorRPhi(Int_t idDet) const {return fErrorRPhi[idDet];}
- Double_t ErrorZ(Int_t idDet) const {return fErrorZ[idDet];}
- Double_t ErrorR(Int_t idDet) const {return fErrorR[idDet];}
- Int_t IFlagDet(Int_t idDet) const {return fIFlagDet[idDet];}
- Int_t IFlagGas(Int_t idDet) const {return fIFlagGas[idDet];}
- Double_t ErrorVertexX() const {return fErrorVertexX;}
- Double_t ErrorVertexY() const {return fErrorVertexY;}
- Double_t ErrorVertexZ() const {return fErrorVertexZ;}
- Double_t BMag() const {return fBMag;}
- Double_t ConstMag() const {return fConstMag;}
- Int_t NDetActive() const {return fNDetActive;}
- Int_t NDet() const {return fNDet;}
-
-
-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; // Constant Magnetic Field flag
- Int_t fNDetActive; // n. of active detector layers
- Int_t fNDet; // n. of detectors layers
-
-
- ClassDef(AliFDet,1) //AliFast Detector intialisation for AliFTrackMaker
-};
-
-#endif
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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()
-{
- fCanvas = 0;
- fTrigPad = 0;
- fButtons = 0;
- fPad = 0;
- fTubin = 0;
- fTubout = 0;
- fNodin = 0;
- fFruits = 0;
- fParticle = 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();
-}
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-#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
-
-
-
-
-
-
-
+++ /dev/null
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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);
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-#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() {
- fFruit=0;
- }
- 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
+++ /dev/null
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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());
- }
-
-}
+++ /dev/null
-#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() const {return kTRUE;}
-
- ClassDef(AliFHistBrowser, 0) //helper class to browse AliFast Makers histograms
-};
-
-#endif
+++ /dev/null
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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()) {
- UInt_t R__s, R__c;
- Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
-
- AliFMaker::Class()->ReadBuffer(R__b, this, R__v, R__s, R__c);
- //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 {
- AliFMaker::Class()->WriteBuffer(R__b,this);
- }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-#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() const {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
-
-
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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();
- }
-}
-
-
-
-
-
-
-
-
+++ /dev/null
-#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() {
- fParticles = 0;
- fDisplay = 0;
- fMCParticle = 0;
- fLine = 0;
- }
- 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
+++ /dev/null
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// AliFast Track class //
-// //
-//////////////////////////////////////////////////////////////////////////
-
-#include "AliFTrack.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)
-{
- //
- // Class constructor
- //
- 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 *)
-{
-
-}
-
+++ /dev/null
-#ifndef AliFTrack_H
-#define AliFTrack_H
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// AliFast track class //
-// //
-//////////////////////////////////////////////////////////////////////////
-
-#include <TObject.h>
-
-class AliFTrack : public TObject {
-
-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() const {return fIdTrack;}
- Double_t ChTrack() const {return fChTrack;}
- Double_t PT() const {return fPT;}
- Double_t Eta() const {return fEta;}
- Double_t Phi() const {return fPhi;}
- Double_t V11() const {return fV11;}
- Double_t V22() const {return fV22;}
- Double_t V33() const {return fV33;}
- Double_t V12() const {return fV12;}
- Double_t V13() const {return fV13;}
- Double_t V23() const {return fV23;}
- Int_t IFlag() const {return fIFlag;}
-
-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; //Element of the covariance matrix
- Double_t fV22; //Element of the covariance matrix
- Double_t fV33; //Element of the covariance matrix
- Double_t fV12; //Element of the covariance matrix
- Double_t fV13; //Element of the covariance matrix
- Double_t fV23; //Element of the covariance matrix
- Int_t fIFlag; //Status flag
-
-
- ClassDef(AliFTrack, 1) //AliFast track class
-};
-
-#endif
+++ /dev/null
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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 <TFile.h>
-#include <TH1.h>
-#include <TMath.h>
-#include <TParticle.h>
-#include <TRandom.h>
-
-#include "AliFDet.h"
-#include "AliFTrack.h"
-#include "AliFTrackMaker.h"
-#include "AliFast.h"
-#include "AliMC.h"
-
-static const Double_t kPi = TMath::Pi();
-static const Double_t k2Pi = 2*kPi;
-static const Double_t kPiHalf = kPi/2.;
-extern AliFast * gAliFast;
-ClassImp(AliFTrackMaker)
-
-//_____________________________________________________________________________
-AliFTrackMaker::AliFTrackMaker()
-{
- //
- // Default constructor
- //
- fNTracks = 0;
- fResID1Test = 0;
- fResID2Test = 0;
- fResID3Test = 0;
- fResID4Test = 0;
- fResID5Test = 0;
-}
-
-//_____________________________________________________________________________
-AliFTrackMaker::AliFTrackMaker(const char *name, const char *title)
- :AliFMaker(name,title)
-{
- //
- // Standard Setters for tracks
- //
- fFruits = new TClonesArray("AliFTrack",100, kFALSE);
- fBranchName = "Tracks";
- fNTracks = 0;
-// Please, how to do this optionally ??!!!
- Save();
-}
-
-//_______________________________________________________________________
-AliFTrackMaker::AliFTrackMaker(const AliFTrackMaker& aftmk):
- AliFMaker(aftmk)
-{
- //
- // Copy constructor for AliRun
- //
- aftmk.Copy(*this);
-}
-
-//_____________________________________________________________________________
-AliFTrackMaker::~AliFTrackMaker()
-{
- //
- // Dummy constructor
- //
-}
-
-//_____________________________________________________________________________
-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();
-
-}
-
-void AliFTrackMaker::Make()
-{
- //
- // Calculate track and its resolution
- //
- 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
-
- Int_t idPart, idTrack;
- Double_t charge, pT, eta, phi;
- TParticle *part;
- Int_t nparticles = gAlice->GetMCApp()->GetNtrack();
- printf("%10s%10d\n","nparticles",nparticles);
- for(Int_t ind=0;ind<nparticles;ind++) {
- part = gAlice->GetMCApp()->Particle(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::Copy(TObject &) const
-{
- Fatal("Copy","Not implemented!\n");
-}
-
-//_____________________________________________________________________________
-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);
-
-
-}
-
-//-----------------------------------------------------------------------------
-Double_t AliFTrackMaker::ParticleMass(Int_t idTrack) const
-{
- //
- // returns the mass given particle ID
- //
- 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;
-
-}
-
-//____________________________________________________________________________
-Double_t AliFTrackMaker::Rapidity(Double_t pt, Double_t pz)
-{
- //
- // returns the rapidity given particle pT, 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;
-}
-
-//_____________________________________________________________________________
-void AliFTrackMaker::MakeTest(Int_t n)
-{
- //
- // TEST JOB: Calculate tracks resolution
- //
- 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=0;
- // 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]);
- }
- }
-}
-//_____________________________________________________________________________
+++ /dev/null
-#ifndef AliFTrackMaker_H
-#define AliFTrackMaker_H
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// AliFast TrackMaker class. //
-// //
-// //
-//////////////////////////////////////////////////////////////////////////
-
-class TH1D;
-
-#include "AliFDet.h"
-#include "AliFMaker.h"
-
-class AliFTrack;
-
-class AliFTrackMaker : public AliFMaker {
-public:
- AliFTrackMaker();
- AliFTrackMaker(const char *name, const char *title);
- AliFTrackMaker(const AliFTrackMaker &aftmk);
-
- AliFTrackMaker& operator = (const AliFTrackMaker &aftmk)
- {aftmk.Copy(*this); return (*this);}
-
- 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) const;
- 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) const {return fHH[id1][id2];}
- Double_t HHI(Int_t id1, Int_t id2) const {return fHHI[id1][id2];}
- Double_t SigmaRPhiSQ() const {return fSigmaRPhiSQ;}
- Double_t SigmaZSQ() const {return fSigmaZSQ;}
- Int_t NTracks() const {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;}
-
-protected:
- void Copy(TObject &aftmk) const;
-
- Int_t fNTracks; // Number of tracks
- Int_t fRecTrack; // Tracks reconstruction on/off
- //masses
- Double_t fPionMass; // Mass of pion
- Double_t fKaonMass; // Mass of kaon
- Double_t fElectronMass; // Mass of electron
- Double_t fProtonMass; // Mass of proton
- //matrices
- Double_t fHH[kNMaxDet2][kNMaxDet2]; // Matrix
- Double_t fHHI[kNMaxDet2][kNMaxDet2]; // Matrix
- //TPC resolution
- Double_t fSigmaRPhiSQ; // Sigma R-PHI
- Double_t fSigmaZSQ; // Sigma Z^2
- // 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
-
- //
- ClassDef(AliFTrackMaker, 1) //AliFast TrackMaker
-};
-
-#endif
-
-
-
-
-
-
-
-
+++ /dev/null
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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
-{
-
-}
+++ /dev/null
-#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
+++ /dev/null
-
-//////////////////////////////////////////////////////////////////////////
-// //
-// 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=================================
-//
-//////////////////////////////////////////////////////////////////////////
-
-//class TChain;
-
-#include <TBrowser.h>
-#include <TChain.h>
-#include <TROOT.h>
-#include <TTree.h>
-
-#include "AliFast.h"
-#include "AliFTrackMaker.h"
-
-
-R__EXTERN AliRun * gAlice;
-
-AliFast *gAliFast;
-
-ClassImp(AliFast)
-
-
-//_____________________________________________________________________________
-AliFast::AliFast():
- AliRun("alifast","The ALICE fast simulation"),
- fVersion(0),
- fVersionDate(0),
- fMode(0),
- fTestTrack(0),
- fTree(0),
- fMakers(0),
- fMCMaker(0),
- fTrackMaker(0),
- fDet(new AliFDet("Detector","Make AliFast detector")),
- fLuminosity(0),
- fBfield(0),
- fSmearing(0),
- fSUSYcodeLSP(0),
- fTrackFinding(0),
- fFDisplay(0)
-{
- //
- // Default constructor
- //
-
- gAliFast = this;
- gAlice = (AliRun*)this;
-}
-
-//_____________________________________________________________________________
-AliFast::AliFast(const char *name, const char *title):
- AliRun(name,title),
- fVersion(1), //AliFAST version number and release date
- fVersionDate(150399),
- fMode(0),
- fTestTrack(0),
- fTree(0),
- fMakers(new TList()), // support list for the lists of AliFast objects
- fMCMaker(0),
- fTrackMaker(new AliFTrackMaker("TrackMaker","Make AliFast tracks")),
- fDet(new AliFDet("Detector","Make AliFast detector")), // create detectors
- fLuminosity(0),
- fBfield(0),
- fSmearing(0),
- fSUSYcodeLSP(0),
- fTrackFinding(0),
- fFDisplay(0)
-{
- //
- // Standard constructor
- //
-
- gAliFast = this;
-
- SetDefaultParameters();
-
- gROOT->GetListOfBrowsables()->Add(this,"AliFast");
-
- // 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");
-
-}
-
-//_______________________________________________________________________
-AliFast::AliFast(const AliFast& afast):
- AliRun(afast),
- fVersion(0),
- fVersionDate(0),
- fMode(0),
- fTestTrack(0),
- fTree(0),
- fMakers(0),
- fMCMaker(0),
- fTrackMaker(0),
- fDet(0),
- fLuminosity(0),
- fBfield(0),
- fSmearing(0),
- fSUSYcodeLSP(0),
- fTrackFinding(0),
- fFDisplay(0)
-{
- //
- // Copy constructor for AliRun
- //
- afast.Copy(*this);
-}
-
-//_____________________________________________________________________________
-AliFast::~AliFast()
-{
- //
- // Destructor
- //
-// fMakers->Delete();
-// delete fMakers;
-}
-
-
-//______________________________________________________________________________
-void AliFast::Browse(TBrowser *b)
-{
- //
- // To allow browsing of the class
- //
-
- 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);
- }
-}
-
-//_____________________________________________________________________________
-void AliFast::Draw(Option_t */*option*/)
-{
- //
- // Insert current event in graphics pad list
- // Check if the Event Display object has been created
- //
- if (!fFDisplay) {
- Error("Draw","You must create an AliFDisplay object first");
- return;
- }
-}
-
-//_____________________________________________________________________________
-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
- //
-}
-
-//_____________________________________________________________________________
-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)
-{
- //
- // Main maker method
- //
- 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) const
-{
-// 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()) {
- UInt_t R__s, R__c;
- if (!gAliFast) gAliFast = this;
- gROOT->GetListOfBrowsables()->Add(this,"AliFast");
-
- Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
-
- AliFast::Class()->ReadBuffer(R__b, this, R__v, R__s, R__c);
-
- fTree = (TTree*)gDirectory->Get("T");
- } else {
- AliFast::Class()->WriteBuffer(R__b,this);
- }
-}
-
-
-
-
-
+++ /dev/null
-#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 "AliFBigBang.h"
-#include "AliFHistBrowser.h"
-#include "AliRun.h"
-
-class TBrowser;
-class TChain;
-class TTree;
-
-class AliFDet;
-class AliFMCMaker;
-class AliFMaker;
-class AliFTrackMaker;
-class AliFVirtualDisplay;
-
-class AliFast : public AliRun {
-
-public:
- AliFast();
- AliFast(const AliFast &afast);
- AliFast(const char *name, const char *title="The ALIAS fast MonteCarlo");
- virtual ~AliFast();
- AliFast& operator = (const AliFast &afast)
- {afast.Copy(*this); return (*this);}
-
- virtual void Browse(TBrowser *b);
- virtual void Draw(Option_t *option=""); // *MENU*
- Int_t GetVersion() const {return fVersion;}
- Int_t GetVersionDate() const {return fVersionDate;}
- virtual void Clear(Option_t *option="");
- AliFVirtualDisplay *FDisplay() {return fFDisplay;}
- virtual void FillClone();
- virtual void Finish();
- virtual void GetTreeEvent(Int_t event); // *MENU*
- virtual void Init(const char * setup)
- {AliRun::Init(setup);}
- virtual void Init();
- Bool_t IsFolder() const {return kTRUE;}
- virtual void Make(Int_t i=0);
- virtual void Paint(Option_t *option="");
- virtual void PrintInfo();
- virtual void SetDefaultParameters();
-
- TList *Makers() const {return fMakers;}
- AliFMaker *Maker(const char *name) const {return (AliFMaker*)fMakers->FindObject(name);}
- AliFMCMaker *MCMaker() const {return fMCMaker;}
- AliFTrackMaker *TrackMaker() const {return fTrackMaker;}
- AliFDet *Detector() const {return fDet;}
- TTree *Tree() const {return fTree;}
-
- void Run(Int_t nevent, const char * setup)
- {AliRun::Run(nevent,setup);}
- Int_t Run() const {return fRun;}
- Int_t Event() const {return fEvent;}
- Int_t Mode() const {return fMode;}
- Int_t TestTrack() const {return fTestTrack;}
-
-// Getters for flags and switches
- Int_t Luminosity() const {return fLuminosity;}
- Bool_t Bfield() const {return fBfield;}
- Bool_t Smearing() const {return fSmearing;}
- Int_t SUSYcodeLSP() const {return fSUSYcodeLSP;}
- Bool_t TrackFinding() const {return fTrackFinding;}
-
-
-// Setter for Event Display
- void SetDisplay(AliDisplay *display)
- {fFDisplay=(AliFVirtualDisplay*)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) const;
-
-private:
-
- void Copy(TObject &afast) const;
-
- 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 *fFDisplay; //!Pointer to Event display object
-
- ClassDef(AliFast, 1) //AliFast control class
-};
-
-R__EXTERN AliFast *gAliFast;
-
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-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();
-}
+++ /dev/null
-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();
-}
+++ /dev/null
-SRCS= AliFast.cxx AliFMaker.cxx AliFDet.cxx AliFTrackMaker.cxx \
- AliFTrack.cxx AliFHistBrowser.cxx AliFBigBang.cxx \
- AliFBrowsable.cxx AliFVirtualDisplay.cxx
-
-
-HDRS= $(SRCS:.cxx=.h)
-
-DHDR:=ALIFASTLinkDef.h
+++ /dev/null
-void user() {
- // 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
-}
-
endif
ALIROOTMODULES := STEER PHOS TRD TPC ZDC MUON PMD FMD TOF ITS \
- CRT RICH START STRUCT EVGEN RALICE ALIFAST VZERO \
+ CRT RICH START STRUCT EVGEN RALICE VZERO \
THijing MEVSIM TMEVSIM THbtp HBTP EMCAL HBTAN \
THerwig TEPEMGEN EPEMGEN FASTSIM TPHIC RAW MONITOR DISPLAY ANALYSIS \
JETAN HLT LHC EVE
CXXFLAGSNO = $(NOOPT) -W -Wall -fPIC -pipe
else
ifeq ($(CCMAJORV),3)
-CXXFLAGS = $(OPT) -W -Wall -Werror -Woverloaded-virtual -fPIC -pipe -fmessage-length=0 -Wno-long-long -pedantic-errors -ansi -Dlinux
-CXXFLAGSNO = $(NOOPT) -W -Wall -Werror -fPIC -pipe -fmessage-length=0 -Wno-long-long -pedantic-errors -ansi
+CXXFLAGS = $(OPT) -W -Wall -Weffc++ -Woverloaded-virtual -fPIC -pipe -fmessage-length=0 -Wno-long-long -pedantic-errors -ansi -Dlinux
+CXXFLAGSNO = $(NOOPT) -W -Wall -Weffc++ -fPIC -pipe -fmessage-length=0 -Wno-long-long -pedantic-errors -ansi
else
CXXFLAGS = $(OPT) -W -Wall -Woverloaded-virtual -fPIC -pipe -fmessage-length=0 -Wno-long-long -ansi -Dlinux
-CXXFLAGSNO = $(NOOPT) -W -Wall -Werror -fPIC -pipe -fmessage-length=0 -Wno-long-long -ansi
+CXXFLAGSNO = $(NOOPT) -W -Wall -Weffc++ -fPIC -pipe -fmessage-length=0 -Wno-long-long -ansi
endif
endif
-CFLAGS = $(OPT) -Wall -Werror -fPIC -pipe -Wno-long-long -pedantic-errors -ansi
+CFLAGS = $(OPT) -Wall -Weffc++ -fPIC -pipe -Wno-long-long -pedantic-errors -ansi
FFLAGS = $(CLIBFOPT) $(FOPT) -fno-second-underscore
# rmkdepend flags for building dependencies of FORTRAN files
DEPENDFFLAGS = $(FFLAGS)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff