/*
$Log$
+Revision 1.8 2001/01/08 11:01:02 gosset
+Modifications used for addendum to Dimuon TDR (JP Cussonneau):
+*. MaxBendingMomentum to make both a segment and a track (default 500)
+*. MaxChi2 per degree of freedom to make a track (default 100)
+*. MinBendingMomentum used also to make a track
+ and not only a segment (default 3)
+*. wider roads for track search in stations 1 to 3
+*. extrapolation to actual Z instead of Z(chamber) in FollowTracks
+*. in track fit:
+ - limits on parameters X and Y (+/-500)
+ - covariance matrices in double precision
+ - normalization of covariance matrices before inversion
+ - suppression of Minuit printouts
+*. correction against memory leak (delete extrapHit) in FollowTracks
+*. RMax to 10 degrees with Z(chamber) instead of fixed values;
+ RMin and Rmax cuts suppressed in NewHitForRecFromGEANT,
+ because useless with realistic geometry
+
+Revision 1.7 2000/09/19 15:50:46 gosset
+TrackChi2MCS function: covariance matrix better calculated,
+taking into account missing planes...
+
+Revision 1.6 2000/07/20 12:45:27 gosset
+New "EventReconstructor..." structure,
+ hopefully more adapted to tree/streamer.
+"AliMUONEventReconstructor::RemoveDoubleTracks"
+ to keep only one track among similar ones.
+
+Revision 1.5 2000/07/18 16:04:06 gosset
+AliMUONEventReconstructor package:
+* a few minor modifications and more comments
+* a few corrections
+ * right sign for Z of raw clusters
+ * right loop over chambers inside station
+ * symmetrized covariance matrix for measurements (TrackChi2MCS)
+ * right sign of charge in extrapolation (ExtrapToZ)
+ * right zEndAbsorber for Branson correction below 3 degrees
+* use of TVirtualFitter instead of TMinuit for AliMUONTrack::Fit
+* no parameter for AliMUONTrack::Fit() but more fit parameters in Track object
+
Revision 1.4 2000/06/30 10:15:48 gosset
Changes to EventReconstructor...:
precision fit with multiple Coulomb scattering;
#include <TClonesArray.h>
#include <TMath.h>
-#include <TMatrix.h>
+#include <TMatrixD.h>
+#include <TObjArray.h>
#include <TVirtualFitter.h>
#include "AliMUONEventReconstructor.h"
{
// Constructor from two Segment's
fEventReconstructor = EventReconstructor; // link back to EventReconstructor
- // memory allocation for the TClonesArray of reconstructed TrackHit's
- fTrackHitsPtr = new TClonesArray("AliMUONTrackHit", 10);
+ // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
+ fTrackHitsPtr = new TObjArray(10);
fNTrackHits = 0;
AddSegment(BegSegment); // add hits from BegSegment
AddSegment(EndSegment); // add hits from EndSegment
fTrackHitsPtr->Sort(); // sort TrackHits according to increasing Z
SetTrackParamAtVertex(); // set track parameters at vertex
- // set fit conditions
+ // set fit conditions...
fFitMCS = 0;
fFitNParam = 3;
fFitStart = 1;
+ fFitFMin = -1.0;
return;
}
{
// Constructor from one Segment and one HitForRec
fEventReconstructor = EventReconstructor; // link back to EventReconstructor
- // memory allocation for the TClonesArray of reconstructed TrackHit's
- fTrackHitsPtr = new TClonesArray("AliMUONTrackHit", 10);
+ // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
+ fTrackHitsPtr = new TObjArray(10);
fNTrackHits = 0;
AddSegment(Segment); // add hits from Segment
AddHitForRec(HitForRec); // add HitForRec
fTrackHitsPtr->Sort(); // sort TrackHits according to increasing Z
SetTrackParamAtVertex(); // set track parameters at vertex
- // set fit conditions
+ // set fit conditions...
fFitMCS = 0;
fFitNParam = 3;
fFitStart = 1;
+ fFitFMin = -1.0;
return;
}
+ //__________________________________________________________________________
+AliMUONTrack::~AliMUONTrack()
+{
+ // Destructor
+ if (fTrackHitsPtr) {
+ delete fTrackHitsPtr; // delete the TObjArray of pointers to TrackHit's
+ fTrackHitsPtr = NULL;
+ }
+}
+
//__________________________________________________________________________
AliMUONTrack::AliMUONTrack (const AliMUONTrack& MUONTrack)
{
return *this;
}
+ //__________________________________________________________________________
+void AliMUONTrack::Remove()
+{
+ // Remove current track from array of tracks,
+ // and corresponding track hits from array of track hits.
+ // Compress the TClonesArray it belongs to.
+ AliMUONTrackHit *nextTrackHit;
+ AliMUONEventReconstructor *eventRec = this->fEventReconstructor;
+ TClonesArray *trackHitsPtr = eventRec->GetRecTrackHitsPtr();
+ // Loop over all track hits of track
+ AliMUONTrackHit *trackHit = (AliMUONTrackHit*) fTrackHitsPtr->First();
+ while (trackHit) {
+ nextTrackHit = (AliMUONTrackHit*) fTrackHitsPtr->After(trackHit);
+ // Remove TrackHit from event TClonesArray.
+ // Destructor is called,
+ // hence links between HitForRec's and TrackHit's are updated
+ trackHitsPtr->Remove(trackHit);
+ trackHit = nextTrackHit;
+ }
+ // Remove the track from event TClonesArray
+ // Destructor is called,
+ // hence space for TObjArray of pointers to TrackHit's is freed
+ eventRec->GetRecTracksPtr()->Remove(this);
+ // Number of tracks decreased by 1
+ eventRec->SetNRecTracks(eventRec->GetNRecTracks() - 1);
+ // Compress event TClonesArray of Track's:
+ // this is essential to retrieve the TClonesArray afterwards
+ eventRec->GetRecTracksPtr()->Compress();
+ // Compress event TClonesArray of TrackHit's:
+ // this is probably also essential to retrieve the TClonesArray afterwards
+ trackHitsPtr->Compress();
+}
+
//__________________________________________________________________________
void AliMUONTrack::SetFitMCS(Int_t FitMCS)
{
return;
}
+ //__________________________________________________________________________
+Int_t AliMUONTrack::HitsInCommon(AliMUONTrack* Track)
+{
+ // Returns the number of hits in common
+ // between the current track ("this")
+ // and the track pointed to by "Track".
+ Int_t hitsInCommon = 0;
+ AliMUONTrackHit *trackHit1, *trackHit2;
+ // Loop over hits of first track
+ trackHit1 = (AliMUONTrackHit*) this->GetTrackHitsPtr()->First();
+ while (trackHit1) {
+ // Loop over hits of second track
+ trackHit2 = (AliMUONTrackHit*) Track->GetTrackHitsPtr()->First();
+ while (trackHit2) {
+ // Increment "hitsInCommon" if both TrackHits point to the same HitForRec
+ if ( (trackHit1->GetHitForRecPtr()) ==
+ (trackHit2->GetHitForRecPtr()) ) hitsInCommon++;
+ trackHit2 = (AliMUONTrackHit*) Track->GetTrackHitsPtr()->After(trackHit2);
+ } // trackHit2
+ trackHit1 = (AliMUONTrackHit*) this->GetTrackHitsPtr()->After(trackHit1);
+ } // trackHit1
+ return hitsInCommon;
+}
+
//__________________________________________________________________________
void AliMUONTrack::Fit()
{
// choice of function to be minimized according to fFitMCS
if (fFitMCS == 0) fgFitter->SetFCN(TrackChi2);
else fgFitter->SetFCN(TrackChi2MCS);
- arg[0] = 1;
+ arg[0] = -1;
fgFitter->ExecuteCommand("SET PRINT", arg, 1); // More printing !!!!
// Parameters according to "fFitStart"
// (should be a function to be used at every place where needed ????)
trackParam->GetNonBendingSlope(),
0.001, -0.5, 0.5);
if (fFitNParam == 5) {
- // set last 2 Minuit parameters (no limits for the search: min=max=0)
+ // set last 2 Minuit parameters
+ // mandatory limits in Bending to avoid NaN values of parameters
fgFitter->SetParameter(3, "X",
trackParam->GetNonBendingCoor(),
- 0.03, 0.0, 0.0);
+ 0.03, -500.0, 500.0);
+ // mandatory limits in non Bending to avoid NaN values of parameters
fgFitter->SetParameter(4, "Y",
trackParam->GetBendingCoor(),
- 0.10, 0.0, 0.0);
+ 0.10, -500.0, 500.0);
}
// search without gradient calculation in the function
fgFitter->ExecuteCommand("SET NOGRADIENT", arg, 0);
trackParam->SetNonBendingCoor(x);
trackParam->SetBendingCoor(y);
}
+ // global result of the fit
+ Double_t fedm, errdef;
+ Int_t npari, nparx;
+ fgFitter->GetStats(fFitFMin, fedm, errdef, npari, nparx);
}
//__________________________________________________________________________
void AliMUONTrack::AddSegment(AliMUONSegment* Segment)
{
- // Add Segment
+ // Add Segment to the track
AddHitForRec(Segment->GetHitForRec1()); // 1st hit
AddHitForRec(Segment->GetHitForRec2()); // 2nd hit
}
//__________________________________________________________________________
void AliMUONTrack::AddHitForRec(AliMUONHitForRec* HitForRec)
{
- // Add HitForRec
- new ((*fTrackHitsPtr)[fNTrackHits]) AliMUONTrackHit(HitForRec);
+ // Add HitForRec to the track:
+ // actual TrackHit into TClonesArray of TrackHit's for the event;
+ // pointer to actual TrackHit in TObjArray of pointers to TrackHit's for the track
+ TClonesArray *recTrackHitsPtr = this->fEventReconstructor->GetRecTrackHitsPtr();
+ Int_t eventTrackHits = this->fEventReconstructor->GetNRecTrackHits();
+ // event
+ AliMUONTrackHit* trackHit =
+ new ((*recTrackHitsPtr)[eventTrackHits]) AliMUONTrackHit(HitForRec);
+ this->fEventReconstructor->SetNRecTrackHits(eventTrackHits + 1);
+ // track
+ fTrackHitsPtr->Add(trackHit);
fNTrackHits++;
}
AliMUONTrackHit *hit;
Bool_t goodDeterminant;
- Int_t hitNumber, hitNumber1, hitNumber2, hitNumber3;
- Double_t zHit[10], paramBendingCoor[10], paramNonBendingCoor[10], ap[10];
- Double_t hitBendingCoor[10], hitNonBendingCoor[10];
- Double_t hitBendingReso2[10], hitNonBendingReso2[10];
- // dimension 10 in parameter ??? related to AliMUONConstants::NTrackingCh() !!!!
- Int_t numberOfHit = TMath::Min(trackBeingFitted->GetNTrackHits(), 10);
- TMatrix *covBending = new TMatrix(numberOfHit, numberOfHit);
- TMatrix *covNonBending = new TMatrix(numberOfHit, numberOfHit);
+ Int_t chCurrent, chPrev = 0, hitNumber, hitNumber1, hitNumber2, hitNumber3;
+ Double_t z, z1, z2, z3;
+ AliMUONTrackHit *hit1, *hit2, *hit3;
+ Double_t hbc1, hbc2, pbc1, pbc2;
+ Double_t hnbc1, hnbc2, pnbc1, pnbc2;
+ Int_t numberOfHit = trackBeingFitted->GetNTrackHits();
+ TMatrixD *covBending = new TMatrixD(numberOfHit, numberOfHit);
+ TMatrixD *covNonBending = new TMatrixD(numberOfHit, numberOfHit);
+ Double_t *msa2 = new Double_t[numberOfHit];
// Predicted coordinates and multiple scattering angles are first calculated
for (hitNumber = 0; hitNumber < numberOfHit; hitNumber++) {
hit = (AliMUONTrackHit*) (*(trackBeingFitted->GetTrackHitsPtr()))[hitNumber];
- zHit[hitNumber] = hit->GetHitForRecPtr()->GetZ();
+ z = hit->GetHitForRecPtr()->GetZ();
// do something special if 2 hits with same Z ????
// security against infinite loop ????
- (¶m1)->ExtrapToZ(zHit[hitNumber]); // extrapolation
+ (¶m1)->ExtrapToZ(z); // extrapolation
hit->SetTrackParam(¶m1);
- paramBendingCoor[hitNumber] = (¶m1)->GetBendingCoor();
- paramNonBendingCoor[hitNumber] = (¶m1)->GetNonBendingCoor();
- hitBendingCoor[hitNumber] = hit->GetHitForRecPtr()->GetBendingCoor();
- hitNonBendingCoor[hitNumber] = hit->GetHitForRecPtr()->GetNonBendingCoor();
- hitBendingReso2[hitNumber] = hit->GetHitForRecPtr()->GetBendingReso2();
- hitNonBendingReso2[hitNumber] = hit->GetHitForRecPtr()->GetNonBendingReso2();
- ap[hitNumber] = MultipleScatteringAngle2(hit); // multiple scatt. angle ^2
+ // square of multiple scattering angle at current hit, with one chamber
+ msa2[hitNumber] = MultipleScatteringAngle2(hit);
+ // correction for eventual missing hits or multiple hits in a chamber,
+ // according to the number of chambers
+ // between the current hit and the previous one
+ chCurrent = hit->GetHitForRecPtr()->GetChamberNumber();
+ if (hitNumber > 0) msa2[hitNumber] = msa2[hitNumber] * (chCurrent - chPrev);
+ chPrev = chCurrent;
}
// Calculates the covariance matrix
- // One chamber is taken into account between successive hits.
- // "ap" should be changed for taking into account the eventual missing hits
- // by defining an "equivalent" chamber thickness !!!!
- for (hitNumber1 = 0; hitNumber1 < numberOfHit; hitNumber1++) {
+ for (hitNumber1 = 0; hitNumber1 < numberOfHit; hitNumber1++) {
+ hit1 = (AliMUONTrackHit*) (*(trackBeingFitted->GetTrackHitsPtr()))[hitNumber1];
+ z1 = hit1->GetHitForRecPtr()->GetZ();
for (hitNumber2 = hitNumber1; hitNumber2 < numberOfHit; hitNumber2++) {
+ hit2 = (AliMUONTrackHit*) (*(trackBeingFitted->GetTrackHitsPtr()))[hitNumber2];
+ z2 = hit2->GetHitForRecPtr()->GetZ();
// initialization to 0 (diagonal plus upper triangular part)
(*covBending)(hitNumber2, hitNumber1) = 0.0;
// contribution from multiple scattering in bending plane:
// loop over upstream hits
for (hitNumber3 = 0; hitNumber3 < hitNumber1; hitNumber3++) {
+ hit3 = (AliMUONTrackHit*)
+ (*(trackBeingFitted->GetTrackHitsPtr()))[hitNumber3];
+ z3 = hit3->GetHitForRecPtr()->GetZ();
(*covBending)(hitNumber2, hitNumber1) =
(*covBending)(hitNumber2, hitNumber1) +
- ((zHit[hitNumber1] - zHit[hitNumber3]) *
- (zHit[hitNumber2] - zHit[hitNumber3]) * ap[hitNumber3]);
+ ((z1 - z3) * (z2 - z3) * msa2[hitNumber3]);
}
// equal contribution from multiple scattering in non bending plane
(*covNonBending)(hitNumber2, hitNumber1) =
// Diagonal elements: add contribution from position measurements
// in bending plane
(*covBending)(hitNumber2, hitNumber1) =
- (*covBending)(hitNumber2, hitNumber1) + hitBendingReso2[hitNumber1];
+ (*covBending)(hitNumber2, hitNumber1) +
+ hit1->GetHitForRecPtr()->GetBendingReso2();
// and in non bending plane
(*covNonBending)(hitNumber2, hitNumber1) =
- (*covNonBending)(hitNumber2, hitNumber1) + hitNonBendingReso2[hitNumber1];
+ (*covNonBending)(hitNumber2, hitNumber1) +
+ hit1->GetHitForRecPtr()->GetNonBendingReso2();
}
else {
// Non diagonal elements: symmetrization
}
} // for (hitNumber2 = hitNumber1;...
} // for (hitNumber1 = 0;...
-
+ // Normalization of covariance matrices
+ Double_t normCovBending2 = covBending->E2Norm();
+ Double_t normCovNonBending2 = covNonBending->E2Norm();
+ (*covBending) *= 1/normCovBending2;
+ (*covNonBending) *= 1/normCovNonBending2;
+// if (covBending->Determinant() < 1.e-33) {
+// printf(" *** covBending *** \n");
+// covBending->Print();
+// printf(" *** covNonBending *** \n");
+// covNonBending->Print();
+// cout << " number of hits " << numberOfHit << endl;
+// cout << "Momentum = " << 1/Param[0] <<endl;
+// cout << "normCovBending = " << normCovBending2 << endl;
+// cout << "normCovNonBending = " << normCovNonBending2 << endl;
+// exit(0);
+
+// }
// Inverts covariance matrix
goodDeterminant = kTRUE;
// check whether the Invert method returns flag if matrix cannot be inverted,
// and it would save a lot of computing time !!!!
// Calculates Chi2
- if (goodDeterminant) { // with Multiple Scattering if inversion correct
- for (hitNumber1=0; hitNumber1 < numberOfHit ; hitNumber1++){
- for (hitNumber2=0; hitNumber2 < numberOfHit; hitNumber2++){
- Chi2 = Chi2 +
- ((*covBending)(hitNumber2, hitNumber1) *
- (hitBendingCoor[hitNumber1] - paramBendingCoor[hitNumber1]) *
- (hitBendingCoor[hitNumber2] - paramBendingCoor[hitNumber2]));
+ if (goodDeterminant) {
+ // with Multiple Scattering if inversion correct
+ // Inverse matrices without normalization
+ (*covBending) *= 1/normCovBending2;
+ (*covNonBending) *= 1/normCovNonBending2;
+ for (hitNumber1 = 0; hitNumber1 < numberOfHit ; hitNumber1++) {
+ hit1 = (AliMUONTrackHit*) (*(trackBeingFitted->GetTrackHitsPtr()))[hitNumber1];
+ hbc1 = hit1->GetHitForRecPtr()->GetBendingCoor();
+ pbc1 = hit1->GetTrackParam()->GetBendingCoor();
+ hnbc1 = hit1->GetHitForRecPtr()->GetNonBendingCoor();
+ pnbc1 = hit1->GetTrackParam()->GetNonBendingCoor();
+ for (hitNumber2 = 0; hitNumber2 < numberOfHit; hitNumber2++) {
+ hit2 = (AliMUONTrackHit*)
+ (*(trackBeingFitted->GetTrackHitsPtr()))[hitNumber2];
+ hbc2 = hit2->GetHitForRecPtr()->GetBendingCoor();
+ pbc2 = hit2->GetTrackParam()->GetBendingCoor();
+ hnbc2 = hit2->GetHitForRecPtr()->GetNonBendingCoor();
+ pnbc2 = hit2->GetTrackParam()->GetNonBendingCoor();
Chi2 = Chi2 +
+ ((*covBending)(hitNumber2, hitNumber1) *
+ (hbc1 - pbc1) * (hbc2 - pbc2)) +
((*covNonBending)(hitNumber2, hitNumber1) *
- (hitNonBendingCoor[hitNumber1] - paramNonBendingCoor[hitNumber1]) *
- (hitNonBendingCoor[hitNumber2] - paramNonBendingCoor[hitNumber2]));
+ (hnbc1 - pnbc1) * (hnbc2 - pnbc2));
}
}
- } else { // without Multiple Scattering if inversion impossible
- for (hitNumber1=0; hitNumber1 < numberOfHit ; hitNumber1++) {
- Chi2 = Chi2 +
- ((hitBendingCoor[hitNumber1] - paramBendingCoor[hitNumber1]) *
- (hitBendingCoor[hitNumber1] - paramBendingCoor[hitNumber1]) /
- hitBendingReso2[hitNumber1]);
- Chi2 = Chi2 +
- ((hitNonBendingCoor[hitNumber1] - paramNonBendingCoor[hitNumber1]) *
- (hitNonBendingCoor[hitNumber1] - paramNonBendingCoor[hitNumber1]) /
- hitNonBendingReso2[hitNumber1]);
+ } else {
+ // without Multiple Scattering if inversion impossible
+ for (hitNumber1 = 0; hitNumber1 < numberOfHit ; hitNumber1++) {
+ hit1 = (AliMUONTrackHit*) (*(trackBeingFitted->GetTrackHitsPtr()))[hitNumber1];
+ hbc1 = hit1->GetHitForRecPtr()->GetBendingCoor();
+ pbc1 = hit1->GetTrackParam()->GetBendingCoor();
+ hnbc1 = hit1->GetHitForRecPtr()->GetNonBendingCoor();
+ pnbc1 = hit1->GetTrackParam()->GetNonBendingCoor();
+ Chi2 = Chi2 +
+ ((hbc1 - pbc1) * (hbc1 - pbc1) /
+ hit1->GetHitForRecPtr()->GetBendingReso2()) +
+ ((hnbc1 - pnbc1) * (hnbc1 - pnbc1) /
+ hit1->GetHitForRecPtr()->GetNonBendingReso2());
}
}
delete covBending;
delete covNonBending;
+ delete [] msa2;
}
Double_t MultipleScatteringAngle2(AliMUONTrackHit *TrackHit)
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff