ITS/AliITSClusterFinderV2SSD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2007-2009, 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 //            Implementation of the ITS clusterer V2 class                //
  20 //                                                                        //
  21 //          Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch            //
  22 //          Last revision: 13-05-09 Enrico Fragiacomo                     //
  23 //                                  enrico.fragiacomo@ts.infn.it          //
  24 //                                                                        //
  25 ///////////////////////////////////////////////////////////////////////////
  26
  27 #include <Riostream.h>
  28 #include "AliLog.h"
  29
  30 #include "AliITSClusterFinderV2SSD.h"
  31 #include "AliITSRecPoint.h"
  32 #include "AliITSRecPointContainer.h"
  33 #include "AliITSgeomTGeo.h"
  34 #include "AliITSDetTypeRec.h"
  35 #include "AliRawReader.h"
  36 #include "AliITSRawStreamSSD.h"
  37 #include <TClonesArray.h>
  38 #include <TCollection.h>
  39 #include "AliITSdigitSSD.h"
  40 #include "AliITSReconstructor.h"
  41 #include "AliITSCalibrationSSD.h"
  42 #include "AliITSsegmentationSSD.h"
  43
  44 Short_t *AliITSClusterFinderV2SSD::fgPairs = 0x0;
  45 Int_t    AliITSClusterFinderV2SSD::fgPairsSize = 0;
  46 const Float_t  AliITSClusterFinderV2SSD::fgkThreshold = 5.;
  47
  48 const Float_t AliITSClusterFinderV2SSD::fgkCosmic2008StripShifts[16][9] =
  49   {{-0.35,-0.35,-0.35,-0.35,-0.35,-0.35,-0.35,-0.35,-0.35},  // DDL 512
  50    {-0.35,-0.35,-0.35,-0.35,-0.35,-0.35,-0.35,-0.35,-0.35},  // DDL 513
  51    {-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15},  // DDL 514
  52    {-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15},  // DDL 515
  53    { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00},  // DDL 516
  54    { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00},  // DDL 517
  55    {-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15},  // DDL 518
  56    {-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15},  // DDL 519
  57    {-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.25,-0.15},  // DDL 520
  58    {-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15,-0.15},  // DDL 521
  59    {-0.10,-0.10,-0.10,-0.40,-0.40,-0.40,-0.10,-0.10,-0.45},  // DDL 522
  60    {-0.10,-0.10,-0.10,-0.35,-0.35,-0.35,-0.10,-0.35,-0.50},  // DDL 523
  61    { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00},  // DDL 524
  62    { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00},  // DDL 525
  63    { 0.35, 0.35, 0.35, 0.35, 0.35, 0.35, 0.35, 0.35, 0.35},  // DDL 526
  64    { 0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45}}; // DDL 527
  65
  66 ClassImp(AliITSClusterFinderV2SSD)
  67
  68
  69 AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(AliITSDetTypeRec* dettyp):AliITSClusterFinder(dettyp),
  70                                                                              fLastSSD1(AliITSgeomTGeo::GetModuleIndex(6,1,1)-1)
  71 {
  72 //Default constructor
  73
  74 }
  75
  76 //______________________________________________________________________
  77 AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(const AliITSClusterFinderV2SSD &cf) : AliITSClusterFinder(cf),                                               fLastSSD1(cf.fLastSSD1)
  78 {
  79   // Copy constructor
  80 }
  81
  82 //______________________________________________________________________
  83 AliITSClusterFinderV2SSD& AliITSClusterFinderV2SSD::operator=(const AliITSClusterFinderV2SSD&  cf ){
  84   // Assignment operator
  85
  86   this->~AliITSClusterFinderV2SSD();
  87   new(this) AliITSClusterFinderV2SSD(cf);
  88   return *this;
  89 }
  90
  91
  92 void AliITSClusterFinderV2SSD::FindRawClusters(Int_t mod){
  93
  94   //Find clusters V2
  95   SetModule(mod);
  96   FindClustersSSD(fDigits);
  97
  98 }
  99
 100 void AliITSClusterFinderV2SSD::FindClustersSSD(TClonesArray *alldigits) {
 101   //------------------------------------------------------------
 102   // Actual SSD cluster finder
 103   //------------------------------------------------------------
 104   Int_t smaxall=alldigits->GetEntriesFast();
 105   if (smaxall==0) return;
 106
 107
 108   //---------------------------------------
 109   // load recoparam and calibration
 110   //
 111   static AliITSRecoParam *repa = NULL;
 112   if(!repa){
 113     repa = (AliITSRecoParam*) AliITSReconstructor::GetRecoParam();
 114     if(!repa){
 115       repa = AliITSRecoParam::GetHighFluxParam();
 116       AliWarning("Using default AliITSRecoParam class");
 117     }
 118   }
 119
 120   AliITSCalibrationSSD* cal = (AliITSCalibrationSSD*)GetResp(fModule);
 121   Float_t gain=0;
 122   Float_t noise=0;
 123   //---------------------------------------
 124
 125
 126   //------------------------------------
 127   // fill the digits array with zero-suppression condition
 128   // Signal is converted in KeV
 129   //
 130   TObjArray digits;
 131   for (Int_t i=0;i<smaxall; i++){
 132     AliITSdigitSSD *d=(AliITSdigitSSD*)alldigits->UncheckedAt(i);
 133
 134     if(d->IsSideP()) noise = cal->GetNoiseP(d->GetStripNumber());
 135     else noise = cal->GetNoiseN(d->GetStripNumber());
 136     if (d->GetSignal()<3.*noise) continue;
 137
 138     if(d->IsSideP()) gain = cal->GetGainP(d->GetStripNumber());
 139     else gain = cal->GetGainN(d->GetStripNumber());
 140
 141     Float_t q=gain*d->GetSignal(); //
 142     q=cal->ADCToKeV(q); // converts the charge in KeV from ADC units
 143     d->SetSignal(Int_t(q));
 144
 145     digits.AddLast(d);
 146   }
 147   Int_t smax = digits.GetEntriesFast();
 148   if (smax==0) return;
 149   //------------------------------------
 150
 151
 152   const Int_t kMax=1000;
 153   Int_t np=0, nn=0;
 154   Ali1Dcluster pos[kMax], neg[kMax];
 155   Float_t y=0., q=0., qmax=0.;
 156   Int_t lab[4]={-2,-2,-2,-2};
 157   Bool_t flag5 = 0;
 158
 159   /*
 160   cout<<"-----------------------------"<<endl;
 161   cout<<"this is module "<<fModule;
 162   cout<<endl;
 163   cout<<endl;
 164   */
 165
 166   //--------------------------------------------------------
 167   // start 1D-clustering from the first digit in the digits array
 168   //
 169   AliITSdigitSSD *d=(AliITSdigitSSD*)digits.UncheckedAt(0);
 170   q += d->GetSignal();
 171   y += d->GetCoord2()*d->GetSignal();
 172   qmax=d->GetSignal();
 173   lab[0]=d->GetTrack(0); lab[1]=d->GetTrack(1); lab[2]=d->GetTrack(2);
 174
 175   if(d->IsSideP()) {
 176     noise = cal->GetNoiseP(d->GetStripNumber());
 177     gain = cal->GetGainP(d->GetStripNumber());
 178   }
 179   else {
 180     noise = cal->GetNoiseN(d->GetStripNumber());
 181     gain = cal->GetGainN(d->GetStripNumber());
 182   }
 183   noise*=gain;
 184   noise=cal->ADCToKeV(noise); // converts noise in KeV from ADC units
 185
 186   if(qmax>fgkThreshold*noise) flag5=1; // seed for the cluster
 187
 188   /*
 189   cout<<d->GetSignal()<<" "<<noise<<" "<<flag5<<" "<<
 190     d->GetCoord1()<<" "<<d->GetCoord2()<<endl;
 191   */
 192
 193   Int_t curr=d->GetCoord2();
 194   Int_t flag=d->GetCoord1();
 195
 196   // Note: the first side which will be processed is supposed to be the
 197   // P-side which is neg
 198   Int_t *n=&nn;
 199   Ali1Dcluster *c=neg;
 200   if(flag) {n=&np; c=pos;} // in case we have only Nstrips (P was bad!)
 201
 202   Int_t nd=1;
 203   Int_t milab[10];
 204   for (Int_t ilab=0;ilab<10;ilab++){
 205     milab[ilab]=-2;
 206   }
 207   milab[0]=d->GetTrack(0); milab[1]=d->GetTrack(1); milab[2]=d->GetTrack(2);
 208
 209
 210   //----------------------------------------------------------
 211   // search for neighboring digits
 212   //
 213   for (Int_t s=1; s<smax; s++) {
 214       d=(AliITSdigitSSD*)digits.UncheckedAt(s);
 215       Int_t strip=d->GetCoord2();
 216
 217       // if digits is not a neighbour or side did not change
 218       // and at least one of the previous digits met the seed condition
 219       // then creates a new 1D cluster
 220       if ( ( ((strip-curr) > 1) || (flag!=d->GetCoord1()) ) ) {
 221
 222         if(flag5) {
 223           //cout<<"here1"<<endl;
 224          c[*n].SetY(y/q);
 225          c[*n].SetQ(q);
 226          c[*n].SetNd(nd);
 227          CheckLabels2(milab);
 228          c[*n].SetLabels(milab);
 229
 230          if(repa->GetUseUnfoldingInClusterFinderSSD()==kTRUE) {
 231            // Note: fUseUnfoldingInClusterFinderSSD=kFALSE by default in RecoParam
 232
 233            //Split suspiciously big cluster
 234            if (nd>4&&nd<25) {
 235              c[*n].SetY(y/q-0.25*nd);
 236              c[*n].SetQ(0.5*q);
 237              (*n)++;
 238              if (*n==kMax) {
 239                Error("FindClustersSSD","Too many 1D clusters !");
 240                return;
 241              }
 242              c[*n].SetY(y/q+0.25*nd);
 243              c[*n].SetQ(0.5*q);
 244              c[*n].SetNd(nd);
 245              c[*n].SetLabels(milab);
 246            }
 247
 248          } // unfolding is on
 249
 250          (*n)++;
 251          if (*n==kMax) {
 252           Error("FindClustersSSD","Too many 1D clusters !");
 253           return;
 254          }
 255
 256         } // flag5 set
 257
 258          // reset everything
 259          y=q=qmax=0.;
 260          nd=0;
 261          flag5=0;
 262          lab[0]=lab[1]=lab[2]=-2;
 263          for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
 264
 265          // if side changed from P to N, switch to pos 1D clusters
 266          // (if for some reason the side changed from N to P then do the opposite)
 267          if (flag!=d->GetCoord1())
 268            { if(!flag) {n=&np; c=pos;} else {n=&nn; c=neg;} }
 269
 270       } // end create new 1D cluster from previous neighboring digits
 271
 272       // continues adding digits to the previous cluster
 273       // or start a new one
 274       flag=d->GetCoord1();
 275       q += d->GetSignal();
 276       y += d->GetCoord2()*d->GetSignal();
 277       nd++;
 278
 279       if(d->IsSideP()) {
 280         noise = cal->GetNoiseP(d->GetStripNumber());
 281         gain = cal->GetGainP(d->GetStripNumber());
 282       }
 283       else {
 284         noise = cal->GetNoiseN(d->GetStripNumber());
 285         gain = cal->GetGainN(d->GetStripNumber());
 286       }
 287       noise*=gain;
 288       noise=cal->ADCToKeV(noise); // converts the charge in KeV from ADC units
 289
 290       if(d->GetSignal()>fgkThreshold*noise) flag5=1;
 291
 292       /*
 293   cout<<d->GetSignal()<<" "<<noise<<" "<<flag5<<" "<<
 294     d->GetCoord1()<<" "<<d->GetCoord2()<<endl;
 295       */
 296
 297       if (d->GetSignal()>qmax) {
 298          qmax=d->GetSignal();
 299          lab[0]=d->GetTrack(0); lab[1]=d->GetTrack(1); lab[2]=d->GetTrack(2);
 300       }
 301       for (Int_t ilab=0;ilab<10;ilab++) {
 302         if (d->GetTrack(ilab)>=0) AddLabel(milab, (d->GetTrack(ilab)));
 303       }
 304       curr=strip;
 305
 306
 307   } // loop over digits, no more digits in the digits array
 308
 309
 310   // add the last 1D cluster
 311   if(flag5) {
 312
 313     //  cout<<"here2"<<endl;
 314
 315     c[*n].SetY(y/q);
 316     c[*n].SetQ(q);
 317     c[*n].SetNd(nd);
 318     c[*n].SetLabels(lab);
 319
 320     if(repa->GetUseUnfoldingInClusterFinderSSD()==kTRUE) {
 321
 322       //Split suspiciously big cluster
 323       if (nd>4 && nd<25) {
 324         c[*n].SetY(y/q-0.25*nd);
 325         c[*n].SetQ(0.5*q);
 326         (*n)++;
 327         if (*n==kMax) {
 328           Error("FindClustersSSD","Too many 1D clusters !");
 329           return;
 330         }
 331         c[*n].SetY(y/q+0.25*nd);
 332         c[*n].SetQ(0.5*q);
 333         c[*n].SetNd(nd);
 334         c[*n].SetLabels(lab);
 335       }
 336     } // unfolding is on
 337
 338     (*n)++;
 339     if (*n==kMax) {
 340       Error("FindClustersSSD","Too many 1D clusters !");
 341       return;
 342     }
 343
 344   } // if flag5 last 1D cluster added
 345
 346
 347   //------------------------------------------------------
 348   // call FindClustersSSD to pair neg and pos 1D clusters
 349   // and create recpoints from the crosses
 350   // Note1: neg are Pside and pos are Nside!!
 351   // Note2: if there are no Pside digits nn=0 (bad strips!!) (same for Nside)
 352   //
 353   //  cout<<nn<<" Pside and "<<np<<" Nside clusters"<<endl;
 354
 355   AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
 356   if (nn*np > 0) {
 357     TClonesArray* clusters = rpc->UncheckedGetClusters(fModule);
 358     clusters->Clear();
 359     FindClustersSSD(neg, nn, pos, np, clusters);
 360     TIter itr(clusters);
 361     AliITSRecPoint *irp;
 362     while ((irp = (AliITSRecPoint*)itr.Next()))  fDetTypeRec->AddRecPoint(*irp);
 363   }
 364   //-----------------------------------------------------
 365 }
 366
 367
 368 void AliITSClusterFinderV2SSD::RawdataToClusters(AliRawReader* rawReader){
 369
 370     //------------------------------------------------------------
 371   // This function creates ITS clusters from raw data
 372   //------------------------------------------------------------
 373   rawReader->Reset();
 374   AliITSRawStreamSSD inputSSD(rawReader);
 375   FindClustersSSD(&inputSSD);
 376
 377 }
 378
 379
 380 void AliITSClusterFinderV2SSD::FindClustersSSD(AliITSRawStreamSSD* input)
 381 {
 382   //------------------------------------------------------------
 383   // Actual SSD cluster finder for raw data
 384   //------------------------------------------------------------
 385
 386   AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
 387   static AliITSRecoParam *repa = NULL;
 388   if(!repa){
 389     repa = (AliITSRecoParam*) AliITSReconstructor::GetRecoParam();
 390     if(!repa){
 391       repa = AliITSRecoParam::GetHighFluxParam();
 392       AliWarning("Using default AliITSRecoParam class");
 393     }
 394   }
 395   Int_t nClustersSSD = 0;
 396   const Int_t kNADC = 12;
 397   const Int_t kMaxADCClusters = 1000;
 398
 399   Int_t strips[kNADC][2][kMaxADCClusters][2]; // [ADC],[side],[istrip], [0]=istrip [1]=signal
 400   Int_t nStrips[kNADC][2];
 401
 402   for( int i=0; i<kNADC; i++ ){
 403     nStrips[i][0] = 0;
 404     nStrips[i][1] = 0;
 405   }
 406
 407   Int_t ddl = -1;
 408   Int_t ad = -1;
 409
 410   //*
 411   //* Loop over modules DDL+AD
 412   //*
 413
 414   while (kTRUE) {
 415
 416     bool next = input->Next();
 417
 418     //*
 419     //* Continue if corrupted input
 420     //*
 421
 422     if( (!next)&&(input->flag) ){
 423      AliWarning(Form("ITSClustersFinderSSD: Corrupted data: warning from RawReader"));
 424       continue;
 425     }
 426
 427     Int_t newDDL = input->GetDDL();
 428     Int_t newAD = input->GetAD();
 429
 430     if( next ){
 431       if( newDDL<0 || newDDL>15 ){
 432         AliWarning(Form("ITSClustersFinderSSD: Corrupted data: wrong DDL number (%d)",newDDL));
 433         continue;
 434       }
 435
 436       if( newAD<1 || newAD>9 ){
 437         AliWarning(Form("ITSClustersFinderSSD: Corrupted data: wrong AD number (%d)",newAD));
 438         continue;
 439       }
 440     }
 441
 442     bool newModule = ( !next || ddl!= newDDL || ad!=newAD );
 443
 444     if( newModule && ddl>=0 && ad>=0 ){
 445
 446       //*
 447       //* Reconstruct the previous block of 12 modules --- actual clusterfinder
 448       //*
 449       //cout<<endl;
 450       for( int adc = 0; adc<kNADC; adc++ ){
 451
 452         //* 1D clusterfinder
 453
 454         Ali1Dcluster clusters1D[2][kMaxADCClusters]; // per ADC, per side
 455         Int_t nClusters1D[2] = {0,0};
 456         //int nstat[2] = {0,0};
 457         fModule = AliITSRawStreamSSD::GetModuleNumber(ddl, (ad - 1)  * 12 + adc );
 458
 459         if( fModule<0 ){
 460 //        AliWarning(Form("ITSClustersFinderSSD: Corrupted data: module (ddl %d ad %d adc %d) not found in the map",ddl,ad,adc));
 461 //CM channels are always present even everything is suppressed
 462           continue;
 463         }
 464
 465         AliITSCalibrationSSD* cal = (AliITSCalibrationSSD*)fDetTypeRec->GetCalibrationModel(fModule);
 466         if( !cal ){
 467           AliWarning(Form("ITSClustersFinderSSD: No calibration found for module (ddl %d ad %d adc %d)",ddl,ad,adc));
 468           continue;
 469         }
 470
 471         Float_t dStrip = 0;
 472
 473         if( repa->GetUseCosmicRunShiftsSSD()) {  // Special condition for 2007/2008 cosmic data
 474           dStrip = fgkCosmic2008StripShifts[ddl][ad-1];
 475           if (TMath::Abs(dStrip) > 1.5){
 476             AliWarning(Form("Indexing error in Cosmic calibration: ddl = %d, dStrip %f\n",ddl,dStrip));
 477             dStrip = 0;
 478           }
 479         }
 480
 481         for( int side=0; side<=1; side++ ){
 482
 483           Int_t lab[3]={-2,-2,-2};
 484           Float_t q = 0.;
 485           Float_t y = 0.;
 486           Int_t nDigits = 0;
 487           Int_t ostrip = -2;
 488           Bool_t snFlag = 0;
 489
 490           Int_t n = nStrips[adc][side];
 491           for( int istr = 0; istr<n+1; istr++ ){
 492
 493             bool stripOK = 1;
 494             Int_t strip=0;
 495             Float_t signal=0.0, noise=0.0, gain=0.0;
 496
 497             if( istr<n ){
 498               strip = strips[adc][side][istr][0];
 499               signal = strips[adc][side][istr][1];
 500
 501               //cout<<"strip "<<adc<<" / "<<side<<": "<<strip<<endl;
 502
 503               if( cal ){
 504                 noise = side ?cal->GetNoiseN(strip) :cal->GetNoiseP(strip);
 505                 gain = side ?cal->GetGainN(strip) :cal->GetGainP(strip);
 506                 stripOK = ( noise>=1. && signal>=3.0*noise
 507                             //&& !cal->IsPChannelBad(strip)
 508                             );
 509               }
 510             } else stripOK = 0; // end of data
 511
 512             bool newCluster = ( (abs(strip-ostrip)!=1) || !stripOK );
 513
 514             if( newCluster ){
 515
 516               //* Store the previous cluster
 517
 518               if( nDigits>0 && q>0 && snFlag ){
 519
 520                 if (nClusters1D[side] >= kMaxADCClusters-1 ) {
 521                   AliWarning("HLT ClustersFinderSSD: Too many 1D clusters !");
 522                 }else {
 523
 524                   Ali1Dcluster &cluster = clusters1D[side][nClusters1D[side]++];
 525                   cluster.SetY( y / q + dStrip);
 526                   cluster.SetQ(q);
 527                   cluster.SetNd(nDigits);
 528                   cluster.SetLabels(lab);
 529                   //cout<<"cluster 1D side "<<side<<": y= "<<y<<" q= "<<q<<" d="<<dStrip<<" Y="<<cluster.GetY()<<endl;
 530                   //Split suspiciously big cluster
 531
 532                   if( repa->GetUseUnfoldingInClusterFinderSSD()
 533                       && nDigits > 4 && nDigits < 25
 534                       ){
 535                     cluster.SetY(y/q + dStrip - 0.25*nDigits);
 536                     cluster.SetQ(0.5*q);
 537                     Ali1Dcluster& cluster2 = clusters1D[side][nClusters1D[side]++];
 538                     cluster2.SetY(y/q + dStrip + 0.25*nDigits);
 539                     cluster2.SetQ(0.5*q);
 540                     cluster2.SetNd(nDigits);
 541                     cluster2.SetLabels(lab);
 542                   } // unfolding is on
 543                 }
 544               }
 545               y = q = 0.;
 546               nDigits = 0;
 547               snFlag = 0;
 548
 549             } //* End store the previous cluster
 550
 551             if( stripOK ){ // add new signal to the cluster
 552 //            signal = (Int_t) (signal * gain); // signal is corrected for gain
 553               if( signal>fgkThreshold*noise) snFlag = 1;
 554               signal = signal * gain; // signal is corrected for gain
 555 //            if( cal ) signal = (Int_t) cal->ADCToKeV( signal ); // signal is  converted in KeV
 556               if( cal ) signal = cal->ADCToKeV( signal ); // signal is  converted in KeV
 557               q += signal;        // add digit to current cluster
 558               y += strip * signal;
 559               nDigits++;
 560               //nstat[side]++;
 561               ostrip = strip;
 562
 563             }
 564           } //* end loop over strips
 565
 566         } //* end loop over ADC sides
 567
 568
 569         //* 2D clusterfinder
 570         if( nClusters1D[0] && nClusters1D[1] && fModule>=0 ){
 571            TClonesArray* clusters = rpc->UncheckedGetClusters(fModule);
 572                FindClustersSSD( clusters1D[0], nClusters1D[0], clusters1D[1], nClusters1D[1], clusters);
 573            Int_t nClustersn = clusters->GetEntriesFast();
 574                nClustersSSD += nClustersn;
 575         }
 576
 577         //cout<<"SG: "<<ddl<<" "<<ad<<" "<<adc<<": strips "<<nstat[0]<<"+"<<nstat[1]<<", clusters 1D= "<<nClusters1D[0]<<" + "<<nClusters1D[1]<<", 2D= "<<clusters.size()<<endl;
 578
 579       }//* end loop over adc
 580
 581     }//* end of reconstruction of previous block of 12 modules
 582
 583     if( newModule ){
 584
 585       //*
 586       //* Clean up arrays and set new module
 587       //*
 588
 589       for( int i=0; i<kNADC; i++ ){
 590         nStrips[i][0] = 0;
 591         nStrips[i][1] = 0;
 592       }
 593       ddl = newDDL;
 594       ad = newAD;
 595     }
 596
 597
 598     //*
 599     //* Exit main loop when there is no more input
 600     //*
 601
 602     if( !next ) break;
 603
 604     //*
 605     //* Fill the current strip information
 606     //*
 607
 608     Int_t adc = input->GetADC();
 609     if( adc<0 || adc>=kNADC+2 || (adc>5&&adc<8) ){
 610       AliWarning(Form("HLT ClustersFinderSSD: Corrupted data: wrong adc number (%d)", adc));
 611       continue;
 612     }
 613
 614     if( adc>7 ) adc-= 2; // shift ADC numbers 8-13 to 6-11
 615
 616     Bool_t side = input->GetSideFlag();
 617     Int_t strip = input->GetStrip();
 618     Int_t signal = input->GetSignal();
 619
 620
 621     //cout<<"SSD: "<<ddl<<" "<<ad<<" "<<adc<<" "<<side<<" "<<strip<<" : "<<signal<<endl;
 622
 623     if( strip>767 ){
 624       AliWarning(Form("HLT ClustersFinderSSD: Corrupted data: wrong strip number (ddl %d ad %d adc %d side %d, strip %d",
 625                       ddl, ad, adc, side,strip) );
 626       continue;
 627     }
 628     if (strip < 0) continue;
 629
 630     int &n = nStrips[adc][side];
 631     if( n >0 ){
 632       Int_t oldStrip = strips[adc][side][n-1][0];
 633
 634       if( strip==oldStrip ){
 635         AliWarning(Form("HLT ClustersFinderSSD: Corrupted data: duplicated signal: ddl %d ad %d adc %d, side %d, strip %d",
 636                         ddl, ad, adc, side, strip ));
 637         continue;
 638       }
 639     }
 640     strips[adc][side][n][0] = strip;
 641     strips[adc][side][n][1] = signal;
 642     n++;
 643
 644     //cout<<"SSD: "<<input->GetDDL()<<" "<<input->GetAD()<<" "
 645     //<<input->GetADC()<<" "<<input->GetSideFlag()<<" "<<((int)input->GetStrip())<<" "<<strip<<" : "<<input->GetSignal()<<endl;
 646
 647   } //* End main loop over the input
 648
 649   AliDebug(1,Form("found clusters in ITS SSD: %d", nClustersSSD));
 650 }
 651
 652
 653 void AliITSClusterFinderV2SSD::
 654 FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
 655                 Ali1Dcluster* pos, Int_t np,
 656                 TClonesArray *clusters) {
 657   //------------------------------------------------------------
 658   // Actual SSD cluster finder
 659   //------------------------------------------------------------
 660
 661   const TGeoHMatrix *mT2L=AliITSgeomTGeo::GetTracking2LocalMatrix(fModule);
 662
 663   //---------------------------------------
 664   // load recoparam
 665   //
 666   static AliITSRecoParam *repa = NULL;
 667   if(!repa){
 668     repa = (AliITSRecoParam*) AliITSReconstructor::GetRecoParam();
 669     if(!repa){
 670       repa = AliITSRecoParam::GetHighFluxParam();
 671       AliWarning("Using default AliITSRecoParam class");
 672     }
 673   }
 674
 675 //  TClonesArray &cl=*clusters;
 676
 677   AliITSsegmentationSSD *seg = dynamic_cast<AliITSsegmentationSSD*>(fDetTypeRec->GetSegmentationModel(2));
 678   if (fModule>fLastSSD1)
 679     seg->SetLayer(6);
 680   else
 681     seg->SetLayer(5);
 682
 683   Float_t hwSSD = seg->Dx()*1e-4/2;
 684   Float_t hlSSD = seg->Dz()*1e-4/2;
 685
 686   Int_t idet=fNdet[fModule];
 687   Int_t ncl=0;
 688
 689   //
 690   Int_t *cnegative = new Int_t[np];
 691   Int_t *cused1 = new Int_t[np];
 692   Int_t *negativepair = new Int_t[10*np];
 693   Int_t *cpositive = new Int_t[nn];
 694   Int_t *cused2 = new Int_t[nn];
 695   Int_t *positivepair = new Int_t[10*nn];
 696   for (Int_t i=0;i<np;i++) {cnegative[i]=0; cused1[i]=0;}
 697   for (Int_t i=0;i<nn;i++) {cpositive[i]=0; cused2[i]=0;}
 698   for (Int_t i=0;i<10*np;i++) {negativepair[i]=0;}
 699   for (Int_t i=0;i<10*nn;i++) {positivepair[i]=0;}
 700
 701   if ((np*nn) > fgPairsSize) {
 702
 703     if (fgPairs) delete [] fgPairs;
 704     fgPairsSize = 4*np*nn;
 705     fgPairs = new Short_t[fgPairsSize];
 706   }
 707   memset(fgPairs,0,sizeof(Short_t)*np*nn);
 708
 709   //
 710   // find available pairs
 711   //
 712   Int_t ncross = 0;
 713   for (Int_t i=0; i<np; i++) {
 714     Float_t yp=pos[i].GetY();
 715     if ( (pos[i].GetQ()>0) && (pos[i].GetQ()<3) ) continue;
 716     for (Int_t j=0; j<nn; j++) {
 717       if ( (neg[j].GetQ()>0) && (neg[j].GetQ()<3) ) continue;
 718       Float_t yn=neg[j].GetY();
 719
 720       Float_t xt, zt;
 721       seg->GetPadCxz(yn, yp, xt, zt);
 722       //cout<<yn<<" "<<yp<<" "<<xt<<" "<<zt<<endl;
 723
 724       if (TMath::Abs(xt)<hwSSD)
 725       if (TMath::Abs(zt)<hlSSD) {
 726         Int_t in = i*10+cnegative[i];
 727         Int_t ip = j*10+cpositive[j];
 728         if ((in < 10*np) && (ip < 10*nn)) {
 729           negativepair[in] =j;  //index
 730           positivepair[ip] =i;
 731           cnegative[i]++;  //counters
 732           cpositive[j]++;
 733           ncross++;
 734           fgPairs[i*nn+j]=100;
 735         }
 736         else
 737           AliError(Form("Index out of range: ip=%d, in=%d",ip,in));
 738       }
 739     }
 740   }
 741
 742   if (!ncross) {
 743     delete [] cnegative;
 744     delete [] cused1;
 745     delete [] negativepair;
 746     delete [] cpositive;
 747     delete [] cused2;
 748     delete [] positivepair;
 749     return;
 750   }
 751 //why not to allocate memorey here?  if(!clusters) clusters = new TClonesArray("AliITSRecPoint", ncross);
 752
 753   /* //
 754   // try to recover points out of but close to the module boundaries
 755   //
 756   for (Int_t i=0; i<np; i++) {
 757     Float_t yp=pos[i].GetY();
 758     if ( (pos[i].GetQ()>0) && (pos[i].GetQ()<3) ) continue;
 759     for (Int_t j=0; j<nn; j++) {
 760       if ( (neg[j].GetQ()>0) && (neg[j].GetQ()<3) ) continue;
 761       // if both 1Dclusters have an other cross continue
 762       if (cpositive[j]&&cnegative[i]) continue;
 763       Float_t yn=neg[j].GetY();
 764
 765       Float_t xt, zt;
 766       seg->GetPadCxz(yn, yp, xt, zt);
 767
 768       if (TMath::Abs(xt)<hwSSD+0.1)
 769       if (TMath::Abs(zt)<hlSSD+0.15) {
 770         // tag 1Dcluster (eventually will produce low quality recpoint)
 771         if (cnegative[i]==0) pos[i].SetNd(100);  // not available pair
 772         if (cpositive[j]==0) neg[j].SetNd(100);  // not available pair
 773         Int_t in = i*10+cnegative[i];
 774         Int_t ip = j*10+cpositive[j];
 775         if ((in < 10*np) && (ip < 10*nn)) {
 776           negativepair[in] =j;  //index
 777           positivepair[ip] =i;
 778           cnegative[i]++;  //counters
 779           cpositive[j]++;
 780           fgPairs[i*nn+j]=100;
 781         }
 782         else
 783           AliError(Form("Index out of range: ip=%d, in=%d",ip,in));
 784       }
 785     }
 786   }
 787   */
 788
 789   //
 790   Float_t lp[6];
 791   Int_t milab[10];
 792   Double_t ratio;
 793
 794
 795   if(repa->GetUseChargeMatchingInClusterFinderSSD()==kTRUE) {
 796
 797
 798     //
 799     // sign gold tracks
 800     //
 801     for (Int_t ip=0;ip<np;ip++){
 802       Float_t xbest=1000,zbest=1000,qbest=0;
 803       //
 804       // select gold clusters
 805       if ( (cnegative[ip]==1) && cpositive[negativepair[10*ip]]==1){
 806         Float_t yp=pos[ip].GetY();
 807         Int_t j = negativepair[10*ip];
 808
 809         if( (pos[ip].GetQ()==0) && (neg[j].GetQ() ==0) ) {
 810           // both bad, hence continue;
 811           // mark both as used (to avoid recover at the end)
 812           cused1[ip]++;
 813           cused2[j]++;
 814           continue;
 815         }
 816
 817         ratio = (pos[ip].GetQ()-neg[j].GetQ())/(pos[ip].GetQ()+neg[j].GetQ());
 818         //cout<<"ratio="<<ratio<<endl;
 819
 820         // charge matching (note that if posQ or negQ is 0 -> ratio=1 and the following condition is met
 821         if (TMath::Abs(ratio)>0.2) continue; // note: 0.2=3xsigma_ratio calculated in cosmics tests
 822
 823         //
 824         Float_t yn=neg[j].GetY();
 825
 826         Float_t xt, zt;
 827         seg->GetPadCxz(yn, yp, xt, zt);
 828
 829         xbest=xt; zbest=zt;
 830
 831
 832         qbest=0.5*(pos[ip].GetQ()+neg[j].GetQ());
 833         if( (pos[ip].GetQ()==0)||(neg[j].GetQ()==0)) qbest*=2; // in case of bad strips on one side keep all charge from the other one
 834
 835         {
 836           Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
 837           mT2L->MasterToLocal(loc,trk);
 838           lp[0]=trk[1];
 839           lp[1]=trk[2];
 840         }
 841         lp[4]=qbest;        //Q
 842         for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
 843         for (Int_t ilab=0;ilab<3;ilab++){
 844           milab[ilab] = pos[ip].GetLabel(ilab);
 845           milab[ilab+3] = neg[j].GetLabel(ilab);
 846         }
 847         //
 848         CheckLabels2(milab);
 849         milab[3]=(((ip<<10) + j)<<10) + idet; // pos|neg|det
 850         Int_t info[3] = {pos[ip].GetNd(),neg[j].GetNd(),fNlayer[fModule]};
 851
 852         lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
 853         lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
 854         // out-of-diagonal element of covariance matrix
 855         if( (info[0]==1) && (info[1]==1) ) lp[5]=-0.00012;
 856         else if ( (info[0]>1) && (info[1]>1) ) {
 857           lp[2]=2.63e-06;    // 0.0016*0.0016;  //SigmaY2
 858           lp[3]=0.0065;      // 0.08*0.08;   //SigmaZ2
 859           lp[5]=-6.48e-05;
 860         }
 861         else {
 862           lp[2]=4.80e-06;      // 0.00219*0.00219
 863           lp[3]=0.0093;        // 0.0964*0.0964;
 864           if (info[0]==1) {
 865             lp[5]=-0.00014;
 866           }
 867           else {
 868             lp[2]=2.79e-06;    // 0.0017*0.0017;
 869             lp[3]=0.00935;     // 0.967*0.967;
 870             lp[5]=-4.32e-05;
 871           }
 872         }
 873
 874         AliITSRecPoint * cl2;
 875     cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
 876
 877     cl2->SetChargeRatio(ratio);
 878     cl2->SetType(1);
 879     fgPairs[ip*nn+j]=1;
 880
 881     if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
 882       cl2->SetType(2);
 883       fgPairs[ip*nn+j]=2;
 884     }
 885
 886     if(pos[ip].GetQ()==0) cl2->SetType(3);
 887     if(neg[j].GetQ()==0) cl2->SetType(4);
 888
 889     cused1[ip]++;
 890     cused2[j]++;
 891
 892         ncl++;
 893       }
 894     }
 895
 896     for (Int_t ip=0;ip<np;ip++){
 897       Float_t xbest=1000,zbest=1000,qbest=0;
 898       //
 899       //
 900       // select "silber" cluster
 901       if ( cnegative[ip]==1 && cpositive[negativepair[10*ip]]==2){
 902         Int_t in  = negativepair[10*ip];
 903         Int_t ip2 = positivepair[10*in];
 904         if (ip2==ip) ip2 =  positivepair[10*in+1];
 905         Float_t pcharge = pos[ip].GetQ()+pos[ip2].GetQ();
 906
 907
 908
 909         ratio = (pcharge-neg[in].GetQ())/(pcharge+neg[in].GetQ());
 910         if ( (TMath::Abs(ratio)<0.2) && (pcharge!=0) ) {
 911           //if ( (TMath::Abs(pcharge-neg[in].GetQ())<30) && (pcharge!=0) ) { //
 912
 913           //
 914           // add first pair
 915           if ( (fgPairs[ip*nn+in]==100)&&(pos[ip].GetQ() ) ) {  //
 916
 917             Float_t yp=pos[ip].GetY();
 918             Float_t yn=neg[in].GetY();
 919
 920             Float_t xt, zt;
 921             seg->GetPadCxz(yn, yp, xt, zt);
 922
 923             xbest=xt; zbest=zt;
 924
 925             qbest =pos[ip].GetQ();
 926             Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
 927             mT2L->MasterToLocal(loc,trk);
 928             lp[0]=trk[1];
 929             lp[1]=trk[2];
 930
 931             lp[4]=qbest;        //Q
 932             for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
 933             for (Int_t ilab=0;ilab<3;ilab++){
 934               milab[ilab] = pos[ip].GetLabel(ilab);
 935               milab[ilab+3] = neg[in].GetLabel(ilab);
 936             }
 937             //
 938             CheckLabels2(milab);
 939             ratio = (pos[ip].GetQ()-neg[in].GetQ())/(pos[ip].GetQ()+neg[in].GetQ());
 940             milab[3]=(((ip<<10) + in)<<10) + idet; // pos|neg|det
 941             Int_t info[3] = {pos[ip].GetNd(),neg[in].GetNd(),fNlayer[fModule]};
 942
 943         lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
 944         lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
 945         // out-of-diagonal element of covariance matrix
 946         if( (info[0]==1) && (info[1]==1) ) lp[5]=-0.00012;
 947         else if ( (info[0]>1) && (info[1]>1) ) {
 948           lp[2]=2.63e-06;    // 0.0016*0.0016;  //SigmaY2
 949           lp[3]=0.0065;      // 0.08*0.08;   //SigmaZ2
 950           lp[5]=-6.48e-05;
 951         }
 952         else {
 953           lp[2]=4.80e-06;      // 0.00219*0.00219
 954           lp[3]=0.0093;        // 0.0964*0.0964;
 955           if (info[0]==1) {
 956             lp[5]=-0.00014;
 957           }
 958           else {
 959             lp[2]=2.79e-06;    // 0.0017*0.0017;
 960             lp[3]=0.00935;     // 0.967*0.967;
 961             lp[5]=-4.32e-05;
 962           }
 963         }
 964
 965         AliITSRecPoint * cl2;
 966               cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
 967               cl2->SetChargeRatio(ratio);
 968               cl2->SetType(5);
 969               fgPairs[ip*nn+in] = 5;
 970               if ((pos[ip].GetNd()+neg[in].GetNd())>6){ //multi cluster
 971                 cl2->SetType(6);
 972                 fgPairs[ip*nn+in] = 6;
 973               }
 974             ncl++;
 975           }
 976
 977
 978           //
 979           // add second pair
 980
 981           //    if (!(cused1[ip2] || cused2[in])){  //
 982           if ( (fgPairs[ip2*nn+in]==100) && (pos[ip2].GetQ()) ) {
 983
 984             Float_t yp=pos[ip2].GetY();
 985             Float_t yn=neg[in].GetY();
 986
 987             Float_t xt, zt;
 988             seg->GetPadCxz(yn, yp, xt, zt);
 989
 990             xbest=xt; zbest=zt;
 991
 992             qbest =pos[ip2].GetQ();
 993
 994             Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
 995             mT2L->MasterToLocal(loc,trk);
 996             lp[0]=trk[1];
 997             lp[1]=trk[2];
 998
 999             lp[4]=qbest;        //Q
1000             for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1001             for (Int_t ilab=0;ilab<3;ilab++){
1002               milab[ilab] = pos[ip2].GetLabel(ilab);
1003               milab[ilab+3] = neg[in].GetLabel(ilab);
1004             }
1005             //
1006             CheckLabels2(milab);
1007             ratio = (pos[ip2].GetQ()-neg[in].GetQ())/(pos[ip2].GetQ()+neg[in].GetQ());
1008             milab[3]=(((ip2<<10) + in)<<10) + idet; // pos|neg|det
1009             Int_t info[3] = {pos[ip2].GetNd(),neg[in].GetNd(),fNlayer[fModule]};
1010
1011         lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
1012         lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
1013         // out-of-diagonal element of covariance matrix
1014         if( (info[0]==1) && (info[1]==1) ) lp[5]=-0.00012;
1015         else if ( (info[0]>1) && (info[1]>1) ) {
1016           lp[2]=2.63e-06;    // 0.0016*0.0016;  //SigmaY2
1017           lp[3]=0.0065;      // 0.08*0.08;   //SigmaZ2
1018           lp[5]=-6.48e-05;
1019         }
1020         else {
1021           lp[2]=4.80e-06;      // 0.00219*0.00219
1022           lp[3]=0.0093;        // 0.0964*0.0964;
1023           if (info[0]==1) {
1024             lp[5]=-0.00014;
1025           }
1026           else {
1027             lp[2]=2.79e-06;    // 0.0017*0.0017;
1028             lp[3]=0.00935;     // 0.967*0.967;
1029             lp[5]=-4.32e-05;
1030           }
1031         }
1032
1033             AliITSRecPoint * cl2;
1034               cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1035
1036               cl2->SetChargeRatio(ratio);
1037               cl2->SetType(5);
1038               fgPairs[ip2*nn+in] =5;
1039               if ((pos[ip2].GetNd()+neg[in].GetNd())>6){ //multi cluster
1040                 cl2->SetType(6);
1041                 fgPairs[ip2*nn+in] =6;
1042               }
1043             ncl++;
1044           }
1045
1046           cused1[ip]++;
1047           cused1[ip2]++;
1048           cused2[in]++;
1049
1050         } // charge matching condition
1051
1052       } // 2 Pside cross 1 Nside
1053     } // loop over Pside clusters
1054
1055
1056
1057       //
1058     for (Int_t jn=0;jn<nn;jn++){
1059       if (cused2[jn]) continue;
1060       Float_t xbest=1000,zbest=1000,qbest=0;
1061       // select "silber" cluster
1062       if ( cpositive[jn]==1 && cnegative[positivepair[10*jn]]==2){
1063         Int_t ip  = positivepair[10*jn];
1064         Int_t jn2 = negativepair[10*ip];
1065         if (jn2==jn) jn2 =  negativepair[10*ip+1];
1066         Float_t pcharge = neg[jn].GetQ()+neg[jn2].GetQ();
1067         //
1068
1069
1070         ratio = (pcharge-pos[ip].GetQ())/(pcharge+pos[ip].GetQ());
1071         if ( (TMath::Abs(ratio)<0.2) && (pcharge!=0) ) {
1072
1073           /*
1074         if ( (TMath::Abs(pcharge-pos[ip].GetQ())<30) &&  // charge matching
1075              (pcharge!=0) ) { // reject combinations of bad strips
1076           */
1077
1078
1079           //
1080           // add first pair
1081           //    if (!(cused1[ip]||cused2[jn])){
1082           if ( (fgPairs[ip*nn+jn]==100) && (neg[jn].GetQ()) ) {  //
1083
1084             Float_t yn=neg[jn].GetY();
1085             Float_t yp=pos[ip].GetY();
1086
1087             Float_t xt, zt;
1088             seg->GetPadCxz(yn, yp, xt, zt);
1089
1090             xbest=xt; zbest=zt;
1091
1092             qbest =neg[jn].GetQ();
1093
1094             {
1095               Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
1096               mT2L->MasterToLocal(loc,trk);
1097               lp[0]=trk[1];
1098               lp[1]=trk[2];
1099           }
1100
1101           lp[4]=qbest;        //Q
1102           for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1103           for (Int_t ilab=0;ilab<3;ilab++){
1104             milab[ilab] = pos[ip].GetLabel(ilab);
1105             milab[ilab+3] = neg[jn].GetLabel(ilab);
1106           }
1107           //
1108           CheckLabels2(milab);
1109           ratio = (pos[ip].GetQ()-neg[jn].GetQ())/(pos[ip].GetQ()+neg[jn].GetQ());
1110           milab[3]=(((ip<<10) + jn)<<10) + idet; // pos|neg|det
1111           Int_t info[3] = {pos[ip].GetNd(),neg[jn].GetNd(),fNlayer[fModule]};
1112
1113         lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
1114         lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
1115         // out-of-diagonal element of covariance matrix
1116         if( (info[0]==1) && (info[1]==1) ) lp[5]=-0.00012;
1117         else if ( (info[0]>1) && (info[1]>1) ) {
1118           lp[2]=2.63e-06;    // 0.0016*0.0016;  //SigmaY2
1119           lp[3]=0.0065;      // 0.08*0.08;   //SigmaZ2
1120           lp[5]=-6.48e-05;
1121         }
1122         else {
1123           lp[2]=4.80e-06;      // 0.00219*0.00219
1124           lp[3]=0.0093;        // 0.0964*0.0964;
1125           if (info[0]==1) {
1126             lp[5]=-0.00014;
1127           }
1128           else {
1129             lp[2]=2.79e-06;    // 0.0017*0.0017;
1130             lp[3]=0.00935;     // 0.967*0.967;
1131             lp[5]=-4.32e-05;
1132           }
1133         }
1134
1135           AliITSRecPoint * cl2;
1136             cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1137
1138             cl2->SetChargeRatio(ratio);
1139             cl2->SetType(7);
1140             fgPairs[ip*nn+jn] =7;
1141             if ((pos[ip].GetNd()+neg[jn].GetNd())>6){ //multi cluster
1142               cl2->SetType(8);
1143               fgPairs[ip*nn+jn]=8;
1144             }
1145           ncl++;
1146         }
1147         //
1148         // add second pair
1149         //      if (!(cused1[ip]||cused2[jn2])){
1150         if ( (fgPairs[ip*nn+jn2]==100)&&(neg[jn2].GetQ() ) ) {  //
1151
1152           Float_t yn=neg[jn2].GetY();
1153           Double_t yp=pos[ip].GetY();
1154
1155           Float_t xt, zt;
1156           seg->GetPadCxz(yn, yp, xt, zt);
1157
1158           xbest=xt; zbest=zt;
1159
1160           qbest =neg[jn2].GetQ();
1161
1162           {
1163           Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
1164           mT2L->MasterToLocal(loc,trk);
1165           lp[0]=trk[1];
1166           lp[1]=trk[2];
1167           }
1168
1169           lp[4]=qbest;        //Q
1170           for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1171           for (Int_t ilab=0;ilab<3;ilab++){
1172             milab[ilab] = pos[ip].GetLabel(ilab);
1173             milab[ilab+3] = neg[jn2].GetLabel(ilab);
1174           }
1175           //
1176           CheckLabels2(milab);
1177           ratio = (pos[ip].GetQ()-neg[jn2].GetQ())/(pos[ip].GetQ()+neg[jn2].GetQ());
1178           milab[3]=(((ip<<10) + jn2)<<10) + idet; // pos|neg|det
1179           Int_t info[3] = {pos[ip].GetNd(),neg[jn2].GetNd(),fNlayer[fModule]};
1180
1181         lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
1182         lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
1183         // out-of-diagonal element of covariance matrix
1184         if( (info[0]==1) && (info[1]==1) ) lp[5]=-0.00012;
1185         else if ( (info[0]>1) && (info[1]>1) ) {
1186           lp[2]=2.63e-06;    // 0.0016*0.0016;  //SigmaY2
1187           lp[3]=0.0065;      // 0.08*0.08;   //SigmaZ2
1188           lp[5]=-6.48e-05;
1189         }
1190         else {
1191           lp[2]=4.80e-06;      // 0.00219*0.00219
1192           lp[3]=0.0093;        // 0.0964*0.0964;
1193           if (info[0]==1) {
1194             lp[5]=-0.00014;
1195           }
1196           else {
1197             lp[2]=2.79e-06;    // 0.0017*0.0017;
1198             lp[3]=0.00935;     // 0.967*0.967;
1199             lp[5]=-4.32e-05;
1200           }
1201         }
1202
1203           AliITSRecPoint * cl2;
1204             cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1205
1206
1207             cl2->SetChargeRatio(ratio);
1208             fgPairs[ip*nn+jn2]=7;
1209             cl2->SetType(7);
1210             if ((pos[ip].GetNd()+neg[jn2].GetNd())>6){ //multi cluster
1211               cl2->SetType(8);
1212               fgPairs[ip*nn+jn2]=8;
1213             }
1214           ncl++;
1215         }
1216         cused1[ip]++;
1217         cused2[jn]++;
1218         cused2[jn2]++;
1219
1220         } // charge matching condition
1221
1222       } // 2 Nside cross 1 Pside
1223     } // loop over Pside clusters
1224
1225
1226
1227     for (Int_t ip=0;ip<np;ip++){
1228
1229       if(cused1[ip]) continue;
1230
1231
1232       Float_t xbest=1000,zbest=1000,qbest=0;
1233       //
1234       // 2x2 clusters
1235       //
1236       if ( (cnegative[ip]==2) && cpositive[negativepair[10*ip]]==2){
1237         Float_t minchargediff =4.;
1238         Float_t minchargeratio =0.2;
1239
1240         Int_t j=-1;
1241         for (Int_t di=0;di<cnegative[ip];di++){
1242           Int_t   jc = negativepair[ip*10+di];
1243           Float_t chargedif = pos[ip].GetQ()-neg[jc].GetQ();
1244           ratio = (pos[ip].GetQ()-neg[jc].GetQ())/(pos[ip].GetQ()+neg[jc].GetQ());
1245           //if (TMath::Abs(chargedif)<minchargediff){
1246           if (TMath::Abs(ratio)<0.2){
1247             j =jc;
1248             minchargediff = TMath::Abs(chargedif);
1249             minchargeratio = TMath::Abs(ratio);
1250           }
1251         }
1252         if (j<0) continue;  // not proper cluster
1253
1254
1255         Int_t count =0;
1256         for (Int_t di=0;di<cnegative[ip];di++){
1257           Int_t   jc = negativepair[ip*10+di];
1258           Float_t chargedif = pos[ip].GetQ()-neg[jc].GetQ();
1259           if (TMath::Abs(chargedif)<minchargediff+3.) count++;
1260         }
1261         if (count>1) continue;  // more than one "proper" cluster for positive
1262         //
1263
1264         count =0;
1265         for (Int_t dj=0;dj<cpositive[j];dj++){
1266           Int_t   ic  = positivepair[j*10+dj];
1267           Float_t chargedif = pos[ic].GetQ()-neg[j].GetQ();
1268           if (TMath::Abs(chargedif)<minchargediff+3.) count++;
1269         }
1270         if (count>1) continue;  // more than one "proper" cluster for negative
1271
1272         Int_t jp = 0;
1273
1274         count =0;
1275         for (Int_t dj=0;dj<cnegative[jp];dj++){
1276           Int_t   ic = positivepair[jp*10+dj];
1277           Float_t chargedif = pos[ic].GetQ()-neg[jp].GetQ();
1278           if (TMath::Abs(chargedif)<minchargediff+4.) count++;
1279         }
1280         if (count>1) continue;
1281         if (fgPairs[ip*nn+j]<100) continue;
1282         //
1283
1284
1285
1286         //almost gold clusters
1287         Float_t yp=pos[ip].GetY();
1288         Float_t yn=neg[j].GetY();
1289         Float_t xt, zt;
1290         seg->GetPadCxz(yn, yp, xt, zt);
1291         xbest=xt; zbest=zt;
1292         qbest=0.5*(pos[ip].GetQ()+neg[j].GetQ());
1293         {
1294           Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
1295           mT2L->MasterToLocal(loc,trk);
1296           lp[0]=trk[1];
1297           lp[1]=trk[2];
1298         }
1299         lp[4]=qbest;        //Q
1300         for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1301         for (Int_t ilab=0;ilab<3;ilab++){
1302           milab[ilab] = pos[ip].GetLabel(ilab);
1303           milab[ilab+3] = neg[j].GetLabel(ilab);
1304         }
1305         //
1306         CheckLabels2(milab);
1307         if ((neg[j].GetQ()==0)&&(pos[ip].GetQ()==0)) continue; // reject crosses of bad strips!!
1308         ratio = (pos[ip].GetQ()-neg[j].GetQ())/(pos[ip].GetQ()+neg[j].GetQ());
1309         milab[3]=(((ip<<10) + j)<<10) + idet; // pos|neg|det
1310         Int_t info[3] = {pos[ip].GetNd(),neg[j].GetNd(),fNlayer[fModule]};
1311
1312         lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
1313         lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
1314         // out-of-diagonal element of covariance matrix
1315         if( (info[0]==1) && (info[1]==1) ) lp[5]=-0.00012;
1316         else if ( (info[0]>1) && (info[1]>1) ) {
1317           lp[2]=2.63e-06;    // 0.0016*0.0016;  //SigmaY2
1318           lp[3]=0.0065;      // 0.08*0.08;   //SigmaZ2
1319           lp[5]=-6.48e-05;
1320         }
1321         else {
1322           lp[2]=4.80e-06;      // 0.00219*0.00219
1323           lp[3]=0.0093;        // 0.0964*0.0964;
1324           if (info[0]==1) {
1325             lp[5]=-0.00014;
1326           }
1327           else {
1328             lp[2]=2.79e-06;    // 0.0017*0.0017;
1329             lp[3]=0.00935;     // 0.967*0.967;
1330             lp[5]=-4.32e-05;
1331           }
1332         }
1333
1334         AliITSRecPoint * cl2;
1335           cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1336
1337           cl2->SetChargeRatio(ratio);
1338           cl2->SetType(10);
1339           fgPairs[ip*nn+j]=10;
1340           if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
1341             cl2->SetType(11);
1342             fgPairs[ip*nn+j]=11;
1343           }
1344           cused1[ip]++;
1345           cused2[j]++;
1346         ncl++;
1347
1348       } // 2X2
1349     } // loop over Pside 1Dclusters
1350
1351
1352
1353     for (Int_t ip=0;ip<np;ip++){
1354
1355       if(cused1[ip]) continue;
1356
1357
1358       Float_t xbest=1000,zbest=1000,qbest=0;
1359       //
1360       // manyxmany clusters
1361       //
1362       if ( (cnegative[ip]<5) && cpositive[negativepair[10*ip]]<5){
1363         Float_t minchargediff =4.;
1364         Int_t j=-1;
1365         for (Int_t di=0;di<cnegative[ip];di++){
1366           Int_t   jc = negativepair[ip*10+di];
1367           Float_t chargedif = pos[ip].GetQ()-neg[jc].GetQ();
1368           if (TMath::Abs(chargedif)<minchargediff){
1369             j =jc;
1370             minchargediff = TMath::Abs(chargedif);
1371           }
1372         }
1373         if (j<0) continue;  // not proper cluster
1374
1375         Int_t count =0;
1376         for (Int_t di=0;di<cnegative[ip];di++){
1377           Int_t   jc = negativepair[ip*10+di];
1378           Float_t chargedif = pos[ip].GetQ()-neg[jc].GetQ();
1379           if (TMath::Abs(chargedif)<minchargediff+3.) count++;
1380         }
1381         if (count>1) continue;  // more than one "proper" cluster for positive
1382         //
1383
1384         count =0;
1385         for (Int_t dj=0;dj<cpositive[j];dj++){
1386           Int_t   ic  = positivepair[j*10+dj];
1387           Float_t chargedif = pos[ic].GetQ()-neg[j].GetQ();
1388           if (TMath::Abs(chargedif)<minchargediff+3.) count++;
1389         }
1390         if (count>1) continue;  // more than one "proper" cluster for negative
1391
1392         Int_t jp = 0;
1393
1394         count =0;
1395         for (Int_t dj=0;dj<cnegative[jp];dj++){
1396           Int_t   ic = positivepair[jp*10+dj];
1397           Float_t chargedif = pos[ic].GetQ()-neg[jp].GetQ();
1398           if (TMath::Abs(chargedif)<minchargediff+4.) count++;
1399         }
1400         if (count>1) continue;
1401         if (fgPairs[ip*nn+j]<100) continue;
1402         //
1403
1404         //almost gold clusters
1405         Float_t yp=pos[ip].GetY();
1406         Float_t yn=neg[j].GetY();
1407
1408
1409         Float_t xt, zt;
1410         seg->GetPadCxz(yn, yp, xt, zt);
1411
1412         xbest=xt; zbest=zt;
1413
1414         qbest=0.5*(pos[ip].GetQ()+neg[j].GetQ());
1415
1416         {
1417           Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
1418           mT2L->MasterToLocal(loc,trk);
1419           lp[0]=trk[1];
1420           lp[1]=trk[2];
1421         }
1422         lp[4]=qbest;        //Q
1423         for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1424         for (Int_t ilab=0;ilab<3;ilab++){
1425           milab[ilab] = pos[ip].GetLabel(ilab);
1426           milab[ilab+3] = neg[j].GetLabel(ilab);
1427         }
1428         //
1429         CheckLabels2(milab);
1430         if ((neg[j].GetQ()==0)&&(pos[ip].GetQ()==0)) continue; // reject crosses of bad strips!!
1431         ratio = (pos[ip].GetQ()-neg[j].GetQ())/(pos[ip].GetQ()+neg[j].GetQ());
1432         milab[3]=(((ip<<10) + j)<<10) + idet; // pos|neg|det
1433         Int_t info[3] = {pos[ip].GetNd(),neg[j].GetNd(),fNlayer[fModule]};
1434
1435         lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
1436         lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
1437         // out-of-diagonal element of covariance matrix
1438         if( (info[0]==1) && (info[1]==1) ) lp[5]=-0.00012;
1439         else if ( (info[0]>1) && (info[1]>1) ) {
1440           lp[2]=2.63e-06;    // 0.0016*0.0016;  //SigmaY2
1441           lp[3]=0.0065;      // 0.08*0.08;   //SigmaZ2
1442           lp[5]=-6.48e-05;
1443         }
1444         else {
1445           lp[2]=4.80e-06;      // 0.00219*0.00219
1446           lp[3]=0.0093;        // 0.0964*0.0964;
1447           if (info[0]==1) {
1448             lp[5]=-0.00014;
1449           }
1450           else {
1451             lp[2]=2.79e-06;    // 0.0017*0.0017;
1452             lp[3]=0.00935;     // 0.967*0.967;
1453             lp[5]=-4.32e-05;
1454           }
1455         }
1456
1457         AliITSRecPoint * cl2;
1458           cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1459
1460           cl2->SetChargeRatio(ratio);
1461           cl2->SetType(12);
1462           fgPairs[ip*nn+j]=12;
1463           if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
1464             cl2->SetType(13);
1465             fgPairs[ip*nn+j]=13;
1466           }
1467           cused1[ip]++;
1468           cused2[j]++;
1469         ncl++;
1470
1471       } // manyXmany
1472     } // loop over Pside 1Dclusters
1473
1474   } // use charge matching
1475
1476
1477   // recover all the other crosses
1478   //
1479   for (Int_t i=0; i<np; i++) {
1480     Float_t xbest=1000,zbest=1000,qbest=0;
1481     Float_t yp=pos[i].GetY();
1482     if ((pos[i].GetQ()>0)&&(pos[i].GetQ()<3)) continue;
1483     for (Int_t j=0; j<nn; j++) {
1484     //    for (Int_t di = 0;di<cpositive[i];di++){
1485     //  Int_t j = negativepair[10*i+di];
1486       if ((neg[j].GetQ()>0)&&(neg[j].GetQ()<3)) continue;
1487
1488       if ((neg[j].GetQ()==0)&&(pos[i].GetQ()==0)) continue; // reject crosses of bad strips!!
1489
1490       if (cused2[j]||cused1[i]) continue;
1491       if (fgPairs[i*nn+j]>0 &&fgPairs[i*nn+j]<100) continue;
1492       ratio = (pos[i].GetQ()-neg[j].GetQ())/(pos[i].GetQ()+neg[j].GetQ());
1493       Float_t yn=neg[j].GetY();
1494
1495       Float_t xt, zt;
1496       seg->GetPadCxz(yn, yp, xt, zt);
1497
1498       if (TMath::Abs(xt)<hwSSD)
1499       if (TMath::Abs(zt)<hlSSD) {
1500         xbest=xt; zbest=zt;
1501
1502         qbest=0.5*(pos[i].GetQ()+neg[j].GetQ());
1503
1504         {
1505         Double_t loc[3]={xbest,0.,zbest},trk[3]={0.,0.,0.};
1506         mT2L->MasterToLocal(loc,trk);
1507         lp[0]=trk[1];
1508         lp[1]=trk[2];
1509         }
1510         lp[4]=qbest;        //Q
1511         for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1512         for (Int_t ilab=0;ilab<3;ilab++){
1513           milab[ilab] = pos[i].GetLabel(ilab);
1514           milab[ilab+3] = neg[j].GetLabel(ilab);
1515         }
1516         //
1517         CheckLabels2(milab);
1518         milab[3]=(((i<<10) + j)<<10) + idet; // pos|neg|det
1519         Int_t info[3] = {pos[i].GetNd(),neg[j].GetNd(),fNlayer[fModule]};
1520
1521         lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
1522         lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
1523         // out-of-diagonal element of covariance matrix
1524         if( (info[0]==1) && (info[1]==1) ) lp[5]=-0.00012;
1525         else if ( (info[0]>1) && (info[1]>1) ) {
1526           lp[2]=2.63e-06;    // 0.0016*0.0016;  //SigmaY2
1527           lp[3]=0.0065;      // 0.08*0.08;   //SigmaZ2
1528           lp[5]=-6.48e-05;
1529         }
1530         else {
1531           lp[2]=4.80e-06;      // 0.00219*0.00219
1532           lp[3]=0.0093;        // 0.0964*0.0964;
1533           if (info[0]==1) {
1534             lp[5]=-0.00014;
1535           }
1536           else {
1537             lp[2]=2.79e-06;    // 0.0017*0.0017;
1538             lp[3]=0.00935;     // 0.967*0.967;
1539             lp[5]=-4.32e-05;
1540           }
1541         }
1542
1543         AliITSRecPoint * cl2;
1544           cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1545
1546           cl2->SetChargeRatio(ratio);
1547           cl2->SetType(100+cpositive[j]+cnegative[i]);
1548
1549           if(pos[i].GetQ()==0) cl2->SetType(200+cpositive[j]+cnegative[i]);
1550           if(neg[j].GetQ()==0) cl2->SetType(300+cpositive[j]+cnegative[i]);
1551         ncl++;
1552       }
1553     }
1554   }
1555
1556
1557
1558   if(repa->GetUseBadChannelsInClusterFinderSSD()==kTRUE) {
1559
1560     //---------------------------------------------------------
1561     // recover crosses of good 1D clusters with bad strips on the other side
1562     // Note1: at first iteration skip modules with a bad side (or almost), (would produce too many fake!)
1563     // Note2: for modules with a bad side see below
1564
1565     AliITSCalibrationSSD* cal = (AliITSCalibrationSSD*)GetResp(fModule);
1566     Int_t countPbad=0, countNbad=0;
1567     for(Int_t ib=0; ib<768; ib++) {
1568       if(cal->IsPChannelBad(ib)) countPbad++;
1569       if(cal->IsNChannelBad(ib)) countNbad++;
1570     }
1571     //  AliInfo(Form("module %d has %d P- and %d N-bad strips",fModule,countPbad,countNbad));
1572
1573     if( (countPbad<100) && (countNbad<100) ) { // no bad side!!
1574
1575       for (Int_t i=0; i<np; i++) { // loop over Nside 1Dclusters with no crosses
1576         if(cnegative[i]) continue; // if intersecting Pside clusters continue;
1577
1578         //      for(Int_t ib=0; ib<768; ib++) { // loop over all Pstrips
1579         for(Int_t ib=15; ib<753; ib++) { // loop over all Pstrips
1580
1581           if(cal->IsPChannelBad(ib)) { // check if strips is bad
1582             Float_t yN=pos[i].GetY();
1583             Float_t xt, zt;
1584             seg->GetPadCxz(1.*ib, yN, xt, zt);
1585
1586             //----------
1587             // bad Pstrip is crossing the Nside 1Dcluster -> create recpoint
1588             //
1589             if ( (TMath::Abs(xt)<hwSSD) && (TMath::Abs(zt)<hlSSD) ) {
1590               Double_t loc[3]={xt,0.,zt},trk[3]={0.,0.,0.};
1591               mT2L->MasterToLocal(loc,trk);
1592               lp[0]=trk[1];
1593               lp[1]=trk[2];
1594               lp[4]=pos[i].GetQ(); //Q
1595               for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1596               for (Int_t ilab=0;ilab<3;ilab++) milab[ilab] = pos[i].GetLabel(ilab);
1597               CheckLabels2(milab);
1598               milab[3]=( (i<<10) << 10 ) + idet; // pos|neg|det
1599               Int_t info[3] = {pos[i].GetNd(),0,fNlayer[fModule]};
1600
1601               lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
1602               lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
1603               lp[5]=-0.00012; // out-of-diagonal element of covariance matrix
1604               if (info[0]>1) {
1605                 lp[2]=4.80e-06;
1606                 lp[3]=0.0093;
1607                 lp[5]=0.00014;
1608               }
1609
1610               AliITSRecPoint * cl2;
1611                 cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1612                 cl2->SetChargeRatio(1.);
1613               cl2->SetType(50);
1614               ncl++;
1615             } // cross is within the detector
1616             //
1617             //--------------
1618
1619           } // bad Pstrip
1620
1621         } // end loop over Pstrips
1622
1623       } // end loop over Nside 1D clusters
1624
1625       for (Int_t j=0; j<nn; j++) { // loop over Pside 1D clusters with no crosses
1626         if(cpositive[j]) continue;
1627
1628         //      for(Int_t ib=0; ib<768; ib++) { // loop over all Nside strips
1629         for(Int_t ib=15; ib<753; ib++) { // loop over all Nside strips
1630
1631           if(cal->IsNChannelBad(ib)) { // check if strip is bad
1632             Float_t yP=neg[j].GetY();
1633             Float_t xt, zt;
1634             seg->GetPadCxz(yP, 1.*ib, xt, zt);
1635
1636             //----------
1637             // bad Nstrip is crossing the Pside 1Dcluster -> create recpoint
1638             //
1639             if ( (TMath::Abs(xt)<hwSSD) && (TMath::Abs(zt)<hlSSD) ) {
1640               Double_t loc[3]={xt,0.,zt},trk[3]={0.,0.,0.};
1641               mT2L->MasterToLocal(loc,trk);
1642               lp[0]=trk[1];
1643               lp[1]=trk[2];
1644               lp[4]=neg[j].GetQ(); //Q
1645               for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1646               for (Int_t ilab=0;ilab<3;ilab++) milab[ilab] = neg[j].GetLabel(ilab);
1647               CheckLabels2(milab);
1648               milab[3]=( j << 10 ) + idet; // pos|neg|det
1649               Int_t info[3]={0,(Int_t)neg[j].GetNd(),fNlayer[fModule]};
1650
1651               lp[2]=4.968e-06;     // 0.00223*0.00223;  //SigmaY2
1652               lp[3]=0.012;         // 0.110*0.110;  //SigmaZ2
1653               lp[5]=-0.00012; // out-of-diagonal element of covariance matrix
1654               if (info[0]>1) {
1655                 lp[2]=2.79e-06;
1656                 lp[3]=0.00935;
1657                 lp[5]=-4.32e-05;
1658               }
1659
1660               AliITSRecPoint * cl2;
1661                 cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1662                 cl2->SetChargeRatio(1.);
1663                 cl2->SetType(60);
1664               ncl++;
1665             } // cross is within the detector
1666             //
1667             //--------------
1668
1669           } // bad Nstrip
1670         } // end loop over Nstrips
1671       } // end loop over Pside 1D clusters
1672
1673     } // no bad sides
1674
1675     //---------------------------------------------------------
1676
1677     else if( (countPbad>700) && (countNbad<100) ) { // bad Pside!!
1678
1679       for (Int_t i=0; i<np; i++) { // loop over Nside 1Dclusters with no crosses
1680         if(cnegative[i]) continue; // if intersecting Pside clusters continue;
1681
1682         Float_t xt, zt;
1683         Float_t yN=pos[i].GetY();
1684         Float_t yP=0.;
1685         if (seg->GetLayer()==5) yP = yN + (7.6/1.9);
1686         else yP = yN - (7.6/1.9);
1687         seg->GetPadCxz(yP, yN, xt, zt);
1688
1689         if ( (TMath::Abs(xt)<hwSSD) && (TMath::Abs(zt)<hlSSD) ) {
1690           Double_t loc[3]={xt,0.,zt},trk[3]={0.,0.,0.};
1691           mT2L->MasterToLocal(loc,trk);
1692           lp[0]=trk[1];
1693           lp[1]=trk[2];
1694           lp[4]=pos[i].GetQ(); //Q
1695           for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1696           for (Int_t ilab=0;ilab<3;ilab++) milab[ilab] = pos[i].GetLabel(ilab);
1697           CheckLabels2(milab);
1698           milab[3]=( (i<<10) << 10 ) + idet; // pos|neg|det
1699           Int_t info[3] = {(Int_t)pos[i].GetNd(),0,fNlayer[fModule]};
1700
1701           lp[2]=0.00098;    // 0.031*0.031;  //SigmaY2
1702           lp[3]=1.329;      // 1.15*1.15;  //SigmaZ2
1703           lp[5]=-0.0359;
1704           if(info[0]>1) lp[2]=0.00097;
1705
1706           AliITSRecPoint * cl2;
1707             cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1708             cl2->SetChargeRatio(1.);
1709             cl2->SetType(70);
1710           ncl++;
1711         } // cross is within the detector
1712         //
1713         //--------------
1714
1715       } // end loop over Nside 1D clusters
1716
1717     } // bad Pside module
1718
1719     else if( (countNbad>700) && (countPbad<100) ) { // bad Nside!!
1720
1721       for (Int_t j=0; j<nn; j++) { // loop over Pside 1D clusters with no crosses
1722         if(cpositive[j]) continue;
1723
1724         Float_t xt, zt;
1725         Float_t yP=neg[j].GetY();
1726         Float_t yN=0.;
1727         if (seg->GetLayer()==5) yN = yP - (7.6/1.9);
1728         else yN = yP + (7.6/1.9);
1729         seg->GetPadCxz(yP, yN, xt, zt);
1730
1731         if ( (TMath::Abs(xt)<hwSSD) && (TMath::Abs(zt)<hlSSD) ) {
1732           Double_t loc[3]={xt,0.,zt},trk[3]={0.,0.,0.};
1733           mT2L->MasterToLocal(loc,trk);
1734           lp[0]=trk[1];
1735           lp[1]=trk[2];
1736           lp[4]=neg[j].GetQ(); //Q
1737           for (Int_t ilab=0;ilab<10;ilab++) milab[ilab]=-2;
1738           for (Int_t ilab=0;ilab<3;ilab++) milab[ilab] = neg[j].GetLabel(ilab);
1739           CheckLabels2(milab);
1740           milab[3]=( j << 10 ) + idet; // pos|neg|det
1741           Int_t info[3] = {0,(Int_t)neg[j].GetNd(),fNlayer[fModule]};
1742
1743           lp[2]=7.27e-05;   // 0.0085*0.0085;  //SigmaY2
1744           lp[3]=1.33;       // 1.15*1.15;  //SigmaZ2
1745           lp[5]=0.00931;
1746           if(info[1]>1) lp[2]=6.91e-05;
1747
1748           AliITSRecPoint * cl2;
1749             cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);
1750             cl2->SetChargeRatio(1.);
1751             cl2->SetType(80);
1752           ncl++;
1753         } // cross is within the detector
1754         //
1755         //--------------
1756
1757       } // end loop over Pside 1D clusters
1758
1759     } // bad Nside module
1760
1761     //---------------------------------------------------------
1762
1763   } // use bad channels
1764
1765   //cout<<ncl<<" clusters for this module"<<endl;
1766
1767   delete [] cnegative;
1768   delete [] cused1;
1769   delete [] negativepair;
1770   delete [] cpositive;
1771   delete [] cused2;
1772   delete [] positivepair;
1773
1774 }