ITS/AliITSmoduleSSD.cxx

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