Revision of SSD ClusterFinder (S. Borysov)

diff --git a/ITS/AliITSClusterFinderV2SSD.cxx b/ITS/AliITSClusterFinderV2SSD.cxx
index 3c71ad378e6d2a0bb55680aae0343f20a0696453..84592311f5e502b23cd218fea0e57abc9ebb8019 100644 (file)
--- a/ITS/AliITSClusterFinderV2SSD.cxx
+++ b/ITS/AliITSClusterFinderV2SSD.cxx
@@ -35,6 +35,7 @@
 #include "AliRawReader.h"
 #include "AliITSRawStreamSSD.h"
 #include <TClonesArray.h>
 #include "AliRawReader.h"
 #include "AliITSRawStreamSSD.h"
 #include <TClonesArray.h>

+#include <TCollection.h>

 #include "AliITSdigitSSD.h"
 #include "AliITSReconstructor.h"
 #include "AliITSCalibrationSSD.h"
 #include "AliITSdigitSSD.h"
 #include "AliITSReconstructor.h"
 #include "AliITSCalibrationSSD.h"


@@ -350,10 +351,17 @@ void AliITSClusterFinderV2SSD::FindClustersSSD(TClonesArray *alldigits) {
   // Note2: if there are no Pside digits nn=0 (bad strips!!) (same for Nside)
   //
   //  cout<<nn<<" Pside and "<<np<<" Nside clusters"<<endl;
   // Note2: if there are no Pside digits nn=0 (bad strips!!) (same for Nside)
   //
   //  cout<<nn<<" Pside and "<<np<<" Nside clusters"<<endl;

-  FindClustersSSD(neg, nn, pos, np);
-  //
+  
+  AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();   
+  if (nn*np > 0) { 
+    TClonesArray* clusters = rpc->UncheckedGetClusters(fModule);
+    clusters->Clear();
+    FindClustersSSD(neg, nn, pos, np, clusters);
+    TIter itr(clusters);
+    AliITSRecPoint *irp;
+    while ((irp = (AliITSRecPoint*)itr.Next()))  fDetTypeRec->AddRecPoint(*irp);
+  }

   //-----------------------------------------------------
   //-----------------------------------------------------

-

 }
 
 
 }
 
 


@@ -368,6 +376,7 @@ void AliITSClusterFinderV2SSD::RawdataToClusters(AliRawReader* rawReader){
   
 }
 
   
 }
 

+

 void AliITSClusterFinderV2SSD::FindClustersSSD(AliITSRawStreamSSD* input) 
 {
   //------------------------------------------------------------
 void AliITSClusterFinderV2SSD::FindClustersSSD(AliITSRawStreamSSD* input) 
 {
   //------------------------------------------------------------


@@ -383,357 +392,264 @@ void AliITSClusterFinderV2SSD::FindClustersSSD(AliITSRawStreamSSD* input)
       AliWarning("Using default AliITSRecoParam class");
     }
   }
       AliWarning("Using default AliITSRecoParam class");
     }
   }

-

   Int_t nClustersSSD = 0;
   Int_t nClustersSSD = 0;

-  const Int_t kMax = 1000;
-  Ali1Dcluster clusters1D[2][kMax];
-  Int_t nClusters[2] = {0, 0};
-  Int_t lab[3]={-2,-2,-2};
-  Float_t q = 0.;
-  Float_t y = 0.;
-  Int_t nDigits = 0;
-  Float_t gain=0;
-  Float_t noise=0.;
-  //  Float_t pedestal=0.;
-  Float_t oldnoise=0.;
-  AliITSCalibrationSSD* cal=NULL;
-
-  Int_t matrix[12][1536];
-  Int_t iddl=-1;
-  Int_t iad=-1;
-  Int_t oddl = -1;
-  Int_t oad = -1;
-  Int_t oadc = -1;
-  Int_t ostrip = -1;
-  Int_t osignal = 65535;
-  Int_t n=0;
-  Bool_t next=0;
-
-  // read raw data input stream
+  const Int_t kNADC = 12;
+  const Int_t kMaxADCClusters = 1000;
+
+  Int_t strips[kNADC][2][kMaxADCClusters][2]; // [ADC],[side],[istrip], [0]=istrip [1]=signal
+  Int_t nStrips[kNADC][2];
+
+  for( int i=0; i<kNADC; i++ ){
+    nStrips[i][0] = 0;
+    nStrips[i][1] = 0;
+  }
+
+  Int_t ddl = -1;
+  Int_t ad = -1;
+  
+  //*
+  //* Loop over modules DDL+AD
+  //*
+  

   while (kTRUE) {
   while (kTRUE) {

+
+    bool next = input->Next();

     
     

-    // reset signal matrix
-    for(Int_t i=0; i<12; i++) { for(Int_t j=0; j<1536; j++) { matrix[i][j] = 65535;} }
-    
-    if((osignal!=65535)&&(ostrip>0)&&(ostrip<1536)) { 
-      n++;
-      matrix[oadc][ostrip] = osignal; // recover data from previous occurence of input->Next() 
+    //* 
+    //* Continue if corrupted input
+    //*
+
+    if( (!next)&&(input->flag) ){
+     AliWarning(Form("ITSClustersFinderSSD: Corrupted data: warning from RawReader"));
+      continue; 

     }
     }

-    
-    // buffer data for ddl=iddl and ad=iad
-    while(kTRUE) {
-        
-      next = input->Next();
-      if((!next)&&(input->flag)) continue;
-      Int_t ddl=input->GetDDL(); 
-      Int_t ad=input->GetAD();
-      Int_t adc = input->GetADC(); adc = (adc<6)? adc : adc - 2;
-      Int_t strip = input->GetStrip();
-      if(input->GetSideFlag()) strip=1535-strip;
-      Int_t signal = input->GetSignal();
-
-      if((ddl==iddl)&&(ad==iad)&&(strip>0)&&(strip<1536)) {n++; matrix[adc][strip] = signal;}
-      else {if ((strip<1536) && (strip>0)) {oddl=iddl; oad=iad; oadc = adc; ostrip = strip; osignal=signal; iddl=ddl; iad=ad; break;}}
+
+    Int_t newDDL = input->GetDDL(); 
+    Int_t newAD = input->GetAD();
+
+    if( next ){
+      if( newDDL<0 || newDDL>15 ){
+       AliWarning(Form("ITSClustersFinderSSD: Corrupted data: wrong DDL number (%d)",newDDL));
+       continue;
+      }

       
       

-      if(!next)  {oddl=iddl; oad=iad; oadc = adc; ostrip = strip; osignal=signal; iddl=ddl; iad=ad; break;}
-      //break;
+      if( newAD<1 || newAD>9 ){
+       AliWarning(Form("ITSClustersFinderSSD: Corrupted data: wrong AD number (%d)",newAD));
+       continue;
+      }

     }
     }

-    
-    // No SSD data
-    if(!next && oddl<0) break;
-    
-    if(n==0) continue; // first occurence
-    n=0; //osignal=0;

 
 

-    Float_t dStrip = 0;
-    if (repa->GetUseCosmicRunShiftsSSD()) {  // Special condition for 2007/2008 cosmic data
-      dStrip = fgkCosmic2008StripShifts[oddl][oad-1];
-    }
-    if (TMath::Abs(dStrip) > 1.5)
-      AliError(Form("Indexing error ? oddl = %d, dStrip %f\n",oddl,dStrip));
-    // fill 1Dclusters
-    for(Int_t iadc=0; iadc<12; iadc++) {  // loop over ADC index for ddl=oddl and ad=oad
-      
-      Int_t iimod = (oad - 1)  * 12 + iadc;
-      Int_t iModule = AliITSRawStreamSSD::GetModuleNumber(oddl,iimod);
-      if(iModule==-1) continue;
-      cal = (AliITSCalibrationSSD*)GetResp(iModule);
+    bool newModule = ( !next || ddl!= newDDL || ad!=newAD );

 
 

-      Bool_t first = 0;
-      Bool_t flag5 = 0;
-      
-      /*
-      for(Int_t istrip=0; istrip<768; istrip++) { // P-side
-       Int_t signal = matrix[iadc][istrip];
-       pedestal = cal->GetPedestalP(istrip);
-       matrix[iadc][istrip]=signal-(Int_t)pedestal;
-      } 
-      */
+    if( newModule && ddl>=0 && ad>=0 ){ 

 
 

-      /*
-      Float_t cmode=0;
-      for(Int_t l=0; l<6; l++) {
-       cmode=0;
-       for(Int_t n=20; n<108; n++) cmode+=matrix[iadc][l*128+n];
-       cmode/=88.;
-       for(Int_t n=0; n<128; n++) matrix[iadc][l*128+n]-=(Int_t)cmode;
+      //*
+      //* Reconstruct the previous block of 12 modules --- actual clusterfinder
+      //* 
+      //cout<<endl;
+      for( int adc = 0; adc<kNADC; adc++ ){

        
        

-      }
-      */
+       //* 1D clusterfinder

 
 

-      Int_t istrip=0;
-      for(istrip=0; istrip<768; istrip++) { // P-side
+       Ali1Dcluster clusters1D[2][kMaxADCClusters]; // per ADC, per side
+       Int_t nClusters1D[2] = {0,0};
+       //int nstat[2] = {0,0};
+       fModule = AliITSRawStreamSSD::GetModuleNumber(ddl, (ad - 1)  * 12 + adc );

        
        

-       Int_t signal = TMath::Abs(matrix[iadc][istrip]);
-       
-       oldnoise = noise;
-       noise = cal->GetNoiseP(istrip); if(noise<1.) signal = 65535;
-       if(signal<3*noise) signal = 65535; // in case ZS was not done in hw do it now
+       if( fModule<0 ){
+//       AliWarning(Form("ITSClustersFinderSSD: Corrupted data: module (ddl %d ad %d adc %d) not found in the map",ddl,ad,adc));
+//CM channels are always present even everything is suppressed 
+         continue;
+       }

 
 

-       //        if(cal->IsPChannelBad(istrip)) signal=0;
+       AliITSCalibrationSSD* cal = (AliITSCalibrationSSD*)fDetTypeRec->GetCalibrationModel(fModule);
+       if( !cal ){
+         AliWarning(Form("ITSClustersFinderSSD: No calibration found for module (ddl %d ad %d adc %d)",ddl,ad,adc));       
+         continue;
+       }

 
 

-       if (signal!=65535) {
-         gain = cal->GetGainP(istrip);
-         signal = (Int_t) ( signal * gain ); // signal is corrected for gain
-         if(signal>fgkThreshold*noise) flag5=1;
-         signal = (Int_t) cal->ADCToKeV( signal ); // signal is  converted in KeV 
-         
-         q += signal;    // add digit to current cluster
-         y += istrip * signal;   
-         nDigits++;
-         first=1;
+       Float_t dStrip = 0;
+
+       if( repa->GetUseCosmicRunShiftsSSD()) {  // Special condition for 2007/2008 cosmic data
+         dStrip = fgkCosmic2008StripShifts[ddl][ad-1];
+         if (TMath::Abs(dStrip) > 1.5){
+           AliWarning(Form("Indexing error in Cosmic calibration: ddl = %d, dStrip %f\n",ddl,dStrip));
+           dStrip = 0;
+         }     

        }
        
        }
        

-       else if(first) {
+       for( int side=0; side<=1; side++ ){
+
+         Int_t lab[3]={-2,-2,-2};
+         Float_t q = 0.;
+         Float_t y = 0.;
+         Int_t nDigits = 0;
+         Int_t ostrip = -2;
+         Bool_t snFlag = 0;

          
          

-         if ( (nDigits>0) && flag5 ) {
+         Int_t n = nStrips[adc][side];
+         for( int istr = 0; istr<n+1; istr++ ){

            
            

-           Ali1Dcluster& cluster = clusters1D[0][nClusters[0]++];
-
-           if(q!=0) cluster.SetY(y/q + dStrip);
-           else cluster.SetY(istrip + dStrip -1);
-
-           cluster.SetQ(q);
-           cluster.SetNd(nDigits);
-           cluster.SetLabels(lab);
+           bool stripOK = 1;
+           Int_t strip=0;
+           Float_t signal=0.0, noise=0.0, gain=0.0;

            
            

-           if(repa->GetUseUnfoldingInClusterFinderSSD()==kTRUE) {
+           if( istr<n ){
+             strip = strips[adc][side][istr][0];
+             signal = strips[adc][side][istr][1];

              
              

-             //Split suspiciously big cluster
-             if (nDigits > 4&&nDigits < 25) {
-               if(q!=0) cluster.SetY(y/q + dStrip - 0.25*nDigits);
-               else cluster.SetY(istrip-1 + dStrip - 0.25*nDigits);
-               cluster.SetQ(0.5*q);
-               if (nClusters[0] == kMax) {
-                 Error("FindClustersSSD", "Too many 1D clusters !");
-                 return;
+             //cout<<"strip "<<adc<<" / "<<side<<": "<<strip<<endl;
+
+             if( cal ){
+               noise = side ?cal->GetNoiseN(strip) :cal->GetNoiseP(strip); 
+               gain = side ?cal->GetGainN(strip) :cal->GetGainP(strip);         
+               stripOK = ( noise>=1. && signal>=3.0*noise 
+                           //&& !cal->IsPChannelBad(strip) 
+                           );
+             }
+           } else stripOK = 0; // end of data
+
+           bool newCluster = ( (abs(strip-ostrip)!=1) || !stripOK );     
+               
+           if( newCluster ){
+
+             //* Store the previous cluster
+
+             if( nDigits>0 && q>0 && snFlag ){
+
+               if (nClusters1D[side] >= kMaxADCClusters-1 ) {
+                 AliWarning("HLT ClustersFinderSSD: Too many 1D clusters !");
+               }else {
+                 
+                 Ali1Dcluster &cluster = clusters1D[side][nClusters1D[side]++];
+                 cluster.SetY( y / q + dStrip);
+                 cluster.SetQ(q);
+                 cluster.SetNd(nDigits);
+                 cluster.SetLabels(lab);
+                 //cout<<"cluster 1D side "<<side<<": y= "<<y<<" q= "<<q<<" d="<<dStrip<<" Y="<<cluster.GetY()<<endl;
+                 //Split suspiciously big cluster
+
+                 if( repa->GetUseUnfoldingInClusterFinderSSD()
+                     && nDigits > 4 && nDigits < 25 
+                     ){
+                   cluster.SetY(y/q + dStrip - 0.25*nDigits);      
+                   cluster.SetQ(0.5*q);          
+                   Ali1Dcluster& cluster2 = clusters1D[side][nClusters1D[side]++];
+                   cluster2.SetY(y/q + dStrip + 0.25*nDigits);     
+                   cluster2.SetQ(0.5*q);
+                   cluster2.SetNd(nDigits);
+                   cluster2.SetLabels(lab);      
+                 } // unfolding is on          

                }
                }

-               Ali1Dcluster& cluster2 = clusters1D[0][nClusters[0]++];
-               if(q!=0) cluster2.SetY(y/q + dStrip + 0.25*nDigits);
-               else cluster2.SetY(istrip-1 + dStrip + 0.25*nDigits);
-               cluster2.SetQ(0.5*q);
-               cluster2.SetNd(nDigits);
-               cluster2.SetLabels(lab);

              }
              }

-           } // unfolding is on            
-         }
-         
-         y = q = 0.;
-         nDigits = 0;
-         first=0;
-         flag5=0;
-       }
-       
-      } // loop over strip on P-side
-      
-      // if last strip does have signal
-      if(first) {
-       
-         if ( (nDigits>0) && flag5 ) {
-         
-         Ali1Dcluster& cluster = clusters1D[0][nClusters[0]++];
-
-         if(q!=0) cluster.SetY(y/q + dStrip);
-         else cluster.SetY(istrip - 1 + dStrip);
+             y = q = 0.;
+             nDigits = 0;
+             snFlag = 0;
+
+           } //* End store the previous cluster
+
+           if( stripOK ){ // add new signal to the cluster
+//           signal = (Int_t) (signal * gain); // signal is corrected for gain
+             if( signal>fgkThreshold*noise) snFlag = 1;
+             signal = signal * gain; // signal is corrected for gain
+//           if( cal ) signal = (Int_t) cal->ADCToKeV( signal ); // signal is  converted in KeV          
+             if( cal ) signal = cal->ADCToKeV( signal ); // signal is  converted in KeV          
+             q += signal;        // add digit to current cluster
+             y += strip * signal;        
+             nDigits++;
+             //nstat[side]++;
+             ostrip = strip;

 
 

-         cluster.SetQ(q);
-         cluster.SetNd(nDigits);
-         cluster.SetLabels(lab);
-         
-         if(repa->GetUseUnfoldingInClusterFinderSSD()==kTRUE) {
-           
-           //Split suspiciously big cluster
-           if (nDigits > 4&&nDigits < 25) {
-             if(q!=0) cluster.SetY(y/q + dStrip - 0.25*nDigits);
-             else cluster.SetY(istrip-1 + dStrip - 0.25*nDigits);
-             cluster.SetQ(0.5*q);
-             if (nClusters[0] == kMax) {
-               Error("FindClustersSSD", "Too many 1D clusters !");
-               return;
-             }
-             Ali1Dcluster& cluster2 = clusters1D[0][nClusters[0]++];
-             if(q!=0) cluster2.SetY(y/q + dStrip + 0.25*nDigits);
-             else cluster2.SetY(istrip-1 + dStrip + 0.25*nDigits);
-             cluster2.SetQ(0.5*q);
-             cluster2.SetNd(nDigits);
-             cluster2.SetLabels(lab);

            }
            }

-         } // unfolding is on    
-         
-       }
-       y = q = 0.;
-       nDigits = 0;
-       first=0;
-       flag5=0;
-      }
-      
-      /*
-      for(Int_t istrip=768; istrip<1536; istrip++) { // P-side
-       Int_t signal = matrix[iadc][istrip];
-       pedestal = cal->GetPedestalN(1535-istrip);
-       matrix[iadc][istrip]=signal-(Int_t)pedestal;
-      }        
-      */
+         } //* end loop over strips

 
 

-      /*
-      for(Int_t l=6; l<12; l++) {
-       Float_t cmode=0;
-       for(Int_t n=20; n<108; n++) cmode+=matrix[iadc][l*128+n];
-       cmode/=88.;
-       for(Int_t n=0; n<128; n++) matrix[iadc][l*128+n]-=(Int_t)cmode;
-      }
-      */
-
-      oldnoise = 0.;
-      noise = 0.;
-      Int_t strip=0;
-      for(Int_t iistrip=768; iistrip<1536; iistrip++) { // N-side
+       } //* end loop over ADC sides

        
        

-       Int_t signal = TMath::Abs(matrix[iadc][iistrip]);
-       strip = 1535-iistrip;
-
-       oldnoise = noise;
-       noise = cal->GetNoiseN(strip); if(noise<1.) signal=65535;

 
 

-       //        if(cal->IsNChannelBad(strip)) signal=0;
-
-       if(signal<3*noise) signal = 65535; // in case ZS was not done in hw do it now
-
-       if (signal!=65535) {
-         gain = cal->GetGainN(strip);
-         signal = (Int_t) ( signal * gain); // signal is corrected for gain
-         if(signal>fgkThreshold*noise) flag5=1;
-         signal = (Int_t) cal->ADCToKeV( signal ); // signal is  converted in KeV 
-         
-         // add digit to current cluster
-         q += signal;
-         y += strip * signal;
-         nDigits++;
-         first=1;
+       //* 2D clusterfinder
+       if( nClusters1D[0] && nClusters1D[1] && fModule>=0 ){
+           TClonesArray* clusters = rpc->UncheckedGetClusters(fModule);
+              FindClustersSSD( clusters1D[0], nClusters1D[0], clusters1D[1], nClusters1D[1], clusters); 
+           Int_t nClustersn = clusters->GetEntriesFast();
+              nClustersSSD += nClustersn;

        }
 
        }
 

-       else if(first) {
-         
-         if ( (nDigits>0) && flag5 ) {
-           
-           Ali1Dcluster& cluster = clusters1D[1][nClusters[1]++];
+       //cout<<"SG: "<<ddl<<" "<<ad<<" "<<adc<<": strips "<<nstat[0]<<"+"<<nstat[1]<<", clusters 1D= "<<nClusters1D[0]<<" + "<<nClusters1D[1]<<", 2D= "<<clusters.size()<<endl;

 
 

-           if(q!=0) cluster.SetY(y/q - dStrip);
-           else cluster.SetY(strip+1 - dStrip);
+      }//* end loop over adc
+      
+    }//* end of reconstruction of previous block of 12 modules
+    
+    if( newModule ){
+      
+      //*
+      //* Clean up arrays and set new module
+      //* 
+      
+      for( int i=0; i<kNADC; i++ ){
+       nStrips[i][0] = 0;
+       nStrips[i][1] = 0;
+      }     
+      ddl = newDDL;
+      ad = newAD;
+    } 
+    

 
 

-           cluster.SetQ(q);
-           cluster.SetNd(nDigits);
-           cluster.SetLabels(lab);
-           
-           if(repa->GetUseUnfoldingInClusterFinderSSD()==kTRUE) {
-
-             //Split suspiciously big cluster
-             if (nDigits > 4&&nDigits < 25) {
-               cluster.SetY(y/q - dStrip - 0.25*nDigits);
-               cluster.SetQ(0.5*q);
-               if (nClusters[1] == kMax) {
-                 Error("FindClustersSSD", "Too many 1D clusters !");
-                 return;
-               }
-               Ali1Dcluster& cluster2 = clusters1D[1][nClusters[1]++];
-               cluster2.SetY(y/q - dStrip + 0.25*nDigits);
-               cluster2.SetQ(0.5*q);
-               cluster2.SetNd(nDigits);
-               cluster2.SetLabels(lab);
-             }       
-           } // unfolding is on
-         } 
-
-         y = q = 0.;
-         nDigits = 0;
-         first=0;        
-       flag5=0;
-       }
-       
-      } // loop over strips on N-side
+    //*
+    //* Exit main loop when there is no more input
+    //* 

 
 

-      if(first) {
-       
-         if ( (nDigits>0) && flag5 ) {
-         
-         Ali1Dcluster& cluster = clusters1D[1][nClusters[1]++];
-         
-         if(q!=0) cluster.SetY(y/q - dStrip);
-         else cluster.SetY(strip - dStrip + 1);
+    if( !next ) break;
+    
+    //* 
+    //* Fill the current strip information
+    //* 
+
+    Int_t adc = input->GetADC(); 
+    if( adc<0 || adc>=kNADC+2 || (adc>5&&adc<8) ){
+      AliWarning(Form("HLT ClustersFinderSSD: Corrupted data: wrong adc number (%d)", adc));
+      continue;
+    }

 
 

-         cluster.SetQ(q);
-         cluster.SetNd(nDigits);
-         cluster.SetLabels(lab);
-         
-         if(repa->GetUseUnfoldingInClusterFinderSSD()==kTRUE) {
-           
-           //Split suspiciously big cluster
-           if (nDigits > 4&&nDigits < 25) {
-             if(q!=0) cluster.SetY(y/q - dStrip - 0.25*nDigits);
-             else cluster.SetY(strip+1 - dStrip - 0.25*nDigits);
-             cluster.SetQ(0.5*q);
-             if (nClusters[1] == kMax) {
-               Error("FindClustersSSD", "Too many 1D clusters !");
-               return;
-             }
-             Ali1Dcluster& cluster2 = clusters1D[1][nClusters[1]++];
-             if(q!=0) cluster2.SetY(y/q - dStrip + 0.25*nDigits);
-             else cluster2.SetY(strip+1 - dStrip + 0.25*nDigits);
-             cluster2.SetQ(0.5*q);
-             cluster2.SetNd(nDigits);
-             cluster2.SetLabels(lab);
-           }
-         } // unfolding is on      
-       }
+    if( adc>7 ) adc-= 2; // shift ADC numbers 8-13 to 6-11
+    
+    Bool_t side = input->GetSideFlag();
+    Int_t strip = input->GetStrip();
+    Int_t signal = input->GetSignal();
+    

 
 

-       y = q = 0.;
-       nDigits = 0;
-       first=0;          
-       flag5=0;
-      }
-      
-      // create recpoints
-      if((nClusters[0])&&(nClusters[1])) {     
-       fModule = iModule;
-       TClonesArray* clusters = rpc->UncheckedGetClusters(fModule);
-       FindClustersSSD(&clusters1D[0][0], nClusters[0], 
-                       &clusters1D[1][0], nClusters[1], clusters);
-       Int_t nClustersn = clusters->GetEntriesFast();
-       nClustersSSD += nClustersn;
-      }
+    //cout<<"SSD: "<<ddl<<" "<<ad<<" "<<adc<<" "<<side<<" "<<strip<<" : "<<signal<<endl;

 
 

-      nClusters[0] = nClusters[1] = 0;
-      y = q = 0.;
-      nDigits = 0;
+    if( strip>767 ){    
+      AliWarning(Form("HLT ClustersFinderSSD: Corrupted data: wrong strip number (ddl %d ad %d adc %d side %d, strip %d", 
+                     ddl, ad, adc, side,strip) );
+      continue;
+    }
+    if (strip < 0) continue;
+    
+    int &n = nStrips[adc][side];
+    if( n >0 ){
+      Int_t oldStrip = strips[adc][side][n-1][0];
+
+      if( strip==oldStrip ){
+       AliWarning(Form("HLT ClustersFinderSSD: Corrupted data: duplicated signal: ddl %d ad %d adc %d, side %d, strip %d", 
+                       ddl, ad, adc, side, strip ));
+       continue;
+      }
+    }
+    strips[adc][side][n][0] = strip;
+    strips[adc][side][n][1] = signal;    
+    n++;

 
 

-    } // loop over adc
+    //cout<<"SSD: "<<input->GetDDL()<<" "<<input->GetAD()<<" "
+    //<<input->GetADC()<<" "<<input->GetSideFlag()<<" "<<((int)input->GetStrip())<<" "<<strip<<" : "<<input->GetSignal()<<endl;

 
 

-    if(!next) break;
-  }
+  } //* End main loop over the input

   
   AliDebug(1,Form("found clusters in ITS SSD: %d", nClustersSSD));
 }
 
   
   AliDebug(1,Form("found clusters in ITS SSD: %d", nClustersSSD));
 }
 

+

 void AliITSClusterFinderV2SSD::
 FindClustersSSD(Ali1Dcluster* neg, Int_t nn, 
                Ali1Dcluster* pos, Int_t np,
 void AliITSClusterFinderV2SSD::
 FindClustersSSD(Ali1Dcluster* neg, Int_t nn, 
                Ali1Dcluster* pos, Int_t np,


@@ -756,7 +672,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
     }
   }
 
     }
   }
 

-  TClonesArray &cl=*clusters;
+//  TClonesArray &cl=*clusters;

   
   AliITSsegmentationSSD *seg = dynamic_cast<AliITSsegmentationSSD*>(fDetTypeRec->GetSegmentationModel(2));
   if (fModule>fLastSSD1) 
   
   AliITSsegmentationSSD *seg = dynamic_cast<AliITSsegmentationSSD*>(fDetTypeRec->GetSegmentationModel(2));
   if (fModule>fLastSSD1) 


@@ -793,6 +709,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
   //
   // find available pairs
   //
   //
   // find available pairs
   //

+  Int_t ncross = 0;

   for (Int_t i=0; i<np; i++) {
     Float_t yp=pos[i].GetY(); 
     if ( (pos[i].GetQ()>0) && (pos[i].GetQ()<3) ) continue;
   for (Int_t i=0; i<np; i++) {
     Float_t yp=pos[i].GetY(); 
     if ( (pos[i].GetQ()>0) && (pos[i].GetQ()<3) ) continue;


@@ -812,7 +729,8 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          negativepair[in] =j;  //index
          positivepair[ip] =i;
          cnegative[i]++;  //counters
          negativepair[in] =j;  //index
          positivepair[ip] =i;
          cnegative[i]++;  //counters

-         cpositive[j]++;       
+         cpositive[j]++;
+         ncross++;     

          fgPairs[i*nn+j]=100;
        }
        else
          fgPairs[i*nn+j]=100;
        }
        else


@@ -821,6 +739,9 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
     }
   }
 
     }
   }
 

+  if (!ncross) return;
+//why not to allocate memorey here?  if(!clusters) clusters = new TClonesArray("AliITSRecPoint", ncross);
+  

   /* //
   // try to recover points out of but close to the module boundaries 
   //
   /* //
   // try to recover points out of but close to the module boundaries 
   //


@@ -943,50 +864,24 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        }
 
        AliITSRecPoint * cl2;
        }
 
        AliITSRecPoint * cl2;

-       
-       if(clusters){  // Note clusters != 0 when method is called for rawdata
-         
+    cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);

          
          

-         cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
-         
-         cl2->SetChargeRatio(ratio);           
-         cl2->SetType(1);
-         fgPairs[ip*nn+j]=1;
+    cl2->SetChargeRatio(ratio);        
+    cl2->SetType(1);
+    fgPairs[ip*nn+j]=1;

 
 

-         if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
-           cl2->SetType(2);
-           fgPairs[ip*nn+j]=2;
-         }
-
-         if(pos[ip].GetQ()==0) cl2->SetType(3);
-         if(neg[j].GetQ()==0) cl2->SetType(4);
-
-         cused1[ip]++;
-         cused2[j]++;
-         
-       }
-       else{ // Note clusters == 0 when method is called for digits
-         
-         cl2 = new AliITSRecPoint(milab,lp,info);      
-         
-         cl2->SetChargeRatio(ratio);           
-         cl2->SetType(1);
-         fgPairs[ip*nn+j]=1;
-
-         if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
-           cl2->SetType(2);
-           fgPairs[ip*nn+j]=2;
-         }
+    if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
+      cl2->SetType(2);
+      fgPairs[ip*nn+j]=2;
+    }

 
 

-         if(pos[ip].GetQ()==0) cl2->SetType(3);
-         if(neg[j].GetQ()==0) cl2->SetType(4);
+    if(pos[ip].GetQ()==0) cl2->SetType(3);
+    if(neg[j].GetQ()==0) cl2->SetType(4);

 
 

-         cused1[ip]++;
-         cused2[j]++;
+    cused1[ip]++;
+    cused2[j]++;

 
 

-         fDetTypeRec->AddRecPoint(*cl2);
-       }
-       ncl++;
+       ncl++;

       }
     }
     
       }
     }
     


@@ -1060,9 +955,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        }
 
        AliITSRecPoint * cl2;
        }
 
        AliITSRecPoint * cl2;

-           if(clusters){
-             
-             cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+             cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);

              cl2->SetChargeRatio(ratio);       
              cl2->SetType(5);
              fgPairs[ip*nn+in] = 5;
              cl2->SetChargeRatio(ratio);       
              cl2->SetType(5);
              fgPairs[ip*nn+in] = 5;


@@ -1070,19 +963,6 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
                cl2->SetType(6);
                fgPairs[ip*nn+in] = 6;
              }     
                cl2->SetType(6);
                fgPairs[ip*nn+in] = 6;
              }     

-           }
-           else{
-             cl2 = new AliITSRecPoint(milab,lp,info);
-             cl2->SetChargeRatio(ratio);       
-             cl2->SetType(5);
-             fgPairs[ip*nn+in] = 5;
-             if ((pos[ip].GetNd()+neg[in].GetNd())>6){ //multi cluster
-               cl2->SetType(6);
-               fgPairs[ip*nn+in] = 6;
-             }
-             
-             fDetTypeRec->AddRecPoint(*cl2);
-           }

            ncl++;
          }
          
            ncl++;
          }
          


@@ -1143,8 +1023,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        }
 
            AliITSRecPoint * cl2;
        }
 
            AliITSRecPoint * cl2;

-           if(clusters){
-             cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+             cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);

              
              cl2->SetChargeRatio(ratio);       
              cl2->SetType(5);
              
              cl2->SetChargeRatio(ratio);       
              cl2->SetType(5);


@@ -1153,19 +1032,6 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
                cl2->SetType(6);
                fgPairs[ip2*nn+in] =6;
              }
                cl2->SetType(6);
                fgPairs[ip2*nn+in] =6;
              }

-           }
-           else{
-             cl2 = new AliITSRecPoint(milab,lp,info);
-             cl2->SetChargeRatio(ratio);       
-             cl2->SetType(5);
-             fgPairs[ip2*nn+in] =5;
-             if ((pos[ip2].GetNd()+neg[in].GetNd())>6){ //multi cluster
-               cl2->SetType(6);
-               fgPairs[ip2*nn+in] =6;
-             }
-             
-             fDetTypeRec->AddRecPoint(*cl2);
-           }

            ncl++;
          }
          
            ncl++;
          }
          


@@ -1259,8 +1125,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        }
 
          AliITSRecPoint * cl2;
        }
 
          AliITSRecPoint * cl2;

-         if(clusters){
-           cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+           cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);

 
            cl2->SetChargeRatio(ratio);         
            cl2->SetType(7);
 
            cl2->SetChargeRatio(ratio);         
            cl2->SetType(7);


@@ -1269,20 +1134,6 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
              cl2->SetType(8);
              fgPairs[ip*nn+jn]=8;
            }
              cl2->SetType(8);
              fgPairs[ip*nn+jn]=8;
            }

-
-         }
-         else{
-           cl2 = new AliITSRecPoint(milab,lp,info);
-           cl2->SetChargeRatio(ratio);         
-           cl2->SetType(7);
-           fgPairs[ip*nn+jn] =7;
-           if ((pos[ip].GetNd()+neg[jn].GetNd())>6){ //multi cluster
-             cl2->SetType(8);
-             fgPairs[ip*nn+jn]=8;
-           }
-
-           fDetTypeRec->AddRecPoint(*cl2);
-         }

          ncl++;
        }
        //
          ncl++;
        }
        //


@@ -1342,8 +1193,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        }
 
          AliITSRecPoint * cl2;
        }
 
          AliITSRecPoint * cl2;

-         if(clusters){
-           cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+           cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);

 
 
            cl2->SetChargeRatio(ratio);         
 
 
            cl2->SetChargeRatio(ratio);         


@@ -1353,21 +1203,6 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
              cl2->SetType(8);
              fgPairs[ip*nn+jn2]=8;
            }
              cl2->SetType(8);
              fgPairs[ip*nn+jn2]=8;
            }

-           
-         }
-         else{
-           cl2 = new AliITSRecPoint(milab,lp,info);
-           cl2->SetChargeRatio(ratio);         
-           fgPairs[ip*nn+jn2]=7;
-           cl2->SetType(7);
-           if ((pos[ip].GetNd()+neg[jn2].GetNd())>6){ //multi cluster
-             cl2->SetType(8);
-             fgPairs[ip*nn+jn2]=8;
-           }
-
-           fDetTypeRec->AddRecPoint(*cl2);
-         }
-

          ncl++;
        }
        cused1[ip]++;
          ncl++;
        }
        cused1[ip]++;


@@ -1489,8 +1324,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        }
 
        AliITSRecPoint * cl2;
        }
 
        AliITSRecPoint * cl2;

-       if(clusters){
-         cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+         cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);

                  
          cl2->SetChargeRatio(ratio);           
          cl2->SetType(10);
                  
          cl2->SetChargeRatio(ratio);           
          cl2->SetType(10);


@@ -1501,21 +1335,6 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          }
          cused1[ip]++;
          cused2[j]++;      
          }
          cused1[ip]++;
          cused2[j]++;      

-       }
-       else{
-         cl2 = new AliITSRecPoint(milab,lp,info);
-         cl2->SetChargeRatio(ratio);           
-         cl2->SetType(10);
-         fgPairs[ip*nn+j]=10;
-         if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
-           cl2->SetType(11);
-           fgPairs[ip*nn+j]=11;
-         }
-         cused1[ip]++;
-         cused2[j]++;      
-         
-         fDetTypeRec->AddRecPoint(*cl2);
-       }      

        ncl++;
        
       } // 2X2
        ncl++;
        
       } // 2X2


@@ -1628,8 +1447,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        }
 
        AliITSRecPoint * cl2;
        }
 
        AliITSRecPoint * cl2;

-       if(clusters){
-         cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+         cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);

                  
          cl2->SetChargeRatio(ratio);           
          cl2->SetType(12);
                  
          cl2->SetChargeRatio(ratio);           
          cl2->SetType(12);


@@ -1640,21 +1458,6 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          }
          cused1[ip]++;
          cused2[j]++;      
          }
          cused1[ip]++;
          cused2[j]++;      

-       }
-       else{
-         cl2 = new AliITSRecPoint(milab,lp,info);
-         cl2->SetChargeRatio(ratio);           
-         cl2->SetType(12);
-         fgPairs[ip*nn+j]=12;
-         if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
-           cl2->SetType(13);
-           fgPairs[ip*nn+j]=13;
-         }
-         cused1[ip]++;
-         cused2[j]++;      
-         
-         fDetTypeRec->AddRecPoint(*cl2);
-       }      

        ncl++;
        
       } // manyXmany
        ncl++;
        
       } // manyXmany


@@ -1730,26 +1533,13 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        }
 
        AliITSRecPoint * cl2;
        }
 
        AliITSRecPoint * cl2;

-       if(clusters){
-         cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+         cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);

 
          cl2->SetChargeRatio(ratio);
          cl2->SetType(100+cpositive[j]+cnegative[i]);    
 
          if(pos[i].GetQ()==0) cl2->SetType(200+cpositive[j]+cnegative[i]);
          if(neg[j].GetQ()==0) cl2->SetType(300+cpositive[j]+cnegative[i]);
 
          cl2->SetChargeRatio(ratio);
          cl2->SetType(100+cpositive[j]+cnegative[i]);    
 
          if(pos[i].GetQ()==0) cl2->SetType(200+cpositive[j]+cnegative[i]);
          if(neg[j].GetQ()==0) cl2->SetType(300+cpositive[j]+cnegative[i]);

-
-       }
-       else{
-         cl2 = new AliITSRecPoint(milab,lp,info);
-         cl2->SetChargeRatio(ratio);
-         cl2->SetType(100+cpositive[j]+cnegative[i]);
-         
-         if(pos[i].GetQ()==0) cl2->SetType(200+cpositive[j]+cnegative[i]);
-         if(neg[j].GetQ()==0) cl2->SetType(300+cpositive[j]+cnegative[i]);
-
-         fDetTypeRec->AddRecPoint(*cl2);
-       }

        ncl++;
       }
     }
        ncl++;
       }
     }


@@ -1810,17 +1600,9 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
              }
                      
              AliITSRecPoint * cl2;
              }
                      
              AliITSRecPoint * cl2;

-             if(clusters){
-               cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);          
+               cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);         

                cl2->SetChargeRatio(1.);
              cl2->SetType(50);   
                cl2->SetChargeRatio(1.);
              cl2->SetType(50);   

-             }
-             else{
-               cl2 = new AliITSRecPoint(milab,lp,info);
-               cl2->SetChargeRatio(1.);
-               cl2->SetType(50);
-               fDetTypeRec->AddRecPoint(*cl2);
-             }

              ncl++;
            } // cross is within the detector
            //
              ncl++;
            } // cross is within the detector
            //


@@ -1868,17 +1650,9 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
              }
              
              AliITSRecPoint * cl2;
              }
              
              AliITSRecPoint * cl2;

-             if(clusters){
-               cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);          
+               cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);         

                cl2->SetChargeRatio(1.);
                cl2->SetType(60);         
                cl2->SetChargeRatio(1.);
                cl2->SetType(60);         

-             }
-             else{
-               cl2 = new AliITSRecPoint(milab,lp,info);
-               cl2->SetChargeRatio(1.);
-               cl2->SetType(60);
-               fDetTypeRec->AddRecPoint(*cl2);
-             }

              ncl++;
            } // cross is within the detector
            //
              ncl++;
            } // cross is within the detector
            //


@@ -1922,17 +1696,9 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          if(info[0]>1) lp[2]=0.00097;
 
          AliITSRecPoint * cl2;
          if(info[0]>1) lp[2]=0.00097;
 
          AliITSRecPoint * cl2;

-         if(clusters){
-           cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);      
+           cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);     

            cl2->SetChargeRatio(1.);
            cl2->SetType(70);     
            cl2->SetChargeRatio(1.);
            cl2->SetType(70);     

-         }
-         else{
-           cl2 = new AliITSRecPoint(milab,lp,info);
-           cl2->SetChargeRatio(1.);
-           cl2->SetType(70);
-           fDetTypeRec->AddRecPoint(*cl2);
-         }

          ncl++;
        } // cross is within the detector
        //
          ncl++;
        } // cross is within the detector
        //


@@ -1972,17 +1738,9 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          if(info[1]>1) lp[2]=6.91e-05;
          
          AliITSRecPoint * cl2;
          if(info[1]>1) lp[2]=6.91e-05;
          
          AliITSRecPoint * cl2;

-         if(clusters){
-           cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);      
+           cl2 = new ((*clusters)[ncl]) AliITSRecPoint(milab,lp,info);     

            cl2->SetChargeRatio(1.);
            cl2->SetType(80);     
            cl2->SetChargeRatio(1.);
            cl2->SetType(80);     

-         }
-         else{
-           cl2 = new AliITSRecPoint(milab,lp,info);
-           cl2->SetChargeRatio(1.);
-           cl2->SetType(80);
-           fDetTypeRec->AddRecPoint(*cl2);
-         }

          ncl++;
        } // cross is within the detector
        //
          ncl++;
        } // cross is within the detector
        //