ClassImp(AliMUONClusterFinderAZ)
+ const Double_t AliMUONClusterFinderAZ::fgkCouplMin = 1.e-3; // threshold on coupling
AliMUONClusterFinderAZ* AliMUONClusterFinderAZ::fgClusterFinder = 0x0;
TMinuit* AliMUONClusterFinderAZ::fgMinuit = 0x0;
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:
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);
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];
}
}
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));
}
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));
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);
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) {
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)
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];
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;
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 {
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
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
#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
fMUONData = 0;
fChambers = new TObjArray(AliMUONConstants::NCh());
- fPrintLevel = kDefaultPrintLevel;
+ fPrintLevel = fgkDefaultPrintLevel;
// initialize loader's
fLoader = loader;
protected:
private:
+ static const Int_t fgkDefaultPrintLevel; // Default print level
Int_t fNCh; // Number of chambers
Int_t fNTrackingCh; // Number of tracking chambers*
#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
{
// 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
// 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;
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;
}
// 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;
}
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]
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
// 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;
}
// 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
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
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:
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
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
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
#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:
// 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
#include "AliMUONTrackParam.h" // object belongs to the class
-const Int_t kMaxTrackingChamber=10;
+//const Int_t kMaxTrackingChamber=10;
+ // not used
class TObjArray;
class TClonesArray;
#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
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) {
// 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;
}
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();
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));
distance = zEnd - vGeant3New[2];
step /= 2;
nTries ++;
- if (nTries > kTriesMax) {
+ if (nTries > fgkTriesMax) {
cout << " ***** ParPropagation: too many tries " << nTries << endl;
exit(0);
}
Int_t i, j;
Double_t dPar;
- TMatrixD Jacob(kSize,kSize);
+ TMatrixD Jacob(fgkSize,fgkSize);
Jacob = 0;
// Save initial and propagated parameters
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;
}
// 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;
}
}
// 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;
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
// 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;
}
//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;
}
//fWeight->Invert(); // weight
Int_t ifailWeight;
- mnvertLocalK(&((*fWeight)(0,0)), kSize,kSize,kSize,ifailWeight);
+ mnvertLocalK(&((*fWeight)(0,0)), fgkSize,fgkSize,fgkSize,ifailWeight);
return;
}
//__________________________________________________________________________
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;
// 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;
}
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
// 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;
}
// 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;
}
// 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;
}
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:
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