X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSsimulationSSD.h;h=b2ec98ff016ad21fe72949bc2d9f69a0f03c4d69;hb=c61a7285011faf50a1f39c6a49e0c3fdeeff6260;hp=359d0ca077caa797b6d3cd97e618fe36f544098c;hpb=b0f5e3fcf84ecedb50df35ebe629b44bafc15bc0;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSsimulationSSD.h b/ITS/AliITSsimulationSSD.h index 359d0ca077c..b2ec98ff016 100644 --- a/ITS/AliITSsimulationSSD.h +++ b/ITS/AliITSsimulationSSD.h @@ -1,68 +1,134 @@ #ifndef ALIITSSIMULATIONSSD_H #define ALIITSSIMULATIONSSD_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ -#include +/* $Id$ */ -#include "AliITSdcsSSD.h" -#include "AliITSsimulation.h" -#include "AliITSdictSSD.h" +///////////////////////////////////////////////////////////// +// Simulation class for SSD // +///////////////////////////////////////////////////////////// +#include "AliITSsimulation.h" +#include "AliITSsegmentationSSD.h" // function used in inline functions -class AliITSdictSSD; -class AliITSdcsSSD; +class AliITSMapA2; +class AliITSpList; +class AliITSTableSSD; +//class AliITSdcsSSD; +class AliITSsegmentationSSD; +class AliITSCalibrationSSD; class AliITSsimulationSSD: public AliITSsimulation { -public: + public: + AliITSsimulationSSD(); // Default constructor + AliITSsimulationSSD(const AliITSsimulationSSD &source); // copy constructor + // operator = + AliITSsimulationSSD& operator=(const AliITSsimulationSSD &source); + // virtual AliITSsimulation& operator=(const AliITSsimulation &source); + //Standard Constructor + AliITSsimulationSSD(AliITSDetTypeSim* dettyp); + //Destructor + virtual ~AliITSsimulationSSD(); + // Get a pointer to the segmentation object + virtual AliITSsegmentation* GetSegmentationModel(Int_t /*dt*/){return fDetType->GetSegmentationModel(2);} + // set pointer to segmentation objec + virtual void SetSegmentationModel(Int_t /*dt*/, AliITSsegmentation *seg){fDetType->SetSegmentationModel(2,seg);} + // Initilize variables for this simulation + void Init(); + // Initilize variables for this simulation + //void Init(AliITSsegmentationSSD *seg,AliITSCalibrationSSD *resp); + // Create maps to build the lists of tracks for each summable digit + void InitSimulationModule(Int_t module,Int_t events); + // Digitize module from the sum of summable digits. + void FinishSDigitiseModule(); + //Digitizes all of the hits in a module + void DigitiseModule(AliITSmodule *mod,Int_t dummy0,Int_t dummy1); + // Computes the Summable Digits + void SDigitiseModule(AliITSmodule *mod,Int_t module,Int_t dummy); + // Computes the Charge on each Strip/ Analog/summable digits + void HitsToAnalogDigits(AliITSmodule *mod,AliITSpList *pList); + //Computes the signal from one hit + void HitToDigit(Int_t module,Double_t x0,Double_t y0,Double_t z0, + Double_t x,Double_t y,Double_t z,Double_t de, + AliITSTableSSD *tav); + //returns a pointer to the SSD segmentation. + /*AliITSsegmentationSSD *GetSegmentation() { + return (AliITSsegmentationSSD*) fSegmentation;} + */ + //Returns the ionization energy for Si in GeV. + Double_t GetIonizeE() const {return fIonE;} + //Sets the ionization energy for Si in GeV. + void SetIonizeE(Double_t e=3.62E-09){fIonE = e;} + //Returns the Diffusion constant h in cm**2/sec + Double_t GetDiffConst(Int_t i) const {return fDifConst[i];} + //Sets the Diffusion constant h in cm**2/sec + void SetDiffConst(Double_t h=11.0,Double_t e=30.0) + {fDifConst[0] = h;fDifConst[1]=e;} + //Returns the Drift velocity for the side i + Double_t GetDriftVelocity(Int_t i) const {return fDriftVel[i];} + //Sets the Drift velocity for the P and N sides + void SetDriftVelocity(Double_t v0=0.86E+06,Double_t v1=2.28E+06) + {fDriftVel[0] = v0;fDriftVel[1] = v1;} + // Standard ascii class print function + void Print(ostream *os); + // Standard ascii class read function + void Read(istream *is); + virtual void Print(Option_t *option="") const {TObject::Print(option);} + virtual Int_t Read(const char *name) {return TObject::Read(name);} + // Data members + protected: - AliITSsimulationSSD() {} - AliITSsimulationSSD(AliITSsimulationSSD &source); // copy constructor - AliITSsimulationSSD& operator=(AliITSsimulationSSD &source); // operator = - AliITSsimulationSSD(AliITSsegmentation *seg, AliITSresponse *resp); - virtual ~AliITSsimulationSSD(); - - void DigitiseModule(AliITSmodule *mod, Int_t mod, Int_t dummy); - void HitToDigit(Int_t &hit,Int_t idtrack,Int_t nhits,TObjArray *hits); + // AliITSdcsSSD *fDCS; // Class containing detector controle paramters - TArrayF* GetSignalP() {return fP;} - TArrayF* GetSignalN() {return fN;} + private: + // Return the Response class + // AliITSCalibrationSSD* GetResp(){return (AliITSCalibrationSSD*)fResponse;} + // Return the Segmentation class + //AliITSsegmentationSSD* GetSeg(){ + // return (AliITSsegmentationSSD*)fSegmentation;} + // returns the number of steps needed to proplerly distribute the charge + // in a step + Int_t NumOfSteps(Double_t x,Double_t y,Double_t z, + Double_t &dex,Double_t &dey,Double_t &dez); + // Keepts track and orders tracks for a give strip. + void GetList(Int_t trk,Int_t ht,Int_t mod,AliITSpList *pLt, + AliITSTableSSD *tav); + // sets thresholds and fills digits + void ChargeToSignal(Int_t module,AliITSpList *pList); + // Writes Summable Digits to a root file for later use. + void WriteSDigits(AliITSpList *pList); + // ReadSDigits and create Digits + void SDigitToDigit(Int_t module,AliITSpList *pList); + // Fills fMapA2 from pList AliITSpList + void FillMapFrompList(AliITSpList *pList); + // Diffuses the charge onto neighboring strips. + void IntegrateGaussian(Int_t k,Double_t par,Double_t av,Double_t sigma, + Double_t inf, Double_t sup, + AliITSTableSSD *tav); + // Applies noise to strips randomly + void ApplyNoise(AliITSpList *pList,Int_t mod); + // Applies posible signal coupling between strips + void ApplyCoupling(AliITSpList *pList,Int_t mod); + // Kill dead channels + void ApplyDeadChannels(Int_t mod); + // Computes the integral of a gaussian using Error Function + Float_t F(Float_t av, Float_t x, Float_t s); + // returns, from the segmentation, the number of stips + Int_t GetNStrips() {AliITSsegmentationSSD* seg = (AliITSsegmentationSSD*)GetSegmentationModel(2);return seg->Npx();} + // returns, from the segmentation, the strip pitch + Float_t GetStripPitch() {AliITSsegmentationSSD* seg = (AliITSsegmentationSSD*)GetSegmentationModel(2);return seg->Dpx(0);} -protected: - - Int_t IntegrateGaussian(Double_t par, Double_t av, Double_t sigma, - Double_t inf, Double_t sup); - void NormalizeCharge(Int_t k, Double_t pair); - Int_t NumOfSteps(Double_t x, Double_t y, Double_t z, - Double_t &dex,Double_t &dey,Double_t &dez); - void ApplyNoise(); - void ApplyCoupling(); - void ApplyThreshold(); - void ApplyDAQ(); - - Float_t F(Float_t x, Float_t s); - Float_t Get2Strip(Int_t flag, Int_t istrip, Float_t x, Float_t z); - - // Data members - -protected: - - AliITSdcsSSD *fDCS; - Int_t fNstrips; - Float_t fPitch; - TArrayF *fN; // for signal N side - TArrayF *fP; // for signal P side - AliITSdictSSD *fTracksP; //! - AliITSdictSSD *fTracksN; //! - //______________________________________________________________ - // - // Parameters for simulation - //______________________________________________________________ - Int_t fSteps; //Number of steps - - ClassDef(AliITSsimulationSSD,1) - - - }; + AliITSMapA2 *fMapA2; //! Map of ionization, used localy only + Double_t fIonE; // ionization energy of Si in GeV + Double_t fDifConst[2]; // Diffusion constants [h,e] in cm**2/sec + Double_t fDriftVel[2]; // Drift velocities [P,N sides] cm/sec + ClassDef(AliITSsimulationSSD,2) // SSD signal simulation class +}; +// Input and output functions for standard C++ input/output. +ostream &operator<<(ostream &os,AliITSsimulationSSD &source); +istream &operator>>(istream &is,AliITSsimulationSSD &source); #endif