1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
17 #include <TObjArray.h>
19 #include "AliITSsegmentationSSD.h"
20 #include "AliITSresponseSSD.h"
21 #include "AliITSsimulationSSD.h"
22 #include "AliITSdictSSD.h"
23 #include "AliITSdcsSSD.h"
28 ClassImp(AliITSsimulationSSD);
29 //------------------------------------------------------------
30 AliITSsimulationSSD::AliITSsimulationSSD(AliITSsegmentation *seg,
31 AliITSresponse *resp){
36 fDCS = new AliITSdcsSSD(seg,resp);
38 fNstrips = fSegmentation->Npx();
39 fPitch = fSegmentation->Dpx(0);
41 fP = new TArrayF(fNstrips);
42 fN = new TArrayF(fNstrips);
44 fTracksP = new AliITSdictSSD[fNstrips];
45 fTracksN = new AliITSdictSSD[fNstrips];
47 fSteps = 10; // still hard-wired - set in SetDetParam and get it via
48 // fDCS together with the others eventually
51 //printf("SSD ctor: fNstrips fPitch %d %f\n",fNstrips, fPitch);
53 //___________________________________________________________________________
54 AliITSsimulationSSD& AliITSsimulationSSD::operator=(AliITSsimulationSSD
57 if(this==&source) return *this;
59 this->fDCS = new AliITSdcsSSD(*(source.fDCS));
60 this->fN = new TArrayF(*(source.fN));
61 this->fP = new TArrayF(*(source.fP));
62 this->fTracksP = new AliITSdictSSD(*(source.fTracksP));
63 this->fTracksN = new AliITSdictSSD(*(source.fTracksN));
64 this->fNstrips = source.fNstrips;
65 this->fPitch = source.fPitch;
66 this->fSteps = source.fSteps;
69 //_____________________________________________________________
70 AliITSsimulationSSD::AliITSsimulationSSD(AliITSsimulationSSD &source){
74 //____________________________________________________________________________
75 AliITSsimulationSSD::~AliITSsimulationSSD() {
81 if(fTracksP) delete fTracksP;
82 if(fTracksN) delete fTracksN;
86 //_______________________________________________________________
89 //_______________________________________________________________
91 void AliITSsimulationSSD::DigitiseModule(AliITSmodule *mod,Int_t module,
93 // Digitizes one SSD module of hits.
95 TObjArray *hits = mod->GetHits();
96 Int_t nhits = hits->GetEntriesFast();
97 //printf("SSD: nhits %d\n",nhits);
101 for(i=0; i<fNstrips; i++) {
104 fTracksP[i].ZeroTracks();
105 fTracksN[i].ZeroTracks();
108 for(i=0; i<nhits; i++) {
109 Int_t idtrack=mod->GetHitTrackIndex(i);
110 HitToDigit(i,idtrack,nhits,hits);
122 //---------------------------------------------------------------
124 void AliITSsimulationSSD::HitToDigit(Int_t & hitNo,Int_t idtrack,
125 Int_t nhits,TObjArray *hits) {
126 // Turns one or more hits in an SSD module into one or more digits.
128 Int_t stripP, stripN, i;
136 Float_t ionization = 0;
142 // check if this is the right order !!!!!
144 AliITShit *hitI = (AliITShit*)hits->At(hitNo++);
145 AliITShit *hitE = (AliITShit*)hits->At(hitNo);
148 while (!((hitE->StatusExiting()) ||
149 (hitE->StatusDisappeared()) ||
150 (hitE->StatusStop()))) {
153 ionization = hitE->GetIonization();
154 hitE = (AliITShit*)hits->At(hitNo);
159 if (hitI->GetTrack() == hitE->GetTrack())
161 track = hitI->GetTrack();
163 printf("!!! Emergency !!!\n");
166 ionization += hitE->GetIonization();
168 const Float_t kconvm=10000.; // cm -> microns
171 hitI->GetPositionL(xI, yI, zI);
173 //Float_t zI = hitI->GetZL();
180 hitE->GetPositionL(xE, yE, zE);
182 //Float_t zE = hitE->GetZL();
188 Float_t dx = (xE - xI);
189 Float_t dz = (zE - zI);
194 fSegmentation->GetCellIxz(xI,zI,stripP,stripN);
196 printf("%5d %8.3f %8.3f %8.3f %8.3f %d %d %d\n",
197 hitNo, xI, zI, dx, dz,
198 stripP, stripN, track);
199 printf("%10.5f %10d \n", ionization, hitI->fTrack);
209 for(i=0; i<fSteps; i++) {
211 // arrayEP[i] = gRandom->Landau(ionization/fSteps, ionization/(4*fSteps));
212 // arrayEN[i] = gRandom->Landau(ionization/fSteps, ionization/(4*fSteps));
213 arrayEP[i] = ionization/fSteps;
214 arrayEN[i] = ionization/fSteps;
220 const Float_t kconv = 1.0e9 / 3.6; // GeV -> e-hole pairs
222 for(i=0; i<fSteps; i++) {
224 arrayEP[i] = kconv * arrayEP[i] * (ionization / eP);
225 arrayEN[i] = kconv * arrayEN[i] * (ionization / eN);
231 Float_t sigmaP, sigmaN;
232 fResponse->SigmaSpread(sigmaP,sigmaN);
234 //printf("SigmaP SigmaN %f %f\n",sigmaP, sigmaN);
236 Float_t noiseP, noiseN;
237 fResponse->GetNoiseParam(noiseP,noiseN);
239 //printf("NoiseP NoiseN %f %f\n",noiseP, noiseN);
241 for(i=0; i<fSteps; i++) {
245 fSegmentation->GetCellIxz(xI,zI,stripP,stripN);
246 //printf("i xI zI stripP stripN %d %f %f %d %d\n",i,xI, zI, stripP, stripN);
247 dsP = Get2Strip(1,stripP,xI, zI); // Between 0-1
248 dsN = Get2Strip(0,stripN,xI, zI); // Between 0-1
250 sP = sigmaP * sqrt(300. * i / (fSteps));
251 sN = sigmaN * sqrt(300. * i /(fSteps-i));
254 sP = (i<2 && dsP>0.3 && dsP<0.7)? 20. : sP; // square of (microns)
255 sN = (i>fSteps-2 && dsN>0.3 && dsN<0.7)? 20. : sN; // square of (microns)
257 sP = (i==2 && dsP>0.4 && dsP<0.6)? 15. : sP; // square of (microns)
258 sN = (i==8 && dsN>0.4 && dsN<0.6)? 15. : sN; // square of (microns)
261 //printf("i=%d SigmaP SigmaN sP sN %f %f %e %e\n",i,sigmaP, sigmaN,sP,sN);
263 for(j=-1; j<2; j++) {
265 if (stripP+j<0 || stripP+j>fNstrips) continue;
267 signal = arrayEP[i] * TMath::Abs( (F(j+0.5-dsP,sP)-F(j-0.5-dsP,sP)) );
268 //printf("SimSSD::HitsToDigits:%d arrayEP[%d]=%e signal=%e\n",j,i,arrayEP[i],signal);
269 if (signal > noiseP/fSteps) {
270 (*fP)[stripP+j] += signal;
271 dict = (fTracksP+stripP+j);
272 (*dict).AddTrack(track);
274 } // end for j loop over neighboring strips
275 for(j=-1; j<2; j++) {
277 if (stripN+j<0 || stripN+j>fNstrips) continue;
279 signal = arrayEN[i] * TMath::Abs( (F(j+0.5-dsN,sN)-F(j-0.5-dsN,sN)) );
280 //printf("SimSSD::HitsToDigits:%d arrayEN[%d]=%e signal=%e\n",j,i,arrayEN[i],signal);
281 if (signal > noiseN/fSteps) {
282 (*fN)[stripN+j] += signal;
283 dict = (fTracksN+stripN+j); //co to jest
284 (*dict).AddTrack(track);
286 } // end for j loop over neighboring strips
296 //____________________________________________________________________
298 // Private Methods for Simulation
299 //______________________________________________________________________
302 void AliITSsimulationSSD::ApplyNoise() {
304 Float_t noiseP, noiseN;
305 fResponse->GetNoiseParam(noiseP,noiseN);
308 for(i = 0; i<fNstrips; i++) {
309 (*fP)[i] += gRandom->Gaus(0,noiseP);
310 (*fN)[i] += gRandom->Gaus(0,noiseN);
314 //_________________________________________________________________________
316 void AliITSsimulationSSD::ApplyCoupling() {
317 // Apply the effecto of electronic coupling between channels
320 for(i = 1; i<fNstrips-1; i++) {
321 (*fP)[i] += (*fP)[i-1]*fDCS->GetCouplingPL() + (*fP)[i+1]*fDCS->GetCouplingPR();
322 (*fN)[i] += (*fN)[i-1]*fDCS->GetCouplingNL() + (*fN)[i+1]*fDCS->GetCouplingNR();
326 //__________________________________________________________________________
328 void AliITSsimulationSSD::ApplyThreshold() {
329 // Applies the effect of a threshold on the signals for digitization.
330 Float_t noiseP, noiseN;
331 fResponse->GetNoiseParam(noiseP,noiseN);
333 // or introduce the SetThresholds in fResponse
336 for(i=0; i<fNstrips; i++) {
337 (*fP)[i] = ((*fP)[i] > noiseP*4) ? (*fP)[i] : 0;
338 (*fN)[i] = ((*fN)[i] > noiseN*4) ? (*fN)[i] : 0;
339 //printf("SSD:(*fP)[i] (*fN)[i] %f %f \n",(*fP)[i], (*fN)[i]);
344 //__________________________________________________________________________
346 void AliITSsimulationSSD::ApplyDAQ() {
347 // Converts simulated signals to simulated ADC counts
348 AliITS *its=(AliITS*)gAlice->GetModule("ITS");
350 Float_t noiseP, noiseN;
351 fResponse->GetNoiseParam(noiseP,noiseN);
353 // Set signal = 0 if invalid strip
355 for(i=0; i<fNstrips; i++) {
356 if (!(fDCS->IsValidP(i))) (*fP)[i] = 0;
357 if (!(fDCS->IsValidN(i))) (*fN)[i] = 0;
360 Int_t digits[3], tracks[3];
363 for(i=0; i<fNstrips; i++) {
364 if ((*fP)[i] < noiseP*4) continue;
367 digits[2]=(int)(*fP)[i];
368 for(j=0; j<(fTracksP+i)->GetNTracks(); j++) {
370 tracks[j] = (fTracksP+i)->GetTrack(j);
373 its->AddDigit(2,phys,digits,tracks,charges);
375 //cout << (fTracksP+i)->GetNTracks();
377 //if ((fTracksP+i)->GetNTracks() == 0) {
378 // cout << d.fCoord2 << " " << d.fSignal << "\n";
383 for(i=0; i<fNstrips; i++) {
384 if ((*fN)[i] < noiseN*4) continue;
387 digits[2]=(int)(*fN)[i];
388 for(j=0; j<(fTracksN+i)->GetNTracks(); j++) {
390 tracks[j] = (fTracksN+i)->GetTrack(j);
393 its->AddDigit(2,phys,digits,tracks,charges);
395 //cout << (fTracksN+i)->GetNTracks();
396 //if ((fTracksN+i)->GetNTracks() == 0) {
397 // cout << d.fCoord2 << " " << d.fSignal << "\n";
404 //____________________________________________________________________________
406 Float_t AliITSsimulationSSD::F(Float_t x, Float_t s) {
407 // Computes the integral of a gaussian at the mean valuse x with sigma s.
408 //printf("SDD:F(%e,%e)\n",x,s);
409 return 0.5*TMath::Erf(x * fPitch / s) ;
412 //______________________________________________________________________
414 Float_t AliITSsimulationSSD::Get2Strip(Int_t flag, Int_t iStrip, Float_t x, Float_t z){
415 // Returns the relative space between two strips.
417 // flag==1 for Pside, 0 for Nside
419 Float_t stereoP, stereoN;
420 fSegmentation->Angles(stereoP,stereoN);
422 Float_t tanP=TMath::Tan(stereoP);
423 Float_t tanN=TMath::Tan(stereoN);
425 Float_t dx = fSegmentation->Dx();
426 Float_t dz = fSegmentation->Dz();
432 if (flag) return (x - z*tanP) / fPitch - iStrip; // from 0 to 1
433 else return (x - tanN*(dz - z)) / fPitch - iStrip;
435 //____________________________________________________________________________