ITS/AliITSmoduleSSD.cxx

   1
   2 #include "AliITSmoduleSSD.h"
   3
   4
   5 ClassImp(AliITSmoduleSSD)
   6
   7 //____________________________________________________________________
   8 //
   9 //  Constructor
  10 //____________________________________________________________________
  11 //
  12
  13
  14 AliITSmoduleSSD::AliITSmoduleSSD() {
  15
  16
  17     //Invalid Strips parameters
  18
  19     fInvalidP = new TArrayS(0);
  20     fInvalidN = new TArrayS(0);
  21
  22     fNInvalidP = 0;
  23     fNInvalidN = 0;
  24
  25
  26     //DCS parameters
  27
  28     fGainP = 83;
  29     fGainN = 83;
  30     fSNRatioP = 600;
  31     fSNRatioP = 500;
  32
  33     fCouplingPR = 0.021;
  34     fCouplingPL = 0.026;
  35     fCouplingNR = 0.013;
  36     fCouplingNL = 0.010;
  37
  38 }
  39
  40 AliITSmoduleSSD::AliITSmoduleSSD(Int_t index) {
  41
  42     fIndex = index;
  43
  44     //Invalid Strips parameters
  45
  46     fInvalidP = new TArrayS(0);
  47     fInvalidN = new TArrayS(0);
  48
  49     fNInvalidP = 0;
  50     fNInvalidN = 0;
  51
  52
  53     //DCS parameters
  54
  55     fGainP = 83;
  56     fGainN = 83;
  57     fSNRatioP = 600;
  58     fSNRatioP = 500;
  59
  60     fCouplingPR = 0.021;
  61     fCouplingPL = 0.026;
  62     fCouplingNR = 0.013;
  63     fCouplingNL = 0.010;
  64 }
  65
  66 AliITSmoduleSSD::~AliITSmoduleSSD() {
  67
  68     if (!fInvalidP) delete fInvalidP;
  69     if (!fInvalidN) delete fInvalidN;
  70 }
  71
  72
  73 //____________________________________________________________________
  74 //
  75 //  Inalid strips menagement
  76 //____________________________________________________________________
  77 //
  78
  79
  80
  81 void AliITSmoduleSSD::SetInvalidP(Int_t strip, Bool_t b) {
  82
  83     Bool_t already = kFALSE;
  84     Int_t i;
  85
  86     for (i=0; i<fNInvalidP; i++) {
  87         if ((*fInvalidP)[i] == strip) {
  88            already = kTRUE;
  89            break;
  90         }
  91     }
  92
  93     if (!already && b) {
  94        (*fInvalidP)[fNInvalidP++] = strip;
  95     }
  96 }
  97
  98 void AliITSmoduleSSD::SetInvalidMC(Float_t m, Float_t s) {
  99
 100     fNInvalid = m;
 101     fISigma = s;
 102     SetInvalidMC();
 103 }
 104
 105 void AliITSmoduleSSD::SetInvalidMC() {
 106
 107     Int_t m = (Int_t)gRandom->Gaus(fNInvalid, fISigma);
 108
 109     for(int i=0; i<m; i++) {
 110        SetInvalidP((Int_t)(gRandom->Rndm()*kNStrips), kTRUE);
 111     }
 112
 113 }
 114
 115 Bool_t AliITSmoduleSSD::IsValidP(Int_t n) {
 116
 117     for(Int_t i=0; i<fNInvalidP; i++)
 118        if ((*fInvalidP)[i] == n) return kFALSE;
 119     return kTRUE;
 120 }
 121
 122 Bool_t AliITSmoduleSSD::IsValidN(Int_t n) {
 123
 124     for(Int_t i=0; i<fNInvalidN; i++)
 125        if ((*fInvalidN)[i] == n) return kFALSE;
 126     return kTRUE;
 127 }
 128
 129
 130 //____________________________________________________________________
 131 //
 132 //  Add digit
 133 //____________________________________________________________________
 134 //
 135
 136 /*********************************************************************
 137 *
 138 * AddDigits
 139 * sets paramerers: layer, ladder detector
 140 * scan tracks wich produced this digit
 141 * creates new SSD DIGTS
 142 * call ITS to add digit to its Array
 143 * set index frm ITS in its own array
 144 *
 145 * S.Radomski 17.09.1999
 146 *
 147 *********************************************************************/
 148
 149 void AliITSmoduleSSD::AddDigit(Int_t strNo, Int_t s, Bool_t p) {
 150
 151     Int_t tracks[3];
 152     Int_t digits[4];
 153     AliITSdigit *t = (AliITSdigit*) (new AliITSdigitSSD(tracks, digits,
 154                                                         strNo, s, p));
 155
 156     fIdigits->AddAt(((AliITS *)fITS)->AddDigit(t), fNdigits++);
 157 }
 158
 159
 160 //____________________________________________________________________
 161 //
 162 //  Hits to digits
 163 //____________________________________________________________________
 164 //
 165
 166
 167
 168 void AliITSmoduleSSD::HitToDigit() {
 169
 170     Int_t i;                           //for iteration
 171     fP = new TArrayI(768);
 172     fN = new TArrayI(768);
 173
 174     fPtrack1 = new TArrayI(768);
 175     fPtrack2 = new TArrayI(768);
 176     fPtrack3 = new TArrayI(768);
 177
 178     fNtrack1 = new TArrayI(768);
 179     fNtrack2 = new TArrayI(768);
 180     fNtrack3 = new TArrayI(768);
 181
 182     for(i=0; i<kNStrips; i++) {
 183        (*fN)[i] = 0;
 184        (*fP)[i] = 0;
 185     } // end for i
 186
 187     for(i=0; i<fNhitsM; i++) HitToDigit(i);
 188
 189     ApplyCoupling();
 190     ApplyNoise();
 191
 192     for(i=0; i<fNInvalidP; i++) (*fP)[(*fInvalidP)[i]] = -20;
 193     for(i=0; i<fNInvalidN; i++) (*fN)[(*fInvalidN)[i]] = -20;
 194
 195     for(i=0; i<kNStrips; i++)
 196        if ((*fP)[i]>kTresholdP) AddDigit(i+1, (*fP)[i], kTRUE);
 197
 198     for(i=0; i<kNStrips; i++)
 199        if ((*fN)[i]>kTresholdN) AddDigit(i+1, (*fN)[i], kFALSE);
 200
 201     delete fN;
 202     delete fP;
 203
 204     delete fPtrack1;
 205     delete fPtrack2;
 206     delete fPtrack3;
 207
 208     delete fPtrack1;
 209     delete fPtrack2;
 210     delete fPtrack3;
 211
 212 }
 213
 214
 215
 216 void AliITSmoduleSSD::HitToDigit(Int_t hitNo) {
 217
 218     Int_t stripP, stripN, i;
 219     Float_t dsP, dsN;
 220     Float_t sP, sN;
 221     Float_t EP, EN;
 222     AliITShit *hit = (AliITShit*)((*fHitsM)[hitNo]);
 223     Float_t dZ = kZ/kSteps*1000, l;
 224
 225     if(hit->GetIonization()==0.0) return;
 226
 227     Float_t x =  hit->GetXG();
 228     Float_t y =  hit->GetYG();
 229
 230     Float_t dx = 0.0; //TMath::Tan(hit->fTheta)*kZ/kSteps;
 231     Float_t dy = 0.0; //TMath::Tan(hit->fPhi)*kZ/kSteps;
 232     l = sqrt(dZ*dZ + dx*dx *1000000);
 233
 234     x -= (kSteps/2 -1) * dx;
 235     y -= (kSteps/2 -1) * dy;
 236
 237     for (i=1; i<kSteps; i++) {
 238
 239         stripP = GetStripP(x, y);
 240         dsP = Get2StripP(x, y);
 241
 242         stripN = GetStripN(x, y);
 243         dsN = Get2StripN(x, y);
 244
 245         EP = gRandom->Landau(fGainP*l, l*10);
 246         EN = gRandom->Landau(fGainN*l, l*10);
 247
 248         sP = kSigmaP * sqrt(i);
 249         sN = kSigmaN * sqrt(kSteps-i);
 250
 251         sP = (i<3 && dsP>0.3 && dsP<0.7)? 0.02 : sP;
 252         sN = (i>7 && dsN>0.3 && dsN<0.7)? 0.02 : sN;
 253
 254         sP = (i==3 && dsP>0.4 && dsP<0.6)? 0.015 : sP;
 255         sN = (i==7 && dsN>0.4 && dsN<0.6)? 0.015 : sN;
 256
 257
 258         (*fP)[stripP-1]+=(Int_t)(EP*(F(-0.5-dsP,sP)-F(-1.5-dsP,sP)));
 259         (*fP)[stripP]  +=(Int_t)(EP*(F(0.5-dsP,sP)-F(-0.5-dsP,sP)));
 260         (*fP)[stripP+1]+=(Int_t)(EP*(F(1.5-dsP,sP)-F(0.5-dsP,sP)));
 261         (*fP)[stripP+2]+=(Int_t)(EP*(F(2.5-dsP,sP)-F(1.5-dsP,sP)));
 262
 263         (*fN)[stripN-1]+=(Int_t)(EN*(F(-0.5-dsN,sN)-F(-1.5-dsN,sN)));
 264         (*fN)[stripN]  +=(Int_t)(EN*(F(0.5-dsN,sN)-F(-0.5-dsN,sN)));
 265         (*fN)[stripN+1]+=(Int_t)(EN*(F(1.5-dsN,sN)-F(0.5-dsN,sN)));
 266         (*fN)[stripN+2]+=(Int_t)(EN*(F(2.5-dsN,sN)-F(1.5-dsN,sN)));
 267
 268         x += dx;
 269         y += dy;
 270     }
 271 }
 272
 273
 274 //____________________________________________________________________
 275 //
 276 //  Private Methods for Simulation
 277 //____________________________________________________________________
 278 //
 279
 280
 281
 282 void AliITSmoduleSSD::ApplyNoise() {
 283
 284     for(Int_t i = 0; i<kNStrips; i++) {
 285         (*fP)[i] += (Int_t)gRandom->Gaus(0,fSNRatioP);
 286         (*fN)[i] += (Int_t)gRandom->Gaus(0,fSNRatioN);
 287     }
 288 }
 289
 290 void AliITSmoduleSSD::ApplyCoupling() {
 291
 292     for(Int_t i = 1; i<kNStrips-1; i++) {
 293         (*fP)[i] += (Int_t)((*fP)[i-1]*fCouplingPL + (*fP)[i+1]*fCouplingPR);
 294         (*fN)[i] += (Int_t)((*fN)[i-1]*fCouplingNL + (*fN)[i+1]*fCouplingNR);
 295     }
 296 }
 297
 298
 299 //____________________________________________________________________
 300 //
 301 //  Private methods for geometry
 302 //____________________________________________________________________
 303 //
 304
 305
 306
 307 Int_t AliITSmoduleSSD::GetStripP(Float_t x, Float_t y) {
 308
 309     Float_t  X = x - y*kTan;
 310     Int_t strip = (Int_t)(X/kPitch);
 311     strip = (strip<0)? -1: strip;
 312     strip = (strip>kNStrips)? -1: strip;
 313     return strip;
 314 }
 315
 316 Int_t AliITSmoduleSSD::GetStripN(Float_t x, Float_t y) {
 317
 318     Float_t  X = x - kTan*(kY - y);
 319     Int_t strip = (Int_t)(X/kPitch);
 320     strip = (strip<0)? -1: strip;
 321     strip = (strip>kNStrips)? -1: strip;
 322     return strip;
 323
 324 }
 325
 326 Float_t AliITSmoduleSSD::Get2StripP(Float_t x, Float_t y) {
 327
 328     Int_t n = GetStripP(x,y);
 329     return (x - y*kTan) / kPitch - n;
 330 }
 331
 332 Float_t AliITSmoduleSSD::Get2StripN(Float_t x, Float_t y) {
 333
 334     Int_t n = GetStripN(x,y);
 335     return (x - kTan*(kY - y)) / kPitch - n;
 336 }
 337
 338
 339 Bool_t AliITSmoduleSSD::GetCrossing (Float_t &P, Float_t &N) {
 340
 341     P *= kPitch;
 342     N *= kPitch;
 343
 344     P = (kY * kTan + N + P)/2.0;         // x coordinate
 345     N = kY - (P-N)/kTan;                 // y coordinate
 346
 347     if (N<0 || N>kY) return kFALSE;
 348     if (P<0 || P>kX) return kFALSE;
 349     return kTRUE;
 350 }
 351
 352 //____________________________________________________________________
 353
 354
 355