Updated version from B. Batyunya and E. Fragiacomo
authorbarbera <barbera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 10 May 2001 07:33:57 +0000 (07:33 +0000)
committerbarbera <barbera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 10 May 2001 07:33:57 +0000 (07:33 +0000)
ITS/AliITSClusterFinderSSD.cxx
ITS/AliITSClusterFinderSSD.h
ITS/AliITSRawCluster.h
ITS/AliITSclusterSSD.cxx
ITS/AliITSclusterSSD.h
ITS/SSDrecpointTest.C

index 42a7f84bad5835e83ec1a1eeff5fadccee43f7f3..17ef79dab632756f845c297fa64df6e46a44b470 100644 (file)
@@ -26,7 +26,6 @@
 #include "AliITSpackageSSD.h"
 #include "AliITSsegmentation.h"
 #include "AliITSgeom.h"
-#include "AliITSsegmentationSSD.h"
 
 const Bool_t AliITSClusterFinderSSD::fgkSIDEP=kTRUE;
 const Bool_t AliITSClusterFinderSSD::fgkSIDEN=kFALSE;
@@ -34,15 +33,15 @@ const Int_t debug=0;
 
 ClassImp(AliITSClusterFinderSSD)
 
-//______________________________________________________________________
+//____________________________________________________________________
 //
 //  Constructor
-//______________________________________________________________________
+//____________________________________________________________________
 //                                     
 
 
-AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg, 
-                                              TClonesArray *digits){
+AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg, TClonesArray *digits)   
+{
 //Standard constructor
 
     fSegmentation=seg;
@@ -60,6 +59,7 @@ AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg,
 
     fPackages =  new TClonesArray ("AliITSpackageSSD",200);    //packages  
     fNPackages = 0;
+
         
     fDigitsIndexP      =  new TArrayI(300);
     fNDigitsP          =  0;
@@ -71,7 +71,8 @@ AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg,
     fPNsignalRatio=7./8.;         // warning: hard-wired number
 
 }
-//----------------------------------------------------------------------
+
+//-------------------------------------------------------
 AliITSClusterFinderSSD::~AliITSClusterFinderSSD() {
 // Default destructor   
 
@@ -81,50 +82,63 @@ AliITSClusterFinderSSD::~AliITSClusterFinderSSD() {
     delete fDigitsIndexP;        
     delete fDigitsIndexN; 
     delete fMap;
+
 }
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::InitReconstruction(){
+
+//-------------------------------------------------------
+void AliITSClusterFinderSSD::InitReconstruction()
+{
 // initialization of the cluster finder
-    register Int_t i; //iterator
 
-    for (i=0;i<fNClusterP;i++){
-       fClusterP->RemoveAt(i);
-    } // end for i
-    fNClusterP  =0 ;
-    for (i=0;i<fNClusterN;i++){
-       fClusterN->RemoveAt(i);
-    } // end for i
-    fNClusterN=0;
+  register Int_t i; //iterator
 
-    for (i=0;i<fNPackages;i++){
-       fPackages->RemoveAt(i);
-    } // end for i
+  for (i=0;i<fNClusterP;i++)
+    {
+      fClusterP->RemoveAt(i);
+    }
+  fNClusterP  =0;
+  for (i=0;i<fNClusterN;i++)
+    {
+      fClusterN->RemoveAt(i);
+    }
+  fNClusterN=0;
 
-    fNPackages = 0;
-    fNDigitsP  = 0;
-    fNDigitsN  = 0;
+  for (i=0;i<fNPackages;i++)
+    {
+      fPackages->RemoveAt(i);
+    }
+
+  fNPackages = 0;
+  fNDigitsP=0;
+  fNDigitsN=0;
 
-    Float_t StereoP,StereoN;
-    fSegmentation->Angles(StereoP,StereoN);
+  Float_t StereoP,StereoN;
+  fSegmentation->Angles(StereoP,StereoN);
 
-    CalcStepFactor (StereoP,StereoN);
+  CalcStepFactor (StereoP,StereoN);
 
-    if (debug) cout<<"fSFF = "<<fSFF<<"  fSFB = "<<fSFB<<"\n";
+  if (debug) cout<<"fSFF = "<<fSFF<<"  fSFB = "<<fSFB<<"\n";
 }
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::FindRawClusters(Int_t module){
+
+
+//---------------------------------------------
+void AliITSClusterFinderSSD::FindRawClusters(Int_t module) 
+{
 // This function findes out all clusters belonging to one module
 // 1. Zeroes all space after previous module reconstruction
 // 2. Finds all neighbouring digits, create clusters
 // 3. If necesery, resolves for each group of neighbouring digits 
 //    how many clusters creates it.
-// 4. Colculate the x and z coordinate
+// 4. Colculate the x and z coordinate  
+
   Int_t lay, lad, detect;
   AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
   AliITSgeom *geom = aliITS->GetITSgeom();
-  geom->GetModuleId(module,lay, lad, detect);
-  if ( lay == 6 )((AliITSsegmentationSSD*)fSegmentation)->SetLayer(6);
-  if ( lay == 5 )((AliITSsegmentationSSD*)fSegmentation)->SetLayer(5);
+           geom->GetModuleId(module,lay, lad, detect);
+            if ( lay == 6 )
+             ((AliITSsegmentationSSD*)fSegmentation)->SetLayer(6);
+           if ( lay == 5 )
+             ((AliITSsegmentationSSD*)fSegmentation)->SetLayer(5);
 
   InitReconstruction();  //ad. 1
   fMap->FillMap();
@@ -136,373 +150,441 @@ void AliITSClusterFinderSSD::FindRawClusters(Int_t module){
   AliITSRecPoint rnew;
   fMap->ClearMap();
 }
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::FindNeighbouringDigits(){
+
+
+//-------------------------------------------------
+void AliITSClusterFinderSSD::FindNeighbouringDigits()
+{
 //If there are any digits on this side, create 1st Cluster,
 // add to it this digit, and increment number of clusters
-    register Int_t i;
-
-    if ((fNDigitsP>0 )  && (fNDigitsN > 0 )) {     
-
-       Int_t currentstripNo;
-       Int_t *dbuffer = new Int_t [300];   //buffer for strip numbers
-       Int_t dnumber;    //curent number of digits in buffer
-       TArrayI      &lDigitsIndexP = *fDigitsIndexP;
-       TArrayI      &lDigitsIndexN = *fDigitsIndexN;
-       TObjArray    &lDigits       = *(Digits());
-       TClonesArray &lClusterP     = *fClusterP;
-       TClonesArray &lClusterN     = *fClusterN;
-
-       //process P side 
-       dnumber = 1;
-       dbuffer[0]=lDigitsIndexP[0];
-       // If next digit is a neighbour of previous, adds to last cluster
-       // this digit
-       for (i=1; i<fNDigitsP; i++) {
-           //reads new digit
-           currentstripNo = ((AliITSdigitSSD*)lDigits[lDigitsIndexP[i]])->
-                                                            GetStripNumber(); 
-           //check if it is a neighbour of a previous one
-           if((((AliITSdigitSSD*)lDigits[lDigitsIndexP[i-1]])->
-               GetStripNumber()) == (currentstripNo-1) ){
-               dbuffer[dnumber++]=lDigitsIndexP[i];
-           }else{ 
-               //create a new one side cluster
-               new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,
-                                                  dbuffer,Digits(),fgkSIDEP); 
-               dbuffer[0]=lDigitsIndexP[i];
-               dnumber = 1;
-           } // end if
-       } // end loop over fNDigitsP
-       new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,
-                                                     Digits(),fgkSIDEP);
-       //process N side 
-       //for comments, see above
-       dnumber = 1;
-       dbuffer[0]=lDigitsIndexN[0];
-       // If next digit is a neighbour of previous, adds to last cluster
-       // this digit
-       for (i=1; i<fNDigitsN; i++) { 
-           currentstripNo = ((AliITSdigitSSD*)(lDigits[lDigitsIndexN[i]]))->
+
+
+ register Int_t i;
+
+
+ if ((fNDigitsP>0 )  && (fNDigitsN > 0 )) {     
+
+   Int_t currentstripNo;
+   Int_t *dbuffer = new Int_t [300];   //buffer for strip numbers
+   Int_t dnumber;    //curent number of digits in buffer
+   TArrayI      &lDigitsIndexP = *fDigitsIndexP;
+   TArrayI      &lDigitsIndexN = *fDigitsIndexN;
+   TObjArray    &lDigits       = *(Digits());
+   TClonesArray &lClusterP     = *fClusterP;
+   TClonesArray &lClusterN     = *fClusterN;
+  
+   //process P side 
+   dnumber = 1;
+   dbuffer[0]=lDigitsIndexP[0];
+   //If next digit is a neighbour of previous, adds to last cluster this digit
+   for (i=1; i<fNDigitsP; i++) {
+     //reads new digit
+     currentstripNo = ((AliITSdigitSSD*)lDigits[lDigitsIndexP[i]])->
+                                                            GetStripNumber(); 
+     //check if it is a neighbour of a previous one
+     if ( (((AliITSdigitSSD*)lDigits[lDigitsIndexP[i-1]])->GetStripNumber()) 
+           ==  (currentstripNo-1) ) dbuffer[dnumber++]=lDigitsIndexP[i];
+     else  { 
+       //create a new one side cluster
+       new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,Digits(),fgkSIDEP); 
+       dbuffer[0]=lDigitsIndexP[i];
+       dnumber = 1;
+     }
+   } // end loop over fNDigitsP
+   new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,Digits(),fgkSIDEP);
+
+
+   //process N side 
+   //for comments, see above
+   dnumber = 1;
+   dbuffer[0]=lDigitsIndexN[0];
+   //If next digit is a neighbour of previous, adds to last cluster this digit
+   for (i=1; i<fNDigitsN; i++) { 
+     currentstripNo = ((AliITSdigitSSD*)(lDigits[lDigitsIndexN[i]]))->
                                                             GetStripNumber();
-           if ( (((AliITSdigitSSD*)lDigits[lDigitsIndexN[i-1]])->
-                 GetStripNumber()) == (currentstripNo-1) ){
-               dbuffer[dnumber++]=lDigitsIndexN[i];
-           }else{
-               new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,
-                                                            Digits(),fgkSIDEN);
-               dbuffer[0]=lDigitsIndexN[i];
-               dnumber = 1;
-           } // end if
-       } // end loop over fNDigitsN
-       new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,
-                                                     Digits(),fgkSIDEN);
-       delete [] dbuffer;
-    } // end condition on  NDigits 
-
-    if (debug) cout<<"\n Found clusters: fNClusterP = "<<fNClusterP<<
-                  "  fNClusterN ="<<fNClusterN<<"\n";
-}
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::SeparateOverlappedClusters(){
+     if ( (((AliITSdigitSSD*)lDigits[lDigitsIndexN[i-1]])->GetStripNumber()) 
+           == (currentstripNo-1) ) dbuffer[dnumber++]=lDigitsIndexN[i];
+     else {
+       new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,Digits(),fgkSIDEN);
+       dbuffer[0]=lDigitsIndexN[i];
+       dnumber = 1;
+     }
+   } // end loop over fNDigitsN
+   new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,Digits(),fgkSIDEN);
+   delete [] dbuffer; 
+ } // end condition on  NDigits 
+
+ if (debug) cout<<"\n Found clusters: fNClusterP = "<<fNClusterP<<"  fNClusterN ="<<fNClusterN<<"\n";
+
+}  
+
+//--------------------------------------------------------------
+
+void AliITSClusterFinderSSD::SeparateOverlappedClusters()
+{
 // overlapped clusters separation
-    register Int_t i; //iterator
-    Float_t  factor=0.75;           // How many percent must be lower signal
-                                    // on the middle one digit
-                                    // from its neighbours
-    Int_t    signal0;               //signal on strip before the current one
-    Int_t    signal1;               //signal on the current one signal
-    Int_t    signal2;               //signal on the strip after the current one
-    TArrayI *splitlist;             //  List of splits
-    Int_t    numerofsplits=0;       // number of splits
-    Int_t    initPsize = fNClusterP;//initial size of the arrays 
-    Int_t    initNsize = fNClusterN;//we have to keep it because it will grow 
-                                    // in this function and it doasn't make 
-                                    // sense to pass through it again
-
-    splitlist = new TArrayI(300);
-
-    for (i=0;i<initPsize;i++){
-       if((((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==1) continue;
-       if((((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==2) continue;
+
+  register Int_t i; //iterator
+
+  Float_t  factor=0.75;            // How many percent must be lower signal 
+                                   // on the middle one digit
+                                   // from its neighbours
+  Int_t    signal0;                //signal on the strip before the current one
+  Int_t    signal1;                //signal on the current one signal
+  Int_t    signal2;                //signal on the strip after the current one
+  TArrayI *splitlist;              //  List of splits
+  Int_t    numerofsplits=0;        // number of splits
+  Int_t    initPsize = fNClusterP; //initial size of the arrays 
+  Int_t    initNsize = fNClusterN; //we have to keep it because it will grow 
+                                   // in this function and it doasn't make 
+                                   // sense to pass through it again
+
+  splitlist = new TArrayI(300);
+
+  for (i=0;i<initPsize;i++)
+  {
+    if (( ((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==1) continue;
+    if (( ((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==2) continue;
         Int_t nj=(((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits()-1);
-        for (Int_t j=1; j<nj; j++){
+        for (Int_t j=1; j<nj; j++)
+          {
             signal1=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j);
             signal0=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j-1);
             signal2=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j+1);
             //if signal is less then factor*signal of its neighbours
-            if (  (signal1<(factor*signal0)) && (signal1<(factor*signal2)) ){
-               (*splitlist)[numerofsplits++]=j;  
-           } // end if
-       } // end loop over number of digits
+            if (  (signal1<(factor*signal0)) && (signal1<(factor*signal2)) )
+             {                                                               
+               (*splitlist)[numerofsplits++]=j;  
+            }
+         } // end loop over number of digits
           //split this cluster if necessary
-       if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEP);
-       numerofsplits=0;
-
-       //in signed places (splitlist)
-    } // end loop over clusters on Pside
-
-    for (i=0;i<initNsize;i++) {
-       if((((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==1) continue;
-       if((((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==2) continue;
-       Int_t nj=(((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits()-1);
-       for (Int_t j=1; j<nj; j++){
+          if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEP);
+         numerofsplits=0;
+
+         //in signed places (splitlist)
+  } // end loop over clusters on Pside
+
+  for (i=0;i<initNsize;i++) {
+    if (( ((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==1) continue;
+    if (( ((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==2) continue;
+       Int_t nj=(((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits()-1);
+       for (Int_t j=1; j<nj; j++)
+          {
             signal1=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j);
             signal0=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j-1);
             signal2=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j+1);
             //if signal is less then factor*signal of its neighbours
             if (  (signal1<(factor*signal0)) && (signal1<(factor*signal2)) ) 
-               (*splitlist)[numerofsplits++]=j;  
-       } // end loop over number of digits 
-       //split this cluster into more clusters
-       if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEN);
-       numerofsplits=0;                                                              //in signed places (splitlist)
-    } // end loop over clusters on Nside
-
-    delete splitlist;
+               (*splitlist)[numerofsplits++]=j;  
+          } // end loop over number of digits 
+          //split this cluster into more clusters
+          if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEN);
+         numerofsplits=0;                                                              //in signed places (splitlist)
+  } // end loop over clusters on Nside
+
+  delete splitlist;
 }
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::SplitCluster(TArrayI *list, Int_t nsplits,
-                                         Int_t index, Bool_t side){
-    //This function splits one side cluster into more clusters
-    //number of splits is defined by "nsplits"
-    //Place of splits are defined in the TArray "list"
-    // For further optimisation: Replace this function by two 
-    // specialised ones (each for one side)
-    // save one "if"
-    //For comlete comments see AliITSclusterSSD::SplitCluster
-    register Int_t i; //iterator
-    AliITSclusterSSD* curentcluster;
-    Int_t   *tmpdigits = new Int_t[100];
-    Int_t    NN;
-    // side true means P side
-
-    if (side) {
-       curentcluster =((AliITSclusterSSD*)((*fClusterP)[index])) ;
-       for (i = nsplits; i>0 ;i--) {  
-           NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
-           new ((*fClusterP)[fNClusterP]) AliITSclusterSSD(NN,
-                                                     tmpdigits,Digits(),side);
-           ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
-               SetLeftNeighbour(kTRUE);
-           //if left cluster had neighbour on the right before split 
-           //new should have it too
-           if ( curentcluster->GetRightNeighbour() ) 
-               ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
-                   SetRightNeighbour(kTRUE);
-           else curentcluster->SetRightNeighbour(kTRUE); 
-           fNClusterP++;
-       } // end loop over nplits
-    } else {
-       curentcluster =((AliITSclusterSSD*)((*fClusterN)[index]));
-       for (i = nsplits; i>0 ;i--) {  
-           NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
-           new ((*fClusterN)[fNClusterN]) AliITSclusterSSD(NN,
-                                                     tmpdigits,Digits(),side);
-           ((AliITSclusterSSD*)((*fClusterN)[fNClusterN]))->
-               SetRightNeighbour(kTRUE);
-           if (curentcluster->GetRightNeighbour())
-               ( (AliITSclusterSSD*)( (*fClusterN)[fNClusterN]) )->
-                   SetRightNeighbour(kTRUE);
-           else curentcluster->SetRightNeighbour(kTRUE);      
-           fNClusterN++;
-       } // end loop over nplits
-    } // end if side
-    delete []tmpdigits;
+
+//-------------------------------------------------------
+void AliITSClusterFinderSSD::SplitCluster(TArrayI *list, Int_t nsplits, Int_t index, Bool_t side)
+{
+  //This function splits one side cluster into more clusters
+  //number of splits is defined by "nsplits"
+  //Place of splits are defined in the TArray "list" 
+  
+  // For further optimisation: Replace this function by two 
+  // specialised ones (each for one side)
+  // save one "if"
+
+  //For comlete comments see AliITSclusterSSD::SplitCluster
+
+
+  register Int_t i; //iterator
+
+  AliITSclusterSSD* curentcluster;
+  Int_t   *tmpdigits = new Int_t[100];
+  Int_t    NN;
+  // side true means P side
+  if (side) {
+     curentcluster =((AliITSclusterSSD*)((*fClusterP)[index])) ;
+     for (i = nsplits; i>0 ;i--) {  
+         NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
+         new ((*fClusterP)[fNClusterP]) AliITSclusterSSD(NN,tmpdigits,Digits(),side);
+        ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
+                                                      SetLeftNeighbour(kTRUE);
+         //if left cluster had neighbour on the right before split 
+        //new should have it too
+        if ( curentcluster->GetRightNeighbour() ) 
+                     ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
+                                                     SetRightNeighbour(kTRUE);
+         else curentcluster->SetRightNeighbour(kTRUE); 
+        fNClusterP++;
+     } // end loop over nplits
+  } else {
+     curentcluster =((AliITSclusterSSD*)((*fClusterN)[index]));
+     for (i = nsplits; i>0 ;i--) {  
+         NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
+        new ((*fClusterN)[fNClusterN]) AliITSclusterSSD(NN,tmpdigits,Digits(),side);
+        ((AliITSclusterSSD*)((*fClusterN)[fNClusterN]))->
+                                                    SetRightNeighbour(kTRUE);
+        if (curentcluster->GetRightNeighbour())
+                      ( (AliITSclusterSSD*)( (*fClusterN)[fNClusterN]) )->
+                                                     SetRightNeighbour(kTRUE);
+        else curentcluster->SetRightNeighbour(kTRUE);      
+        fNClusterN++;
+     } // end loop over nplits
+  } // end if side
+  delete []tmpdigits;
+
 }
-//----------------------------------------------------------------------
-Int_t AliITSClusterFinderSSD::SortDigitsP(Int_t start, Int_t end){
+
+
+//-------------------------------------------------
+Int_t AliITSClusterFinderSSD::SortDigitsP(Int_t start, Int_t end)
+{
 // sort digits on the P side
-    Int_t right;
-    Int_t left;
-    if (start != (end - 1) ){
-       left=this->SortDigitsP(start,(start+end)/2);
-       right=this->SortDigitsP((start+end)/2,end);  
-       return (left || right);
-    }else{ 
-       left = ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[start]]))->
-                                                             GetStripNumber();
-       right= ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[end]]))->
-                                                             GetStripNumber();
-       if( left > right ){
-           Int_t tmp = (*fDigitsIndexP)[start];
-           (*fDigitsIndexP)[start]=(*fDigitsIndexP)[end];
-           (*fDigitsIndexP)[end]=tmp;
-           return 1;
-       } // end if
-       else return 0;
-    } // end if
+
+  
+  Int_t right;
+  Int_t left;
+  if (start != (end - 1) ) 
+    {
+      left=this->SortDigitsP(start,(start+end)/2);
+      right=this->SortDigitsP((start+end)/2,end);  
+      return (left || right);
+    }
+  else
+   { 
+    left =  ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[start]]))->GetStripNumber();
+    right= ((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexP)[end]]))->GetStripNumber();  
+    if( left > right )
+     {
+       Int_t tmp = (*fDigitsIndexP)[start];
+       (*fDigitsIndexP)[start]=(*fDigitsIndexP)[end];
+       (*fDigitsIndexP)[end]=tmp;
+       return 1;
+     }
+    else return 0;
+   }
 }
-//----------------------------------------------------------------------
-Int_t AliITSClusterFinderSSD::SortDigitsN(Int_t start, Int_t end){
+
+
+//--------------------------------------------------
+
+Int_t AliITSClusterFinderSSD::SortDigitsN(Int_t start, Int_t end)
+{
 // sort digits on the N side
-    Int_t right;
-    Int_t left;
-
-    if (start != (end - 1)){
-       left=this->SortDigitsN(start,(start+end)/2);
-       right=this->SortDigitsN((start+end)/2,end);  
-       return (left || right);
-    }else{
-       left =((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[start]]))->
-                                                            GetStripNumber(); 
-       right=((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[end]]))->
-                                                             GetStripNumber();
-       if ( left > right ){
-           Int_t tmp = (*fDigitsIndexN)[start];
-           (*fDigitsIndexN)[start]=(*fDigitsIndexN)[end];
-           (*fDigitsIndexN)[end]=tmp;
-           return 1;
-       }else return 0;
-    } // end if
+
+  Int_t right;
+  Int_t left;
+  if (start != (end - 1)) 
+    {
+      left=this->SortDigitsN(start,(start+end)/2);
+      right=this->SortDigitsN((start+end)/2,end);  
+      return (left || right);
+    }
+  else 
+   {
+    left =((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[start]]))->GetStripNumber(); 
+    right=((AliITSdigitSSD*)((*(Digits()))[(*fDigitsIndexN)[end]]))->GetStripNumber();
+    if ( left > right )
+      {
+        Int_t tmp = (*fDigitsIndexN)[start];
+        (*fDigitsIndexN)[start]=(*fDigitsIndexN)[end];
+        (*fDigitsIndexN)[end]=tmp;
+        return 1;
+      }else return 0;
+   }  
 }
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::FillDigitsIndex(){
-    //Fill the indexes of the clusters belonging to a given ITS module
-    Int_t PNs=0, NNs=0;
-    Int_t tmp,bit,k;
-    Int_t N;
-    Int_t i;
-
-    N = fDigits->GetEntriesFast();
-
-    Int_t* PSidx = new Int_t [N*sizeof(Int_t)];
-    Int_t* NSidx = new Int_t [N*sizeof(Int_t)]; 
-    if (fDigitsIndexP==NULL) fDigitsIndexP = new TArrayI(N);
-    if (fDigitsIndexN==NULL) fDigitsIndexN = new TArrayI(N);
-
-    AliITSdigitSSD *dig;
-
-    for ( i = 0 ; i< N; i++ ) {
-       dig = (AliITSdigitSSD*)GetDigit(i);
-       if(dig->IsSideP()) { 
-           bit=1;
-           tmp=dig->GetStripNumber();
-           // I find this totally unnecessary - it's just a 
-           // CPU consuming double check
-           for( k=0;k<PNs;k++){
-               if (tmp==PSidx[k]){
-                   if (debug) cout<<"Such a digit exists \n";
-                   bit=0;
-               } // end if
-           } // end if
-           // end comment 
-           if(bit) {
-               fDigitsIndexP->AddAt(i,fNDigitsP++);
-               PSidx[PNs++]=tmp;
-           } // end if bit
-       } else {
-           bit=1;
-           tmp=dig->GetStripNumber();
-           // same as above
-           for( k=0;k<NNs;k++){
-               if (tmp==NSidx[k]){
-                   if (debug) cout<<"Such a digit exists \n";
-                   bit=0;
-               } // end if
-           } // end for k
-           // end comment
-           if (bit) {
-               fDigitsIndexN->AddAt(i,fNDigitsN++);
-               NSidx[NNs++] =tmp;
-           } // end if bit
-       } // end for dig->IsSideP()
-    } // end for i
+
+
+//------------------------------------------------
+void AliITSClusterFinderSSD::FillDigitsIndex()
+{
+ //Fill the indexes of the clusters belonging to a given ITS module
+
+ Int_t PNs=0, NNs=0;
+ Int_t tmp,bit,k;
+ Int_t N;
+ Int_t i;
+ N = fDigits->GetEntriesFast();
+
+ Int_t* PSidx = new Int_t [N*sizeof(Int_t)];
+ Int_t* NSidx = new Int_t [N*sizeof(Int_t)]; 
+ if (fDigitsIndexP==NULL) fDigitsIndexP = new TArrayI(N);
+ if (fDigitsIndexN==NULL) fDigitsIndexN = new TArrayI(N);
+ AliITSdigitSSD *dig; 
+ for ( i = 0 ; i< N; i++ ) {
+      dig = (AliITSdigitSSD*)GetDigit(i);
+      if(dig->IsSideP()) { 
+           bit=1;
+           tmp=dig->GetStripNumber();
+          // I find this totally unnecessary - it's just a 
+          // CPU consuming double check
+           for( k=0;k<PNs;k++)
+            {
+             if (tmp==PSidx[k])
+              {
+                 if (debug) cout<<"Such a digit exists \n";
+                 bit=0;
+              }
+           }   
+          // end comment 
+        if(bit) {
+            fDigitsIndexP->AddAt(i,fNDigitsP++);
+            PSidx[PNs++]=tmp;
+       }
+      } else {
+         bit=1;
+         tmp=dig->GetStripNumber();
+        // same as above
+         for( k=0;k<NNs;k++)
+          {
+           if (tmp==NSidx[k])
+            {
+             if (debug) cout<<"Such a digit exists \n";
+             bit=0;
+            }
+          } 
+        // end comment
+         if (bit) {
+          fDigitsIndexN->AddAt(i,fNDigitsN++);
+          NSidx[NNs++] =tmp;
+        }
+      }
+ }
    
   delete [] PSidx;
   delete [] NSidx;
+ delete [] PSidx;
+ delete [] NSidx;
 
   if (debug) cout<<"Digits :  P = "<<fNDigitsP<<"   N = "<<fNDigitsN<<endl;
+ if (debug) cout<<"Digits :  P = "<<fNDigitsP<<"   N = "<<fNDigitsN<<endl;
 
 }
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::SortDigits(){
+
+
+//-------------------------------------------
+
+void AliITSClusterFinderSSD::SortDigits()
+{
 // sort digits
-    Int_t i;
 
-    if(fNDigitsP>1) 
-       for (i=0;i<fNDigitsP-1;i++)
-           if (SortDigitsP(0,(fNDigitsP-1-i))==0) break;
+  Int_t i;
+  if(fNDigitsP>1) 
+  for (i=0;i<fNDigitsP-1;i++)
+  if (SortDigitsP(0,(fNDigitsP-1-i))==0) break;
 
-    if(fNDigitsN>1) 
-       for (i=0;i<fNDigitsN-1;i++)
-           if(SortDigitsN(0,(fNDigitsN-1-i))==0) break;
+  if(fNDigitsN>1) 
+    for (i=0;i<fNDigitsN-1;i++)
+  if(SortDigitsN(0,(fNDigitsN-1-i))==0) break;
 }
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::FillClIndexArrays(Int_t* arrayP, Int_t *arrayN){
+
+
+
+//----------------------------------------------
+void AliITSClusterFinderSSD::FillClIndexArrays(Int_t* arrayP, Int_t *arrayN)
+{
 // fill cluster index array
-    register Int_t i;
-
-    for (i=0; i<fNClusterP;i++){
-       arrayP[i]=i;
-    } // end for i
-    for (i=0; i<fNClusterN;i++){
-       arrayN[i]=i;
-    } // end for i
+
+  register Int_t i;
+  for (i=0; i<fNClusterP;i++)
+    {
+      arrayP[i]=i;
+    }
+  for (i=0; i<fNClusterN;i++)
+    {
+      arrayN[i]=i;
+    }
 }
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::SortClusters(Int_t* arrayP, Int_t *arrayN){
+
+
+//------------------------------------------------------
+void AliITSClusterFinderSSD::SortClusters(Int_t* arrayP, Int_t *arrayN)
+{
 // sort clusters
-    Int_t i;
-
-    if(fNClusterP>1) 
-       for (i=0;i<fNClusterP-1;i++)
-           if (SortClustersP(0,(fNClusterP-1),arrayP)==0)  break;
-    if(fNClusterN>1) 
-       for (i=0;i<fNClusterN-1;i++)
-           if (SortClustersN(0,(fNClusterN-1),arrayN)==0)  break;
+
+  Int_t i;
+  if(fNClusterP>1) 
+    for (i=0;i<fNClusterP-1;i++)
+      if (SortClustersP(0,(fNClusterP-1),arrayP)==0)  break;
+    
+    
+  if(fNClusterN>1) 
+    for (i=0;i<fNClusterN-1;i++)
+      if (SortClustersN(0,(fNClusterN-1),arrayN)==0)  break;
+
 }
-//----------------------------------------------------------------------
-Int_t AliITSClusterFinderSSD::SortClustersP(Int_t start, Int_t end,
-                                           Int_t *array){
+
+
+
+//---------------------------------------------------
+Int_t AliITSClusterFinderSSD::SortClustersP(Int_t start, Int_t end, Int_t *array)
+{
 //Sort P side clusters
-    Int_t right;
-    Int_t left;
-
-    if (start != (end - 1) ) {
-       left=this->SortClustersP(start,(start+end)/2,array);
-       right=this->SortClustersP((start+end)/2,end,array);  
-       return (left || right);
-    } else {
-       left =((AliITSclusterSSD*)((*fClusterP)[array[start]]))->
-           GetDigitStripNo(0);
-       right=((AliITSclusterSSD*)((*fClusterP)[array[ end ]]))->
-           GetDigitStripNo(0);
-       if(left>right) {
-           Int_t tmp = array[start];
-           array[start]=array[end];
-           array[end]=tmp;
-           return 1;
-       } else return 0;
-    } // end for start
+
+
+  Int_t right;
+  Int_t left;
+  if (start != (end - 1) ) {
+      left=this->SortClustersP(start,(start+end)/2,array);
+      right=this->SortClustersP((start+end)/2,end,array);  
+      return (left || right);
+  } else {
+      left =((AliITSclusterSSD*)((*fClusterP)[array[start]]))->
+                                                         GetDigitStripNo(0);
+      right=((AliITSclusterSSD*)((*fClusterP)[array[ end ]]))->
+                                                         GetDigitStripNo(0);
+      if(left>right) {
+         Int_t tmp = array[start];
+        array[start]=array[end];
+        array[end]=tmp;
+        return 1;
+      } else return 0;
+  }
+
 }
+
+
+
 //-------------------------------------------------------
-Int_t AliITSClusterFinderSSD::SortClustersN(Int_t start, Int_t end,
-                                           Int_t *array){
+Int_t AliITSClusterFinderSSD::SortClustersN(Int_t start, Int_t end, Int_t *array)
+{
 //Sort N side clusters
-    Int_t right;
-    Int_t left;
-
-    if (start != (end - 1) ) {
-       left=this->SortClustersN(start,(start+end)/2,array);
-       right=this->SortClustersN((start+end)/2,end,array);  
-       return (left || right);
-    } else {
-       left =((AliITSclusterSSD*)((*fClusterN)[array[start]]))->
-           GetDigitStripNo(0);
-       right=((AliITSclusterSSD*)((*fClusterN)[array[ end ]]))->
-           GetDigitStripNo(0);
-       if( left > right) {
-           Int_t tmp = array[start];
-           array[start]=array[end];
-           array[end]=tmp;
-           return 1;
-       } else return 0;
-    } // end for start
+
+
+  Int_t right;
+  Int_t left;
+  
+  if (start != (end - 1) ) {
+      left=this->SortClustersN(start,(start+end)/2,array);
+      right=this->SortClustersN((start+end)/2,end,array);  
+      return (left || right);
+  } else {
+      left =((AliITSclusterSSD*)((*fClusterN)[array[start]]))->
+                                                         GetDigitStripNo(0);
+      right=((AliITSclusterSSD*)((*fClusterN)[array[ end ]]))->
+                                                         GetDigitStripNo(0);
+      if( left > right) {
+         Int_t tmp = array[start];
+         array[start]=array[end];
+         array[end]=tmp;
+         return 1;
+      } else return 0;
+    } 
+
 }
-//----------------------------------------------------------------------
-void AliITSClusterFinderSSD::ClustersToPackages(){  
-// fill packages    
+    
+
+
+//-------------------------------------------------------
+void AliITSClusterFinderSSD::ClustersToPackages()
+{  
+// fill packages   
+    
   Int_t *oneSclP = new Int_t[fNClusterP]; //I want to have sorted 1 S clusters
   Int_t *oneSclN = new Int_t[fNClusterN]; //I can not sort it in TClonesArray
                                           //so, I create table of indexes and 
@@ -566,6 +648,8 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
 
   Int_t n=0;
   Int_t *tr;
+  Int_t NTracks;
+
   if (GetCrossing(P,N)) {
   
     //GetCrossingError(dP,dN);
@@ -585,38 +669,37 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
 
      Float_t signalCut = TMath::Abs((SigP-SigN)/signal);
 
-     cnew.fSignalP=SigP;
-     cnew.fSignalN=SigN;
-     cnew.fMultiplicity=nstripsP;
-     cnew.fMultiplicityN=nstripsN;
-     cnew.fQErr=signalCut;
-
-     //fITS->AddCluster(2,&cnew);
-
-     if(signalCut<0.18) fITS->AddCluster(2,&cnew);
-     // the cut of the signals difference in P and N sides to
-     // remove the "ghosts"
 
      tr = (Int_t*) clusterP->GetTracks(n);
-
-     AliITSRecPoint rnew;
-     rnew.SetX(P*kconv);
-     rnew.SetZ(N*kconv);
-     rnew.SetQ(signal);
-     rnew.SetdEdX(dedx);
-     rnew.SetSigmaX2( kRMSx* kRMSx); 
-     rnew.SetSigmaZ2( kRMSz* kRMSz);
-     rnew.fTracks[0]=tr[0];
-     rnew.fTracks[1]=tr[1];
-     rnew.fTracks[2]=tr[2];
-
-     //fITS->AddRecPoint(rnew);
-
-     if(signalCut<0.18) fITS->AddRecPoint(rnew);
+     NTracks = clusterP->GetNTracks();
+     //cout<<"NewRec: NTracks,tr0,tr1,tr2 ="<<NTracks<<","<<tr[0]<<","<<tr[1]<<","<<tr[2]<<endl;
+     if(NTracks>0 && signalCut<0.18) {
      // the cut of the signals difference in P and N sides to
      // remove the "ghosts"
-
-     return kTRUE;
+       cnew.fSignalP=SigP;
+       cnew.fSignalN=SigN;
+       cnew.fMultiplicity=nstripsP;
+       cnew.fMultiplicityN=nstripsN;
+       cnew.fQErr=signalCut;
+       cnew.fNtracks=NTracks;
+
+       fITS->AddCluster(2,&cnew);
+
+       AliITSRecPoint rnew;
+       rnew.SetX(P*kconv);
+       rnew.SetZ(N*kconv);
+       rnew.SetQ(signal);
+       rnew.SetdEdX(dedx);
+       rnew.SetSigmaX2( kRMSx* kRMSx); 
+       rnew.SetSigmaZ2( kRMSz* kRMSz);
+       rnew.fTracks[0]=tr[0];
+       rnew.fTracks[1]=tr[1];
+       rnew.fTracks[2]=tr[2];
+
+       fITS->AddRecPoint(rnew);
+
+       return kTRUE;
+     }
   }
      return kFALSE;  
 }
index 0e69d197bf5840504b02c00b39d88c3f7aeb5555..016bcbb2136f0229d49bb5124a3989ee6fdf8702 100644 (file)
@@ -5,6 +5,7 @@
 
 #include <TMath.h>
 #include "AliITSClusterFinder.h"
+#include "AliITSsegmentationSSD.h"
 
 class TArrayI;
 class AliITSclusterSSD;
@@ -19,14 +20,8 @@ public:
                
   virtual ~AliITSClusterFinderSSD();
 
+  void FindRawClusters(Int_t module);    
 
-  void FindRawClusters(Int_t mod);
-
-  /*
-  void SetAlpha1(Float_t a) {fAlpha1 =a;}
-  void SetAlpha2(Float_t a) {fAlpha2 =a;}
-  void SetAlpha3(Float_t a) {fAlpha3 =a;}
-  */
  protected:
    
   void      InitReconstruction();
index a814d697e41206b753b50a07da05a6165c125bd5..6853fba0e1593463626eb3c443c94e75d37d0d2e 100644 (file)
@@ -310,6 +310,7 @@ public:
     fSignalP=0;
     fSignalN=0;
     fStatus=-1;
+    fNtracks=0;
   }
   AliITSRawClusterSSD(Float_t Prob,Int_t Sp,Int_t Sn);
   virtual ~AliITSRawClusterSSD() {
@@ -336,6 +337,8 @@ public:
                            //               1 - ghost 
                            //               2 - EIC ? 
                            //               3 - single side 
+  Int_t fNtracks;          // Number of tracks created the cluster
+
   
   // Float_t fProbability;    // The probability that this is a "real" point
   // Int_t  fIndexMapN[100];  // indices of digits for Nside - the corresponding
index 30aa2bd9a139bb3600b936236c5e0437665c9dc0..4ef957470cd4cf55706666d64014f4d1ef1102cc 100644 (file)
@@ -1,5 +1,4 @@
 #include <iostream.h>
-
 #include "AliITSdigit.h"
 #include "AliITSclusterSSD.h"
 
@@ -8,13 +7,14 @@ ClassImp(AliITSclusterSSD)
 AliITSclusterSSD::AliITSclusterSSD()
 {
   // default constructor
+
        fSide        = kTRUE;
        fDigits      = 0;
        fNDigits     = 0;
        fDigitsIndex = 0;
         fNCrosses    = 0;
        fTotalSignal = -1;
-       fNTrack      = -1;
+       fNTracks      = -1;
        fLeftNeighbour  = kFALSE;
        fRightNeighbour = kFALSE;
        fCrossedClusterIndexes = new TArrayI(300);
@@ -28,7 +28,7 @@ AliITSclusterSSD::AliITSclusterSSD
    TObjArray *Digits, Bool_t side)
 {
   // non-default constructor
-  
+
        fNDigits = ndigits;
        fDigits = Digits;
        fSide = side;
@@ -38,7 +38,7 @@ AliITSclusterSSD::AliITSclusterSSD
        fLeftNeighbour  = kFALSE;
        fRightNeighbour = kFALSE;
        fTotalSignal =-1;
-       fNTrack      = -1;
+       fNTracks    = -1;
         fConsumed=kFALSE;
 }
 /*************************************************************************/
@@ -53,6 +53,7 @@ AliITSclusterSSD::~AliITSclusterSSD()
 AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster)
 {
   // copy constructor
+
   if (this == &OneSCluster) return;
   fNDigits = OneSCluster.fNDigits;
   fSide=OneSCluster.fSide;
@@ -61,7 +62,7 @@ AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster)
   fLeftNeighbour  = OneSCluster.fLeftNeighbour;
   fRightNeighbour = OneSCluster.fRightNeighbour;
   fTotalSignal =-1;
-  fNTrack      = -1;
+  fNTracks     = -1;
   fNCrosses = OneSCluster.fNCrosses;
   fConsumed = OneSCluster.fConsumed;
   Int_t i;
@@ -80,6 +81,7 @@ AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster)
 AliITSclusterSSD& AliITSclusterSSD::operator=(const AliITSclusterSSD & OneSCluster)
 {
   // assignment operator
+
   if (this == &OneSCluster) return *this;
   fNDigits = OneSCluster.fNDigits;
   fSide=OneSCluster.fSide;
@@ -88,7 +90,7 @@ AliITSclusterSSD& AliITSclusterSSD::operator=(const AliITSclusterSSD & OneSClust
   fLeftNeighbour  = OneSCluster.fLeftNeighbour;
   fRightNeighbour = OneSCluster.fRightNeighbour;
   fTotalSignal =-1;
-  fNTrack      = -1;
+  fNTracks     = -1;
   fNCrosses = OneSCluster.fNCrosses;
   fConsumed = OneSCluster.fConsumed;
   Int_t i;
@@ -274,49 +276,43 @@ Int_t  *AliITSclusterSSD::GetTracks(Int_t &nt)
 {
   // return the track number of the cluster
   Int_t *tidx=0;
-  Int_t i, bit;
+  Int_t i, j;
+  Int_t bit =0;
+  Int_t ntracks=0;
   nt=0;
 
-  
-   
-   fNTrack =0;
-   for (i=0;i<10;i++)
-    {
-     fTrack[i] = 0;
-    }
+  for (i=0;i<10;i++) {
+       fTrack[i] = -2;
+  }
    
-   tidx=GetDigit(0)->GetTracks();
-        
-   for (i = 0; i<3;i++)
-   {
-    fTrack[i]=tidx[i];
-    if (fTrack[i] != 0) fNTrack++;
-   }
-   for (i = 1; i<fNDigits; i++)
-   {
-    tidx=GetDigit(i)->GetTracks();
-    for (Int_t j = 0; j<3;j++)
-    {
-     bit = 1;
-     if (tidx[j]==0) break;
-     for (Int_t k = 0; k < fNTrack;k++)
-      {
-       if (tidx[j]==fTrack[k]) bit =0;
-      }
-     if (bit) fTrack[fNTrack++]=tidx[j];       
-    }
-   }
-       
-  if (fNTrack > 10)
-   {
-     cout<<"\n\n Error AliITSclusterSSD::GetTracks  OUT  "<<fNDigits<<"   "<<fNTrack<<"\n\n\n\n\n";
-     
-   }
+  //cout<<"GetTrack start -------: fNDigits ="<<fNDigits<<endl;
 
- nt = fNTrack;
- if(!nt) return 0;
+  for (i = 0; i<fNDigits; i++) {
+     tidx=GetDigit(i)->GetTracks();
+     for (j = 0; j<3;j++) {
+       if (tidx[j] >= 0) {
+        if(ntracks == 0){
+         ntracks++; 
+         fTrack[ntracks-1] = tidx[j];
+        }else if(tidx[j] != fTrack[ntracks-1]){
+          ntracks++; 
+          if(ntracks > 9) {
+           bit = 1;
+           break;
+         }
+          fTrack[ntracks-1] = tidx[j];
+        }
+       }
+       //cout<<"digit,dtrack,tidx,bit ="<<i<<","<<j<<","<<tidx[j]<<","<<bit<<endl; 
+       //if(ntracks>0) cout<<"digit,dtrack,fTrack,ntracks ="<<i<<","<<j<<","<<fTrack[ntracks-1]<<","<<ntracks<<endl; 
+     } // 3-tracks loop for the digit 
+     if(bit == 1) break;
+  } // digit loop
+
+  SetNTracks(ntracks); 
+  nt = ntracks;
+  //if(nt == 0) cout<<"!!! No tracks"<<endl;
+  //cout<<"GetTracks: nt,fTrack0,fTrack1,fTrack2 ="<< nt<<","<<fTrack[0]<<","<<fTrack[1]<<","<<fTrack[2]<<endl;
  return &(fTrack[0]);
 }
 /***********************************************************/
index 56557ea65b85be770acb87586d552bb5670dc5e7..7ab9876e64909bbac47720c12213984fd5917866 100644 (file)
@@ -101,6 +101,18 @@ public:
                                            // comment to be written
                                            fLeftNeighbour=nei;
                                            }
+
+  void   SetNTracks(Int_t ntracks) {
+    // set ntracks
+    fNTracks=ntracks;
+  }
+
+
+  Int_t          GetNTracks(){
+                           // comment to be written
+                           return fNTracks;
+                           }
+
   Bool_t          GetSide(){
                            // comment to be written
                            return fSide;
@@ -139,7 +151,7 @@ protected:
   
   Float_t         fTotalSignal;     // comment to be written
   Int_t           fTrack[10];       // comment to be written
-  Int_t           fNTrack         // comment to be written
+  Int_t           fNTracks;         // comment to be written
 
   Double_t        CentrOfGravity();
   Double_t        EtaAlgorithm();
index cd88fe7092a1f0f0d05356417249920396c5df5a..600e378c10e85c31ace478eefb953196c4876dd6 100644 (file)
@@ -47,6 +47,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
             Int_t nxN;
             Int_t hitprim;
             Int_t partcode;
+            Int_t ntrover;
             Float_t x;
             Float_t z;
             Float_t dx;
@@ -62,6 +63,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
             Int_t nxN;
             Int_t noverlaps;
             Int_t noverprim;
+            Int_t ntrover;
             Float_t qclP;
             Float_t qclN;
             Float_t qrec;
@@ -82,6 +84,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
           ntuple->Branch("nxN",&ntuple_st.nxN,"nxN/I");
           ntuple->Branch("hitprim",&ntuple_st.hitprim,"hitprim/I");
           ntuple->Branch("partcode",&ntuple_st.partcode,"partcode/I");
+          ntuple->Branch("ntrover",&ntuple_st.ntrover,"ntrover/I");
           ntuple->Branch("x",&ntuple_st.x,"x/F");
           ntuple->Branch("z",&ntuple_st.z,"z/F");
           ntuple->Branch("dx",&ntuple_st.dx,"dx/F");
@@ -101,6 +104,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
           ntuple1->Branch("dz",&ntuple1_st.dz,"dz/F");
          ntuple1->Branch("noverlaps",&ntuple1_st.noverlaps,"noverlaps/I");
           ntuple1->Branch("noverprim",&ntuple1_st.noverprim,"noverprim/I");
+          ntuple1->Branch("ntrover",&ntuple1_st.ntrover,"ntrover/I");
 
           ntuple2 = new TTree("ntuple2","Demo ntuple2");
           ntuple2->Branch("nxP",&ntuple2_st.nxP,"nxP/I");
@@ -229,8 +233,8 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
      printf("det type %d first2, last2 %d %d \n",2,first2,last2);
 
      // module loop for the SSD
-     for (mod=first2; mod<last2+1; mod++) {  // for the "ALL" option
-     //for (mod=0; mod<last2-first2+1; mod++) { //for the "SSD" option
+     //for (mod=first2; mod<last2+1; mod++) {  // for the "ALL" option
+     for (mod=0; mod<last2-first2+1; mod++) { //for the "SSD" option
 
        TTree *TR = gAlice->TreeR();
        Int_t nentrec=TR->GetEntries();
@@ -254,10 +258,10 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
        totclust += nclusters;
        //if (nclusters) printf("Found %d clusters for module %d\n",nrecc,mod);
        
-       //AliITSmodule *Mod = (AliITSmodule *)fITSmodules->At(mod+first2);
+       AliITSmodule *Mod = (AliITSmodule *)fITSmodules->At(mod+first2);
        // for the "SSD" option
 
-       AliITSmodule *Mod = (AliITSmodule *)fITSmodules->At(mod);
+       //AliITSmodule *Mod = (AliITSmodule *)fITSmodules->At(mod);
        // for the "ALL" option
 
        //       printf("Mod: %X\n",Mod);
@@ -279,6 +283,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
 
         Int_t nxP = itsClu->fMultiplicity;
         Int_t nxN = itsClu->fMultiplicityN;
+        Int_t ntrover = itsClu->fNtracks;
         Float_t qclP = itsClu->fSignalP;     // in ADC
         Float_t qclN = itsClu->fSignalN;     // in ADC
         //Float_t dq = qclP - qclN;
@@ -296,7 +301,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
         Int_t tr2 = itsPnt->GetLabel(ii);
          Int_t ii = 2;
         Int_t tr3 = itsPnt->GetLabel(ii);
-
+        //cout<<"pnt,ntrover,tr1,tr2,tr3 ="<<pnt<<","<<ntrover<<","<<tr1<<","<<tr2<<","<<tr3<<endl;
         // fill ntuple2
             ntuple2_st.nxP = nxP;
              ntuple2_st.nxN = nxN;
@@ -338,6 +343,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
    //  partcode (pdgCode): 11 - e-, 13 - mu-, 22 - gamma, 111 - pi0, 211 - i+
    //  310 - K0s, 321 - K+, 2112 - n, 2212 - p, 3122 - lambda
 
+          //cout<<"hit,hitstat,track,partcode,parent ="<<hit<<","<<hitstat<<","<<track<<","<<partcode<<","<<parent<<endl;
            Float_t pmod = itsHit->GetParticle()->P(); // the momentum at the
                                                      // vertex
           pmod *= 1.0e+3;
@@ -359,7 +365,8 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
 
          // Consider the hits only with the track number equaled to one
          // of the recpoint
-         if(track == tr1) flagtrack = 1;
+         if((track == tr1) || (track == tr2) || (track == tr3)) flagtrack = 1;
+         //cout<<"!!Ok: track,tr1,tr2,tr3 ="<<track<<","<<tr1<<","<<tr2<<","<<tr3<<endl;
 
          if(flagtrack == 1) {     // the hit corresponds to the recpoint
 
@@ -383,7 +390,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
 
 
          // x,z resolution colculation
-          if(hitstat == 68 || hitsat == 33) {
+          if((hitstat == 68 || hitsat == 33) && dray == 0) {
             Float_t xmed = (xhit + xhit0)/2;
             Float_t zmed = (zhit + zhit0)/2;
             Float_t xdif = xmed - xrec;
@@ -403,6 +410,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
              ntuple_st.nxN = nxN;
             ntuple_st.hitprim = hitprim;
              ntuple_st.partcode = partcode;
+             ntuple_st.ntrover = ntrover;
             ntuple_st.x = xrec/1000;
              ntuple_st.z = zrec/1000;
             ntuple_st.dx = xdif;
@@ -451,6 +459,7 @@ void SSDrecpointTest (Int_t evNumber1=0,Int_t evNumber2=0)
          noverprim -= 1;
          ntuple1_st.noverlaps = noverlaps;
          ntuple1_st.noverprim = noverprim;
+          ntuple1_st.ntrover = ntrover;
 
          //if(qcut < 0.18) ntuple1->Fill();
          ntuple1->Fill();