Global constants moved to the class scope. (I. Hrivnacova)

diff --git a/MUON/AliMUONClusterFinderAZ.cxx b/MUON/AliMUONClusterFinderAZ.cxx
index 1992593..204ab8b 100644 (file)
--- a/MUON/AliMUONClusterFinderAZ.cxx
+++ b/MUON/AliMUONClusterFinderAZ.cxx
@@ -33,6 +33,7 @@
 
 ClassImp(AliMUONClusterFinderAZ)
  
+ const Double_t AliMUONClusterFinderAZ::fgkCouplMin = 1.e-3; // threshold on coupling 
  AliMUONClusterFinderAZ* AliMUONClusterFinderAZ::fgClusterFinder = 0x0;
  TMinuit* AliMUONClusterFinderAZ::fgMinuit = 0x0;
 
@@ -170,7 +171,7 @@ newchamber:
 
   Int_t ndigits[2]={9,9}, nShown[2]={0};
   for (Int_t i=0; i<2; i++) {
-    for (Int_t j=0; j<kDim; j++) {fUsed[i][j]=kFALSE;}
+    for (Int_t j=0; j<fgkDim; j++) {fUsed[i][j]=kFALSE;}
   }
 
 next:
@@ -186,7 +187,7 @@ next:
   Bool_t first = kTRUE;
   cout << " *** Event # " << nev << " chamber: " << ch << endl;
   fnPads[0] = fnPads[1] = 0;
-  for (Int_t i=0; i<kDim; i++) {fPadIJ[1][i] = 0;}
+  for (Int_t i=0; i<fgkDim; i++) {fPadIJ[1][i] = 0;}
   //for (Int_t iii = 0; iii<999; iii++) { 
   for (Int_t iii = 0; iii<2; iii++) { 
     Int_t cath = TMath::Odd(iii);
@@ -1582,7 +1583,7 @@ void AliMUONClusterFinderAZ::Split(TH2D *mlem, Double_t *coef)
       for (Int_t j=0; j<npad; j++) {
        // Exclude overflows
        if (fPadIJ[1][j] < 0) continue;
-       if (coef[j*nPix+indx] < kCouplMin) continue;
+       if (coef[j*nPix+indx] < fgkCouplMin) continue;
        (*aijclupad)(iclust,j) += coef[j*nPix+indx];
       }
     }
@@ -1594,9 +1595,9 @@ void AliMUONClusterFinderAZ::Split(TH2D *mlem, Double_t *coef)
     for (Int_t j=0; j<npad; j++) {
       // Exclude overflows
       if (fPadIJ[1][j] < 0) continue;
-      if ((*aijclupad)(iclust,j) < kCouplMin) continue;
+      if ((*aijclupad)(iclust,j) < fgkCouplMin) continue;
       for (Int_t iclust1=iclust+1; iclust1<nclust; iclust1++) {
-       if ((*aijclupad)(iclust1,j) < kCouplMin) continue;
+       if ((*aijclupad)(iclust1,j) < fgkCouplMin) continue;
        (*aijcluclu)(iclust,iclust1) += 
          TMath::Sqrt ((*aijclupad)(iclust,j)*(*aijclupad)(iclust1,j));
       }
@@ -1701,10 +1702,10 @@ void AliMUONClusterFinderAZ::Split(TH2D *mlem, Double_t *coef)
          if (fPadIJ[1][j] != -1) continue;
          for (Int_t iclust=0; iclust<nCoupled; iclust++) {
            indx = clustNumb[iclust];
-           if ((*aijclupad)(indx,j) < kCouplMin) continue;
+           if ((*aijclupad)(indx,j) < fgkCouplMin) continue;
            for (Int_t iclust1=iclust+1; iclust1<nCoupled; iclust1++) {
              indx1 = clustNumb[iclust1];
-             if ((*aijclupad)(indx1,j) < kCouplMin) continue;
+             if ((*aijclupad)(indx1,j) < fgkCouplMin) continue;
              // Check this
              (*aijcluclu)(indx,indx1) -= 
                TMath::Sqrt ((*aijclupad)(indx,j)*(*aijclupad)(indx1,j));
@@ -1784,7 +1785,7 @@ void AliMUONClusterFinderAZ::AddCluster(Int_t ic, Int_t nclust, TMatrixD *aijclu
 
   for (Int_t i=0; i<nclust; i++) {
     if (used[i]) continue;
-    if ((*aijcluclu)(i,ic) < kCouplMin) continue;
+    if ((*aijcluclu)(i,ic) < fgkCouplMin) continue;
     used[i] = kTRUE;
     clustNumb[nCoupled++] = i;
     AddCluster(i, nclust, aijcluclu, used, clustNumb, nCoupled);
@@ -1892,7 +1893,7 @@ Int_t AliMUONClusterFinderAZ::SelectPad(Int_t nCoupled, Int_t nForFit, Int_t *cl
     indx = clustFit[iclust];
     for (Int_t j=0; j<npad; j++) {
       if (fPadIJ[1][j] < 0) continue; // exclude overflows and used pads
-      if ((*aijclupad)(indx,j) < kCouplMin) continue;
+      if ((*aijclupad)(indx,j) < fgkCouplMin) continue;
       fPadIJ[1][j] = 1; // pad to be used in fit
       nOK++;
       if (nCoupled > 3) {
@@ -1900,7 +1901,7 @@ Int_t AliMUONClusterFinderAZ::SelectPad(Int_t nCoupled, Int_t nForFit, Int_t *cl
        for (Int_t iclust1=0; iclust1<nCoupled; iclust1++) {
          indx1 = clustNumb[iclust1];
          if (indx1 < 0) continue;
-         if ((*aijclupad)(indx1,j) < kCouplMin) continue;
+         if ((*aijclupad)(indx1,j) < fgkCouplMin) continue;
          padpix[j] += (*aijclupad)(indx1,j);
        }
       } // if (nCoupled > 3)
@@ -1910,7 +1911,7 @@ Int_t AliMUONClusterFinderAZ::SelectPad(Int_t nCoupled, Int_t nForFit, Int_t *cl
 
   Double_t aaa = 0;
   for (Int_t j=0; j<npad; j++) {
-    if (padpix[j] < kCouplMin) continue;
+    if (padpix[j] < fgkCouplMin) continue;
     cout << j << " " << padpix[j] << " "; 
     cout << fXyq[0][j] << " " << fXyq[1][j] << endl;
     aaa += padpix[j];
@@ -1943,7 +1944,7 @@ void AliMUONClusterFinderAZ::Merge(Int_t nForFit, Int_t nCoupled, Int_t *clustNu
        imax = indx1;
       }
     } // for (Int_t icl1=0;
-    /*if (couplMax < kCouplMin) {
+    /*if (couplMax < fgkCouplMin) {
       cout << " Oops " << couplMax << endl;
       aijcluclu->Print();
       cout << icl << " " << indx << " " << npxclu << " " << nLinks << endl;

diff --git a/MUON/AliMUONClusterFinderAZ.h b/MUON/AliMUONClusterFinderAZ.h
index f397c3e..7362450 100644 (file)
--- a/MUON/AliMUONClusterFinderAZ.h
+++ b/MUON/AliMUONClusterFinderAZ.h
@@ -14,10 +14,6 @@ class TMatrixD;
 class AliMUONPixel;
 #include "AliMUONClusterFinderVS.h"
 
-// Some constants
- static const Int_t kDim = 2000; // array size
- static const Double_t kCouplMin = 1.e-3; // threshold on coupling 
-
 //class AliMUONClusterFinderAZ : public TObject {
 class AliMUONClusterFinderAZ : public AliMUONClusterFinderVS {
 
@@ -38,10 +34,14 @@ protected:
  
 
  private:
+  // Some constants
+  static const Int_t fgkDim = 2000; // array size
+  static const Double_t fgkCouplMin; // threshold on coupling 
+
 
   Int_t      fnPads[2];        // ! number of pads in the cluster on 2 cathodes
-  Float_t    fXyq[6][kDim];    // ! pad information
-  Int_t      fPadIJ[2][kDim];  // ! pad information
+  Float_t    fXyq[6][fgkDim];    // ! pad information
+  Int_t      fPadIJ[2][fgkDim];  // ! pad information
   AliSegmentation *fSegmentation[2]; // ! segmentation
   AliMUONResponse *fResponse;// ! response
   Float_t    fZpad;            // ! z-coordinate of the hit
@@ -50,7 +50,7 @@ protected:
   Int_t      fReco;            // ! =1 if run reco with writing to TreeR 
 
   static     TMinuit* fgMinuit; // ! Fitter
-  Bool_t     fUsed[2][kDim]; // ! flags for used pads
+  Bool_t     fUsed[2][fgkDim]; // ! flags for used pads
   TH2F*      fHist[4]; // ! histograms
   TClonesArray *fMuonDigits; // ! pointer to digits
   Bool_t     fDraw; // ! draw flag

diff --git a/MUON/AliMUONClusterReconstructor.cxx b/MUON/AliMUONClusterReconstructor.cxx
index 71e749f..232adb9 100644 (file)
--- a/MUON/AliMUONClusterReconstructor.cxx
+++ b/MUON/AliMUONClusterReconstructor.cxx
@@ -51,7 +51,7 @@
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 
-static const Int_t kDefaultPrintLevel = 0;
+const Int_t AliMUONClusterReconstructor::fgkDefaultPrintLevel = 0;
 
 ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
 
@@ -67,7 +67,7 @@ AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
   fMUONData        = 0;
   fChambers = new TObjArray(AliMUONConstants::NCh());
 
-  fPrintLevel = kDefaultPrintLevel;
+  fPrintLevel = fgkDefaultPrintLevel;
 
   // initialize loader's
   fLoader = loader;

diff --git a/MUON/AliMUONClusterReconstructor.h b/MUON/AliMUONClusterReconstructor.h
index 95c5a93..ed9224a 100644 (file)
--- a/MUON/AliMUONClusterReconstructor.h
+++ b/MUON/AliMUONClusterReconstructor.h
@@ -47,6 +47,7 @@ class AliMUONClusterReconstructor : public TObject {
  protected:
 
  private:
+  static const Int_t fgkDefaultPrintLevel;     // Default print level
 
   Int_t                   fNCh;                // Number of chambers   
   Int_t                   fNTrackingCh;        // Number of tracking chambers*

diff --git a/MUON/AliMUONEventReconstructor.cxx b/MUON/AliMUONEventReconstructor.cxx
index 76121ed..4a372f9 100644 (file)
--- a/MUON/AliMUONEventReconstructor.cxx
+++ b/MUON/AliMUONEventReconstructor.cxx
@@ -61,26 +61,26 @@
 #include "AliMC.h"
 
 //************* Defaults parameters for reconstruction
-static const Double_t kDefaultMinBendingMomentum = 3.0;
-static const Double_t kDefaultMaxBendingMomentum = 500.0;
-static const Double_t kDefaultMaxChi2 = 100.0;
-static const Double_t kDefaultMaxSigma2Distance = 16.0;
-static const Double_t kDefaultBendingResolution = 0.01;
-static const Double_t kDefaultNonBendingResolution = 0.144;
-static const Double_t kDefaultChamberThicknessInX0 = 0.03;
+const Double_t AliMUONEventReconstructor::fgkDefaultMinBendingMomentum = 3.0;
+const Double_t AliMUONEventReconstructor::fgkDefaultMaxBendingMomentum = 500.0;
+const Double_t AliMUONEventReconstructor::fgkDefaultMaxChi2 = 100.0;
+const Double_t AliMUONEventReconstructor::fgkDefaultMaxSigma2Distance = 16.0;
+const Double_t AliMUONEventReconstructor::fgkDefaultBendingResolution = 0.01;
+const Double_t AliMUONEventReconstructor::fgkDefaultNonBendingResolution = 0.144;
+const Double_t AliMUONEventReconstructor::fgkDefaultChamberThicknessInX0 = 0.03;
 // Simple magnetic field:
 // Value taken from macro MUONtracking.C: 0.7 T, hence 7 kG
 // Length and Position from reco_muon.F, with opposite sign:
 // Length = ZMAGEND-ZCOIL
 // Position = (ZMAGEND+ZCOIL)/2
 // to be ajusted differently from real magnetic field ????
-static const Double_t kDefaultSimpleBValue = 7.0;
-static const Double_t kDefaultSimpleBLength = 428.0;
-static const Double_t kDefaultSimpleBPosition = 1019.0;
-static const Int_t kDefaultRecGeantHits = 0;
-static const Double_t kDefaultEfficiency = 0.95;
+const Double_t AliMUONEventReconstructor::fgkDefaultSimpleBValue = 7.0;
+const Double_t AliMUONEventReconstructor::fgkDefaultSimpleBLength = 428.0;
+const Double_t AliMUONEventReconstructor::fgkDefaultSimpleBPosition = 1019.0;
+const Int_t    AliMUONEventReconstructor::fgkDefaultRecGeantHits = 0;
+const Double_t AliMUONEventReconstructor::fgkDefaultEfficiency = 0.95;
 
-static const Int_t kDefaultPrintLevel = -1;
+const Int_t    AliMUONEventReconstructor::fgkDefaultPrintLevel = -1;
 
 ClassImp(AliMUONEventReconstructor) // Class implementation in ROOT context
 
@@ -187,10 +187,10 @@ void AliMUONEventReconstructor::SetReconstructionParametersToDefaults(void)
 {
   // Set reconstruction parameters to default values
   // Would be much more convenient with a structure (or class) ????
-  fMinBendingMomentum = kDefaultMinBendingMomentum;
-  fMaxBendingMomentum = kDefaultMaxBendingMomentum;
-  fMaxChi2 = kDefaultMaxChi2;
-  fMaxSigma2Distance = kDefaultMaxSigma2Distance;
+  fMinBendingMomentum = fgkDefaultMinBendingMomentum;
+  fMaxBendingMomentum = fgkDefaultMaxBendingMomentum;
+  fMaxChi2 = fgkDefaultMaxChi2;
+  fMaxSigma2Distance = fgkDefaultMaxSigma2Distance;
 
   AliMUON *pMUON = (AliMUON*) gAlice->GetModule("MUON");
   // ******** Parameters for making HitsForRec
@@ -198,7 +198,7 @@ void AliMUONEventReconstructor::SetReconstructionParametersToDefaults(void)
   // like in TRACKF_STAT:
   // 2 degrees for stations 1 and 2, or ch(0...) from 0 to 3;
   // 30 cm for stations 3 to 5, or ch(0...) from 4 to 9
-  for (Int_t ch = 0; ch < kMaxMuonTrackingChambers; ch++) {
+  for (Int_t ch = 0; ch < fgkMaxMuonTrackingChambers; ch++) {
     if (ch < 4) fRMin[ch] = TMath::Abs((&(pMUON->Chamber(ch)))->Z()) *
                  2.0 * TMath::Pi() / 180.0;
     else fRMin[ch] = 30.0;
@@ -229,15 +229,15 @@ void AliMUONEventReconstructor::SetReconstructionParametersToDefaults(void)
   fSegmentMaxDistBending[4] =  TMath::Abs( 6.0 *
     ((&(pMUON->Chamber(9)))->Z() - (&(pMUON->Chamber(8)))->Z()) / 20.0);
   
-  fBendingResolution = kDefaultBendingResolution;
-  fNonBendingResolution = kDefaultNonBendingResolution;
-  fChamberThicknessInX0 = kDefaultChamberThicknessInX0;
-  fSimpleBValue = kDefaultSimpleBValue;
-  fSimpleBLength = kDefaultSimpleBLength;
-  fSimpleBPosition = kDefaultSimpleBPosition;
-  fRecGeantHits = kDefaultRecGeantHits;
-  fEfficiency = kDefaultEfficiency;
-  fPrintLevel = kDefaultPrintLevel;
+  fBendingResolution = fgkDefaultBendingResolution;
+  fNonBendingResolution = fgkDefaultNonBendingResolution;
+  fChamberThicknessInX0 = fgkDefaultChamberThicknessInX0;
+  fSimpleBValue = fgkDefaultSimpleBValue;
+  fSimpleBLength = fgkDefaultSimpleBLength;
+  fSimpleBPosition = fgkDefaultSimpleBPosition;
+  fRecGeantHits = fgkDefaultRecGeantHits;
+  fEfficiency = fgkDefaultEfficiency;
+  fPrintLevel = fgkDefaultPrintLevel;
   return;
 }
 
@@ -400,7 +400,7 @@ void AliMUONEventReconstructor::ResetHitsForRec(void)
   // and the index of the first HitForRec per chamber
   if (fHitsForRecPtr) fHitsForRecPtr->Clear();
   fNHitsForRec = 0;
-  for (Int_t ch = 0; ch < kMaxMuonTrackingChambers; ch++)
+  for (Int_t ch = 0; ch < fgkMaxMuonTrackingChambers; ch++)
     fNHitsForRecPerChamber[ch] = fIndexOfFirstHitForRecPerChamber[ch] = 0;
   return;
 }
@@ -514,7 +514,7 @@ void AliMUONEventReconstructor::MakeEventToBeReconstructed(void)
   if (fPrintLevel >= 10) {
     cout << "end of MakeEventToBeReconstructed" << endl;
     cout << "NHitsForRec: " << fNHitsForRec << endl;
-    for (Int_t ch = 0; ch < kMaxMuonTrackingChambers; ch++) {
+    for (Int_t ch = 0; ch < fgkMaxMuonTrackingChambers; ch++) {
       cout << "chamber(0...): " << ch
           << "  NHitsForRec: " << fNHitsForRecPerChamber[ch]
           << "  index(first HitForRec): " << fIndexOfFirstHitForRecPerChamber[ch]
@@ -622,7 +622,7 @@ AliMUONHitForRec* AliMUONEventReconstructor::NewHitForRecFromGEANT(AliMUONHit* H
   Double_t bendCoor, nonBendCoor, radius;
   Int_t chamber = Hit->Chamber() - 1; // chamber(0...)
   // only in tracking chambers (fChamber starts at 1)
-  if (chamber >= kMaxMuonTrackingChambers) return NULL;
+  if (chamber >= fgkMaxMuonTrackingChambers) return NULL;
   // only if hit is efficient (keep track for checking ????)
   if (gRandom->Rndm() > fEfficiency) return NULL;
   // only if radius between RMin and RMax
@@ -665,7 +665,7 @@ void AliMUONEventReconstructor::SortHitsForRecWithIncreasingChamber()
   // Update the information for HitsForRec per chamber too.
   Int_t ch, nhits, prevch;
   fHitsForRecPtr->Sort();
-  for (ch = 0; ch < kMaxMuonTrackingChambers; ch++) {
+  for (ch = 0; ch < fgkMaxMuonTrackingChambers; ch++) {
     fNHitsForRecPerChamber[ch] = 0;
     fIndexOfFirstHitForRecPerChamber[ch] = 0;
   }
@@ -700,7 +700,7 @@ void AliMUONEventReconstructor::SortHitsForRecWithIncreasingChamber()
 //   AliMUON *MUON  = (AliMUON*) gAlice->GetModule("MUON"); // necessary ????
 //   // Security on MUON ????
 //   // Loop over tracking chambers
-//   for (Int_t ch = 0; ch < kMaxMuonTrackingChambers; ch++) {
+//   for (Int_t ch = 0; ch < fgkMaxMuonTrackingChambers; ch++) {
 //     // number of HitsForRec to 0 for the chamber
 //     fNHitsForRecPerChamber[ch] = 0;
 //     // index of first HitForRec for the chamber
@@ -780,7 +780,7 @@ void AliMUONEventReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
   fLoader->TreeR()->GetEvent(0); // only one entry  
 
   // Loop over tracking chambers
-  for (Int_t ch = 0; ch < kMaxMuonTrackingChambers; ch++) {
+  for (Int_t ch = 0; ch < fgkMaxMuonTrackingChambers; ch++) {
     // number of HitsForRec to 0 for the chamber
     fNHitsForRecPerChamber[ch] = 0;
     // index of first HitForRec for the chamber

diff --git a/MUON/AliMUONEventReconstructor.h b/MUON/AliMUONEventReconstructor.h
index 5afde84..0de866c 100644 (file)
--- a/MUON/AliMUONEventReconstructor.h
+++ b/MUON/AliMUONEventReconstructor.h
@@ -22,10 +22,6 @@ class AliMUONData;
 class AliRunLoader;
 class AliLoader;
 
-// Constants which should be elsewhere ????
-const Int_t kMaxMuonTrackingChambers = 10;
-const Int_t kMaxMuonTrackingStations = kMaxMuonTrackingChambers / 2;
-
 class AliMUONEventReconstructor : public TObject {
 
  public:
@@ -105,6 +101,32 @@ class AliMUONEventReconstructor : public TObject {
 
  private:
 
+  // Constants which should be elsewhere ????
+  static const Int_t fgkMaxMuonTrackingChambers = 10; // Max number of Muon tracking chambers
+  static const Int_t kMaxMuonTrackingStations = 5; // Max number of Muon tracking stations
+
+  // Defaults parameters for reconstruction
+  static const Double_t fgkDefaultMinBendingMomentum;
+  static const Double_t fgkDefaultMaxBendingMomentum;
+  static const Double_t fgkDefaultMaxChi2;
+  static const Double_t fgkDefaultMaxSigma2Distance;
+  static const Double_t fgkDefaultBendingResolution;
+  static const Double_t fgkDefaultNonBendingResolution;
+  static const Double_t fgkDefaultChamberThicknessInX0;
+  // Simple magnetic field:
+  // Value taken from macro MUONtracking.C: 0.7 T, hence 7 kG
+  // Length and Position from reco_muon.F, with opposite sign:
+  // Length = ZMAGEND-ZCOIL
+  // Position = (ZMAGEND+ZCOIL)/2
+  // to be ajusted differently from real magnetic field ????
+  static const Double_t fgkDefaultSimpleBValue;
+  static const Double_t fgkDefaultSimpleBLength;
+  static const Double_t fgkDefaultSimpleBPosition;
+  static const Int_t fgkDefaultRecGeantHits;
+  static const Double_t fgkDefaultEfficiency;
+
+  static const Int_t fgkDefaultPrintLevel;
+
   Int_t fTrackMethod; // AZ - tracking method
 
   // Parameters for event reconstruction
@@ -113,8 +135,8 @@ class AliMUONEventReconstructor : public TObject {
   Double_t fMaxBendingMomentum; // maximum value (GeV/c) of momentum in bending plane
   Double_t fMaxChi2; // maximum Chi2 per degree of Freedom
   Double_t fMaxSigma2Distance; // maximum square distance in units of the variance (maximum chi2)
-  Double_t fRMin[kMaxMuonTrackingChambers]; // minimum radius (cm)
-  Double_t fRMax[kMaxMuonTrackingChambers]; // maximum radius (cm)
+  Double_t fRMin[fgkMaxMuonTrackingChambers]; // minimum radius (cm)
+  Double_t fRMax[fgkMaxMuonTrackingChambers]; // maximum radius (cm)
   Double_t fSegmentMaxDistBending[kMaxMuonTrackingStations]; // maximum distance (cm) for segments in bending plane
   Double_t fSegmentMaxDistNonBending[kMaxMuonTrackingStations]; // maximum distance (cm) for segments in non bending plane
   Double_t fBendingResolution; // chamber resolution (cm) in bending plane
@@ -141,8 +163,8 @@ class AliMUONEventReconstructor : public TObject {
   TClonesArray *fHitsForRecPtr; // pointer to the array of hits for reconstruction
   Int_t fNHitsForRec; // number of hits for reconstruction
   // Information per chamber (should be in AliMUONChamber ????)
-  Int_t fNHitsForRecPerChamber[kMaxMuonTrackingChambers]; // number of HitsForRec
-  Int_t fIndexOfFirstHitForRecPerChamber[kMaxMuonTrackingChambers]; // index (0...) of first HitForRec
+  Int_t fNHitsForRecPerChamber[fgkMaxMuonTrackingChambers]; // number of HitsForRec
+  Int_t fIndexOfFirstHitForRecPerChamber[fgkMaxMuonTrackingChambers]; // index (0...) of first HitForRec
 
   // Segments inside a station
   TClonesArray *fSegmentsPtr[kMaxMuonTrackingStations]; // array of pointers to the segments for each station

diff --git a/MUON/AliMUONSegmentationV1.h b/MUON/AliMUONSegmentationV1.h
index aa63ed8..c381634 100644 (file)
--- a/MUON/AliMUONSegmentationV1.h
+++ b/MUON/AliMUONSegmentationV1.h
@@ -7,10 +7,6 @@
 
 #include "AliSegmentation.h"
 
-const Int_t kNzone = 3;                // Specific for chamber with equal pads
-const Int_t kNzonem1 = 2;              // kNzone - 1
-const Int_t kNzoneCUT = 30;            
-
 class AliMUONSegmentationV1 :
 public AliSegmentation {
  public:
@@ -143,13 +139,17 @@ public AliSegmentation {
     // Version This models rectangular pads with the same dimensions all
     // over the cathode plane but let the possibilit for different design.
     //
+    static const Int_t fgkNzone = 3;     // Specific for chamber with equal pads
+    static const Int_t fgkNzonem1 = 2;   // fgkNzone - 1
+    static const Int_t fgkNzoneCUT = 30; // NzoneCUT           
+
     //  geometry
     Int_t fNzone; // Number of differents sensitive zones
     Float_t fDpx;         // X pad width
     Float_t fDpy;         // Y pad width
-    Int_t   fNZoneCut[kNzonem1];    // Number of cuts for given zone 
-    Int_t fZoneX[kNzonem1][kNzoneCUT]; // X descriptor of zone segmentations
-    Int_t fZoneY[kNzonem1][kNzoneCUT]; // Y descriptor of zone segmentations
+    Int_t   fNZoneCut[fgkNzonem1];    // Number of cuts for given zone 
+    Int_t fZoneX[fgkNzonem1][fgkNzoneCUT]; // X descriptor of zone segmentations
+    Int_t fZoneY[fgkNzonem1][fgkNzoneCUT]; // Y descriptor of zone segmentations
     Float_t frSensMax2; // square of maximum sensitive radius
     Float_t frSensMin2; // square of minimum sensitive radius
     Int_t   fNpx;         // Maximum number of pads along x

diff --git a/MUON/AliMUONTrack.h b/MUON/AliMUONTrack.h
index bf552d5..be351d7 100644 (file)
--- a/MUON/AliMUONTrack.h
+++ b/MUON/AliMUONTrack.h
@@ -11,7 +11,8 @@
 
 #include "AliMUONTrackParam.h" // object belongs to the class
 
-const Int_t kMaxTrackingChamber=10;
+//const Int_t kMaxTrackingChamber=10;
+        // not used
 
 class TObjArray;
 class TClonesArray;

diff --git a/MUON/AliMUONTrackK.cxx b/MUON/AliMUONTrackK.cxx
index 3612dcb..a5e46af 100644 (file)
--- a/MUON/AliMUONTrackK.cxx
+++ b/MUON/AliMUONTrackK.cxx
@@ -32,6 +32,11 @@
 #include "AliRun.h"
 #include "AliMagF.h"
 
+const Int_t AliMUONTrackK::fgkSize = 5;
+const Int_t AliMUONTrackK::fgkNSigma = 4; 
+const Int_t AliMUONTrackK::fgkTriesMax = 10000; 
+const Double_t AliMUONTrackK::fgkEpsilon = 0.002; 
+
 void mnvertLocalK(Double_t* a, Int_t l, Int_t m, Int_t n, Int_t& ifail);
 
 ClassImp(AliMUONTrackK) // Class implementation in ROOT context
@@ -146,10 +151,10 @@ AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
   fNTrackHits = 2;
   fChi2 = 0;
   fBPFlag = kFALSE;
-  fTrackPar = new TMatrixD(kSize,1); // track parameters
-  fTrackParNew = new TMatrixD(kSize,1); // track parameters
-  fCovariance = new TMatrixD(kSize,kSize); // covariance matrix
-  fWeight = new TMatrixD(kSize,kSize); // weight matrix (inverse of covariance)
+  fTrackPar = new TMatrixD(fgkSize,1); // track parameters
+  fTrackParNew = new TMatrixD(fgkSize,1); // track parameters
+  fCovariance = new TMatrixD(fgkSize,fgkSize); // covariance matrix
+  fWeight = new TMatrixD(fgkSize,fgkSize); // weight matrix (inverse of covariance)
 
   // Fill array of track parameters
   if (hit1->GetChamberNumber() > 7) {
@@ -283,7 +288,7 @@ void AliMUONTrackK::EvalCovariance(Double_t dZ)
     // fWeight->Invert();
 
     Int_t ifailWeight;
-    mnvertLocalK(&((*fWeight)(0,0)), kSize,kSize,kSize,ifailWeight);
+    mnvertLocalK(&((*fWeight)(0,0)), fgkSize,fgkSize,fgkSize,ifailWeight);
   } else {
     cout << " ***** Warning in EvalCovariance: Determinant fWeight=0:" << endl;
   }
@@ -539,8 +544,8 @@ Bool_t AliMUONTrackK::KalmanFilter(Int_t ichamBeg, Int_t ichamEnd, Bool_t Back,
 
     if (Back && !miss) {
       // backward propagator
-      TMatrixD pointWeight(kSize,kSize);
-      TMatrixD point(kSize,1);
+      TMatrixD pointWeight(fgkSize,fgkSize);
+      TMatrixD point(fgkSize,1);
       TMatrixD trackParTmp = point;
       point(0,0) = hitAdd->GetBendingCoor();
       point(1,0) = hitAdd->GetNonBendingCoor();
@@ -597,12 +602,12 @@ void AliMUONTrackK::ParPropagation(Double_t zEnd)
     distance = zEnd - vGeant3New[2];
     step *= dZ/(vGeant3New[2]-fPositionNew);
     nTries ++;
-  } while (distance*iFB < 0 && TMath::Abs(distance) > kEpsilon);
+  } while (distance*iFB < 0 && TMath::Abs(distance) > fgkEpsilon);
 
   GetFromGeantParam(vGeant3New,iFB);
 
   // Position ajustment (until within tolerance)
-  while (TMath::Abs(distance) > kEpsilon) {
+  while (TMath::Abs(distance) > fgkEpsilon) {
     dZ = zEnd - fPositionNew;
     iFB = (Int_t)TMath::Sign(Double_t(1.0),dZ);
     step = dZ/TMath::Cos((*fTrackParNew)(2,0))/TMath::Cos((*fTrackParNew)(3,0));
@@ -615,7 +620,7 @@ void AliMUONTrackK::ParPropagation(Double_t zEnd)
       distance = zEnd - vGeant3New[2];
       step /= 2;
       nTries ++;
-      if (nTries > kTriesMax) {
+      if (nTries > fgkTriesMax) {
        cout << " ***** ParPropagation: too many tries " << nTries << endl;
        exit(0);
       }
@@ -647,7 +652,7 @@ void AliMUONTrackK::WeightPropagation(Double_t zEnd)
   Int_t i, j;
   Double_t dPar;
 
-  TMatrixD Jacob(kSize,kSize);
+  TMatrixD Jacob(fgkSize,fgkSize);
   Jacob = 0;
 
   // Save initial and propagated parameters
@@ -662,7 +667,7 @@ void AliMUONTrackK::WeightPropagation(Double_t zEnd)
   if (fCovariance->Determinant() != 0) {
     //   fCovariance->Invert();
     Int_t ifailCov;
-    mnvertLocalK(&((*fCovariance)(0,0)), kSize,kSize,kSize,ifailCov);
+    mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
   } else {
     cout << " ***** Warning in WeightPropagation: Determinant fCovariance=0:" << endl;
   }
@@ -670,12 +675,12 @@ void AliMUONTrackK::WeightPropagation(Double_t zEnd)
   // Loop over parameters to find change of the initial vs propagated ones
   zEnd = fPosition;
   fPosition = fPositionNew;
-  for (i=0; i<kSize; i++) {
+  for (i=0; i<fgkSize; i++) {
     dPar = TMath::Sqrt((*fCovariance)(i,i));
     *fTrackPar = trackParNew0;
     (*fTrackPar)(i,0) += dPar;
     ParPropagation(zEnd);
-    for (j=0; j<kSize; j++) {
+    for (j=0; j<fgkSize; j++) {
       Jacob(j,i) = ((*fTrackParNew)(j,0)-trackPar0(j,0))/dPar;
     }
   }
@@ -724,17 +729,17 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
     //  fCovariance->Invert();
 
       Int_t ifailCov;
-      mnvertLocalK(&((*fCovariance)(0,0)), kSize,kSize,kSize,ifailCov);
+      mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
   } else {
     cout << " ***** Warning in FindPoint: Determinant fCovariance=0:" << endl;
   }
-  //WindowB = kNSigma*TMath::Sqrt((*fCovariance)(0,0)+sigmaB*sigmaB);
-  //WindowNonB = kNSigma*TMath::Sqrt((*fCovariance)(1,1)+sigmaNonB*sigmaNonB);
+  //WindowB = fgkNSigma*TMath::Sqrt((*fCovariance)(0,0)+sigmaB*sigmaB);
+  //WindowNonB = fgkNSigma*TMath::Sqrt((*fCovariance)(1,1)+sigmaNonB*sigmaNonB);
   // Loop over all hits and take hits from the chamber
-  TMatrixD pointWeight(kSize,kSize);
+  TMatrixD pointWeight(fgkSize,fgkSize);
   TMatrixD saveWeight = pointWeight;
   TMatrixD pointWeightTmp = pointWeight;
-  TMatrixD point(kSize,1);
+  TMatrixD point(fgkSize,1);
   TMatrixD trackPar = point;
   TMatrixD trackParTmp = point;
   Int_t nHitsOK = 0;
@@ -758,15 +763,15 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
          if (fCovariance->Determinant() != 0) {
            //fCovariance->Invert();
            Int_t ifailCov;
-           mnvertLocalK(&((*fCovariance)(0,0)), kSize,kSize,kSize,ifailCov);
+           mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
          } else {
            cout << " ***** Warning in FindPoint: Determinant fCovariance=0:" << endl;
          }
        }
        y = hit->GetBendingCoor();
        x = hit->GetNonBendingCoor();
-       WindowB = kNSigma*TMath::Sqrt((*fCovariance)(0,0)+hit->GetBendingReso2());
-       WindowNonB = kNSigma*TMath::Sqrt((*fCovariance)(1,1)+hit->GetNonBendingReso2());
+       WindowB = fgkNSigma*TMath::Sqrt((*fCovariance)(0,0)+hit->GetBendingReso2());
+       WindowNonB = fgkNSigma*TMath::Sqrt((*fCovariance)(1,1)+hit->GetNonBendingReso2());
        if (TMath::Abs((*fTrackParNew)(0,0)-y) <= WindowB &&
            TMath::Abs((*fTrackParNew)(1,0)-x) <= WindowNonB) {
          // Vector of measurements and covariance matrix
@@ -866,7 +871,7 @@ void AliMUONTrackK::TryPoint(TMatrixD &point, const TMatrixD &pointWeight, TMatr
 
     //  wu.Invert();
      Int_t ifailWU;
-      mnvertLocalK(&((wu)(0,0)), kSize,kSize,kSize,ifailWU);
+      mnvertLocalK(&((wu)(0,0)), fgkSize,fgkSize,fgkSize,ifailWU);
   } else {
     cout << " ***** Warning in TryPoint: Determinant wu=0:" << endl;
   }
@@ -897,7 +902,7 @@ void AliMUONTrackK::MSThin(Int_t sign)
     //fWeight->Invert(); // covariance
 
     Int_t ifailWeight;
-    mnvertLocalK(&((*fWeight)(0,0)), kSize,kSize,kSize,ifailWeight);
+    mnvertLocalK(&((*fWeight)(0,0)), fgkSize,fgkSize,fgkSize,ifailWeight);
   } else {
     cout << " ***** Warning in MSThin: Determinant fWeight=0:" << endl;
   }
@@ -915,7 +920,7 @@ void AliMUONTrackK::MSThin(Int_t sign)
   //fWeight->Invert(); // weight
 
   Int_t ifailWeight;
-  mnvertLocalK(&((*fWeight)(0,0)), kSize,kSize,kSize,ifailWeight);
+  mnvertLocalK(&((*fWeight)(0,0)), fgkSize,fgkSize,fgkSize,ifailWeight);
   return;
 }
   //__________________________________________________________________________
@@ -925,8 +930,8 @@ void AliMUONTrackK::StartBack(void)
   
   fBPFlag = kTRUE;
   fChi2 = 0;
-  for (Int_t i=0; i<kSize; i++) {
-    for (Int_t j=0; j<kSize; j++) {
+  for (Int_t i=0; i<fgkSize; i++) {
+    for (Int_t j=0; j<fgkSize; j++) {
       if (j==i) (*fWeight)(i,i) /= 100;
       //if (j==i) (*fWeight)(i,i) /= fNTrackHits*fNTrackHits;
       else (*fWeight)(j,i) = 0;
@@ -1066,7 +1071,7 @@ void AliMUONTrackK::Branson(void)
     //    fCovariance->Invert();
 
       Int_t ifailCov;
-      mnvertLocalK(&((*fCovariance)(0,0)), kSize,kSize,kSize,ifailCov);
+      mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
   } else {
     cout << " ***** Warning in Branson: Determinant fCovariance=0:" << endl;
   }
@@ -1181,8 +1186,8 @@ void AliMUONTrackK::GoToVertex(void)
   fPosition = fPositionNew;
   //*fTrackPar = *fTrackParNew; 
   // Add vertex as a hit
-  TMatrixD pointWeight(kSize,kSize);
-  TMatrixD point(kSize,1);
+  TMatrixD pointWeight(fgkSize,fgkSize);
+  TMatrixD point(fgkSize,1);
   TMatrixD trackParTmp = point;
   point(0,0) = 0; // vertex coordinate - should be taken somewhere
   point(1,0) = 0; // vertex coordinate - should be taken somewhere
@@ -1247,7 +1252,7 @@ void AliMUONTrackK::GoToVertex(void)
     //   fCovariance->Invert();
 
       Int_t ifailCov;
-      mnvertLocalK(&((*fCovariance)(0,0)), kSize,kSize,kSize,ifailCov);
+      mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
   } else {
     cout << " ***** Warning in GoToVertex: Determinant fCovariance=0:" << endl;
   }
@@ -1289,7 +1294,7 @@ void AliMUONTrackK::MSLine(Double_t dZ, Double_t X0)
     //   fCovariance->Invert();
 
        Int_t ifailCov;
-       mnvertLocalK(&((*fCovariance)(0,0)), kSize,kSize,kSize,ifailCov);
+       mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
   } else {
     cout << " ***** Warning in MSLine: Determinant fCovariance=0:" << endl;
   }
@@ -1323,7 +1328,7 @@ void AliMUONTrackK::MSLine(Double_t dZ, Double_t X0)
     //  fWeight->Invert();
 
        Int_t ifailWeight;
-       mnvertLocalK(&((*fWeight)(0,0)), kSize,kSize,kSize,ifailWeight);
+       mnvertLocalK(&((*fWeight)(0,0)), fgkSize,fgkSize,fgkSize,ifailWeight);
   } else {
     cout << " ***** Warning in MSLine: Determinant fWeight=0:" << endl;
   }

diff --git a/MUON/AliMUONTrackK.h b/MUON/AliMUONTrackK.h
index 5cc2aa1..188fa42 100644 (file)
--- a/MUON/AliMUONTrackK.h
+++ b/MUON/AliMUONTrackK.h
@@ -12,12 +12,6 @@ class AliMUONSegment;
 class AliMUON;
 class AliMUONHitForRec;
 
-// Some constants
- static const Int_t kSize = 5; // number of track parameters
-static const Int_t kNSigma = 4; //4; // acceptance window width in sigmas
- static const Int_t kTriesMax = 10000; // max number of attempts to find exact position during tracking
- static const Double_t kEpsilon = 0.002; // tracking precision (cm)
-
 class AliMUONTrackK : public TObject {
 
  public:
@@ -98,6 +92,13 @@ class AliMUONTrackK : public TObject {
   void GetFromGeantParam(Double_t *VGeant3, Int_t iFB);
   void Recover(void);
 
+  private:
+   // Some constants
+   static const Int_t fgkSize; // number of track parameters
+   static const Int_t fgkNSigma; //4; // acceptance window width in sigmas
+   static const Int_t fgkTriesMax; // max number of attempts to find exact position during tracking
+   static const Double_t fgkEpsilon; // tracking precision (cm)
+
   ClassDef(AliMUONTrackK,0) // Kalman track in MUON arm of ALICE
     };
 #endif