Corrections to comply with coding conventions
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Mar 2003 16:34:35 +0000 (16:34 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Mar 2003 16:34:35 +0000 (16:34 +0000)
ITS/AliITSClusterFinder.cxx
ITS/AliITSClusterFinder.h
ITS/AliITSClusterFinderSDD.cxx
ITS/AliITSClusterFinderSDD.h
ITS/AliITSClusterFinderSPD.cxx
ITS/AliITSClusterFinderSPDdubna.cxx
ITS/AliITSClusterFinderSSD.cxx
ITS/AliITSClusterFinderSSD.h

index c111f18..8851601 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-
+//
+// Base Class used to find
+// the reconstructed points for ITS
+// See also AliITSClusterFinderSPD, AliITSClusterFinderSDD, 
+// AliITSClusterFinderSDD
+//
 #include "AliITSClusterFinder.h"
 #include "AliITSdigit.h"
 #include "AliRun.h"
@@ -217,7 +222,7 @@ void AliITSClusterFinder::FindRawClusters(Int_t module){
     delete digs;
 }
 //______________________________________________________________________
-Bool_t AliITSClusterFinder::IsNeighbor(TObjArray *digs,Int_t i,Int_t n[]){
+Bool_t AliITSClusterFinder::IsNeighbor(TObjArray *digs,Int_t i,Int_t n[]) const{
     // Locagical function which checks to see if digit i has a neighbor.
     // If so, then it returns kTRUE and its neighbor index j.
     // This routine checks if the digits are side by side or one before the
index d502e20..01ddba6 100644 (file)
@@ -50,11 +50,11 @@ class AliITSClusterFinder :public TObject{
     virtual TClonesArray* Digits(){
        return fDigits;
     }
-    virtual Int_t   NDigits() {
+    virtual Int_t   NDigits() const {
        // Get Number of Digits
        return fNdigits;
     }
-    AliITSMap   *Map()  {
+    AliITSMap   *Map() {
        // map
        return fMap;
     }
@@ -64,7 +64,7 @@ class AliITSClusterFinder :public TObject{
                            AliITSRecPoint &rp);
     virtual void FindRawClusters(Int_t mod=0); // Finds cluster of digits.
     // Determins if digit i has a neighbor and if so that neighor index is j.
-    virtual Bool_t IsNeighbor(TObjArray *digs,Int_t i,Int_t j[]);
+    virtual Bool_t IsNeighbor(TObjArray *digs,Int_t i,Int_t j[]) const;
     // Given a cluster of digits, creates the nessesary RecPoint. May also
     // do some peak separation.
     virtual void CreateRecPoints(TObjArray *cluster,Int_t mod){};
@@ -92,7 +92,7 @@ class AliITSClusterFinder :public TObject{
     virtual void CorrectCOG(){
        // correct COG
     }
-    virtual Bool_t Centered(AliITSRawCluster *cluster) {
+    virtual Bool_t Centered(AliITSRawCluster *cluster) const {
        // cluster
        return kTRUE;
     }
@@ -109,10 +109,10 @@ class AliITSClusterFinder :public TObject{
     // set the fitting methods in the derived classes
     // data members
 
-    TClonesArray       *fDigits;       //! digits
-    Int_t              fNdigits;       //! num of digits
-
  protected:
+    TClonesArray       *fDigits;       //! digits
+    Int_t              fNdigits;       //! num of digits 
     AliITSresponse     *fResponse;     //! response
     AliITSsegmentation *fSegmentation; //!segmentation
     Int_t              fNRawClusters;  //! in case we split the cluster
index f8a2bd7..aeae08a 100644 (file)
@@ -15,6 +15,9 @@
 /*
   $Id$
   $Log$
+  Revision 1.29  2002/10/25 18:54:22  barbera
+  Various improvements and updates from B.S.Nilsen and T. Virgili
+
   Revision 1.28  2002/10/22 14:45:29  alibrary
   Introducing Riostream.h
 
   noise values).
 
  */
-
+// 
+//  Cluster finder 
+//  for Silicon
+//  Drift Detector
+//
 #include <Riostream.h>
-#include <TFile.h>
+
 #include <TMath.h>
 #include <math.h>
 
@@ -114,11 +121,11 @@ AliITSClusterFinderSDD::~AliITSClusterFinderSDD(){
 //______________________________________________________________________
 void AliITSClusterFinderSDD::SetCutAmplitude(Float_t nsigma){
     // set the signal threshold for cluster finder
-    Float_t baseline,noise,noise_after_el;
+    Float_t baseline,noise,noiseAfterEl;
 
     fResponse->GetNoiseParam(noise,baseline);
-    noise_after_el = ((AliITSresponseSDD*)fResponse)->GetNoiseAfterElectronics();
-    fCutAmplitude = (Int_t)((baseline + nsigma*noise_after_el));
+    noiseAfterEl = ((AliITSresponseSDD*)fResponse)->GetNoiseAfterElectronics();
+    fCutAmplitude = (Int_t)((baseline + nsigma*noiseAfterEl));
 }
 //______________________________________________________________________
 void AliITSClusterFinderSDD::Find1DClusters(){
@@ -465,22 +472,22 @@ void AliITSClusterFinderSDD::PeakFunc( Int_t xdim, Int_t zdim, Float_t *par,
     for( Int_t i=0; i<npeak; i++ ){
         if( integral != 0 ) integral[i] = 0.;
         Float_t sigmaA2 = par[k+4]*par[k+4]*2.;
-        Float_t T2 = par[k+3];   // PASCAL
-        if( electronics == 2 ) { T2 *= T2; T2 *= 2; } // OLA
+        Float_t t2 = par[k+3];   // PASCAL
+        if( electronics == 2 ) { t2 *= t2; t2 *= 2; } // OLA
         for( Int_t z=0; z<zdim; z++ ){
             for( Int_t x=0; x<xdim; x++ ){
                 Float_t z2 = (z-par[k+2])*(z-par[k+2])/sigmaA2;
                 Float_t x2 = 0.;
                 Float_t signal = 0.;
                 if( electronics == 1 ){ // PASCAL
-                    x2 = (x-par[k+1]+T2)/T2;
+                    x2 = (x-par[k+1]+t2)/t2;
                     signal = (x2>0.) ? par[k]*x2*exp(-x2+1.-z2) :0.0; // RCCR2
                 //  signal =(x2>0.) ? par[k]*x2*x2*exp(-2*x2+2.-z2 ):0.0;//RCCR
                 }else if( electronics == 2 ) { // OLA
-                    x2 = (x-par[k+1])*(x-par[k+1])/T2;
+                    x2 = (x-par[k+1])*(x-par[k+1])/t2;
                     signal = par[k]  * exp( -x2 - z2 );
                 } else {
-                    cout << "Wrong SDD Electronics =" << electronics << endl;
+                 Warning("PeakFunc","Wrong SDD Electronics = %d",electronics);
                     // exit( 1 );
                 } // end if electronicx
                 spe[x*zdim+z] += signal;
@@ -493,7 +500,7 @@ void AliITSClusterFinderSDD::PeakFunc( Int_t xdim, Int_t zdim, Float_t *par,
 }
 //__________________________________________________________________________
 Float_t AliITSClusterFinderSDD::ChiSqr( Int_t xdim, Int_t zdim, Float_t *spe,
-                                        Float_t *speFit ){
+                                        Float_t *speFit ) const{
     // EVALUATES UNNORMALIZED CHI-SQUARED
     Float_t chi2 = 0.;
     for( Int_t z=0; z<zdim; z++ ){
@@ -754,7 +761,10 @@ void AliITSClusterFinderSDD::ResolveClustersE(){
         } // end if 
         Int_t xdim = tstop-tstart+3;
         Int_t zdim = astop-astart+3;
-        if(xdim > 50 || zdim > 30) { cout << "Warning: xdim: " << xdim << ", zdim: " << zdim << endl; continue; }
+        if(xdim > 50 || zdim > 30) { 
+         Warning("ResolveClustersE","xdim: %d , zdim: %d ",xdim,zdim);
+         continue;
+       }
         Float_t *sp = new Float_t[ xdim*zdim+1 ];
         memset( sp, 0, sizeof(Float_t)*(xdim*zdim+1) );
         
@@ -853,11 +863,9 @@ void AliITSClusterFinderSDD::ResolveClustersE(){
             fClusters->RemoveAt( j );
             delete [] par;
         } else {  // something odd
-            cout << " --- Peak not found!!!!  minpeak=" << fMinPeak<< 
-                    " cluster peak=" << clusterJ->PeakAmpl() << 
-                    " module=" << fModule << endl; 
-            clusterJ->PrintInfo(); 
-            cout << " xdim=" << xdim-2 << " zdim=" << zdim-2 << endl << endl;
+         Warning("ResolveClustersE","--- Peak not found!!!!  minpeak=%d ,cluster peak= %f , module= %d",fMinPeak,clusterJ->PeakAmpl(),fModule); 
+         clusterJ->PrintInfo();
+         Warning("ResolveClustersE"," xdim= %d zdim= %d",xdim-2,zdim-2);
         }
         delete [] sp;
     } // cluster loop
@@ -1295,7 +1303,7 @@ void AliITSClusterFinderSDD::FindRawClusters(Int_t mod){
     GetRecPoints();
 }
 //_______________________________________________________________________
-void AliITSClusterFinderSDD::Print(){
+void AliITSClusterFinderSDD::Print() const{
     // Print SDD cluster finder Parameters
 
     cout << "**************************************************" << endl;
index aaa5c19..038784d 100644 (file)
@@ -22,35 +22,35 @@ class AliITSClusterFinderSDD : public AliITSClusterFinder{
     virtual ~AliITSClusterFinderSDD();
 
     virtual void  SetCutAmplitude(Float_t nsigma=4);
-    virtual Int_t CutAmplitude() {// get cut amplitude
+    virtual Int_t CutAmplitude() const {// get cut amplitude
        return fCutAmplitude;}
     virtual void SetDAnode(Float_t danode=4.2) {// setDAnode
        fDAnode=danode;}
-    virtual Float_t DAnode() {// get DAnode
+    virtual Float_t DAnode() const {// get DAnode
        return fDAnode;}
     virtual void SetDTime(Float_t dtime=75) {// SetDTime
        fDTime=dtime;}
-    virtual Float_t DTime() {// get DTime
+    virtual Float_t DTime() const {// get DTime
        return fDTime;}
     virtual void SetMinPeak(Int_t minpeak=10) {// SetMinPeak
        fMinPeak=minpeak;}
-    virtual Int_t MinPeak() {// get MinPeak
+    virtual Int_t MinPeak() const {// get MinPeak
        return fMinPeak;}
     virtual void SetMinCharge(Int_t mincharge=30) {// SetMinCharge
        fMinCharge=mincharge;}
-    virtual Int_t MinCharge() {// get MinCharge
+    virtual Int_t MinCharge() const {// get MinCharge
        return fMinCharge;}
     virtual void SetMinNCells(Int_t minc=3) {// setNCells
        fMinNCells=minc;}
-    virtual Int_t MinNCells() {// get MinNCells
+    virtual Int_t MinNCells() const {// get MinNCells
        return fMinNCells;}
     virtual void SetMaxNCells(Int_t maxc=10) {// setNCells
        fMaxNCells=maxc;}
-    virtual Int_t MaxNCells() {// get MaxNCells
+    virtual Int_t MaxNCells() const {// get MaxNCells
        return fMaxNCells;}
     virtual void SetTimeCorr(Float_t timec=19.3) {// setNCells
        fTimeCorr=timec;}
-    virtual Float_t TimeCorr() {// get Time Correction (ns)
+    virtual Float_t TimeCorr() const{// get Time Correction (ns)
        return fTimeCorr;}
 
     // Search for clusters
@@ -68,10 +68,10 @@ class AliITSClusterFinderSDD : public AliITSClusterFinder{
                       Int_t *niter, Float_t *chir );
     void  Minim( Int_t xdim, Int_t zdim, Float_t *param, Float_t *prm0,
                Float_t *steprm, Float_t *chisqr,Float_t *spe,Float_t *speFit);
-    Float_t ChiSqr( Int_t xdim, Int_t zdim, Float_t *spe, Float_t *speFit );
+    Float_t ChiSqr ( Int_t xdim, Int_t zdim, Float_t *spe, Float_t *speFit ) const;
     void  PeakFunc( Int_t xdim, Int_t zdim, Float_t *par, Float_t *spe,
                   Float_t *Integral=0 );
-    void  Print();
+    void  Print() const;
 
  private:
     AliITSClusterFinderSDD(const AliITSClusterFinderSDD &source); // copy ctor
index 75ecdcf..b550858 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-
+//
+//  Cluster finder
+//  for Silicon pixels
+//
+//
 #include "AliITSClusterFinderSPD.h"
 #include "AliITS.h"
-#include "AliITSgeom.h"
 #include "AliITSdigit.h"
 #include "AliITSRawCluster.h"
 #include "AliITSRecPoint.h"
 #include "AliITSsegmentation.h"
-#include "AliITSresponse.h"
 #include "AliRun.h"
 
 //#define DEBUG
index 35d0d99..71247b1 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.6  2002/10/22 14:45:33  alibrary
+Introducing Riostream.h
+
 Revision 1.5  2002/10/14 14:57:00  hristov
 Merging the VirtualMC branch to the main development branch (HEAD)
 
@@ -39,7 +42,11 @@ Revision 1.14  2001/03/05 14:48:46  nilsen
 Fixed a reoccuring bug. Array sizes must be declare const.
 
 */
-
+//  Cluster Finder for
+//  Silicon
+//  Pixel
+//  developed by the Dubna group
+//
 #include <Riostream.h>
 #include "AliITSClusterFinderSPDdubna.h"
 #include "AliITSMapA1.h"
@@ -48,7 +55,6 @@ Fixed a reoccuring bug. Array sizes must be declare const.
 #include "AliITSRawCluster.h"
 #include "AliITSRecPoint.h"
 #include "AliITSsegmentation.h"
-#include "AliITSresponse.h"
 #include "AliRun.h"
 
 //#define DEBUG
@@ -266,13 +272,13 @@ void AliITSClusterFinderSPDdubna::TracksInCluster(){
     // get number of clusters for this module
     Int_t nofClusters = fClusters->GetEntriesFast();
     Int_t i, ix, iz, jx, jz, xstart, xstop, zstart, zstop, nclx, nclz;
-    const Int_t trmax = 100;
-    Int_t cltracks[trmax], itr, tracki, ii, is, js, ie, ntr, tr0, tr1, tr2;
+    const Int_t kTrmax = 100;
+    Int_t cltracks[kTrmax], itr, tracki, ii, is, js, ie, ntr, tr0, tr1, tr2;
 
     nofClusters -= fNclusters;
     for(i=0; i<nofClusters; i++) { 
        ii = 0;
-       memset(cltracks,-1,sizeof(int)*trmax);
+       memset(cltracks,-1,sizeof(int)*kTrmax);
        tr0=tr1=tr2=-1;
        AliITSRawClusterSPD *clusterI = (AliITSRawClusterSPD*) fClusters->At(i);
        nclx = clusterI->NclX();
@@ -301,15 +307,15 @@ void AliITSClusterFinderSPDdubna::TracksInCluster(){
                } // end for itr
            } // ix pixel
        }  // iz pixel
-       for(is=0; is<trmax; is++) { 
+       for(is=0; is<kTrmax; is++) { 
            if(cltracks[is]<0) continue;
-           for(js=is+1; js<trmax; js++) { 
+           for(js=is+1; js<kTrmax; js++) { 
                if(cltracks[js]<0) continue;
                if(cltracks[js]==cltracks[is]) cltracks[js]=-5;
            } // end for js
        } // end for is
        ntr = 0;
-       for(ie=0; ie<trmax; ie++) { 
+       for(ie=0; ie<kTrmax; ie++) { 
            if(cltracks[ie] >= 0) {
                ntr=ntr+1;
                if(ntr==1) tr0=cltracks[ie];
index e90577b..b2481af 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/**************************************************************************
- * The package was revised and changed by Boris Batiounia in the time     *
- * period of March - June 2001                                            *
- **************************************************************************/
-
+/**************************************************************************
+//  * The package was revised and changed by Boris Batiounia in the time     *
+//  * period of March - June 2001                                            *
+// **************************************************************************/
+//
 #include <Riostream.h>
 #include <TArrayI.h>
 #include "AliRun.h"
@@ -109,9 +109,9 @@ void AliITSClusterFinderSSD::InitReconstruction(){
     fNPackages = 0;
     fNDigitsP  = 0;
     fNDigitsN  = 0;
-    Float_t StereoP,StereoN;
-    fSegmentation->Angles(StereoP,StereoN);
-    CalcStepFactor(StereoP,StereoN);
+    Float_t stereoP,stereoN;
+    fSegmentation->Angles(stereoP,stereoN);
+    CalcStepFactor(stereoP,stereoN);
     if (debug) cout<<"fSFF = "<<fSFF<<"  fSFB = "<<fSFB<<"\n";
 }
 //______________________________________________________________________
@@ -278,14 +278,14 @@ void AliITSClusterFinderSSD::SplitCluster(TArrayI *list, Int_t nsplits,
     register Int_t i; //iterator
     AliITSclusterSSD* curentcluster;
     Int_t   *tmpdigits = new Int_t[100];
-    Int_t    NN;
+    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,
+           nn=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
+           new ((*fClusterP)[fNClusterP]) AliITSclusterSSD(nn,tmpdigits,
                                                            Digits(),side);
            ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
                                                       SetLeftNeighbour(kTRUE);
@@ -300,8 +300,8 @@ void AliITSClusterFinderSSD::SplitCluster(TArrayI *list, Int_t nsplits,
     } else {
        curentcluster =((AliITSclusterSSD*)((*fClusterN)[index]));
        for (i = nsplits; i>0 ;i--) {  
-           NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
-           new ((*fClusterN)[fNClusterN]) AliITSclusterSSD(NN,tmpdigits,
+           nn=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
+           new ((*fClusterN)[fNClusterN]) AliITSclusterSSD(nn,tmpdigits,
                                                            Digits(),side);
            ((AliITSclusterSSD*)((*fClusterN)[fNClusterN]))->
                                                     SetRightNeighbour(kTRUE);
@@ -363,29 +363,29 @@ Int_t AliITSClusterFinderSSD::SortDigitsN(Int_t start, Int_t end){
 //______________________________________________________________________
 void AliITSClusterFinderSSD::FillDigitsIndex(){
     //Fill the indexes of the clusters belonging to a given ITS module
-    Int_t PNs=0, NNs=0;
+    Int_t pns=0, nns=0;
     Int_t tmp,bit,k;
-    Int_t N;
+    Int_t noentries;
     Int_t i;
 
-    N = fDigits->GetEntriesFast();
+    noentries = 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);
+    Int_t* psidx = new Int_t [noentries*sizeof(Int_t)];
+    Int_t* nsidx = new Int_t [noentries*sizeof(Int_t)]; 
+    if (fDigitsIndexP==NULL) fDigitsIndexP = new TArrayI(noentries);
+    if (fDigitsIndexN==NULL) fDigitsIndexN = new TArrayI(noentries);
 
     AliITSdigitSSD *dig;
 
-    for ( i = 0 ; i< N; i++ ) {
+    for ( i = 0 ; i< noentries; 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]){
+           for( k=0;k<pns;k++){
+               if (tmp==psidx[k]){
                    if (debug) cout<<"Such a digit exists \n";
                    bit=0;
                } // end if
@@ -393,14 +393,14 @@ void AliITSClusterFinderSSD::FillDigitsIndex(){
            // end comment 
            if(bit) {
                fDigitsIndexP->AddAt(i,fNDigitsP++);
-               PSidx[PNs++]=tmp;
+               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]){
+           for( k=0;k<nns;k++){
+               if (tmp==nsidx[k]){
                    if (debug) cout<<"Such a digit exists \n";
                    bit=0;
                } // end if
@@ -408,13 +408,13 @@ void AliITSClusterFinderSSD::FillDigitsIndex(){
            // end comment
            if (bit) {
                fDigitsIndexN->AddAt(i,fNDigitsN++);
-               NSidx[NNs++] =tmp;
+               nsidx[nns++] =tmp;
            } // end if bit
        } // end if
     } // end for i
 
-    delete [] PSidx;
-    delete [] NSidx;
+    delete [] psidx;
+    delete [] nsidx;
 
     if (debug) cout<<"Digits :  P = "<<fNDigitsP<<"   N = "<<fNDigitsN<<endl;
 }
@@ -429,7 +429,7 @@ void AliITSClusterFinderSSD::SortDigits(){
        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) const{
     // fill cluster index array
     register Int_t i;
 
@@ -553,7 +553,7 @@ Bool_t AliITSClusterFinderSSD::CreateNewRecPoint(Float_t P,Float_t dP,
     const Float_t kRMSz = 800.0*kconv;
     Int_t n=0;
     Int_t *tr;
-    Int_t NTracks;
+    Int_t ntracks;
 
     if (GetCrossing(P,N)) {
        //GetCrossingError(dP,dN);
@@ -570,13 +570,13 @@ Bool_t AliITSClusterFinderSSD::CreateNewRecPoint(Float_t P,Float_t dP,
            dedx = SigN*kADCtoKeV;
        } // end if SigP>SigN
      tr = (Int_t*) clusterP->GetTracks(n);
-     NTracks = clusterP->GetNTracks();
+     ntracks = clusterP->GetNTracks();
      cnew.fSignalP=SigP;
      cnew.fSignalN=SigN;
      cnew.fMultiplicity=nstripsP;
      cnew.fMultiplicityN=nstripsN;
      cnew.fQErr=TMath::Abs(SigP-SigN);
-     cnew.fNtracks=NTracks;
+     cnew.fNtracks=ntracks;
      fITS->AddCluster(2,&cnew);
      AliITSRecPoint rnew;
      rnew.SetX(P*kconv);
@@ -634,19 +634,19 @@ AliITSclusterSSD* AliITSClusterFinderSSD::GetCluster(Int_t idx, Bool_t side){
 Bool_t AliITSClusterFinderSSD::GetCrossing (Float_t &P, Float_t &N){ 
     // get crossing
     // This function was rivised and changed by Boris Batiounia in March 2001
-    Float_t Dx = fSegmentation->Dx(); // detector size in x direction, microns
-    Float_t Dz = fSegmentation->Dz(); // detector size in z direction, microns
+    Float_t dx = fSegmentation->Dx(); // detector size in x direction, microns
+    Float_t dz = fSegmentation->Dz(); // detector size in z direction, microns
     Float_t xL; // x local coordinate
     Float_t zL; // z local coordinate
-    Float_t x;  // x = xL + Dx/2
-    Float_t z;  // z = zL + Dz/2
+    Float_t x;  // x = xL + dx/2
+    Float_t z;  // z = zL + dz/2
     Float_t xP; // x coordinate in the P side from the first P strip
     Float_t xN; // x coordinate in the N side from the first N strip
-    Float_t StereoP,StereoN;
+    Float_t stereoP,stereoN;
 
-    fSegmentation->Angles(StereoP,StereoN);
-    fTanP=TMath::Tan(StereoP);
-    fTanN=TMath::Tan(StereoN);
+    fSegmentation->Angles(stereoP,stereoN);
+    fTanP=TMath::Tan(stereoP);
+    fTanN=TMath::Tan(stereoN);
     Float_t kP = fTanP; // Tangent of 0.0075 mrad
     Float_t kN = fTanN; // Tangent of 0.0275 mrad
     P *= fPitch;
@@ -655,14 +655,14 @@ Bool_t AliITSClusterFinderSSD::GetCrossing (Float_t &P, Float_t &N){
     xP = N;      // change the mistake for the P/N
     xN = P;      // coordinates correspondence in this function
 
-    x = xP + kP*(Dz*kN-xP+xN)/(kP+kN);
-    z = (Dz*kN-xP+xN)/(kP+kN); 
-    xL = x - Dx/2;
-    zL = z - Dz/2;
+    x = xP + kP*(dz*kN-xP+xN)/(kP+kN);
+    z = (dz*kN-xP+xN)/(kP+kN); 
+    xL = x - dx/2;
+    zL = z - dz/2;
     P = xL;
     N = zL;  
 
-    if(TMath::Abs(xL) > Dx/2 || TMath::Abs(zL) > Dz/2) return kFALSE;
+    if(TMath::Abs(xL) > dx/2 || TMath::Abs(zL) > dz/2) return kFALSE;
     
     // Check that xL and zL are inside the detector for the 
     // correspondent xP and xN coordinates
index 65d5000..77d9960 100644 (file)
@@ -34,15 +34,15 @@ class AliITSClusterFinderSSD: public AliITSClusterFinder{
     Int_t     SortDigitsN(Int_t start, Int_t end);
     void      FillDigitsIndex();
     void      SortDigits();
-    void      FillClIndexArrays(Int_t* arrayP, Int_t *arrayN);
+    void      FillClIndexArrays(Int_t* arrayP, Int_t *arrayN) const;
     void      SortClusters(Int_t* arrayP, Int_t *arrayN);
     Int_t     SortClustersP(Int_t start, Int_t end,Int_t *array);
     Int_t     SortClustersN(Int_t start, Int_t end,Int_t *array);
     void      ClustersToPackages();
-    Int_t     GetDiff(Float_t *retx, Float_t *rety) {return 0;}
+    Int_t     GetDiff(Float_t *retx, Float_t *rety) const {return 0;}
     void      CalcStepFactor(Float_t Psteo, Float_t Nsteo );
     Bool_t GetCrossing(Float_t &x, Float_t &z); //x, y of strips crossing
-    void   GetCrossingError(Float_t&, Float_t&);//x, y of strips crossing err.
+    void   GetCrossingError(Float_t& dp, Float_t& dn);//x, y of strips crossing err.
 
     // Data memebers
     AliITS          *fITS;           //!Pointer to AliITS object
@@ -77,7 +77,6 @@ class AliITSClusterFinderSSD: public AliITSClusterFinder{
     Int_t fSFF;              //!forward stepping factor 
     Int_t fSFB;              //!backward stepping factor 
 
- public:
     ClassDef(AliITSClusterFinderSSD, 1) //Class for clustering and reconstruction of space points in SSDs 
 
 };