6 #include "AliITSsegmentationSSD.h"
7 #include "AliITSresponseSSD.h"
8 #include "AliITSsimulationSSD.h"
9 #include "AliITSdictSSD.h"
10 #include "AliITSdcsSSD.h"
12 #include "AliITShit.h"
13 #include "AliITSdigit.h"
14 #include "AliITSmodule.h"
18 ClassImp(AliITSsimulationSSD);
19 //------------------------------------------------------------
20 AliITSsimulationSSD::AliITSsimulationSSD(AliITSsegmentation *seg,
21 AliITSresponse *resp){
27 fDCS = new AliITSdcsSSD(seg,resp);
29 fNstrips = fSegmentation->Npx();
30 fPitch = fSegmentation->Dpx(0);
32 fP = new TArrayF(fNstrips+1);
33 fN = new TArrayF(fNstrips+1);
35 fTracksP = new AliITSdictSSD[fNstrips+1];
36 fTracksN = new AliITSdictSSD[fNstrips+1];
39 fSteps = 10; // still hard-wired - set in SetDetParam and get it via
40 // fDCS together with the others eventually
43 //___________________________________________________________________________
44 AliITSsimulationSSD& AliITSsimulationSSD::operator=(AliITSsimulationSSD
47 if(this==&source) return *this;
49 this->fDCS = new AliITSdcsSSD(*(source.fDCS));
50 this->fN = new TArrayF(*(source.fN));
51 this->fP = new TArrayF(*(source.fP));
52 this->fTracksP = new AliITSdictSSD(*(source.fTracksP));
53 this->fTracksN = new AliITSdictSSD(*(source.fTracksN));
54 this->fNstrips = source.fNstrips;
55 this->fPitch = source.fPitch;
56 this->fSteps = source.fSteps;
59 //_____________________________________________________________
60 AliITSsimulationSSD::AliITSsimulationSSD(AliITSsimulationSSD &source){
64 //____________________________________________________________________________
65 AliITSsimulationSSD::~AliITSsimulationSSD() {
72 if(fTracksP) delete [] fTracksP;
73 if(fTracksN) delete [] fTracksN;
78 //_______________________________________________________________
81 //_______________________________________________________________
83 void AliITSsimulationSSD::DigitiseModule(AliITSmodule *mod,Int_t module,
85 // Digitizes one SSD module of hits.
87 TObjArray *hits = mod->GetHits();
88 Int_t nhits = hits->GetEntriesFast();
91 //printf("simSSD: module nhits %d %d\n",module,nhits);
94 for(i=0; i<fNstrips; i++) {
97 fTracksP[i].ZeroTracks();
98 fTracksN[i].ZeroTracks();
101 //unsafe code but that's it for the moment
102 for(i=0; i<nhits; i++) {
103 HitToDigit(i,nhits,hits);
116 //---------------------------------------------------------------
118 void AliITSsimulationSSD::HitToDigit(Int_t & hitNo,
119 Int_t nhits,TObjArray *hits) {
120 // Turns one or more hits in an SSD module into one or more digits.
123 Float_t ionization = 0;
128 // check if this is the right order !!!!!
131 AliITShit *hitI = (AliITShit*)hits->At(hitNo++);
132 AliITShit *hitE = (AliITShit*)hits->At(hitNo);
134 while (!((hitE->StatusExiting()) ||
135 (hitE->StatusDisappeared()) ||
136 (hitE->StatusStop()))) {
138 ionization = hitE->GetIonization();
139 hitE = (AliITShit*)hits->At(hitNo);
144 if (hitI->GetTrack() == hitE->GetTrack())
145 track = hitI->GetTrack();
147 printf("!!! Emergency !!!\n");
150 ionization += hitE->GetIonization();
152 const Float_t kconvm=10000.; // cm -> microns
155 hitI->GetPositionL(xI, yI, zI);
162 hitE->GetPositionL(xE, yE, zE);
168 Float_t dx = (xE - xI);
169 Float_t dz = (zE - zI);
171 const Float_t kconv = 1.0e9 / 3.6; // GeV -> e-hole pairs
173 Float_t enStep = kconv*ionization/fSteps;
178 Float_t sigmaP, sigmaN;
179 fResponse->SigmaSpread(sigmaP,sigmaN);
181 Float_t noiseP, noiseN;
182 fResponse->GetNoiseParam(noiseP,noiseN);
186 Float_t dsP=0, dsN=0;
189 for(Int_t i=0; i<fSteps; i++) {
191 fSegmentation->GetPadIxz(xI,zI,stripP,stripN);
193 dsP = Get2Strip(1,stripP,xI, zI); // Between 0-1
194 dsN = Get2Strip(0,stripN,xI, zI); // Between 0-1
196 //sP = sigmaP * sqrt(300. * i / (fSteps));
197 //sN = sigmaN * sqrt(300. * i /(fSteps-i));
199 sP = sigmaP * sqrt(300. * (i+1) / (fSteps));
200 sN = sigmaN * sqrt(300. * (i+1) /(fSteps-i));
203 sP = (i<2 && dsP>0.3 && dsP<0.7)? 20. : sP; // square of (microns)
204 sN = (i>fSteps-2 && dsN>0.3 && dsN<0.7)? 20. : sN; // square of (microns)
206 sP = (i==2 && dsP>0.4 && dsP<0.6)? 15. : sP; // square of (microns)
207 sN = (i==8 && dsN>0.4 && dsN<0.6)? 15. : sN; // square of (microns)
209 for (j=-1; j<2; j++) {
210 if (stripP+j<0 || stripP+j>fNstrips) continue;
211 signal = enStep * TMath::Abs( (F(j+0.5-dsP,sP)-F(j-0.5-dsP,sP)) );
212 if (signal > noiseP/fSteps) {
213 (*fP)[stripP+j] += signal;
214 dict = (fTracksP+stripP+j);
215 (*dict).AddTrack(track);
217 } // end for j loop over neighboring strips
219 for (j=-1; j<2; j++) {
220 if (stripN+j<0 || stripN+j>fNstrips) continue;
221 signal = enStep * TMath::Abs( (F(j+0.5-dsN,sN)-F(j-0.5-dsN,sN)) );
222 if (signal > noiseN/fSteps) {
223 (*fN)[stripN+j] += signal;
224 dict = (fTracksN+stripN+j); //co to jest
225 (*dict).AddTrack(track);
227 } // end for j loop over neighboring strips
237 //____________________________________________________________________
239 // Private Methods for Simulation
240 //______________________________________________________________________
243 void AliITSsimulationSSD::ApplyNoise() {
245 Float_t noiseP, noiseN;
246 fResponse->GetNoiseParam(noiseP,noiseN);
249 for(i = 0; i<fNstrips; i++) {
250 (*fP)[i] += gRandom->Gaus(0,noiseP);
251 (*fN)[i] += gRandom->Gaus(0,noiseN);
255 //_________________________________________________________________________
257 void AliITSsimulationSSD::ApplyCoupling() {
258 // Apply the effecto of electronic coupling between channels
260 for(i = 1; i<fNstrips-1; i++) {
261 (*fP)[i] += (*fP)[i-1]*fDCS->GetCouplingPL() + (*fP)[i+1]*fDCS->GetCouplingPR();
262 (*fN)[i] += (*fN)[i-1]*fDCS->GetCouplingNL() + (*fN)[i+1]*fDCS->GetCouplingNR();
266 //__________________________________________________________________________
268 void AliITSsimulationSSD::ApplyThreshold() {
269 // Applies the effect of a threshold on the signals for digitization.
270 Float_t noiseP, noiseN;
271 fResponse->GetNoiseParam(noiseP,noiseN);
273 // or introduce the SetThresholds in fResponse
276 for(i=0; i<fNstrips; i++) {
277 (*fP)[i] = ((*fP)[i] > noiseP*4) ? (*fP)[i] : 0;
278 (*fN)[i] = ((*fN)[i] > noiseN*4) ? (*fN)[i] : 0;
283 //__________________________________________________________________________
285 void AliITSsimulationSSD::ApplyDAQ() {
286 // Converts simulated signals to simulated ADC counts
287 AliITS *its=(AliITS*)gAlice->GetModule("ITS");
289 Float_t noiseP, noiseN;
290 fResponse->GetNoiseParam(noiseP,noiseN);
292 char opt[30],dummy[20];
293 fResponse->ParamOptions(opt,dummy);
296 if (strstr(opt,"SetInvalid")) {
297 printf("invalid option %s\n",opt);
298 // Set signal = 0 if invalid strip
299 for(i=0; i<fNstrips; i++) {
300 if (!(fDCS->IsValidP(i))) (*fP)[i] = 0;
301 if (!(fDCS->IsValidN(i))) (*fN)[i] = 0;
305 Int_t digits[3], tracks[3], hits[3];
308 for(i=0;i<3;i++) tracks[i]=-3;
309 for(i=0; i<fNstrips; i++) {
310 if( (strstr(opt,"SetInvalid") && (*fP)[i] < noiseP*4) || !(*fP)[i]) continue;
313 digits[2]=(int)(*fP)[i];
314 for(j=0; j<(fTracksP+i)->GetNTracks(); j++) {
316 if((fTracksP+i)->GetNTracks()) tracks[j]=(fTracksP+i)->GetTrack(j);
318 //printf("P side: i,j,tracks[j] %d %d %d\n",i,j,tracks[j]);
322 its->AddSimDigit(2,phys,digits,tracks,hits,charges);
324 //cout << (fTracksP+i)->GetNTracks();
326 //if ((fTracksP+i)->GetNTracks() == 0) {
327 // cout << d.fCoord2 << " " << d.fSignal << "\n";
332 for(i=0; i<fNstrips; i++) {
333 if( (strstr(opt,"SetInvalid") && (*fN)[i] < noiseN*4)|| !(*fN)[i]) continue;
336 digits[2]=(int)(*fN)[i];
337 for( j=0; j<(fTracksN+i)->GetNTracks(); j++) {
339 if((fTracksN+i)->GetNTracks()) tracks[j]=(fTracksN+i)->GetTrack(j);
341 //printf("N side: i,j,tracks[j] %d %d %d\n",i,j,tracks[j]);
345 its->AddSimDigit(2,phys,digits,tracks,hits,charges);
347 //cout << (fTracksN+i)->GetNTracks();
348 //if ((fTracksN+i)->GetNTracks() == 0) {
349 // cout << d.fCoord2 << " " << d.fSignal << "\n";
356 //____________________________________________________________________________
358 Float_t AliITSsimulationSSD::F(Float_t x, Float_t s) {
359 // Computes the integral of a gaussian at the mean valuse x with sigma s.
360 //printf("SDD:F(%e,%e)\n",x,s);
363 if(s) fval=0.5*TMath::Erf(x * fPitch / s) ;
365 Error("SSD simulation: F","sigma is zero!!!",s);
370 //______________________________________________________________________
372 Float_t AliITSsimulationSSD::Get2Strip(Int_t flag, Int_t iStrip, Float_t x, Float_t z){
373 // Returns the relative space between two strips.
375 // flag==1 for Pside, 0 for Nside
377 Float_t stereoP, stereoN;
378 fSegmentation->Angles(stereoP,stereoN);
380 Float_t tanP=TMath::Tan(stereoP);
381 Float_t tanN=TMath::Tan(stereoN);
383 Float_t dx = fSegmentation->Dx();
384 Float_t dz = fSegmentation->Dz();
390 if (flag) return (x - z*tanP) / fPitch - iStrip; // from 0 to 1
391 else return (x - tanN*(dz - z)) / fPitch - iStrip;
393 //____________________________________________________________________________