ITS/Pixel.C

   1 // inserted you find the pixel routine: From a macro it is called like:
   2
   3 //    Int_t spdTriggerBit = CalculateFOTrigger(itsLoader,geom,hDigits,nFO);
   4
   5
   6 // spdTriggerBit is a bit array which can be queried like:
   7
   8 // if (spdTriggerBit & (1 << 1)) globalFO = kTRUE;
   9
  10 //The arguments hDigits and NFO are things that you don't need. The routine
  11 //CalculateFOTrigger uses anouther subroutine RequireZ10cm() which
  12 //calculates the VERTEX coincidence requirement.
  13
  14 //Don't hesitate to contact me in case of questions. My suggestion to you is
  15 //that you first only implement a simple version of the trigger (for example
  16 //the OR of all signals).
  17
  18
  19 //Best regards,
  20
  21 //Jan
  22
  23
  24
  25 Int_t CalculateFOTrigger( AliITSLoader *itsl, AliITSgeom* geom, TH1F* hDigits, Float_t& nFO)
  26 {
  27
  28   TObjArray *digDet = 0;
  29   digDet = new TObjArray(3);
  30
  31   Int_t startSPD = geom->GetStartSPD();
  32   Int_t lastSPD  = geom->GetLastSPD();
  33
  34   // Cut on Signal In the Pixel Detector
  35   treeD = itsl->TreeD();
  36   br = treeD->GetBranch("ITSDigitsSPD");
  37   br->SetAddress(&((*digDet)[0]));
  38   ((TClonesArray*)(digDet->At(0)))->Clear();
  39
  40   Int_t ndig = 0;
  41   Int_t ndigfo = 0;
  42
  43   Int_t singhitthreshold = 1; // single hit threshold
  44   Int_t threshold = 1;
  45
  46   const Int_t nlay =2;
  47   const Int_t nlad =240;
  48   const Int_t nstave=40;
  49   const Int_t ndet =4;
  50   const Int_t nchip =5;
  51   const Int_t ntotal = 1200;
  52
  53   Int_t ndigA[5];
  54   Int_t FOperlayer[2];
  55   Int_t FOperladder[240];
  56   Int_t FOperstave[40][2];
  57   Int_t FOperchip[ntotal];
  58   Int_t FOperChipinStave[20][40][2];
  59
  60   for (Int_t m=startSPD;m<lastSPD;m++) {
  61     FOperladder[m] = 0;
  62   }
  63
  64   for (Int_t k = 0;k<2;k++){
  65     FOperlayer[k] = 0;
  66     for (Int_t o=0;o<40;o++) {
  67       FOperstave[o][k] = 0;
  68       for (Int_t ich=0;ich<20;ich++) {
  69         FOperChipinStave[ich][o][k] = 0;
  70       }
  71     }
  72   }
  73
  74
  75   nFO=0.0;
  76
  77   Int_t mInStaveCounter = 0.;
  78
  79   Int_t checkStave = 0;
  80
  81
  82   for (m=startSPD;m<lastSPD;m++) {
  83
  84     treeD->GetEvent(m);
  85     digits = (TClonesArray*) (digDet->At(0)); // SPD only.
  86
  87
  88     Int_t lay,stav,det;  geom->GetModuleId(m,lay,stav,det);
  89
  90     ndig = digits->GetEntriesFast();
  91
  92     for(Int_t l = 0;l<5;l++){
  93       ndigA[l] =0 ;
  94     }
  95
  96     //
  97
  98     for(Int_t dig=0; dig<ndig; dig++){
  99       dp = (AliITSdigitSPD*) digits->At(dig);
 100       Int_t column = dp->GetCoord1();
 101       //   Int_t row = dp->GetCoord2();
 102       Int_t chip = Int_t(column/32.);
 103       ndigA[chip]++;
 104     }
 105
 106     if (checkStave !=stav){
 107       mInStaveCounter = 0;
 108     } else{
 109       mInStaveCounter += 1;
 110     }
 111
 112     // m 0,.., 239
 113     // stav 1,..,40
 114     // mInStave 0,..,3
 115     // chipInStave 0,..,19
 116
 117     //cout << "m " << m << " stav "  << stav  << " mInStave " <<
 118 mInStaveCounter << " " <<lay << endl;
 119
 120     for (Int_t ichip=0;ichip<5;ichip++){
 121       Int_t seq = (m*5+ichip);
 122       Int_t chipInStave = (mInStaveCounter *5) + ichip;
 123
 124       if (ndigA[ichip] >= 1) {
 125         FOperladder[m]++;
 126         FOperlayer[lay-1]++;
 127         FOperstave[stav-1][lay-1]++;
 128         //FOperHstave[hstav-1][lay-1]++;
 129         FOperChipinStave[chipInStave][stav-1][lay-1]++;
 130         nFO++;
 131      }
 132
 133     }
 134     // SIMPLE FO ---> ANY HIT TRIGGERS
 135     ndigfo += ndig;
 136     checkStave = stav;
 137
 138   }
 139
 140   //cout << 2 << endl;
 141
 142    Int_t bit1 = 0;
 143    Int_t upper_cut = 120;
 144
 145    hDigits->Fill(ndigfo);
 146
 147
 148    //   nFO  = ndigfo;
 149
 150
 151    //cout << nFO << endl;
 152
 153   if ( ndigfo >= singhitthreshold) {bit1 |= (1 << 1);}
 154
 155   //  if ( ndigfo <= upper_cut) {bit1 |= (1 << 10);}
 156
 157
 158
 159   if (FOperlayer[0] >= threshold && FOperlayer[1] >=threshold) {
 160      bit1 |= (1 << 2);
 161      if ( ndigfo <= upper_cut) {bit1 |= (1 << 10);}
 162   }
 163
 164
 165   // Sector coincidence
 166
 167   Int_t nsec = 0;
 168   Int_t finstav = 0;
 169
 170   // staves layer 1  1-20
 171   // staves layer 2: 0-39
 172
 173   //cout << 3 << endl;
 174
 175
 176    for (Int_t istav=1;istav<21;istav++){
 177      for (Int_t jstav = finstav; jstav<finstav+4;jstav++) {
 178        if ((FOperstave[istav-1][0] >= threshold) &&
 179            (FOperstave[jstav][1] >= threshold)) {
 180          bit1 |= (1 << 3);
 181
 182
 183      if (RequireZ10cm(FOperChipinStave,istav-1,jstav) == kTRUE) {
 184              //cout << (RequireZ(FOperChipinStave,istav-1,probe_stav) <<
 185 endl;
 186               bit1 |= (1 << 7);
 187      }
 188
 189        //   cout << " " << istav << " " << jstav << " " << endl;
 190        }
 191
 192      }
 193      if (TMath::Even(istav)) {
 194        finstav = jstav;
 195      }
 196
 197    }
 198    //cout << 4 << endl;
 199
 200    // half sector coincidence
 201
 202    Int_t finstav = 0;
 203     for (Int_t istav=1;istav<21;istav++){
 204      for (Int_t jstav = finstav; jstav<finstav+2;jstav++)
 205      {
 206        if (FOperstave[istav-1][0] >= threshold && FOperstave[jstav][1] >=
 207 threshold)
 208        {
 209          bit1 |= (1 << 4);
 210
 211            if (RequireZ10cm(FOperChipinStave,istav-1,jstav) == kTRUE) {
 212
 213              bit1 |= (1 << 8);
 214            }
 215        }
 216      }
 217
 218       finstav = jstav;
 219
 220     }
 221
 222
 223
 224
 225     Int_t finstav = 0;
 226
 227     for (Int_t istav=1;istav<21;istav++){
 228
 229       for (Int_t jstav = finstav-1; jstav<finstav+3;jstav++) {
 230
 231        Int_t probe_stav = jstav;
 232
 233        if (jstav == -1) probe_stav = 39;
 234        if (jstav == 40) probe_stav = 0;
 235
 236        if (FOperstave[istav-1][0] >= threshold &&
 237 FOperstave[probe_stav][1] >= threshold) {
 238          bit1 |= (1 << 5);
 239        }
 240
 241       }
 242
 243      finstav = jstav-1;
 244
 245     }
 246
 247
 248
 249
 250   // sliding window coincidence (symmetric): 1 (layer 1), 5 (layer 2)
 251
 252    Int_t finstav = 0;
 253
 254    for (Int_t istav=1;istav<21;istav++) {
 255      for (Int_t jstav = finstav-2; jstav<finstav+3;jstav++) {
 256
 257        // cout << 7 << endl;
 258
 259        probe_stav = jstav;
 260        if (jstav == -2) probe_stav = 38;
 261        if (jstav == -1) probe_stav = 39;
 262        if (jstav == 40) probe_stav = 0;
 263        if (jstav == 41) probe_stav = 1;
 264
 265        if ((FOperstave[istav-1][0] >= threshold) &&
 266            (FOperstave[probe_stav][1] >= threshold)) {
 267             bit1 |= (1 << 6);
 268             if (RequireZ10cm(FOperChipinStave,istav-1,probe_stav) ==
 269 kTRUE) {
 270                      bit1 |= (1 << 9);
 271             }
 272
 273
 274
 275        }
 276      }
 277      finstav = jstav-1;
 278    }
 279
 280   return bit1;
 281 }
 282
 283
 284
 285 Bool_t RequireZ10cm(Int_t FOperChipinStave[][40][2], Int_t stave1, Int_t
 286 stave2){
 287
 288 // z  sliding window
 289
 290   Bool_t zFlag = kFALSE;
 291
 292   Int_t threshold = 1;
 293   Int_t start1 = 1;
 294   Int_t start2 = 3;
 295   Int_t start3 = 6;
 296   Int_t start4 = 7;
 297   Int_t i = 1;
 298
 299    for (Int_t ic=0;ic<=19;ic++) {
 300
 301
 302        if(ic <= 5) {
 303
 304
 305          for (Int_t jc=0;jc<=ic-1;jc++) {
 306           if (FOperChipinStave[ic][stave1][0] >=threshold) {
 307            if (FOperChipinStave[jc][stave2][1] >= threshold){
 308              zFlag = kTRUE;
 309            }
 310            }
 311          }
 312        }
 313
 314        if(ic >=6 && ic <=8){
 315          for (jc=(2*start1-1);jc<=(2*start1-1)+5;jc++) {
 316            if (FOperChipinStave[ic][stave1][0] >=threshold) {
 317            if  (FOperChipinStave[jc][stave2][1] >= threshold){
 318              zFlag = kTRUE;
 319            }
 320            }
 321
 322          }
 323          start1++;
 324        }
 325
 326        if(ic >=9 && ic <=11){
 327
 328          for (jc=(2*start2);jc<=(2*start2+5);jc++) {
 329            if (FOperChipinStave[ic][stave1][0] >=threshold) {
 330            if  (FOperChipinStave[jc][stave2][1] >= threshold){
 331              zFlag = kTRUE;
 332            }
 333            }
 334          }
 335          start2++;
 336        }
 337
 338        if(ic >=12 && ic <=13){
 339
 340          for (jc=(2*start3-1);jc<=(2*start3-1)+5;jc++) {
 341            if (FOperChipinStave[ic][stave1][0] >=threshold) {
 342            if  (FOperChipinStave[jc][stave2][1] >= threshold){
 343              zFlag = kTRUE;
 344            }
 345            }
 346          }
 347          start3++;
 348        }
 349
 350
 351         if(ic >=14){
 352          for (jc=(2*start4);jc<=19;jc++) {
 353            if (FOperChipinStave[ic][stave1][0] >=threshold) {
 354            if  (FOperChipinStave[jc][stave2][1] >= threshold){
 355              zFlag = kTRUE;
 356            }
 357            }
 358          }
 359          start4++;
 360
 361         }
 362
 363    }
 364
 365    return zFlag;
 366
 367 }