New macro "MUONTracker" to make track reconstruction from reference tracks.
authorcussonno <cussonno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 29 Oct 2004 07:49:31 +0000 (07:49 +0000)
committercussonno <cussonno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 29 Oct 2004 07:49:31 +0000 (07:49 +0000)
13 files changed:
MUON/AliMUONConstants.cxx
MUON/AliMUONConstants.h
MUON/AliMUONEventReconstructor.cxx
MUON/AliMUONEventReconstructor.h
MUON/AliMUONHitForRec.cxx
MUON/AliMUONHitForRec.h
MUON/AliMUONRecoCheck.cxx
MUON/AliMUONRecoCheck.h
MUON/AliMUONRecoEvent.cxx
MUON/AliMUONTrack.cxx
MUON/AliMUONTrackK.cxx
MUON/MUONTracker.C [new file with mode: 0644]
MUON/README

index b789ff2..b50e3e6 100644 (file)
@@ -15,6 +15,7 @@
 
 /* $Id$ */
 
+#include <TMath.h>
 #include "AliMUONConstants.h"
 
 ClassImp(AliMUONConstants)
@@ -55,4 +56,22 @@ Int_t AliMUONConstants::GetFirstDetElemId(Int_t chamberId)
 // ---
 
   return (chamberId+1)*100;
-}  
+} 
+//_____________________________________________________________________________
+Int_t AliMUONConstants::ChamberNumber(Float_t z) 
+{
+  // return chamber number according z position of hit. Should be taken from geometry ?
+  Float_t dMaxChamber = DzSlat() + DzCh() + 0.25; // cm st 3 &4 & 5
+  if ( z >  (DefaultChamberZ(4)+50.)) dMaxChamber = 7.; // cm stations 1 & 2
+  Int_t iChamber;
+
+  for (iChamber = 0; iChamber < 10; iChamber++) {
+    
+    if (TMath::Abs(z-DefaultChamberZ(iChamber)) < dMaxChamber) {
+      return iChamber;
+    }
+  }
+  return -1;
+}
index 1af0eb3..104a476 100644 (file)
@@ -39,6 +39,8 @@ class AliMUONConstants : public TObject {
     static  Int_t GetChamberId(Int_t detElemId); 
     static  Int_t GetFirstDetElemId(Int_t chamberId); 
 
+    static  Int_t ChamberNumber(Float_t z); 
+
  protected:
     AliMUONConstants() : TObject() {}
     virtual ~AliMUONConstants(){}
index 06202b7..8ecd49a 100644 (file)
@@ -40,6 +40,7 @@
 
 #include "AliMUONEventReconstructor.h"
 #include "AliMUON.h"
+#include "AliMUONConstants.h"
 #include "AliMUONHit.h"
 #include "AliMUONHitForRec.h"
 #include "AliMUONTriggerTrack.h"
@@ -58,6 +59,7 @@
 #include "AliMUONTrackK.h" //AZ
 #include "AliMC.h"
 #include "AliLog.h"
+#include "AliTrackReference.h"
 
 //************* Defaults parameters for reconstruction
 const Double_t AliMUONEventReconstructor::fgkDefaultMinBendingMomentum = 3.0;
@@ -76,7 +78,7 @@ const Double_t AliMUONEventReconstructor::fgkDefaultChamberThicknessInX0 = 0.03;
 const Double_t AliMUONEventReconstructor::fgkDefaultSimpleBValue = 7.0;
 const Double_t AliMUONEventReconstructor::fgkDefaultSimpleBLength = 428.0;
 const Double_t AliMUONEventReconstructor::fgkDefaultSimpleBPosition = 1019.0;
-const Int_t    AliMUONEventReconstructor::fgkDefaultRecGeantHits = 0;
+const Int_t    AliMUONEventReconstructor::fgkDefaultRecTrackRefHits = 0;
 const Double_t AliMUONEventReconstructor::fgkDefaultEfficiency = 0.95;
 
 const Int_t    AliMUONEventReconstructor::fgkDefaultPrintLevel = -1;
@@ -129,13 +131,12 @@ AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
     cout << endl;
   }
   
-  // Initializions for GEANT background events
-  fBkgGeantFile = 0;
-  fBkgGeantTK = 0;
-  fBkgGeantParticles = 0;
-  fBkgGeantTH = 0;
-  fBkgGeantHits = 0;
-  fBkgGeantEventNumber = -1;
+  // Initializions for track ref. background events
+  fBkgTrackRefFile = 0;
+  fBkgTrackRefTK = 0;
+  fBkgTrackRefParticles = 0;
+  fBkgTrackRefTTR = 0;
+  fBkgTrackRefEventNumber = -1;
   
   // Initialize to 0 pointers to RecoEvent, tree and tree file
   fRecoEvent = 0;
@@ -245,7 +246,7 @@ void AliMUONEventReconstructor::SetReconstructionParametersToDefaults(void)
   fSimpleBValue = fgkDefaultSimpleBValue;
   fSimpleBLength = fgkDefaultSimpleBLength;
   fSimpleBPosition = fgkDefaultSimpleBPosition;
-  fRecGeantHits = fgkDefaultRecGeantHits;
+  fRecTrackRefHits = fgkDefaultRecTrackRefHits;
   fEfficiency = fgkDefaultEfficiency;
   fPrintLevel = fgkDefaultPrintLevel;
   return;
@@ -274,33 +275,32 @@ Double_t AliMUONEventReconstructor::GetBendingMomentumFromImpactParam(Double_t I
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::SetBkgGeantFile(Text_t *BkgGeantFileName)
+void AliMUONEventReconstructor::SetBkgTrackRefFile(Text_t *BkgTrackRefFileName)
 {
-  // Set background file ... for GEANT hits
+  // Set background file ... for track ref. hits
   // Must be called after having loaded the firts signal event
   if (fPrintLevel >= 0) {
-    cout << "Enter SetBkgGeantFile with BkgGeantFileName ``"
-        << BkgGeantFileName << "''" << endl;}
-  if (strlen(BkgGeantFileName)) {
-    // BkgGeantFileName not empty: try to open the file
+    cout << "Enter SetBkgTrackRefFile with BkgTrackRefFileName ``"
+        << BkgTrackRefFileName << "''" << endl;}
+  if (strlen(BkgTrackRefFileName)) {
+    // BkgTrackRefFileName not empty: try to open the file
     if (fPrintLevel >= 2) {cout << "Before File(Bkg)" << endl; gDirectory->Dump();}
-    fBkgGeantFile = new TFile(BkgGeantFileName);
+    fBkgTrackRefFile = new TFile(BkgTrackRefFileName);
     if (fPrintLevel >= 2) {cout << "After File(Bkg)" << endl; gDirectory->Dump();}
-    if (fBkgGeantFile-> IsOpen()) {
+    if (fBkgTrackRefFile-> IsOpen()) {
       if (fPrintLevel >= 0) {
-       cout << "Background for GEANT hits in file: ``" << BkgGeantFileName
+       cout << "Background for Track ref. hits in file: ``" << BkgTrackRefFileName
             << "'' successfully opened" << endl;}
     }
     else {
-      cout << "Background for GEANT hits in file: " << BkgGeantFileName << endl;
+      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"
-    fBkgGeantParticles = new TClonesArray("TParticle", 200);
-    fBkgGeantHits = new TClonesArray("AliMUONHit", 2000);
+    fBkgTrackRefParticles = new TClonesArray("TParticle", 200);
     // Event number to -1 for initialization
-    fBkgGeantEventNumber = -1;
+    fBkgTrackRefEventNumber = -1;
     // Back to the signal file:
     // first signal event must have been loaded previously,
     // otherwise, Segmentation violation at the next instruction
@@ -312,59 +312,53 @@ void AliMUONEventReconstructor::SetBkgGeantFile(Text_t *BkgGeantFileName)
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::NextBkgGeantEvent(void)
+void AliMUONEventReconstructor::NextBkgTrackRefEvent(void)
 {
-  // Get next event in background file for GEANT hits
+  // 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];
-  TBranch *branch;
   if (fPrintLevel >= 0) {
-    cout << "Enter NextBkgGeantEvent" << endl;}
+    cout << "Enter NextBkgTrackRefEvent" << endl;}
   // Clean previous event
-  if(fBkgGeantTK) delete fBkgGeantTK;
-  fBkgGeantTK = NULL;
-  if(fBkgGeantParticles) fBkgGeantParticles->Clear();
-  if(fBkgGeantTH) delete fBkgGeantTH;
-  fBkgGeantTH = NULL;
-  if(fBkgGeantHits) fBkgGeantHits->Clear();
+  if(fBkgTrackRefTK) delete fBkgTrackRefTK;
+  fBkgTrackRefTK = NULL;
+  if(fBkgTrackRefParticles) fBkgTrackRefParticles->Clear();
+  if(fBkgTrackRefTTR) delete fBkgTrackRefTTR;
+  fBkgTrackRefTTR = NULL;
   // Increment event number
-  fBkgGeantEventNumber++;
+  fBkgTrackRefEventNumber++;
   // Get access to Particles and Hits for event from background file
   if (fPrintLevel >= 2) {cout << "Before cd(Bkg)" << endl; gDirectory->Dump();}
-  fBkgGeantFile->cd();
+  fBkgTrackRefFile->cd();
   if (fPrintLevel >= 2) {cout << "After cd(Bkg)" << endl; gDirectory->Dump();}
   // Particles: TreeK for event and branch "Particles"
-  sprintf(treeName, "TreeK%d", fBkgGeantEventNumber);
-  fBkgGeantTK = (TTree*)gDirectory->Get(treeName);
-  if (!fBkgGeantTK) {
+  sprintf(treeName, "TreeK%d", fBkgTrackRefEventNumber);
+  fBkgTrackRefTK = (TTree*)gDirectory->Get(treeName);
+  if (!fBkgTrackRefTK) {
     if (fPrintLevel >= 0) {
       cout << "Cannot find Kine Tree for background event: " <<
-       fBkgGeantEventNumber << endl;
+       fBkgTrackRefEventNumber << endl;
       cout << "Goes back to event 0" << endl;
     }
-    fBkgGeantEventNumber = 0;
-    sprintf(treeName, "TreeK%d", fBkgGeantEventNumber);
-    fBkgGeantTK = (TTree*)gDirectory->Get(treeName);
-    if (!fBkgGeantTK) {
-               AliError(Form("cannot find Kine Tree for background event: %d",fBkgGeantEventNumber));
+    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 (fBkgGeantTK) 
-    fBkgGeantTK->SetBranchAddress("Particles", &fBkgGeantParticles);
-  fBkgGeantTK->GetEvent(0); // why event 0 ???? necessary ????
+  if (fBkgTrackRefTK) 
+    fBkgTrackRefTK->SetBranchAddress("Particles", &fBkgTrackRefParticles);
+  fBkgTrackRefTK->GetEvent(0); // why event 0 ???? necessary ????
   // Hits: TreeH for event and branch "MUON"
-  sprintf(treeName, "TreeH%d", fBkgGeantEventNumber);
-  fBkgGeantTH = (TTree*)gDirectory->Get(treeName);
-  if (!fBkgGeantTH) {
-         AliError(Form("cannot find Hits Tree for background event: %d",fBkgGeantEventNumber));
+  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);
   }
-  if (fBkgGeantTH && fBkgGeantHits) {
-    branch = fBkgGeantTH->GetBranch("MUON");
-    if (branch) branch->SetAddress(&fBkgGeantHits);
-  }
-  fBkgGeantTH->GetEntries(); // necessary ????
+  fBkgTrackRefTTR->GetEntries(); // necessary ????
   // Back to the signal file
   ((gAlice->TreeK())->GetCurrentFile())->cd();
   if (fPrintLevel >= 2) {cout << "After cd(gAlice)" << endl; gDirectory->Dump();}
@@ -460,7 +454,7 @@ void AliMUONEventReconstructor::ResetTrackHits(void)
 void AliMUONEventReconstructor::MakeEventToBeReconstructed(void)
 {
   // To make the list of hits to be reconstructed,
-  // either from the GEANT hits or from the raw clusters
+  // 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
   
@@ -478,33 +472,34 @@ void AliMUONEventReconstructor::MakeEventToBeReconstructed(void)
 //      Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
 //      return;
 //    }
-  
+  AliRunLoader *runLoader = fLoader->GetRunLoader();
+
   if (fPrintLevel >= 1) cout << "enter MakeEventToBeReconstructed" << endl;
   ResetHitsForRec();
-  if (fRecGeantHits == 1) {
-    // Reconstruction from GEANT hits
+  if (fRecTrackRefHits == 1) {
+    // Reconstruction from track ref. hits
     // Back to the signal file
-      TTree* treeH = fLoader->TreeH();
-      if (treeH == 0x0)
-       {
-         Int_t retval = fLoader->LoadHits();
-         if ( retval)
+    TTree* treeTR = runLoader->TreeTR();
+    if (treeTR == 0x0)
+      {
+       Int_t retval = runLoader->LoadTrackRefs("READ");
+       if ( retval)
           {
             AliError("Error occured while loading hits.");
             return;
           }
-         treeH = fLoader->TreeH();
-         if (treeH == 0x0)
+       treeTR = runLoader->TreeTR();
+       if (treeTR == 0x0)
           {
-           AliError("Can not get TreeH");
-           return;
+           AliError("Can not get TreeTR");
+           return;
           }
-       }
-      fMUONData->SetTreeAddress("H");
-      AddHitsForRecFromGEANT(treeH);
+      }
+    
+    AddHitsForRecFromTrackRef(treeTR,1);
     
     // Background hits
-    AddHitsForRecFromBkgGEANT(fBkgGeantTH, fBkgGeantHits);
+    AddHitsForRecFromTrackRef(fBkgTrackRefTTR,0);
     // Sort HitsForRec in increasing order with respect to chamber number
     SortHitsForRecWithIncreasingChamber();
   }
@@ -539,83 +534,43 @@ void AliMUONEventReconstructor::MakeEventToBeReconstructed(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::AddHitsForRecFromGEANT(TTree *TH)
+void AliMUONEventReconstructor::AddHitsForRecFromTrackRef(TTree *TTR, Int_t signal)
 {
   // To add to the list of hits for reconstruction
-  // the GEANT signal hits from a hit tree TH.
-  Int_t hitBits, chamBits; //AZ
-  if (fPrintLevel >= 2)
-    cout << "enter AddHitsForRecFromGEANT with TH: " << TH << endl;
-  if (TH == NULL) return;
-  //  AliMUON *pMUON  = (AliMUON*) gAlice->GetModule("MUON"); // necessary ????
-  //AliMUONData * muondata = pMUON->GetMUONData();
-  // Security on MUON ????
-  // See whether it could be the same for signal and background ????
-  // Loop over tracks in tree
-  Int_t ntracks = (Int_t) TH->GetEntries();
+  // the signal hits from a track reference tree TreeTR.
+  TClonesArray *listOfTrackRefs = NULL;
+  AliTrackReference *trackRef;
+  
+  Int_t track = 0;
   if (fPrintLevel >= 2)
-    cout << "ntracks: " << ntracks << endl;
-  fMuons = 0; //AZ
-  for (Int_t track = 0; track < ntracks; track++) {
-    fMUONData->ResetHits();
-    TH->GetEvent(track);
-    // Loop over hits
-    Int_t hit = 0;
-    hitBits = 0; // AZ
-    chamBits = 0; // AZ
-    Int_t itrack = track; //AZ
-
-    Int_t ihit, nhits=0;
-      nhits = (Int_t) fMUONData->Hits()->GetEntriesFast();
-      AliMUONHit* mHit=0x0;
-
-      for(ihit=0; ihit<nhits; ihit++) {
-       mHit = static_cast<AliMUONHit*>(fMUONData->Hits()->At(ihit));
-       Int_t ipart = TMath::Abs ((Int_t) mHit->Particle()); //AZ
-       if (NewHitForRecFromGEANT(mHit,track, hit, 1) && ipart == 13
-           //if (NewHitForRecFromGEANT(mHit,itrack-1, hit, 1) && ipart == 13 
-           && itrack <= 2 && !BIT(mHit->Chamber()-1)  ) chamBits |= BIT(mHit->Chamber()-1); //AZ - set bit
-      }
+    cout << "enter AddHitsForRecFromTrackRef with TTR: " << TTR << endl;
+  if (TTR == NULL) return;
+  
+  listOfTrackRefs = CleanTrackRefs(TTR);
 
-    if (chamBits&3 && chamBits>>2&3 && chamBits>>4&3 && chamBits>>6&3 && 
-        chamBits>>8&3 && ((chamBits>>6&3)==3 || (chamBits>>8&3)==3)) 
-      fMuons += 1; //AZ
-    //if (chamBits&3 && chamBits>>2&3 && chamBits>>4&3 && chamBits>>6&3 && 
-    //      chamBits>>8&3 && ((chamBits>>6&3)==3 || (chamBits>>8&3)==3) && 
-    //      ((chamBits&3)==3 || (chamBits>>2&3)==3)) fMuons += 1;
-  } // end of track loop
-  return;
-}
+  Int_t ntracks = listOfTrackRefs->GetEntriesFast();
 
-  //__________________________________________________________________________
-void AliMUONEventReconstructor::AddHitsForRecFromBkgGEANT(TTree *TH, TClonesArray *Hits)
-{
-  // To add to the list of hits for reconstruction
-  // the GEANT background hits from a hit tree TH and a pointer Hits to a hit list.
-  // How to have only one function "AddHitsForRecFromGEANT" ????
-  if (fPrintLevel >= 2)
-    cout << "enter AddHitsForRecFromBkgGEANT with TH: " << TH << endl;
-  if (TH == NULL) return;
-  // Loop over tracks in tree
-  Int_t ntracks = (Int_t) TH->GetEntries();
   if (fPrintLevel >= 2)
     cout << "ntracks: " << ntracks << endl;
-  for (Int_t track = 0; track < ntracks; track++) {
-    if (Hits) Hits->Clear();
-    TH->GetEvent(track);
-    // Loop over hits
-    for (Int_t hit = 0; hit < Hits->GetEntriesFast(); hit++) {
-      NewHitForRecFromGEANT((AliMUONHit*) (*Hits)[hit], track, hit, 0);
-    } // end of hit loop
-  } // end of track loop
+
+  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* AliMUONEventReconstructor::NewHitForRecFromGEANT(AliMUONHit* Hit, Int_t TrackNumber, Int_t HitNumber, Int_t Signal)
+AliMUONHitForRec* AliMUONEventReconstructor::NewHitForRecFromTrackRef(AliTrackReference* Hit, Int_t TrackNumber, Int_t Signal)
 {
-  // To make a new hit for reconstruction from a GEANT hit pointed to by "Hit",
-  // with hit number "HitNumber" in the track numbered "TrackNumber",
+  // 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)
@@ -628,7 +583,8 @@ AliMUONHitForRec* AliMUONEventReconstructor::NewHitForRecFromGEANT(AliMUONHit* H
   // like in Fortran TRACKF_STAT.
   AliMUONHitForRec* hitForRec;
   Double_t bendCoor, nonBendCoor, radius;
-  Int_t chamber = Hit->Chamber() - 1; // chamber(0...)
+  Int_t chamber = AliMUONConstants::ChamberNumber(Hit->Z()); // chamber(0...)
+  if (chamber < 0) return NULL;
   // only in tracking chambers (fChamber starts at 1)
   if (chamber >= fgkMaxMuonTrackingChambers) return NULL;
   // only if hit is efficient (keep track for checking ????)
@@ -639,7 +595,7 @@ AliMUONHitForRec* AliMUONEventReconstructor::NewHitForRecFromGEANT(AliMUONHit* H
   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 GEANT hit and increment number of AliMUONHitForRec's
+  // new AliMUONHitForRec from track ref. hit and increment number of AliMUONHitForRec's
   hitForRec = new ((*fHitsForRecPtr)[fNHitsForRec]) AliMUONHitForRec(Hit);
   fNHitsForRec++;
   // add smearing from resolution
@@ -653,18 +609,100 @@ AliMUONHitForRec* AliMUONEventReconstructor::NewHitForRecFromGEANT(AliMUONHit* H
   //  resolution: angular effect to be added here ????
   hitForRec->SetBendingReso2(fBendingResolution * fBendingResolution);
   hitForRec->SetNonBendingReso2(fNonBendingResolution * fNonBendingResolution);
-  //  GEANT track info
-  hitForRec->SetHitNumber(HitNumber);
-  hitForRec->SetTHTrack(TrackNumber);
-  hitForRec->SetGeantSignal(Signal);
+  //   track ref. info
+  hitForRec->SetTTRTrack(TrackNumber);
+  hitForRec->SetTrackRefSignal(Signal);
   if (fPrintLevel >= 10) {
-    cout << "track: " << TrackNumber << " hit: " << HitNumber << endl;
+    cout << "track: " << TrackNumber << endl;
     Hit->Dump();
     cout << "AliMUONHitForRec number (1...): " << fNHitsForRec << endl;
     hitForRec->Dump();}
   return hitForRec;
 }
-
+  //__________________________________________________________________________
+TClonesArray* AliMUONEventReconstructor::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 AliMUONEventReconstructor::SortHitsForRecWithIncreasingChamber()
 {
@@ -730,7 +768,7 @@ void AliMUONEventReconstructor::SortHitsForRecWithIncreasingChamber()
 //       // more information into HitForRec
 //       hitForRec->SetChamberNumber(ch);
 //       hitForRec->SetHitNumber(cor);
-//       // Z coordinate of the chamber (cm) with sign opposite to GEANT sign
+//       // Z coordinate of the chamber (cm) with sign opposite to TRACKREF sign
 //       // could (should) be more exact from chamber geometry ???? 
 //       hitForRec->SetZ(-(&(MUON->Chamber(ch)))->Z());
 //       if (fPrintLevel >= 10) {
@@ -1764,13 +1802,13 @@ void AliMUONEventReconstructor::FollowTracksK(void)
   if (trackK->DebugLevel() > 0) {
     for (Int_t i1=0; i1<fNHitsForRec; i1++) {
       hit = (AliMUONHitForRec*) ((*fHitsForRecPtr)[i1]);
-      //if (hit->GetTHTrack() > 1 || hit->GetGeantSignal() == 0) continue;
+      //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 (fRecGeantHits) {
-        // from GEANT hits
-       printf(" %3d %3d \n", hit->GetGeantSignal(), hit->GetTHTrack());
+      if (fRecTrackRefHits) {
+        // from track ref hits
+       printf(" %3d %3d \n", hit->GetTrackRefSignal(), hit->GetTTRTrack());
       } else {
        // from raw clusters
        rawclusters = fMUONData->RawClusters(hit->GetChamberNumber());
@@ -1779,7 +1817,7 @@ void AliMUONEventReconstructor::FollowTracksK(void)
        printf("%3d", clus->GetTrack(1)-1);
        if (clus->GetTrack(2) != 0) printf("%3d \n", clus->GetTrack(2)-1);
        else printf("\n");
-      } // if (fRecGeantHits)
+      } // if (fRecTrackRefHits)
     }
   } // if (trackK->DebugLevel() > 0)
 
index c357988..48dbae0 100644 (file)
@@ -22,6 +22,7 @@ class AliMUONRecoEvent;
 class AliMUONData;
 class AliRunLoader;
 class AliLoader;
+class AliTrackReference;
 
 class AliMUONEventReconstructor : public TObject {
 
@@ -51,18 +52,18 @@ class AliMUONEventReconstructor : public TObject {
   void SetSimpleBLength(Double_t SimpleBLength) {fSimpleBLength = SimpleBLength;}
   Double_t GetSimpleBPosition(void) const {return fSimpleBPosition;}
   void SetSimpleBPosition(Double_t SimpleBPosition) {fSimpleBPosition = SimpleBPosition;}
-  Int_t GetRecGeantHits(void) const {return fRecGeantHits;}
-  void SetRecGeantHits(Int_t RecGeantHits) {fRecGeantHits = RecGeantHits;}
+  Int_t GetRecTrackRefHits(void) const {return fRecTrackRefHits;}
+  void SetRecTrackRefHits(Int_t RecTrackRefHits) {fRecTrackRefHits = RecTrackRefHits;}
   Double_t GetEfficiency(void) const {return fEfficiency;}
   void SetEfficiency(Double_t Efficiency) {fEfficiency = Efficiency;}
   Int_t GetPrintLevel(void) const {return fPrintLevel;}
   void SetPrintLevel(Int_t PrintLevel) {fPrintLevel = PrintLevel;}
   void SetReconstructionParametersToDefaults(void);
 
-  // Parameters for GEANT background events
-  TFile* GetBkgGeantFile(void) const {return fBkgGeantFile;}
-  void SetBkgGeantFile(Text_t *BkgGeantFileName); // set background file for GEANT hits
-  void NextBkgGeantEvent(void); // next event in background file for GEANT hits
+  // Parameters for Track Ref. background events
+  TFile* GetBkgTrackRefFile(void) const {return fBkgTrackRefFile;}
+  void SetBkgTrackRefFile(Text_t *BkgTrackRefFileName); // set background file for track ref. hits
+  void NextBkgTrackRefEvent(void); // next event in background file for track ref. hits
 
   // Hits for reconstruction
   Int_t GetNHitsForRec(void) const {return fNHitsForRec;} // Number
@@ -124,8 +125,8 @@ class AliMUONEventReconstructor : public TObject {
   static const Double_t fgkDefaultSimpleBValue; // default value of magnetic field (dipole)
   static const Double_t fgkDefaultSimpleBLength; // default length of magnetic field (dipole)
   static const Double_t fgkDefaultSimpleBPosition; // default position of magnetic field (dipole)
-  static const Int_t fgkDefaultRecGeantHits; // default flag for reconstrution GEANT hits or Clusters
-  static const Double_t fgkDefaultEfficiency; // default chamber efficiency for GEANT hits recontruction
+  static const Int_t fgkDefaultRecTrackRefHits; // default flag for reconstrution track ref. hits or Clusters
+  static const Double_t fgkDefaultEfficiency; // default chamber efficiency for track ref. hits recontruction
 
   static const Int_t fgkDefaultPrintLevel; // default print level
 
@@ -148,18 +149,17 @@ class AliMUONEventReconstructor : public TObject {
   Double_t fSimpleBValue; // simple magnetic field: value (kG)
   Double_t fSimpleBLength; // simple magnetic field: length (cm)
   Double_t fSimpleBPosition; // simple magnetic field: Z central position (cm)
-  Int_t fRecGeantHits; // reconstruction from raw clusters (0) or from GEANT hits (1)
-  Double_t fEfficiency; // chamber efficiency (used for GEANT hits only)
+  Int_t fRecTrackRefHits; // reconstruction from raw clusters (0) or from track ref. hits (1)
+  Double_t fEfficiency; // chamber efficiency (used for track ref. hits only)
   Int_t fPrintLevel; // print level
 
-  // Parameters for GEANT background events
+  // Parameters for track ref. background events
   // should be in AliMUON class ????
-  TFile *fBkgGeantFile; // pointer to file
-  TTree *fBkgGeantTK; // pointer to tree TK
-  TClonesArray *fBkgGeantParticles;   // pointer to list of particles in tree TK
-  TTree *fBkgGeantTH; // pointer to tree TH
-  TClonesArray *fBkgGeantHits; // pointer to list of hits in tree TH
-  Int_t fBkgGeantEventNumber; // event number
+  TFile *fBkgTrackRefFile; // pointer to file
+  TTree *fBkgTrackRefTK; // pointer to tree TK
+  TClonesArray *fBkgTrackRefParticles;   // pointer to list of particles in tree TK
+  TTree *fBkgTrackRefTTR; // pointer to tree TTR
+  Int_t fBkgTrackRefEventNumber; // event number
   
   // Hits for reconstruction (should be in AliMUON ????)
   TClonesArray *fHitsForRecPtr; // pointer to the array of hits for reconstruction
@@ -200,9 +200,9 @@ class AliMUONEventReconstructor : public TObject {
   // Functions
   void ResetHitsForRec(void);
   void MakeEventToBeReconstructed(void);
-  void AddHitsForRecFromGEANT(TTree *TH);
-  void AddHitsForRecFromBkgGEANT(TTree *TH, TClonesArray *Hits);
-  AliMUONHitForRec* NewHitForRecFromGEANT(AliMUONHit* Hit, Int_t TrackNumber, Int_t HitNumber, Int_t Signal);
+  void AddHitsForRecFromTrackRef(TTree *TTR, Int_t Signal);
+  AliMUONHitForRec* NewHitForRecFromTrackRef(AliTrackReference* Hit, Int_t TrackNumber, Int_t Signal);
+  TClonesArray *CleanTrackRefs(TTree *treeTR);
 /*   void AddHitsForRecFromCathodeCorrelations(TTree* TC); */
   void AddHitsForRecFromRawClusters(TTree* TR);
   void SortHitsForRecWithIncreasingChamber();
@@ -231,6 +231,7 @@ class AliMUONEventReconstructor : public TObject {
   void GoToVertex(void);
   Bool_t CheckCandidateK(Int_t icand, Int_t nSeeds) const;
 
+
   ClassDef(AliMUONEventReconstructor, 0) // MUON event reconstructor in ALICE
     };
        
index 528ad4a..9ebb718 100644 (file)
 // Hit for reconstruction in ALICE dimuon spectrometer
 //__________________________________________________________________________
 
+#include "AliTrackReference.h" 
 #include "AliMUONHitForRec.h" 
 #include "AliMUONRawCluster.h"
 #include "AliMUONHit.h"
+#include "AliMUONConstants.h"
 #include "AliLog.h"
 
 ClassImp(AliMUONHitForRec) // Class implementation in ROOT context
@@ -38,21 +40,21 @@ AliMUONHitForRec::AliMUONHitForRec()
 }
 
   //__________________________________________________________________________
-AliMUONHitForRec::AliMUONHitForRec(AliMUONHit* theGhit)
+AliMUONHitForRec::AliMUONHitForRec(AliTrackReference* theGhit)
   : TObject()
 {
-  // Constructor for AliMUONHitForRec from a GEANT hit.
+  // Constructor for AliMUONHitForRec from a track ref. hit.
   // Fills the bending, non bending, and Z coordinates,
-  // which are taken from the coordinates of the GEANT hit,
-  // the track number (GEANT and not TH),
+  // which are taken from the coordinates of the track ref. hit,
+  // the track number (track ref. and not TH),
   // and the chamber number (0...).
   fBendingCoor = theGhit->Y();
   fNonBendingCoor = theGhit->X();
   fZ = theGhit->Z();
   // fTrack = theGhit->fTrack; ?????????
-  fChamberNumber = theGhit->Chamber() - 1;
+  fChamberNumber = AliMUONConstants::ChamberNumber(fZ);
   // other fields will be updated in
-  // AliMUONEventReconstructor::NewHitForRecFromGEANT,
+  // AliMUONEventReconstructor::NewHitForRecFromTrackRef,
   // except the following ones
   fIndexOfFirstSegment = -1;
   fNSegments = 0;
@@ -88,8 +90,8 @@ AliMUONHitForRec::AliMUONHitForRec(AliMUONRawCluster* theRawCluster)
   // other fields will be updated in
   // AliMUONEventReconstructor::AddHitsForRecFromRawClusters,
   // except the following ones
-  fTHTrack = -1;
-  fGeantSignal = -1;
+  fTTRTrack = -1;
+  fTrackRefSignal = -1;
   fIndexOfFirstSegment = -1;
   fNSegments = 0;
   fFirstTrackHitPtr = fLastTrackHitPtr = NULL;
@@ -108,8 +110,8 @@ AliMUONHitForRec::AliMUONHitForRec (const AliMUONHitForRec& theMUONHitForRec)
   fNonBendingReso2 = theMUONHitForRec.fNonBendingReso2;
   fChamberNumber = theMUONHitForRec.fChamberNumber;
   fHitNumber = theMUONHitForRec.fHitNumber;
-  fTHTrack = theMUONHitForRec.fTHTrack;
-  fGeantSignal = theMUONHitForRec.fGeantSignal;
+  fTTRTrack = theMUONHitForRec.fTTRTrack;
+  fTrackRefSignal = theMUONHitForRec.fTrackRefSignal;
   fIndexOfFirstSegment = theMUONHitForRec.fIndexOfFirstSegment;
   fNSegments = theMUONHitForRec.fNSegments;
   fFirstTrackHitPtr = theMUONHitForRec.fFirstTrackHitPtr;
@@ -128,8 +130,8 @@ AliMUONHitForRec & AliMUONHitForRec::operator=(const AliMUONHitForRec& theMUONHi
   fNonBendingReso2 = theMUONHitForRec.fNonBendingReso2;
   fChamberNumber = theMUONHitForRec.fChamberNumber;
   fHitNumber = theMUONHitForRec.fHitNumber;
-  fTHTrack = theMUONHitForRec.fTHTrack;
-  fGeantSignal = theMUONHitForRec.fGeantSignal;
+  fTTRTrack = theMUONHitForRec.fTTRTrack;
+  fTrackRefSignal = theMUONHitForRec.fTrackRefSignal;
   fIndexOfFirstSegment = theMUONHitForRec.fIndexOfFirstSegment;
   fNSegments = theMUONHitForRec.fNSegments;
   fFirstTrackHitPtr = theMUONHitForRec.fFirstTrackHitPtr;
index e412fa7..83a15f9 100644 (file)
@@ -8,7 +8,7 @@
 
 #include <TObject.h>
 
-class AliMUONHit;
+class AliTrackReference;
 class AliMUONRawCluster;
 class AliMUONTrackHit;
 class AliMUONTrackParam;
@@ -19,7 +19,7 @@ class AliMUONHitForRec : public TObject {
   virtual ~AliMUONHitForRec(){} // Destructor
   AliMUONHitForRec (const AliMUONHitForRec& AliMUONHitForRec); // copy constructor
   AliMUONHitForRec& operator=(const AliMUONHitForRec& AliMUONHitForRec); // assignment operator
-  AliMUONHitForRec(AliMUONHit* mHit); // Constructor from GEANT hit
+  AliMUONHitForRec(AliTrackReference* mHit); // Constructor from track ref. hit
   AliMUONHitForRec(AliMUONRawCluster* theRawCluster); // Constructor from raw cluster
 
   // Inline functions for Get and Set
@@ -37,10 +37,10 @@ class AliMUONHitForRec : public TObject {
   void SetChamberNumber(Int_t ChamberNumber) { fChamberNumber = ChamberNumber;}
   Int_t GetHitNumber(void) const { return fHitNumber;}
   void SetHitNumber(Int_t HitNumber) { fHitNumber = HitNumber;}
-  Int_t GetTHTrack(void) const { return fTHTrack;}
-  void SetTHTrack(Int_t THTrack) { fTHTrack = THTrack;}
-  Int_t GetGeantSignal(void) const { return fGeantSignal;}
-  void SetGeantSignal(Int_t GeantSignal) { fGeantSignal = GeantSignal;}
+  Int_t GetTTRTrack(void) const { return fTTRTrack;}
+  void SetTTRTrack(Int_t TTRTrack) { fTTRTrack = TTRTrack;}
+  Int_t GetTrackRefSignal(void) const { return fTrackRefSignal;}
+  void SetTrackRefSignal(Int_t TrackRefSignal) { fTrackRefSignal = TrackRefSignal;}
   Int_t GetIndexOfFirstSegment(void) const { return fIndexOfFirstSegment;}
   void SetIndexOfFirstSegment(Int_t IndexOfFirstSegment) { fIndexOfFirstSegment = IndexOfFirstSegment;}
   Int_t GetNSegments(void) const { return fNSegments;}
@@ -72,9 +72,9 @@ class AliMUONHitForRec : public TObject {
   // ideal would be real link to "hit" or "reconstructed hit"
   // if everything would be in memory ????
   Int_t fChamberNumber; // chamber number (0...)
-  Int_t fHitNumber; // hit number (0...): RawCluster in "chamber" event of TR or GEANT hit in "track" event of TH
-  Int_t fTHTrack; // track number (0...) in TH
-  Int_t fGeantSignal; // Geant signal (1) or background (0)
+  Int_t fHitNumber; // hit number (0...): RawCluster in "chamber" event of TR or track ref. hit in "track" event of TTR
+  Int_t fTTRTrack; // track number (0...) in TTR
+  Int_t fTrackRefSignal; // Track ref. signal (1) or background (0)
 
   // links forward to the segment(s) if HitForRec in first chamber of a station
   Int_t fIndexOfFirstSegment; //! index of first Segment
index 0ed3ef3..3e0444d 100644 (file)
@@ -76,6 +76,7 @@ AliMUONRecoCheck::~AliMUONRecoCheck()
   fRunLoader->UnloadKinematics();
   fRunLoader->UnloadTrackRefs();
   fRunLoader->UnloadTracks();
+  fMuonTrackRef->Delete();
   delete fMuonTrackRef;
   delete fMUONData;
 }
@@ -121,10 +122,10 @@ void AliMUONRecoCheck::MakeTrackRef()
     iHitMin = 0;
     isNewTrack = kTRUE;
     
-    if (!trackRefs->GetEntries()) continue;
-    
-    while (isNewTrack) {
+    if (!trackRefs->GetEntries()) continue; 
 
+    while (isNewTrack) {
+      
       for (Int_t iHit = iHitMin; iHit < trackRefs->GetEntries(); iHit++) {
       
        trackReference = (AliTrackReference*)trackRefs->At(iHit);
@@ -164,7 +165,7 @@ void AliMUONRecoCheck::MakeTrackRef()
        hitForRec->SetZ(z);
        hitForRec->SetBendingReso2(0.0); 
        hitForRec->SetNonBendingReso2(0.0);  
-       iChamber = ChamberNumber(z);
+       iChamber = AliMUONConstants::ChamberNumber(z);
        hitForRec->SetChamberNumber(iChamber);
 
        muonTrack->AddTrackParamAtHit(trackParam);
@@ -216,6 +217,7 @@ void AliMUONRecoCheck::MakeTrackRef()
   delete muonTrack;
   delete trackParam;
   delete hitForRec;
+  trackRefs->Delete();
   delete trackRefs;
 
 }
@@ -225,6 +227,7 @@ TClonesArray* AliMUONRecoCheck::GetTrackReco()
 {
   // Return TClonesArray of reconstructed tracks
 
+  GetMUONData()->ResetRecTracks();
   GetMUONData()->SetTreeAddress("RT");
   fTrackReco = GetMUONData()->RecTracks(); 
   GetMUONData()->GetRecTracks();
@@ -352,7 +355,7 @@ void AliMUONRecoCheck::CleanMuonTrackRef()
       hitForRec->SetNonBendingCoor(xRec);
       hitForRec->SetBendingCoor(yRec);
       hitForRec->SetZ(zRec);
-      iChamber = ChamberNumber(zRec);
+      iChamber = AliMUONConstants::ChamberNumber(zRec);
       hitForRec->SetChamberNumber(iChamber);
       hitForRec->SetBendingReso2(0.0); 
       hitForRec->SetNonBendingReso2(0.0); 
@@ -388,6 +391,7 @@ void AliMUONRecoCheck::CleanMuonTrackRef()
   delete trackNew;
   delete hitForRec;
   delete trackParam;
+  newMuonTrackRef->Delete();
   delete newMuonTrackRef;
   
 }
@@ -427,28 +431,10 @@ void AliMUONRecoCheck::ReconstructibleTracks()
     isTrackOK = kTRUE;
     for (Int_t ch = 0; ch < 10; ch++) {
       if (!isChamberInTrack[ch]) isTrackOK = kFALSE;
-    }
-    if (isTrackOK) fReconstructibleTracks++;
+    }    if (isTrackOK) fReconstructibleTracks++;
     if (!isTrackOK) fMuonTrackRef->Remove(track); // remove non reconstructible tracks
   }
   fMuonTrackRef->Compress();
 }
 
 
-//_____________________________________________________________________________
-Int_t AliMUONRecoCheck::ChamberNumber(Float_t z) const
-{
-  // return chamber number according z position of hit. Should be taken from geometry ?
-  Float_t dMaxChamber =  AliMUONConstants::DzSlat() + AliMUONConstants::DzCh() + 0.25; // cm st 3 &4 & 5
-  if ( z >  (AliMUONConstants::DefaultChamberZ(4)+50.)) dMaxChamber = 7.; // cm stations 1 & 2
-  Int_t iChamber;
-
-  for (iChamber = 0; iChamber < 10; iChamber++) {
-    
-    if (TMath::Abs(z-AliMUONConstants::DefaultChamberZ(iChamber)) < dMaxChamber) {
-      return iChamber;
-    }
-  }
-  return -1;
-}
index 48b6d1f..e2a56df 100644 (file)
@@ -33,7 +33,6 @@ public:
   void CleanMuonTrackRef();
   void ReconstructibleTracks();
   Int_t GetNumberOfReconstuctibleTracks() {return fReconstructibleTracks;}
-  Int_t ChamberNumber(Float_t z) const;
   Int_t GetNumberOfRecoTracks() {return fRecoTracks;}
   TClonesArray *GetTrackReco();
   TClonesArray *GetMuonTrackRef() {return fMuonTrackRef;}
index 430178a..4cd53f2 100644 (file)
@@ -217,15 +217,15 @@ Bool_t AliMUONRecoEvent::MakeDumpTracks(Int_t muons, TClonesArray *tracksPtr,
        Float_t signal = 0;
        Float_t tht = 0;
        for (int ihit = 0; ihit < nTrackHits; ihit++) {
-         signal += ((AliMUONHitForRec*)((*hitsOnTrack)[ihit]))->GetGeantSignal();
-         tht += TMath::Min (1,((AliMUONHitForRec*)((*hitsOnTrack)[ihit]))->GetTHTrack());
+         signal += ((AliMUONHitForRec*)((*hitsOnTrack)[ihit]))->GetTrackRefSignal();
+         tht += TMath::Min (1,((AliMUONHitForRec*)((*hitsOnTrack)[ihit]))->GetTTRTrack());
        }
        signal /= nTrackHits;
        tht /= nTrackHits;
        flag = 0;
        if (TMath::Nint(signal) > 0) { // signal muon
          for (int ihit = 0; ihit < nTrackHits ; ihit++) {
-           if (((AliMUONHitForRec*)((*hitsOnTrack)[ihit]))->GetTHTrack() != TMath::Nint(tht)) flag++;
+           if (((AliMUONHitForRec*)((*hitsOnTrack)[ihit]))->GetTTRTrack() != TMath::Nint(tht)) flag++;
          }
        } else flag = -9; // background track
        //cout << TMath::Nint(signal) << " " << TMath::Nint(tht) << " " << recTrackNt->fFlag << endl;
@@ -259,8 +259,8 @@ Bool_t AliMUONRecoEvent::MakeDumpTracks(Int_t muons, TClonesArray *tracksPtr,
        AliMUONHitForRec *hitForRec = 0;
        for (int ihit = 0; ihit < nTrackHits; ihit++) {
          hitForRec = ((AliMUONTrackHit*)(*hitsOnTrack)[ihit])->GetHitForRecPtr();
-         signal += hitForRec->GetGeantSignal();
-         tht += TMath::Min (1,hitForRec->GetTHTrack());
+         signal += hitForRec->GetTrackRefSignal();
+         tht += TMath::Min (1,hitForRec->GetTTRTrack());
        }
        signal /= nTrackHits;
        tht /= nTrackHits;
@@ -268,7 +268,7 @@ Bool_t AliMUONRecoEvent::MakeDumpTracks(Int_t muons, TClonesArray *tracksPtr,
        if (TMath::Nint(signal) > 0) { // signal muon
          for (int ihit = 0; ihit < nTrackHits ; ihit++) {
            hitForRec = ((AliMUONTrackHit*)(*hitsOnTrack)[ihit])->GetHitForRecPtr();
-           if (hitForRec->GetTHTrack() != TMath::Nint(tht)) flag++;
+           if (hitForRec->GetTTRTrack() != TMath::Nint(tht)) flag++;
          }
        } else flag = -9; // background track
        //cout << TMath::Nint(signal) << " " << TMath::Nint(tht) << " " << recTrackNt->fFlag << endl;
index e6a34af..d490e53 100644 (file)
@@ -123,18 +123,21 @@ AliMUONTrack::~AliMUONTrack()
 {
   // Destructor
   if (fTrackHitsPtr) {
+    fTrackHitsPtr->Clear();
     delete fTrackHitsPtr; // delete the TObjArray of pointers to TrackHit's
     fTrackHitsPtr = NULL;
   }
   
   if (fTrackParamAtHit) {
     // delete the TClonesArray of pointers to TrackParam
+    fTrackParamAtHit->Clear();
     delete fTrackParamAtHit;
     fTrackParamAtHit = NULL;
   }
 
   if (fHitForRecAtHit) {
     // delete the TClonesArray of pointers to HitForRec
+    fHitForRecAtHit->Clear();
     delete fHitForRecAtHit;
     fHitForRecAtHit = NULL;
   }
index 34fb0f2..5f9e4cd 100644 (file)
@@ -218,9 +218,9 @@ AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
 
   if (fgDebug < 0 ) return;
   cout << fgEventReconstructor->GetBendingMomentumFromImpactParam(segment->GetBendingImpact()) << " " << 1/(*fTrackPar)(4,0) << " ";
-  if (fgEventReconstructor->GetRecGeantHits()) { 
-    // from GEANT hits
-    cout << ((AliMUONHitForRec*)((*fTrackHitsPtr)[0]))->GetTHTrack() << "<-->" << ((AliMUONHitForRec*)((*fTrackHitsPtr)[1]))->GetTHTrack() << " @ " << fStartSegment->GetHitForRec1()->GetChamberNumber() << endl;
+  if (fgEventReconstructor->GetRecTrackRefHits()) { 
+    // from track ref. hits
+    cout << ((AliMUONHitForRec*)((*fTrackHitsPtr)[0]))->GetTTRTrack() << "<-->" << ((AliMUONHitForRec*)((*fTrackHitsPtr)[1]))->GetTTRTrack() << " @ " << fStartSegment->GetHitForRec1()->GetChamberNumber() << endl;
   } else {
     // from raw clusters
     for (Int_t i=0; i<2; i++) {
@@ -530,7 +530,7 @@ Bool_t AliMUONTrackK::KalmanFilter(Int_t ichamBeg, Int_t ichamEnd, Bool_t Back,
            cout << ((AliMUONHitForRec*)((*fgHitForRec)[i1]))->GetBendingCoor() << " ";
            cout << ((AliMUONHitForRec*)((*fgHitForRec)[i1]))->GetNonBendingCoor() << " ";
            cout << ((AliMUONHitForRec*)((*fgHitForRec)[i1]))->GetZ() << " " << " ";
-           cout << ((AliMUONHitForRec*)((*fgHitForRec)[i1]))->GetTHTrack() << endl;
+           cout << ((AliMUONHitForRec*)((*fgHitForRec)[i1]))->GetTTRTrack() << endl;
          }
          cout << endl;
          cout << fNTrackHits << endl;
@@ -539,9 +539,9 @@ Bool_t AliMUONTrackK::KalmanFilter(Int_t ichamBeg, Int_t ichamEnd, Bool_t Back,
            printf(" * %d %10.4f %10.4f %10.4f", 
                   hit->GetChamberNumber(), hit->GetBendingCoor(), 
                   hit->GetNonBendingCoor(), hit->GetZ());
-           if (fgEventReconstructor->GetRecGeantHits()) { 
-             // from GEANT hits
-             printf(" %3d %3d \n", hit->GetGeantSignal(), hit->GetTHTrack());
+           if (fgEventReconstructor->GetRecTrackRefHits()) { 
+             // from track ref. hits
+             printf(" %3d %3d \n", hit->GetTrackRefSignal(), hit->GetTTRTrack());
            } else {
              // from raw clusters
              rawclusters = fgEventReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
@@ -911,7 +911,7 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
            TMath::Abs((*fTrackParNew)(1,0)-x) <= windowNonB) {
        //if (TMath::Abs((*fTrackParNew)(0,0)-y) <= windowB &&
          //    TMath::Abs((*fTrackParNew)(1,0)-x) <= windowNonB &&
-         //  hit->GetGeantSignal() == 1) { // just for test
+         //  hit->GetTrackRefSignal() == 1) { // just for test
          // Vector of measurements and covariance matrix
          point.Zero();
          point(0,0) = y;
@@ -939,7 +939,7 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
            trackK = new ((*trackPtr)[nRecTracks]) AliMUONTrackK(NULL, NULL); 
            *trackK = *this;
            fgEventReconstructor->SetNRecTracks(nRecTracks+1);
-           if (fgDebug > 0) cout << " ******** New track: " << ichamb << " " << hit->GetTHTrack() << " " << 1/(trackPar)(4,0) << " " << hit->GetBendingCoor() << " " << hit->GetNonBendingCoor() << " " << fNTrackHits << " " << nRecTracks << endl;
+           if (fgDebug > 0) cout << " ******** New track: " << ichamb << " " << hit->GetTTRTrack() << " " << 1/(trackPar)(4,0) << " " << hit->GetBendingCoor() << " " << hit->GetNonBendingCoor() << " " << fNTrackHits << " " << nRecTracks << endl;
            trackK->fRecover = 0;
            *(trackK->fTrackPar) = trackPar;
            *(trackK->fWeight) += pointWeight; 
@@ -980,12 +980,12 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
                cout << hitLoop->GetBendingCoor() << " ";
                cout << hitLoop->GetNonBendingCoor() << " ";
                cout << hitLoop->GetZ() << " " << " ";
-               cout << hitLoop->GetGeantSignal() << " " << " ";
-               cout << hitLoop->GetTHTrack() << endl;
+               cout << hitLoop->GetTrackRefSignal() << " " << " ";
+               cout << hitLoop->GetTTRTrack() << endl;
                printf(" ** %d %10.4f %10.4f %10.4f %d %d \n", 
                       hitLoop->GetChamberNumber(), hitLoop->GetBendingCoor(), 
                       hitLoop->GetNonBendingCoor(), hitLoop->GetZ(), 
-                      hitLoop->GetGeantSignal(), hitLoop->GetTHTrack());
+                      hitLoop->GetTrackRefSignal(), hitLoop->GetTTRTrack());
              }
            }
            //add point
@@ -1521,11 +1521,11 @@ vertex:
     }
     cout << endl;
   }
-  if (fgEventReconstructor->GetRecGeantHits()) { 
-      // from GEANT hits
+  if (fgEventReconstructor->GetRecTrackRefHits()) { 
+      // from track ref. hits
     for (Int_t i1=0; i1<fNTrackHits; i1++) {
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
-      cout << hit->GetTHTrack() + hit->GetGeantSignal()*10000 << " ";
+      cout << hit->GetTTRTrack() + hit->GetTrackRefSignal()*10000 << " ";
     }
   } else {
     // from raw clusters
@@ -2221,18 +2221,18 @@ void AliMUONTrackK::Print(FILE *lun) const
 
   Int_t flag = 1;
   AliMUONHitForRec *hit = 0; 
-  if (fgEventReconstructor->GetRecGeantHits()) { 
-    // from GEANT hits
+  if (fgEventReconstructor->GetRecTrackRefHits()) { 
+    // from track ref. hits
     for (Int_t j=0; j<fNTrackHits; j++) {
       hit = (AliMUONHitForRec*) fTrackHitsPtr->UncheckedAt(j);
-      if (hit->GetTHTrack() > 1) { flag = 0; break; }
+      if (hit->GetTTRTrack() > 1) { flag = 0; break; }
     }
     for (Int_t j=0; j<fNTrackHits; j++) {
       printf("%10.4f", GetChi2PerPoint(j));
       if (GetChi2PerPoint(j) > -0.1) {
        hit = (AliMUONHitForRec*) fTrackHitsPtr->UncheckedAt(j);
        fprintf(lun,"%3d %3d %10.4f", gAlice->GetEvNumber(), hit->GetChamberNumber(), GetChi2PerPoint(j));
-       fprintf(lun, "%3d %3d %3d \n", hit->GetGeantSignal(), hit->GetTHTrack(), flag);
+       fprintf(lun, "%3d %3d %3d \n", hit->GetTrackRefSignal(), hit->GetTTRTrack(), flag);
       }
     }
     printf("\n");
diff --git a/MUON/MUONTracker.C b/MUON/MUONTracker.C
new file mode 100644 (file)
index 0000000..ebfd8db
--- /dev/null
@@ -0,0 +1,113 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// Macro MUONTracker.C (TO BE COMPILED)
+// for testing the C++ reconstruction code
+// Output is using aliroot standard output MUON.Tracks.root
+// The output is a TClonesArray of AliMUONTracks.
+// Allow to make track reconstruction directly from AliTrackReference hits 
+// recorded in TrackRefs.root file.
+
+#if !defined(__CINT__) || defined(__MAKECINT__)
+#include "AliRun.h"
+#include "AliMUON.h"
+#include "AliMUONData.h"
+#include "AliMUONEventReconstructor.h"
+#endif
+
+void MUONTracker (Int_t FirstEvent = 0, Int_t LastEvent = 9999, Text_t *FileName = "galice.root")
+{
+  //
+  cout << "MUONTracker" << endl;
+  cout << "FirstEvent " << FirstEvent << endl;
+  cout << "LastEvent " << LastEvent << endl;
+  cout << "FileName ``" << FileName << "''" << endl;
+  
+  // Creating Run Loader and openning file containing Hits, Digits and RecPoints
+  AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"MUONLoader","UPDATE");
+  if (RunLoader ==0x0) {
+    printf(">>> Error : Error Opening %s file \n",FileName);
+    return;
+  }
+  // Loading AliRun master
+  if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
+  gAlice = RunLoader->GetAliRun();
+  RunLoader->LoadTrackRefs("READ");
+  
+  // Loading MUON subsystem
+  AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
+  MUONLoader->LoadTracks("UPDATE");
+  
+  Int_t nevents;
+  nevents = RunLoader->GetNumberOfEvents();
+  
+  AliMUONEventReconstructor* Reco = new AliMUONEventReconstructor(MUONLoader);
+  AliMUONData* muondata = Reco->GetMUONData();
+
+  // Testing if Tracker has already been done
+  RunLoader->GetEvent(0);
+  if (MUONLoader->TreeT()) {
+    if (muondata->IsTrackBranchesInTree()) {
+      MUONLoader->UnloadTracks();
+      MUONLoader->LoadTracks("RECREATE");
+      printf("Recreating tracks files\n");
+    }
+  }
+  
+  // The right place for changing AliMUONEventReconstructor parameters
+  // with respect to the default ones
+  //   Reco->SetMaxSigma2Distance(100.0);
+  //   Reco->SetPrintLevel(20);
+  Reco->SetPrintLevel(0);
+  //   Reco->SetBendingResolution(0.0);
+  //   Reco->SetNonBendingResolution(0.0);
+  Reco->SetRecTrackRefHits(1); // 1: reconst. from track ref. hits 0: from clusters
+
+  if (Reco->GetRecTrackRefHits() == 0)
+    MUONLoader->LoadRecPoints("READ");
+
+  if  (LastEvent > nevents-1) LastEvent=nevents-1;
+  
+  // Loop over events
+  for (Int_t event = FirstEvent; event <= LastEvent; event++) {
+    cout << "Event: " << event << endl;
+    RunLoader->GetEvent(event);   
+    // Test if trigger track has already been done before
+    if (MUONLoader->TreeT() == 0x0) {  
+      MUONLoader->MakeTracksContainer();
+    }      else {
+      if (muondata->IsTrackBranchesInTree()){ // Test if track has already been done before
+       if (event==FirstEvent) MUONLoader->UnloadTracks();
+       MUONLoader->MakeTracksContainer();  // Redoing Tracking
+       Info("TrackContainer","Recreating TrackContainer and deleting previous ones");
+      }
+    }
+    
+    muondata->MakeBranch("RT");
+    muondata->SetTreeAddress("RT");
+    Reco->EventReconstruct();
+    
+    muondata->Fill("RT");
+    MUONLoader->WriteTracks("OVERWRITE");  
+    muondata->ResetRecTracks();
+    if (Reco->GetRecTrackRefHits() == 0)
+      muondata->ResetRawClusters();
+  } // Event loop
+  
+  MUONLoader->UnloadRecPoints();
+  MUONLoader->UnloadTracks();
+  RunLoader->UnloadTrackRefs();
+}
index 9242640..43bcc52 100644 (file)
@@ -198,6 +198,24 @@ To compile MUONRecoCheck.C
 // To run MUONRecoCheck
 MUONRecoCheck(nEvent,"galice.root"); // nEvent = nb of events
 
+
+============================================================
+ How to run MUONTracker macro
+============================================================
+To make the track reconstruction directly from AliTrackReference hits 
+which are recorded in TrackRefs.root during the simulation.
+It can be used to check the reconstruction without clusterization.     
+
+To compile MUONTracker.C
+.includepath $ALICE_ROOT/STEER
+.includepath $ALICE_ROOT/MUON
+.L $ALICE_ROOT/MUON/MUONTracker.C+
+
+// To run MUONTracker
+MUONTracker(iEventMin,iEventMax,"galice.root"); // iEventMin: first event
+                                               // iEventMax: last event        
+
+
 ===========================================================
  Still working ..............
 ===========================================================