#include <TMatrixD.h>
#include "AliMUONTrackReconstructor.h"
-#include "AliMUON.h"
+#include "AliMUONData.h"
#include "AliMUONConstants.h"
#include "AliMUONHitForRec.h"
#include "AliMUONTriggerTrack.h"
-#include "AliMUONTriggerCircuit.h"
+#include "AliMUONTriggerCircuitNew.h"
#include "AliMUONRawCluster.h"
#include "AliMUONLocalTrigger.h"
#include "AliMUONGlobalTrigger.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackHit.h"
#include "AliMagF.h"
-#include "AliRun.h" // for gAlice
-#include "AliRunLoader.h"
-#include "AliLoader.h"
#include "AliMUONTrackK.h"
-#include "AliMC.h"
#include "AliLog.h"
-#include "AliTrackReference.h"
+#include "AliTracker.h"
//************* Defaults parameters for reconstruction
const Double_t AliMUONTrackReconstructor::fgkDefaultMinBendingMomentum = 3.0;
const Double_t AliMUONTrackReconstructor::fgkDefaultSimpleBValue = 7.0;
const Double_t AliMUONTrackReconstructor::fgkDefaultSimpleBLength = 428.0;
const Double_t AliMUONTrackReconstructor::fgkDefaultSimpleBPosition = 1019.0;
-const Int_t AliMUONTrackReconstructor::fgkDefaultRecTrackRefHits = 0;
const Double_t AliMUONTrackReconstructor::fgkDefaultEfficiency = 0.95;
ClassImp(AliMUONTrackReconstructor) // Class implementation in ROOT context
//__________________________________________________________________________
-AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliLoader* loader, AliMUONData* data)
- : TObject()
+AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliMUONData* data)
+ : TObject(),
+ fTrackMethod(1), //AZ - tracking method (1-default, 2-Kalman)
+ fMinBendingMomentum(fgkDefaultMinBendingMomentum),
+ fMaxBendingMomentum(fgkDefaultMaxBendingMomentum),
+ fMaxChi2(fgkDefaultMaxChi2),
+ fMaxSigma2Distance(fgkDefaultMaxSigma2Distance),
+ fBendingResolution(fgkDefaultBendingResolution),
+ fNonBendingResolution(fgkDefaultNonBendingResolution),
+ fChamberThicknessInX0(fgkDefaultChamberThicknessInX0),
+ fSimpleBValue(fgkDefaultSimpleBValue),
+ fSimpleBLength(fgkDefaultSimpleBLength),
+ fSimpleBPosition(fgkDefaultSimpleBPosition),
+ fEfficiency(fgkDefaultEfficiency),
+ fHitsForRecPtr(0x0),
+ fNHitsForRec(0),
+ fRecTracksPtr(0x0),
+ fNRecTracks(0),
+ fRecTrackHitsPtr(0x0),
+ fNRecTrackHits(0),
+ fMUONData(data),
+ fMuons(0),
+ fTriggerTrack(new AliMUONTriggerTrack()),
+ fTriggerCircuit(0x0)
{
// Constructor for class AliMUONTrackReconstructor
SetReconstructionParametersToDefaults();
- fTrackMethod = 1; //AZ - tracking method (1-default, 2-Kalman)
+
// Memory allocation for the TClonesArray of hits for reconstruction
// Is 10000 the right size ????
fHitsForRecPtr = new TClonesArray("AliMUONHitForRec", 10000);
- fNHitsForRec = 0; // really needed or GetEntriesFast sufficient ????
+
// Memory allocation for the TClonesArray's of segments in stations
// Is 2000 the right size ????
for (Int_t st = 0; st < AliMUONConstants::NTrackingCh()/2; st++) {
// Memory allocation for the TClonesArray of reconstructed tracks
// Is 10 the right size ????
fRecTracksPtr = new TClonesArray("AliMUONTrack", 10);
- fNRecTracks = 0; // really needed or GetEntriesFast sufficient ????
+
// Memory allocation for the TClonesArray of hits on reconstructed tracks
// Is 100 the right size ????
fRecTrackHitsPtr = new TClonesArray("AliMUONTrackHit", 100);
- fNRecTrackHits = 0; // really needed or GetEntriesFast sufficient ????
- // Sign of fSimpleBValue according to sign of Bx value at (50,50,-950).
+ const AliMagF* kField = AliTracker::GetFieldMap();
+ if (!kField) AliFatal("No field available");
+ // Sign of fSimpleBValue according to sign of Bx value at (50,50,-950).
Float_t b[3], x[3];
x[0] = 50.; x[1] = 50.; x[2] = -950.;
- gAlice->Field()->Field(x, b);
- fSimpleBValue = TMath::Sign(fSimpleBValue,(Double_t) b[0]);
+ kField->Field(x,b);
+
+ fSimpleBValue = TMath::Sign(fSimpleBValue,(Double_t) b[0]);
fSimpleBPosition = TMath::Sign(fSimpleBPosition,(Double_t) x[2]);
// See how to get fSimple(BValue, BLength, BPosition)
// automatically calculated from the actual magnetic field ????
- AliDebug(1,"AliMUONTrackReconstructor constructed with defaults");
- if ( AliLog::GetGlobalDebugLevel()>0) Dump();
- AliDebug(1,"Magnetic field from root file:");
- if ( AliLog::GetGlobalDebugLevel()>0) gAlice->Field()->Dump();
-
-
- // Initializions for track ref. background events
- fBkgTrackRefFile = 0;
- fBkgTrackRefTK = 0;
- fBkgTrackRefParticles = 0;
- fBkgTrackRefTTR = 0;
- fBkgTrackRefEventNumber = -1;
-
- // initialize loader's
- fLoader = loader;
-
- // initialize container
- // fMUONData = new AliMUONData(fLoader,"MUON","MUON");
- fMUONData = data;
-
return;
}
- //__________________________________________________________________________
-AliMUONTrackReconstructor::AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs)
- : TObject(rhs)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-AliMUONTrackReconstructor &
-AliMUONTrackReconstructor::operator=(const AliMUONTrackReconstructor& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
//__________________________________________________________________________
AliMUONTrackReconstructor::~AliMUONTrackReconstructor(void)
delete fHitsForRecPtr; // Correct destruction of everything ???? or delete [] ????
for (Int_t st = 0; st < AliMUONConstants::NTrackingCh()/2; st++)
delete fSegmentsPtr[st]; // Correct destruction of everything ????
- return;
-}
+ delete fTriggerTrack;
+}
//__________________________________________________________________________
void AliMUONTrackReconstructor::SetReconstructionParametersToDefaults(void)
{
// Set reconstruction parameters to default values
// Would be much more convenient with a structure (or class) ????
- fMinBendingMomentum = fgkDefaultMinBendingMomentum;
- fMaxBendingMomentum = fgkDefaultMaxBendingMomentum;
- fMaxChi2 = fgkDefaultMaxChi2;
- fMaxSigma2Distance = fgkDefaultMaxSigma2Distance;
// ******** Parameters for making HitsForRec
// minimum radius,
fSegmentMaxDistBending[4] = TMath::Abs( 6.0 *
(AliMUONConstants::DefaultChamberZ(9) - AliMUONConstants::DefaultChamberZ(8)) / 20.0);
-
- fBendingResolution = fgkDefaultBendingResolution;
- fNonBendingResolution = fgkDefaultNonBendingResolution;
- fChamberThicknessInX0 = fgkDefaultChamberThicknessInX0;
- fSimpleBValue = fgkDefaultSimpleBValue;
- fSimpleBLength = fgkDefaultSimpleBLength;
- fSimpleBPosition = fgkDefaultSimpleBPosition;
- fRecTrackRefHits = fgkDefaultRecTrackRefHits;
- fEfficiency = fgkDefaultEfficiency;
return;
}
ImpactParam);
}
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::SetBkgTrackRefFile(Text_t *BkgTrackRefFileName)
-{
- // Set background file ... for track ref. hits
- // Must be called after having loaded the firts signal event
- AliDebug(1,Form("Enter SetBkgTrackRefFile with BkgTrackRefFileName %s",BkgTrackRefFileName));
-
- if (strlen(BkgTrackRefFileName)) {
- // BkgTrackRefFileName not empty: try to open the file
-
- if(AliLog::GetGlobalDebugLevel()>1) {
- cout << "Before File(Bkg)" << endl; gDirectory->Dump();
- }
- fBkgTrackRefFile = new TFile(BkgTrackRefFileName);
- if(AliLog::GetGlobalDebugLevel()>1) {
- cout << "After File(Bkg)" << endl; gDirectory->Dump();
- }
- if (fBkgTrackRefFile-> IsOpen()) {
- if(AliLog::GetGlobalDebugLevel()>0) {
- cout << "Background for Track ref. hits in file: ``" << BkgTrackRefFileName
- << "'' successfully opened" << endl;}
- }
- else {
- cout << "Background for Track Ref. hits in file: " << BkgTrackRefFileName << endl;
- cout << "NOT FOUND: EXIT" << endl;
- exit(0); // right instruction for exit ????
- }
- // Arrays for "particles" and "hits"
- fBkgTrackRefParticles = new TClonesArray("TParticle", 200);
- // Event number to -1 for initialization
- fBkgTrackRefEventNumber = -1;
- // Back to the signal file:
- // first signal event must have been loaded previously,
- // otherwise, Segmentation violation at the next instruction
- // How is it possible to do smething better ????
- ((gAlice->TreeK())->GetCurrentFile())->cd();
- if(AliLog::GetGlobalDebugLevel()>1) cout << "After cd(gAlice)" << endl; gDirectory->Dump();
- }
- return;
-}
-
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::NextBkgTrackRefEvent(void)
-{
- // Get next event in background file for track ref. hits
- // Goes back to event number 0 when end of file is reached
- char treeName[20];
-
- AliDebug(1,"Enter NextBkgTrackRefEvent");
- // Clean previous event
- if(fBkgTrackRefTK) delete fBkgTrackRefTK;
- fBkgTrackRefTK = NULL;
- if(fBkgTrackRefParticles) fBkgTrackRefParticles->Clear();
- if(fBkgTrackRefTTR) delete fBkgTrackRefTTR;
- fBkgTrackRefTTR = NULL;
- // Increment event number
- fBkgTrackRefEventNumber++;
- // Get access to Particles and Hits for event from background file
- if (AliLog::GetGlobalDebugLevel()>1) cout << "Before cd(Bkg)" << endl; gDirectory->Dump();
- fBkgTrackRefFile->cd();
- if (AliLog::GetGlobalDebugLevel()>1) cout << "After cd(Bkg)" << endl; gDirectory->Dump();
- // Particles: TreeK for event and branch "Particles"
- sprintf(treeName, "TreeK%d", fBkgTrackRefEventNumber);
- fBkgTrackRefTK = (TTree*)gDirectory->Get(treeName);
- if (!fBkgTrackRefTK) {
-
- AliDebug(1,Form("Cannot find Kine Tree for background event: %d",fBkgTrackRefEventNumber));
- AliDebug(1,"Goes back to event 0");
-
- fBkgTrackRefEventNumber = 0;
- sprintf(treeName, "TreeK%d", fBkgTrackRefEventNumber);
- fBkgTrackRefTK = (TTree*)gDirectory->Get(treeName);
- if (!fBkgTrackRefTK) {
- AliError(Form("cannot find Kine Tree for background event: %d",fBkgTrackRefEventNumber));
- exit(0);
- }
- }
- if (fBkgTrackRefTK)
- fBkgTrackRefTK->SetBranchAddress("Particles", &fBkgTrackRefParticles);
- fBkgTrackRefTK->GetEvent(0); // why event 0 ???? necessary ????
- // Hits: TreeH for event and branch "MUON"
- sprintf(treeName, "TreeTR%d", fBkgTrackRefEventNumber);
- fBkgTrackRefTTR = (TTree*)gDirectory->Get(treeName);
- if (!fBkgTrackRefTTR) {
- AliError(Form("cannot find Hits Tree for background event: %d",fBkgTrackRefEventNumber));
- exit(0);
- }
- fBkgTrackRefTTR->GetEntries(); // necessary ????
- // Back to the signal file
- ((gAlice->TreeK())->GetCurrentFile())->cd();
- if (AliLog::GetGlobalDebugLevel()>1)
- cout << "After cd(gAlice)" << endl; gDirectory->Dump();
- return;
-}
-
//__________________________________________________________________________
void AliMUONTrackReconstructor::EventReconstruct(void)
{
// To reconstruct one event
AliDebug(1,"Enter EventReconstruct");
+ ResetTracks(); //AZ
+ ResetTrackHits(); //AZ
+ ResetSegments(); //AZ
+ ResetHitsForRec(); //AZ
MakeEventToBeReconstructed();
MakeSegments();
MakeTracks();
// To reset the array and the number of HitsForRec,
// and also the number of HitsForRec
// and the index of the first HitForRec per chamber
- if (fHitsForRecPtr) fHitsForRecPtr->Clear();
+ if (fHitsForRecPtr) fHitsForRecPtr->Delete();
fNHitsForRec = 0;
for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++)
fNHitsForRecPerChamber[ch] = fIndexOfFirstHitForRecPerChamber[ch] = 0;
// To make the list of hits to be reconstructed,
// either from the track ref. hits or from the raw clusters
// according to the parameter set for the reconstructor
-// TString evfoldname = AliConfig::GetDefaultEventFolderName();//to be interfaced properly
-
-// AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
-// if (rl == 0x0)
-// {
-// Error("MakeEventToBeReconstructed",
-// "Can not find Run Loader in Event Folder named %s.",
-// evfoldname.Data());
-// return;
-// }
-// AliLoader* gime = rl->GetLoader("MUONLoader");
-// if (gime == 0x0)
-// {
-// Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
-// return;
-// }
- AliRunLoader *runLoader = fLoader->GetRunLoader();
AliDebug(1,"Enter MakeEventToBeReconstructed");
- ResetHitsForRec();
- if (fRecTrackRefHits == 1) {
- // Reconstruction from track ref. hits
- // Back to the signal file
- TTree* treeTR = runLoader->TreeTR();
- if (treeTR == 0x0)
- {
- Int_t retval = runLoader->LoadTrackRefs("READ");
- if ( retval)
- {
- AliError("Error occured while loading hits.");
- return;
- }
- treeTR = runLoader->TreeTR();
- if (treeTR == 0x0)
- {
- AliError("Can not get TreeTR");
- return;
- }
- }
-
- AddHitsForRecFromTrackRef(treeTR,1);
-
- // Background hits
- AddHitsForRecFromTrackRef(fBkgTrackRefTTR,0);
- // Sort HitsForRec in increasing order with respect to chamber number
- SortHitsForRecWithIncreasingChamber();
- }
- else {
- // Reconstruction from raw clusters
- // AliMUON *MUON = (AliMUON*) gAlice->GetModule("MUON"); // necessary ????
- // Security on MUON ????
- // TreeR assumed to be be "prepared" in calling function
- // by "MUON->GetTreeR(nev)" ????
- TTree *treeR = fLoader->TreeR();
- //AZ? fMUONData->SetTreeAddress("RC");
- AddHitsForRecFromRawClusters(treeR);
- // No sorting: it is done automatically in the previous function
- }
+ //AZ ResetHitsForRec();
+
+ // Reconstruction from raw clusters
+ // AliMUON *MUON = (AliMUON*) gAlice->GetModule("MUON"); // necessary ????
+ // Security on MUON ????
+ // TreeR assumed to be be "prepared" in calling function
+ // by "MUON->GetTreeR(nev)" ????
+ TTree *treeR = fMUONData->TreeR();
+
+ //AZ? fMUONData->SetTreeAddress("RC");
+ AddHitsForRecFromRawClusters(treeR);
+ // No sorting: it is done automatically in the previous function
+
AliDebug(1,"End of MakeEventToBeReconstructed");
if (AliLog::GetGlobalDebugLevel() > 0) {
return;
}
- //__________________________________________________________________________
-void AliMUONTrackReconstructor::AddHitsForRecFromTrackRef(TTree *TTR, Int_t signal)
-{
- // To add to the list of hits for reconstruction
- // the signal hits from a track reference tree TreeTR.
- TClonesArray *listOfTrackRefs = NULL;
- AliTrackReference *trackRef;
-
- Int_t track = 0;
- AliDebug(2,Form("Enter AddHitsForRecFromTrackRef with TTR: %d", TTR));
- if (TTR == NULL) return;
-
- listOfTrackRefs = CleanTrackRefs(TTR);
-
- Int_t ntracks = listOfTrackRefs->GetEntriesFast();
-
- AliDebug(2,Form("ntracks: %d", ntracks));
-
- for (Int_t index = 0; index < ntracks; index++) {
- trackRef = (AliTrackReference*) listOfTrackRefs->At(index);
- track = trackRef->GetTrack();
-
- NewHitForRecFromTrackRef(trackRef,track,signal);
- } // end of track ref.
-
- listOfTrackRefs->Delete();
- delete listOfTrackRefs;
- return;
-}
-
-
- //__________________________________________________________________________
-AliMUONHitForRec* AliMUONTrackReconstructor::NewHitForRecFromTrackRef(AliTrackReference* Hit, Int_t TrackNumber, Int_t Signal)
-{
- // To make a new hit for reconstruction from a track ref. hit pointed to by "Hit",
- // with the track numbered "TrackNumber",
- // either from signal ("Signal" = 1) or background ("Signal" = 0) event.
- // Selects hits in tracking (not trigger) chambers.
- // Takes into account the efficiency (fEfficiency)
- // and the smearing from resolution (fBendingResolution and fNonBendingResolution).
- // Adds a condition on the radius between RMin and RMax
- // to better simulate the real chambers.
- // Returns the pointer to the new hit for reconstruction,
- // or NULL in case of inefficiency or non tracking chamber or bad radius.
- // No condition on at most 20 cm from a muon from a resonance
- // like in Fortran TRACKF_STAT.
- AliMUONHitForRec* hitForRec;
- Double_t bendCoor, nonBendCoor, radius;
- Int_t chamber = AliMUONConstants::ChamberNumber(Hit->Z()); // chamber(0...)
- if (chamber < 0) return NULL;
- // only in tracking chambers (fChamber starts at 1)
- if (chamber >= AliMUONConstants::NTrackingCh()) return NULL;
- // only if hit is efficient (keep track for checking ????)
- if (gRandom->Rndm() > fEfficiency) return NULL;
- // only if radius between RMin and RMax
- bendCoor = Hit->Y();
- nonBendCoor = Hit->X();
- radius = TMath::Sqrt((bendCoor * bendCoor) + (nonBendCoor * nonBendCoor));
- // This cut is not needed with a realistic chamber geometry !!!!
-// if ((radius < fRMin[chamber]) || (radius > fRMax[chamber])) return NULL;
- // new AliMUONHitForRec from track ref. hit and increment number of AliMUONHitForRec's
- hitForRec = new ((*fHitsForRecPtr)[fNHitsForRec]) AliMUONHitForRec(Hit);
- fNHitsForRec++;
- // add smearing from resolution
- hitForRec->SetBendingCoor(bendCoor + gRandom->Gaus(0., fBendingResolution));
- hitForRec->SetNonBendingCoor(nonBendCoor
- + gRandom->Gaus(0., fNonBendingResolution));
-// // !!!! without smearing
-// hitForRec->SetBendingCoor(bendCoor);
-// hitForRec->SetNonBendingCoor(nonBendCoor);
- // more information into HitForRec
- // resolution: angular effect to be added here ????
- hitForRec->SetBendingReso2(fBendingResolution * fBendingResolution);
- hitForRec->SetNonBendingReso2(fNonBendingResolution * fNonBendingResolution);
- // track ref. info
- hitForRec->SetTTRTrack(TrackNumber);
- hitForRec->SetTrackRefSignal(Signal);
- if (AliLog::GetGlobalDebugLevel()> 1) {
- AliDebug(2,Form("Track: %d", TrackNumber));
- Hit->Dump();
- cout << "AliMUONHitForRec number (1...): " << fNHitsForRec << endl;
- hitForRec->Dump();
- }
- return hitForRec;
-}
- //__________________________________________________________________________
-TClonesArray* AliMUONTrackReconstructor::CleanTrackRefs(TTree *treeTR)
-{
- // Make hits from track ref..
- // Re-calculate hits parameters because two AliTrackReferences are recorded for
- // each chamber (one when particle is entering + one when particle is leaving
- // the sensitive volume)
-
- AliTrackReference *trackReference;
- Float_t x1, y1, z1, pX1, pY1, pZ1;
- Float_t x2, y2, z2, pX2, pY2, pZ2;
- Int_t track1, track2;
- Int_t nRec = 0;
- Float_t maxGasGap = 1.; // cm
- Int_t iHit1 = 0;
- Int_t iHitMin = 0;
-
- AliTrackReference *trackReferenceNew = new AliTrackReference();
-
- TClonesArray* trackRefs = new TClonesArray("AliTrackReference", 10);
- TClonesArray* cleanTrackRefs = new TClonesArray("AliTrackReference", 10);
-
- if (treeTR == NULL) return NULL;
- TBranch* branch = treeTR->GetBranch("MUON");
- if (branch == NULL) return NULL;
- branch->SetAddress(&trackRefs);
-
- Int_t nTrack = (Int_t)treeTR->GetEntries();
- for (Int_t iTrack = 0; iTrack < nTrack; iTrack++) {
- treeTR->GetEntry(iTrack);
- iHitMin = 0;
- iHit1 = 0;
- while (iHit1 < trackRefs->GetEntries()) {
- trackReference = (AliTrackReference*)trackRefs->At(iHit1);
- x1 = trackReference->X();
- y1 = trackReference->Y();
- z1 = trackReference->Z();
- pX1 = trackReference->Px();
- pY1 = trackReference->Py();
- pZ1 = trackReference->Pz();
- track1 = trackReference->GetTrack();
- nRec = 1;
- iHitMin = iHit1+1;
- for (Int_t iHit2 = iHit1+1; iHit2 < trackRefs->GetEntries(); iHit2++) {
- trackReference = (AliTrackReference*)trackRefs->At(iHit2);
- x2 = trackReference->X();
- y2 = trackReference->Y();
- z2 = trackReference->Z();
- pX2 = trackReference->Px();
- pY2 = trackReference->Py();
- pZ2 = trackReference->Pz();
- track2 = trackReference->GetTrack();
- if (track2 == track1 && TMath::Abs(z2-z1) < maxGasGap ) {
- nRec++;
- x1 += x2;
- y1 += y2;
- z1 += z2;
- pX1 += pX2;
- pY1 += pY2;
- pZ1 += pZ2;
- iHitMin = iHit2+1;
- }
-
- } // for iHit2
- x1 /= (Float_t)nRec;
- y1 /= (Float_t)nRec;
- z1 /= (Float_t)nRec;
- pX1 /= (Float_t)nRec;
- pY1 /= (Float_t)nRec;
- pZ1 /= (Float_t)nRec;
- trackReferenceNew->SetPosition(x1,y1,z1);
- trackReferenceNew->SetMomentum(pX1,pY1,pZ1);
- trackReferenceNew->SetTrack(track1);
- {new ((*cleanTrackRefs)[cleanTrackRefs->GetEntriesFast()]) AliTrackReference(*trackReferenceNew);}
- iHit1 = iHitMin;
- } // while iHit1
- } // for track
-
- trackRefs->Delete();
- delete trackRefs;
- delete trackReferenceNew;
- return cleanTrackRefs;
-
-}
//__________________________________________________________________________
void AliMUONTrackReconstructor::SortHitsForRecWithIncreasingChamber()
{
AliError(Form("nTRentries = %d not equal to 1 ",nTRentries));
exit(0);
}
- fLoader->TreeR()->GetEvent(0); // only one entry
+ fMUONData->GetRawClusters(); // only one entry
}
// Loop over tracking chambers
if (ch == 0) fIndexOfFirstHitForRecPerChamber[ch] = 0;
else fIndexOfFirstHitForRecPerChamber[ch] = fNHitsForRec;
rawclusters =fMUONData->RawClusters(ch);
-// pMUON->ResetRawClusters();
-// TR->GetEvent((Int_t) (TR->GetEntries()) - 1); // to be checked ????
nclus = (Int_t) (rawclusters->GetEntries());
// Loop over (cathode correlated) raw clusters
for (iclus = 0; iclus < nclus; iclus++) {
(fNHitsForRecPerChamber[ch])++;
// more information into HitForRec
// resolution: info should be already in raw cluster and taken from it ????
- hitForRec->SetBendingReso2(fBendingResolution * fBendingResolution);
- hitForRec->SetNonBendingReso2(fNonBendingResolution * fNonBendingResolution);
- //hitForRec->SetBendingReso2(clus->GetErrY() * clus->GetErrY());
- //hitForRec->SetNonBendingReso2(clus->GetErrX() * clus->GetErrX());
+ //hitForRec->SetBendingReso2(fBendingResolution * fBendingResolution);
+ //hitForRec->SetNonBendingReso2(fNonBendingResolution * fNonBendingResolution);
+ hitForRec->SetBendingReso2(clus->GetErrY() * clus->GetErrY());
+ hitForRec->SetNonBendingReso2(clus->GetErrX() * clus->GetErrX());
// original raw cluster
hitForRec->SetChamberNumber(ch);
hitForRec->SetHitNumber(iclus);
// To make the list of segments in all stations,
// from the list of hits to be reconstructed
AliDebug(1,"Enter MakeSegments");
- ResetSegments();
+ //AZ ResetSegments();
// Loop over stations
Int_t nb = (fTrackMethod != 1) ? 3 : 0; //AZ
for (Int_t st = nb; st < AliMUONConstants::NTrackingCh()/2; st++)
distNonBend = TMath::Abs(hit2Ptr->GetNonBendingCoor() - extNonBendCoor);
if (last2st) {
// bending slope
- bendingSlope = (hit1Ptr->GetBendingCoor() - hit2Ptr->GetBendingCoor()) /
- (hit1Ptr->GetZ() - hit2Ptr->GetZ());
- // absolute value of impact parameter
- impactParam =
- TMath::Abs(hit1Ptr->GetBendingCoor() - hit1Ptr->GetZ() * bendingSlope);
+ if ( hit1Ptr->GetZ() - hit2Ptr->GetZ() != 0.0 ) {
+ bendingSlope = (hit1Ptr->GetBendingCoor() - hit2Ptr->GetBendingCoor()) /
+ (hit1Ptr->GetZ() - hit2Ptr->GetZ());
+ // absolute value of impact parameter
+ impactParam =
+ TMath::Abs(hit1Ptr->GetBendingCoor() - hit1Ptr->GetZ() * bendingSlope);
+ }
+ else {
+ AliWarning("hit1Ptr->GetZ() = hit2Ptr->GetZ(): impactParam set to maxImpactParam");
+ impactParam = maxImpactParam;
+ }
}
// check for distances not too large,
// and impact parameter not too big if stations downstream of the dipole.
// from the list of segments and points in all stations
AliDebug(1,"Enter MakeTracks");
// The order may be important for the following Reset's
- ResetTracks();
- ResetTrackHits();
+ //AZ ResetTracks();
+ //AZ ResetTrackHits();
if (fTrackMethod != 1) { //AZ - Kalman filter
MakeTrackCandidatesK();
if (fRecTracksPtr->GetEntriesFast() == 0) return;
TClonesArray *globalTrigger;
AliMUONLocalTrigger *locTrg;
AliMUONGlobalTrigger *gloTrg;
- AliMUONTriggerCircuit *circuit;
- AliMUONTriggerTrack *recTriggerTrack = 0;
- TTree* treeR = fLoader->TreeR();
-
- // Loading MUON subsystem
- AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
-
+ TTree* treeR = fMUONData->TreeR();
+
nTRentries = Int_t(treeR->GetEntries());
treeR->GetEvent(0); // only one entry
// global trigger for trigger pattern
gloTrigPat = 0;
globalTrigger = fMUONData->GlobalTrigger();
- gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0);
- if (gloTrg) {
- if (gloTrg->SinglePlusLpt()) gloTrigPat|= 0x1;
- if (gloTrg->SinglePlusHpt()) gloTrigPat|= 0x2;
- if (gloTrg->SinglePlusApt()) gloTrigPat|= 0x4;
-
- if (gloTrg->SingleMinusLpt()) gloTrigPat|= 0x8;
- if (gloTrg->SingleMinusHpt()) gloTrigPat|= 0x10;
- if (gloTrg->SingleMinusApt()) gloTrigPat|= 0x20;
-
- if (gloTrg->SingleUndefLpt()) gloTrigPat|= 0x40;
- if (gloTrg->SingleUndefHpt()) gloTrigPat|= 0x80;
- if (gloTrg->SingleUndefApt()) gloTrigPat|= 0x100;
-
- if (gloTrg->PairUnlikeLpt()) gloTrigPat|= 0x200;
- if (gloTrg->PairUnlikeHpt()) gloTrigPat|= 0x400;
- if (gloTrg->PairUnlikeApt()) gloTrigPat|= 0x800;
-
- if (gloTrg->PairLikeLpt()) gloTrigPat|= 0x1000;
- if (gloTrg->PairLikeHpt()) gloTrigPat|= 0x2000;
- if (gloTrg->PairLikeApt()) gloTrigPat|= 0x4000;
- }
+ gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0);
+
+ if (gloTrg)
+ gloTrigPat = gloTrg->GetGlobalPattern();
+
// local trigger for tracking
localTrigger = fMUONData->LocalTrigger();
Float_t z11 = AliMUONConstants::DefaultChamberZ(10);
Float_t z21 = AliMUONConstants::DefaultChamberZ(12);
+ Float_t y11 = 0.;
+ Int_t stripX21 = 0;
+ Float_t y21 = 0.;
+ Float_t x11 = 0.;
+
for (Int_t i=0; i<nlocals; i++) { // loop on Local Trigger
locTrg = (AliMUONLocalTrigger*)localTrigger->UncheckedAt(i);
- circuit = &(pMUON->TriggerCircuit(locTrg->LoCircuit()));
- Float_t y11 = circuit->GetY11Pos(locTrg->LoStripX());
- Int_t stripX21 = locTrg->LoStripX()+locTrg->LoDev()+1;
- Float_t y21 = circuit->GetY21Pos(stripX21);
- Float_t x11 = circuit->GetX11Pos(locTrg->LoStripY());
+
+ AliDebug(1, "AliMUONTrackReconstructor::MakeTriggerTrack using NEW trigger \n");
+ AliMUONTriggerCircuitNew* circuit =
+ (AliMUONTriggerCircuitNew*)fTriggerCircuit->At(locTrg->LoCircuit()-1); // -1 !!!
+
+ y11 = circuit->GetY11Pos(locTrg->LoStripX());
+ stripX21 = locTrg->LoStripX()+locTrg->LoDev()+1;
+ y21 = circuit->GetY21Pos(stripX21);
+ x11 = circuit->GetX11Pos(locTrg->LoStripY());
+
+ AliDebug(1, Form(" MakeTriggerTrack %d %d %d %d %d %f %f %f \n",i,locTrg->LoCircuit(),
+ locTrg->LoStripX(),locTrg->LoStripX()+locTrg->LoDev()+1,locTrg->LoStripY(),y11, y21, x11));
+
Float_t thetax = TMath::ATan2( x11 , z11 );
Float_t thetay = TMath::ATan2( (y21-y11) , (z21-z11) );
-
- recTriggerTrack = new AliMUONTriggerTrack(x11,y11,thetax,thetay,gloTrigPat);
- // since static statement does not work, set gloTrigPat for each track
-
- fMUONData->AddRecTriggerTrack(*recTriggerTrack);
- delete recTriggerTrack;
+ fTriggerTrack->SetX11(x11);
+ fTriggerTrack->SetY11(y11);
+ fTriggerTrack->SetThetax(thetax);
+ fTriggerTrack->SetThetay(thetay);
+ fTriggerTrack->SetGTPattern(gloTrigPat);
+
+ fMUONData->AddRecTriggerTrack(*fTriggerTrack);
} // end of loop on Local Trigger
return kTRUE;
}
Double_t bestChi2, chi2, dZ1, dZ2, dZ3, maxSigma2Distance, mcsFactor;
Double_t bendingMomentum, chi2Norm = 0.;
+
// local maxSigma2Distance, for easy increase in testing
maxSigma2Distance = fMaxSigma2Distance;
AliDebug(2,"Enter FollowTracks");
cout << "FollowTracks: track candidate(0..): " << trackIndex
<< " Look for segment in station(0..): " << station << endl;
}
+
// Loop over segments in station
for (iSegment = 0; iSegment < fNSegments[station]; iSegment++) {
// Look for best compatible Segment in station
AliMUONTrackParam *trackParam, *trackParam1;
Double_t bendingSlope, nonBendingSlope, pYZ;
Double_t pX, pY, pZ, x, y, z, c;
- Int_t np, trackIndex, nTrackHits;
+ Int_t trackIndex, nTrackHits;
AliDebug(1,"****** enter EventDump ******");
AliDebug(1, Form("Number of Reconstructed tracks : %d", fNRecTracks));
AliDebug(1, Form("track parameters at z= %f: X= %f Y= %f pX= %f pY= %f pZ= %f c= %f\n",
z, x, y, pX, pY, pZ, c));
}
- // informations about generated particles
- np = gAlice->GetMCApp()->GetNtrack();
- printf(" **** number of generated particles: %d \n", np);
+ // informations about generated particles NO !!!!!!!!
// for (Int_t iPart = 0; iPart < np; iPart++) {
// p = gAlice->Particle(iPart);
AliMUONTrackK *trackK;
AliDebug(1,"Enter MakeTrackCandidatesK");
- // Reset the TClonesArray of reconstructed tracks
- if (fRecTracksPtr) fRecTracksPtr->Delete();
- // Delete in order that the Track destructors are called,
- // hence the space for the TClonesArray of pointers to TrackHit's is freed
- fNRecTracks = 0;
- AliMUONTrackK a(this, fHitsForRecPtr); // bad idea ???
+ AliMUONTrackK a(this, fHitsForRecPtr);
// Loop over stations(1...) 5 and 4
for (istat=4; istat>=3; istat--) {
// Loop over segments in the station
// Print hits
trackK = (AliMUONTrackK*) ((*fRecTracksPtr)[0]);
+
if (trackK->DebugLevel() > 0) {
for (Int_t i1=0; i1<fNHitsForRec; i1++) {
hit = (AliMUONHitForRec*) ((*fHitsForRecPtr)[i1]);
- //if (hit->GetTTRTrack() > 1 || hit->GetTrackRefSignal() == 0) continue;
printf(" Hit # %d %10.4f %10.4f %10.4f",
hit->GetChamberNumber(), hit->GetBendingCoor(),
hit->GetNonBendingCoor(), hit->GetZ());
- if (fRecTrackRefHits) {
- // from track ref hits
- printf(" %3d %3d \n", hit->GetTrackRefSignal(), hit->GetTTRTrack());
- } else {
- // from raw clusters
- rawclusters = fMUONData->RawClusters(hit->GetChamberNumber());
- clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->
- GetHitNumber());
- printf(" %d", clus->GetTrack(1));
- if (clus->GetTrack(2) != -1) printf(" %d \n", clus->GetTrack(2));
- else printf("\n");
- } // if (fRecTrackRefHits)
+
+ // from raw clusters
+ rawclusters = fMUONData->RawClusters(hit->GetChamberNumber());
+ clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->
+ GetHitNumber());
+ printf(" %d", clus->GetTrack(1));
+ if (clus->GetTrack(2) != -1) printf(" %d \n", clus->GetTrack(2));
+ else printf("\n");
+
}
} // if (trackK->DebugLevel() > 0)
*/
ok = kTRUE;
- if (trackK->GetRecover() == 0) hit = (AliMUONHitForRec*)
- trackK->GetHitOnTrack()->Last(); // last hit
- //else hit = (AliMUONHitForRec*) (*trackK->GetHitOnTrack())[1]; // 2'nd hit
- else hit = trackK->GetHitLastOk(); // hit where track stopped
+ if (trackK->GetRecover() == 0)
+ hit = (AliMUONHitForRec*) trackK->GetTrackHits()->Last(); // last hit
+ else
+ hit = trackK->GetHitLastOk(); // hit where track stopped
+
if (hit) ichamBeg = hit->GetChamberNumber();
ichamEnd = 0;
// Check propagation direction
chamBits = 0;
Double_t chi2max = 0;
for (Int_t i=0; i<trackK->GetNTrackHits(); i++) {
- hit = (AliMUONHitForRec*) (*trackK->GetHitOnTrack())[i];
+ hit = (AliMUONHitForRec*) (*trackK->GetTrackHits())[i];
chamBits |= BIT(hit->GetChamberNumber());
if (trackK->GetChi2PerPoint(i) > chi2max) chi2max = trackK->GetChi2PerPoint(i);
}
AliMUONHitForRec *hit1, *hit2, *hit;
track1 = (AliMUONTrackK*) ((*fRecTracksPtr)[icand]);
- hit1 = (AliMUONHitForRec*) (*track1->GetHitOnTrack())[0]; // 1'st hit
- hit2 = (AliMUONHitForRec*) (*track1->GetHitOnTrack())[1]; // 2'nd hit
+ hit1 = (AliMUONHitForRec*) (*track1->GetTrackHits())[0]; // 1'st hit
+ hit2 = (AliMUONHitForRec*) (*track1->GetTrackHits())[1]; // 2'nd hit
for (Int_t i=0; i<icand; i++) {
track2 = (AliMUONTrackK*) ((*fRecTracksPtr)[i]);
} else {
Int_t nSame = 0;
for (Int_t j=0; j<track2->GetNTrackHits(); j++) {
- hit = (AliMUONHitForRec*) (*track2->GetHitOnTrack())[j];
+ hit = (AliMUONHitForRec*) (*track2->GetTrackHits())[j];
if (hit == hit1 || hit == hit2) {
nSame++;
if (nSame == 2) return kFALSE;
fRecTracksPtr = new TClonesArray("AliMUONTrackK", 10);
if (fTrackMethod == 2) cout << " *** Tracking with the Kalman filter *** " << endl;
else cout << " *** Combined cluster / track finder ***" << endl;
- } else cout << " *** Traditional tracking *** " << endl;
+ } else cout << " *** Original tracking *** " << endl;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff