#include "AliMUONVClusterStore.h"
#include "AliMUONObjectPair.h"
#include "AliMUONTrackExtrap.h"
+#include "AliMUONConstants.h"
+#include "AliMUONTrackParam.h"
#include "AliLog.h"
#include <TMath.h>
-#include <TMatrixD.h>
#include <Riostream.h>
+using std::setw;
+using std::endl;
+using std::cout;
+using std::streamsize;
+using std::setprecision;
/// \cond CLASSIMP
ClassImp(AliMUONTrack) // Class implementation in ROOT context
/// \endcond
+
+const Double_t AliMUONTrack::fgkMaxChi2 = 1.e10; ///< maximum chi2 above which the track can be considered as abnormal
+
+
//__________________________________________________________________________
AliMUONTrack::AliMUONTrack()
: TObject(),
fGlobalChi2(-1.),
fImproved(kFALSE),
fMatchTrigger(-1),
- floTrgNum(-1),
fChi2MatchTrigger(0.),
- fTrackID(0),
+ fTrackID(-1),
fTrackParamAtVertex(0x0),
fHitsPatternInTrigCh(0),
- fLocalTrigger(0)
+ fHitsPatternInTrigChTrk(0),
+ fLocalTrigger(0),
+ fConnected(kFALSE)
{
/// Default constructor
fVertexErrXY2[0] = 0.;
//__________________________________________________________________________
AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment, Double_t bendingVertexDispersion)
: TObject(),
- fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)),
+ fTrackParamAtCluster(new TObjArray(20)),
fFitWithVertex(kFALSE),
fVertexErrXY2(),
fFitWithMCS(kFALSE),
fGlobalChi2(0.),
fImproved(kFALSE),
fMatchTrigger(-1),
- floTrgNum(-1),
fChi2MatchTrigger(0.),
- fTrackID(0),
+ fTrackID(-1),
fTrackParamAtVertex(0x0),
fHitsPatternInTrigCh(0),
- fLocalTrigger(0)
+ fHitsPatternInTrigChTrk(0),
+ fLocalTrigger(0),
+ fConnected(kFALSE)
{
/// Constructor from two clusters
+ fTrackParamAtCluster->SetOwner(kTRUE);
+
fVertexErrXY2[0] = 0.;
fVertexErrXY2[1] = 0.;
paramCov(3,2) = paramCov(2,3);
paramCov(3,3) = ( firstCluster->GetErrY2() + lastCluster->GetErrY2() ) / dZ / dZ;
// Inverse bending momentum (vertex resolution + bending slope resolution + 10% error on dipole parameters+field)
- paramCov(4,4) = ( ( bendingVertexDispersion*bendingVertexDispersion +
- (z1 * z1 * lastCluster->GetErrY2() + z2 * z2 * firstCluster->GetErrY2()) / dZ / dZ) /
- bendingImpact / bendingImpact + 0.1 * 0.1) * inverseBendingMomentum * inverseBendingMomentum ;
- paramCov(2,4) = - z2 * firstCluster->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ;
- paramCov(4,2) = paramCov(2,4);
- paramCov(3,4) = - (z1 * lastCluster->GetErrY2() + z2 * firstCluster->GetErrY2()) * inverseBendingMomentum / bendingImpact / dZ / dZ;
- paramCov(4,3) = paramCov(3,4);
-
- // Set covariances
+ if (AliMUONTrackExtrap::IsFieldON()) {
+ paramCov(4,4) = ( ( bendingVertexDispersion*bendingVertexDispersion +
+ (z1 * z1 * lastCluster->GetErrY2() + z2 * z2 * firstCluster->GetErrY2()) / dZ / dZ) /
+ bendingImpact / bendingImpact + 0.1 * 0.1) * inverseBendingMomentum * inverseBendingMomentum ;
+ paramCov(2,4) = - z2 * firstCluster->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ;
+ paramCov(4,2) = paramCov(2,4);
+ paramCov(3,4) = - (z1 * lastCluster->GetErrY2() + z2 * firstCluster->GetErrY2()) * inverseBendingMomentum / bendingImpact / dZ / dZ;
+ paramCov(4,3) = paramCov(3,4);
+ } else paramCov(4,4) = inverseBendingMomentum*inverseBendingMomentum;
trackParamAtFirstCluster.SetCovariances(paramCov);
// Compute and set track parameters covariances at last cluster
- paramCov(1,0) = - paramCov(1,0);
- paramCov(0,1) = - paramCov(0,1);
- paramCov(3,2) = - paramCov(3,2);
- paramCov(2,3) = - paramCov(2,3);
- paramCov(2,4) = z1 * lastCluster->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ;
- paramCov(4,2) = paramCov(2,4);
+ // Non bending plane
+ paramCov(0,0) = lastCluster->GetErrX2();
+ paramCov(0,1) = - lastCluster->GetErrX2() / dZ;
+ paramCov(1,0) = paramCov(0,1);
+ // Bending plane
+ paramCov(2,2) = lastCluster->GetErrY2();
+ paramCov(2,3) = - lastCluster->GetErrY2() / dZ;
+ paramCov(3,2) = paramCov(2,3);
+ // Inverse bending momentum (vertex resolution + bending slope resolution + 10% error on dipole parameters+field)
+ if (AliMUONTrackExtrap::IsFieldON()) {
+ paramCov(2,4) = z1 * lastCluster->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ;
+ paramCov(4,2) = paramCov(2,4);
+ }
trackParamAtLastCluster.SetCovariances(paramCov);
// Add track parameters at clusters
fGlobalChi2(track.fGlobalChi2),
fImproved(track.fImproved),
fMatchTrigger(track.fMatchTrigger),
- floTrgNum(track.floTrgNum),
fChi2MatchTrigger(track.fChi2MatchTrigger),
fTrackID(track.fTrackID),
fTrackParamAtVertex(0x0),
fHitsPatternInTrigCh(track.fHitsPatternInTrigCh),
- fLocalTrigger(track.fLocalTrigger)
+ fHitsPatternInTrigChTrk(track.fHitsPatternInTrigChTrk),
+ fLocalTrigger(track.fLocalTrigger),
+ fConnected(track.fConnected)
{
///copy constructor
- // necessary to make a copy of the objects and not only the pointers in TClonesArray.
+ // necessary to make a copy of the objects and not only the pointers in TObjArray.
if (track.fTrackParamAtCluster) {
- fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10);
- AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->First();
- while (trackParamAtCluster) {
- new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(*trackParamAtCluster);
- trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->After(trackParamAtCluster);
- }
+ fTrackParamAtCluster = new TObjArray(track.fTrackParamAtCluster->GetSize());
+ fTrackParamAtCluster->SetOwner(kTRUE);
+ for (Int_t i = 0; i < track.GetNClusters(); i++)
+ fTrackParamAtCluster->AddLast(new AliMUONTrackParam(*static_cast<AliMUONTrackParam*>(track.fTrackParamAtCluster->UncheckedAt(i))));
}
// copy vertex resolution square used during the tracking procedure
// clear memory
Clear();
- // necessary to make a copy of the objects and not only the pointers in TClonesArray
+ // necessary to make a copy of the objects and not only the pointers in TObjArray
if (track.fTrackParamAtCluster) {
- fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10);
- AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->First();
- while (trackParamAtCluster) {
- new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(*trackParamAtCluster);
- trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->After(trackParamAtCluster);
- }
+ fTrackParamAtCluster = new TObjArray(track.fTrackParamAtCluster->GetSize());
+ fTrackParamAtCluster->SetOwner(kTRUE);
+ for (Int_t i = 0; i < track.GetNClusters(); i++)
+ fTrackParamAtCluster->AddLast(new AliMUONTrackParam(*static_cast<AliMUONTrackParam*>(track.fTrackParamAtCluster->UncheckedAt(i))));
}
// copy cluster weights matrix if any
fGlobalChi2 = track.fGlobalChi2;
fImproved = track.fImproved;
fMatchTrigger = track.fMatchTrigger;
- floTrgNum = track.floTrgNum;
fChi2MatchTrigger = track.fChi2MatchTrigger;
fTrackID = track.fTrackID;
fHitsPatternInTrigCh = track.fHitsPatternInTrigCh;
+ fHitsPatternInTrigChTrk = track.fHitsPatternInTrigChTrk;
fLocalTrigger = track.fLocalTrigger;
+ fConnected = track.fConnected;
return *this;
}
}
//__________________________________________________________________________
-void AliMUONTrack::Clear(Option_t* opt)
+void AliMUONTrack::Clear(Option_t* /*opt*/)
{
/// Clear arrays
- if (opt && opt[0] == 'C' && fTrackParamAtCluster) fTrackParamAtCluster->Clear("C");
- else {
- delete fTrackParamAtCluster;
- fTrackParamAtCluster = 0x0;
- }
+ delete fTrackParamAtCluster; fTrackParamAtCluster = 0x0;
delete fClusterWeightsNonBending; fClusterWeightsNonBending = 0x0;
delete fClusterWeightsBending; fClusterWeightsBending = 0x0;
delete fTrackParamAtVertex; fTrackParamAtVertex = 0x0;
fGlobalChi2 = -1.;
fImproved = kFALSE;
fMatchTrigger = -1;
- floTrgNum = -1;
fChi2MatchTrigger = 0.;
- fTrackID = 0;
+ fTrackID = -1;
fHitsPatternInTrigCh = 0;
+ fHitsPatternInTrigChTrk = 0;
fLocalTrigger = 0;
+ fConnected = kFALSE;
delete fTrackParamAtCluster; fTrackParamAtCluster = 0x0;
delete fClusterWeightsNonBending; fClusterWeightsNonBending = 0x0;
delete fClusterWeightsBending; fClusterWeightsBending = 0x0;
}
//__________________________________________________________________________
-TClonesArray* AliMUONTrack::GetTrackParamAtCluster() const
+TObjArray* AliMUONTrack::GetTrackParamAtCluster() const
{
/// return array of track parameters at cluster (create it if needed)
- if (!fTrackParamAtCluster) fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10);
+ if (!fTrackParamAtCluster) {
+ fTrackParamAtCluster = new TObjArray(20);
+ fTrackParamAtCluster->SetOwner(kTRUE);
+ }
return fTrackParamAtCluster;
}
}
// check whether track parameters are given at the correct cluster z position
- if (cluster.GetZ() != trackParam.GetZ()) {
+ if (TMath::Abs(cluster.GetZ() - trackParam.GetZ())>1.e-5) { // AU
AliError("track parameters are given at a different z position than the one of the associated cluster");
return;
}
// add parameters to the array of track parameters
- if (!fTrackParamAtCluster) fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10);
- AliMUONTrackParam* trackParamAtCluster = new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(trackParam);
+ if (!fTrackParamAtCluster) {
+ fTrackParamAtCluster = new TObjArray(20);
+ fTrackParamAtCluster->SetOwner(kTRUE);
+ }
+ AliMUONTrackParam* trackParamAtCluster = new AliMUONTrackParam(trackParam);
+ fTrackParamAtCluster->AddLast(trackParamAtCluster);
// link parameters with the associated cluster or its copy
if (copy) {
//__________________________________________________________________________
void AliMUONTrack::RemoveTrackParamAtCluster(AliMUONTrackParam *trackParam)
{
- /// Remove trackParam from the array of TrackParamAtCluster
- if (!fTrackParamAtCluster || !fTrackParamAtCluster->Remove(trackParam)) {
- AliWarning("object to remove does not exist in array fTrackParamAtCluster");
- return;
- }
+ /// Remove trackParam from the array of TrackParamAtCluster and delete it since the array is owner
+
+ if (fTrackParamAtCluster) {
+
+ AliMUONTrackParam* trackParamAtCluster = static_cast<AliMUONTrackParam*>(fTrackParamAtCluster->Remove(trackParam));
+
+ if (trackParamAtCluster) {
+
+ // clean memory
+ delete trackParamAtCluster;
+
+ // remove hole
+ fTrackParamAtCluster->Compress();
+
+ } else AliWarning("object to remove does not exist in array fTrackParamAtCluster");
+
+ } else AliWarning("array fTrackParamAtCluster does not exist");
- fTrackParamAtCluster->Compress();
}
//__________________________________________________________________________
-void AliMUONTrack::UpdateTrackParamAtCluster()
+Bool_t AliMUONTrack::UpdateTrackParamAtCluster()
{
/// Update track parameters at each attached cluster
+ /// Return kFALSE in case of failure (i.e. extrapolation problem)
- if (GetNClusters() == 0) {
+ Int_t nClusters = GetNClusters();
+ if (nClusters == 0) {
AliWarning("no cluster attached to the track");
- return;
+ return kFALSE;
}
- AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->First();
- AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(startingTrackParam);
- while (trackParamAtCluster) {
+ Bool_t extrapStatus = kTRUE;
+ AliMUONTrackParam* startingTrackParam = static_cast<AliMUONTrackParam*>(fTrackParamAtCluster->UncheckedAt(0));
+
+ for (Int_t i = 1; i < nClusters; i++) {
+ AliMUONTrackParam* trackParamAtCluster = static_cast<AliMUONTrackParam*>(fTrackParamAtCluster->UncheckedAt(i));
// reset track parameters and their covariances
trackParamAtCluster->SetParameters(startingTrackParam->GetParameters());
trackParamAtCluster->SetZ(startingTrackParam->GetZ());
// extrapolation to the given z
- AliMUONTrackExtrap::ExtrapToZ(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ());
+ if (!AliMUONTrackExtrap::ExtrapToZ(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ())) extrapStatus = kFALSE;
// prepare next step
startingTrackParam = trackParamAtCluster;
- trackParamAtCluster = (AliMUONTrackParam*) (fTrackParamAtCluster->After(trackParamAtCluster));
}
+ // set global chi2 to max value in case of problem during track extrapolation
+ if (!extrapStatus) SetGlobalChi2(2.*MaxChi2());
+ return extrapStatus;
+
}
//__________________________________________________________________________
-void AliMUONTrack::UpdateCovTrackParamAtCluster()
+Bool_t AliMUONTrack::UpdateCovTrackParamAtCluster()
{
/// Update track parameters and their covariances at each attached cluster
/// Include effects of multiple scattering in chambers
+ /// Return kFALSE in case of failure (i.e. extrapolation problem)
- if (GetNClusters() == 0) {
+ Int_t nClusters = GetNClusters();
+ if (nClusters == 0) {
AliWarning("no cluster attached to the track");
- return;
+ return kFALSE;
}
- AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->First();
- AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(startingTrackParam);
+ Bool_t extrapStatus = kTRUE;
+ AliMUONTrackParam* startingTrackParam = static_cast<AliMUONTrackParam*>(fTrackParamAtCluster->UncheckedAt(0));
Int_t expectedChamber = startingTrackParam->GetClusterPtr()->GetChamberId() + 1;
Int_t currentChamber;
- while (trackParamAtCluster) {
+
+ for (Int_t i = 1; i < nClusters; i++) {
+ AliMUONTrackParam* trackParamAtCluster = static_cast<AliMUONTrackParam*>(fTrackParamAtCluster->UncheckedAt(i));
// reset track parameters and their covariances
trackParamAtCluster->SetParameters(startingTrackParam->GetParameters());
trackParamAtCluster->SetCovariances(startingTrackParam->GetCovariances());
// add MCS effect
- AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(expectedChamber-1),-1.);
// add MCS in missing chambers if any
currentChamber = trackParamAtCluster->GetClusterPtr()->GetChamberId();
while (currentChamber > expectedChamber) {
// extrapolation to the missing chamber
- AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, AliMUONConstants::DefaultChamberZ(expectedChamber));
+ if (!AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, AliMUONConstants::DefaultChamberZ(expectedChamber))) extrapStatus = kFALSE;
// add MCS effect
- AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(expectedChamber),-1.);
expectedChamber++;
}
// extrapolation to the z of the current cluster
- AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ());
+ if (!AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ())) extrapStatus = kFALSE;
// prepare next step
expectedChamber = currentChamber + 1;
startingTrackParam = trackParamAtCluster;
- trackParamAtCluster = (AliMUONTrackParam*) (fTrackParamAtCluster->After(trackParamAtCluster));
}
+ // set global chi2 to max value in case of problem during track extrapolation
+ if (!extrapStatus) SetGlobalChi2(2.*MaxChi2());
+ return extrapStatus;
+
}
//__________________________________________________________________________
-Bool_t AliMUONTrack::IsValid(UInt_t requestedStationMask)
+Bool_t AliMUONTrack::IsValid(UInt_t requestedStationMask, Bool_t request2ChInSameSt45)
{
/// check the validity of the current track:
/// at least one cluster per requested station
/// and at least 2 chambers in stations 4 & 5 that contain cluster(s)
+ /// + if request2ChInSameSt45 = kTRUE: 2 chambers hit in the same station (4 or 5)
Int_t nClusters = GetNClusters();
AliMUONTrackParam *trackParam;
- Int_t currentCh, currentSt, previousCh = -1, nChHitInSt45 = 0;
+ Int_t currentCh, currentSt, previousCh = -1, nChHitInSt4 = 0, nChHitInSt5 = 0;
UInt_t presentStationMask(0);
// first loop over clusters
// build present station mask
presentStationMask |= ( 1 << currentSt );
- // count the number of chambers in station 4 & 5 that contain cluster(s)
- if (currentCh > 5 && currentCh != previousCh) {
- nChHitInSt45++;
+ // count the number of chambers hit in station 4 that contain cluster(s)
+ if (currentSt == 3 && currentCh != previousCh) {
+ nChHitInSt4++;
+ previousCh = currentCh;
+ }
+
+ // count the number of chambers hit in station 5 that contain cluster(s)
+ if (currentSt == 4 && currentCh != previousCh) {
+ nChHitInSt5++;
previousCh = currentCh;
}
}
- return (((requestedStationMask & presentStationMask) == requestedStationMask) && (nChHitInSt45 >= 2));
+ // at least one cluster per requested station
+ if ((requestedStationMask & presentStationMask) != requestedStationMask) return kFALSE;
+
+ // 2 chambers hit in the same station (4 or 5)
+ if (request2ChInSameSt45) return (nChHitInSt4 == 2 || nChHitInSt5 == 2);
+ // or 2 chambers hit in station 4 & 5 together
+ else return (nChHitInSt4+nChHitInSt5 >= 2);
+
}
//__________________________________________________________________________
if (globalChi2 < 0.) return kFALSE;
// Loop over removable clusters and compute their local chi2
+ AliMUONTrackParam* trackParamAtCluster;
AliMUONTrackParam* trackParamAtCluster1;
AliMUONVCluster *cluster, *discardedCluster;
Int_t iCluster1, iCluster2, iCurrentCluster1, iCurrentCluster2;
Double_t *dX = new Double_t[nClusters-1];
Double_t *dY = new Double_t[nClusters-1];
Double_t globalChi2b;
- AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->First();
- while (trackParamAtCluster) {
+ for (Int_t iCluster = 0; iCluster < nClusters ; iCluster++) {
+ trackParamAtCluster = static_cast<AliMUONTrackParam*>(fTrackParamAtCluster->UncheckedAt(iCluster));
discardedCluster = trackParamAtCluster->GetClusterPtr();
// Set local chi2
trackParamAtCluster->SetLocalChi2(globalChi2 - globalChi2b);
-
- trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(trackParamAtCluster);
}
delete [] dX;
} else { // without multiple scattering effects
+ Int_t nClusters = GetNClusters();
+ AliMUONTrackParam* trackParamAtCluster;
AliMUONVCluster *discardedCluster;
Double_t dX, dY;
- AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->First();
- while (trackParamAtCluster) {
+ for (Int_t iCluster = 0; iCluster < nClusters ; iCluster++) {
+ trackParamAtCluster = static_cast<AliMUONTrackParam*>(fTrackParamAtCluster->UncheckedAt(iCluster));
discardedCluster = trackParamAtCluster->GetClusterPtr();
// Set local chi2
trackParamAtCluster->SetLocalChi2(dX * dX / discardedCluster->GetErrX2() + dY * dY / discardedCluster->GetErrY2());
-
- trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(trackParamAtCluster);
}
}
/// Compute the chi2 of the track accounting for multiple scattering or not according to the flag
/// - Assume that track parameters at each cluster are corrects
/// - Assume the cluster weights matrices are corrects
- /// - Return negative value if chi2 computation failed
+ /// - Return a value of chi2 higher than the maximum allowed if computation failed
AliDebug(1,"Enter ComputeGlobalChi2");
if (!fTrackParamAtCluster) {
AliWarning("no cluster attached to this track");
- return 1.e10;
+ return 2.*MaxChi2();
}
Double_t chi2 = 0.;
//__________________________________________________________________________
Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& clusterWeightsNB, TMatrixD& clusterWeightsB,
- TMatrixD* mcsCovariances, AliMUONVCluster* discardedCluster) const
+ TMatrixD* mcsCovariances, const AliMUONVCluster* discardedCluster) const
{
/// Compute the weight matrices, in non bending and bending direction,
/// of the other attached clusters assuming the discarded one does not exist
AliMUONTrackExtrap::ExtrapToZ(&extrapTrackParam, zMCS[size]);
// Save multiple scattering dispersion angle in missing chamber
- mcsAngle2[size] = AliMUONTrackExtrap::GetMCSAngle2(extrapTrackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
+ mcsAngle2[size] = AliMUONTrackExtrap::GetMCSAngle2(extrapTrackParam,AliMUONConstants::ChamberThicknessInX0(expectedChamber),1.);
} else mcsAngle2[size] = 0.;
zMCS[size] = trackParamAtCluster->GetZ();
// Save multiple scattering dispersion angle in current chamber
- mcsAngle2[size] = AliMUONTrackExtrap::GetMCSAngle2(*trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.);
+ mcsAngle2[size] = AliMUONTrackExtrap::GetMCSAngle2(*trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(currentChamber),1.);
// Save indice in zMCS array corresponding to the current cluster
indices[iCluster] = size;
}
//__________________________________________________________________________
-Int_t AliMUONTrack::ClustersInCommon(AliMUONTrack* track, Bool_t inSt345) const
+Int_t AliMUONTrack::ClustersInCommon(AliMUONTrack* track, Int_t stMin, Int_t stMax) const
{
- /// Returns the number of clusters in common between the current track ("this")
- /// and the track pointed to by "track".
- /// If inSt345=kTRUE only stations 3, 4 and 5 are considered.
- if (!fTrackParamAtCluster || !this->fTrackParamAtCluster) return 0;
+ /// Returns the number of clusters in common in stations [stMin, stMax]
+ /// between the current track ("this") and the track pointed to by "track".
+
+ if (!track || !track->fTrackParamAtCluster || !this->fTrackParamAtCluster) return 0;
+
+ Int_t chMin = 2 * stMin;
+ Int_t chMax = 2 * stMax + 1;
Int_t clustersInCommon = 0;
- AliMUONTrackParam *trackParamAtCluster1, *trackParamAtCluster2;
+
// Loop over clusters of first track
- trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->First();
- while (trackParamAtCluster1) {
- if ((!inSt345) || (trackParamAtCluster1->GetClusterPtr()->GetChamberId() > 3)) {
- // Loop over clusters of second track
- trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->First();
- while (trackParamAtCluster2) {
- if ((!inSt345) || (trackParamAtCluster2->GetClusterPtr()->GetChamberId() > 3)) {
- // Increment "clustersInCommon" if both trackParamAtCluster1 & 2 point to the same cluster
- if ((trackParamAtCluster1->GetClusterPtr()) == (trackParamAtCluster2->GetClusterPtr())) {
- clustersInCommon++;
- break;
- }
- }
- trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->After(trackParamAtCluster2);
- } // trackParamAtCluster2
+ Int_t nCl1 = this->GetNClusters();
+ for(Int_t iCl1 = 0; iCl1 < nCl1; iCl1++) {
+ AliMUONVCluster* cl1 = ((AliMUONTrackParam*) this->fTrackParamAtCluster->UncheckedAt(iCl1))->GetClusterPtr();
+
+ Int_t chCl1 = cl1->GetChamberId();
+ if (chCl1 < chMin || chCl1 > chMax) continue;
+
+ // Loop over clusters of second track
+ Int_t nCl2 = track->GetNClusters();
+ for(Int_t iCl2 = 0; iCl2 < nCl2; iCl2++) {
+ AliMUONVCluster* cl2 = ((AliMUONTrackParam*) track->fTrackParamAtCluster->UncheckedAt(iCl2))->GetClusterPtr();
+
+ Int_t chCl2 = cl2->GetChamberId();
+ if (chCl2 < chMin || chCl2 > chMax) continue;
+
+ // Increment "clustersInCommon" if both clusters have the same ID
+ if (cl1->GetUniqueID() == cl2->GetUniqueID()) {
+ clustersInCommon++;
+ break;
+ }
+
}
- trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->After(trackParamAtCluster1);
- } // trackParamAtCluster1
+
+ }
+
return clustersInCommon;
}
/// return the chi2 value divided by the number of degrees of freedom (or FLT_MAX if ndf <= 0)
Double_t ndf = (Double_t) GetNDF();
- return (ndf > 0.) ? fGlobalChi2 / ndf : FLT_MAX;
+ return (ndf > 0.) ? fGlobalChi2 / ndf : 2.*MaxChi2();
}
//__________________________________________________________________________
-Int_t AliMUONTrack::CompatibleTrack(AliMUONTrack* track, Double_t sigmaCut, Bool_t compatibleCluster[10]) const
+Int_t AliMUONTrack::FindCompatibleClusters(const AliMUONTrack &track, Double_t sigmaCut, Bool_t compatibleCluster[10]) const
{
- /// for each chamber: return kTRUE (kFALSE) if clusters are compatible (not compatible).
- /// nMatchClusters = number of clusters of "this" track matched with one cluster of track "track"
- AliMUONTrackParam *trackParamAtCluster1, *trackParamAtCluster2;
+ /// Try to match clusters from this track with clusters from the given track within the provided sigma cut:
+ /// - Fill the array compatibleCluster[iCh] with kTRUE if a compatible cluster has been found in chamber iCh.
+ /// - Return the number of clusters of "this" track matched with one cluster of the given track.
AliMUONVCluster *cluster1, *cluster2;
Double_t chi2, dX, dY;
Double_t chi2Max = sigmaCut * sigmaCut;
Int_t nMatchClusters = 0;
for ( Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++) compatibleCluster[ch] = kFALSE;
- if (!fTrackParamAtCluster || !this->fTrackParamAtCluster) return nMatchClusters;
+ if (!track.fTrackParamAtCluster || !this->fTrackParamAtCluster) return nMatchClusters;
// Loop over clusters of first track
- trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->First();
- while (trackParamAtCluster1) {
-
- cluster1 = trackParamAtCluster1->GetClusterPtr();
+ Int_t nCl1 = this->GetNClusters();
+ for(Int_t iCl1 = 0; iCl1 < nCl1; iCl1++) {
+ cluster1 = static_cast<AliMUONTrackParam*>(this->fTrackParamAtCluster->UncheckedAt(iCl1))->GetClusterPtr();
// Loop over clusters of second track
- trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->First();
- while (trackParamAtCluster2) {
-
- cluster2 = trackParamAtCluster2->GetClusterPtr();
-
- //prepare next step
- trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->After(trackParamAtCluster2);
+ Int_t nCl2 = track.GetNClusters();
+ for(Int_t iCl2 = 0; iCl2 < nCl2; iCl2++) {
+ cluster2 = static_cast<AliMUONTrackParam*>(track.fTrackParamAtCluster->UncheckedAt(iCl2))->GetClusterPtr();
// check DE Id
if (cluster1->GetDetElemId() != cluster2->GetDetElemId()) continue;
- // non bending direction
+ // check local chi2
dX = cluster1->GetX() - cluster2->GetX();
- chi2 = dX * dX / (cluster1->GetErrX2() + cluster2->GetErrX2());
- if (chi2 > chi2Max) continue;
-
- // bending direction
dY = cluster1->GetY() - cluster2->GetY();
- chi2 = dY * dY / (cluster1->GetErrY2() + cluster2->GetErrY2());
- if (chi2 > chi2Max) continue;
+ chi2 = dX * dX / (cluster1->GetErrX2() + cluster2->GetErrX2()) + dY * dY / (cluster1->GetErrY2() + cluster2->GetErrY2());
+ if (chi2 > 2. * chi2Max) continue; // 2 because 2 quantities in chi2
compatibleCluster[cluster1->GetChamberId()] = kTRUE;
nMatchClusters++;
break;
}
- trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->After(trackParamAtCluster1);
}
return nMatchClusters;
}
+//__________________________________________________________________________
+Bool_t AliMUONTrack::Match(AliMUONTrack &track, Double_t sigmaCut, Int_t &nMatchClusters) const
+{
+ /// Try to match this track with the given track. Matching conditions:
+ /// - more than 50% of clusters from this track matched with clusters from the given track
+ /// - at least 1 cluster matched before and 1 cluster matched after the dipole
+
+ Bool_t compTrack[10];
+ nMatchClusters = FindCompatibleClusters(track, sigmaCut, compTrack);
+
+ if ((compTrack[0] || compTrack[1] || compTrack[2] || compTrack[3]) && // at least 1 cluster matched in st 1 & 2
+ (compTrack[6] || compTrack[7] || compTrack[8] || compTrack[9]) && // at least 1 cluster matched in st 4 & 5
+ 2 * nMatchClusters > GetNClusters()) return kTRUE; // more than 50% of clusters matched
+ else return kFALSE;
+
+}
+
//__________________________________________________________________________
void AliMUONTrack::SetTrackParamAtVertex(const AliMUONTrackParam* trackParam)
{
{
/// Printing Track information
+ streamsize curW = cout.width();
+ streamsize curPrecision = cout.precision();
cout << "<AliMUONTrack> No.Clusters=" << setw(2) << GetNClusters() <<
", Match2Trig=" << setw(1) << GetMatchTrigger() <<
- ", LoTrgNum=" << setw(3) << GetLoTrgNum() <<
+ ", LoTrgNum=" << setw(3) << LoCircuit() <<
", Chi2-tracking-trigger=" << setw(8) << setprecision(5) << GetChi2MatchTrigger();
- cout << Form(" HitTriggerPattern %x",fHitsPatternInTrigCh) << endl;
+ cout << Form(" HitTriggerPattern trig %x track %x",fHitsPatternInTrigCh, fHitsPatternInTrigChTrk);
+ cout << Form(" MClabel=%d",fTrackID) << endl;
if (fTrackParamAtCluster) fTrackParamAtCluster->First()->Print("FULL");
+ cout.width(curW);
+ cout.precision(curPrecision);
}
//__________________________________________________________________________
-void AliMUONTrack::SetLocalTrigger(Int_t loCirc, Int_t loStripX, Int_t loStripY, Int_t loDev, Int_t loLpt, Int_t loHpt)
+void AliMUONTrack::SetLocalTrigger(Int_t loCirc, Int_t loStripX, Int_t loStripY, Int_t loDev, Int_t loLpt, Int_t loHpt, UChar_t respWithoutChamber)
{
/// pack the local trigger information and store
fLocalTrigger += loDev << 17;
fLocalTrigger += loLpt << 22;
fLocalTrigger += loHpt << 24;
+ fLocalTrigger += respWithoutChamber << 26;
+
+}
+//__________________________________________________________________________
+void AliMUONTrack::FindMCLabel()
+{
+ /// Determine the MC label from the label of the attached clusters and fill fMCLabel data member:
+ /// More than 50% of clusters, including 1 before and 1 after the dipole, must share the same label
+
+ Int_t nClusters = GetNClusters();
+ Int_t halfCluster = nClusters/2;
+
+ // reset MC label
+ fTrackID = -1;
+
+ // loop over first clusters (if nClusters left < (nClusters-halfCluster) the conditions cannot be fulfilled)
+ for (Int_t iCluster1 = 0; iCluster1 < nClusters-halfCluster; iCluster1++) {
+ AliMUONVCluster* cluster1 = ((AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(iCluster1))->GetClusterPtr();
+
+ // if the first cluster is not on station 1 or 2 the conditions cannot be fulfilled
+ if (cluster1->GetChamberId() > 3) return;
+
+ Int_t label1 = cluster1->GetMCLabel();
+ if (label1 < 0) continue;
+
+ Int_t nIdenticalLabel = 1;
+
+ // Loop over next clusters
+ for (Int_t iCluster2 = iCluster1+1; iCluster2 < nClusters; iCluster2++) {
+ AliMUONVCluster* cluster2 = ((AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(iCluster2))->GetClusterPtr();
+
+ if (cluster2->GetMCLabel() != label1) continue;
+
+ nIdenticalLabel++;
+
+ // stop as soon as conditions are fulfilled
+ if (nIdenticalLabel > halfCluster && cluster2->GetChamberId() > 5) {
+ fTrackID = label1;
+ return;
+ }
+
+ }
+
+ }
+
}