change class name: AliMUONEventReconstructor -> AliMUONTrackReconstructor

diff --git a/MUON/AliMUONReconstructor.cxx b/MUON/AliMUONReconstructor.cxx
index 9d47fa0b183d838180bd6757979b2a139720fddd..9e2ab6e9df7b068ad4a71a0a0b64ce1f2b401cba 100644 (file)
--- a/MUON/AliMUONReconstructor.cxx
+++ b/MUON/AliMUONReconstructor.cxx
@@ -27,9 +27,9 @@
 #include "AliGenEventHeader.h"
 #include "AliESD.h"
 #include "AliMUONReconstructor.h"
-
+ 
 #include "AliMUONData.h"
-#include "AliMUONEventReconstructor.h"
+#include "AliMUONTrackReconstructor.h"
 #include "AliMUONClusterReconstructor.h"
 #include "AliMUONClusterFinderVS.h"
 #include "AliMUONTrack.h"
@@ -40,6 +40,7 @@
 
 #include "AliRawReader.h"
 
+
 ClassImp(AliMUONReconstructor)
 //_____________________________________________________________________________
 AliMUONReconstructor::AliMUONReconstructor()
@@ -59,7 +60,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 
 // used local container for each method
 // passing fLoader as argument, could be avoided ???
-  AliMUONEventReconstructor* recoEvent = new AliMUONEventReconstructor(loader);
+  AliMUONTrackReconstructor* recoEvent = new AliMUONTrackReconstructor(loader);
   AliMUONData* dataEvent = recoEvent->GetMUONData();
 
   AliMUONClusterReconstructor* recoCluster = new AliMUONClusterReconstructor(loader);
@@ -108,7 +109,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
     recoEvent->EventReconstruct();
     dataEvent->Fill("RT");
 
-    loader->WriteTracks("OVERWRITE");  
+    loader->WriteTracks("OVERWRITE"); 
   
     //--------------------------- Resetting branches -----------------------
     dataCluster->ResetDigits();
@@ -117,9 +118,9 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 
     dataEvent->ResetRawClusters();
     dataEvent->ResetTrigger();
-    dataEvent->ResetRecTracks();
+    dataEvent->ResetRecTracks();  
     dataEvent->ResetRecTriggerTracks();
-  
+
   }
   loader->UnloadDigits();
   loader->UnloadRecPoints();
@@ -137,7 +138,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
 
 // used local container for each method
 // passing fLoader as argument, could be avoided ???
-  AliMUONEventReconstructor* recoEvent = new AliMUONEventReconstructor(loader);
+  AliMUONTrackReconstructor* recoEvent = new AliMUONTrackReconstructor(loader);
   AliMUONData* dataEvent = recoEvent->GetMUONData();
 
   AliMUONRawData* rawData = new AliMUONRawData(loader);

diff --git a/MUON/AliMUONTrack.cxx b/MUON/AliMUONTrack.cxx
index bed3e822d1926c0686a3a2f5b6e6f754653ccc16..92b32b7354555bd310dbbcf1bb2e4ea5b6750d8b 100644 (file)
--- a/MUON/AliMUONTrack.cxx
+++ b/MUON/AliMUONTrack.cxx
@@ -35,7 +35,7 @@
 
 #include "AliLog.h"
 
-#include "AliMUONEventReconstructor.h" 
+#include "AliMUONTrackReconstructor.h" 
 #include "AliMUONHitForRec.h" 
 #include "AliMUONSegment.h" 
 #include "AliMUONTrack.h"
@@ -61,7 +61,7 @@ AliMUONTrack::AliMUONTrack()
 {
   // Default constructor
   fgFitter = 0;
-  fEventReconstructor = 0;
+  fTrackReconstructor = 0;
   fTrackHitsPtr = new TObjArray(10);
   fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);  
   fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10); 
@@ -69,11 +69,11 @@ AliMUONTrack::AliMUONTrack()
 }
 
   //__________________________________________________________________________
-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
+  fTrackReconstructor = TrackReconstructor; // link back to TrackReconstructor
   // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
   fTrackHitsPtr = new TObjArray(10);
   fNTrackHits = 0;
@@ -95,11 +95,11 @@ AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegmen
 }
 
   //__________________________________________________________________________
-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
+  fTrackReconstructor = TrackReconstructor; // link back to TrackReconstructor
   // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
   fTrackHitsPtr = new TObjArray(10);
   fNTrackHits = 0;
@@ -147,11 +147,11 @@ AliMUONTrack::~AliMUONTrack()
 AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
   :  TObject(theMUONTrack)
 {
-  //fEventReconstructor = new AliMUONEventReconstructor(*MUONTrack.fEventReconstructor);
+  //fTrackReconstructor = new AliMUONTrackReconstructor(*MUONTrack.fTrackReconstructor);
                                // is it right ?
                               // NO, because it would use dummy copy constructor
-                              // and AliMUONTrack is not the owner of its EventReconstructor 
-  fEventReconstructor = theMUONTrack.fEventReconstructor;
+                              // 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.
@@ -197,10 +197,10 @@ AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& theMUONTrack)
   // base class assignement
   TObject::operator=(theMUONTrack);
 
-  // fEventReconstructor =  new AliMUONEventReconstructor(*MUONTrack.fEventReconstructor); 
+  // fTrackReconstructor =  new AliMUONTrackReconstructor(*MUONTrack.fTrackReconstructor); 
   // is it right ?
   // is it right ? NO because it would use dummy copy constructor
-  fEventReconstructor =  theMUONTrack.fEventReconstructor;
+  fTrackReconstructor =  theMUONTrack.fTrackReconstructor;
   fTrackParamAtVertex =  theMUONTrack.fTrackParamAtVertex;
 
  // necessary to make a copy of the objects and not only the pointers in TObjArray.
@@ -244,7 +244,7 @@ void AliMUONTrack::Remove()
   // and corresponding track hits from array of track hits.
   // Compress the TClonesArray it belongs to.
   AliMUONTrackHit *nextTrackHit;
-  AliMUONEventReconstructor *eventRec = this->fEventReconstructor;
+  AliMUONTrackReconstructor *eventRec = this->fTrackReconstructor;
   TClonesArray *trackHitsPtr = eventRec->GetRecTrackHitsPtr();
   // Loop over all track hits of track
   AliMUONTrackHit *trackHit = (AliMUONTrackHit*) fTrackHitsPtr->First();
@@ -422,7 +422,7 @@ void AliMUONTrack::MatchTriggerTrack(TClonesArray *triggerTrackArray)
   trackParam = *((AliMUONTrackParam*) fTrackParamAtHit->Last()); 
   trackParam.ExtrapToZ(AliMUONConstants::DefaultChamberZ(10)); // extrap to 1st trigger chamber
 
-  nSigmaCut2 =  fEventReconstructor->GetMaxSigma2Distance(); // nb of sigma**2 for cut
+  nSigmaCut2 =  fTrackReconstructor->GetMaxSigma2Distance(); // nb of sigma**2 for cut
   xTrack = trackParam.GetNonBendingCoor();
   yTrack = trackParam.GetBendingCoor();
   ySlopeTrack = trackParam.GetBendingSlope();
@@ -541,12 +541,12 @@ void AliMUONTrack::AddHitForRec(AliMUONHitForRec* HitForRec)
   // Add HitForRec to the track:
   // actual TrackHit into TClonesArray of TrackHit's for the event;
   // pointer to actual TrackHit in TObjArray of pointers to TrackHit's for the track
-  TClonesArray *recTrackHitsPtr = this->fEventReconstructor->GetRecTrackHitsPtr();
-  Int_t eventTrackHits = this->fEventReconstructor->GetNRecTrackHits();
+  TClonesArray *recTrackHitsPtr = this->fTrackReconstructor->GetRecTrackHitsPtr();
+  Int_t eventTrackHits = this->fTrackReconstructor->GetNRecTrackHits();
   // event
   AliMUONTrackHit* trackHit =
     new ((*recTrackHitsPtr)[eventTrackHits]) AliMUONTrackHit(HitForRec);
-  this->fEventReconstructor->SetNRecTrackHits(eventTrackHits + 1);
+  this->fTrackReconstructor->SetNRecTrackHits(eventTrackHits + 1);
   // track
   if (fTrackHitsPtr->IsOwner()) AliFatal("fTrackHitsPtr is owner");
   fTrackHitsPtr->Add(trackHit);
@@ -590,12 +590,12 @@ void AliMUONTrack::SetTrackParamAtVertex()
     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;
@@ -832,7 +832,7 @@ 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 = 

diff --git a/MUON/AliMUONTrack.h b/MUON/AliMUONTrack.h
index 89342f6f96708328e2b6c3947b5b7f8199e0b061..d8ea82a35c1f60e0fad0d0dbfd8324986f73e19e 100644 (file)
--- a/MUON/AliMUONTrack.h
+++ b/MUON/AliMUONTrack.h
@@ -21,7 +21,7 @@
 
 class TObjArray;
 class TVirtualFitter;
-class AliMUONEventReconstructor;
+class AliMUONTrackReconstructor;
 class AliMUONHitForRec;
 class AliMUONSegment;
 
@@ -33,11 +33,11 @@ class AliMUONTrack : public TObject
   AliMUONTrack (const AliMUONTrack& AliMUONTrack); // copy constructor
   AliMUONTrack& operator=(const AliMUONTrack& AliMUONTrack); // assignment operator
 
-  AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegment, AliMUONEventReconstructor* EventReconstructor); // Constructor from two Segment's
-  AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec, AliMUONEventReconstructor* EventReconstructor); // Constructor from one Segment and one HitForRec
+  AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegment, AliMUONTrackReconstructor* TrackReconstructor); // Constructor from two Segment's
+  AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec, AliMUONTrackReconstructor* TrackReconstructor); // Constructor from one Segment and one HitForRec
   void Remove(void);
 
-  AliMUONEventReconstructor* GetEventReconstructor(void) const {return fEventReconstructor;}
+  AliMUONTrackReconstructor* GetTrackReconstructor(void) const {return fTrackReconstructor;}
   AliMUONTrackParam* GetTrackParamAtVertex(void) {return &fTrackParamAtVertex;}
   void SetTrackParamAtVertex(void); // Set track parameters at vertex from last stations 4 & 5
   void SetTrackParamAtVertex(AliMUONTrackParam* TrackParam) {fTrackParamAtVertex = *TrackParam;}
@@ -82,7 +82,7 @@ class AliMUONTrack : public TObject
  protected:
  private:
   static TVirtualFitter* fgFitter; //!                  Pointer to track fitter
-  AliMUONEventReconstructor* fEventReconstructor; //!   Pointer to EventReconstructor
+  AliMUONTrackReconstructor* fTrackReconstructor; //!   Pointer to TrackReconstructor
   AliMUONTrackParam fTrackParamAtVertex; // Track parameters at vertex
   TClonesArray *fTrackParamAtHit; // Track parameters at hit
   TClonesArray *fHitForRecAtHit; // Cluster parameters at hit

diff --git a/MUON/AliMUONTrackK.cxx b/MUON/AliMUONTrackK.cxx
index fed6f217f2a38b197b75c3877f45c68ec0180ffa..850dddf79dcb51e54fd79ac0793b0892bc877a75 100644 (file)
--- a/MUON/AliMUONTrackK.cxx
+++ b/MUON/AliMUONTrackK.cxx
@@ -25,7 +25,7 @@
 #include "AliCallf77.h"
 #include "AliMUON.h"
 #include "AliMUONChamber.h"
-#include "AliMUONEventReconstructor.h"
+#include "AliMUONTrackReconstructor.h"
 #include "AliMagF.h"
 #include "AliMUONSegment.h"
 #include "AliMUONHitForRec.h"
@@ -47,7 +47,7 @@ ClassImp(AliMUONTrackK) // Class implementation in ROOT context
 Int_t AliMUONTrackK::fgDebug = -1;
 Int_t AliMUONTrackK::fgNOfPoints = 0; 
 AliMUON* AliMUONTrackK::fgMUON = NULL;
-AliMUONEventReconstructor* AliMUONTrackK::fgEventReconstructor = NULL; 
+AliMUONTrackReconstructor* AliMUONTrackK::fgTrackReconstructor = NULL; 
 TClonesArray* AliMUONTrackK::fgHitForRec = NULL; 
 //FILE *lun1 = fopen("window.dat","w");
 
@@ -58,7 +58,7 @@ AliMUONTrackK::AliMUONTrackK()
 {
   // Default constructor
 
-  fgEventReconstructor = NULL; // pointer to event reconstructor
+  fgTrackReconstructor = NULL; // pointer to track reconstructor
   fgMUON = NULL; // pointer to Muon module
   fgHitForRec = NULL; // pointer to points
   fgNOfPoints = 0; // number of points
@@ -80,14 +80,14 @@ AliMUONTrackK::AliMUONTrackK()
 }
 
   //__________________________________________________________________________
-AliMUONTrackK::AliMUONTrackK(AliMUONEventReconstructor *EventReconstructor, TClonesArray *hitForRec)
+AliMUONTrackK::AliMUONTrackK(AliMUONTrackReconstructor *TrackReconstructor, TClonesArray *hitForRec)
   //AZ: TObject()
   : AliMUONTrack()
 {
   // Constructor
 
-  if (!EventReconstructor) return;
-  fgEventReconstructor = EventReconstructor; // pointer to event reconstructor
+  if (!TrackReconstructor) return;
+  fgTrackReconstructor = TrackReconstructor; // pointer to track reconstructor
   fgMUON = (AliMUON*) gAlice->GetModule("MUON"); // pointer to Muon module
   fgHitForRec = hitForRec; // pointer to points
   fgNOfPoints = fgHitForRec->GetEntriesFast(); // number of points
@@ -110,7 +110,7 @@ AliMUONTrackK::AliMUONTrackK(AliMUONEventReconstructor *EventReconstructor, TClo
   //__________________________________________________________________________
 AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
   //AZ: TObject()
-  : AliMUONTrack(segment, segment, fgEventReconstructor)
+  : AliMUONTrack(segment, segment, fgTrackReconstructor)
 {
   // Constructor from a segment
   Double_t dX, dY, dZ;
@@ -166,7 +166,7 @@ AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
   dX = hit2->GetNonBendingCoor() - hit1->GetNonBendingCoor();
   (*fTrackPar)(2,0) = TMath::ATan2(dY,dZ); // alpha
   (*fTrackPar)(3,0) = TMath::ATan2(dX,dZ/TMath::Cos((*fTrackPar)(2,0))); // beta
-  (*fTrackPar)(4,0) = 1/fgEventReconstructor->GetBendingMomentumFromImpactParam(segment->GetBendingImpact()); // 1/Pt
+  (*fTrackPar)(4,0) = 1/fgTrackReconstructor->GetBendingMomentumFromImpactParam(segment->GetBendingImpact()); // 1/Pt
   (*fTrackPar)(4,0) *= TMath::Cos((*fTrackPar)(3,0)); // 1/p
   // Evaluate covariance (and weight) matrix
   EvalCovariance(dZ);
@@ -184,15 +184,15 @@ AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
   fParSmooth = NULL;
 
   if (fgDebug < 0 ) return;
-  cout << fgEventReconstructor->GetBendingMomentumFromImpactParam(segment->GetBendingImpact()) << " " << 1/(*fTrackPar)(4,0) << " ";
-  if (fgEventReconstructor->GetRecTrackRefHits()) { 
+  cout << fgTrackReconstructor->GetBendingMomentumFromImpactParam(segment->GetBendingImpact()) << " " << 1/(*fTrackPar)(4,0) << " ";
+  if (fgTrackReconstructor->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++) {
       hit1 = (AliMUONHitForRec*) ((*fTrackHitsPtr)[i]);
-      rawclusters = fgEventReconstructor->GetMUONData()->RawClusters(hit1->GetChamberNumber());
+      rawclusters = fgTrackReconstructor->GetMUONData()->RawClusters(hit1->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit1->GetHitNumber());
       cout << clus->GetTrack(1)-1;
       if (clus->GetTrack(2) != 0) cout << " " << clus->GetTrack(2)-1;
@@ -349,8 +349,8 @@ void AliMUONTrackK::EvalCovariance(Double_t dZ)
   // Evaluate covariance (and weight) matrix for track candidate
   Double_t sigmaB, sigmaNonB, tanA, tanB, dAdY, rad, dBdX, dBdY;
 
-  sigmaB = fgEventReconstructor->GetBendingResolution(); // bending resolution
-  sigmaNonB = fgEventReconstructor->GetNonBendingResolution(); // non-bending resolution
+  sigmaB = fgTrackReconstructor->GetBendingResolution(); // bending resolution
+  sigmaNonB = fgTrackReconstructor->GetNonBendingResolution(); // non-bending resolution
 
   (*fWeight)(0,0) = sigmaB*sigmaB; // <yy>
 
@@ -506,12 +506,12 @@ 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->GetRecTrackRefHits()) { 
+           if (fgTrackReconstructor->GetRecTrackRefHits()) { 
              // from track ref. hits
              printf(" %3d %3d \n", hit->GetTrackRefSignal(), hit->GetTTRTrack());
            } else {
              // from raw clusters
-             rawclusters = fgEventReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
+             rawclusters = fgTrackReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
              clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
              printf("%3d", clus->GetTrack(1)-1); 
              if (clus->GetTrack(2) != 0) printf("%3d \n", clus->GetTrack(2)-1);
@@ -612,7 +612,7 @@ Bool_t AliMUONTrackK::KalmanFilter(Int_t ichamBeg, Int_t ichamEnd, Bool_t Back,
     }
   } // while
   if (fgDebug > 0) cout << fNTrackHits << " " << fChi2 << " " << 1/(*fTrackPar)(4,0) << " " << fPosition << endl;
-  if (1/TMath::Abs((*fTrackPar)(4,0)) < fgEventReconstructor->GetMinBendingMomentum()) success = kFALSE; // p < p_min
+  if (1/TMath::Abs((*fTrackPar)(4,0)) < fgTrackReconstructor->GetMinBendingMomentum()) success = kFALSE; // p < p_min
   return success;
 }
 
@@ -796,8 +796,8 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
   AliMUONTrackK *trackK;
 
   Bool_t ok = kFALSE;
-  //sigmaB = fgEventReconstructor->GetBendingResolution(); // bending resolution
-  //sigmaNonB = fgEventReconstructor->GetNonBendingResolution(); // non-bending resolution
+  //sigmaB = fgTrackReconstructor->GetBendingResolution(); // bending resolution
+  //sigmaNonB = fgTrackReconstructor->GetNonBendingResolution(); // non-bending resolution
   *fCovariance = *fWeight;
   // check whether the Invert method returns flag if matrix cannot be inverted,
   // and do not calculate the Determinant in that case !!!!
@@ -889,7 +889,7 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
          pointWeight(0,0) = 1/hit->GetBendingReso2();
          pointWeight(1,1) = 1/hit->GetNonBendingReso2();
          TryPoint(point,pointWeight,trackPar,dChi2);
-         if (TMath::Abs(1./(trackPar)(4,0)) < fgEventReconstructor->GetMinBendingMomentum()) continue; // p < p_min - next hit
+         if (TMath::Abs(1./(trackPar)(4,0)) < fgTrackReconstructor->GetMinBendingMomentum()) continue; // p < p_min - next hit
          ok = kTRUE;
          nHitsOK++;
          //if (nHitsOK > -1) {
@@ -904,11 +904,11 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
            hitAdd = hit;
          } else {
            // branching: create a new track
-           trackPtr = fgEventReconstructor->GetRecTracksPtr();
-           nRecTracks = fgEventReconstructor->GetNRecTracks();
+           trackPtr = fgTrackReconstructor->GetRecTracksPtr();
+           nRecTracks = fgTrackReconstructor->GetNRecTracks();
            trackK = new ((*trackPtr)[nRecTracks]) AliMUONTrackK(NULL, NULL); 
            *trackK = *this;
-           fgEventReconstructor->SetNRecTracks(nRecTracks+1);
+           fgTrackReconstructor->SetNRecTracks(nRecTracks+1);
            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;
@@ -1064,7 +1064,7 @@ void AliMUONTrackK::MSThin(Int_t sign)
   momentum = 1/(*fTrackParNew)(4,0); // particle momentum
   //velo = momentum/TMath::Sqrt(momentum*momentum+muonMass*muonMass); // velocity/c for muon hypothesis
   velo = 1; // relativistic
-  path = TMath::Abs(fgEventReconstructor->GetChamberThicknessInX0()/cosAlph/cosBeta); // path length
+  path = TMath::Abs(fgTrackReconstructor->GetChamberThicknessInX0()/cosAlph/cosBeta); // path length
   theta0 = 0.0136/velo/momentum*TMath::Sqrt(path)*(1+0.038*TMath::Log(path)); // projected scattering angle
 
   (*fWeight)(2,2) += sign*theta0/cosBeta*theta0/cosBeta; // alpha
@@ -1227,7 +1227,7 @@ void AliMUONTrackK::Kill(void)
       hit->SetNTrackHits(hit->GetNTrackHits()-1); 
     }
   }
-  fgEventReconstructor->GetRecTracksPtr()->Remove(this);
+  fgTrackReconstructor->GetRecTracksPtr()->Remove(this);
 }
 
   //__________________________________________________________________________
@@ -1491,7 +1491,7 @@ vertex:
     }
     cout << endl;
   }
-  if (fgEventReconstructor->GetRecTrackRefHits()) { 
+  if (fgTrackReconstructor->GetRecTrackRefHits()) { 
       // from track ref. hits
     for (Int_t i1=0; i1<fNTrackHits; i1++) {
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
@@ -1501,14 +1501,14 @@ vertex:
     // from raw clusters
     for (Int_t i1=0; i1<fNTrackHits; i1++) {
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
-      rawclusters = fgEventReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
+      rawclusters = fgTrackReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
       printf ("%4d", clus->GetTrack(1) - 1); 
     }
     cout << endl;
     for (Int_t i1=0; i1<fNTrackHits; i1++) {
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
-      rawclusters = fgEventReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
+      rawclusters = fgTrackReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
       if (clus->GetTrack(2) != 0) printf ("%4d", clus->GetTrack(2) - 1);
       else printf ("%4s", "   ");
@@ -1621,7 +1621,7 @@ Bool_t AliMUONTrackK::Recover(void)
   AliMUONTrackK *trackK;
 
   if (fgDebug > 0) cout << " ******** Enter Recover " << endl;
-  trackPtr = fgEventReconstructor->GetRecTracksPtr();
+  trackPtr = fgTrackReconstructor->GetRecTracksPtr();
 
   // Remove hit with the highest chi2
   Double_t chi2 = 0;
@@ -1678,7 +1678,7 @@ Bool_t AliMUONTrackK::Recover(void)
   //DropBranches(imax0, hits); // drop branches downstream the discarded hit
   delete hits;
 
-  nRecTracks = fgEventReconstructor->GetNRecTracks();
+  nRecTracks = fgTrackReconstructor->GetNRecTracks();
   skipHit = (AliMUONHitForRec*) ((*fTrackHitsPtr)[fNTrackHits-1]);
   // Remove all saved steps and smoother matrices after the skipped hit 
   RemoveMatrices(skipHit->GetZ());
@@ -1688,7 +1688,7 @@ Bool_t AliMUONTrackK::Recover(void)
     // Propagation toward high Z or skipped hit next to segment - 
     // start track from segment 
     trackK = new ((*trackPtr)[nRecTracks]) AliMUONTrackK(fStartSegment); 
-    fgEventReconstructor->SetNRecTracks(nRecTracks+1);
+    fgTrackReconstructor->SetNRecTracks(nRecTracks+1);
     trackK->fRecover = 1;
     trackK->fSkipHit = skipHit;
     trackK->fNTrackHits = fNTrackHits;
@@ -1700,7 +1700,7 @@ Bool_t AliMUONTrackK::Recover(void)
 
   trackK = new ((*trackPtr)[nRecTracks]) AliMUONTrackK(NULL, NULL);
   *trackK = *this;
-  fgEventReconstructor->SetNRecTracks(nRecTracks+1);
+  fgTrackReconstructor->SetNRecTracks(nRecTracks+1);
   //AZ(z->-z) trackK->fTrackDir = -1;
   trackK->fTrackDir = 1;
   trackK->fRecover = 1;
@@ -2122,14 +2122,14 @@ void AliMUONTrackK::Outlier()
   // Check for possible double track candidates
   //if (ExistDouble(hit)) return;
 
-  TClonesArray *trackPtr = fgEventReconstructor->GetRecTracksPtr();
-  Int_t nRecTracks = fgEventReconstructor->GetNRecTracks();
+  TClonesArray *trackPtr = fgTrackReconstructor->GetRecTracksPtr();
+  Int_t nRecTracks = fgTrackReconstructor->GetNRecTracks();
 
   AliMUONTrackK *trackK = 0;
   if (!fNSteps || GetStation0() == 3 && hit->GetChamberNumber() > 7) {
     // start track from segment 
     trackK = new ((*trackPtr)[nRecTracks]) AliMUONTrackK(fStartSegment); 
-    fgEventReconstructor->SetNRecTracks(nRecTracks+1);
+    fgTrackReconstructor->SetNRecTracks(nRecTracks+1);
     trackK->fRecover = 2;
     trackK->fSkipHit = hit;
     trackK->fNTrackHits = fNTrackHits;
@@ -2141,7 +2141,7 @@ void AliMUONTrackK::Outlier()
   } 
   trackK = new ((*trackPtr)[nRecTracks]) AliMUONTrackK(NULL, NULL);
   *trackK = *this;
-  fgEventReconstructor->SetNRecTracks(nRecTracks+1);
+  fgTrackReconstructor->SetNRecTracks(nRecTracks+1);
   //AZ(z->-z) trackK->fTrackDir = -1;
   trackK->fTrackDir = 1;
   trackK->fRecover = 2;
@@ -2191,7 +2191,7 @@ void AliMUONTrackK::Print(FILE *lun) const
 
   Int_t flag = 1;
   AliMUONHitForRec *hit = 0; 
-  if (fgEventReconstructor->GetRecTrackRefHits()) { 
+  if (fgTrackReconstructor->GetRecTrackRefHits()) { 
     // from track ref. hits
     for (Int_t j=0; j<fNTrackHits; j++) {
       hit = (AliMUONHitForRec*) fTrackHitsPtr->UncheckedAt(j);
@@ -2212,7 +2212,7 @@ void AliMUONTrackK::Print(FILE *lun) const
     TClonesArray *rawclusters = 0;
     for (Int_t i1=0; i1<fNTrackHits; i1++) {
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
-      rawclusters = fgEventReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
+      rawclusters = fgTrackReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
       if (TMath::Abs(clus->GetTrack(1)-1) < 2) {
        if (clus->GetTrack(2)) flag = 2;
@@ -2229,7 +2229,7 @@ void AliMUONTrackK::Print(FILE *lun) const
     for (Int_t i1=0; i1<fNTrackHits; i1++) {
       if (GetChi2PerPoint(i1) < -0.1) continue;
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
-      rawclusters = fgEventReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
+      rawclusters = fgTrackReconstructor->GetMUONData()->RawClusters(hit->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
       for (Int_t j=0; j<2; j++) {
        tid[j] = clus->GetTrack(j+1) - 1;
@@ -2255,8 +2255,8 @@ void AliMUONTrackK::DropBranches(Int_t imax, TObjArray *hits)
   TClonesArray *trackPtr;
   AliMUONTrackK *trackK;
 
-  trackPtr = fgEventReconstructor->GetRecTracksPtr();
-  nRecTracks = fgEventReconstructor->GetNRecTracks();
+  trackPtr = fgTrackReconstructor->GetRecTracksPtr();
+  nRecTracks = fgTrackReconstructor->GetNRecTracks();
   Int_t icand = trackPtr->IndexOf(this);
   if (!hits) hits = fTrackHitsPtr; 
 
@@ -2301,8 +2301,8 @@ void AliMUONTrackK::DropBranches(AliMUONSegment *segment)
   TClonesArray *trackPtr;
   AliMUONTrackK *trackK;
 
-  trackPtr = fgEventReconstructor->GetRecTracksPtr();
-  nRecTracks = fgEventReconstructor->GetNRecTracks();
+  trackPtr = fgTrackReconstructor->GetRecTracksPtr();
+  nRecTracks = fgTrackReconstructor->GetNRecTracks();
   Int_t icand = trackPtr->IndexOf(this);
 
   for (Int_t i=icand+1; i<nRecTracks; i++) {
@@ -2335,8 +2335,8 @@ Bool_t AliMUONTrackK::ExistDouble(AliMUONHitForRec *hit)
 {
   // Check if the track will make a double after outlier removal
 
-  TClonesArray *trackPtr = fgEventReconstructor->GetRecTracksPtr();
-  Int_t nRecTracks = fgEventReconstructor->GetNRecTracks();
+  TClonesArray *trackPtr = fgTrackReconstructor->GetRecTracksPtr();
+  Int_t nRecTracks = fgTrackReconstructor->GetNRecTracks();
   TObjArray *hitArray = new TObjArray(*fTrackHitsPtr);
   TObjArray *hitArray1 = new TObjArray(*hitArray);
   hitArray1->Remove(hit);
@@ -2388,8 +2388,8 @@ Bool_t AliMUONTrackK::ExistDouble(void)
 {
   // Check if the track will make a double after recovery
 
-  TClonesArray *trackPtr = fgEventReconstructor->GetRecTracksPtr();
-  Int_t nRecTracks = fgEventReconstructor->GetNRecTracks();
+  TClonesArray *trackPtr = fgTrackReconstructor->GetRecTracksPtr();
+  Int_t nRecTracks = fgTrackReconstructor->GetNRecTracks();
 
   TObjArray *hitArray = new TObjArray(*fTrackHitsPtr);
   if (GetStation0() == 3) SortHits(0, hitArray); // sort

diff --git a/MUON/AliMUONTrackK.h b/MUON/AliMUONTrackK.h
index 86bd3eed9114f0c4b4be10aad94b3603a8920911..6d489cb958957535c3ca5c96243798568e42b6ec 100644 (file)
--- a/MUON/AliMUONTrackK.h
+++ b/MUON/AliMUONTrackK.h
@@ -11,7 +11,7 @@
 
 class TArrayD;
 class TMatrixD;
-class AliMUONEventReconstructor;
+class AliMUONTrackReconstructor;
 class TClonesArray;
 class TObjArray;
 class AliMUONSegment;
@@ -26,8 +26,8 @@ class AliMUONTrackK : public AliMUONTrack {
   AliMUONTrackK(); // Default constructor
   virtual ~AliMUONTrackK(); // Destructor
 
-  //AliMUONTrackK(const AliMUONEventReconstructor *EventReconstructor, const AliMUONHitForRec *hitForRec); // Constructor
-  AliMUONTrackK(AliMUONEventReconstructor *EventReconstructor, TClonesArray *hitForRec); // Constructor
+  //AliMUONTrackK(const AliMUONTrackReconstructor *TrackReconstructor, const AliMUONHitForRec *hitForRec); // Constructor
+  AliMUONTrackK(AliMUONTrackReconstructor *TrackReconstructor, TClonesArray *hitForRec); // Constructor
   AliMUONTrackK(AliMUONSegment *segment); // Constructor from a segment
 
   // Pointer to hits on track
@@ -79,7 +79,7 @@ class AliMUONTrackK : public AliMUONTrack {
   static Int_t fgDebug; // debug level
   static Int_t fgNOfPoints; // number of points in event
   static AliMUON *fgMUON; // pointer to MUON module  
-  static AliMUONEventReconstructor *fgEventReconstructor; // pointer to event reconstructor
+  static AliMUONTrackReconstructor *fgTrackReconstructor; // pointer to event reconstructor
   static TClonesArray *fgHitForRec; // pointer to hits
 
   AliMUONSegment *fStartSegment; // seed segment  

diff --git a/MUON/AliMUONEventReconstructor.cxx b/MUON/AliMUONTrackReconstructor.cxx
similarity index 95%
rename from MUON/AliMUONEventReconstructor.cxx
rename to MUON/AliMUONTrackReconstructor.cxx
index a3eeafce7379e2e5d6b5604db53493030b802da4..b06beff8cc88e2b89c805e6899dd847769e8c9dc 100644 (file)
--- a/MUON/AliMUONEventReconstructor.cxx
+++ b/MUON/AliMUONTrackReconstructor.cxx
@@ -13,14 +13,12 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
 ////////////////////////////////////
 //
-// MUON event reconstructor in ALICE
+// MUON track reconstructor in ALICE (class renamed from AliMUONEventReconstructor)
 //
 // This class contains as data:
-// * the parameters for the event reconstruction
+// * the parameters for the track reconstruction
 // * a pointer to the array of hits to be reconstructed (the event)
 // * a pointer to the array of segments made with these hits inside each station
 // * a pointer to the array of reconstructed tracks
@@ -38,7 +36,7 @@
 #include <TFile.h>
 #include <TMatrixD.h> //AZ
 
-#include "AliMUONEventReconstructor.h"
+#include "AliMUONTrackReconstructor.h"
 #include "AliMUON.h"
 #include "AliMUONConstants.h"
 #include "AliMUONHitForRec.h"
@@ -60,32 +58,32 @@
 #include "AliTrackReference.h"
 
 //************* Defaults parameters for reconstruction
-const Double_t AliMUONEventReconstructor::fgkDefaultMinBendingMomentum = 3.0;
-const Double_t AliMUONEventReconstructor::fgkDefaultMaxBendingMomentum = 2000.0;
-const Double_t AliMUONEventReconstructor::fgkDefaultMaxChi2 = 100.0;
-const Double_t AliMUONEventReconstructor::fgkDefaultMaxSigma2Distance = 16.0;
-const Double_t AliMUONEventReconstructor::fgkDefaultBendingResolution = 0.01;
-const Double_t AliMUONEventReconstructor::fgkDefaultNonBendingResolution = 0.144;
-const Double_t AliMUONEventReconstructor::fgkDefaultChamberThicknessInX0 = 0.03;
+const Double_t AliMUONTrackReconstructor::fgkDefaultMinBendingMomentum = 3.0;
+const Double_t AliMUONTrackReconstructor::fgkDefaultMaxBendingMomentum = 2000.0;
+const Double_t AliMUONTrackReconstructor::fgkDefaultMaxChi2 = 100.0;
+const Double_t AliMUONTrackReconstructor::fgkDefaultMaxSigma2Distance = 16.0;
+const Double_t AliMUONTrackReconstructor::fgkDefaultBendingResolution = 0.01;
+const Double_t AliMUONTrackReconstructor::fgkDefaultNonBendingResolution = 0.144;
+const Double_t AliMUONTrackReconstructor::fgkDefaultChamberThicknessInX0 = 0.03;
 // Simple magnetic field:
 // Value taken from macro MUONtracking.C: 0.7 T, hence 7 kG
 // Length and Position from reco_muon.F, with opposite sign:
 // Length = ZMAGEND-ZCOIL
 // Position = (ZMAGEND+ZCOIL)/2
 // to be ajusted differently from real magnetic field ????
-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::fgkDefaultRecTrackRefHits = 0;
-const Double_t AliMUONEventReconstructor::fgkDefaultEfficiency = 0.95;
+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(AliMUONEventReconstructor) // Class implementation in ROOT context
+ClassImp(AliMUONTrackReconstructor) // Class implementation in ROOT context
 
   //__________________________________________________________________________
-AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
+AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliLoader* loader)
   : TObject()
 {
-  // Constructor for class AliMUONEventReconstructor
+  // Constructor for class AliMUONTrackReconstructor
   SetReconstructionParametersToDefaults();
   fTrackMethod = 1; //AZ - tracking method (1-default, 2-Kalman)
   // Memory allocation for the TClonesArray of hits for reconstruction
@@ -117,7 +115,7 @@ AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
   // See how to get fSimple(BValue, BLength, BPosition)
   // automatically calculated from the actual magnetic field ????
 
-  AliDebug(1,"AliMUONEventReconstructor constructed with defaults"); 
+  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();
@@ -139,7 +137,7 @@ AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
   return;
 }
   //__________________________________________________________________________
-AliMUONEventReconstructor::AliMUONEventReconstructor (const AliMUONEventReconstructor& rhs)
+AliMUONTrackReconstructor::AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs)
   : TObject(rhs)
 {
 // Protected copy constructor
@@ -147,8 +145,8 @@ AliMUONEventReconstructor::AliMUONEventReconstructor (const AliMUONEventReconstr
   AliFatal("Not implemented.");
 }
 
-AliMUONEventReconstructor & 
-AliMUONEventReconstructor::operator=(const AliMUONEventReconstructor& rhs)
+AliMUONTrackReconstructor & 
+AliMUONTrackReconstructor::operator=(const AliMUONTrackReconstructor& rhs)
 {
 // Protected assignement operator
 
@@ -160,9 +158,9 @@ AliMUONEventReconstructor::operator=(const AliMUONEventReconstructor& rhs)
 }
 
   //__________________________________________________________________________
-AliMUONEventReconstructor::~AliMUONEventReconstructor(void)
+AliMUONTrackReconstructor::~AliMUONTrackReconstructor(void)
 {
-  // Destructor for class AliMUONEventReconstructor
+  // Destructor for class AliMUONTrackReconstructor
   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 ????
@@ -170,7 +168,7 @@ AliMUONEventReconstructor::~AliMUONEventReconstructor(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::SetReconstructionParametersToDefaults(void)
+void AliMUONTrackReconstructor::SetReconstructionParametersToDefaults(void)
 {
   // Set reconstruction parameters to default values
   // Would be much more convenient with a structure (or class) ????
@@ -228,7 +226,7 @@ void AliMUONEventReconstructor::SetReconstructionParametersToDefaults(void)
 }
 
 //__________________________________________________________________________
-Double_t AliMUONEventReconstructor::GetImpactParamFromBendingMomentum(Double_t BendingMomentum) const
+Double_t AliMUONTrackReconstructor::GetImpactParamFromBendingMomentum(Double_t BendingMomentum) const
 {
   // Returns impact parameter at vertex in bending plane (cm),
   // from the signed bending momentum "BendingMomentum" in bending plane (GeV/c),
@@ -239,7 +237,7 @@ Double_t AliMUONEventReconstructor::GetImpactParamFromBendingMomentum(Double_t B
 }
 
 //__________________________________________________________________________
-Double_t AliMUONEventReconstructor::GetBendingMomentumFromImpactParam(Double_t ImpactParam) const
+Double_t AliMUONTrackReconstructor::GetBendingMomentumFromImpactParam(Double_t ImpactParam) const
 {
   // Returns signed bending momentum in bending plane (GeV/c),
   // the sign being the sign of the charge for particles moving forward in Z,
@@ -250,7 +248,7 @@ Double_t AliMUONEventReconstructor::GetBendingMomentumFromImpactParam(Double_t I
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::SetBkgTrackRefFile(Text_t *BkgTrackRefFileName)
+void AliMUONTrackReconstructor::SetBkgTrackRefFile(Text_t *BkgTrackRefFileName)
 {
   // Set background file ... for track ref. hits
   // Must be called after having loaded the firts signal event
@@ -291,7 +289,7 @@ void AliMUONEventReconstructor::SetBkgTrackRefFile(Text_t *BkgTrackRefFileName)
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::NextBkgTrackRefEvent(void)
+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
@@ -345,7 +343,7 @@ void AliMUONEventReconstructor::NextBkgTrackRefEvent(void)
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::EventReconstruct(void)
+void AliMUONTrackReconstructor::EventReconstruct(void)
 {
   // To reconstruct one event
   AliDebug(1,"Enter EventReconstruct");
@@ -365,7 +363,7 @@ void AliMUONEventReconstructor::EventReconstruct(void)
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::EventReconstructTrigger(void)
+void AliMUONTrackReconstructor::EventReconstructTrigger(void)
 {
   // To reconstruct one event
   AliDebug(1,"Enter EventReconstructTrigger");
@@ -374,7 +372,7 @@ void AliMUONEventReconstructor::EventReconstructTrigger(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::ResetHitsForRec(void)
+void AliMUONTrackReconstructor::ResetHitsForRec(void)
 {
   // To reset the array and the number of HitsForRec,
   // and also the number of HitsForRec
@@ -387,7 +385,7 @@ void AliMUONEventReconstructor::ResetHitsForRec(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::ResetSegments(void)
+void AliMUONTrackReconstructor::ResetSegments(void)
 {
   // To reset the TClonesArray of segments and the number of Segments
   // for all stations
@@ -399,7 +397,7 @@ void AliMUONEventReconstructor::ResetSegments(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::ResetTracks(void)
+void AliMUONTrackReconstructor::ResetTracks(void)
 {
   // To reset the TClonesArray of reconstructed tracks
   if (fRecTracksPtr) fRecTracksPtr->Delete();
@@ -411,7 +409,7 @@ void AliMUONEventReconstructor::ResetTracks(void)
 
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::ResetTrackHits(void)
+void AliMUONTrackReconstructor::ResetTrackHits(void)
 {
   // To reset the TClonesArray of hits on reconstructed tracks
   if (fRecTrackHitsPtr) fRecTrackHitsPtr->Clear();
@@ -420,7 +418,7 @@ void AliMUONEventReconstructor::ResetTrackHits(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::MakeEventToBeReconstructed(void)
+void AliMUONTrackReconstructor::MakeEventToBeReconstructed(void)
 {
   // To make the list of hits to be reconstructed,
   // either from the track ref. hits or from the raw clusters
@@ -503,7 +501,7 @@ void AliMUONEventReconstructor::MakeEventToBeReconstructed(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::AddHitsForRecFromTrackRef(TTree *TTR, Int_t signal)
+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.
@@ -534,7 +532,7 @@ void AliMUONEventReconstructor::AddHitsForRecFromTrackRef(TTree *TTR, Int_t sign
 
 
   //__________________________________________________________________________
-AliMUONHitForRec* AliMUONEventReconstructor::NewHitForRecFromTrackRef(AliTrackReference* Hit, Int_t TrackNumber, Int_t Signal)
+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",
@@ -588,7 +586,7 @@ AliMUONHitForRec* AliMUONEventReconstructor::NewHitForRecFromTrackRef(AliTrackRe
   return hitForRec;
 }
   //__________________________________________________________________________
-TClonesArray* AliMUONEventReconstructor::CleanTrackRefs(TTree *treeTR)
+TClonesArray* AliMUONTrackReconstructor::CleanTrackRefs(TTree *treeTR)
 {
   // Make hits from track ref..  
   // Re-calculate hits parameters because two AliTrackReferences are recorded for
@@ -672,7 +670,7 @@ TClonesArray* AliMUONEventReconstructor::CleanTrackRefs(TTree *treeTR)
  
 }
   //__________________________________________________________________________
-void AliMUONEventReconstructor::SortHitsForRecWithIncreasingChamber()
+void AliMUONTrackReconstructor::SortHitsForRecWithIncreasingChamber()
 {
   // Sort HitsForRec's in increasing order with respect to chamber number.
   // Uses the function "Compare".
@@ -702,7 +700,7 @@ void AliMUONEventReconstructor::SortHitsForRecWithIncreasingChamber()
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
+void AliMUONTrackReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
 {
   // To add to the list of hits for reconstruction all the raw clusters
   // No condition added, like in Fortran TRACKF_STAT,
@@ -761,7 +759,7 @@ void AliMUONEventReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::MakeSegments(void)
+void AliMUONTrackReconstructor::MakeSegments(void)
 {
   // To make the list of segments in all stations,
   // from the list of hits to be reconstructed
@@ -790,7 +788,7 @@ void AliMUONEventReconstructor::MakeSegments(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::MakeSegmentsPerStation(Int_t Station)
+void AliMUONTrackReconstructor::MakeSegmentsPerStation(Int_t Station)
 {
   // To make the list of segments in station number "Station" (0...)
   // from the list of hits to be reconstructed.
@@ -897,7 +895,7 @@ void AliMUONEventReconstructor::MakeSegmentsPerStation(Int_t Station)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::MakeTracks(void)
+void AliMUONTrackReconstructor::MakeTracks(void)
 {
   // To make the tracks,
   // from the list of segments and points in all stations
@@ -930,7 +928,7 @@ void AliMUONEventReconstructor::MakeTracks(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::ValidateTracksWithTrigger(void)
+void AliMUONTrackReconstructor::ValidateTracksWithTrigger(void)
 {
   // Try to match track from tracking system with trigger track
   AliMUONTrack *track;
@@ -949,7 +947,7 @@ void AliMUONEventReconstructor::ValidateTracksWithTrigger(void)
 }
 
   //__________________________________________________________________________
-Bool_t AliMUONEventReconstructor::MakeTriggerTracks(void)
+Bool_t AliMUONTrackReconstructor::MakeTriggerTracks(void)
 {
     // To make the trigger tracks from Local Trigger
   AliDebug(1, "Enter MakeTriggerTracks");
@@ -1034,7 +1032,7 @@ Bool_t AliMUONEventReconstructor::MakeTriggerTracks(void)
 }
 
   //__________________________________________________________________________
-Int_t AliMUONEventReconstructor::MakeTrackCandidatesWithTwoSegments(AliMUONSegment *BegSegment)
+Int_t AliMUONTrackReconstructor::MakeTrackCandidatesWithTwoSegments(AliMUONSegment *BegSegment)
 {
   // To make track candidates with two segments in stations(1..) 4 and 5,
   // the first segment being pointed to by "BegSegment".
@@ -1085,7 +1083,7 @@ Int_t AliMUONEventReconstructor::MakeTrackCandidatesWithTwoSegments(AliMUONSegme
 }
 
   //__________________________________________________________________________
-Int_t AliMUONEventReconstructor::MakeTrackCandidatesWithOneSegmentAndOnePoint(AliMUONSegment *BegSegment)
+Int_t AliMUONTrackReconstructor::MakeTrackCandidatesWithOneSegmentAndOnePoint(AliMUONSegment *BegSegment)
 {
   // To make track candidates with one segment and one point
   // in stations(1..) 4 and 5,
@@ -1145,7 +1143,7 @@ Int_t AliMUONEventReconstructor::MakeTrackCandidatesWithOneSegmentAndOnePoint(Al
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::MakeTrackCandidates(void)
+void AliMUONTrackReconstructor::MakeTrackCandidates(void)
 {
   // To make track candidates
   // with at least 3 aligned points in stations(1..) 4 and 5
@@ -1178,7 +1176,7 @@ void AliMUONEventReconstructor::MakeTrackCandidates(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::FollowTracks(void)
+void AliMUONTrackReconstructor::FollowTracks(void)
 {
   // Follow tracks in stations(1..) 3, 2 and 1
   // too long: should be made more modular !!!!
@@ -1406,7 +1404,7 @@ void AliMUONEventReconstructor::FollowTracks(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::RemoveDoubleTracks(void)
+void AliMUONTrackReconstructor::RemoveDoubleTracks(void)
 {
   // To remove double tracks.
   // Tracks are considered identical
@@ -1450,7 +1448,7 @@ void AliMUONEventReconstructor::RemoveDoubleTracks(void)
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::UpdateTrackParamAtHit()
+void AliMUONTrackReconstructor::UpdateTrackParamAtHit()
 {
   // Set track parameters after track fitting. Fill fTrackParamAtHit of AliMUONTrack's
   AliMUONTrack *track;
@@ -1470,7 +1468,7 @@ void AliMUONEventReconstructor::UpdateTrackParamAtHit()
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::UpdateHitForRecAtHit()
+void AliMUONTrackReconstructor::UpdateHitForRecAtHit()
 {
   // Set cluster parameterss after track fitting. Fill fHitForRecAtHit of AliMUONTrack's
   AliMUONTrack *track;
@@ -1490,7 +1488,7 @@ void AliMUONEventReconstructor::UpdateHitForRecAtHit()
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::FillMUONTrack()
+void AliMUONTrackReconstructor::FillMUONTrack()
 {
   // Set track parameters at hits for Kalman track. Fill fTrackParamAtHit of AliMUONTrack's
   AliMUONTrackK *track;
@@ -1503,7 +1501,7 @@ void AliMUONEventReconstructor::FillMUONTrack()
 }
 
   //__________________________________________________________________________
-void AliMUONEventReconstructor::EventDump(void)
+void AliMUONTrackReconstructor::EventDump(void)
 {
   // Dump reconstructed event (track parameters at vertex and at first hit),
   // and the particle parameters
@@ -1571,7 +1569,7 @@ void AliMUONEventReconstructor::EventDump(void)
 
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::EventDumpTrigger(void)
+void AliMUONTrackReconstructor::EventDumpTrigger(void)
 {
   // Dump reconstructed trigger event 
   // and the particle parameters
@@ -1593,7 +1591,7 @@ void AliMUONEventReconstructor::EventDumpTrigger(void)
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::MakeTrackCandidatesK(void)
+void AliMUONTrackReconstructor::MakeTrackCandidatesK(void)
 {
   // To make initial tracks for Kalman filter from the list of segments
   Int_t istat, iseg;
@@ -1622,7 +1620,7 @@ void AliMUONEventReconstructor::MakeTrackCandidatesK(void)
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::FollowTracksK(void)
+void AliMUONTrackReconstructor::FollowTracksK(void)
 {
   // Follow tracks using Kalman filter
   Bool_t ok;
@@ -1763,7 +1761,7 @@ void AliMUONEventReconstructor::FollowTracksK(void)
 }
 
 //__________________________________________________________________________
-Bool_t AliMUONEventReconstructor::CheckCandidateK(Int_t icand, Int_t nSeeds) const
+Bool_t AliMUONTrackReconstructor::CheckCandidateK(Int_t icand, Int_t nSeeds) const
 {
   // Discards track candidate if it will produce the double track (having
   // the same seed segment hits as hits of a good track found before)
@@ -1796,7 +1794,7 @@ Bool_t AliMUONEventReconstructor::CheckCandidateK(Int_t icand, Int_t nSeeds) con
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::RemoveDoubleTracksK(void)
+void AliMUONTrackReconstructor::RemoveDoubleTracksK(void)
 {
   // Removes double tracks (sharing more than half of their hits). Keeps
   // the track with higher quality
@@ -1830,7 +1828,7 @@ void AliMUONEventReconstructor::RemoveDoubleTracksK(void)
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::GoToVertex(void)
+void AliMUONTrackReconstructor::GoToVertex(void)
 {
   // Propagates track to the vertex thru absorber
   // (using Branson correction for now)
@@ -1846,7 +1844,7 @@ void AliMUONEventReconstructor::GoToVertex(void)
 }
 
 //__________________________________________________________________________
-void AliMUONEventReconstructor::SetTrackMethod(Int_t iTrackMethod)
+void AliMUONTrackReconstructor::SetTrackMethod(Int_t iTrackMethod)
 {
   // Set track method and recreate track container if necessary
   

diff --git a/MUON/AliMUONEventReconstructor.h b/MUON/AliMUONTrackReconstructor.h
similarity index 92%
rename from MUON/AliMUONEventReconstructor.h
rename to MUON/AliMUONTrackReconstructor.h
index 90ef83b53a3d887de0a1dcf608fd77d87bfd2cd2..6219cb6cc1a171546bd7d17850c8e7466b5dc7e9 100644 (file)
--- a/MUON/AliMUONEventReconstructor.h
+++ b/MUON/AliMUONTrackReconstructor.h
@@ -1,13 +1,8 @@
-#ifndef ALIMUONEVENTRECONSTRUCTOR_H
-#define ALIMUONEVENTRECONSTRUCTOR_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/*$Id$*/
-// Revision of includes 07/05/2004
+#ifndef ALIMUONTRACKTRECONSTRUCTOR_H
+#define ALIMUONTRACKRECONSTRUCTOR_H
 
 ////////////////////////////////////
-// MUON event reconstructor in ALICE
+// MUON track reconstructor in ALICE
 ////////////////////////////////////
 
 #include <TObject.h>
@@ -23,13 +18,13 @@ class AliRunLoader;
 class AliLoader;
 class AliTrackReference;
 
-class AliMUONEventReconstructor : public TObject {
+class AliMUONTrackReconstructor : public TObject {
 
  public:
-  AliMUONEventReconstructor(AliLoader* loader); // default Constructor
-  virtual ~AliMUONEventReconstructor(void); // Destructor
+  AliMUONTrackReconstructor(AliLoader* loader); // default Constructor
+  virtual ~AliMUONTrackReconstructor(void); // Destructor
 
-  // Parameters for event reconstruction: public methods
+  // Parameters for track reconstruction: public methods
   // Get and Set, Set to defaults
   Double_t GetMinBendingMomentum(void) const {return fMinBendingMomentum;}
   void SetMinBendingMomentum(Double_t MinBendingMomentum) {fMinBendingMomentum = MinBendingMomentum;}
@@ -91,8 +86,8 @@ class AliMUONEventReconstructor : public TObject {
   AliMUONData*  GetMUONData() {return fMUONData;}
 
  protected:
-  AliMUONEventReconstructor (const AliMUONEventReconstructor& rhs); // copy constructor
-  AliMUONEventReconstructor& operator=(const AliMUONEventReconstructor& rhs); // assignment operator
+  AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); // copy constructor
+  AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); // assignment operator
 
  private:
 
@@ -123,9 +118,9 @@ class AliMUONEventReconstructor : public TObject {
 
   Int_t fTrackMethod; // AZ - tracking method
 
-  // Parameters for event reconstruction
+  // Parameters for track reconstruction
   Double_t fMinBendingMomentum; // minimum value (GeV/c) of momentum in bending plane
-  // Parameters for event reconstruction
+  // Parameters for track reconstruction
   Double_t fMaxBendingMomentum; // maximum value (GeV/c) of momentum in bending plane
   Double_t fMaxChi2; // maximum Chi2 per degree of Freedom
   Double_t fMaxSigma2Distance; // maximum square distance in units of the variance (maximum chi2)
@@ -212,7 +207,7 @@ class AliMUONEventReconstructor : public TObject {
   Bool_t CheckCandidateK(Int_t icand, Int_t nSeeds) const;
 
 
-  ClassDef(AliMUONEventReconstructor, 0) // MUON event reconstructor in ALICE
+  ClassDef(AliMUONTrackReconstructor, 0) // MUON track reconstructor in ALICE
     };
        
 #endif

diff --git a/MUON/AliMUONTriggerTrack.cxx b/MUON/AliMUONTriggerTrack.cxx
index c0fa4e0223610e82b9c154479e591755f78bf58f..84412d18e35902869257cef8302b3a6d288f8d52 100644 (file)
--- a/MUON/AliMUONTriggerTrack.cxx
+++ b/MUON/AliMUONTriggerTrack.cxx
@@ -27,7 +27,7 @@
 ///////////////////////////////////////////////////
 
 #include "AliMUONTriggerTrack.h"
-#include "AliMUONEventReconstructor.h" 
+#include "AliMUONTrackReconstructor.h" 
 
 
 //__________________________________________________________________________

diff --git a/MUON/AliMUONTriggerTrack.h b/MUON/AliMUONTriggerTrack.h
index 68dd815061358c232a114aaa282b461350664cdc..29698fad6e46385e2795c74f0457a1c2ef61eb52 100644 (file)
--- a/MUON/AliMUONTriggerTrack.h
+++ b/MUON/AliMUONTriggerTrack.h
@@ -12,7 +12,7 @@
 
 #include <TObject.h>
 
-class AliMUONEventReconstructor;
+class AliMUONTrackReconstructor;
 
 class AliMUONTriggerTrack : public TObject 
 {

diff --git a/MUON/MUONTracker.C b/MUON/MUONTracker.C
index ebfd8db9a832879e1cd1f1e4dbfcb70502f8a968..da95c6ab614501fc03249b59b6cc261c2c6eaaaa 100644 (file)
--- a/MUON/MUONTracker.C
+++ b/MUON/MUONTracker.C
@@ -24,7 +24,7 @@
 #include "AliRun.h"
 #include "AliMUON.h"
 #include "AliMUONData.h"
-#include "AliMUONEventReconstructor.h"
+#include "AliMUONTrackReconstructor.h"
 #endif
 
 void MUONTracker (Int_t FirstEvent = 0, Int_t LastEvent = 9999, Text_t *FileName = "galice.root")
@@ -54,7 +54,7 @@ void MUONTracker (Int_t FirstEvent = 0, Int_t LastEvent = 9999, Text_t *FileName
   Int_t nevents;
   nevents = RunLoader->GetNumberOfEvents();
   
-  AliMUONEventReconstructor* Reco = new AliMUONEventReconstructor(MUONLoader);
+  AliMUONTrackReconstructor* Reco = new AliMUONTrackReconstructor(MUONLoader);
   AliMUONData* muondata = Reco->GetMUONData();
 
   // Testing if Tracker has already been done
@@ -67,7 +67,7 @@ void MUONTracker (Int_t FirstEvent = 0, Int_t LastEvent = 9999, Text_t *FileName
     }
   }
   
-  // The right place for changing AliMUONEventReconstructor parameters
+  // The right place for changing AliMUONTrackReconstructor parameters
   // with respect to the default ones
   //   Reco->SetMaxSigma2Distance(100.0);
   //   Reco->SetPrintLevel(20);

diff --git a/MUON/MUONrecLinkDef.h b/MUON/MUONrecLinkDef.h
index ddf94024f77c6ba5f9f19091aab979d7aa7dc065..99e35c83bfe98cf31b54d4a8c7b78e022ea8b3da 100644 (file)
--- a/MUON/MUONrecLinkDef.h
+++ b/MUON/MUONrecLinkDef.h
@@ -10,7 +10,7 @@
 #pragma link C++ class AliMUONPixel+; 
 #pragma link C++ class AliMUONClusterInput+; 
 #pragma link C++ class AliMUONReconstructor+;
-#pragma link C++ class AliMUONEventReconstructor+; 
+#pragma link C++ class AliMUONTrackReconstructor+; 
 #pragma link C++ class AliMUONTrack+; 
 #pragma link C++ class AliMUONTrackK+; 
 #pragma link C++ class AliMUONTrackParam+; 

diff --git a/MUON/libMUONrec.pkg b/MUON/libMUONrec.pkg
index c67509a3606e710286a8f793ced4458f56855ea4..320de220c18392493811e0fc20f79e8597987688 100644 (file)
--- a/MUON/libMUONrec.pkg
+++ b/MUON/libMUONrec.pkg
@@ -6,7 +6,7 @@ SRCS:= AliMUONClusterReconstructor.cxx \
        AliMUONPixel.cxx \
        AliMUONClusterInput.cxx \
        AliMUONReconstructor.cxx \
-       AliMUONEventReconstructor.cxx \
+       AliMUONTrackReconstructor.cxx \
        AliMUONTrack.cxx \
        AliMUONTrackK.cxx \
        AliMUONTrackParam.cxx \