* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.4 2000/06/30 10:15:48 gosset
-Changes to EventReconstructor...:
-precision fit with multiple Coulomb scattering;
-extrapolation to vertex with Branson correction in absorber (JPC)
+/* $Id$ */
-Revision 1.3 2000/06/25 13:23:28 hristov
-stdlib.h needed for non-Linux compilation
-
-Revision 1.2 2000/06/15 07:58:48 morsch
-Code from MUON-dev joined
-
-Revision 1.1.2.3 2000/06/12 10:11:34 morsch
-Dummy copy constructor and assignment operator added
-
-Revision 1.1.2.2 2000/06/09 12:58:05 gosset
-Removed comment beginnings in Log sections of .cxx files
-Suppressed most violations of coding rules
-
-Revision 1.1.2.1 2000/06/07 14:44:53 gosset
-Addition of files for track reconstruction in C++
-*/
-
-//__________________________________________________________________________
+///////////////////////////////////////////////////
//
-// Reconstructed track in ALICE dimuon spectrometer
-//__________________________________________________________________________
+// Reconstructed track
+// in
+// ALICE
+// dimuon
+// spectrometer
+//
+///////////////////////////////////////////////////
#include "AliMUONTrack.h"
-#include <iostream.h>
-
-#include <TClonesArray.h>
-#include <TMath.h>
-#include <TMatrix.h>
-#include <TVirtualFitter.h>
-
-#include "AliMUONEventReconstructor.h"
+#include "AliMUONTrackReconstructor.h"
#include "AliMUONHitForRec.h"
#include "AliMUONSegment.h"
#include "AliMUONTrackHit.h"
+#include "AliMUONTriggerTrack.h"
+#include "AliMUONConstants.h"
-#include <stdlib.h>
+#include "AliLog.h"
+
+#include <Riostream.h> // for cout
+#include <TMath.h>
+#include <TMatrixD.h>
+#include <TObjArray.h>
+#include <TVirtualFitter.h>
+
+#include <stdlib.h> // for exit()
// Functions to be minimized with Minuit
void TrackChi2(Int_t &NParam, Double_t *Gradient, Double_t &Chi2, Double_t *Param, Int_t Flag);
void TrackChi2MCS(Int_t &NParam, Double_t *Gradient, Double_t &Chi2, Double_t *Param, Int_t Flag);
+void mnvertLocal(Double_t* a, Int_t l, Int_t m, Int_t n, Int_t& ifail);
+
Double_t MultipleScatteringAngle2(AliMUONTrackHit *TrackHit);
+TVirtualFitter* AliMUONTrack::fgFitter = NULL;
+
ClassImp(AliMUONTrack) // Class implementation in ROOT context
-TVirtualFitter* AliMUONTrack::fgFitter = NULL;
+//__________________________________________________________________________
+AliMUONTrack::AliMUONTrack()
+ : TObject()
+{
+ // Default constructor
+ fgFitter = 0;
+ fTrackReconstructor = 0;
+ fTrackHitsPtr = new TObjArray(10);
+ fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
+ fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
+ fTrackID = 0;
+}
//__________________________________________________________________________
-AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegment, AliMUONEventReconstructor* EventReconstructor)
+AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegment, AliMUONTrackReconstructor* TrackReconstructor)
+ : TObject()
{
// 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);
+ fTrackReconstructor = TrackReconstructor; // link back to TrackReconstructor
+ // 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
+ if (BegSegment) { //AZ
+ 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
+ }
+ fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
+ fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
+ // set fit conditions...
fFitMCS = 0;
fFitNParam = 3;
fFitStart = 1;
+ fFitFMin = -1.0;
+ fMatchTrigger = kFALSE;
+ fChi2MatchTrigger = 0;
+ fTrackID = 0;
return;
}
//__________________________________________________________________________
-AliMUONTrack::AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec, AliMUONEventReconstructor* EventReconstructor)
+AliMUONTrack::AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec, AliMUONTrackReconstructor* TrackReconstructor)
+ : TObject()
{
// 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);
+ fTrackReconstructor = TrackReconstructor; // link back to TrackReconstructor
+ // 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
+ fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
+ fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
+ // set fit conditions...
fFitMCS = 0;
fFitNParam = 3;
fFitStart = 1;
+ fFitFMin = -1.0;
+ fMatchTrigger = kFALSE;
+ fChi2MatchTrigger = 0;
+ fTrackID = 0;
return;
}
//__________________________________________________________________________
-AliMUONTrack::AliMUONTrack (const AliMUONTrack& MUONTrack)
+AliMUONTrack::~AliMUONTrack()
{
-// Dummy copy constructor
+ // Destructor
+ if (fTrackHitsPtr) {
+ // delete the TObjArray of pointers to TrackHit's
+ delete fTrackHitsPtr;
+ fTrackHitsPtr = NULL;
+ }
+
+ if (fTrackParamAtHit) {
+ // delete the TClonesArray of pointers to TrackParam
+ delete fTrackParamAtHit;
+ fTrackParamAtHit = NULL;
+ }
+
+ if (fHitForRecAtHit) {
+ // delete the TClonesArray of pointers to HitForRec
+ delete fHitForRecAtHit;
+ fHitForRecAtHit = NULL;
+ }
}
//__________________________________________________________________________
-AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& MUONTrack)
+AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
+ : TObject(theMUONTrack)
{
-// Dummy assignment operator
+ //fTrackReconstructor = new AliMUONTrackReconstructor(*MUONTrack.fTrackReconstructor);
+ // is it right ?
+ // NO, because it would use dummy copy constructor
+ // and AliMUONTrack is not the owner of its TrackReconstructor
+ fTrackReconstructor = theMUONTrack.fTrackReconstructor;
+ fTrackParamAtVertex = theMUONTrack.fTrackParamAtVertex;
+
+ // necessary to make a copy of the objects and not only the pointers in TObjArray.
+ fTrackHitsPtr = new TObjArray(10);
+ for (Int_t index = 0; index < (theMUONTrack.fTrackHitsPtr)->GetEntriesFast(); index++) {
+ AliMUONTrackHit *trackHit = new AliMUONTrackHit(*(AliMUONTrackHit*)(theMUONTrack.fTrackHitsPtr)->At(index));
+ fTrackHitsPtr->Add(trackHit);
+ }
+ fTrackHitsPtr->SetOwner(); // nedeed for deleting TClonesArray
+
+ // necessary to make a copy of the objects and not only the pointers in TClonesArray.
+ fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
+ for (Int_t index = 0; index < (theMUONTrack.fTrackParamAtHit)->GetEntriesFast(); index++) {
+ {new ((*fTrackParamAtHit)[fTrackParamAtHit->GetEntriesFast()])
+ AliMUONTrackParam(*(AliMUONTrackParam*)(theMUONTrack.fTrackParamAtHit)->At(index));}
+ }
+
+ // necessary to make a copy of the objects and not only the pointers in TClonesArray.
+ fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
+ for (Int_t index = 0; index < (theMUONTrack.fHitForRecAtHit)->GetEntriesFast(); index++) {
+ {new ((*fHitForRecAtHit)[fHitForRecAtHit->GetEntriesFast()])
+ AliMUONHitForRec(*(AliMUONHitForRec*)(theMUONTrack.fHitForRecAtHit)->At(index));}
+ }
+
+ fNTrackHits = theMUONTrack.fNTrackHits;
+ fFitMCS = theMUONTrack.fFitMCS;
+ fFitNParam = theMUONTrack.fFitNParam;
+ fFitFMin = theMUONTrack.fFitFMin;
+ fFitStart = theMUONTrack.fFitStart;
+ fMatchTrigger = theMUONTrack.fMatchTrigger;
+ fChi2MatchTrigger = theMUONTrack.fChi2MatchTrigger;
+ fTrackID = theMUONTrack.fTrackID;
+}
+
+ //__________________________________________________________________________
+AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& theMUONTrack)
+{
+
+ // check assignement to self
+ if (this == &theMUONTrack)
return *this;
+
+ // base class assignement
+ TObject::operator=(theMUONTrack);
+
+ // fTrackReconstructor = new AliMUONTrackReconstructor(*MUONTrack.fTrackReconstructor);
+ // is it right ?
+ // is it right ? NO because it would use dummy copy constructor
+ fTrackReconstructor = theMUONTrack.fTrackReconstructor;
+ fTrackParamAtVertex = theMUONTrack.fTrackParamAtVertex;
+
+ // necessary to make a copy of the objects and not only the pointers in TObjArray.
+ fTrackHitsPtr = new TObjArray(10);
+ for (Int_t index = 0; index < (theMUONTrack.fTrackHitsPtr)->GetEntriesFast(); index++) {
+ AliMUONTrackHit *trackHit = new AliMUONTrackHit(*(AliMUONTrackHit*)(theMUONTrack.fTrackHitsPtr)->At(index));
+ fTrackHitsPtr->Add(trackHit);
+ }
+ fTrackHitsPtr->SetOwner(); // nedeed for deleting TClonesArray
+
+ // necessary to make a copy of the objects and not only the pointers in TClonesArray.
+ fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
+ for (Int_t index = 0; index < (theMUONTrack.fTrackParamAtHit)->GetEntriesFast(); index++) {
+ {new ((*fTrackParamAtHit)[fTrackParamAtHit->GetEntriesFast()])
+ AliMUONTrackParam(*(AliMUONTrackParam*)(theMUONTrack.fTrackParamAtHit)->At(index));}
+ }
+
+ // necessary to make a copy of the objects and not only the pointers in TClonesArray.
+ fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
+ for (Int_t index = 0; index < (theMUONTrack.fHitForRecAtHit)->GetEntriesFast(); index++) {
+ {new ((*fHitForRecAtHit)[fHitForRecAtHit->GetEntriesFast()])
+ AliMUONHitForRec(*(AliMUONHitForRec*)(theMUONTrack.fHitForRecAtHit)->At(index));}
+ }
+
+ fNTrackHits = theMUONTrack.fNTrackHits;
+ fFitMCS = theMUONTrack.fFitMCS;
+ fFitNParam = theMUONTrack.fFitNParam;
+ fFitFMin = theMUONTrack.fFitFMin;
+ fFitStart = theMUONTrack.fFitStart;
+ fMatchTrigger = theMUONTrack.fMatchTrigger;
+ fChi2MatchTrigger = theMUONTrack.fChi2MatchTrigger;
+ fTrackID = theMUONTrack.fTrackID;
+
+ 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;
+ AliMUONTrackReconstructor *eventRec = this->fTrackReconstructor;
+ 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();
}
//__________________________________________________________________________
}
//__________________________________________________________________________
-AliMUONTrackParam* AliMUONTrack::GetTrackParamAtFirstHit(void) {
+AliMUONTrackParam* AliMUONTrack::GetTrackParamAtFirstHit(void) const {
// Get pointer to TrackParamAtFirstHit
return ((AliMUONTrackHit*) (fTrackHitsPtr->First()))->GetTrackParam();}
//__________________________________________________________________________
-void AliMUONTrack::RecursiveDump(void)
+void AliMUONTrack::RecursiveDump(void) const
{
// Recursive dump of AliMUONTrack, i.e. with dump of TrackHit's and HitForRec's
AliMUONTrackHit *trackHit;
}
return;
}
+
+ //__________________________________________________________________________
+Bool_t* AliMUONTrack::CompatibleTrack(AliMUONTrack * Track, Double_t Sigma2Cut) const
+{
+ // Return kTRUE/kFALSE for each chamber if hit is compatible or not
+ TClonesArray *hitArray, *thisHitArray;
+ AliMUONHitForRec *hit, *thisHit;
+ Int_t chamberNumber;
+ Float_t deltaZ;
+ Float_t deltaZMax = 1.; // 1 cm
+ Float_t chi2 = 0;
+ Bool_t *nCompHit = new Bool_t[AliMUONConstants::NTrackingCh()];
+
+ for ( Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++) {
+ nCompHit[ch] = kFALSE;
+ }
+
+ thisHitArray = this->GetHitForRecAtHit();
+
+ hitArray = Track->GetHitForRecAtHit();
+
+ for (Int_t iHthis = 0; iHthis < thisHitArray->GetEntriesFast(); iHthis++) {
+ thisHit = (AliMUONHitForRec*) thisHitArray->At(iHthis);
+ chamberNumber = thisHit->GetChamberNumber();
+ if (chamberNumber < 0 || chamberNumber > AliMUONConstants::NTrackingCh()) continue;
+ nCompHit[chamberNumber] = kFALSE;
+ for (Int_t iH = 0; iH < hitArray->GetEntriesFast(); iH++) {
+ hit = (AliMUONHitForRec*) hitArray->At(iH);
+ deltaZ = TMath::Abs(thisHit->GetZ() - hit->GetZ());
+ chi2 = thisHit->NormalizedChi2WithHitForRec(hit,Sigma2Cut); // set cut to 4 sigmas
+ if (chi2 < 3. && deltaZ < deltaZMax) {
+ nCompHit[chamberNumber] = kTRUE;
+ break;
+ }
+ }
+ }
+
+ return nCompHit;
+}
+
+ //__________________________________________________________________________
+Int_t AliMUONTrack::HitsInCommon(AliMUONTrack* Track) const
+{
+ // 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::MatchTriggerTrack(TClonesArray *triggerTrackArray)
+{
+ // Match this track with one trigger track if possible
+ AliMUONTrackParam trackParam;
+ AliMUONTriggerTrack *triggerTrack;
+ Double_t xTrack, yTrack, ySlopeTrack, dTrigTrackMin2, dTrigTrack2;
+ Double_t nSigmaCut2;
+
+ Double_t distSigma[3]={1,1,0.02}; // sigma of distributions (trigger-track) X,Y,slopeY
+ Double_t distTriggerTrack[3] = {0,0,0};
+
+ fMatchTrigger = kFALSE;
+ fChi2MatchTrigger = 0;
+
+ trackParam = *((AliMUONTrackParam*) fTrackParamAtHit->Last());
+ trackParam.ExtrapToZ(AliMUONConstants::DefaultChamberZ(10)); // extrap to 1st trigger chamber
+
+ nSigmaCut2 = fTrackReconstructor->GetMaxSigma2Distance(); // nb of sigma**2 for cut
+ xTrack = trackParam.GetNonBendingCoor();
+ yTrack = trackParam.GetBendingCoor();
+ ySlopeTrack = trackParam.GetBendingSlope();
+ dTrigTrackMin2 = 999;
+
+ triggerTrack = (AliMUONTriggerTrack*) triggerTrackArray->First();
+ while(triggerTrack){
+ distTriggerTrack[0] = (triggerTrack->GetX11()-xTrack)/distSigma[0];
+ distTriggerTrack[1] = (triggerTrack->GetY11()-yTrack)/distSigma[1];
+ distTriggerTrack[2] = (TMath::Tan(triggerTrack->GetThetay())-ySlopeTrack)/distSigma[2];
+ dTrigTrack2 = 0;
+ for (Int_t iVar = 0; iVar < 3; iVar++)
+ dTrigTrack2 += distTriggerTrack[iVar]*distTriggerTrack[iVar];
+ if (dTrigTrack2 < dTrigTrackMin2 && dTrigTrack2 < nSigmaCut2) {
+ dTrigTrackMin2 = dTrigTrack2;
+ fMatchTrigger = kTRUE;
+ fChi2MatchTrigger = dTrigTrack2/3.; // Normalized Chi2, 3 variables (X,Y,slopeY)
+ }
+ triggerTrack = (AliMUONTriggerTrack*) triggerTrackArray->After(triggerTrack);
+ }
+}
//__________________________________________________________________________
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;
+ // Switch off printout
+ arg[0] = -1;
fgFitter->ExecuteCommand("SET PRINT", arg, 1); // More printing !!!!
+ // No warnings
+ fgFitter->ExecuteCommand("SET NOW", arg, 0);
// Parameters according to "fFitStart"
// (should be a function to be used at every place where needed ????)
if (fFitStart == 0) trackParam = &fTrackParamAtVertex;
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);
// minimization
fgFitter->ExecuteCommand("MINIMIZE", arg, 0);
// exit from Minuit
- fgFitter->ExecuteCommand("EXIT", arg, 0); // necessary ????
+ // fgFitter->ExecuteCommand("EXIT", arg, 0); // necessary ????
// get results into "invBenP", "benC", "nonBenC" ("x", "y")
fgFitter->GetParameter(0, parName, invBenP, errorParam, lower, upper);
fgFitter->GetParameter(1, parName, benC, errorParam, lower, upper);
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->fTrackReconstructor->GetRecTrackHitsPtr();
+ Int_t eventTrackHits = this->fTrackReconstructor->GetNRecTrackHits();
+ // event
+ AliMUONTrackHit* trackHit =
+ new ((*recTrackHitsPtr)[eventTrackHits]) AliMUONTrackHit(HitForRec);
+ this->fTrackReconstructor->SetNRecTrackHits(eventTrackHits + 1);
+ // track
+ if (fTrackHitsPtr->IsOwner()) AliFatal("fTrackHitsPtr is owner");
+ fTrackHitsPtr->Add(trackHit);
fNTrackHits++;
}
//__________________________________________________________________________
-void AliMUONTrack::SetTrackParamAtHit(Int_t indexHit, AliMUONTrackParam *TrackParam)
+void AliMUONTrack::SetTrackParamAtHit(Int_t indexHit, AliMUONTrackParam *TrackParam) const
{
// Set track parameters at TrackHit with index "indexHit"
// from the track parameters pointed to by "TrackParam".
- AliMUONTrackHit* trackHit = (AliMUONTrackHit*) ((*fTrackHitsPtr)[indexHit]);
+ //PH AliMUONTrackHit* trackHit = (AliMUONTrackHit*) ((*fTrackHitsPtr)[indexHit]);
+ AliMUONTrackHit* trackHit = (AliMUONTrackHit*) (fTrackHitsPtr->At(indexHit));
trackHit->SetTrackParam(TrackParam);
}
firstHit->GetBendingCoor() - bendingSlope * firstHit->GetZ(); // same if from firstHit and lastHit ????
// signed bending momentum
Double_t signedBendingMomentum =
- fEventReconstructor->GetBendingMomentumFromImpactParam(impactParam);
+ fTrackReconstructor->GetBendingMomentumFromImpactParam(impactParam);
trackParam->SetInverseBendingMomentum(1.0 / signedBendingMomentum);
// bending slope at vertex
trackParam->
SetBendingSlope(bendingSlope +
- impactParam / fEventReconstructor->GetSimpleBPosition());
+ impactParam / fTrackReconstructor->GetSimpleBPosition());
// non bending slope
Double_t nonBendingSlope =
(firstHit->GetNonBendingCoor() - lastHit->GetNonBendingCoor()) / deltaZ;
}
//__________________________________________________________________________
-void TrackChi2(Int_t &NParam, Double_t *Gradient, Double_t &Chi2, Double_t *Param, Int_t Flag)
+void TrackChi2(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double_t *Param, Int_t /*Flag*/)
{
// Return the "Chi2" to be minimized with Minuit for track fitting,
// with "NParam" parameters
}
//__________________________________________________________________________
-void TrackChi2MCS(Int_t &NParam, Double_t *Gradient, Double_t &Chi2, Double_t *Param, Int_t Flag)
+void TrackChi2MCS(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double_t *Param, Int_t /*Flag*/)
{
// Return the "Chi2" to be minimized with Minuit for track fitting,
// with "NParam" parameters
}
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;...
-
- // Inverts covariance matrix
- goodDeterminant = kTRUE;
- // check whether the Invert method returns flag if matrix cannot be inverted,
- // and do not calculate the Determinant in that case !!!!
- if (covBending->Determinant() != 0) {
- covBending->Invert();
- } else {
- goodDeterminant = kFALSE;
- cout << "Warning in ChiMCS Determinant Bending=0: " << endl;
- }
- if (covNonBending->Determinant() != 0) {
- covNonBending->Invert();
- } else {
- goodDeterminant = kFALSE;
- cout << "Warning in ChiMCS Determinant non Bending=0: " << endl;
- }
+
+ // Inversion of covariance matrices
+ // with "mnvertLocal", local "mnvert" function of Minuit.
+ // One cannot use directly "mnvert" since "TVirtualFitter" does not know it.
+ // One will have to replace this local function by the right inversion function
+ // from a specialized Root package for symmetric positive definite matrices,
+ // when available!!!!
+ Int_t ifailBending;
+ mnvertLocal(&((*covBending)(0,0)), numberOfHit, numberOfHit, numberOfHit,
+ ifailBending);
+ Int_t ifailNonBending;
+ mnvertLocal(&((*covNonBending)(0,0)), numberOfHit, numberOfHit, numberOfHit,
+ ifailNonBending);
// It would be worth trying to calculate the inverse of the covariance matrix
// only once per fit, since it cannot change much in principle,
// 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 ((ifailBending == 0) && (ifailNonBending == 0)) {
+ // with Multiple Scattering if inversion correct
+ 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)
// thickness in radiation length for the current track,
// taking local angle into account
radiationLength =
- trackBeingFitted->GetEventReconstructor()->GetChamberThicknessInX0() *
+ trackBeingFitted->GetTrackReconstructor()->GetChamberThicknessInX0() *
TMath::Sqrt(1.0 +
slopeBending * slopeBending + slopeNonBending * slopeNonBending);
inverseBendingMomentum2 =
varMultipleScatteringAngle * varMultipleScatteringAngle;
return varMultipleScatteringAngle;
}
+
+//______________________________________________________________________________
+ void mnvertLocal(Double_t *a, Int_t l, Int_t, Int_t n, Int_t &ifail)
+{
+//*-*-*-*-*-*-*-*-*-*-*-*Inverts a symmetric matrix*-*-*-*-*-*-*-*-*-*-*-*-*
+//*-* ==========================
+//*-* inverts a symmetric matrix. matrix is first scaled to
+//*-* have all ones on the diagonal (equivalent to change of units)
+//*-* but no pivoting is done since matrix is positive-definite.
+//*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
+
+ // taken from TMinuit package of Root (l>=n)
+ // fVERTs, fVERTq and fVERTpp changed to localVERTs, localVERTq and localVERTpp
+ // Double_t localVERTs[n], localVERTq[n], localVERTpp[n];
+ Double_t * localVERTs = new Double_t[n];
+ Double_t * localVERTq = new Double_t[n];
+ Double_t * localVERTpp = new Double_t[n];
+ // fMaxint changed to localMaxint
+ Int_t localMaxint = n;
+
+ /* System generated locals */
+ Int_t aOffset;
+
+ /* Local variables */
+ Double_t si;
+ Int_t i, j, k, kp1, km1;
+
+ /* Parameter adjustments */
+ aOffset = l + 1;
+ a -= aOffset;
+
+ /* Function Body */
+ ifail = 0;
+ if (n < 1) goto L100;
+ if (n > localMaxint) goto L100;
+//*-*- scale matrix by sqrt of diag elements
+ for (i = 1; i <= n; ++i) {
+ si = a[i + i*l];
+ if (si <= 0) goto L100;
+ localVERTs[i-1] = 1 / TMath::Sqrt(si);
+ }
+ for (i = 1; i <= n; ++i) {
+ for (j = 1; j <= n; ++j) {
+ a[i + j*l] = a[i + j*l]*localVERTs[i-1]*localVERTs[j-1];
+ }
+ }
+//*-*- . . . start main loop . . . .
+ for (i = 1; i <= n; ++i) {
+ k = i;
+//*-*- preparation for elimination step1
+ if (a[k + k*l] != 0) localVERTq[k-1] = 1 / a[k + k*l];
+ else goto L100;
+ localVERTpp[k-1] = 1;
+ a[k + k*l] = 0;
+ kp1 = k + 1;
+ km1 = k - 1;
+ if (km1 < 0) goto L100;
+ else if (km1 == 0) goto L50;
+ else goto L40;
+L40:
+ for (j = 1; j <= km1; ++j) {
+ localVERTpp[j-1] = a[j + k*l];
+ localVERTq[j-1] = a[j + k*l]*localVERTq[k-1];
+ a[j + k*l] = 0;
+ }
+L50:
+ if (k - n < 0) goto L51;
+ else if (k - n == 0) goto L60;
+ else goto L100;
+L51:
+ for (j = kp1; j <= n; ++j) {
+ localVERTpp[j-1] = a[k + j*l];
+ localVERTq[j-1] = -a[k + j*l]*localVERTq[k-1];
+ a[k + j*l] = 0;
+ }
+//*-*- elimination proper
+L60:
+ for (j = 1; j <= n; ++j) {
+ for (k = j; k <= n; ++k) { a[j + k*l] += localVERTpp[j-1]*localVERTq[k-1]; }
+ }
+ }
+//*-*- elements of left diagonal and unscaling
+ for (j = 1; j <= n; ++j) {
+ for (k = 1; k <= j; ++k) {
+ a[k + j*l] = a[k + j*l]*localVERTs[k-1]*localVERTs[j-1];
+ a[j + k*l] = a[k + j*l];
+ }
+ }
+ delete [] localVERTs;
+ delete [] localVERTq;
+ delete [] localVERTpp;
+ return;
+//*-*- failure return
+L100:
+ delete [] localVERTs;
+ delete [] localVERTq;
+ delete [] localVERTpp;
+ ifail = 1;
+} /* mnvertLocal */
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff