Changing once more (hopefully we get it correct this time...) the logic to trig the...
[u/mrichter/AliRoot.git] / ITS / AliITSsimulationSDD.h
1 #ifndef ALIITSSIMULATIONSDD_H
2 #define ALIITSSIMULATIONSDD_H
3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4  * See cxx source for full Copyright notice     */
5
6
7 /* $Id$ */
8
9 ////////////////////////////////////////////////////////////
10 // Simulation class for SDD                               //
11 ////////////////////////////////////////////////////////////
12
13 #include <TNtuple.h>
14 #include "AliITSsimulation.h"
15
16 class TH1F;
17 class TFile;
18 class TArrayI;
19 class TArrayF;
20 class AliITS;
21 class AliITSpList;
22 class AliITSMap;
23 class AliITSMapA1;
24 class AliITSMapA2;
25 class AliITSetfSDD;
26 class AliITSsegmentationSDD;
27 class AliITSCalibration;
28 class AliITSCalibrationSDD;
29
30 class AliITSsimulationSDD : public AliITSsimulation {
31   public:
32     AliITSsimulationSDD(); // default constructor
33     //Standard Constructor
34     AliITSsimulationSDD(AliITSDetTypeSim* dettyp);
35     // Copy operator
36     AliITSsimulationSDD(const AliITSsimulationSDD &source);
37     virtual ~AliITSsimulationSDD(); // Destructor
38     // = operator
39     AliITSsimulationSDD& operator=(const AliITSsimulationSDD &source);
40     //    virtual AliITSsimulation& operator=(const AliITSsimulation &source);
41     // Initilize variables for this simulation
42     void Init();
43
44     // Get a pointer to the segmentation object
45     virtual AliITSsegmentation* GetSegmentationModel(Int_t /*dt*/){return fDetType->GetSegmentationModel(1);}
46     // set pointer to segmentation object
47     virtual void SetSegmentationModel(Int_t /*dt*/, AliITSsegmentation *seg){fDetType->SetSegmentationModel(1,seg);}
48
49     // set the scale size factor for the smples in FFT
50     virtual void SetScaleFourier(Int_t scale=4) {fScaleSize=scale;}
51     Int_t ScaleFourier() const {return fScaleSize;} // returns the scale factor
52     // set perpendicular tracks flag
53     virtual void SetPerpendTracksFlag(Bool_t flag=kFALSE) {fFlag=flag;}
54     // returns perpendicular track flag.
55     Bool_t PerpendTracksFlag() const {return fFlag;} 
56     // set crosstalk flag
57     virtual void SetCrosstalkFlag(Bool_t flag=kFALSE) {fCrosstalkFlag=flag;}
58     // return crosstalk flag
59     Bool_t CrosstalkFlag() const {return fCrosstalkFlag;}
60     void FastFourierTransform(Double_t *real, Double_t *imag, Int_t direction);
61     virtual Int_t Convert10to8(Int_t signal) const;//10 to 8 bit SDD compresion
62     virtual Int_t Convert8to10(Int_t signal) const;//8 to 10 bit decompresion
63     virtual void Compress2D(); // Applies 2D compresion algorithm
64     virtual void StoreAllDigits(); // if No compresion run this.
65     // returns baseline and noise for a given anode i.
66     //virtual void GetAnodeBaseline(Int_t i,Double_t &baseline,Double_t &noise) const;
67     // local implementation of ITS->AddDigit. Specific for SDD
68     virtual void AddDigit(Int_t i, Int_t j, Int_t signalc, Int_t signale);
69
70     // add baseline, noise, gain, electronics and ADC saturation effects
71     void ChargeToSignal(Int_t mod,Bool_t bAddNoise=kFALSE, Bool_t bAddGain=kTRUE);
72     // add crosstalk effect
73     void ApplyCrosstalk(Int_t mod);
74     
75     // create maps to build the lists of tracks for each summable digit
76     void InitSimulationModule( Int_t module, Int_t event );
77     // clear maps
78     void ClearMaps();
79     // Summable Digitses a SDD module
80     void SDigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev);
81     // Add Summable digits to module maps.
82     Bool_t AddSDigitsToModule( TClonesArray *pItemArray, Int_t mask );
83     // digitize module from the sum of summable digits.
84     void FinishSDigitiseModule();
85     // Writes summable digits
86     void WriteSDigits();
87     // Introduces electronics effects and does zero-suppresion if required
88     void FinishDigits();
89     // Digitses a SDD module
90     void DigitiseModule(AliITSmodule *mod,Int_t md,Int_t ev);
91     // Spread charge in a SDD module
92     void HitsToAnalogDigits(AliITSmodule *mod);
93     // Sorts tracks for the 3 most highly contributed one to be added to digit.
94     //void SortTracks(Int_t *tracks,Float_t *charges,Int_t *hits
95     //                Int_t ntracks);
96     // collects and returns the fired SDD cells (uses AliITSMapA2...).
97     //void ListOfFiredCells(Int_t *arg,Double_t timeAmplitude,TObjArray *list,
98     //            TClonesArray *padr);
99
100     // Creates histograms of maps for debugging
101     void CreateHistograms(Int_t scale);
102     // Fills histograms of maps for debugging
103     void FillHistograms();
104     // Resets histograms of maps for debugging
105     void ResetHistograms();
106     // Get the pointer to the array of histograms
107     TObjArray*  GetHistArray() {return fHis;}
108     void WriteToFile(TFile *fp);// Writes the histograms to a file
109     // Get's histogram of a particular anode.
110     TH1F *GetAnode(Int_t wing, Int_t anode);
111
112     // sets DoFFT value.
113     void SetDoFFT(Int_t doFFT=1) {fDoFFT=doFFT;}
114
115     // Print SSD simulation Parameters
116     virtual void PrintStatus() const;
117
118   private:
119     // virtual void GetBaseline(Int_t mod);  // read baseline values from a file
120     // Variables and pointers for local use only. Not Streamed out.
121     AliITS         *fITS;          //! local pointer to ITS
122     AliITSMapA2    *fHitMap2;      //! local pointer to map of signals
123     AliITSMapA2    *fHitSigMap2;   //! local pointer to map of signals
124     AliITSMapA2    *fHitNoiMap2;   //! local pointer to map of signals
125     AliITSetfSDD   *fElectronics;  //! local pointer to electronics simulation
126     Double_t       *fInZR;         //! [fScaleSize*fMaxNofSamples] input of the
127                                    // real part of FFT
128     Double_t       *fInZI;         //! [fScaleSize*fMaxNofSamples] 
129                                    // input of the imaginary part of FFT
130     Double_t       *fOutZR;        //! [fScaleSize*fMaxNofSamples] 
131                                    // output of the real part of FFT
132     Double_t       *fOutZI;        //! [fScaleSize*fMaxNofSamples] 
133                                    // output of the imaginary part of FFT
134     Bool_t         *fAnodeFire;     //! [#of anodes] Flag if there is a signal
135
136     TObjArray *fHis;          // just in case for histogramming
137     Bool_t     fFlag;         // Flag used to simulate perpendicular tracks
138     Bool_t     fCrosstalkFlag; // Flag used to apply the crosstalk effect
139     Int_t      fDoFFT;        // Flag used to switch off electronics when 0
140     Int_t      fNofMaps;      // Number of anodes used ( 1-2*nanodes per wing )
141     Int_t      fMaxNofSamples;// Number of time samples
142     Int_t      fScaleSize;    // scale size factor for the samples in FFT
143
144     ClassDef(AliITSsimulationSDD,3)  // Simulation of SDD clusters
145
146 };
147 #endif