/* $Id$ */
-///////////////////////////////////////////////////
-//
-// Track parameters
-// in
-// ALICE
-// dimuon
-// spectrometer
-//
-///////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
+// Class AliMUONTrackParam
+//-------------------------
+// Track parameters in ALICE dimuon spectrometer
+//-----------------------------------------------------------------------------
#include "AliMUONTrackParam.h"
-#include "AliMUONHitForRec.h"
+#include "AliMUONVCluster.h"
-#include "AliESDMuonTrack.h"
#include "AliLog.h"
#include <TMath.h>
fExtrapCovariances(0x0),
fSmoothParameters(0x0),
fSmoothCovariances(0x0),
- fHitForRecPtr(0x0),
+ fClusterPtr(0x0),
+ fOwnCluster(kFALSE),
fRemovable(kFALSE),
fTrackChi2(0.),
fLocalChi2(0.)
{
/// Constructor
+ fParameters.Zero();
}
//_________________________________________________________________________
fExtrapCovariances(0x0),
fSmoothParameters(0x0),
fSmoothCovariances(0x0),
- fHitForRecPtr(theMUONTrackParam.fHitForRecPtr),
+ fClusterPtr(0x0),
+ fOwnCluster(theMUONTrackParam.fOwnCluster),
fRemovable(theMUONTrackParam.fRemovable),
fTrackChi2(theMUONTrackParam.fTrackChi2),
fLocalChi2(theMUONTrackParam.fLocalChi2)
if (theMUONTrackParam.fExtrapCovariances) fExtrapCovariances = new TMatrixD(*(theMUONTrackParam.fExtrapCovariances));
if (theMUONTrackParam.fSmoothParameters) fSmoothParameters = new TMatrixD(*(theMUONTrackParam.fSmoothParameters));
if (theMUONTrackParam.fSmoothCovariances) fSmoothCovariances = new TMatrixD(*(theMUONTrackParam.fSmoothCovariances));
+
+ if(fOwnCluster) fClusterPtr = static_cast<AliMUONVCluster*>(theMUONTrackParam.fClusterPtr->Clone());
+ else fClusterPtr = theMUONTrackParam.fClusterPtr;
}
//_________________________________________________________________________
if (theMUONTrackParam.fCovariances) {
if (fCovariances) *fCovariances = *(theMUONTrackParam.fCovariances);
else fCovariances = new TMatrixD(*(theMUONTrackParam.fCovariances));
- } else if (fCovariances) {
+ } else {
delete fCovariances;
fCovariances = 0x0;
}
if (theMUONTrackParam.fPropagator) {
if (fPropagator) *fPropagator = *(theMUONTrackParam.fPropagator);
else fPropagator = new TMatrixD(*(theMUONTrackParam.fPropagator));
- } else if (fPropagator) {
+ } else {
delete fPropagator;
fPropagator = 0x0;
}
if (theMUONTrackParam.fExtrapParameters) {
if (fExtrapParameters) *fExtrapParameters = *(theMUONTrackParam.fExtrapParameters);
else fExtrapParameters = new TMatrixD(*(theMUONTrackParam.fExtrapParameters));
- } else if (fExtrapParameters) {
+ } else {
delete fExtrapParameters;
fExtrapParameters = 0x0;
}
if (theMUONTrackParam.fExtrapCovariances) {
if (fExtrapCovariances) *fExtrapCovariances = *(theMUONTrackParam.fExtrapCovariances);
else fExtrapCovariances = new TMatrixD(*(theMUONTrackParam.fExtrapCovariances));
- } else if (fExtrapCovariances) {
+ } else {
delete fExtrapCovariances;
fExtrapCovariances = 0x0;
}
if (theMUONTrackParam.fSmoothParameters) {
if (fSmoothParameters) *fSmoothParameters = *(theMUONTrackParam.fSmoothParameters);
else fSmoothParameters = new TMatrixD(*(theMUONTrackParam.fSmoothParameters));
- } else if (fSmoothParameters) {
+ } else {
delete fSmoothParameters;
fSmoothParameters = 0x0;
}
if (theMUONTrackParam.fSmoothCovariances) {
if (fSmoothCovariances) *fSmoothCovariances = *(theMUONTrackParam.fSmoothCovariances);
else fSmoothCovariances = new TMatrixD(*(theMUONTrackParam.fSmoothCovariances));
- } else if (fSmoothCovariances) {
+ } else {
delete fSmoothCovariances;
fSmoothCovariances = 0x0;
}
- fHitForRecPtr = theMUONTrackParam.fHitForRecPtr;
+ if (fOwnCluster) delete fClusterPtr;
+ fOwnCluster = theMUONTrackParam.fOwnCluster;
+ if(fOwnCluster) fClusterPtr = static_cast<AliMUONVCluster*>(theMUONTrackParam.fClusterPtr->Clone());
+ else fClusterPtr = theMUONTrackParam.fClusterPtr;
fRemovable = theMUONTrackParam.fRemovable;
delete fExtrapCovariances;
delete fSmoothParameters;
delete fSmoothCovariances;
+ if(fOwnCluster) delete fClusterPtr;
}
//__________________________________________________________________________
void
AliMUONTrackParam::Clear(Option_t* /*opt*/)
{
- /// Delete the covariance matrix
+ /// clear memory
DeleteCovariances();
delete fPropagator; fPropagator = 0x0;
delete fExtrapParameters; fExtrapParameters = 0x0;
delete fExtrapCovariances; fExtrapCovariances = 0x0;
delete fSmoothParameters; fSmoothParameters = 0x0;
delete fSmoothCovariances; fSmoothCovariances = 0x0;
-}
-
- //__________________________________________________________________________
-AliMUONHitForRec* AliMUONTrackParam::GetHitForRecPtr(void) const
-{
-/// return pointer to HitForRec attached to the current TrackParam
-/// this method should not be called when fHitForRecPtr == NULL
- if (!fHitForRecPtr) AliWarning("fHitForRecPtr == NULL");
- return fHitForRecPtr;
-}
-
- //_________________________________________________________________________
-void AliMUONTrackParam::GetParamFrom(const AliESDMuonTrack& esdMuonTrack)
-{
- /// assigned value form ESD track.
- fZ = esdMuonTrack.GetZ();
- fParameters(0,0) = esdMuonTrack.GetNonBendingCoor();
- fParameters(1,0) = TMath::Tan(esdMuonTrack.GetThetaX());
- fParameters(2,0) = esdMuonTrack.GetBendingCoor();
- fParameters(3,0) = TMath::Tan(esdMuonTrack.GetThetaY());
- fParameters(4,0) = esdMuonTrack.GetInverseBendingMomentum();
-}
-
- //_________________________________________________________________________
-void AliMUONTrackParam::SetParamFor(AliESDMuonTrack& esdMuonTrack) const
-{
- /// assigned value form ESD track.
- esdMuonTrack.SetZ(fZ);
- esdMuonTrack.SetNonBendingCoor(fParameters(0,0));
- esdMuonTrack.SetThetaX(TMath::ATan(fParameters(1,0)));
- esdMuonTrack.SetBendingCoor(fParameters(2,0));
- esdMuonTrack.SetThetaY(TMath::ATan(fParameters(3,0)));
- esdMuonTrack.SetInverseBendingMomentum(fParameters(4,0));
-}
-
- //_________________________________________________________________________
-void AliMUONTrackParam::GetParamFromUncorrected(const AliESDMuonTrack& esdMuonTrack)
-{
- /// assigned value form ESD track.
- fZ = esdMuonTrack.GetZUncorrected();
- fParameters(0,0) = esdMuonTrack.GetNonBendingCoorUncorrected();
- fParameters(1,0) = TMath::Tan(esdMuonTrack.GetThetaXUncorrected());
- fParameters(2,0) = esdMuonTrack.GetBendingCoorUncorrected();
- fParameters(3,0) = TMath::Tan(esdMuonTrack.GetThetaYUncorrected());
- fParameters(4,0) = esdMuonTrack.GetInverseBendingMomentumUncorrected();
-}
-
- //_________________________________________________________________________
-void AliMUONTrackParam::SetParamForUncorrected(AliESDMuonTrack& esdMuonTrack) const
-{
- /// assigned value form ESD track.
- esdMuonTrack.SetZUncorrected(fZ);
- esdMuonTrack.SetNonBendingCoorUncorrected(fParameters(0,0));
- esdMuonTrack.SetThetaXUncorrected(TMath::ATan(fParameters(1,0)));
- esdMuonTrack.SetBendingCoorUncorrected(fParameters(2,0));
- esdMuonTrack.SetThetaYUncorrected(TMath::ATan(fParameters(3,0)));
- esdMuonTrack.SetInverseBendingMomentumUncorrected(fParameters(4,0));
+ if(fOwnCluster) {
+ delete fClusterPtr; fClusterPtr = 0x0;
+ }
}
//__________________________________________________________________________
Double_t AliMUONTrackParam::Px() const
{
/// return p_x from track parameters
- Double_t pYZ, pZ, pX;
- pYZ = 0;
- if ( TMath::Abs(fParameters(4,0)) > 0 )
- pYZ = TMath::Abs(1.0 / fParameters(4,0));
- pZ = -pYZ / (TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0))); // spectro. (z<0)
- pX = pZ * fParameters(1,0);
- return pX;
+ Double_t pZ;
+ if (TMath::Abs(fParameters(4,0)) > 0) {
+ Double_t pYZ = (TMath::Abs(fParameters(4,0)) > 0) ? TMath::Abs(1.0 / fParameters(4,0)) : FLT_MAX;
+ pZ = - pYZ / (TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0))); // spectro. (z<0)
+ } else {
+ pZ = - FLT_MAX / TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0) + fParameters(1,0) * fParameters(1,0));
+ }
+ return pZ * fParameters(1,0);
}
//__________________________________________________________________________
Double_t AliMUONTrackParam::Py() const
{
/// return p_y from track parameters
- Double_t pYZ, pZ, pY;
- pYZ = 0;
- if ( TMath::Abs(fParameters(4,0)) > 0 )
- pYZ = TMath::Abs(1.0 / fParameters(4,0));
- pZ = -pYZ / (TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0))); // spectro. (z<0)
- pY = pZ * fParameters(3,0);
- return pY;
+ Double_t pZ;
+ if (TMath::Abs(fParameters(4,0)) > 0) {
+ Double_t pYZ = (TMath::Abs(fParameters(4,0)) > 0) ? TMath::Abs(1.0 / fParameters(4,0)) : FLT_MAX;
+ pZ = - pYZ / (TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0))); // spectro. (z<0)
+ } else {
+ pZ = - FLT_MAX / TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0) + fParameters(1,0) * fParameters(1,0));
+ }
+ return pZ * fParameters(3,0);
}
//__________________________________________________________________________
Double_t AliMUONTrackParam::Pz() const
{
/// return p_z from track parameters
- Double_t pYZ, pZ;
- pYZ = 0;
- if ( TMath::Abs(fParameters(4,0)) > 0 )
- pYZ = TMath::Abs(1.0 / fParameters(4,0));
- pZ = -pYZ / (TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0))); // spectro. (z<0)
- return pZ;
+ if (TMath::Abs(fParameters(4,0)) > 0) {
+ Double_t pYZ = TMath::Abs(1.0 / fParameters(4,0));
+ return - pYZ / (TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0))); // spectro. (z<0)
+ } else return - FLT_MAX / TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0) + fParameters(1,0) * fParameters(1,0));
}
//__________________________________________________________________________
Double_t AliMUONTrackParam::P() const
{
/// return p from track parameters
- Double_t pYZ, pZ, p;
- pYZ = 0;
- if ( TMath::Abs(fParameters(4,0)) > 0 )
- pYZ = TMath::Abs(1.0 / fParameters(4,0));
- pZ = -pYZ / (TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0))); // spectro. (z<0)
- p = TMath::Abs(pZ) *
- TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0) + fParameters(1,0) * fParameters(1,0));
- return p;
-
+ if (TMath::Abs(fParameters(4,0)) > 0) {
+ Double_t pYZ = TMath::Abs(1.0 / fParameters(4,0));
+ Double_t pZ = - pYZ / (TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0))); // spectro. (z<0)
+ return - pZ * TMath::Sqrt(1.0 + fParameters(3,0) * fParameters(3,0) + fParameters(1,0) * fParameters(1,0));
+ } else return FLT_MAX;
}
//__________________________________________________________________________
void AliMUONTrackParam::SetCovariances(const TMatrixD& covariances)
{
/// Set the covariance matrix
- if (&covariances == fCovariances) return; // nothing to be done
if (fCovariances) *fCovariances = covariances;
else fCovariances = new TMatrixD(covariances);
}
/// Return the propagator (create it before if needed)
if (!fPropagator) {
fPropagator = new TMatrixD(5,5);
- fPropagator->Zero();
+ fPropagator->UnitMatrix();
}
return *fPropagator;
- }
+}
//__________________________________________________________________________
void AliMUONTrackParam::ResetPropagator()
{
/// Reset the propagator
- if (!fPropagator) fPropagator = new TMatrixD(5,5);
- fPropagator->UnitMatrix();
+ if (fPropagator) fPropagator->UnitMatrix();
}
//__________________________________________________________________________
void AliMUONTrackParam::UpdatePropagator(const TMatrixD& propagator)
{
/// Update the propagator
- if (&propagator == fPropagator) return; // nothing to be done
if (fPropagator) *fPropagator = TMatrixD(propagator,TMatrixD::kMult,*fPropagator);
else fPropagator = new TMatrixD(propagator);
}
void AliMUONTrackParam::SetExtrapParameters(const TMatrixD& extrapParameters)
{
/// Set extrapolated parameters
- if (&extrapParameters == fExtrapParameters) return; // nothing to be done
if (fExtrapParameters) *fExtrapParameters = extrapParameters;
else fExtrapParameters = new TMatrixD(extrapParameters);
}
void AliMUONTrackParam::SetExtrapCovariances(const TMatrixD& extrapCovariances)
{
/// Set the extrapolated covariance matrix
- if (&extrapCovariances == fExtrapCovariances) return; // nothing to be done
if (fExtrapCovariances) *fExtrapCovariances = extrapCovariances;
else fExtrapCovariances = new TMatrixD(extrapCovariances);
}
void AliMUONTrackParam::SetSmoothParameters(const TMatrixD& smoothParameters)
{
/// Set the smoothed parameters
- if (&smoothParameters == fSmoothParameters) return; // nothing to be done
if (fSmoothParameters) *fSmoothParameters = smoothParameters;
else fSmoothParameters = new TMatrixD(smoothParameters);
}
void AliMUONTrackParam::SetSmoothCovariances(const TMatrixD& smoothCovariances)
{
/// Set the smoothed covariance matrix
- if (&smoothCovariances == fSmoothCovariances) return; // nothing to be done
if (fSmoothCovariances) *fSmoothCovariances = smoothCovariances;
else fSmoothCovariances = new TMatrixD(smoothCovariances);
}
+//__________________________________________________________________________
+void AliMUONTrackParam::SetClusterPtr(AliMUONVCluster* cluster, Bool_t owner)
+{
+ /// set pointeur to associated cluster
+ if (fOwnCluster) delete fClusterPtr;
+ fClusterPtr = cluster;
+ fOwnCluster = owner;
+}
+
//__________________________________________________________________________
Int_t AliMUONTrackParam::Compare(const TObject* trackParam) const
{
/// "Compare" function to sort with decreasing Z (spectro. muon Z <0).
- /// Returns 1 (0, -1) if Z of current TrackHit
- /// is smaller than (equal to, larger than) Z of TrackHit
- if (fHitForRecPtr) {
- if (fHitForRecPtr->GetZ() != fZ)
- AliWarning("track parameters are given at a different z position than the one of the corresponding hit");
- }
+ /// Returns 1 (0, -1) if the current Z
+ /// is smaller than (equal to, larger than) Z of trackParam
if (fZ < ((AliMUONTrackParam*)trackParam)->GetZ()) return(1);
else if (fZ == ((AliMUONTrackParam*)trackParam)->GetZ()) return(0);
else return(-1);
}
-//_____________________________________________-
+ //__________________________________________________________________________
+Bool_t AliMUONTrackParam::CompatibleTrackParam(const AliMUONTrackParam &trackParam, Double_t sigma2Cut, Double_t &chi2) const
+{
+ /// Return kTRUE if the two set of track parameters are compatible within sigma2Cut
+ /// Set chi2 to the compatible chi2 value
+ /// Note that parameter covariances must exist for at least one set of parameters
+ /// Note also that if parameters are not given at the same Z, results will be meaningless
+
+ // reset chi2 value
+ chi2 = 0.;
+
+ // ckeck covariance matrices
+ if (!fCovariances && !trackParam.fCovariances) {
+ AliError("Covariance matrix must exist for at least one set of parameters");
+ return kFALSE;
+ }
+
+ Double_t maxChi2 = 5. * sigma2Cut * sigma2Cut; // 5 degrees of freedom
+
+ // check Z parameters
+ if (fZ != trackParam.fZ)
+ AliWarning(Form("Parameters are given at different Z position (%e : %e): results are meaningless", fZ, trackParam.fZ));
+
+ // compute the parameter residuals
+ TMatrixD deltaParam(fParameters, TMatrixD::kMinus, trackParam.fParameters);
+
+ // build the error matrix
+ TMatrixD weight(5,5);
+ if (fCovariances) weight += *fCovariances;
+ if (trackParam.fCovariances) weight += *(trackParam.fCovariances);
+
+ // invert the error matrix to get the parameter weights if possible
+ if (weight.Determinant() == 0) {
+ AliError("Cannot compute the compatibility chi2");
+ return kFALSE;
+ }
+ weight.Invert();
+
+ // compute the compatibility chi2
+ TMatrixD tmp(deltaParam, TMatrixD::kTransposeMult, weight);
+ TMatrixD mChi2(tmp, TMatrixD::kMult, deltaParam);
+
+ // set chi2 value
+ chi2 = mChi2(0,0);
+
+ // check compatibility
+ if (chi2 > maxChi2) return kFALSE;
+
+ return kTRUE;
+}
+
+ //__________________________________________________________________________
void AliMUONTrackParam::Print(Option_t* opt) const
{
/// Printing TrackParam information
"," << setw(5) << setprecision(3) << fZ <<
") cm, (px,py,pz)=(" << setw(5) << setprecision(3) << Px() <<
"," << setw(5) << setprecision(3) << Py() <<
- "," << setw(5) << setprecision(3) << Pz() << ") GeV/c" << endl;
+ "," << setw(5) << setprecision(3) << Pz() << ") GeV/c"
+ "," << "local chi2=" << GetLocalChi2() << endl;
}
else {
cout << "<AliMUONTrackParam>" << endl;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff