ITS/UPGRADE/AliITSUpgradeClusterFinder.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 /* $Id$ */
  17
  18 ////////////////////////////////////////////////////////////////////////////
  19 //                                                                        //
  20 // Base Class used to find                                                //
  21 // the reconstructed points for ITS Upgrade                               //
  22 //                                                                        //
  23 ////////////////////////////////////////////////////////////////////////////
  24
  25 #include "AliITSUpgradeClusterFinder.h"
  26 #include "AliITSsegmentationUpgrade.h"
  27 #include "AliITSRecPoint.h"
  28 #include "AliITSDigitUpgrade.h"
  29 #include "AliITSRawStreamSPD.h"
  30 #include "AliLog.h"
  31 #include <string.h>
  32 #include <TObjString.h>
  33 #include <TClonesArray.h>
  34 #include <TTree.h>
  35 #include <TMath.h>
  36
  37 AliITSUpgradeClusterFinder::AliITSUpgradeClusterFinder() :
  38   fNhitsLeft(0),
  39   fOldModule(-1),
  40   fClusterTypeFlag(kTRUE),
  41   fFindClusterType(kFALSE),
  42   fClusterTypeOrigCol(0),
  43   fClusterTypeOrigRow(0),
  44   fColSum(0),fRowSum(0),
  45   fCharge(0),
  46   fClusterWidthMaxCol(0),
  47   fClusterWidthMinCol(0),
  48   fClusterWidthMaxRow(0),
  49   fClusterWidthMinRow(0),
  50   fChargeArray(0x0),
  51   fRecPoints(0x0)
  52 {
  53   //
  54   // Default constructor
  55   //
  56
  57   fChargeArray = new TObjArray();
  58   fRecPoints = new TClonesArray("AliITSRecPoint",3000);
  59   fTmpLabel[0]=-5;
  60   fTmpLabel[1]=-5;
  61   fTmpLabel[2]=-5;
  62   for(int il=0; il<10;il++) fLabels[il]=-5;
  63 }
  64
  65 //___________________________________________________________________________________
  66 AliITSUpgradeClusterFinder::~AliITSUpgradeClusterFinder() {
  67   if(fChargeArray) delete fChargeArray;
  68   if(fRecPoints) delete fRecPoints;
  69 }
  70 //___________________________________________________________________________________
  71 void AliITSUpgradeClusterFinder::StartEvent() {
  72   NewEvent();
  73 }
  74 //___________________________________________________________________________________
  75 Int_t AliITSUpgradeClusterFinder::ProcessHit(Int_t layer , UInt_t col, UInt_t row, UShort_t charge, Int_t label[3]) {
  76   //
  77   // Adds one pixel to the cluster
  78   //
  79
  80   if (layer>=6) {
  81     printf("ERROR: UpgradeClusterFinder::ProcessHit: Out of bounds: layer ,col,row, charge, label(0,1,2)= %d,%d,%d,%d,(%d,%d,%d)\n",layer ,col,row,charge,label[0],label[1],label[2]);
  82     return 1;
  83   }
  84
  85   // do we need to perform clustering on previous module?
  86   if (fOldModule!=-1 && (Int_t)layer!=fOldModule) {
  87     fChargeArray->AddLast(new TObjString(Form("%i %i %i %i %i %i",col,row,charge,label[0],label[1],label[2])));
  88     DoModuleClustering(fOldModule,charge);
  89     NewModule();
  90   }
  91   // add hit
  92   fChargeArray->AddLast(new TObjString(Form("%i %i %i %i %i %i",col,row,charge,label[0],label[1],label[2])));
  93
  94   fOldModule=layer;
  95   fHitCol[fNhitsLeft]=col;
  96   fHitRow[fNhitsLeft]=row;
  97   fHits[col][row]=kTRUE;
  98   fTmpLabel[0]=label[0];
  99   fTmpLabel[1]=label[1];
 100   fTmpLabel[2]=label[2];
 101   fNhitsLeft++;
 102   return 0;
 103 }
 104 //___________________________________________________________________________________
 105 void AliITSUpgradeClusterFinder::FinishEvent() {
 106   if (fNhitsLeft>0) {
 107     DoModuleClustering(fOldModule,fCharge);
 108   }
 109 }
 110 //___________________________________________________________________________________
 111 UInt_t AliITSUpgradeClusterFinder::GetClusterCount(Int_t layer) const {
 112   //
 113   // number of clusters in the layer
 114   //
 115   if (layer>=6) {
 116     printf("ERROR: UpgradeClusterFinder::GetClusterCount: Module out of bounds: layer = %d\n",layer);
 117     return 0;
 118   }
 119   return fClusterList[layer].GetNrEntries();
 120 }
 121 //___________________________________________________________________________________
 122 Float_t AliITSUpgradeClusterFinder::GetClusterMeanCol(Int_t layer, UInt_t index) {
 123   //
 124   // cluster position in terms of colums : mean column ID
 125   //
 126   if (layer>=6) {
 127     printf("ERROR: UpgradeClusterFinder::GetClusterMeanCol: Module out of bounds: layer = %d\n",layer);
 128     return 0;
 129   }
 130   return fClusterList[layer].GetColIndex(index);
 131 }
 132 //___________________________________________________________________________________
 133 Float_t AliITSUpgradeClusterFinder::GetClusterMeanRow(Int_t layer, UInt_t index) {
 134   //
 135   // cluster position in terms of rows : mean row ID
 136   //
 137   if (layer>=6) {
 138     printf("ERROR: UpgradeClusterFinder::GetClusterMeanRow: Module out of bounds: layer = %d\n",layer);
 139     return 0;
 140   }
 141   return fClusterList[layer].GetRowIndex(index);
 142 }
 143 //___________________________________________________________________________________
 144 UInt_t AliITSUpgradeClusterFinder::GetClusterSize(Int_t layer, UInt_t index) {
 145   //
 146   // total number of pixels of the cluster
 147   //
 148   if (layer>=6) {
 149     printf("ERROR: UpgradeClusterFinder::GetClusterSize: Module out of bounds: layer = %d\n",layer);
 150     return 0;
 151   }
 152   return fClusterList[layer].GetSizeIndex(index);
 153 }
 154 //___________________________________________________________________________________
 155 UInt_t AliITSUpgradeClusterFinder::GetClusterWidthZ(Int_t layer, UInt_t index) {
 156   //
 157   // # pixels of the cluster in Z direction
 158   //
 159
 160   if (layer>=6) {
 161     printf("ERROR: UpgradeClusterFinder::GetClusterWidthZ: Module out of bounds: layer = %d\n",layer);
 162     return 0;
 163   }
 164   return fClusterList[layer].GetWidthZIndex(index);
 165 }
 166 //___________________________________________________________________________________
 167 UInt_t AliITSUpgradeClusterFinder::GetClusterWidthPhi(Int_t layer, UInt_t index) {
 168   //
 169   // # pixels of the cluster in phi direction (XY plane)
 170   //
 171
 172     if (layer>=6) {
 173     printf("ERROR: UpgradeClusterFinder::GetClusterWidthPhi: Module out of bounds: layer = %d\n",layer);
 174     return 0;
 175   }
 176   return fClusterList[layer].GetWidthPhiIndex(index);
 177 }
 178 //___________________________________________________________________________________
 179 UInt_t AliITSUpgradeClusterFinder::GetClusterType(Int_t layer, UInt_t index) {
 180   //
 181   // cluster shape
 182   //
 183
 184   if (layer>=6) {
 185     printf("ERROR: UpgradeClusterFinder::GetClusterType: Module out of bounds: layer = %d\n",layer);
 186     return 0;
 187   }
 188   return fClusterList[layer].GetTypeIndex(index);
 189 }
 190 //___________________________________________________________________________________
 191 void AliITSUpgradeClusterFinder::PrintAllClusters() {
 192   //
 193   // printout of the cluster information
 194   //
 195
 196   for (Int_t layer=0; layer<6; layer++) {
 197     PrintClusters(layer);
 198   }
 199 }
 200 //___________________________________________________________________________________
 201 void AliITSUpgradeClusterFinder::PrintClusters(Int_t layer) {
 202   //
 203   // printout of the cluster information
 204   //
 205
 206   if (layer>=6) {
 207     printf("ERROR: UpgradeClusterFinder::PrintClusters: Out of bounds: layer = %d\n",layer);
 208     return;
 209   }
 210   if(fClusterList[layer].GetNrEntries()==0) {
 211     printf("no cluster list entries. Exiting... \n");
 212     return;
 213   }
 214   for (UInt_t c=0; c<fClusterList[layer].GetNrEntries(); c++) {
 215     printf("layer  %d , z,y=%f,%f , size=%d , type=%d labels=%d %d %d (label printout to be implemented...)\n",layer,fClusterList[layer].GetColIndex(c),fClusterList[layer].GetRowIndex(c),fClusterList[layer].GetSizeIndex(c),fClusterList[layer].GetTypeIndex(c),999,999,999);
 216   }
 217 }
 218 //___________________________________________________________________________________
 219 void AliITSUpgradeClusterFinder::NewEvent() {
 220   //
 221   // Cleaning up and preparation for the clustering procedure
 222   //
 223
 224   for (Int_t i=0; i<6; i++) {
 225     fClusterList[i].Clear();
 226   }
 227   NewModule();
 228   fOldModule = -1;
 229 }
 230 //___________________________________________________________________________________
 231 void AliITSUpgradeClusterFinder::NewModule() {
 232   //
 233   // Initializations
 234   //
 235
 236   fNhitsLeft=0;
 237   memset(fHits,0,999*999*sizeof(Bool_t));
 238 }
 239 //___________________________________________________________________________________
 240 Int_t AliITSUpgradeClusterFinder::DoModuleClustering(Int_t Layer, UShort_t charge) {
 241   //
 242   // Clustering and cluster-list container filling
 243   //
 244
 245   UInt_t maxHits=fNhitsLeft;
 246   for (UInt_t hit=0; hit<maxHits; hit++) {
 247     if (fClusterTypeFlag) fFindClusterType = kTRUE;
 248
 249     fClusterWidthMinCol = fHitCol[hit];
 250     fClusterWidthMinRow = fHitRow[hit];
 251     fClusterWidthMaxCol = fHitCol[hit];
 252     fClusterWidthMaxRow = fHitRow[hit];
 253
 254
 255     fClusterTypeOrigCol = fHitCol[hit];
 256     fClusterTypeOrigRow = fHitRow[hit];
 257     memset(fClusterTypeArea,0,kMAXCLUSTERTYPESIDEZ*kMAXCLUSTERTYPESIDEY*sizeof(Bool_t));
 258     fColSum=0;
 259     fRowSum=0;
 260     UInt_t size = FindClusterRecu(fClusterTypeOrigCol,fClusterTypeOrigRow,charge);
 261
 262     if(size==1){
 263       fCharge=GetPixelCharge(fColSum,fRowSum);
 264       AddLabelIndex(fColSum,fRowSum);
 265     }
 266     if (size>0) {
 267       if(size>1) AliInfo(Form("DoModuleClustering, size %i , labels :  %i  %i  %i \n",size,fLabels[0],fLabels[1],fLabels[2]));
 268       fClusterList[Layer].Insert((Float_t)fColSum/size, (Float_t)fRowSum/size, size, GetClusterWidthZ(), GetClusterWidthPhi(), GetClusterType(size), fCharge,fLabels);
 269       fCharge=0;
 270       for(Int_t i=0; i<10; i++) fLabels[i]=-5;
 271     }
 272     if (fNhitsLeft==0) break;
 273   }
 274   return 0;
 275 }
 276 //___________________________________________________________________________________
 277 UInt_t AliITSUpgradeClusterFinder::FindClusterRecu(Int_t col, Int_t row, UShort_t charge) {
 278   //
 279   // Pixel selection for the clusters (adjiacent pixels or pixels at the corners)
 280   //
 281
 282     if (col<0 || !fHits[col][row]) {return 0;}
 283   fHits[col][row]=kFALSE;
 284   fColSum+=col;
 285   fRowSum+=row;
 286   fNhitsLeft--;
 287   UInt_t size=1;
 288
 289   if (col>fClusterWidthMaxCol) fClusterWidthMaxCol = col;
 290   if (col<fClusterWidthMinCol) fClusterWidthMinCol = col;
 291   if (row>fClusterWidthMaxRow) fClusterWidthMaxRow = row;
 292   if (row<fClusterWidthMaxRow) fClusterWidthMinRow = row;
 293
 294   if (fFindClusterType) {
 295     Short_t diffz = fClusterTypeOrigCol - col;
 296     Short_t diffy = row - fClusterTypeOrigRow;
 297     if (diffz>=kMAXCLUSTERTYPESIDEZ || diffy>=kMAXCLUSTERTYPESIDEY) {
 298       fFindClusterType=kFALSE;
 299     }
 300     else {
 301       if (diffz==-1) {
 302         ShiftClusterTypeArea(kSHIFTRIGHT);
 303         diffz=0;
 304       }
 305       if (diffy==-1) {
 306         ShiftClusterTypeArea(kSHIFTDOWN);
 307         diffy=0;
 308       }
 309       fClusterTypeArea[diffz][diffy] = kTRUE;
 310     }
 311   }
 312   // straight:
 313   size+=FindClusterRecu(col  ,row-1,charge);
 314   fCharge+=GetPixelCharge(col,row-1);
 315   AddLabelIndex(col,row-1);
 316
 317   size+=FindClusterRecu(col-1,row  ,charge);
 318   fCharge+=GetPixelCharge(col-1,row);
 319   AddLabelIndex(col-1,row);
 320
 321   size+=FindClusterRecu(col  ,row+1,charge);
 322   fCharge+=GetPixelCharge(col,row+1);
 323   AddLabelIndex(col,row+1);
 324
 325   size+=FindClusterRecu(col+1,row ,charge );
 326   fCharge+=GetPixelCharge(col+1,row);
 327   AddLabelIndex(col+1,row);
 328
 329   // diagonal:
 330   size+=FindClusterRecu(col-1,row-1,charge);
 331   fCharge+=GetPixelCharge(col-1,row-1);
 332   AddLabelIndex(col-1,row-1);
 333
 334   size+=FindClusterRecu(col-1,row+1,charge);
 335   fCharge+=GetPixelCharge(col-1,row+1);
 336   AddLabelIndex(col-1,row+1);
 337
 338   size+=FindClusterRecu(col+1,row-1,charge);
 339   fCharge+=GetPixelCharge(col+1,row-1);
 340   AddLabelIndex(col+1,row-1);
 341
 342   size+=FindClusterRecu(col+1,row+1,charge);
 343   fCharge+=GetPixelCharge(col+1,row+1);
 344   AddLabelIndex(col+1,row+1);
 345
 346   return size;
 347 }
 348 //___________________________________________________________________________________
 349 void AliITSUpgradeClusterFinder::ShiftClusterTypeArea(UInt_t direction) {
 350   //
 351   // Cluster checks
 352   //
 353
 354   if (direction == kSHIFTRIGHT) {
 355     fClusterTypeOrigCol++;
 356     Bool_t tmpClusterTypeArea[kMAXCLUSTERTYPESIDEZ][kMAXCLUSTERTYPESIDEY];
 357     memset(tmpClusterTypeArea,0,kMAXCLUSTERTYPESIDEZ*kMAXCLUSTERTYPESIDEY*sizeof(Bool_t));
 358     for (UInt_t z=0; z<kMAXCLUSTERTYPESIDEZ; z++) {
 359       for (UInt_t y=0; y<kMAXCLUSTERTYPESIDEY; y++) {
 360         if (fClusterTypeArea[z][y]) {
 361           if (z==kMAXCLUSTERTYPESIDEZ-1) {
 362             fFindClusterType=kFALSE;
 363             return;
 364           }
 365           else {
 366             tmpClusterTypeArea[z+1][y] = kTRUE;
 367           }
 368         }
 369       }
 370     }
 371     memcpy(fClusterTypeArea,tmpClusterTypeArea,kMAXCLUSTERTYPESIDEZ*kMAXCLUSTERTYPESIDEY*sizeof(Bool_t));
 372   }
 373   else if (direction == kSHIFTDOWN) {
 374     fClusterTypeOrigRow--;
 375     Bool_t tmpClusterTypeArea[kMAXCLUSTERTYPESIDEZ][kMAXCLUSTERTYPESIDEY];
 376     memset(tmpClusterTypeArea,0,kMAXCLUSTERTYPESIDEZ*kMAXCLUSTERTYPESIDEY*sizeof(Bool_t));
 377     for (UInt_t z=0; z<kMAXCLUSTERTYPESIDEZ; z++) {
 378       for (UInt_t y=0; y<kMAXCLUSTERTYPESIDEY; y++) {
 379         if (fClusterTypeArea[z][y]) {
 380           if (y==kMAXCLUSTERTYPESIDEY-1) {
 381             fFindClusterType=kFALSE;
 382             return;
 383           }
 384           else {
 385             tmpClusterTypeArea[z][y+1] = kTRUE;
 386           }
 387         }
 388       }
 389     }
 390     memcpy(fClusterTypeArea,tmpClusterTypeArea,kMAXCLUSTERTYPESIDEZ*kMAXCLUSTERTYPESIDEY*sizeof(Bool_t));
 391   }
 392 }
 393 //___________________________________________________________________________________
 394 UShort_t AliITSUpgradeClusterFinder::GetCharge(Int_t layer,UInt_t index ) {
 395   return fClusterList[layer].GetCharge(index);
 396 }
 397 //___________________________________________________________________________________
 398 Int_t * AliITSUpgradeClusterFinder::GetLabels(Int_t layer,UInt_t index) {
 399   return fClusterList[layer].GetLabels(index);
 400 }
 401
 402 //___________________________________________________________________________________
 403 UInt_t AliITSUpgradeClusterFinder::GetClusterWidthZ() {
 404   return fClusterWidthMaxCol-fClusterWidthMinCol+1;
 405 }
 406 //___________________________________________________________________________________
 407 UInt_t AliITSUpgradeClusterFinder::GetClusterWidthPhi() {
 408   return fClusterWidthMaxRow-fClusterWidthMinRow+1;
 409 }
 410 //___________________________________________________________________________________
 411 UInt_t AliITSUpgradeClusterFinder::GetClusterType(UInt_t size) {
 412   //
 413   // Cluster shape
 414   //
 415   if (!fFindClusterType || size>4)
 416     return 0;
 417
 418   // X
 419   if (size==1)
 420     return 1;
 421
 422   // X
 423   // X
 424   if (size==2 &&
 425       fClusterTypeArea[0][1] &&
 426       fClusterTypeArea[0][0] )
 427     return 2;
 428
 429   // XX
 430   if (size==2 &&
 431       fClusterTypeArea[1][0] &&
 432       fClusterTypeArea[0][0] )
 433     return 3;
 434
 435   // X
 436   // X
 437   // X
 438   if (size==3 &&
 439       fClusterTypeArea[0][2] &&
 440       fClusterTypeArea[0][1] &&
 441       fClusterTypeArea[0][0] )
 442     return 4;
 443
 444   // XX
 445   // X      and equivalent...
 446   if (size==3 &&
 447       (
 448        (
 449         fClusterTypeArea[0][0] &&
 450         fClusterTypeArea[0][1] &&
 451         (fClusterTypeArea[1][1] ||
 452          fClusterTypeArea[1][0])
 453         )
 454        ||
 455        (
 456         fClusterTypeArea[1][0] &&
 457         fClusterTypeArea[1][1] &&
 458         (fClusterTypeArea[0][1] ||
 459          fClusterTypeArea[0][0])
 460         )
 461        )
 462       )
 463     return 5;
 464
 465   // XXX
 466   if (size==3 &&
 467       fClusterTypeArea[2][0] &&
 468       fClusterTypeArea[1][0] &&
 469       fClusterTypeArea[0][0] )
 470     return 6;
 471
 472   // X
 473   // X
 474   // X
 475   // X
 476   if (size==4 &&
 477       fClusterTypeArea[0][3] &&
 478       fClusterTypeArea[0][2] &&
 479       fClusterTypeArea[0][1] &&
 480       fClusterTypeArea[0][0] )
 481     return 7;
 482
 483   // XX
 484   // XX
 485   if (size==4 &&
 486       fClusterTypeArea[1][1] &&
 487       fClusterTypeArea[1][0] &&
 488       fClusterTypeArea[0][1] &&
 489       fClusterTypeArea[0][0] )
 490     return 8;
 491
 492   // XX
 493   // X
 494   // X     and equivalent...
 495   if (size==4 &&
 496       (
 497        (
 498         fClusterTypeArea[1][0] &&
 499         fClusterTypeArea[1][1] &&
 500         fClusterTypeArea[1][2] &&
 501         fClusterTypeArea[0][0]
 502         )
 503        ||
 504        (
 505         fClusterTypeArea[1][0] &&
 506         fClusterTypeArea[1][1] &&
 507         fClusterTypeArea[1][2] &&
 508         fClusterTypeArea[0][2]
 509         )
 510        ||
 511        (
 512         fClusterTypeArea[0][0] &&
 513         fClusterTypeArea[0][1] &&
 514         fClusterTypeArea[0][2] &&
 515         fClusterTypeArea[1][0]
 516         )
 517        ||
 518        (
 519         fClusterTypeArea[0][0] &&
 520         fClusterTypeArea[0][1] &&
 521         fClusterTypeArea[0][2] &&
 522         fClusterTypeArea[1][2]
 523         )
 524        )
 525       )
 526     return 9;
 527
 528   // X
 529   // XX
 530   // X     and equivalent...
 531   if (size==4 &&
 532       (
 533        (
 534         fClusterTypeArea[1][0] &&
 535         fClusterTypeArea[1][1] &&
 536         fClusterTypeArea[1][2] &&
 537         fClusterTypeArea[0][1]
 538         )
 539        ||
 540        (
 541         fClusterTypeArea[0][0] &&
 542         fClusterTypeArea[0][1] &&
 543         fClusterTypeArea[0][2] &&
 544         fClusterTypeArea[1][1]
 545         )
 546        )
 547       )
 548     return 10;
 549
 550   // X
 551   // XXX    and equivalent...
 552   if (size==4 &&
 553       (
 554        (
 555         fClusterTypeArea[2][0] &&
 556         fClusterTypeArea[2][1] &&
 557         fClusterTypeArea[1][1] &&
 558         fClusterTypeArea[0][1]
 559         )
 560        ||
 561        (
 562         fClusterTypeArea[0][0] &&
 563         fClusterTypeArea[2][1] &&
 564         fClusterTypeArea[1][1] &&
 565         fClusterTypeArea[0][1]
 566         )
 567        ||
 568        (
 569         fClusterTypeArea[2][1] &&
 570         fClusterTypeArea[2][0] &&
 571         fClusterTypeArea[1][0] &&
 572         fClusterTypeArea[0][0]
 573         )
 574        ||
 575        (
 576         fClusterTypeArea[0][1] &&
 577         fClusterTypeArea[2][0] &&
 578         fClusterTypeArea[1][0] &&
 579         fClusterTypeArea[0][0]
 580         )
 581        )
 582       )
 583     return 11;
 584
 585   //  X
 586   // XXX     and equivalent...
 587   if (size==4 &&
 588       (
 589        (
 590         fClusterTypeArea[1][0] &&
 591         fClusterTypeArea[2][1] &&
 592         fClusterTypeArea[1][1] &&
 593         fClusterTypeArea[0][1]
 594         )
 595        ||
 596        (
 597         fClusterTypeArea[1][1] &&
 598         fClusterTypeArea[2][0] &&
 599         fClusterTypeArea[1][0] &&
 600         fClusterTypeArea[0][0]
 601         )
 602        )
 603       )
 604     return 12;
 605
 606   //  X
 607   // X      and equivalent...
 608   if (size==2 &&
 609       (
 610        (
 611         fClusterTypeArea[0][0] &&
 612         fClusterTypeArea[1][1]
 613         )
 614        ||
 615        (
 616         fClusterTypeArea[1][0] &&
 617         fClusterTypeArea[0][1]
 618         )
 619        )
 620       )
 621     return 13;
 622
 623   //  X
 624   //  X
 625   // X      and equivalent...
 626   if (size==3 &&
 627       (
 628        (
 629         fClusterTypeArea[0][0] &&
 630         fClusterTypeArea[0][1] &&
 631         fClusterTypeArea[1][2]
 632         )
 633        ||
 634        (
 635         fClusterTypeArea[1][0] &&
 636         fClusterTypeArea[1][1] &&
 637         fClusterTypeArea[0][2]
 638         )
 639        ||
 640        (
 641         fClusterTypeArea[1][0] &&
 642         fClusterTypeArea[0][1] &&
 643         fClusterTypeArea[0][2]
 644         )
 645        ||
 646        (
 647         fClusterTypeArea[0][0] &&
 648         fClusterTypeArea[1][1] &&
 649         fClusterTypeArea[1][2]
 650         )
 651        )
 652       )
 653     return 14;
 654
 655   //  XX
 656   // X      and equivalent...
 657   if (size==3 &&
 658       (
 659        (
 660         fClusterTypeArea[0][0] &&
 661         fClusterTypeArea[1][0] &&
 662         fClusterTypeArea[2][1]
 663         )
 664        ||
 665        (
 666         fClusterTypeArea[0][1] &&
 667         fClusterTypeArea[1][1] &&
 668         fClusterTypeArea[2][0]
 669         )
 670        ||
 671        (
 672         fClusterTypeArea[0][0] &&
 673         fClusterTypeArea[1][1] &&
 674         fClusterTypeArea[2][1]
 675         )
 676        ||
 677        (
 678         fClusterTypeArea[0][1] &&
 679         fClusterTypeArea[1][0] &&
 680         fClusterTypeArea[2][0]
 681         )
 682        )
 683       )
 684     return 15;
 685
 686
 687
 688   return 0;
 689 }
 690
 691 //___________________________________________________________________________________________________
 692 UInt_t AliITSUpgradeClusterFinder::GetPixelCharge(UInt_t col, UInt_t row){
 693   //
 694   //...self explaining
 695   //
 696   Int_t q=0;
 697   for(Int_t entry =0; entry < fChargeArray->GetEntries(); entry++){
 698     TObjString *s = (TObjString*)fChargeArray->At(entry);
 699     TString name = s->GetString();
 700     if(!name.Contains(Form("%i %i",col,row)))
 701       continue;
 702     TObjArray *array = name.Tokenize(" ");
 703     TString charge = ((TObjString*)array->At(2))->String();
 704     TString rowS, colS;
 705     rowS = ((TObjString*)array->At(0))->String();
 706     colS = ((TObjString*)array->At(1))->String();
 707     delete array;
 708     q=charge.Atoi();
 709     return q;
 710
 711   }
 712   return q;
 713 }
 714 //____________________________________________________
 715
 716 void AliITSUpgradeClusterFinder::AddLabelIndex(UInt_t col, UInt_t row){
 717   //
 718   // Adding cluster labels
 719   //
 720
 721   for(Int_t entry =0; entry < fChargeArray->GetEntries(); entry++){
 722     TObjString *s = (TObjString*)fChargeArray->At(entry);
 723     TString name = s->GetString();
 724     if(!name.Contains(Form("%i %i",col,row)))
 725       continue;
 726     TObjArray *array = name.Tokenize(" ");
 727     TString index[3];
 728     Int_t label[3];
 729     for(Int_t i=0; i<3; i++){
 730       index[i]=((TObjString*)array->At(3+i))->String();
 731       label[i]=index[i].Atoi();
 732
 733     }
 734     SetLabels(label);
 735     delete array;
 736   }
 737 }
 738 //____________________________________________________
 739
 740 void AliITSUpgradeClusterFinder::SetLabels(Int_t label[3]){
 741   //
 742   //
 743    //Set the MC lables to the cluster
 744
 745   Bool_t isAssigned[3]={kFALSE,kFALSE,kFALSE};
 746
 747   for(Int_t i=0; i<10; i++){
 748     for(Int_t k=0; k<3; k++){
 749       if(fLabels[i]!=label[k] && label[k]>-1 && fLabels[i]<0) {
 750         if(!isAssigned[k]) {
 751           //  printf("assignign...\n.");
 752           //  printf("Assignign  fLabels[%i]=%i  label[%i]=%i \n",i,fLabels[i],k,label[k]);
 753           fLabels[i+k]=label[k];
 754           isAssigned[k]=kTRUE;
 755         }
 756       }
 757     }
 758   }
 759 }
 760
 761 //____________________________________________________
 762 void AliITSUpgradeClusterFinder::MakeRecPointBranch(TTree *treeR){
 763   //
 764   // Creating the branch (see AliITSUpgradeReconstructor::Reconstruct)
 765   //
 766
 767   if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
 768   if (treeR) {
 769     TBranch *branch = treeR->GetBranch("ITSRecPoints");
 770     if (branch) return ;
 771     else branch = treeR->Branch("ITSRecPoints",&fRecPoints);
 772   }
 773 }
 774 //____________________________________________________
 775 void AliITSUpgradeClusterFinder::SetRecPointTreeAddress(TTree *treeR){
 776   //
 777   // Addressing the branch (see AliITSUpgradeReconstructor::Reconstruct)
 778   //
 779   if(!treeR) return;
 780   if(!fRecPoints) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
 781
 782   TBranch *branch;
 783   branch = treeR->GetBranch("ITSRecPoints");
 784   if (branch) {
 785     branch->SetAddress(&fRecPoints);
 786   } else AliError("No RecPoint branch available");
 787
 788 }
 789 //____________________________________________________
 790 void AliITSUpgradeClusterFinder::DigitsToRecPoints(const TObjArray *digList) {
 791   //
 792   // the clusterization is performed here
 793   //
 794   AliITSsegmentationUpgrade *segmentation = new AliITSsegmentationUpgrade();
 795   AliITSRecPoint  recpnt;
 796   Int_t nClusters =0;
 797   TClonesArray &lrecp = *fRecPoints;
 798
 799   for(Int_t ilayer=0; ilayer < 6 ;ilayer ++){
 800     TClonesArray *pArrDig= (TClonesArray*)digList->At(ilayer);
 801     StartEvent();
 802     AliDebug(1,Form("layer %i : # digits %i",ilayer,pArrDig->GetEntries()));
 803     for(Int_t ientr =0; ientr < pArrDig->GetEntries() ; ientr++){
 804       AliITSDigitUpgrade *dig = (AliITSDigitUpgrade*)pArrDig->At(ientr);
 805       Int_t colz=dig->GetzPixelNumber();
 806       Int_t rowx=dig->GetxPixelNumber();
 807       Double_t hitcharge= (dig->GetNelectrons());
 808       ProcessHit(ilayer,colz, rowx,(Short_t)hitcharge,dig->GetTracks());
 809     }//ientr
 810     FinishEvent();
 811
 812     for(UInt_t nClu = 0; nClu <  GetClusterCount(ilayer); nClu++){
 813       UShort_t charge = GetCharge(ilayer, nClu);
 814       recpnt.SetQ(charge);
 815       recpnt.SetLayer(ilayer);
 816       Int_t *lab=GetLabels(ilayer,nClu);
 817       for(Int_t l=0; l<3; l++) {recpnt.SetLabel(lab[l],l);}
 818
 819       Bool_t check2;
 820       Double_t xcheck2=0.;
 821       Double_t ycheck2=0.;
 822       Double_t zcheck2=0.;
 823       Double_t xzl2[2]={0.,0.};
 824       Double_t xPixC2,zPixC2=0.;
 825
 826       xPixC2 = GetClusterMeanRow(ilayer, nClu);
 827       zPixC2 = GetClusterMeanCol(ilayer, nClu);
 828       xzl2[0] = xPixC2*(segmentation->GetCellSizeX(ilayer))+0.5*(segmentation-> GetCellSizeX(ilayer));
 829       xzl2[1] = zPixC2*(segmentation->GetCellSizeZ(ilayer))+0.5*(segmentation->GetCellSizeZ(ilayer))-(segmentation->GetHalfLength(ilayer));
 830       check2 = segmentation->DetToGlobal(ilayer,xzl2[0], xzl2[1],xcheck2,ycheck2,zcheck2);
 831       recpnt.SetType(GetClusterType(ilayer,nClu ));
 832       // recpnt.SetLocalCoord(xzl2[0],xzl2[1]); //temporary solution (no LocalToTrack Matrix)
 833       //from global to tracking system coordinate
 834       // global coordinate -> local coordinate getting alpha angle of the recpoint
 835       Float_t xclg = xcheck2;//upgrade clusters global coordinate ( ITS official: GetX tracking coordinate)
 836       Float_t yclg = ycheck2;
 837       Float_t zclg = zcheck2;
 838       Double_t phiclu1rad, phiclu1deg;
 839       phiclu1rad=TMath::ATan2(yclg,xclg);//cluster phi angle (rad)
 840       if (phiclu1rad<0) phiclu1rad+=TMath::TwoPi();//from 0 to 360
 841       else if (phiclu1rad>=TMath::TwoPi()) phiclu1rad-=TMath::TwoPi();//
 842
 843       phiclu1deg=180.*phiclu1rad/TMath::Pi();// in deg
 844       Int_t ladder;// virtual segmentation starting from the cluster phi
 845
 846       ladder=(Int_t)phiclu1deg/18;// in which ladder the cluster is
 847       Double_t alpha= (ladder*18.+9.)*TMath::Pi()/180.;//angle at the center of the ladder (rad)
 848
 849       //alpha rotation
 850       Float_t xclu1Tr = xclg*TMath::Cos(alpha)-yclg*TMath::Sin(alpha);
 851       Float_t yclu1 = yclg*TMath::Cos(alpha)+xclg*TMath::Sin(alpha);
 852       Float_t xclu1 = TMath::Sqrt(xclu1Tr*xclu1Tr+yclu1*yclu1);
 853       Float_t zclu1 = zclg;
 854       Double_t phiTrk= (phiclu1rad-alpha);// cluster angle in the rotated system (rad)
 855
 856       yclu1=xclu1*phiTrk; // tracking system coordinate: r*phi
 857       recpnt.SetX(0.);
 858       recpnt.SetY(yclu1);
 859       recpnt.SetZ(zclu1);
 860
 861       Double_t xsize, zsize;
 862       segmentation->GetSegmentation(ilayer,xsize, zsize);
 863       recpnt.SetSigmaY2(xsize/TMath::Sqrt(12)*xsize/TMath::Sqrt(12));
 864       recpnt.SetSigmaZ2(zsize/TMath::Sqrt(12)*zsize/TMath::Sqrt(12));
 865       new(lrecp[nClusters++]) AliITSRecPoint(recpnt);
 866       //Int_t idx = fRecPoints->GetEntries();
 867       AliInfo(Form("recpoint : Nelectrons %f (entry %i)",recpnt.GetQ(),fRecPoints->GetEntries()));
 868     }//cluster list entries
 869   }//ilayer
 870   if(segmentation) delete segmentation;
 871 }
 872