ITS/AliITSClusterFinderSSD.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 #include <iostream.h>
  17 #include <TArrayI.h>
  18 #include "AliRun.h"
  19 #include "AliITS.h"
  20 #include "AliITSdigit.h"
  21 #include "AliITSRawCluster.h"
  22 #include "AliITSRecPoint.h"
  23 #include "AliITSMapA1.h"
  24 #include "AliITSClusterFinderSSD.h"
  25 #include "AliITSclusterSSD.h"
  26 #include "AliITSpackageSSD.h"
  27 #include "AliITSsegmentation.h"
  28 #include "AliITSgeom.h"
  29 #include "AliITSsegmentationSSD.h"
  30
  31 const Bool_t AliITSClusterFinderSSD::fgkSIDEP=kTRUE;
  32 const Bool_t AliITSClusterFinderSSD::fgkSIDEN=kFALSE;
  33 const Int_t debug=0;
  34
  35 ClassImp(AliITSClusterFinderSSD)
  36
  37 //______________________________________________________________________
  38 //
  39 //  Constructor
  40 //______________________________________________________________________
  41 //
  42
  43
  44 AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg,
  45                                                TClonesArray *digits){
  46 //Standard constructor
  47
  48     fSegmentation=seg;
  49     fDigits=digits;
  50
  51     fMap = new AliITSMapA1(fSegmentation,fDigits);
  52
  53     fITS=(AliITS*)gAlice->GetModule("ITS");
  54
  55     fClusterP =  new TClonesArray ("AliITSclusterSSD",200);
  56     fNClusterP =0;
  57
  58     fClusterN=  new TClonesArray ("AliITSclusterSSD",200);
  59     fNClusterN =0;
  60
  61     fPackages =  new TClonesArray ("AliITSpackageSSD",200);    //packages
  62     fNPackages = 0;
  63
  64     fDigitsIndexP      =  new TArrayI(300);
  65     fNDigitsP          =  0;
  66
  67     fDigitsIndexN      =  new TArrayI(300);
  68     fNDigitsN          =  0;
  69
  70     fPitch = fSegmentation->Dpx(0);
  71     fPNsignalRatio=7./8.;         // warning: hard-wired number
  72
  73 }
  74 //----------------------------------------------------------------------
  75 AliITSClusterFinderSSD::~AliITSClusterFinderSSD() {
  76 // Default destructor
  77
  78     delete fClusterP;
  79     delete fClusterN;
  80     delete fPackages;
  81     delete fDigitsIndexP;
  82     delete fDigitsIndexN;
  83     delete fMap;
  84 }
  85 //----------------------------------------------------------------------
  86 void AliITSClusterFinderSSD::InitReconstruction(){
  87 // initialization of the cluster finder
  88     register Int_t i; //iterator
  89
  90     for (i=0;i<fNClusterP;i++){
  91         fClusterP->RemoveAt(i);
  92     } // end for i
  93     fNClusterP  =0 ;
  94     for (i=0;i<fNClusterN;i++){
  95         fClusterN->RemoveAt(i);
  96     } // end for i
  97     fNClusterN=0;
  98
  99     for (i=0;i<fNPackages;i++){
 100         fPackages->RemoveAt(i);
 101     } // end for i
 102
 103     fNPackages = 0;
 104     fNDigitsP  = 0;
 105     fNDigitsN  = 0;
 106
 107     Float_t StereoP,StereoN;
 108     fSegmentation->Angles(StereoP,StereoN);
 109
 110     CalcStepFactor (StereoP,StereoN);
 111
 112     if (debug) cout<<"fSFF = "<<fSFF<<"  fSFB = "<<fSFB<<"\n";
 113 }
 114 //----------------------------------------------------------------------
 115 void AliITSClusterFinderSSD::FindRawClusters(Int_t module){
 116 // This function findes out all clusters belonging to one module
 117 // 1. Zeroes all space after previous module reconstruction
 118 // 2. Finds all neighbouring digits, create clusters
 119 // 3. If necesery, resolves for each group of neighbouring digits
 120 //    how many clusters creates it.
 121 // 4. Colculate the x and z coordinate
 122   Int_t lay, lad, detect;
 123   AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
 124   AliITSgeom *geom = aliITS->GetITSgeom();
 125   geom->GetModuleId(module,lay, lad, detect);
 126   if ( lay == 6 )((AliITSsegmentationSSD*)fSegmentation)->SetLayer(6);
 127   if ( lay == 5 )((AliITSsegmentationSSD*)fSegmentation)->SetLayer(5);
 128
 129   InitReconstruction();  //ad. 1
 130   fMap->FillMap();
 131   FillDigitsIndex();
 132   SortDigits();
 133   FindNeighbouringDigits(); //ad. 2
 134   //SeparateOverlappedClusters();  //ad. 3
 135   ClustersToPackages();  //ad. 4
 136   AliITSRecPoint rnew;
 137   fMap->ClearMap();
 138 }
 139 //----------------------------------------------------------------------
 140 void AliITSClusterFinderSSD::FindNeighbouringDigits(){
 141 //If there are any digits on this side, create 1st Cluster,
 142 // add to it this digit, and increment number of clusters
 143     register Int_t i;
 144
 145     if ((fNDigitsP>0 )  && (fNDigitsN > 0 )) {
 146
 147         Int_t currentstripNo;
 148         Int_t *dbuffer = new Int_t [300];   //buffer for strip numbers
 149         Int_t dnumber;    //curent number of digits in buffer
 150         TArrayI      &lDigitsIndexP = *fDigitsIndexP;
 151         TArrayI      &lDigitsIndexN = *fDigitsIndexN;
 152         TObjArray    &lDigits       = *(Digits());
 153         TClonesArray &lClusterP     = *fClusterP;
 154         TClonesArray &lClusterN     = *fClusterN;
 155
 156         //process P side
 157         dnumber = 1;
 158         dbuffer[0]=lDigitsIndexP[0];
 159         // If next digit is a neighbour of previous, adds to last cluster
 160         // this digit
 161         for (i=1; i<fNDigitsP; i++) {
 162             //reads new digit
 163             currentstripNo = ((AliITSdigitSSD*)lDigits[lDigitsIndexP[i]])->
 164                                                              GetStripNumber();
 165             //check if it is a neighbour of a previous one
 166             if((((AliITSdigitSSD*)lDigits[lDigitsIndexP[i-1]])->
 167                 GetStripNumber()) == (currentstripNo-1) ){
 168                 dbuffer[dnumber++]=lDigitsIndexP[i];
 169             }else{
 170                 //create a new one side cluster
 171                 new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,
 172                                                   dbuffer,Digits(),fgkSIDEP);
 173                 dbuffer[0]=lDigitsIndexP[i];
 174                 dnumber = 1;
 175             } // end if
 176         } // end loop over fNDigitsP
 177         new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,
 178                                                       Digits(),fgkSIDEP);
 179         //process N side
 180         //for comments, see above
 181         dnumber = 1;
 182         dbuffer[0]=lDigitsIndexN[0];
 183         // If next digit is a neighbour of previous, adds to last cluster
 184         // this digit
 185         for (i=1; i<fNDigitsN; i++) {
 186             currentstripNo = ((AliITSdigitSSD*)(lDigits[lDigitsIndexN[i]]))->
 187                                                             GetStripNumber();
 188             if ( (((AliITSdigitSSD*)lDigits[lDigitsIndexN[i-1]])->
 189                   GetStripNumber()) == (currentstripNo-1) ){
 190                 dbuffer[dnumber++]=lDigitsIndexN[i];
 191             }else{
 192                 new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,
 193                                                             Digits(),fgkSIDEN);
 194                 dbuffer[0]=lDigitsIndexN[i];
 195                 dnumber = 1;
 196             } // end if
 197         } // end loop over fNDigitsN
 198         new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,
 199                                                       Digits(),fgkSIDEN);
 200         delete [] dbuffer;
 201     } // end condition on  NDigits
 202
 203     if (debug) cout<<"\n Found clusters: fNClusterP = "<<fNClusterP<<
 204                    "  fNClusterN ="<<fNClusterN<<"\n";
 205 }
 206 //----------------------------------------------------------------------
 207 void AliITSClusterFinderSSD::SeparateOverlappedClusters(){
 208 // overlapped clusters separation
 209     register Int_t i; //iterator
 210     Float_t  factor=0.75;           // How many percent must be lower signal
 211                                     // on the middle one digit
 212                                     // from its neighbours
 213     Int_t    signal0;               //signal on strip before the current one
 214     Int_t    signal1;               //signal on the current one signal
 215     Int_t    signal2;               //signal on the strip after the current one
 216     TArrayI *splitlist;             //  List of splits
 217     Int_t    numerofsplits=0;       // number of splits
 218     Int_t    initPsize = fNClusterP;//initial size of the arrays
 219     Int_t    initNsize = fNClusterN;//we have to keep it because it will grow
 220                                     // in this function and it doasn't make
 221                                     // sense to pass through it again
 222
 223     splitlist = new TArrayI(300);
 224
 225     for (i=0;i<initPsize;i++){
 226         if((((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==1) continue;
 227         if((((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==2) continue;
 228         Int_t nj=(((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits()-1);
 229         for (Int_t j=1; j<nj; j++){
 230             signal1=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j);
 231             signal0=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j-1);
 232             signal2=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j+1);
 233             //if signal is less then factor*signal of its neighbours
 234             if (  (signal1<(factor*signal0)) && (signal1<(factor*signal2)) ){
 235                 (*splitlist)[numerofsplits++]=j;
 236             } // end if
 237         } // end loop over number of digits
 238           //split this cluster if necessary
 239         if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEP);
 240         numerofsplits=0;
 241
 242         //in signed places (splitlist)
 243     } // end loop over clusters on Pside
 244
 245     for (i=0;i<initNsize;i++) {
 246         if((((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==1) continue;
 247         if((((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==2) continue;
 248         Int_t nj=(((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits()-1);
 249         for (Int_t j=1; j<nj; j++){
 250             signal1=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j);
 251             signal0=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j-1);
 252             signal2=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j+1);
 253             //if signal is less then factor*signal of its neighbours
 254             if (  (signal1<(factor*signal0)) && (signal1<(factor*signal2)) )
 255                 (*splitlist)[numerofsplits++]=j;
 256         } // end loop over number of digits
 257         //split this cluster into more clusters
 258         if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEN);
 259         numerofsplits=0;                                                              //in signed places (splitlist)
 260     } // end loop over clusters on Nside
 261
 262     delete splitlist;
 263 }
 264 //----------------------------------------------------------------------
 265 void AliITSClusterFinderSSD::SplitCluster(TArrayI *list, Int_t nsplits,
 266                                           Int_t index, Bool_t side){
 267     //This function splits one side cluster into more clusters
 268     //number of splits is defined by "nsplits"
 269     //Place of splits are defined in the TArray "list"
 270     // For further optimisation: Replace this function by two
 271     // specialised ones (each for one side)
 272     // save one "if"
 273     //For comlete comments see AliITSclusterSSD::SplitCluster
 274     register Int_t i; //iterator
 275     AliITSclusterSSD* curentcluster;
 276     Int_t   *tmpdigits = new Int_t[100];
 277     Int_t    NN;
 278     // side true means P side
 279
 280     if (side) {
 281         curentcluster =((AliITSclusterSSD*)((*fClusterP)[index])) ;
 282         for (i = nsplits; i>0 ;i--) {
 283             NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
 284             new ((*fClusterP)[fNClusterP]) AliITSclusterSSD(NN,
 285                                                      tmpdigits,Digits(),side);
 286             ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
 287                 SetLeftNeighbour(kTRUE);
 288             //if left cluster had neighbour on the right before split
 289             //new should have it too
 290             if ( curentcluster->GetRightNeighbour() )
 291                 ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
 292                     SetRightNeighbour(kTRUE);
 293             else curentcluster->SetRightNeighbour(kTRUE);
 294             fNClusterP++;
 295         } // end loop over nplits
 296     } else {
 297         curentcluster =((AliITSclusterSSD*)((*fClusterN)[index]));
 298         for (i = nsplits; i>0 ;i--) {
 299             NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
 300             new ((*fClusterN)[fNClusterN]) AliITSclusterSSD(NN,
 301                                                      tmpdigits,Digits(),side);
 302             ((AliITSclusterSSD*)((*fClusterN)[fNClusterN]))->
 303                 SetRightNeighbour(kTRUE);
 304             if (curentcluster->GetRightNeighbour())
 305                 ( (AliITSclusterSSD*)( (*fClusterN)[fNClusterN]) )->
 306                     SetRightNeighbour(kTRUE);
 307             else curentcluster->SetRightNeighbour(kTRUE);
 308             fNClusterN++;
 309         } // end loop over nplits
 310     } // end if side
 311     delete []tmpdigits;
 312 }
 313 //----------------------------------------------------------------------
 314 Int_t AliITSClusterFinderSSD::SortDigitsP(Int_t start, Int_t end){
 315 // sort digits on the P side
 316     Int_t right;
 317     Int_t left;
 318     if (start != (end - 1) ){
 319         left=this->SortDigitsP(start,(start+end)/2);
 320         right=this->SortDigitsP((start+end)/2,end);
 321         return (left || right);
 322     }else{
 323         left = ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[start]]))->
 324                                                              GetStripNumber();
 325         right= ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[end]]))->
 326                                                              GetStripNumber();
 327         if( left > right ){
 328             Int_t tmp = (*fDigitsIndexP)[start];
 329             (*fDigitsIndexP)[start]=(*fDigitsIndexP)[end];
 330             (*fDigitsIndexP)[end]=tmp;
 331             return 1;
 332         } // end if
 333         else return 0;
 334     } // end if
 335 }
 336 //----------------------------------------------------------------------
 337 Int_t AliITSClusterFinderSSD::SortDigitsN(Int_t start, Int_t end){
 338 // sort digits on the N side
 339     Int_t right;
 340     Int_t left;
 341
 342     if (start != (end - 1)){
 343         left=this->SortDigitsN(start,(start+end)/2);
 344         right=this->SortDigitsN((start+end)/2,end);
 345         return (left || right);
 346     }else{
 347         left =((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[start]]))->
 348                                                              GetStripNumber();
 349         right=((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[end]]))->
 350                                                              GetStripNumber();
 351         if ( left > right ){
 352             Int_t tmp = (*fDigitsIndexN)[start];
 353             (*fDigitsIndexN)[start]=(*fDigitsIndexN)[end];
 354             (*fDigitsIndexN)[end]=tmp;
 355             return 1;
 356         }else return 0;
 357     } // end if
 358 }
 359 //----------------------------------------------------------------------
 360 void AliITSClusterFinderSSD::FillDigitsIndex(){
 361     //Fill the indexes of the clusters belonging to a given ITS module
 362     Int_t PNs=0, NNs=0;
 363     Int_t tmp,bit,k;
 364     Int_t N;
 365     Int_t i;
 366
 367     N = fDigits->GetEntriesFast();
 368
 369     Int_t* PSidx = new Int_t [N*sizeof(Int_t)];
 370     Int_t* NSidx = new Int_t [N*sizeof(Int_t)];
 371     if (fDigitsIndexP==NULL) fDigitsIndexP = new TArrayI(N);
 372     if (fDigitsIndexN==NULL) fDigitsIndexN = new TArrayI(N);
 373
 374     AliITSdigitSSD *dig;
 375
 376     for ( i = 0 ; i< N; i++ ) {
 377         dig = (AliITSdigitSSD*)GetDigit(i);
 378         if(dig->IsSideP()) {
 379             bit=1;
 380             tmp=dig->GetStripNumber();
 381             // I find this totally unnecessary - it's just a
 382             // CPU consuming double check
 383             for( k=0;k<PNs;k++){
 384                 if (tmp==PSidx[k]){
 385                     if (debug) cout<<"Such a digit exists \n";
 386                     bit=0;
 387                 } // end if
 388             } // end if
 389             // end comment
 390             if(bit) {
 391                 fDigitsIndexP->AddAt(i,fNDigitsP++);
 392                 PSidx[PNs++]=tmp;
 393             } // end if bit
 394         } else {
 395             bit=1;
 396             tmp=dig->GetStripNumber();
 397             // same as above
 398             for( k=0;k<NNs;k++){
 399                 if (tmp==NSidx[k]){
 400                     if (debug) cout<<"Such a digit exists \n";
 401                     bit=0;
 402                 } // end if
 403             } // end for k
 404             // end comment
 405             if (bit) {
 406                 fDigitsIndexN->AddAt(i,fNDigitsN++);
 407                 NSidx[NNs++] =tmp;
 408             } // end if bit
 409         } // end for dig->IsSideP()
 410     } // end for i
 411
 412     delete [] PSidx;
 413     delete [] NSidx;
 414
 415     if (debug) cout<<"Digits :  P = "<<fNDigitsP<<"   N = "<<fNDigitsN<<endl;
 416
 417 }
 418 //----------------------------------------------------------------------
 419 void AliITSClusterFinderSSD::SortDigits(){
 420 // sort digits
 421     Int_t i;
 422
 423     if(fNDigitsP>1)
 424         for (i=0;i<fNDigitsP-1;i++)
 425             if (SortDigitsP(0,(fNDigitsP-1-i))==0) break;
 426
 427     if(fNDigitsN>1)
 428         for (i=0;i<fNDigitsN-1;i++)
 429             if(SortDigitsN(0,(fNDigitsN-1-i))==0) break;
 430 }
 431 //----------------------------------------------------------------------
 432 void AliITSClusterFinderSSD::FillClIndexArrays(Int_t* arrayP, Int_t *arrayN){
 433 // fill cluster index array
 434     register Int_t i;
 435
 436     for (i=0; i<fNClusterP;i++){
 437         arrayP[i]=i;
 438     } // end for i
 439     for (i=0; i<fNClusterN;i++){
 440         arrayN[i]=i;
 441     } // end for i
 442 }
 443 //----------------------------------------------------------------------
 444 void AliITSClusterFinderSSD::SortClusters(Int_t* arrayP, Int_t *arrayN){
 445 // sort clusters
 446     Int_t i;
 447
 448     if(fNClusterP>1)
 449         for (i=0;i<fNClusterP-1;i++)
 450             if (SortClustersP(0,(fNClusterP-1),arrayP)==0)  break;
 451     if(fNClusterN>1)
 452         for (i=0;i<fNClusterN-1;i++)
 453             if (SortClustersN(0,(fNClusterN-1),arrayN)==0)  break;
 454 }
 455 //----------------------------------------------------------------------
 456 Int_t AliITSClusterFinderSSD::SortClustersP(Int_t start, Int_t end,
 457                                             Int_t *array){
 458 //Sort P side clusters
 459     Int_t right;
 460     Int_t left;
 461
 462     if (start != (end - 1) ) {
 463         left=this->SortClustersP(start,(start+end)/2,array);
 464         right=this->SortClustersP((start+end)/2,end,array);
 465         return (left || right);
 466     } else {
 467         left =((AliITSclusterSSD*)((*fClusterP)[array[start]]))->
 468             GetDigitStripNo(0);
 469         right=((AliITSclusterSSD*)((*fClusterP)[array[ end ]]))->
 470             GetDigitStripNo(0);
 471         if(left>right) {
 472             Int_t tmp = array[start];
 473             array[start]=array[end];
 474             array[end]=tmp;
 475             return 1;
 476         } else return 0;
 477     } // end for start
 478 }
 479 //-------------------------------------------------------
 480 Int_t AliITSClusterFinderSSD::SortClustersN(Int_t start, Int_t end,
 481                                             Int_t *array){
 482 //Sort N side clusters
 483     Int_t right;
 484     Int_t left;
 485
 486     if (start != (end - 1) ) {
 487         left=this->SortClustersN(start,(start+end)/2,array);
 488         right=this->SortClustersN((start+end)/2,end,array);
 489         return (left || right);
 490     } else {
 491         left =((AliITSclusterSSD*)((*fClusterN)[array[start]]))->
 492             GetDigitStripNo(0);
 493         right=((AliITSclusterSSD*)((*fClusterN)[array[ end ]]))->
 494             GetDigitStripNo(0);
 495         if( left > right) {
 496             Int_t tmp = array[start];
 497             array[start]=array[end];
 498             array[end]=tmp;
 499             return 1;
 500         } else return 0;
 501     } // end for start
 502 }
 503 //----------------------------------------------------------------------
 504 void AliITSClusterFinderSSD::ClustersToPackages(){
 505 // fill packages
 506   Int_t *oneSclP = new Int_t[fNClusterP]; //I want to have sorted 1 S clusters
 507   Int_t *oneSclN = new Int_t[fNClusterN]; //I can not sort it in TClonesArray
 508                                           //so, I create table of indexes and
 509                                           //sort it
 510                                           //I do not use TArrayI on purpose
 511                                           // MB: well, that's not true that one
 512                                           //cannot sort objects in TClonesArray
 513
 514   //AliITSpackageSSD *currentpkg;
 515   AliITSclusterSSD *currentP;
 516   AliITSclusterSSD *currentN;
 517   Int_t j1, j2;
 518
 519 //Fills in One Side Clusters Index Array
 520   FillClIndexArrays(oneSclP,oneSclN);
 521 //Sorts filled Arrays
 522   SortClusters(oneSclP,oneSclN);
 523
 524   fNPackages=1;
 525   new ((*fPackages)[0]) AliITSpackageSSD(fClusterP,fClusterN);
 526   //currentpkg = (AliITSpackageSSD*)((*fPackages)[0]);
 527
 528   // Take all pairs of recpoints x coordinates in both sides
 529   // to calculate z coordinates of the recpoints
 530   for (j1=0;j1<fNClusterP;j1++) {
 531       currentP = GetPSideCluster(oneSclP[j1]);
 532       Double_t xP = currentP->GetPosition();
 533       //Int_t NxP = currentP->GetNumOfDigits();
 534       Float_t signalP = currentP->GetTotalSignal();
 535     for (j2=0;j2<fNClusterN;j2++) {
 536       currentN = GetNSideCluster(oneSclN[j2]);
 537       Double_t xN = currentN->GetPosition();
 538       //Int_t NxN = currentN->GetNumOfDigits();
 539       Float_t signalN = currentN->GetTotalSignal();
 540       CreateNewRecPoint(xP,1,xN,1,signalP,signalN,currentP, currentN, 0.75);
 541
 542     }
 543   }
 544
 545    delete oneSclP;
 546    delete oneSclN;
 547
 548 }
 549
 550
 551 //------------------------------------------------------
 552 Bool_t AliITSClusterFinderSSD::
 553 CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
 554                   Float_t SigP,Float_t SigN,
 555                   AliITSclusterSSD *clusterP, AliITSclusterSSD *clusterN,
 556                   Stat_t prob)
 557 {
 558 // create the recpoints
 559   const Float_t kADCtoKeV = 2.16;
 560   // 50 ADC units -> 30000 e-h pairs; 1e-h pair -> 3.6e-3 KeV;
 561   // 1 ADC unit -> (30000/50)*3.6e-3 = 2.16 KeV
 562   const Float_t kconv = 1.0e-4;
 563
 564   const Float_t kRMSx = 20.0*kconv;
 565   const Float_t kRMSz = 800.0*kconv;
 566
 567   Int_t n=0;
 568   Int_t *tr;
 569   if (GetCrossing(P,N)) {
 570
 571     //GetCrossingError(dP,dN);
 572      AliITSRawClusterSSD cnew;
 573      Int_t nstripsP=clusterP->GetNumOfDigits();
 574      Int_t nstripsN=clusterN->GetNumOfDigits();
 575      Float_t signal = 0;
 576      Float_t dedx = 0;
 577
 578      if(SigP>SigN) {
 579        signal = SigP;
 580        dedx = SigP*kADCtoKeV;
 581      }else{
 582        signal = SigN;
 583        dedx = SigN*kADCtoKeV;
 584      }
 585
 586      Float_t signalCut = TMath::Abs((SigP-SigN)/signal);
 587
 588      cnew.fSignalP=SigP;
 589      cnew.fSignalN=SigN;
 590      cnew.fMultiplicity=nstripsP;
 591      cnew.fMultiplicityN=nstripsN;
 592      cnew.fQErr=signalCut;
 593
 594      //fITS->AddCluster(2,&cnew);
 595
 596      if(signalCut<0.18) fITS->AddCluster(2,&cnew);
 597      // the cut of the signals difference in P and N sides to
 598      // remove the "ghosts"
 599
 600      tr = (Int_t*) clusterP->GetTracks(n);
 601
 602      AliITSRecPoint rnew;
 603      rnew.SetX(P*kconv);
 604      rnew.SetZ(N*kconv);
 605      rnew.SetQ(signal);
 606      rnew.SetdEdX(dedx);
 607      rnew.SetSigmaX2( kRMSx* kRMSx);
 608      rnew.SetSigmaZ2( kRMSz* kRMSz);
 609      rnew.fTracks[0]=tr[0];
 610      rnew.fTracks[1]=tr[1];
 611      rnew.fTracks[2]=tr[2];
 612
 613      //fITS->AddRecPoint(rnew);
 614
 615      if(signalCut<0.18) fITS->AddRecPoint(rnew);
 616      // the cut of the signals difference in P and N sides to
 617      // remove the "ghosts"
 618
 619      return kTRUE;
 620   }
 621      return kFALSE;
 622 }
 623
 624
 625 //------------------------------------------------------
 626 void  AliITSClusterFinderSSD::CalcStepFactor(Float_t Psteo, Float_t Nsteo )
 627 {
 628 // calculate the step factor for matching clusters
 629
 630
 631   // 95 is the pitch, 4000 - dimension along z ?
 632
 633
 634   Float_t dz=fSegmentation->Dz();
 635
 636   fSFF = ( (Int_t)  (Psteo*dz/fPitch ) );// +1;
 637   fSFB = ( (Int_t)  (Nsteo*dz/fPitch ) );// +1;
 638
 639 }
 640
 641
 642 //-----------------------------------------------------------
 643 AliITSclusterSSD* AliITSClusterFinderSSD::GetPSideCluster(Int_t idx)
 644 {
 645 // get P side clusters
 646
 647
 648
 649
 650   if((idx<0)||(idx>=fNClusterP))
 651     {
 652       printf("AliITSClusterFinderSSD::GetPSideCluster  : index out of range\n");
 653       return 0;
 654     }
 655   else
 656     {
 657       return (AliITSclusterSSD*)((*fClusterP)[idx]);
 658     }
 659 }
 660
 661 //-------------------------------------------------------
 662 AliITSclusterSSD* AliITSClusterFinderSSD::GetNSideCluster(Int_t idx)
 663 {
 664 // get N side clusters
 665
 666   if((idx<0)||(idx>=fNClusterN))
 667     {
 668       printf("AliITSClusterFinderSSD::GetNSideCluster  : index out of range\n");
 669       return 0;
 670     }
 671   else
 672     {
 673       return (AliITSclusterSSD*)((*fClusterN)[idx]);
 674     }
 675 }
 676
 677 //--------------------------------------------------------
 678 AliITSclusterSSD* AliITSClusterFinderSSD::GetCluster(Int_t idx, Bool_t side)
 679 {
 680 // Get cluster
 681
 682   return (side) ? GetPSideCluster(idx) : GetNSideCluster(idx);
 683 }
 684
 685 //_______________________________________________________________________
 686
 687 Bool_t AliITSClusterFinderSSD::GetCrossing (Float_t &P, Float_t &N)
 688 {
 689 // get crossing
 690
 691   Float_t Dx = fSegmentation->Dx(); // detector size in x direction, microns
 692   Float_t Dz = fSegmentation->Dz(); // detector size in z direction, microns
 693
 694   Float_t xL; // x local coordinate
 695   Float_t zL; // z local coordinate
 696   Float_t x;  // x = xL + Dx/2
 697   Float_t z;  // z = zL + Dz/2
 698   Float_t xP; // x coordinate in the P side from the first P strip
 699   Float_t xN; // x coordinate in the N side from the first N strip
 700   Float_t StereoP,StereoN;
 701
 702   fSegmentation->Angles(StereoP,StereoN);
 703   fTanP=TMath::Tan(StereoP);
 704   fTanN=TMath::Tan(StereoN);
 705   Float_t kP = fTanP; // Tangent of 0.0075 mrad
 706   Float_t kN = fTanN; // Tangent of 0.0275 mrad
 707
 708     P *= fPitch;
 709     N *= fPitch;
 710     xP = N;      // change the mistake for the P/N
 711     xN = P;      // coordinates correspondence in this function
 712     x = xP + kP*(Dz*kN-xP+xN)/(kP+kN);
 713     z = (Dz*kN-xP+xN)/(kP+kN);
 714     xL = x - Dx/2;
 715     zL = z - Dz/2;
 716     P = xL;
 717     N = zL;
 718
 719     if(TMath::Abs(xL) > Dx/2 || TMath::Abs(zL) > Dz/2) return kFALSE;
 720     // Check that xL and zL are inside the detector for the
 721     // correspondent xP and xN coordinates
 722
 723     return kTRUE;
 724 }
 725
 726
 727 //_________________________________________________________________________
 728
 729 void AliITSClusterFinderSSD::GetCrossingError(Float_t& dP, Float_t& dN)
 730 {
 731 // get crossing error
 732
 733   Float_t dz, dx;
 734
 735   dz = TMath::Abs(( dP + dN )*fPitch/(fTanP + fTanN) );
 736   dx = fPitch*(TMath::Abs(dP*(1 - fTanP/(fTanP + fTanN))) +
 737                TMath::Abs(dN *fTanP/(fTanP + fTanN) ));
 738
 739   dN = dz;
 740   dP = dx;
 741 }
 742
 743
 744
 745
 746
 747
 748