#include "AliMUONTrack.h"
-#include "AliMUONTrackParam.h"
-#include "AliMUONVCluster.h"
-#include "AliMUONObjectPair.h"
+#include "AliMUONReconstructor.h"
+#include "AliMUONVCluster.h"
+#include "AliMUONVClusterStore.h"
+#include "AliMUONObjectPair.h"
+#include "AliMUONTrackExtrap.h"
#include "AliMUONConstants.h"
-#include "AliMUONTrackExtrap.h"
+#include "AliMUONTrackParam.h"
#include "AliLog.h"
#include <TMath.h>
-#include <TMatrixD.h>
#include <Riostream.h>
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(),
- fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)),
+ fTrackParamAtCluster(0x0),
fFitWithVertex(kFALSE),
fVertexErrXY2(),
fFitWithMCS(kFALSE),
fMatchTrigger(-1),
floTrgNum(-1),
fChi2MatchTrigger(0.),
- fTrackID(0),
+ fTrackID(-1),
fTrackParamAtVertex(0x0),
fHitsPatternInTrigCh(0),
fLocalTrigger(0)
{
/// Default constructor
- fTrackParamAtCluster->SetOwner(kTRUE);
fVertexErrXY2[0] = 0.;
fVertexErrXY2[1] = 0.;
}
//__________________________________________________________________________
-AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment)
+AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment, Double_t bendingVertexDispersion)
: TObject(),
fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)),
fFitWithVertex(kFALSE),
fMatchTrigger(-1),
floTrgNum(-1),
fChi2MatchTrigger(0.),
- fTrackID(0),
+ fTrackID(-1),
fTrackParamAtVertex(0x0),
fHitsPatternInTrigCh(0),
fLocalTrigger(0)
{
/// Constructor from two clusters
- fTrackParamAtCluster->SetOwner(kTRUE);
fVertexErrXY2[0] = 0.;
fVertexErrXY2[1] = 0.;
// Pointers to clusters from the segment
- AliMUONVCluster* cluster1 = (AliMUONVCluster*) segment->First();
- AliMUONVCluster* cluster2 = (AliMUONVCluster*) segment->Second();
-
- // check sorting in -Z (spectro z<0)
- if (cluster1->GetZ() < cluster2->GetZ()) {
- cluster1 = cluster2;
- cluster2 = (AliMUONVCluster*) segment->First();
- }
-
- // order the clusters into the track according to the station the segment belong to
- //(the cluster first attached is the one from which we will start the tracking procedure)
- AliMUONVCluster *firstCluster, *lastCluster;
- if (cluster1->GetChamberId() == 8) {
- firstCluster = cluster1;
- lastCluster = cluster2;
- } else {
- firstCluster = cluster2;
- lastCluster = cluster1;
- }
+ AliMUONVCluster* firstCluster = (AliMUONVCluster*) segment->First();
+ AliMUONVCluster* lastCluster = (AliMUONVCluster*) segment->Second();
// Compute track parameters
Double_t z1 = firstCluster->GetZ();
Double_t bendingImpact = bendingCoor1 - z1 * bendingSlope;
Double_t inverseBendingMomentum = 1. / AliMUONTrackExtrap::GetBendingMomentumFromImpactParam(bendingImpact);
-
// Set track parameters at first cluster
AliMUONTrackParam trackParamAtFirstCluster;
trackParamAtFirstCluster.SetZ(z1);
trackParamAtFirstCluster.SetBendingSlope(bendingSlope);
trackParamAtFirstCluster.SetInverseBendingMomentum(inverseBendingMomentum);
-
// Set track parameters at last cluster
AliMUONTrackParam trackParamAtLastCluster;
trackParamAtLastCluster.SetZ(z2);
trackParamAtLastCluster.SetBendingSlope(bendingSlope);
trackParamAtLastCluster.SetInverseBendingMomentum(inverseBendingMomentum);
-
// Compute and set track parameters covariances at first cluster
- TMatrixD paramCov1(5,5);
- paramCov1.Zero();
+ TMatrixD paramCov(5,5);
+ paramCov.Zero();
// Non bending plane
- paramCov1(0,0) = firstCluster->GetErrX2();
- paramCov1(0,1) = firstCluster->GetErrX2() / dZ;
- paramCov1(1,0) = paramCov1(0,1);
- paramCov1(1,1) = ( firstCluster->GetErrX2() + lastCluster->GetErrX2() ) / dZ / dZ;
+ paramCov(0,0) = firstCluster->GetErrX2();
+ paramCov(0,1) = firstCluster->GetErrX2() / dZ;
+ paramCov(1,0) = paramCov(0,1);
+ paramCov(1,1) = ( firstCluster->GetErrX2() + lastCluster->GetErrX2() ) / dZ / dZ;
// Bending plane
- paramCov1(2,2) = firstCluster->GetErrY2();
- paramCov1(2,3) = firstCluster->GetErrY2() / dZ;
- paramCov1(3,2) = paramCov1(2,3);
- paramCov1(3,3) = ( firstCluster->GetErrY2() + lastCluster->GetErrY2() ) / dZ / dZ;
- // Inverse bending momentum (50% error)
- paramCov1(4,4) = 0.5*inverseBendingMomentum * 0.5*inverseBendingMomentum;
- // Set covariances
- trackParamAtFirstCluster.SetCovariances(paramCov1);
-
-
- // Compute and set track parameters covariances at last cluster (as if the first cluster did not exist)
- TMatrixD paramCov2(5,5);
- paramCov2.Zero();
+ paramCov(2,2) = firstCluster->GetErrY2();
+ paramCov(2,3) = firstCluster->GetErrY2() / dZ;
+ 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)
+ 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
// Non bending plane
- paramCov2(0,0) = paramCov1(0,0);
- paramCov2(1,1) = 100.*paramCov1(1,1);
+ paramCov(0,0) = lastCluster->GetErrX2();
+ paramCov(0,1) = - lastCluster->GetErrX2() / dZ;
+ paramCov(1,0) = paramCov(0,1);
// Bending plane
- paramCov2(2,2) = paramCov1(2,2);
- paramCov2(3,3) = 100.*paramCov1(3,3);
- // Inverse bending momentum
- paramCov2(4,4) = paramCov1(4,4);
- // Set covariances
- trackParamAtLastCluster.SetCovariances(paramCov2);
-
- // Flag clusters as being removable
- trackParamAtFirstCluster.SetRemovable(kTRUE);
- trackParamAtLastCluster.SetRemovable(kTRUE);
+ 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
AddTrackParamAtCluster(trackParamAtFirstCluster,*firstCluster);
}
- //__________________________________________________________________________
+//__________________________________________________________________________
AliMUONTrack::AliMUONTrack(const AliMUONTrack& track)
: TObject(track),
- fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)),
+ fTrackParamAtCluster(0x0),
fFitWithVertex(track.fFitWithVertex),
fVertexErrXY2(),
fFitWithMCS(track.fFitWithMCS),
///copy constructor
// necessary to make a copy of the objects and not only the pointers in TClonesArray.
- AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->First();
- while (trackParamAtCluster) {
- new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(*trackParamAtCluster);
- trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->After(trackParamAtCluster);
+ 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);
+ }
}
// copy vertex resolution square used during the tracking procedure
// base class assignement
TObject::operator=(track);
-
- // necessary to make a copy of the objects and not only the pointers in TClonesArray.
- fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10);
- AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->First();
- while (trackParamAtCluster) {
- new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(*trackParamAtCluster);
- trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->After(trackParamAtCluster);
+
+ // clear memory
+ Clear();
+
+ // necessary to make a copy of the objects and not only the pointers in TClonesArray
+ 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);
+ }
}
// copy cluster weights matrix if any
fClusterWeightsNonBending->ResizeTo(*(track.fClusterWeightsNonBending));
*fClusterWeightsNonBending = *(track.fClusterWeightsNonBending);
} else fClusterWeightsNonBending = new TMatrixD(*(track.fClusterWeightsNonBending));
- } else if (fClusterWeightsNonBending) {
- delete fClusterWeightsNonBending;
- fClusterWeightsNonBending = 0x0;
}
// copy cluster weights matrix if any
fClusterWeightsBending->ResizeTo(*(track.fClusterWeightsBending));
*fClusterWeightsBending = *(track.fClusterWeightsBending);
} else fClusterWeightsBending = new TMatrixD(*(track.fClusterWeightsBending));
- } else if (fClusterWeightsBending) {
- delete fClusterWeightsBending;
- fClusterWeightsBending = 0x0;
}
// copy track parameters at vertex if any
if (track.fTrackParamAtVertex) {
if (fTrackParamAtVertex) *fTrackParamAtVertex = *(track.fTrackParamAtVertex);
else fTrackParamAtVertex = new AliMUONTrackParam(*(track.fTrackParamAtVertex));
- } else if (fTrackParamAtVertex) {
- delete fTrackParamAtVertex;
- fTrackParamAtVertex = 0x0;
}
fFitWithVertex = track.fFitWithVertex;
void AliMUONTrack::Clear(Option_t* opt)
{
/// Clear arrays
- fTrackParamAtCluster->Clear(opt);
+ if (opt && opt[0] == 'C' && fTrackParamAtCluster) fTrackParamAtCluster->Clear("C");
+ else {
+ delete fTrackParamAtCluster;
+ fTrackParamAtCluster = 0x0;
+ }
+ delete fClusterWeightsNonBending; fClusterWeightsNonBending = 0x0;
+ delete fClusterWeightsBending; fClusterWeightsBending = 0x0;
+ delete fTrackParamAtVertex; fTrackParamAtVertex = 0x0;
+}
+
+ //__________________________________________________________________________
+void AliMUONTrack::Reset()
+{
+ /// Reset to default values
+ SetUniqueID(0);
+ fFitWithVertex = kFALSE;
+ fVertexErrXY2[0] = 0.;
+ fVertexErrXY2[1] = 0.;
+ fFitWithMCS = kFALSE;
+ fGlobalChi2 = -1.;
+ fImproved = kFALSE;
+ fMatchTrigger = -1;
+ floTrgNum = -1;
+ fChi2MatchTrigger = 0.;
+ fTrackID = -1;
+ fHitsPatternInTrigCh = 0;
+ fLocalTrigger = 0;
+ delete fTrackParamAtCluster; fTrackParamAtCluster = 0x0;
delete fClusterWeightsNonBending; fClusterWeightsNonBending = 0x0;
delete fClusterWeightsBending; fClusterWeightsBending = 0x0;
delete fTrackParamAtVertex; fTrackParamAtVertex = 0x0;
}
+ //__________________________________________________________________________
+TClonesArray* AliMUONTrack::GetTrackParamAtCluster() const
+{
+ /// return array of track parameters at cluster (create it if needed)
+ if (!fTrackParamAtCluster) fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10);
+ return fTrackParamAtCluster;
+}
+
//__________________________________________________________________________
void AliMUONTrack::AddTrackParamAtCluster(const AliMUONTrackParam &trackParam, AliMUONVCluster &cluster, Bool_t copy)
{
}
// add parameters to the array of track parameters
+ if (!fTrackParamAtCluster) fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10);
AliMUONTrackParam* trackParamAtCluster = new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(trackParam);
// link parameters with the associated cluster or its copy
if (copy) {
- AliMUONVCluster *clusterCopy = cluster.CreateCopy();
+ AliMUONVCluster *clusterCopy = static_cast<AliMUONVCluster*>(cluster.Clone());
trackParamAtCluster->SetClusterPtr(clusterCopy, kTRUE);
} else trackParamAtCluster->SetClusterPtr(&cluster);
+
+ // sort the array of track parameters
+ fTrackParamAtCluster->Sort();
}
//__________________________________________________________________________
void AliMUONTrack::RemoveTrackParamAtCluster(AliMUONTrackParam *trackParam)
{
/// Remove trackParam from the array of TrackParamAtCluster
- if (!fTrackParamAtCluster->Remove(trackParam)) {
+ if (!fTrackParamAtCluster || !fTrackParamAtCluster->Remove(trackParam)) {
AliWarning("object to remove does not exist in array fTrackParamAtCluster");
return;
}
}
//__________________________________________________________________________
-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) {
AliWarning("no cluster attached to the track");
- return;
+ return kFALSE;
}
+ Bool_t extrapStatus = kTRUE;
AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->First();
AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(startingTrackParam);
while (trackParamAtCluster) {
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) {
AliWarning("no cluster attached to the track");
- return;
+ return kFALSE;
}
+ Bool_t extrapStatus = kTRUE;
AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->First();
AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(startingTrackParam);
Int_t expectedChamber = startingTrackParam->GetClusterPtr()->GetChamberId() + 1;
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.);
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;
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)
+{
+ /// 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)
+
+ Int_t nClusters = GetNClusters();
+ AliMUONTrackParam *trackParam;
+ Int_t currentCh, currentSt, previousCh = -1, nChHitInSt45 = 0;
+ UInt_t presentStationMask(0);
+
+ // first loop over clusters
+ for (Int_t i = 0; i < nClusters; i++) {
+ trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i);
+
+ currentCh = trackParam->GetClusterPtr()->GetChamberId();
+ currentSt = currentCh/2;
+
+ // 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++;
+ previousCh = currentCh;
+ }
+
+ }
+
+ return (((requestedStationMask & presentStationMask) == requestedStationMask) && (nChHitInSt45 >= 2));
+}
+
+ //__________________________________________________________________________
+void AliMUONTrack::TagRemovableClusters(UInt_t requestedStationMask) {
+ /// Identify clusters that can be removed from the track,
+ /// with the only requirements to have at least 1 cluster per requested station
+ /// and at least 2 chambers over 4 in stations 4 & 5 that contain cluster(s)
+
+ Int_t nClusters = GetNClusters();
+ AliMUONTrackParam *trackParam, *nextTrackParam;
+ Int_t currentCh, nextCh, currentSt, nextSt, previousCh = -1, nChHitInSt45 = 0;
+
+ // first loop over clusters
+ for (Int_t i = 0; i < nClusters; i++) {
+ trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i);
+
+ currentCh = trackParam->GetClusterPtr()->GetChamberId();
+ currentSt = currentCh/2;
+
+ // reset flags to kFALSE for all clusters in required station
+ if ((1 << currentSt) & requestedStationMask) trackParam->SetRemovable(kFALSE);
+ else trackParam->SetRemovable(kTRUE);
+
+ // count the number of chambers in station 4 & 5 that contain cluster(s)
+ if (currentCh > 5 && currentCh != previousCh) {
+ nChHitInSt45++;
+ previousCh = currentCh;
+ }
+
+ }
+
+ // second loop over clusters
+ for (Int_t i = 0; i < nClusters; i++) {
+ trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i);
+
+ currentCh = trackParam->GetClusterPtr()->GetChamberId();
+ currentSt = currentCh/2;
+
+ // make sure they are more than 2 clusters in 2 different chambers of stations 4 & 5
+ // but 2 clusters in he same chamber will still be flagged as removable
+ if (nChHitInSt45 < 3 && currentSt > 2) {
+
+ if (i == nClusters-1) {
+
+ trackParam->SetRemovable(kFALSE);
+
+ } else {
+
+ nextTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i+1);
+ nextCh = nextTrackParam->GetClusterPtr()->GetChamberId();
+
+ // set clusters in the same chamber as being removable
+ if (nextCh == currentCh) {
+ trackParam->SetRemovable(kTRUE);
+ nextTrackParam->SetRemovable(kTRUE);
+ i++; // skip cluster already checked
+ } else {
+ trackParam->SetRemovable(kFALSE);
+ }
+
+ }
+
+ } else {
+
+ // skip clusters already flag as removable
+ if (trackParam->IsRemovable()) continue;
+
+ // loop over next track parameters
+ for (Int_t j = i+1; j < nClusters; j++) {
+ nextTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(j);
+
+ nextCh = nextTrackParam->GetClusterPtr()->GetChamberId();
+ nextSt = nextCh/2;
+
+ // set clusters in the same station as being removable
+ if (nextSt == currentSt) {
+ trackParam->SetRemovable(kTRUE);
+ nextTrackParam->SetRemovable(kTRUE);
+ i++; // skip cluster already checked
+ }
+
+ }
+
+ }
+
+ }
+
}
//__________________________________________________________________________
/// - Also recompute the weight matrices of the attached clusters if accountForMCS=kTRUE
/// - Assume that track parameters at each cluster are corrects
/// - Return kFALSE if computation failed
+ AliDebug(1,"Enter ComputeLocalChi2");
+
+ if (!fTrackParamAtCluster) {
+ AliWarning("no cluster attached to this track");
+ return kFALSE;
+ }
if (accountForMCS) { // Compute local chi2 taking into account multiple scattering effects
AliMUONTrackParam* trackParamAtCluster1;
AliMUONVCluster *cluster, *discardedCluster;
Int_t iCluster1, iCluster2, iCurrentCluster1, iCurrentCluster2;
- TMatrixD ClusterWeightsNB(nClusters-1,nClusters-1);
- TMatrixD ClusterWeightsB(nClusters-1,nClusters-1);
+ TMatrixD clusterWeightsNB(nClusters-1,nClusters-1);
+ TMatrixD clusterWeightsB(nClusters-1,nClusters-1);
Double_t *dX = new Double_t[nClusters-1];
Double_t *dY = new Double_t[nClusters-1];
Double_t globalChi2b;
discardedCluster = trackParamAtCluster->GetClusterPtr();
// Recompute cluster weights without the current cluster
- if (!ComputeClusterWeights(ClusterWeightsNB, ClusterWeightsB, &mcsCovariances, discardedCluster)) {
+ if (!ComputeClusterWeights(clusterWeightsNB, clusterWeightsB, &mcsCovariances, discardedCluster)) {
AliWarning("cannot take into account the multiple scattering effects");
delete [] dX;
delete [] dY;
if (cluster == discardedCluster) continue;
// Add contribution from covariances
- globalChi2b += (ClusterWeightsNB(iCurrentCluster1, iCurrentCluster2) +
- ClusterWeightsNB(iCurrentCluster2, iCurrentCluster1)) * dX[iCurrentCluster1] * dX[iCurrentCluster2] +
- (ClusterWeightsB(iCurrentCluster1, iCurrentCluster2) +
- ClusterWeightsB(iCurrentCluster2, iCurrentCluster1)) * dY[iCurrentCluster1] * dY[iCurrentCluster2];
+ globalChi2b += (clusterWeightsNB(iCurrentCluster1, iCurrentCluster2) +
+ clusterWeightsNB(iCurrentCluster2, iCurrentCluster1)) * dX[iCurrentCluster1] * dX[iCurrentCluster2] +
+ (clusterWeightsB(iCurrentCluster1, iCurrentCluster2) +
+ clusterWeightsB(iCurrentCluster2, iCurrentCluster1)) * dY[iCurrentCluster1] * dY[iCurrentCluster2];
iCurrentCluster2++;
}
// Add contribution from variances
- globalChi2b += ClusterWeightsNB(iCurrentCluster1, iCurrentCluster1) * dX[iCurrentCluster1] * dX[iCurrentCluster1] +
- ClusterWeightsB(iCurrentCluster1, iCurrentCluster1) * dY[iCurrentCluster1] * dY[iCurrentCluster1];
+ globalChi2b += clusterWeightsNB(iCurrentCluster1, iCurrentCluster1) * dX[iCurrentCluster1] * dX[iCurrentCluster1] +
+ clusterWeightsB(iCurrentCluster1, iCurrentCluster1) * dY[iCurrentCluster1] * dY[iCurrentCluster1];
iCurrentCluster1++;
}
/// 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 2.*MaxChi2();
+ }
Double_t chi2 = 0.;
/// - Use the provided MCS covariance matrix if any (otherwise build it temporarily)
/// - Assume that track parameters at each cluster are corrects
/// - Return kFALSE if computation failed
+ AliDebug(1,"Enter ComputeClusterWeights1");
+
+ if (!fTrackParamAtCluster) {
+ AliWarning("no cluster attached to this track");
+ return kFALSE;
+ }
// Alocate memory
Int_t nClusters = GetNClusters();
}
//__________________________________________________________________________
-Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& ClusterWeightsNB, TMatrixD& ClusterWeightsB,
+Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& clusterWeightsNB, TMatrixD& clusterWeightsB,
TMatrixD* mcsCovariances, AliMUONVCluster* discardedCluster) const
{
/// Compute the weight matrices, in non bending and bending direction,
/// accounting for multiple scattering correlations and cluster resolution
/// - Use the provided MCS covariance matrix if any (otherwise build it temporarily)
/// - Return kFALSE if computation failed
+ AliDebug(1,"Enter ComputeClusterWeights2");
// Check MCS covariance matrix and recompute it if need
Int_t nClusters = GetNClusters();
// Resize the weights matrices; alocate memory
if (discardedCluster) {
- ClusterWeightsNB.ResizeTo(nClusters-1,nClusters-1);
- ClusterWeightsB.ResizeTo(nClusters-1,nClusters-1);
+ clusterWeightsNB.ResizeTo(nClusters-1,nClusters-1);
+ clusterWeightsB.ResizeTo(nClusters-1,nClusters-1);
} else {
- ClusterWeightsNB.ResizeTo(nClusters,nClusters);
- ClusterWeightsB.ResizeTo(nClusters,nClusters);
+ clusterWeightsNB.ResizeTo(nClusters,nClusters);
+ clusterWeightsB.ResizeTo(nClusters,nClusters);
}
// Define variables
if (cluster2 == discardedCluster) continue;
// Fill with MCS covariances
- ClusterWeightsNB(iCurrentCluster1, iCurrentCluster2) = (*mcsCovariances)(iCluster1,iCluster2);
+ clusterWeightsNB(iCurrentCluster1, iCurrentCluster2) = (*mcsCovariances)(iCluster1,iCluster2);
// Equal contribution from multiple scattering in non bending and bending directions
- ClusterWeightsB(iCurrentCluster1, iCurrentCluster2) = ClusterWeightsNB(iCurrentCluster1, iCurrentCluster2);
+ clusterWeightsB(iCurrentCluster1, iCurrentCluster2) = clusterWeightsNB(iCurrentCluster1, iCurrentCluster2);
// Add contribution from cluster resolution to diagonal element and symmetrize the matrix
if (iCurrentCluster1 == iCurrentCluster2) {
// In non bending plane
- ClusterWeightsNB(iCurrentCluster1, iCurrentCluster1) += cluster1->GetErrX2();
+ clusterWeightsNB(iCurrentCluster1, iCurrentCluster1) += cluster1->GetErrX2();
// In bending plane
- ClusterWeightsB(iCurrentCluster1, iCurrentCluster1) += cluster1->GetErrY2();
+ clusterWeightsB(iCurrentCluster1, iCurrentCluster1) += cluster1->GetErrY2();
} else {
// In non bending plane
- ClusterWeightsNB(iCurrentCluster2, iCurrentCluster1) = ClusterWeightsNB(iCurrentCluster1, iCurrentCluster2);
+ clusterWeightsNB(iCurrentCluster2, iCurrentCluster1) = clusterWeightsNB(iCurrentCluster1, iCurrentCluster2);
// In bending plane
- ClusterWeightsB(iCurrentCluster2, iCurrentCluster1) = ClusterWeightsB(iCurrentCluster1, iCurrentCluster2);
+ clusterWeightsB(iCurrentCluster2, iCurrentCluster1) = clusterWeightsB(iCurrentCluster1, iCurrentCluster2);
}
}
// Inversion of covariance matrices to get the weights
- if (ClusterWeightsNB.Determinant() != 0 && ClusterWeightsB.Determinant() != 0) {
- ClusterWeightsNB.Invert();
- ClusterWeightsB.Invert();
+ if (clusterWeightsNB.Determinant() != 0 && clusterWeightsB.Determinant() != 0) {
+ clusterWeightsNB.Invert();
+ clusterWeightsB.Invert();
} else {
AliWarning(" Determinant = 0");
- ClusterWeightsNB.ResizeTo(0,0);
- ClusterWeightsB.ResizeTo(0,0);
+ clusterWeightsNB.ResizeTo(0,0);
+ clusterWeightsB.ResizeTo(0,0);
if(deleteMCSCov) delete mcsCovariances;
return kFALSE;
}
{
/// Compute the multiple scattering covariance matrix
/// (assume that track parameters at each cluster are corrects)
+ AliDebug(1,"Enter ComputeMCSCovariances");
// Reset the size of the covariance matrix if needed
Int_t nClusters = GetNClusters();
{
/// Returns the number of clusters in common between the current track ("this")
/// and the track pointed to by "track".
+ if (!fTrackParamAtCluster || !this->fTrackParamAtCluster) return 0;
+ Int_t nCluster1 = this->GetNClusters();
+ Int_t nCluster2 = track->GetNClusters();
Int_t clustersInCommon = 0;
AliMUONTrackParam *trackParamAtCluster1, *trackParamAtCluster2;
// Loop over clusters of first track
- trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->First();
- while (trackParamAtCluster1) {
+ for(Int_t iCluster1 = 0; iCluster1 < nCluster1; iCluster1++) {
+ trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->UncheckedAt(iCluster1);
// Loop over clusters of second track
- trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->First();
- while (trackParamAtCluster2) {
+ for(Int_t iCluster2 = 0; iCluster2 < nCluster2; iCluster2++) {
+ trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->UncheckedAt(iCluster2);
// Increment "clustersInCommon" if both trackParamAtCluster1 & 2 point to the same cluster
if ((trackParamAtCluster1->GetClusterPtr()) == (trackParamAtCluster2->GetClusterPtr())) {
- clustersInCommon++;
+ clustersInCommon++;
break;
}
- trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->After(trackParamAtCluster2);
- } // trackParamAtCluster2
- trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->After(trackParamAtCluster1);
- } // trackParamAtCluster1
+ }
+ }
return clustersInCommon;
}
+ //__________________________________________________________________________
+Int_t AliMUONTrack::ClustersInCommonInSt345(AliMUONTrack* track) const
+{
+ /// Returns the number of clusters in common on stations 3, 4 and 5
+ /// between the current track ("this") and the track pointed to by "track".
+ if (!fTrackParamAtCluster || !this->fTrackParamAtCluster) return 0;
+ Int_t nCluster1 = this->GetNClusters();
+ Int_t nCluster2 = track->GetNClusters();
+ Int_t clustersInCommon = 0;
+ AliMUONTrackParam *trackParamAtCluster1, *trackParamAtCluster2;
+ // Loop over clusters of first track
+ for(Int_t iCluster1 = 0; iCluster1 < nCluster1; iCluster1++) {
+ trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->UncheckedAt(iCluster1);
+ if (trackParamAtCluster1->GetClusterPtr()->GetChamberId() < 4) continue;
+ // Loop over clusters of second track
+ for(Int_t iCluster2 = 0; iCluster2 < nCluster2; iCluster2++) {
+ trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->UncheckedAt(iCluster2);
+ if (trackParamAtCluster2->GetClusterPtr()->GetChamberId() < 4) continue;
+ // Increment "clustersInCommon" if both trackParamAtCluster1 & 2 point to the same cluster
+ if ((trackParamAtCluster1->GetClusterPtr()) == (trackParamAtCluster2->GetClusterPtr())) {
+ clustersInCommon++;
+ break;
+ }
+ }
+ }
+ return clustersInCommon;
+}
+
+ //__________________________________________________________________________
+Int_t AliMUONTrack::GetNDF() const
+{
+ /// return the number of degrees of freedom
+
+ Int_t ndf = 2 * GetNClusters() - 5;
+ return (ndf > 0) ? ndf : 0;
+}
+
//__________________________________________________________________________
Double_t AliMUONTrack::GetNormalizedChi2() const
{
- /// return the chi2 value divided by the number of degrees of freedom (or 1.e10 if ndf < 0)
+ /// return the chi2 value divided by the number of degrees of freedom (or FLT_MAX if ndf <= 0)
- Double_t numberOfDegFree = (2. * GetNClusters() - 5.);
- if (numberOfDegFree > 0.) return fGlobalChi2 / numberOfDegFree;
- else return 1.e10;
+ Double_t ndf = (Double_t) GetNDF();
+ return (ndf > 0.) ? fGlobalChi2 / ndf : 2.*MaxChi2();
}
//__________________________________________________________________________
-Bool_t* AliMUONTrack::CompatibleTrack(AliMUONTrack *track, Double_t sigma2Cut) const
+Int_t AliMUONTrack::CompatibleTrack(AliMUONTrack* track, Double_t sigmaCut, Bool_t compatibleCluster[10]) const
{
- /// for each chamber: return kTRUE (kFALSE) if clusters are compatible (not compatible)
+ /// 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;
AliMUONVCluster *cluster1, *cluster2;
- Double_t chi2, dX, dY, dZ;
- Double_t chi2Max = sigma2Cut * sigma2Cut;
- Double_t dZMax = 1.; // 1 cm
+ Double_t chi2, dX, dY;
+ Double_t chi2Max = sigmaCut * sigmaCut;
- Bool_t *compatibleCluster = new Bool_t[AliMUONConstants::NTrackingCh()];
+ // initialization
+ Int_t nMatchClusters = 0;
for ( Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++) compatibleCluster[ch] = kFALSE;
+ if (!fTrackParamAtCluster || !this->fTrackParamAtCluster) return nMatchClusters;
+
// Loop over clusters of first track
trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->First();
while (trackParamAtCluster1) {
//prepare next step
trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->After(trackParamAtCluster2);
- // z direction
- dZ = cluster1->GetZ() - cluster2->GetZ();
- if (dZ > dZMax) continue;
+ // 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 compatibleCluster;
-}
-
-//__________________________________________________________________________
-AliMUONTrackParam* AliMUONTrack::GetTrackParamAtVertex()
-{
- /// return reference to track parameters at vertex (create it before if needed)
- if (!fTrackParamAtVertex) fTrackParamAtVertex = new AliMUONTrackParam();
- return fTrackParamAtVertex;
+ return nMatchClusters;
}
//__________________________________________________________________________
", Match2Trig=" << setw(1) << GetMatchTrigger() <<
", LoTrgNum=" << setw(3) << GetLoTrgNum() <<
", Chi2-tracking-trigger=" << setw(8) << setprecision(5) << GetChi2MatchTrigger();
- cout << Form(" HitTriggerPattern %x",fHitsPatternInTrigCh) << endl;
- fTrackParamAtCluster->First()->Print("FULL");
+ cout << Form(" HitTriggerPattern %x",fHitsPatternInTrigCh);
+ cout << Form(" MClabel=%d",fTrackID) << endl;
+ if (fTrackParamAtCluster) fTrackParamAtCluster->First()->Print("FULL");
}
//__________________________________________________________________________
}
+//__________________________________________________________________________
+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;
+ }
+
+ }
+
+ }
+
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff