THbtp/AliGenHBTprocessor.h

   1 // Implementation of the interface for THBTprocessor
   2 // which is a wrapper itself to Fortran
   3 // program "HBT processor" written by Lanny Ray
   4 // Author: Piotr Krzysztof Skowronski <Piotr.Skowronski@cern.ch>
   5 //
   6 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   7  * See cxx source for full Copyright notice                               */
   8
   9 /* $Id$ */
  10
  11 #ifndef ALIGENHBTPROCESSOR_H
  12 #define ALIGENHBTPROCESSOR_H
  13
  14 #include "AliGenerator.h"
  15 #include "TPDGCode.h"
  16
  17 class THBTprocessor;
  18 class TClonesArray;
  19 class TParticle;
  20
  21 enum {kHBTPMaxParticleTypes = 50};
  22
  23 class AliGenHBTprocessor : public AliGenerator
  24 {
  25 //Wrapper class for THBTProcessor
  26 //which is a wrapper itself to Fortran
  27 //program "HBT processor" written by Lanny Ray
  28 //
  29 //Piotr.Skowronski@cern.ch
  30
  31   public:
  32     AliGenHBTprocessor();
  33     virtual ~AliGenHBTprocessor();
  34
  35     virtual void Init();
  36     virtual void Generate();
  37     virtual void GetParticles(TClonesArray * particles) const;
  38     Int_t        IdFromPDG(Int_t pdg) const;
  39     Int_t        PDGFromId(Int_t id) const;
  40
  41     Int_t        GetHbtPStatusCode(Int_t part) const;
  42     void         SetHbtPStatusCode(Int_t hbtstatcode, Int_t part);
  43 /************* S E T T E R S ******************/
  44
  45     virtual void SetTrackRejectionFactor(Float_t trf = 1.0);
  46
  47     virtual void SetRefControl(Int_t rc =2);
  48     virtual void SetPIDs(Int_t pid1 = kPiPlus,Int_t pid2 = kPiMinus); //PDG Codes of particles to be processed, default \\Pi^{+} and \\Pi^{-}
  49     virtual void SetNPIDtypes(Int_t npidt = 2); //Number ofparticle types to be processed
  50     virtual void SetDeltap(Float_t deltp = 0.1); //maximum range for random momentum shifts in GeV/c;
  51                                                  //px,py,pz independent; Default = 0.1 GeV/c.
  52     virtual void SetMaxIterations(Int_t maxiter = 50);//
  53     virtual void SetDelChi(Float_t dc = 0.1);
  54     virtual void SetIRand(Int_t irnd = 76564) ;
  55
  56     virtual void SetLambda(Float_t lam = 0.6);
  57     virtual void SetR1d(Float_t r = 7.0) ;
  58     virtual void SetRSide(Float_t rs = 6.0);
  59     virtual void SetROut(Float_t ro = 7.0) ;
  60     virtual void SetRLong(Float_t rl = 4.0) ;
  61     virtual void SetRPerp(Float_t rp = 6.0);
  62     virtual void SetRParallel(Float_t rprl = 4.0);
  63     virtual void SetR0(Float_t r0 = 4.0) ;
  64     virtual void SetQ0(Float_t q0 = 9.0) ;
  65     virtual void SetSwitch1D(Int_t s1d = 3);
  66     virtual void SetSwitch3D(Int_t s3d = 0) ;
  67     virtual void SetSwitchType(Int_t st = 3);
  68     virtual void SetSwitchCoherence(Int_t sc = 0);
  69     virtual void SetSwitchCoulomb(Int_t scol = 2);
  70     virtual void SetSwitchFermiBose(Int_t sfb = 1);
  71
  72     virtual void SetMomentumRange(Float_t pmin=0, Float_t pmax=0); //Dummy method
  73     virtual void SetPtRange(Float_t ptmin = 0.1, Float_t ptmax = 0.98);
  74     virtual void SetPxRange(Float_t pxmin = -1.0, Float_t pxmax = 1.0);
  75     virtual void SetPyRange(Float_t pymin = -1.0, Float_t pymax = 1.0);
  76     virtual void SetPzRange(Float_t pzmin = -3.6, Float_t pzmax = 3.6);
  77
  78     virtual void SetPhiRange(Float_t phimin = -180.0, Float_t phimax = 180.0);//Phi angle
  79     virtual void SetEtaRange(Float_t etamin = -1.5, Float_t etamax = 1.5);//Pseudorapidity
  80     void SetThetaRange(Float_t thetamin = 0, Float_t thetamax = 180); //Azimuthal angle, override AliGenerator method
  81                                                                       //which uses this, core fortran HBTProcessor uses Eta (pseudorapidity)
  82                                                                       //so these methods has to be synchronized
  83
  84     virtual void SetNPtBins(Int_t nptbin = 50);
  85     virtual void SetNPhiBins(Int_t nphibin = 50);
  86     virtual void SetNEtaBins(Int_t netabin = 50);
  87     virtual void SetNPxBins(Int_t npxbin = 20);
  88     virtual void SetNPyBins(Int_t npybin = 20);
  89     virtual void SetNPzBins(Int_t npzbin = 70);
  90
  91
  92     virtual void SetNBins1DFineMesh(Int_t n = 10);
  93     virtual void SetBinSize1DFineMesh(Float_t x=0.01);
  94
  95     virtual void SetNBins1DCoarseMesh(Int_t n =2 );
  96     virtual void SetBinSize1DCoarseMesh(Float_t x=0.05);
  97
  98     virtual void SetNBins3DFineMesh(Int_t n = 8);
  99     virtual void SetBinSize3DFineMesh(Float_t x=0.01);
 100
 101     virtual void SetNBins3DCoarseMesh(Int_t n = 2);
 102     virtual void SetBinSize3DCoarseMesh(Float_t x=0.08);
 103
 104     virtual void SetNBins3DFineProjectMesh(Int_t n =3 );
 105
 106     virtual void SetPrintFull(Int_t flag = 1);
 107
 108 /************* E V E N T   M E R G E ******************/
 109
 110     Int_t        GetNumberOfEvents();
 111     Int_t        GetNumberOfTracks();
 112     void         SetActiveEventNumber(Int_t n);
 113     TParticle*   GetTrack(Int_t n);
 114     void         SetNEventsToMerge(Int_t nev);
 115
 116
 117     //conveerts Eta (pseudorapidity) to etha(azimuthal angle). Returns radians
 118     static Double_t EtaToTheta(Double_t arg){return 2.*TMath::ATan(TMath::Exp(-arg));}
 119     //converts tetha(azimuthal angle) to Eta (pseudorapidity). Argument in radians
 120     static Double_t ThetaToEta(Double_t arg);
 121     //converts Degrees To Radians
 122     static Double_t DegreesToRadians(Double_t arg){return arg*TMath::Pi()/180.;}
 123     //converts Radians To Degrees
 124     static Double_t RadiansToDegrees(Double_t arg){return arg*180./TMath::Pi();}
 125
 126     static Int_t  GetDebug() {return fgDebug;}
 127 //    static Int_t  GetDebug() {return fgDebug;}
 128
 129 /***********************************************************************/
 130 /* * * * * * *    P R O T E C T E D   A R E A    * * * * * * * * * * * */
 131 /***********************************************************************/
 132   protected:
 133
 134     THBTprocessor * fHBTprocessor;       //pointer to generator (TGenerator)
 135     Int_t         **fHbtPStatCodes;      //! hbtp status codes of particles
 136     Int_t           fNPDGCodes;          //! Number of defined particles
 137     Int_t           fPDGCode[kHBTPMaxParticleTypes]; //! PDG codes (for conversion PDG<->Geant)
 138     void            DefineParticles();   //initiates array with PDG codes
 139     void            InitStatusCodes();   //Initiates status codes (allocates memory and sets everything to zero)
 140     void            CleanStatusCodes();   //deletes array with status codes
 141     /**********   P A R A M E T E R S  OF THE GENERATOR****************/
 142
 143     Float_t fTrackRejectionFactor; //variates in range 0.0 <-> 1.0
 144                                    //Describes the factor of particles rejected from the output.
 145                                    //Used only in case of low muliplicity particles e.g. lambdas.
 146                                    //Processor generates addisional particles and builds the
 147                                    //correletions on such a statistics.
 148                                    //At the end these particels are left in the event according
 149                                    //to this factor: 1==all particles are left
 150                                    //                0==all are removed
 151       Int_t fReferenceControl;     //switch wether read reference histograms from file =1
 152                                    //              compute from input events =2 - default
 153       Int_t fPrintFull;             // Full print out option - each event
 154       Int_t fPrintSectorData;       // Print sector overflow diagnostics
 155       Int_t fNPidTypes;             // # particle ID types to correlate
 156       Int_t fPid[2];                // Geant particle ID #s, max of 2 types
 157       Int_t fNevents ;              // # events in input event text file
 158       Int_t fSwitch1d;              // Include 1D correlations
 159       Int_t fSwitch3d;              // Include 3D correlations
 160       Int_t fSwitchType ;           // For like, unlike or both PID pairs
 161       Int_t fSwitchCoherence;       // To include incoh/coher mixed source
 162       Int_t fSwitchCoulomb;         // Coulomb correction selection options
 163       Int_t fSwitchFermiBose;      // For fermions or bosons
 164
 165 //   Counters:
 166
 167       Int_t fEventLineCounter;     // Input event text file line counter
 168       Int_t fMaxit;                  // Max # iterations in track adjustment
 169       Int_t fIrand;                  // Random # starting seed (Def=12345)
 170 //                                    //    line counter
 171
 172 //   Correlation Model Parameters:
 173
 174       Float_t    fLambda;               // Chaoticity parameter
 175       Float_t    fR1d;                   // Spherical source radius (fm)
 176       Float_t    fRside;                  // 3D Bertsch-Pratt source 'side' R (fm)
 177       Float_t    fRout;                   // 3D Bertsch-Pratt source 'out'  R (fm)
 178       Float_t    fRlong;                  // 3D Bertsch-Pratt source 'long' R (fm)
 179       Float_t    fRperp;                  // 3D YKP source transverse radius  (fm)
 180       Float_t    fRparallel;              // 3D YKP source longitudinal radius(fm)
 181       Float_t    fR0;                     // 3D YKP source emission time durat(fm)
 182       Float_t    fQ0;                     // NA35 Coulomb parameter (GeV/c) or
 183 //                                    // Coul radius for Pratt finite src (fm)
 184
 185 //   Search Control Parameters:
 186
 187
 188       Float_t    fDeltap;                 // Max limit for x,y,z momt shifts(GeV/c)
 189       Float_t    fDelchi;                 // Min% change in Chi-Sq to stop iterat.
 190
 191
 192 //   Particle Masses:
 193
 194
 195   /**********   M E S H  ****************/
 196
 197
 198       Int_t fNPtBins;                  // # one-body pt bins
 199       Int_t fNPhiBins;                 // # one-body phi bins
 200       Int_t fNEtaBins;                 // # one-body eta bins
 201
 202       Int_t fN1dFine;                  // # bins for 1D, Fine Mesh
 203       Int_t fN1dCoarse;                // # bins for 1D, Coarse Mesh
 204       Int_t fN1dTotal;                 // Total # bins for 1D
 205       Int_t fN3dFine ;                 // # bins for 3D, Fine Mesh
 206       Int_t fN3dCoarse;                // # bins for 3D, Coarse Mesh
 207       Int_t fN3dTotal;                 // Total # bins for 3D
 208       Int_t fN3dFineProject;          // # 3D fine mesh bins to sum over for
 209
 210 //   Momentum Space Sectors for Track Sorting:
 211
 212       Int_t fNPxBins;                  // # sector bins in px
 213       Int_t fNPyBins;                  // # sector bins in py
 214       Int_t fNPzBins;                  // # sector bins in pz
 215       Int_t fNSectors;                  // Total # sectors in 3D momentum space
 216
 217
 218       Float_t    fPtBinSize ;          // One-body pt bin size in (GeV/c)
 219
 220
 221       Float_t    fPhiBinSize;          // One-body phi bin size in (degrees)
 222
 223       Float_t    fEtaBinSize ;         // One-body eta bin size
 224       Float_t    fEtaMin;              // One-body eta min
 225       Float_t    fEtaMax;              // One-body eta max
 226 //   Two-Body Histograms and Correlation Mesh for 1D and 3D distributions:
 227 //                                       // projections onto single axis.
 228
 229       Float_t    fBinsize1dFine;       // Bin Size - 1D, Fine Mesh in (GeV/c)
 230       Float_t    fBinsize1dCoarse;     // Bin Size - 1D, Coarse Mesh in (GeV/c)
 231       Float_t    fQmid1d;               // q (GeV/c) at fine-coarse mesh boundary
 232       Float_t    fQmax1d;               // Max q (GeV/c) for 1D distributions
 233       Float_t    fBinsize3dFine;       // Bin Size - 3D, Fine Mesh in (GeV/c)
 234       Float_t    fBinsize3dCoarse;     // Bin Size - 3D, Coarse Mesh in (GeV/c)
 235       Float_t    fQmid3d;               // q (GeV/c) at fine-coarse mesh boundary
 236       Float_t    fQmax3d;               // Max q (GeV/c) for 3D distributions
 237
 238       Float_t    fPxMin;                // Sector range in px in GeV/c
 239       Float_t    fPxMax;                //--//--
 240       Float_t    fDelpx;                 // Mom. space sector cell size - px(GeV/c)
 241
 242       Float_t    fPyMin;                // Sector range in py in GeV/c
 243       Float_t    fPyMax;                // --//--
 244       Float_t    fDelpy;                 // Mom. space sector cell size - py(GeV/c)
 245
 246       Float_t    fPzMin;                // Sector range in pz in GeV/c min
 247       Float_t    fPzMax;                // Sector range in pz in GeV/c max
 248       Float_t    fDelpz;                 // Mom. space sector cell size - pz(GeV/c)
 249
 250
 251       Int_t fEventMerge;                //number of events that are masked as an one event
 252       Int_t fActiveStack;               //current active stack
 253
 254       static Int_t    fgDebug;          //debug level
 255
 256       /******* P R O T E C T E D   M E T H O D S  *****/
 257       void GetTrackEventIndex(Int_t n, Int_t &evno, Int_t &index) const; //returns event(stack) number and
 258
 259  private:
 260       AliGenHBTprocessor(const AliGenHBTprocessor& in);
 261       AliGenHBTprocessor & operator=(const AliGenHBTprocessor& in);
 262
 263     ClassDef(AliGenHBTprocessor,1) // Interface class for AliMevsim
 264
 265 };
 266 #endif