ITS UPGRADE
[u/mrichter/AliRoot.git] / ITS / UPGRADE / ITSUpgradeSim / AliITSUSimulationPix.cxx
1
2 /**************************************************************************
3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4  *                                                                        *
5  * Author: The ALICE Off-line Project.                                    *
6  * Contributors are mentioned in the code where appropriate.              *
7  *                                                                        *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          *
14  * provided "as is" without express or implied warranty.                  *
15  **************************************************************************/
16
17 #include <TGeoGlobalMagField.h>
18 #include <TH1.h>
19 #include <TH2.h>
20 #include <TString.h>
21 #include "AliITSU.h"
22 #include "AliITSUDigitPix.h"
23 #include "AliITSUHit.h"
24 #include "AliITSUChip.h"
25 #include "AliITSUSensMap.h"
26 #include "AliITSUCalibrationPix.h"
27 #include "AliITSUSegmentationPix.h"
28 #include "AliITSUSimulationPix.h"
29 #include "AliLog.h"
30 #include "AliRun.h"
31 #include "AliMagF.h"
32 #include "AliMathBase.h"
33 #include "AliITSUSimuParam.h"
34 #include "AliITSUSDigit.h"
35 #include "AliITSUParamList.h"
36
37 using std::cout;
38 using std::endl;
39 using namespace TMath;
40
41 ClassImp(AliITSUSimulationPix)
42 ////////////////////////////////////////////////////////////////////////
43 //  Version: 1
44 //  Modified by D. Elia, G.E. Bruno, H. Tydesjo
45 //  Fast diffusion code by Bjorn S. Nilsen
46 //  March-April 2006
47 //  October     2007: GetCalibrationObjects() removed
48 //
49 //  Version: 0
50 //  Written by Boris Batyunya
51 //  December 20 1999
52 //
53 //  Adapted for pixels of ITS upgrade July 2012, ruben.shahoyan@cern.ch
54 //
55 //  AliITSUSimulationPix is to do the simulation of pixels
56 //
57 //  2013 Feb: Added MonoPix response and nois calculation al la MIMOSA32 (levente.molnar@cern.ch)
58 //
59 ////////////////////////////////////////////////////////////////////////
60
61 //______________________________________________________________________
62 AliITSUSimulationPix::AliITSUSimulationPix()
63 :  fTanLorAng(0)
64 ,fGlobalChargeScale(1.0)
65 ,fSpread2DHisto(0)
66 ,fSpreadFun(0)
67 ,fROTimeFun(0)
68 {
69     // Default constructor.
70     SetUniqueID(AliITSUGeomTGeo::kChipTypePix);
71 }
72
73 //______________________________________________________________________
74 AliITSUSimulationPix::AliITSUSimulationPix(AliITSUSimuParam* sim,AliITSUSensMap* map)
75 :AliITSUSimulation(sim,map)
76 ,fTanLorAng(0)
77 ,fGlobalChargeScale(1.0)
78 ,fSpread2DHisto(0)
79 ,fSpreadFun(0)
80 ,fROTimeFun(0)
81 {
82     // standard constructor
83     SetUniqueID(AliITSUGeomTGeo::kChipTypePix);
84     Init();
85 }
86
87 //______________________________________________________________________
88 AliITSUSimulationPix::AliITSUSimulationPix(const AliITSUSimulationPix &s)
89 :AliITSUSimulation(s)
90 ,fTanLorAng(s.fTanLorAng)
91 ,fGlobalChargeScale(s.fGlobalChargeScale)
92 ,fSpread2DHisto(s.fSpread2DHisto)
93 ,fSpreadFun(s.fSpreadFun)
94 ,fROTimeFun(s.fROTimeFun)
95 {
96     //     Copy Constructor
97 }
98
99
100 //______________________________________________________________________
101 AliITSUSimulationPix::~AliITSUSimulationPix()
102 {
103     // destructor
104     // only the sens map is owned and it is deleted by ~AliITSUSimulation
105 }
106
107 //______________________________________________________________________
108 AliITSUSimulationPix& AliITSUSimulationPix::operator=(const AliITSUSimulationPix &s)
109 {
110     //    Assignment operator
111     if (&s == this) return *this;
112     AliITSUSimulation::operator=(s);
113     fSpread2DHisto = s.fSpread2DHisto;
114     //
115     fGlobalChargeScale = s.fGlobalChargeScale;
116     fSpreadFun    = s.fSpreadFun;
117     fROTimeFun    = s.fROTimeFun;
118     //
119     return *this;
120 }
121
122 //______________________________________________________________________
123 void AliITSUSimulationPix::Init()
124 {
125     // Initilization
126     if (fSimuParam->GetPixLorentzDrift()) SetTanLorAngle(fSimuParam->GetPixLorentzHoleWeight());
127 }
128
129 //______________________________________________________________________
130 Bool_t AliITSUSimulationPix::SetTanLorAngle(Double_t weightHole)
131 {
132     // This function set the Tangent of the Lorentz angle.
133     // A weighted average is used for electrons and holes
134     // Input: Double_t weightHole: wheight for hole: it should be in the range [0,1]
135     // output: Bool_t : kTRUE in case of success
136     //
137     if (weightHole<0) {
138         weightHole=0.;
139         AliWarning("You have asked for negative Hole weight");
140         AliWarning("I'm going to use only electrons");
141     }
142     if (weightHole>1) {
143         weightHole=1.;
144         AliWarning("You have asked for weight > 1");
145         AliWarning("I'm going to use only holes");
146     }
147     Double_t weightEle=1.-weightHole;
148     AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
149     if (!fld) AliFatal("The field is not initialized");
150     Double_t bz = fld->SolenoidField();
151     fTanLorAng = Tan(weightHole*fSimuParam->LorentzAngleHole(bz) +
152                      weightEle*fSimuParam->LorentzAngleElectron(bz));
153     return kTRUE;
154 }
155
156 //_____________________________________________________________________
157 void AliITSUSimulationPix::SDigitiseChip()
158 {
159     //  This function begins the work of creating S-Digits.
160     
161     AliDebug(10,Form("In event %d chip %d there are %d hits", fEvent, fChip->GetIndex(),fChip->GetNHits()));
162     if (fChip->GetNHits()) {
163         if(fResponseParam->GetParameter(kDigitalSim) == 0 ) Hits2SDigitsFast(); // analogue chip response simulation
164         else Hits2SDigitsFastDigital();                                         // digital chip response
165     }
166     if (!fSensMap->GetEntries()) return;
167     WriteSDigits();
168     ClearMap();
169     //
170 }
171
172 //______________________________________________________________________
173 void AliITSUSimulationPix::WriteSDigits()
174 {
175     //  This function adds each S-Digit to pList
176     static AliITSU *aliITS = (AliITSU*)gAlice->GetModule("ITS");
177     int nsd = fSensMap->GetEntries();
178     
179     
180     for (int i=0;i<nsd;i++) {
181         AliITSUSDigit* sd = (AliITSUSDigit*)fSensMap->At(i); // ordered in index
182         if (!sd->GetSumSignal()>0 || fSensMap->IsDisabled(sd)) continue;
183         aliITS->AddSumDigit(*sd);
184     }
185     return;
186 }
187
188 //______________________________________________________________________
189 void AliITSUSimulationPix::FinishSDigitiseChip()
190 {
191     //  This function calls SDigitsToDigits which creates Digits from SDigits
192     FrompListToDigits();
193     ClearMap();
194     return;
195 }
196
197 //______________________________________________________________________
198 void AliITSUSimulationPix::DigitiseChip()
199 {
200     //  This function creates Digits straight from the hits and then adds
201     //  electronic noise to the digits before adding them to pList
202     //  Each of the input variables is passed along to Hits2SDigits
203     //
204     if(fResponseParam->GetParameter(kDigitalSim) == 0 ) Hits2SDigitsFast(); // analogue chip response simulation
205     else Hits2SDigitsFastDigital();                                         // digital chip response
206     FinishSDigitiseChip();
207 }
208
209 //______________________________________________________________________
210 void AliITSUSimulationPix::Hits2SDigits()
211 {
212     // Does the charge distributions using Gaussian diffusion charge charing.
213     Int_t nhits = fChip->GetNHits();
214     if (!nhits) return;
215     //
216     Int_t h,ix,iz,i;
217     Int_t idtrack;
218     Float_t x,y,z;  // keep coordinates float (required by AliSegmentation)
219     Double_t tof,x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0,de=0.0;
220     Double_t t,tp,st,dt=0.2,el;
221     Double_t thick = 0.5*fSeg->Dy();  // Half Thickness
222     
223     //
224     for (h=0;h<nhits;h++) {
225         //
226         if (!fChip->LineSegmentL(h,x0,x1,y0,y1,z0,z1,de,tof,idtrack)) continue;
227         st = Sqrt(x1*x1+y1*y1+z1*z1);
228         if (st>0.0) {
229             st = (Double_t)((Int_t)(st*1e4)); // number of microns
230             if (st<=1.0) st = 1.0;
231             dt = 1.0/st;               // RS TODO: do we need 1 micron steps?
232             double dy = dt*thick;
233             y = -0.5*dy;
234             for (t=0.0;t<1.0;t+=dt) { // Integrate over t
235                 tp  = t+0.5*dt;
236                 x   = x0+x1*tp;
237                 y  += dy;
238                 z   = z0+z1*tp;
239                 if (!(fSeg->LocalToDet(x,z,ix,iz))) continue; // outside
240                 el  = fGlobalChargeScale * dt * de / fSimuParam->GetGeVToCharge();
241                 //
242                 if (fSimuParam->GetPixLorentzDrift()) x += y*fTanLorAng;
243                 SpreadCharge2D(x,z,y,ix,iz,el,tof,idtrack,h);
244             } // end for t
245         } else { // st == 0.0 deposit it at this point
246             x   = x0;
247             y   = y0 + 0.5*thick;
248             z   = z0;
249             if (!(fSeg->LocalToDet(x,z,ix,iz))) continue; // outside
250             el  = fGlobalChargeScale * de / fSimuParam->GetGeVToCharge();
251             if (fSimuParam->GetPixLorentzDrift()) x += y*fTanLorAng;
252             SpreadCharge2D(x,z,y,ix,iz,el,tof,idtrack,h);
253         } // end if st>0.0
254     } // Loop over all hits h
255     //
256     // Coupling
257     int nd = fSensMap->GetEntriesUnsorted(); // use unsorted access when possible, since it is faster
258     AliITSUSDigit* dg = 0;
259     switch (fSimuParam->GetPixCouplingOption()) {
260         case AliITSUSimuParam::kNoCouplingPix :
261             break;
262         case AliITSUSimuParam::kNewCouplingPix :
263             for (i=nd;i--;) {
264                 dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
265                 if (fSensMap->IsDisabled(dg)) continue;
266                 SetCoupling(dg);
267             }
268             break;
269         case AliITSUSimuParam::kOldCouplingPix:
270             for (i=nd;i--;) {
271                 dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
272                 if (fSensMap->IsDisabled(dg)) continue;
273                 SetCouplingOld(dg);
274             }
275             break;
276         default:
277             break;
278             
279     } // end switch
280     if (GetDebug(2)) AliInfo(Form("Finished fCoupling=%d",fSimuParam->GetPixCouplingOption()));
281 }
282
283 //______________________________________________________________________
284 void AliITSUSimulationPix::Hits2SDigitsFast()
285 {
286     // Does the charge distributions using Gaussian diffusion charge charing.    // Inputs:
287     //    AliITSUChip *mod  Pointer to this chip
288     //
289     TObjArray *hits = fChip->GetHits();
290     Int_t nhits = hits->GetEntriesFast();
291     if (nhits<=0) return;
292     //
293     Int_t h,ix,iz,i;
294     Int_t idtrack;
295     Float_t x,y,z; // keep coordinates float (required by AliSegmentation)
296     Double_t tof,x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0;
297     Double_t step,st,el,de=0.0;
298     Double_t minDim = Min(fSeg->Dpx(1),fSeg->Dpz(1)); // RStmp: smallest pitch
299     Double_t thick = fSeg->Dy();
300     //
301     for (h=0;h<nhits;h++) {
302         //
303         if (!fChip->LineSegmentL(h,x0,x1,y0,y1,z0,z1,de,tof,idtrack)) continue;
304         //
305         st = Sqrt(x1*x1+y1*y1+z1*z1);
306         if (st>0.0) {
307             int np = int(1.5*st/minDim);  //RStmp: inject the points in such a way that there is ~1.5 point per cell
308             np = TMath::Max(1.0*np,fResponseParam->GetParameter(kSpreadFunMinSteps));
309             AliDebug(10,Form(" Number of charge injection steps is set to %d ",np));
310             double dstep = 1./np;
311             double dy = dstep*thick;
312             y = -0.5*dy;
313             step = -0.5*dstep;
314             for (i=0;i<np;i++) {          //RStmp Integrate over t
315                 //      for (i=0;i<kn10;i++) { // Integrate over t
316                 step  += dstep;  // RStmp kti[i];
317                 x   = x0+x1*step;
318                 y  += dy;
319                 z   = z0+z1*step;
320                 if (!(fSeg->LocalToDet(x,z,ix,iz))) continue; // outside
321                 el  = fGlobalChargeScale * dstep * de/fSimuParam->GetGeVToCharge();
322                 if (fSimuParam->GetPixLorentzDrift()) x += y*fTanLorAng;
323                 SpreadCharge2D(x,z,y,ix,iz,el,tof,idtrack,h);
324             } // end for i // End Integrate over t
325         }
326         else { // st == 0.0 deposit it at this point
327             x   = x0;
328             y   = y0+0.5*thick;
329             z   = z0;
330             if (!(fSeg->LocalToDet(x,z,ix,iz))) continue; // outside
331             el  = fGlobalChargeScale * de / fSimuParam->GetGeVToCharge();
332             if (fSimuParam->GetPixLorentzDrift()) x += y*fTanLorAng;
333             SpreadCharge2D(x,z,y,ix,iz,el,tof,idtrack,h);
334         } // end if st>0.0
335         
336     } // Loop over all hits h
337     
338     // Coupling
339     int nd = fSensMap->GetEntriesUnsorted(); // use unsorted access when possible, since it is faster
340     AliITSUSDigit* dg = 0;
341     switch (fSimuParam->GetPixCouplingOption()) {
342         case AliITSUSimuParam::kNoCouplingPix :
343             break;
344         case AliITSUSimuParam::kNewCouplingPix :
345             for (i=nd;i--;) {
346                 dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
347                 if (fSensMap->IsDisabled(dg)) continue;
348                 SetCoupling(dg);
349             }
350         case AliITSUSimuParam::kOldCouplingPix:
351             for (i=nd;i--;) {
352                 dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
353                 if (fSensMap->IsDisabled(dg)) continue;
354                 SetCouplingOld(dg);
355             }
356             break;
357         default:
358             break;
359     } // end switch
360     if (GetDebug(2)) AliInfo(Form("Finished fCoupling=%d",fSimuParam->GetPixCouplingOption()));
361 }
362
363 //______________________________________________________________________
364 void AliITSUSimulationPix::SpreadCharge2D(Double_t x0,Double_t z0, Double_t dy, Int_t ix0,Int_t iz0,
365                                           Double_t el, Double_t tof, Int_t tID, Int_t hID)
366 {
367     // Spreads the charge over neighboring cells. Assume charge is distributed
368     // as charge(x,z) = (el/2*pi*sigx*sigz)*exp(-arg)
369     // arg=((x-x0)*(x-x0)/2*sigx*sigx)+((z-z0*z-z0)/2*sigz*sigz)
370     // Defined this way, the integral over all x and z is el.
371     // Inputs:
372     //    Double_t x0   x position of point where charge is liberated (local)
373     //    Double_t z0   z position of point where charge is liberated (local)
374     //    Double_t dy   distance from the entrance surface (diffusion sigma may depend on it)
375     //    Int_t    ix0  row of cell corresponding to point x0
376     //    Int_t    iz0  columb of cell corresponding to point z0
377     //    Double_t el   number of electrons liberated in this step
378     //    Double_t sigx Sigma difusion along x for this step (y0 dependent)
379     //    Double_t sigz Sigma difusion along z for this step (z0 dependent)
380     //    Int_t    tID  track number
381     //    Int_t    hID  hit "hit" index number
382     //
383     Int_t ix,iz,ixs,ixe,izs,ize;
384     Float_t x,z;   // keep coordinates float (required by AliSegmentation)
385     Float_t xdioshift = 0 , zdioshift = 0 ;
386     Double_t s,dtIn[kNDtSpread]; // data transfered to spread function for integral calculation
387     //
388     if (GetDebug(2)) AliInfo(Form("(x0=%e,z0=%e,dy=%e, ix0=%d,iz0=%d,el=%e,tID=%d,hID=%d)",x0,z0,dy,ix0,iz0,el,tID,hID));
389     //
390     Double_t &x1 = dtIn[kCellX1];
391     Double_t &x2 = dtIn[kCellX2];
392     Double_t &z1 = dtIn[kCellZ1];
393     Double_t &z2 = dtIn[kCellZ2];
394     //
395     int nx = GetResponseParam()->GetParameter(kSpreadFunParamNXoffs);
396     int nz = GetResponseParam()->GetParameter(kSpreadFunParamNZoffs);
397     //
398     dtIn[kCellYDepth]  = dy;
399     ixs = Max(-nx+ix0,0);
400     ixe = Min( nx+ix0,fSeg->Npx()-1);
401     izs = Max(-nz+iz0,0);
402     ize = Min( nz+iz0,fSeg->Npz()-1);
403     for (ix=ixs;ix<=ixe;ix++)
404         for (iz=izs;iz<=ize;iz++) {
405             //
406             // Check if the hit is inside readout window
407             int cycleRO = (((AliITSUSimulationPix*)this)->*AliITSUSimulationPix::fROTimeFun)(ix,iz,tof);
408             if (Abs(cycleRO)>kMaxROCycleAccept) continue;
409             //
410             fSeg->DetToLocal(ix,iz,x,z); // pixel center
411             xdioshift = zdioshift = 0;
412             double dxi = fSeg->Dpx(ix);
413             double dzi = fSeg->Dpz(iz);
414             CalcDiodeShiftInPixel(ix,iz,xdioshift,zdioshift);    // Check and apply diode shift if needed
415             xdioshift *= dxi;
416             zdioshift *= dzi;
417             dxi *= 0.5;
418             dzi *= 0.5;
419             //      printf("DShift: %d %d -> %.4f %.4f\n",ix,iz,xdioshift,zdioshift);
420             x1  = (x + xdioshift) - x0;   // calculate distance of cell boundaries from injection center
421             z1  = (z + zdioshift) - z0;
422             x2  = x1 + dxi; // Upper
423             x1 -= dxi;      // Lower
424             z2  = z1 + dzi; // Upper
425             z1 -= dzi;      // Lower
426             s   = el* (((AliITSUSimulationPix*)this)->*AliITSUSimulationPix::fSpreadFun)(dtIn);
427             if (s>fSimuParam->GetPixMinElToAdd()) UpdateMapSignal(iz,ix,tID,hID,s,cycleRO);
428         } // end for ix, iz
429     //
430 }
431
432 //______________________________________________________________________
433 Double_t AliITSUSimulationPix::SpreadFunDoubleGauss2D(const Double_t *dtIn)
434 {
435     // calculate integral of charge in the cell with boundaries at X=dtIn[kCellX1]:dtIn[kCellX2]
436     // and Z=dtIn[kCellZ1]:dtIn[kCellZ2]
437     // The spread function is assumed to be double gaussian in 2D
438     // Parameters should be: mean0,sigma0, mean1,sigma1, relative strenght of 2nd gaussian wrt 1st one
439     //
440     // 1st gaussian
441     double intg1 = GausInt2D(fResponseParam->GetParameter(kG2SigX0),  // sigX
442                              dtIn[kCellX1]-fResponseParam->GetParameter(kG2MeanX0),      // x1-xmean
443                              dtIn[kCellX2]-fResponseParam->GetParameter(kG2MeanX0),      // x2-xmean
444                              fResponseParam->GetParameter(kG2SigZ0),  // sigZ
445                              dtIn[kCellZ1]-fResponseParam->GetParameter(kG2MeanZ0),    // z1-zmean
446                              dtIn[kCellZ2]-fResponseParam->GetParameter(kG2MeanZ0));   // z2-zmean
447     // 2nd gaussian
448     double intg2 = GausInt2D(fResponseParam->GetParameter(kG2SigX1),  // sigX
449                              dtIn[kCellX1]-fResponseParam->GetParameter(kG2MeanX1),      // x1-xmean
450                              dtIn[kCellX2]-fResponseParam->GetParameter(kG2MeanX1),      // x2-xmean
451                              fResponseParam->GetParameter(kG2SigZ1),  // sigZ
452                              dtIn[kCellZ1]-fResponseParam->GetParameter(kG2MeanZ1),    // z1-zmean
453                              dtIn[kCellZ2]-fResponseParam->GetParameter(kG2MeanZ1));   // z2-zmean
454     double scl = fResponseParam->GetParameter(kG2ScaleG2);
455     return (intg1+intg2*scl)/(1+scl);
456     //
457 }
458
459
460 //______________________________________________________________________
461 Double_t AliITSUSimulationPix::SpreadFrom2DHisto(const Double_t *dtIn)
462 {
463     // calculate integral of charge in the cell with boundaries at X=dtIn[kCellX1]:dtIn[kCellX2]
464     // and Z=dtIn[kCellZ1]:dtIn[kCellZ2]
465     // The spread function integral is taken from fSpread2DHisto extracted from the sensor response parameters
466     // list in the method SetResponseParam. The histo must return the fraction of charge integrates in the
467     // cell whose center is on the distance X=(dtIn[kCellX1]+dtIn[kCellX2])/2 and Z=(dtIn[kCellZ1]+dtIn[kCellZ2])/2
468     // from the injection point.
469     //
470     Double_t qpixfrac = 0;
471     Double_t xintp = 1e4*(dtIn[kCellX1]+dtIn[kCellX2])/2.0;
472     Double_t zintp = 1e4*(dtIn[kCellZ1]+dtIn[kCellZ2])/2.0;
473     //
474     qpixfrac =  fSpread2DHisto->Interpolate(xintp,zintp); //the PSF map is given in um but the dtIn is in cm so we need to convert it
475     //
476     return qpixfrac;
477 }
478
479 //______________________________________________________________________
480 Double_t AliITSUSimulationPix::SpreadFunGauss2D(const Double_t *dtIn)
481 {
482     // calculate integral of charge in the cell with boundaries at X=dtIn[kCellX1]:dtIn[kCellX2]
483     // and Z=dtIn[kCellZ1]:dtIn[kCellZ2]
484     // The spread function is assumed to be gaussian in 2D
485     // Parameters should be: mean0,sigma0
486     return GausInt2D(fResponseParam->GetParameter(kG1SigX),  // sigX
487                      dtIn[kCellX1]-fResponseParam->GetParameter(kG1MeanX),    // x1-xmean
488                      dtIn[kCellX2]-fResponseParam->GetParameter(kG1MeanX),    // x2-xmean
489                      fResponseParam->GetParameter(kG1SigZ),  // sigZ
490                      dtIn[kCellZ1]-fResponseParam->GetParameter(kG1MeanZ),    // z1-zmean
491                      dtIn[kCellZ2]-fResponseParam->GetParameter(kG1MeanZ));   // z2-zmean
492     //
493 }
494
495 //______________________________________________________________________
496 void AliITSUSimulationPix::RemoveDeadPixels()
497 {
498     // Removes dead pixels on each chip (ladder)
499     // This should be called before going from sdigits to digits (i.e. from FrompListToDigits)
500     
501     AliITSUCalibrationPix* calObj = (AliITSUCalibrationPix*) GetCalibDead();
502     if (!calObj) return;
503     //
504     if (calObj->IsBad()) {ClearMap(); return;} // whole chip is masked
505     //
506     // prepare the list of r/o cycles seen
507     Char_t cyclesSeen[2*kMaxROCycleAccept+1];
508     int ncycles = 0;
509     for (int i=(2*kMaxROCycleAccept+1);i--;) if (fCyclesID[i]) cyclesSeen[ncycles++]=i-kMaxROCycleAccept;
510     
511     // remove single bad pixels one by one
512     int nsingle = calObj->GetNrBadSingle();
513     UInt_t col,row;
514     Int_t cycle;
515     for (int i=nsingle;i--;) {
516         calObj->GetBadPixelSingle(i,row,col);
517         for (int icl=ncycles;icl--;) fSensMap->DeleteItem(col,row,cyclesSeen[icl]);
518     }
519     int nsd = fSensMap->GetEntriesUnsorted();
520     for (int isd=nsd;isd--;) {
521         AliITSUSDigit* sd = (AliITSUSDigit*)fSensMap->AtUnsorted(isd);
522         if (fSensMap->IsDisabled(sd)) continue;
523         fSensMap->GetMapIndex(sd->GetUniqueID(),col,row,cycle);
524         int chip = fSeg->GetChipFromChannel(0,col);
525         //    if (calObj->IsChipMarkedBad(chip)) fSensMap->Disable(sd); // this will simple mark the hit as bad
526         if (calObj->IsChipMarkedBad(chip)) fSensMap->DeleteItem(sd); // this will suppress hit in the sorted list
527     }
528     //
529 }
530
531 //______________________________________________________________________
532 void AliITSUSimulationPix::AddNoisyPixels()
533 {
534     // Adds noisy pixels on each chip (ladder)
535     // This should be called before going from sdigits to digits (i.e. FrompListToDigits)
536     AliITSUCalibrationPix* calObj = (AliITSUCalibrationPix*) GetCalibNoisy();
537     if (!calObj) { AliDebug(10,Form("  No Calib Object for Noise!!! ")); return;}
538     for (Int_t i=calObj->GetNrBad(); i--;)
539     {
540         if ( fResponseParam->GetParameter(kDigitalSim) < 1.0 )
541             UpdateMapNoise(calObj->GetBadColAt(i), calObj->GetBadRowAt(i),10*fSimuParam->GetPixThreshold(fChip->GetIndex()));
542         else
543             UpdateMapNoise(calObj->GetBadColAt(i), calObj->GetBadRowAt(i),kNoisyPixOCDB );
544     }
545     //
546 }
547
548 //______________________________________________________________________
549 void AliITSUSimulationPix::FrompListToDigits()
550 {
551     // add noise and electronics, perform the zero suppression and add the digits to the list
552     //
553     // RS may use for ordered random sample generation dl.acm.org/ft_gateway.cfm?id=356313&type=pdf
554     //
555     int nsd = fSensMap->GetEntriesUnsorted();  // sdigits added from the signal
556     //
557     // add different kinds of noise.
558     Bool_t addNoisy = fSimuParam->GetPixAddNoisyFlag() && (nsd>0 || fSimuParam->GetPixNoiseInAllMod()); // do we generate noise?
559     if (addNoisy) {
560         AddNoisyPixels();       // constantly noisy channels
561         AddRandomNoisePixels(0.0); // random noise: at the moment generate noise only for instance 0
562         nsd = fSensMap->GetEntriesUnsorted();
563     }
564     //
565     if (nsd && fSimuParam->GetPixRemoveDeadFlag()) {
566         RemoveDeadPixels();
567         // note that here we shall use GetEntries instead of GetEntriesUnsorted since the
568         // later operates on the array where the elements are not removed by flagged
569         nsd = fSensMap->GetEntries();
570     }
571     if (!nsd) return; // nothing to digitize
572     //
573     UInt_t row,col;
574     Int_t iCycle,modId = fChip->GetIndex();
575     Double_t sig;
576     const Int_t    knmaxtrk=AliITSdigit::GetNTracks();
577     static AliITSU *aliITS = (AliITSU*)gAlice->GetModule("ITS");
578     static AliITSUDigitPix dig;
579     //
580     for (int i=0;i<nsd;i++) {
581         AliITSUSDigit* sd = (AliITSUSDigit*)fSensMap->At(i); // ordered in index
582         if (fSensMap->IsDisabled(sd)) continue;
583         //
584         sig=sd->GetSumSignal();
585         if ( fResponseParam->GetParameter(kDigitalSim) < 1.0 &&
586              sig<=fSimuParam->GetPixThreshold(modId)) continue;   //Threshold only applies in analogue simulation
587         //
588         if (Abs(sig)>2147483647.0) { //RS?
589             //PH 2147483647 is the max. integer
590             //PH This apparently is a problem which needs investigation
591             AliWarning(Form("Too big or too small signal value %f",sig));
592         }
593         fSensMap->GetMapIndex(sd->GetUniqueID(),col,row,iCycle);
594         dig.SetCoord1(col);
595         dig.SetCoord2(row);
596         dig.SetROCycle(iCycle);
597         dig.SetSignal((Int_t)sig);
598         dig.SetSignalPix((Int_t)sig);
599         int ntr = sd->GetNTracks();
600         for (int j=0;j<ntr;j++) {
601             dig.SetTrack(j,sd->GetTrack(j));
602             dig.SetHit(j,sd->GetHit(j));
603         }
604         for (int j=ntr;j<knmaxtrk;j++) {
605             dig.SetTrack(j,-3);
606             dig.SetHit(j,-1);
607         }
608         aliITS->AddSimDigit(AliITSUGeomTGeo::kChipTypePix, &dig);
609     }
610     //
611 }
612
613 //______________________________________________________________________
614 Int_t AliITSUSimulationPix::AddRandomNoisePixels(Double_t tof)
615 {
616   // create random noisy sdigits above threshold
617   //
618   int modId = fChip->GetIndex();
619   int npix = fSeg->GetNPads();
620   int ncand = gRandom->Poisson( npix*fSimuParam->GetPixFakeRate() );
621   if (ncand<1) return 0;
622   //
623   double probNoisy,noiseSig,noiseMean,thresh;
624   //
625   UInt_t row,col;
626   Int_t iCycle;
627   static TArrayI ordSampleInd(100),ordSample(100); //RS!!! static is not thread-safe!!!
628   ncand = GenOrderedSample(npix,ncand,ordSample,ordSampleInd);
629   int* ordV = ordSample.GetArray();
630   int* ordI = ordSampleInd.GetArray();
631   //
632   if ( fResponseParam->GetParameter(kDigitalSim) < 1.0 ) {
633     thresh = fSimuParam->GetPixThreshold(modId);
634     fSimuParam->GetPixNoise(modId, noiseSig, noiseMean);
635     probNoisy = AliITSUSimuParam::CalcProbNoiseOverThreshold(noiseMean,noiseSig,thresh); // prob. to have noise above threshold
636     //
637     for (int j=0;j<ncand;j++) {
638       fSensMap->GetMapIndex((UInt_t)ordV[ordI[j]],col,row,iCycle);   // create noisy digit
639       iCycle = (((AliITSUSimulationPix*)this)->*AliITSUSimulationPix::fROTimeFun)(row,col,tof);
640       UpdateMapNoise(col,row,AliITSUSimuParam::GenerateNoiseQFunction(probNoisy,noiseMean,noiseSig),  iCycle);
641     }
642   }
643   else {
644     for (int j=0;j<ncand;j++) {
645       fSensMap->GetMapIndex((UInt_t)ordV[ordI[j]],col,row,iCycle);   // create noisy digit
646       iCycle = (((AliITSUSimulationPix*)this)->*AliITSUSimulationPix::fROTimeFun)(row,col,tof);
647       UpdateMapNoise(col,row,kNoisyPixRnd, iCycle);
648     }
649   }
650   return ncand;
651 }
652
653
654 //______________________________________________________________________
655 void AliITSUSimulationPix::SetCoupling(AliITSUSDigit* old)
656 {
657     //  Take into account the coupling between adiacent pixels.
658     //  The parameters probcol and probrow are the probability of the
659     //  signal in one pixel shared in the two adjacent pixels along
660     //  the column and row direction, respectively.
661     //  Note pList is goten via GetMap() and chip is not need any more.
662     //  Otherwise it is identical to that coded by Tiziano Virgili (BSN).
663     UInt_t col,row;
664     Int_t iCycle;
665     Double_t pulse1,pulse2;
666     Double_t couplR=0.0,couplC=0.0;
667     Double_t xr=0.;
668     //
669     fSensMap->GetMapIndex(old->GetUniqueID(),col,row,iCycle);
670     int cycle = iCycle;
671     fSimuParam->GetPixCouplingParam(couplC,couplR);
672     if (GetDebug(2)) AliInfo(Form("(col=%d,row=%d,couplC=%e couplR=%e",
673                                   col,row,couplC,couplR));
674     pulse2 = pulse1 = old->GetSignal();
675     if (pulse1<fSimuParam->GetPixMinElToAdd()) return; // too small signal
676     for (Int_t isign=-1;isign<=1;isign+=2) {
677         //
678         // loop in col direction
679         int j1 = int(col) + isign;
680         xr = gRandom->Rndm();
681         if ( !((j1<0) || (j1>fSeg->Npz()-1) || (xr>couplC)) ) UpdateMapSignal(UInt_t(j1),row,old->GetTrack(0),old->GetHit(0),pulse1,cycle);
682         //
683         // loop in row direction
684         int j2 = int(row) + isign;
685         xr = gRandom->Rndm();
686         if ( !((j2<0) || (j2>fSeg->Npx()-1) || (xr>couplR)) ) UpdateMapSignal(col,UInt_t(j2),old->GetTrack(0),old->GetHit(0),pulse2,cycle);
687     }
688     //
689 }
690
691 //______________________________________________________________________
692 void AliITSUSimulationPix::SetCouplingOld(AliITSUSDigit* old)
693 {
694     //  Take into account the coupling between adiacent pixels.
695     //  The parameters probcol and probrow are the fractions of the
696     //  signal in one pixel shared in the two adjacent pixels along
697     //  the column and row direction, respectively.
698     // Inputs:
699     // old            existing AliITSUSDigit
700     // ntrack         track incex number
701     // idhit          hit index number
702     // chip         chip number
703     //
704     UInt_t col,row;
705     Int_t cycle;
706     Int_t modId = fChip->GetIndex();
707     Double_t pulse1,pulse2;
708     Double_t couplR=0.0,couplC=0.0;
709     //
710     fSensMap->GetMapIndex(old->GetUniqueID(),col,row,cycle);
711     fSimuParam->GetPixCouplingParam(couplC,couplR);
712     if (GetDebug(3)) AliInfo(Form("(col=%d,row=%d,roCycle=%d)  couplC=%e couplR=%e",col,row,cycle,couplC,couplR));
713     //
714     if (old->GetSignal()<fSimuParam->GetPixMinElToAdd()) return; // too small signal
715     for (Int_t isign=-1;isign<=1;isign+=2) {// loop in col direction
716         pulse2 = pulse1 = old->GetSignal();
717         //
718         int j1 = int(col)+isign;
719         pulse1 *= couplC;
720         if ((j1<0)||(j1>fSeg->Npz()-1)||(pulse1<fSimuParam->GetPixThreshold(modId))) pulse1 = old->GetSignal();
721         else UpdateMapSignal(UInt_t(j1),row,old->GetTrack(0),old->GetHit(0),pulse1,cycle);
722         
723         // loop in row direction
724         int j2 = int(row) + isign;
725         pulse2 *= couplR;
726         if ((j2<0)||(j2>(fSeg->Npx()-1))||(pulse2<fSimuParam->GetPixThreshold(modId))) pulse2 = old->GetSignal();
727         else UpdateMapSignal(col,UInt_t(j2),old->GetTrack(0),old->GetHit(0),pulse2,cycle);
728     } // for isign
729 }
730
731 //______________________________________________________________________
732 void AliITSUSimulationPix::SetResponseParam(AliITSUParamList* resp)
733 {
734     // attach response parameterisation data
735     fResponseParam = resp;
736     //
737     int spreadID = Nint(fResponseParam->GetParameter(AliITSUSimulationPix::kChargeSpreadType));
738     const char* hname = 0;
739     fSpread2DHisto = 0;
740     //
741     switch (spreadID) {
742             //
743         case kSpreadFunHisto:
744             fSpreadFun = &AliITSUSimulationPix::SpreadFrom2DHisto;
745             hname = fResponseParam->GetParName(AliITSUSimulationPix::kChargeSpreadType);
746             if (!(fSpread2DHisto=(TH2*)fResponseParam->GetParamObject(hname)))
747                 AliFatal(Form("Did not find 2D histo %s for charge spread parameterization",hname));
748             break;
749             //
750         case kSpreadFunDoubleGauss2D:
751             fSpreadFun = &AliITSUSimulationPix::SpreadFunDoubleGauss2D;
752             break;
753             //
754         case kSpreadFunGauss2D:
755             fSpreadFun = &AliITSUSimulationPix::SpreadFunGauss2D;
756             break;
757             //
758         default: AliFatal(Form("Did not find requested spread function id=%d",spreadID));
759     }
760     //
761     int readoutType = Nint(fResponseParam->GetParameter(kReadOutSchemeType));
762     switch (readoutType) {
763         case kReadOutStrobe:
764             fROTimeFun = &AliITSUSimulationPix::GetReadOutCycle;
765             break;
766         case kReadOutRollingShutter:
767             fROTimeFun = &AliITSUSimulationPix::GetReadOutCycleRollingShutter;
768             break;
769         default: AliFatal(Form("Did not find requested readout time type id=%d",readoutType));
770     }
771     
772     //___ Set the Rolling Shutter read-out window
773     fReadOutCycleLength = fResponseParam->GetParameter(kReadOutCycleLength);
774     //___ Pixel discrimination threshold, and the S/N cut
775     fSimuParam->SetPixThreshold(fResponseParam->GetParameter(kPixNoiseMPV) *fResponseParam->GetParameter(kPixSNDisrcCut) , fResponseParam->GetParameter(kPixSNDisrcCut),-1); //for all chips
776     //___ Minimum number of electrons to add
777     fSimuParam->SetPixMinElToAdd(fResponseParam->GetParameter(kPixMinElToAdd));
778     //___ Set the Pixel Noise MPV and Sigma (the noise distribution is Landau not Gauss due to RTN)
779     fSimuParam->SetPixNoise( fResponseParam->GetParameter(kPixNoiseMPV), fResponseParam->GetParameter(kPixNoiseSigma), -1); //for all chips
780     //___ Pixel fake hit rate
781     fSimuParam->SetPixFakeRate( fResponseParam->GetParameter(kPixFakeRate) );
782     //___ To apply the noise or not
783     if (  fResponseParam->GetParameter(kPixNoiseIsOn) > 0.01)  fSimuParam->SetPixAddNoisyFlag(kTRUE);
784     else fSimuParam->SetPixAddNoisyFlag(kFALSE);
785     //
786     if(fResponseParam->GetParameter(kPixNoiseInAllMod) > 0.01 ) fSimuParam->SetPixNoiseInAllMod(kTRUE);
787     else fSimuParam->SetPixNoiseInAllMod(kFALSE);
788     //
789     //  Double_t vGeVToQ = fSimuParam->GetGeVToCharge();
790     fGlobalChargeScale = fResponseParam->GetParameter(kSpreadFunGlobalQScale);
791     
792     AliDebug(10,Form("=============== Setting the response start ============================"));
793     AliDebug(10,Form("=============== Digital (1) / Analogue (0) simu: %f",fResponseParam->GetParameter(kDigitalSim)));
794     AliDebug(10,Form("=============== RO type: %d",readoutType));
795     AliDebug(10,Form("=============== RO cycle lenght: %lf",fReadOutCycleLength));
796     AliDebug(10,Form("=============== Noise MPV: %lf",fResponseParam->GetParameter(kPixNoiseMPV)));
797     AliDebug(10,Form("=============== Noise Sigma: %lf",fResponseParam->GetParameter(kPixNoiseSigma)));
798     AliDebug(10,Form("=============== Fake rate: %lf",fResponseParam->GetParameter(kPixFakeRate)));
799     AliDebug(10,Form("=============== Noise On/Off: %d",fSimuParam->GetPixAddNoisyFlag()));
800     AliDebug(10,Form("=============== Noise in all mod on/off: %d",fSimuParam->GetPixNoiseInAllMod()));
801     AliDebug(10,Form("=============== Global Charge scale: %lf",fGlobalChargeScale));
802     AliDebug(10,Form("=============== Setting the response done  ============================"));
803     
804 }
805
806 //______________________________________________________________________
807 Int_t AliITSUSimulationPix::GetReadOutCycleRollingShutter(Int_t row, Int_t col, Double_t hitTime)
808 {
809     //
810     // Get the read-out cycle of the hit in the given column/row of the sensor.
811     // hitTime is the time of the subhit (hit is divided to nstep charge deposit) in seconds
812     // globalPhaseShift gives the start of the RO for the cycle in pixel wrt the LHC clock
813     // GetRollingShutterWindow give the with of the rolling shutter read out window
814     //
815     double tmin = fReadOutCycleOffset + fReadOutCycleLength*(double(row)/fSeg->Npx()-1.);
816     int cycle = Nint( (hitTime-tmin)/fReadOutCycleLength - 0.5 );
817     AliDebug(3,Form("Rolling shutter at row%d/col%d: particle time: %e, tmin: %e : tmax %e -> cycle:%d",row,col,hitTime,tmin,
818                     tmin+fReadOutCycleLength,cycle));
819     return cycle;
820     //
821 }
822
823 //______________________________________________________________________
824 Int_t AliITSUSimulationPix::GetReadOutCycle(Int_t row, Int_t col, Double_t hitTime)
825 {
826     //
827     // Check whether the hit is in the read out window of the given column/row of the sensor
828     //
829     AliDebug(3,Form("Strobe readout: row%d/col%d: particle time: %e, tmin: %e, tmax %e",
830                     row,col,hitTime,fReadOutCycleOffset,fReadOutCycleOffset+fReadOutCycleLength));
831     hitTime -= fReadOutCycleOffset+0.5*fReadOutCycleLength;
832     return (hitTime<0 || hitTime>fReadOutCycleLength) ? kMaxROCycleAccept+1 : 0;
833     //
834 }
835
836 //_______________________________________________________________________
837 void AliITSUSimulationPix::CalcDiodeShiftInPixel(Int_t xrow, Int_t zcol, Float_t &x, Float_t &z)
838 {
839     //
840     // Calculates the shift of the diode wrt the geometric center of the pixel.
841     // It is needed for staggerred pixel layout or double diode pixels with assymetric center
842     // The shift can depend on the column or line or both...
843     // The x and z are passed in cm
844     //
845     ((AliITSUSegmentationPix*)fSeg)->GetDiodShift(xrow,zcol,x,z);
846     //
847 }
848
849 //______________________________________________________________________
850 void AliITSUSimulationPix::Hits2SDigitsFastDigital()
851 {
852     // Does the digital chip response simulation
853     //    AliITSUChip *mod  Pointer to this chip
854     //
855     
856     
857     TObjArray *hits = fChip->GetHits();
858     Int_t nhits = hits->GetEntriesFast();
859     if (nhits<=0) return;
860     //
861     Int_t h,ix,iz;
862     Int_t idtrack;
863     Double_t tof,x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0;
864     Double_t el,de=0.0;
865     
866     //
867     for (h=0;h<nhits;h++) {
868         //
869         if (!fChip->LineSegmentL(h,x0,x1,y0,y1,z0,z1,de,tof,idtrack)) continue;
870         //
871         //double st = Sqrt(x1*x1+y1*y1+z1*z1);
872         
873         //___ place hit to the middle of the path segment - CHANGE LATER !
874         // keep coordinates float (required by AliSegmentation)
875         float x   = (x0+x1)/2.0;
876         //float y   = (y0+y1)/2.0;
877         float z   = (z0+z1)/2.0;
878         //
879         if (!(fSeg->LocalToDet(x,z,ix,iz))) continue; // outside
880         //
881         // Check if the hit is inside readout window
882         int cycleRO = (((AliITSUSimulationPix*)this)->*AliITSUSimulationPix::fROTimeFun)(ix,iz,tof);
883         if (Abs(cycleRO)>kMaxROCycleAccept) continue;
884         //
885         //
886         el  = de / fSimuParam->GetGeVToCharge();
887         //
888         PlaceDigitalPixels(x,z,el,tof,idtrack,h);
889         //
890     } // Loop over all hits h
891     
892 }
893 //______________________________________________________________________
894 void AliITSUSimulationPix::PlaceDigitalPixels(Double_t x0hit,Double_t z0hit, Double_t el, Double_t tof, Int_t tID, Int_t hID)
895 {
896     // Place the digital pixel positions on the sensor
897     // Inputs:
898     //    Double_t x0hit   x position of point where charge is liberated (local) - hit
899     //    Double_t z0hit   z position of point where charge is liberated (local) - hit
900     //    Double_t el   number of electrons liberated in this step
901     //    Double_t sigx Sigma difusion along x for this step (y0 dependent)
902     //    Double_t sigz Sigma difusion along z for this step (z0 dependent)
903     //    Int_t    tID  track number
904     //    Int_t    hID  hit "hit" index number
905     //
906     
907     
908     Int_t ix,iz,nx,nz;
909     Float_t x,z;   // keep coordinates float (required by AliSegmentation)
910     Float_t distX = 0, distZ = 0;
911     
912     //___ TEMPORARY - place a fixed pattern cluster COG to a distance d(x,z) away from hit - TEMPORARY
913     // Pattern used (not realistic ebye but averaging over events yes):
914     //  -+-
915     //  +++
916     //  -+-
917     //
918     //___ This list should come from a look up table based on CluTypeID as well as COG coord
919     
920     //
921     TRandom3 rnd;
922     distX = rnd.Uniform(-5.0*1e-4, 5.0*1e-4); //in um
923     distZ = rnd.Uniform(-5.0*1e-4, 5.0*1e-4); //in um
924     //
925     x = x0hit + distX;
926     z = z0hit + distZ;
927     //
928     if(!fSeg->LocalToDet(x,z,ix,iz)) return; // if clu CoG is outside of the chip skipp the cluster -> refine later
929     //
930     const Int_t nCluPixels = 5;
931     Int_t aPixListX[nCluPixels] = { 0, -1, 0, 1,  0};
932     Int_t aPixListZ[nCluPixels] = { 1,  0, 0, 0, -1};
933     //
934     Double_t s = el / 1.0 / nCluPixels;
935     //
936     int cycleRO;
937     //
938     for (Int_t ipix = 0 ; ipix < nCluPixels; ipix++)
939     {
940         nx = ix + aPixListX[ipix];
941         nz = iz + aPixListZ[ipix];
942         cycleRO = (((AliITSUSimulationPix*)this)->*AliITSUSimulationPix::fROTimeFun)(ix,iz,tof);
943         if ( nx >= 0 && nx <= fSeg -> Npx() && nz >= 0 && nz <= fSeg -> Npz() ) UpdateMapSignal(nz,nx,tID,hID,s,cycleRO); //if the pixel is in the detector
944     }
945    
946
947     
948 }
949
950
951