TString AliMUONESDInterface::fgTriggerStoreName = "AliMUONTriggerStoreV1";
//_____________________________________________________________________________
-AliMUONESDInterface::AliMUONESDInterface()
+AliMUONESDInterface::AliMUONESDInterface(AliMUONRecoParam* recoParam)
: TObject(),
- fTracks(0x0),
- fDigits(0x0),
- fTriggers(0x0),
- fClusterMap(0x0),
- fDigitMap(0x0)
+fRecoParam(recoParam),
+fTracks(0x0),
+fDigits(0x0),
+fTriggers(0x0),
+fClusterMap(0x0),
+fDigitMap(0x0)
{
/// Default constructor
}
if (!esdTrack->ContainTrackerData()) continue;
// add it to track store
- AliMUONTrack* track = Add(*esdTrack, *fTracks);
+ AliMUONTrack* track = Add(GetRecoParam(),*esdTrack, *fTracks);
// prepare cluster map
AliMpExMap* cMap = new AliMpExMap;
}
//_____________________________________________________________________________
-void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track)
+void AliMUONESDInterface::ESDToMUON(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONTrack& track)
{
/// Transfert data from ESDMuon track to MUON track
AliMUONTrackExtrap::ExtrapToZCov(firstTrackParam,firstTrackParam->GetClusterPtr()->GetZ());
// refit the track to get better parameters and covariances at each cluster (temporary disable track improvement)
- if (!fgTracker) fgTracker = AliMUONTracker::CreateTrackReconstructor(AliMUONReconstructor::GetRecoParam()->GetTrackingMode(),0x0);
+ if (!fgTracker) fgTracker = AliMUONTracker::CreateTrackReconstructor(recoParam,0x0);
if (!fgTracker->RefitTrack(track, kFALSE)) track.UpdateCovTrackParamAtCluster();
} else {
}
//___________________________________________________________________________
-AliMUONTrack* AliMUONESDInterface::Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore)
+AliMUONTrack*
+AliMUONESDInterface::Add(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore)
{
/// Create MUON track from ESDMuon track and add it to the store
/// return a pointer to the track into the store (0x0 if the track already exist)
if(trackStore.FindObject(esdTrack.GetUniqueID())) return 0x0;
AliMUONTrack* track = trackStore.Add(AliMUONTrack());
- ESDToMUON(esdTrack, *track);
+ ESDToMUON(recoParam,esdTrack, *track);
return track;
}
class AliESDMuonCluster;
class AliESDMuonPad;
class TIterator;
+class AliMUONRecoParam;
class AliMUONESDInterface : public TObject
{
public: // methods to play with internal objects
- AliMUONESDInterface();
+ AliMUONESDInterface(AliMUONRecoParam* recoParam);
virtual ~AliMUONESDInterface();
virtual void Clear(Option_t* = "");
TIterator* CreateDigitIteratorInCluster(UInt_t clusterId) const;
TIterator* CreateLocalTriggerIterator() const;
+ const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
public: // static methods
static void SetParamCov(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack);
// ESDMuon objects --> MUON objects conversion
- static void ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track);
+ static void ESDToMUON(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONTrack& track);
static void ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONLocalTrigger& locTrg);
static void ESDToMUON(const AliESDMuonCluster& esdCluster, AliMUONVCluster& cluster);
static void ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit& digit);
// Add ESD object into the corresponding MUON store
// return a pointer to the corresponding MUON object into the store
- static AliMUONTrack* Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore);
+ static AliMUONTrack* Add(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore);
static void Add(const AliESDMuonTrack& esdTrack, AliMUONVTriggerStore& triggerStore);
static AliMUONVCluster* Add(const AliESDMuonCluster& esdCluster, AliMUONVClusterStore& clusterStore);
static AliMUONVDigit* Add(const AliESDMuonPad& esdPad, AliMUONVDigitStore& digitStore);
AliMpExMap* fClusterMap; ///< map of clusters
AliMpExMap* fDigitMap; ///< map of digits
-
+ const AliMUONRecoParam* fRecoParam; ///< get reco param
+
ClassDef(AliMUONESDInterface,0)
};
#include "AliMUONPainterEnv.h"
#include "AliMUONPainterHelper.h"
#include "AliMUONPainterRegistry.h"
+#include "AliMUONRecoParam.h"
#include "AliMUONTrackerACFDataMaker.h"
#include "AliMUONTrackerCalibratedDataMaker.h"
#include "AliMUONTrackerOCDBDataMaker.h"
if ( ocdbPath.Length() > 0 )
{
- reader = new AliMUONTrackerCalibratedDataMaker(rawReader,ocdbPath.Data(),
+ AliMUONRecoParam* recoParam = AliMUONRecoParam::GetCosmicParam();
+
+ // FIXME: where to get the reco params from in reality ?
+
+ reader = new AliMUONTrackerCalibratedDataMaker(recoParam,
+ rawReader,
+ ocdbPath.Data(),
calibMode.Data(),
histogram,
sxmin.Atof(),
#include "AliMUONLocalTrigger.h"
#include "AliMUONRawStreamTracker.h"
#include "AliMUONRawStreamTrigger.h"
+#include "AliMUONRecoParam.h"
#include "AliMUONRegHeader.h"
#include "AliMUONTrackerCalibratedDataMaker.h"
#include "AliMUONTriggerDisplay.h"
/// \endcond
//____________________________________________________________________________
-AliMUONQADataMakerRec::AliMUONQADataMakerRec() :
+AliMUONQADataMakerRec::AliMUONQADataMakerRec(const AliMUONRecoParam* recoParam) :
AliQADataMakerRec(AliQA::GetDetName(AliQA::kMUON), "MUON Quality Assurance Data Maker"),
fIsInitRaws(kFALSE),
fIsInitRecPointsTracker(kFALSE),
fTriggerStore(0x0),
fDigitMaker(0x0),
fClusterStore(0x0),
-fTrackerDataMaker(0x0)
+fTrackerDataMaker(0x0),
+fRecoParam(recoParam)
{
/// ctor
// fTrackerDataMaker = new AliMUONTrackerRawDataMaker(rawReader,histogram,fastDecoder,takeRawReaderOwnership);
- fTrackerDataMaker = new AliMUONTrackerCalibratedDataMaker(AliCDBManager::Instance()->GetRun(),
+ fTrackerDataMaker = new AliMUONTrackerCalibratedDataMaker(GetRecoParam(),
+ AliCDBManager::Instance()->GetRun(),
rawReader,
AliCDBManager::Instance()->GetDefaultStorage()->GetURI(),
"NOGAIN",
#include "AliQADataMakerRec.h"
class AliMUONVTrackerDataMaker;
+class AliMUONRecoParam;
class AliMUONQADataMakerRec: public AliQADataMakerRec {
public:
- AliMUONQADataMakerRec();
+ AliMUONQADataMakerRec(const AliMUONRecoParam* recoParam);
AliMUONQADataMakerRec(const AliMUONQADataMakerRec& qadm);
AliMUONQADataMakerRec& operator=(const AliMUONQADataMakerRec& qadm);
virtual ~AliMUONQADataMakerRec();
void MakeRecPointsTracker(TTree* treeR);
void MakeRecPointsTrigger(TTree* treeR);
+ const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
+
Bool_t fIsInitRaws; //!< info if InitRaws() went ok
Bool_t fIsInitRecPointsTracker; //!< info if InitRecPoints() went ok
Bool_t fIsInitRecPointsTrigger; //!< info if InitRecPoints() went ok
AliMUONVTrackerDataMaker* fTrackerDataMaker; //!< tracker data accumulation
+ const AliMUONRecoParam* fRecoParam; //!< pointer to reco params
+
ClassDef(AliMUONQADataMakerRec,3) // MUON Quality assurance data maker
};
#include "AliMUONVClusterStore.h"
#include "AliMUONConstants.h"
#include "AliMUONESDInterface.h"
-
+#include "AliMUONRecoParam.h"
#include "AliMCEventHandler.h"
#include "AliMCEvent.h"
#include "AliStack.h"
/// \endcond
//_____________________________________________________________________________
-AliMUONRecoCheck::AliMUONRecoCheck(Char_t *esdFileName, Char_t *pathSim)
+AliMUONRecoCheck::AliMUONRecoCheck(AliMUONRecoParam* recoParam, Char_t *esdFileName, Char_t *pathSim)
: TObject(),
+fRecoParam(recoParam),
fMCEventHandler(new AliMCEventHandler()),
fESDEvent(new AliESDEvent()),
fESDTree (0x0),
Int_t nTracks = (Int_t) fESDEvent->GetNumberOfMuonTracks();
for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
AliESDMuonTrack* esdTrack = fESDEvent->GetMuonTrack(iTrack);
- if (esdTrack->ContainTrackerData()) AliMUONESDInterface::Add(*esdTrack, *fRecoTrackStore);
+ if (esdTrack->ContainTrackerData()) AliMUONESDInterface::Add(GetRecoParam(),*esdTrack, *fRecoTrackStore);
}
}
class AliESDEvent;
class AliMCEventHandler;
class AliMUONVTrackStore;
+class AliMUONRecoParam;
class AliMUONRecoCheck : public TObject
{
public:
- AliMUONRecoCheck(Char_t *chLoader, Char_t *pathSim = "./");
+ AliMUONRecoCheck(AliMUONRecoParam* recoParam, Char_t *chLoader, Char_t *pathSim = "./");
virtual ~AliMUONRecoCheck();
/// Return the list of reconstructed tracks
/// Not implemented
AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
+ const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
+
void ResetStores();
void MakeReconstructedTracks();
AliMUONVTrackStore* fRecoTrackRefStore; ///< current reconstructible tracks (owner)
AliMUONVTrackStore* fRecoTrackStore; ///< current reconstructed tracks (owner)
+ const AliMUONRecoParam* fRecoParam; ///< pointer to reco param
+
ClassDef(AliMUONRecoCheck, 0) //Utility class to check reconstruction
};
AliMUONTracker* tracker(0x0);
- if ( ! AliMUONReconstructor::GetRecoParam()->CombineClusterTrackReco() )
+ if ( ! GetRecoParam()->CombineClusterTrackReco() )
{
- tracker = new AliMUONTracker(0x0,
+ tracker = new AliMUONTracker(GetRecoParam(),
+ 0x0,
*DigitStore(),
fDigitMaker,
fTransformer,
}
else
{
- tracker = new AliMUONTracker(fClusterServer,
+ tracker = new AliMUONTracker(GetRecoParam(),
+ fClusterServer,
*DigitStore(),
fDigitMaker,
fTransformer,
Bool_t ok(kFALSE);
Bool_t alone(kTRUE); // is trigger the only info in TreeR ?
- if ( ! AliMUONReconstructor::GetRecoParam()->CombineClusterTrackReco() )
+ if ( ! GetRecoParam()->CombineClusterTrackReco() )
{
alone = kFALSE; // we'll get both tracker and trigger information in TreeR
}
for ( Int_t i = 0; i < AliMpConstants::NofTrackingChambers(); ++i )
{
- if (AliMUONReconstructor::GetRecoParam()->UseChamber(i))
+ if (GetRecoParam()->UseChamber(i))
{
- if ( ( i == 6 || i == 7 ) && AliMUONReconstructor::GetRecoParam()->BypassSt4() ) continue;
- if ( ( i == 8 || i == 9 ) && AliMUONReconstructor::GetRecoParam()->BypassSt5() ) continue;
+ if ( ( i == 6 || i == 7 ) && GetRecoParam()->BypassSt4() ) continue;
+ if ( ( i == 8 || i == 9 ) && GetRecoParam()->BypassSt5() ) continue;
fClusterServer->Clusterize(i,*fClusterStore,area);
}
class AliMUONDigitCalibrator;
class AliMUONDigitMaker;
class AliMUONGeometryTransformer;
-class AliMUONRecoParam;
class AliMUONTracker;
class AliMUONTriggerCircuit;
class AliMUONVClusterFinder;
class AliMUONVTriggerStore;
class TClonesArray;
-#include "AliDetectorRecoParam.h"
#include "AliMUONRecoParam.h"
class AliMUONReconstructor : public AliReconstructor
/// \endcond
//_____________________________________________________________________________
-AliMUONRefitter::AliMUONRefitter()
+AliMUONRefitter::AliMUONRefitter(const AliMUONRecoParam* recoParam)
: TObject(),
fGeometryTransformer(0x0),
fClusterServer(0x0),
/// Default constructor
CreateGeometryTransformer();
CreateClusterServer(*fGeometryTransformer);
- if (fClusterServer) fTracker = AliMUONTracker::CreateTrackReconstructor(AliMUONReconstructor::GetRecoParam()->GetTrackingMode(),fClusterServer);
+ if (fClusterServer) fTracker = AliMUONTracker::CreateTrackReconstructor(recoParam,fClusterServer);
if (!fClusterServer || !fTracker) {
AliFatal("refitter initialization failed");
exit(-1);
void AliMUONRefitter::CreateClusterServer(AliMUONGeometryTransformer& transformer)
{
/// Create cluster server
- AliMUONVClusterFinder* clusterFinder = AliMUONReconstructor::CreateClusterFinder(AliMUONReconstructor::GetRecoParam()->GetClusteringMode());
+ AliMUONVClusterFinder* clusterFinder = AliMUONReconstructor::CreateClusterFinder(GetRecoParam()->GetClusteringMode());
fClusterServer = clusterFinder ? new AliMUONSimpleClusterServer(clusterFinder,transformer) : 0x0;
}
class AliMUONVClusterStore;
class AliMUONVTrackStore;
class AliMUONTrack;
+class AliMUONRecoParam;
class AliMUONRefitter : public TObject
{
public:
- AliMUONRefitter();
+ AliMUONRefitter(const AliMUONRecoParam* recoParam);
virtual ~AliMUONRefitter();
/// connect to the ESD interface containing MUON data to refit
void AddClusterToTracks(const AliMUONVClusterStore &localClusterStore, AliMUONVTrackStore &trackStore);
+ const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
private:
AliMUONVTrackReconstructor* fTracker; ///< tracker (owner)
AliMUONESDInterface* fESDInterface; ///< container of MUON tracks/clusters/digits (not owner)
+ const AliMUONRecoParam* fRecoParam; ///< pointer to reco param
ClassDef(AliMUONRefitter,0)
};
}
//__________________________________________________________________________
-AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment)
+AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment, Double_t bendingVertexDispersion)
: TObject(),
fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)),
fFitWithVertex(kFALSE),
paramCov(3,2) = paramCov(2,3);
paramCov(3,3) = ( firstCluster->GetErrY2() + lastCluster->GetErrY2() ) / dZ / dZ;
// Inverse bending momentum (vertex resolution + bending slope resolution + 10% error on dipole parameters+field)
- paramCov(4,4) = ((AliMUONReconstructor::GetRecoParam()->GetBendingVertexDispersion() *
- AliMUONReconstructor::GetRecoParam()->GetBendingVertexDispersion() +
+ paramCov(4,4) = ( ( bendingVertexDispersion*bendingVertexDispersion +
(z1 * z1 * lastCluster->GetErrY2() + z2 * z2 * firstCluster->GetErrY2()) / dZ / dZ) /
- bendingImpact / bendingImpact + 0.1 * 0.1) * inverseBendingMomentum * inverseBendingMomentum;
+ bendingImpact / bendingImpact + 0.1 * 0.1) * inverseBendingMomentum * inverseBendingMomentum ;
paramCov(2,4) = - z2 * firstCluster->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ;
paramCov(4,2) = paramCov(2,4);
paramCov(3,4) = - (z1 * lastCluster->GetErrY2() + z2 * firstCluster->GetErrY2()) * inverseBendingMomentum / bendingImpact / dZ / dZ;
}
//__________________________________________________________________________
-Bool_t AliMUONTrack::IsValid()
+Bool_t AliMUONTrack::IsValid(UInt_t requestedStationMask)
{
/// check the validity of the current track (at least one cluster per requested station)
Int_t nClusters = GetNClusters();
AliMUONTrackParam *trackParam;
- Int_t currentStation = 0, expectedStation = 0;
+ Int_t currentStation(0);
- for (Int_t i = 0; i < nClusters; i++) {
+ UInt_t m(0);
+
+ for (Int_t i = 0; i < nClusters; i++)
+ {
trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i);
// skip unrequested stations
- while (expectedStation < AliMUONConstants::NTrackingSt() &&
- !AliMUONReconstructor::GetRecoParam()->RequestStation(expectedStation)) expectedStation++;
-
+// while (expectedStation < AliMUONConstants::NTrackingSt() &&
+// !AliMUONReconstructor::GetRecoParam()->RequestStation(expectedStation)) expectedStation++;
+//
+
currentStation = trackParam->GetClusterPtr()->GetChamberId()/2;
- // missing station
- if (currentStation > expectedStation) return kFALSE;
-
- // found station --> look for next one
- if (currentStation == expectedStation) expectedStation++;
+ m |= ( 1 << currentStation );
}
- return expectedStation == AliMUONConstants::NTrackingSt();
-
+ return ( (requestedStationMask & m) == requestedStationMask ) ;
}
//__________________________________________________________________________
-void AliMUONTrack::TagRemovableClusters() {
+void AliMUONTrack::TagRemovableClusters(UInt_t requestedStationMask) {
/// Identify clusters that can be removed from the track,
/// with the only requirement to have at least 1 cluster per requested station
// reset flags to kFALSE for all clusters in required station
for (Int_t i = 0; i < nClusters; i++) {
trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i);
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(trackParam->GetClusterPtr()->GetChamberId()/2))
+ Int_t stationId = ( 1 << (trackParam->GetClusterPtr()->GetChamberId()/2) );
+ UInt_t m = ( 1 << stationId );
+ if ( m & requestedStationMask )
trackParam->SetRemovable(kFALSE);
else trackParam->SetRemovable(kTRUE);
}
{
public:
AliMUONTrack(); // Default constructor
- AliMUONTrack(AliMUONObjectPair *segment); // Constructor from a segment
+ AliMUONTrack(AliMUONObjectPair *segment, Double_t bendingVertexDispersion); // Constructor from a segment
virtual ~AliMUONTrack(); // Destructor
AliMUONTrack (const AliMUONTrack& track); // copy constructor
AliMUONTrack& operator=(const AliMUONTrack& track); // assignment operator
void UpdateTrackParamAtCluster();
void UpdateCovTrackParamAtCluster();
- Bool_t IsValid();
+ Bool_t IsValid(UInt_t requestedStationMask);
- void TagRemovableClusters();
+ void TagRemovableClusters(UInt_t requestedStationMask);
/// return the number of clusters attached to the track
Int_t GetNClusters() const {return fTrackParamAtCluster ? fTrackParamAtCluster->GetEntriesFast() : 0;}
#include "AliMUONGeometryTransformer.h"
#include "AliMUONLocalTrigger.h"
#include "AliMUONLocalTriggerBoard.h"
+#include "AliMUONRecoParam.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackExtrap.h"
#include "AliMUONTrackParam.h"
//______________________________________________________________________________
-AliMUONTrackHitPattern::AliMUONTrackHitPattern(const AliMUONGeometryTransformer& transformer,
+AliMUONTrackHitPattern::AliMUONTrackHitPattern(const AliMUONRecoParam* recoParam,
+ const AliMUONGeometryTransformer& transformer,
const AliMUONDigitMaker& digitMaker)
- : TObject(),
- fTransformer(transformer),
- fDigitMaker(digitMaker),
- fDeltaZ(0.0),
- fTrigCovariance(0x0),
- fkMaxDistance(99999.)
+: TObject(),
+fRecoParam(recoParam),
+fTransformer(transformer),
+fDigitMaker(digitMaker),
+fDeltaZ(0.0),
+fTrigCovariance(0x0),
+fkMaxDistance(99999.)
{
/// Default constructor
InitMembers();
}
chi2 /= 3.; // Normalized Chi2: 3 degrees of freedom (X,Y,slopeY)
- if (chi2 < AliMUONReconstructor::GetRecoParam()->GetMaxNormChi2MatchTrigger())
+ if (chi2 < GetRecoParam()->GetMaxNormChi2MatchTrigger())
{
Bool_t isDoubleTrack = (TMath::Abs(chi2 - minChi2MatchTrigger)<1.);
- if (chi2 < minChi2MatchTrigger && chi2 < AliMUONReconstructor::GetRecoParam()->GetMaxNormChi2MatchTrigger())
+ if (chi2 < minChi2MatchTrigger && chi2 < GetRecoParam()->GetMaxNormChi2MatchTrigger())
{
if(isDoubleTrack)
{
Float_t xTrackAtPad = trackParamAtPadZ.GetNonBendingCoor();
Float_t yTrackAtPad = trackParamAtPadZ.GetBendingCoor();
- const Float_t kNSigma = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTrigger();
+ const Float_t kNSigma = GetRecoParam()->GetSigmaCutForTrigger();
const TMatrixD& kCovParam = trackParamAtPadZ.GetCovariances();
/// Decides if the digit belongs to the trigger track.
//
- Float_t maxDist = AliMUONReconstructor::GetRecoParam()->GetStripCutForTrigger() * 2. * TMath::Min(dpx,dpy); // cm
+ Float_t maxDist = GetRecoParam()->GetStripCutForTrigger() * 2. * TMath::Min(dpx,dpy); // cm
if(maxDist<2.) maxDist = 2.;
- Float_t maxDistCheckArea = AliMUONReconstructor::GetRecoParam()->GetMaxStripAreaForTrigger() * 2. * TMath::Min(dpx,dpy); // cm
+ Float_t maxDistCheckArea = GetRecoParam()->GetMaxStripAreaForTrigger() * 2. * TMath::Min(dpx,dpy); // cm
Float_t matchDist = fkMaxDistance;
class AliMUONVDigitStore;
class AliMUONTriggerTrack;
class AliMUONTrack;
+class AliMUONRecoParam;
class AliMUONTrackHitPattern : public TObject
{
public:
- AliMUONTrackHitPattern(const AliMUONGeometryTransformer& transformer,
+ AliMUONTrackHitPattern(const AliMUONRecoParam* recoParam,
+ const AliMUONGeometryTransformer& transformer,
const AliMUONDigitMaker& digitMaker);
virtual ~AliMUONTrackHitPattern(); // Destructor
void LocalBoardFromPos(Float_t x, Float_t y, Int_t detElemId,
Int_t cathode, Int_t localBoard[4]) const;
+ const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
+
private:
/// Not implemented
AliMUONTrackHitPattern(const AliMUONTrackHitPattern& rhs);
kBoardEff
};
+ const AliMUONRecoParam* fRecoParam; //!< pointer to reco parameters
+
ClassDef(AliMUONTrackHitPattern, 0) // MUON track hit pattern
};
/// \endcond
//__________________________________________________________________________
-AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliMUONVClusterServer* clusterServer)
- : AliMUONVTrackReconstructor(clusterServer)
+AliMUONTrackReconstructor::AliMUONTrackReconstructor(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer)
+ : AliMUONVTrackReconstructor(recoParam,clusterServer)
{
/// Constructor
}
Int_t firstChamber(0);
Int_t lastChamber(9);
- if (AliMUONReconstructor::GetRecoParam()->CombineClusterTrackReco()) {
+ if (GetRecoParam()->CombineClusterTrackReco()) {
// ... Here's the exception : ask the clustering to reconstruct
// clusters *only* in station 4 and 5 for combined tracking
firstChamber = 6;
for (Int_t i = firstChamber; i <= lastChamber; ++i )
{
- if (fClusterServer && AliMUONReconstructor::GetRecoParam()->UseChamber(i)) fClusterServer->Clusterize(i, clusterStore, AliMpArea());
+ if (fClusterServer && GetRecoParam()->UseChamber(i)) fClusterServer->Clusterize(i, clusterStore, AliMpArea());
}
// Loop over stations(1..) 5 and 4 and make track candidates
AliDebug(1,Form("Making primary candidate(1..) %d",++iCandidate));
// Transform segments to tracks and put them at the end of fRecTracksPtr
- track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]));
+ track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]),GetRecoParam()->GetBendingVertexDispersion());
fNRecTracks++;
// Look for compatible cluster(s) in the other station
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast())
+ if (GetRecoParam()->MakeTrackCandidatesFast())
clusterFound = FollowLinearTrackInStation(*track, clusterStore, 7-istat);
else clusterFound = FollowTrackInStation(*track, clusterStore, 7-istat);
// Remove track if no cluster found
- if (!clusterFound && AliMUONReconstructor::GetRecoParam()->RequestStation(7-istat)) {
+ if (!clusterFound && GetRecoParam()->RequestStation(7-istat)) {
fRecTracksPtr->Remove(track);
fNRecTracks--;
}
fRecTracksPtr->Compress(); // this is essential before checking tracks
// Keep all different tracks or only the best ones as required
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
+ if (GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
else RemoveDoubleTracks();
AliDebug(1,Form("Number of good candidates = %d",fNRecTracks));
// Transform segments to tracks and put them at the end of fRecTracksPtr
iCurrentTrack = fRecTracksPtr->GetLast()+1;
- track = new ((*fRecTracksPtr)[iCurrentTrack]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]));
+ track = new ((*fRecTracksPtr)[iCurrentTrack]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]),GetRecoParam()->GetBendingVertexDispersion());
fNRecTracks++;
// Look for compatible cluster(s) in the second chamber of station 5
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast())
+ if (GetRecoParam()->MakeTrackCandidatesFast())
clusterFound = FollowLinearTrackInChamber(*track, clusterStore, 17-ich2);
else clusterFound = FollowTrackInChamber(*track, clusterStore, 17-ich2);
// skip the original track in case it has been removed
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks() && clusterFound) iCurrentTrack++;
+ if (GetRecoParam()->TrackAllTracks() && clusterFound) iCurrentTrack++;
// loop over every new tracks
nCurrentTracks = fRecTracksPtr->GetLast()+1;
track = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iCurrentTrack);
// Look for compatible cluster(s) in the second chamber of station 4
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast())
+ if (GetRecoParam()->MakeTrackCandidatesFast())
FollowLinearTrackInChamber(*track, clusterStore, 13-ich1);
else FollowTrackInChamber(*track, clusterStore, 13-ich1);
fRecTracksPtr->Compress(); // this is essential before checking tracks
// Keep all different tracks or only the best ones as required
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
+ if (GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
else RemoveDoubleTracks();
AliDebug(1,Form("Number of good candidates = %d",fNRecTracks));
AliMUONTrackParam *trackParam, *nextTrackParam;
Int_t currentNRecTracks;
- Double_t sigmaCut2 = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking();
+ Double_t sigmaCut2 = GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking();
for (Int_t station = 2; station >= 0; station--) {
// remove track with absolute bending momentum out of limits
// or if the normalized chi2 is too high
Double_t bendingMomentum = TMath::Abs(1. / ((AliMUONTrackParam*)track->GetTrackParamAtCluster()->First())->GetInverseBendingMomentum());
- if (bendingMomentum < AliMUONReconstructor::GetRecoParam()->GetMinBendingMomentum() ||
- bendingMomentum > AliMUONReconstructor::GetRecoParam()->GetMaxBendingMomentum() ||
+ if (bendingMomentum < GetRecoParam()->GetMinBendingMomentum() ||
+ bendingMomentum > GetRecoParam()->GetMaxBendingMomentum() ||
track->GetNormalizedChi2() > sigmaCut2) {
fRecTracksPtr->Remove(track);
fNRecTracks--;
}
// save parameters from fit into smoothed parameters to complete track afterward
- if (AliMUONReconstructor::GetRecoParam()->ComplementTracks()) {
+ if (GetRecoParam()->ComplementTracks()) {
if (station==2) { // save track parameters on stations 4 and 5
if (!FollowTrackInStation(*track, clusterStore, station)) {
// Try to recover track if required
- if (AliMUONReconstructor::GetRecoParam()->RecoverTracks()) {
+ if (GetRecoParam()->RecoverTracks()) {
// work on a copy of the track if this station is not required
// to keep the case where no cluster is reconstructed as a possible candidate
- if (!AliMUONReconstructor::GetRecoParam()->RequestStation(station)) {
+ if (!GetRecoParam()->RequestStation(station)) {
track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(*track);
fNRecTracks++;
}
fNRecTracks--;
}
- } else if (AliMUONReconstructor::GetRecoParam()->RequestStation(station)) {
+ } else if (GetRecoParam()->RequestStation(station)) {
// remove track if no cluster found
fRecTracksPtr->Remove(track);
fNRecTracks--;
fRecTracksPtr->Compress();
// Keep only the best tracks if required
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) RemoveDoubleTracks();
+ if (!GetRecoParam()->TrackAllTracks()) RemoveDoubleTracks();
}
}
// save parameters from fit into smoothed parameters to complete track afterward
- if (AliMUONReconstructor::GetRecoParam()->ComplementTracks()) {
+ if (GetRecoParam()->ComplementTracks()) {
trackParam = (AliMUONTrackParam*) track->GetTrackParamAtCluster()->First();
if (trackParam->GetClusterPtr()->GetChamberId() < 2) {
AliDebug(1,Form("Enter FollowTrackInChamber(1..) %d", nextChamber+1));
Double_t chi2WithOneCluster = 1.e10;
- Double_t maxChi2WithOneCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t maxChi2WithOneCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
Double_t bestChi2WithOneCluster = maxChi2WithOneCluster;
Bool_t foundOneCluster = kFALSE;
AliMUONTrack *newTrack = 0x0;
// Ask the clustering to reconstruct new clusters around the track position in the current chamber
// except for station 4 and 5 that are already entirely clusterized
- if (AliMUONReconstructor::GetRecoParam()->CombineClusterTrackReco()) {
+ if (GetRecoParam()->CombineClusterTrackReco()) {
if (nextChamber < 6) AskForNewClustersInChamber(extrapTrackParamAtCh, clusterStore, nextChamber);
}
cluster->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
UpdateTrack(*newTrack,extrapTrackParamAtCluster);
}
// fill out the best track if required else clean up the fRecTracksPtr array
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (!GetRecoParam()->TrackAllTracks()) {
if (foundOneCluster) {
UpdateTrack(trackCandidate,bestTrackParamAtCluster);
Double_t chi2WithOneCluster = 1.e10;
Double_t chi2WithTwoClusters = 1.e10;
- Double_t maxChi2WithOneCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
- Double_t maxChi2WithTwoClusters = 4. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 4 because 4 quantities in chi2
+ Double_t maxChi2WithOneCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t maxChi2WithTwoClusters = 4. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 4 because 4 quantities in chi2
Double_t bestChi2WithOneCluster = maxChi2WithOneCluster;
Double_t bestChi2WithTwoClusters = maxChi2WithTwoClusters;
Bool_t foundOneCluster = kFALSE;
// Ask the clustering to reconstruct new clusters around the track position in the current station
// except for station 4 and 5 that are already entirely clusterized
- if (AliMUONReconstructor::GetRecoParam()->CombineClusterTrackReco()) {
+ if (GetRecoParam()->CombineClusterTrackReco()) {
if (nextStation < 3) AskForNewClustersInStation(extrapTrackParamAtCh, clusterStore, nextStation);
}
clusterCh1->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new clusters
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
UpdateTrack(*newTrack,extrapTrackParamAtCluster1,extrapTrackParamAtCluster2);
if (!foundSecondCluster) {
foundOneCluster = kTRUE;
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
UpdateTrack(*newTrack,extrapTrackParamAtCluster2);
// look for candidates in chamber 1 not already attached to a track
// if we want to keep all possible tracks or if no good couple of clusters has been found
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
+ if (GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
// add MCS effect for next step
AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
clusterCh1->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
UpdateTrack(*newTrack,extrapTrackParamAtCluster1);
}
// fill out the best track if required else clean up the fRecTracksPtr array
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (!GetRecoParam()->TrackAllTracks()) {
if (foundTwoClusters) {
UpdateTrack(trackCandidate,bestTrackParamAtCluster1,bestTrackParamAtCluster2);
deltaY*deltaY / cluster->GetErrY2();
// Flag cluster as being not removable
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(cluster->GetChamberId()/2))
+ if (GetRecoParam()->RequestStation(cluster->GetChamberId()/2))
trackParamAtCluster.SetRemovable(kFALSE);
else trackParamAtCluster.SetRemovable(kTRUE);
trackParamAtCluster.SetLocalChi2(0.); // --> Local chi2 not used
if (!trackParamAtCluster->IsRemovable()) return kFALSE;
// reset the current cluster as beig not removable if it is on a required station
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextStation+1)) trackParamAtCluster->SetRemovable(kFALSE);
+ if (GetRecoParam()->RequestStation(nextStation+1)) trackParamAtCluster->SetRemovable(kFALSE);
// Pick up cluster with the worst chi2
localChi2 = trackParamAtCluster->GetLocalChi2();
/// the "trackCandidate" to do not influence the result by changing track resolution at vertex
AliDebug(1,"Enter SetVertexForFit");
- Double_t nonBendingReso2 = AliMUONReconstructor::GetRecoParam()->GetNonBendingVertexDispersion() *
- AliMUONReconstructor::GetRecoParam()->GetNonBendingVertexDispersion();
- Double_t bendingReso2 = AliMUONReconstructor::GetRecoParam()->GetBendingVertexDispersion() *
- AliMUONReconstructor::GetRecoParam()->GetBendingVertexDispersion();
+ Double_t nonBendingReso2 = GetRecoParam()->GetNonBendingVertexDispersion() *
+ GetRecoParam()->GetNonBendingVertexDispersion();
+ Double_t bendingReso2 = GetRecoParam()->GetBendingVertexDispersion() *
+ GetRecoParam()->GetBendingVertexDispersion();
// add multiple scattering effets
AliMUONTrackParam paramAtVertex(*((AliMUONTrackParam*)(trackCandidate.GetTrackParamAtCluster()->First())));
// Set fitted parameters (!! The order is very important for the covariance matrix !!)
// Mandatory limits to avoid NaN values of parameters
trackParam = (AliMUONTrackParam*) (track.GetTrackParamAtCluster()->First());
- Double_t maxIBM = 1. / AliMUONReconstructor::GetRecoParam()->GetMinBendingMomentum();
+ Double_t maxIBM = 1. / GetRecoParam()->GetMinBendingMomentum();
gMinuit->mnparm(0, "X", trackParam->GetNonBendingCoor(), 0.03, -500.0, 500.0, status);
gMinuit->mnparm(1, "NonBenS", trackParam->GetNonBendingSlope(), 0.001, -1., 1., status);
gMinuit->mnparm(2, "Y", trackParam->GetBendingCoor(), 0.10, -500.0, 500.0, status);
Int_t chamberId, detElemId;
Double_t chi2OfCluster, bestChi2OfCluster;
- Double_t sigmaCut2 = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking();
+ Double_t sigmaCut2 = GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking();
Bool_t foundOneCluster, trackModified;
AliMUONVCluster* cluster;
AliMUONTrackParam *trackParam, *nextTrackParam, copyOfTrackParam, trackParamAtCluster, bestTrackParamAtCluster;
Double_t localChi2, worstLocalChi2;
AliMUONTrackParam *trackParamAtCluster, *worstTrackParamAtCluster;
- Double_t sigmaCut2 = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForImprovement() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForImprovement();
+ Double_t sigmaCut2 = GetRecoParam()->GetSigmaCutForImprovement() *
+ GetRecoParam()->GetSigmaCutForImprovement();
while (!track.IsImproved()) {
// identify removable clusters
- track.TagRemovableClusters();
+ track.TagRemovableClusters(GetRecoParam()->RequestedStationMask());
// Update track parameters and covariances
track.UpdateCovTrackParamAtCluster();
/// re-fit the given track
// check validity of the track
- if (!track.IsValid()) {
+ if (!track.IsValid(GetRecoParam()->RequestedStationMask())) {
AliWarning("the track does not contain enough clusters --> unable to refit");
return kFALSE;
}
// Improve the reconstructed tracks if required
track.SetImproved(kFALSE);
- if (enableImprovement && AliMUONReconstructor::GetRecoParam()->ImproveTracks()) ImproveTrack(track);
+ if (enableImprovement && GetRecoParam()->ImproveTracks()) ImproveTrack(track);
// Fill AliMUONTrack data members
FinalizeTrack(track);
public:
- AliMUONTrackReconstructor(AliMUONVClusterServer* clusterServer); // default Constructor
+ AliMUONTrackReconstructor(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer); // default Constructor
virtual ~AliMUONTrackReconstructor(); // Destructor
virtual Bool_t RefitTrack(AliMUONTrack &track, Bool_t enableImprovement = kTRUE);
/// \endcond
//__________________________________________________________________________
-AliMUONTrackReconstructorK::AliMUONTrackReconstructorK(AliMUONVClusterServer* clusterServer)
- : AliMUONVTrackReconstructor(clusterServer)
+AliMUONTrackReconstructorK::AliMUONTrackReconstructorK(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer)
+ : AliMUONVTrackReconstructor(recoParam, clusterServer)
{
/// Constructor
}
Int_t firstChamber(0);
Int_t lastChamber(9);
- if (AliMUONReconstructor::GetRecoParam()->CombineClusterTrackReco()) {
+ if (GetRecoParam()->CombineClusterTrackReco()) {
// ... Here's the exception : ask the clustering to reconstruct
// clusters *only* in station 4 and 5 for combined tracking
firstChamber = 6;
for (Int_t i = firstChamber; i <= lastChamber; ++i )
{
- if (fClusterServer && AliMUONReconstructor::GetRecoParam()->UseChamber(i)) fClusterServer->Clusterize(i, clusterStore, AliMpArea());
+ if (fClusterServer && GetRecoParam()->UseChamber(i)) fClusterServer->Clusterize(i, clusterStore, AliMpArea());
}
// Loop over stations(1..) 5 and 4 and make track candidates
AliDebug(1,Form("Making primary candidate(1..) %d",++iCandidate));
// Transform segments to tracks and put them at the end of fRecTracksPtr
- track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]));
+ track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]),GetRecoParam()->GetBendingVertexDispersion());
fNRecTracks++;
// Look for compatible cluster(s) in the other station
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast())
+ if (GetRecoParam()->MakeTrackCandidatesFast())
clusterFound = FollowLinearTrackInStation(*track, clusterStore, 7-istat);
else {
// First recompute track parameters and covariances on station(1..) 5 using Kalman filter
// Remove track if no cluster found on a requested station
if (!clusterFound) {
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(7-istat)) {
+ if (GetRecoParam()->RequestStation(7-istat)) {
fRecTracksPtr->Remove(track);
fNRecTracks--;
- } else if (istat == 3 && !AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast()) {
+ } else if (istat == 3 && !GetRecoParam()->MakeTrackCandidatesFast()) {
// update track parameters and covariances using Kalman filter
RetraceTrack(*track, kTRUE);
}
// Retrace tracks using Kalman filter and remove bad ones
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast()) {
+ if (GetRecoParam()->MakeTrackCandidatesFast()) {
fRecTracksPtr->Compress(); // this is essential before checking tracks
Int_t currentNRecTracks = fNRecTracks;
RetraceTrack(*track,kTRUE);
// Remove the track if the normalized chi2 is too high
- if (track->GetNormalizedChi2() > AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking()) {
+ if (track->GetNormalizedChi2() > GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking()) {
fRecTracksPtr->Remove(track);
fNRecTracks--;
}
fRecTracksPtr->Compress(); // this is essential before checking tracks
// Keep all different tracks or only the best ones as required
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
+ if (GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
else RemoveDoubleTracks();
AliDebug(1,Form("Number of good candidates = %d",fNRecTracks));
// Transform segments to tracks and put them at the end of fRecTracksPtr
iCurrentTrack = fRecTracksPtr->GetLast()+1;
- track = new ((*fRecTracksPtr)[iCurrentTrack]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]));
+ track = new ((*fRecTracksPtr)[iCurrentTrack]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]),GetRecoParam()->GetBendingVertexDispersion());
fNRecTracks++;
// Look for compatible cluster(s) in the second chamber of station 5
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast())
+ if (GetRecoParam()->MakeTrackCandidatesFast())
clusterFound = FollowLinearTrackInChamber(*track, clusterStore, 17-ich2);
else clusterFound = FollowTrackInChamber(*track, clusterStore, 17-ich2);
// skip the original track in case it has been removed
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks() && clusterFound) iCurrentTrack++;
+ if (GetRecoParam()->TrackAllTracks() && clusterFound) iCurrentTrack++;
// loop over every new tracks
nCurrentTracks = fRecTracksPtr->GetLast()+1;
track = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iCurrentTrack);
// Look for compatible cluster(s) in the second chamber of station 4
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast())
+ if (GetRecoParam()->MakeTrackCandidatesFast())
FollowLinearTrackInChamber(*track, clusterStore, 13-ich1);
else FollowTrackInChamber(*track, clusterStore, 13-ich1);
// Remove the track if the normalized chi2 is too high
// (only if the tracking has been done without magnetic field)
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast() &&
- track->GetNormalizedChi2() > AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking()) {
+ if (GetRecoParam()->MakeTrackCandidatesFast() &&
+ track->GetNormalizedChi2() > GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking()) {
fRecTracksPtr->Remove(track);
fNRecTracks--;
}
}
// this is essential before checking tracks
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast()) fRecTracksPtr->Compress();
+ if (GetRecoParam()->MakeTrackCandidatesFast()) fRecTracksPtr->Compress();
// Keep all different tracks or only the best ones as required
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
+ if (GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
else RemoveDoubleTracks();
AliDebug(1,Form("Number of good candidates = %d",fNRecTracks));
lastParamCov(2,2) = cluster2->GetErrY2();
lastParamCov(3,3) = 100. * ( cluster1->GetErrY2() + cluster2->GetErrY2() ) / dZ / dZ;
// Inverse bending momentum (vertex resolution + bending slope resolution + 10% error on dipole parameters+field)
- lastParamCov(4,4) = ((AliMUONReconstructor::GetRecoParam()->GetBendingVertexDispersion() *
- AliMUONReconstructor::GetRecoParam()->GetBendingVertexDispersion() +
+ lastParamCov(4,4) = ((GetRecoParam()->GetBendingVertexDispersion() *
+ GetRecoParam()->GetBendingVertexDispersion() +
(z1 * z1 * cluster2->GetErrY2() + z2 * z2 * cluster1->GetErrY2()) / dZ / dZ) /
bendingImpact / bendingImpact + 0.1 * 0.1) * inverseBendingMomentum * inverseBendingMomentum;
lastTrackParam->SetCovariances(lastParamCov);
AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.);
// reset propagator for smoother
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) trackParamAtCluster->ResetPropagator();
+ if (GetRecoParam()->UseSmoother()) trackParamAtCluster->ResetPropagator();
// add MCS in missing chambers if any
currentChamber = trackParamAtCluster->GetClusterPtr()->GetChamberId();
while (currentChamber < expectedChamber) {
// extrapolation to the missing chamber (update the propagator)
AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, AliMUONConstants::DefaultChamberZ(expectedChamber),
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// add MCS effect
AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.);
expectedChamber--;
// extrapolation to the plane of the cluster attached to the current trackParamAtCluster (update the propagator)
AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ(),
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) {
+ if (GetRecoParam()->UseSmoother()) {
// save extrapolated parameters for smoother
trackParamAtCluster->SetExtrapParameters(trackParamAtCluster->GetParameters());
if (!FollowTrackInStation(*track, clusterStore, station)) {
// Try to recover track if required
- if (AliMUONReconstructor::GetRecoParam()->RecoverTracks()) {
+ if (GetRecoParam()->RecoverTracks()) {
// work on a copy of the track if this station is not required
// to keep the case where no cluster is reconstructed as a possible candidate
- if (!AliMUONReconstructor::GetRecoParam()->RequestStation(station)) {
+ if (!GetRecoParam()->RequestStation(station)) {
track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(*track);
fNRecTracks++;
}
fNRecTracks--;
}
- } else if (AliMUONReconstructor::GetRecoParam()->RequestStation(station)) {
+ } else if (GetRecoParam()->RequestStation(station)) {
// remove track if no cluster found
fRecTracksPtr->Remove(track);
fNRecTracks--;
fRecTracksPtr->Compress(); // this is essential before checking tracks
// Keep only the best tracks if required
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) RemoveDoubleTracks();
+ if (!GetRecoParam()->TrackAllTracks()) RemoveDoubleTracks();
}
Double_t bendingMomentum;
Double_t chi2OfCluster;
- Double_t maxChi2OfCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t maxChi2OfCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
Double_t addChi2TrackAtCluster;
Double_t bestAddChi2TrackAtCluster = 1.e10;
Bool_t foundOneCluster = kFALSE;
AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
// reset propagator for smoother
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) extrapTrackParamAtCh.ResetPropagator();
+ if (GetRecoParam()->UseSmoother()) extrapTrackParamAtCh.ResetPropagator();
// Add MCS in the missing chamber(s) if any
Int_t currentChamber = extrapTrackParamAtCh.GetClusterPtr()->GetChamberId();
// extrapolation to the missing chamber
currentChamber--;
AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(currentChamber),
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// add MCS effect
AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
}
//Extrapolate trackCandidate to chamber
AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(nextChamber),
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
// Ask the clustering to reconstruct new clusters around the track position in the current chamber
// except for station 4 and 5 that are already entirely clusterized
- if (AliMUONReconstructor::GetRecoParam()->CombineClusterTrackReco()) {
+ if (GetRecoParam()->CombineClusterTrackReco()) {
if (nextChamber < 6) AskForNewClustersInChamber(extrapTrackParamAtCh, clusterStore, nextChamber);
}
// try to add the current cluster accuratly
chi2OfCluster = TryOneCluster(extrapTrackParamAtCh, cluster, extrapTrackParamAtCluster,
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// if good chi2 then consider to add cluster
if (chi2OfCluster < maxChi2OfCluster) {
cluster->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) {
+ if (GetRecoParam()->UseSmoother()) {
// save extrapolated parameters for smoother
extrapTrackParamAtCluster.SetExtrapParameters(extrapTrackParamAtCluster.GetParameters());
// skip track with absolute bending momentum out of limits
bendingMomentum = TMath::Abs(1. / extrapTrackParamAtCluster.GetInverseBendingMomentum());
- if (bendingMomentum < AliMUONReconstructor::GetRecoParam()->GetMinBendingMomentum() ||
- bendingMomentum > AliMUONReconstructor::GetRecoParam()->GetMaxBendingMomentum()) continue;
+ if (bendingMomentum < GetRecoParam()->GetMinBendingMomentum() ||
+ bendingMomentum > GetRecoParam()->GetMaxBendingMomentum()) continue;
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
UpdateTrack(*newTrack,extrapTrackParamAtCluster,addChi2TrackAtCluster);
}
// fill out the best track if required else clean up the fRecTracksPtr array
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (!GetRecoParam()->TrackAllTracks()) {
if (foundOneCluster) {
UpdateTrack(trackCandidate,bestTrackParamAtCluster,bestAddChi2TrackAtCluster);
Double_t bendingMomentum;
Double_t chi2OfCluster;
- Double_t maxChi2OfCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t maxChi2OfCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
Double_t addChi2TrackAtCluster1;
Double_t addChi2TrackAtCluster2;
Double_t bestAddChi2TrackAtCluster1 = 1.e10;
AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
// reset propagator for smoother
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) extrapTrackParamAtCh.ResetPropagator();
+ if (GetRecoParam()->UseSmoother()) extrapTrackParamAtCh.ResetPropagator();
// Add MCS in the missing chamber(s) if any
Int_t currentChamber = extrapTrackParamAtCh.GetClusterPtr()->GetChamberId();
// extrapolation to the missing chamber
currentChamber--;
AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(currentChamber),
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// add MCS effect
AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
}
//Extrapolate trackCandidate to chamber "ch2"
AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch2),
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
// Ask the clustering to reconstruct new clusters around the track position in the current station
// except for station 4 and 5 that are already entirely clusterized
- if (AliMUONReconstructor::GetRecoParam()->CombineClusterTrackReco()) {
+ if (GetRecoParam()->CombineClusterTrackReco()) {
if (nextStation < 3) AskForNewClustersInStation(extrapTrackParamAtCh, clusterStore, nextStation);
}
// try to add the current cluster accuratly
chi2OfCluster = TryOneCluster(extrapTrackParamAtCh, clusterCh2, extrapTrackParamAtCluster2,
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// if good chi2 then try to attach a cluster in the other chamber too
if (chi2OfCluster < maxChi2OfCluster) {
cout << " look for second clusters in chamber(1..): " << ch1+1 << " ..." << endl;
}
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) {
+ if (GetRecoParam()->UseSmoother()) {
// save extrapolated parameters for smoother
extrapTrackParamAtCluster2.SetExtrapParameters(extrapTrackParamAtCluster2.GetParameters());
// skip track with absolute bending momentum out of limits
bendingMomentum = TMath::Abs(1. / extrapTrackParamAtCluster2.GetInverseBendingMomentum());
- if (bendingMomentum < AliMUONReconstructor::GetRecoParam()->GetMinBendingMomentum() ||
- bendingMomentum > AliMUONReconstructor::GetRecoParam()->GetMaxBendingMomentum()) continue;
+ if (bendingMomentum < GetRecoParam()->GetMinBendingMomentum() ||
+ bendingMomentum > GetRecoParam()->GetMaxBendingMomentum()) continue;
// copy new track parameters for next step
extrapTrackParam = extrapTrackParamAtCluster2;
AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
// reset propagator for smoother
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) extrapTrackParam.ResetPropagator();
+ if (GetRecoParam()->UseSmoother()) extrapTrackParam.ResetPropagator();
//Extrapolate track parameters to chamber "ch1"
AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParam, AliMUONConstants::DefaultChamberZ(ch1),
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// reset cluster iterator of chamber 1
nextInCh1.Reset();
// try to add the current cluster accuratly
chi2OfCluster = TryOneCluster(extrapTrackParam, clusterCh1, extrapTrackParamAtCluster1,
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// if good chi2 then consider to add the 2 clusters to the "trackCandidate"
if (chi2OfCluster < maxChi2OfCluster) {
clusterCh1->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) {
+ if (GetRecoParam()->UseSmoother()) {
// save extrapolated parameters for smoother
extrapTrackParamAtCluster1.SetExtrapParameters(extrapTrackParamAtCluster1.GetParameters());
// skip track with absolute bending momentum out of limits
bendingMomentum = TMath::Abs(1. / extrapTrackParamAtCluster1.GetInverseBendingMomentum());
- if (bendingMomentum < AliMUONReconstructor::GetRecoParam()->GetMinBendingMomentum() ||
- bendingMomentum > AliMUONReconstructor::GetRecoParam()->GetMaxBendingMomentum()) continue;
+ if (bendingMomentum < GetRecoParam()->GetMinBendingMomentum() ||
+ bendingMomentum > GetRecoParam()->GetMaxBendingMomentum()) continue;
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new clusters
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
UpdateTrack(*newTrack,extrapTrackParamAtCluster1,extrapTrackParamAtCluster2,addChi2TrackAtCluster1,addChi2TrackAtCluster2);
if (!foundSecondCluster) {
foundOneCluster = kTRUE;
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
UpdateTrack(*newTrack,extrapTrackParamAtCluster2,addChi2TrackAtCluster2);
// look for candidates in chamber 1 not already attached to a track
// if we want to keep all possible tracks or if no good couple of clusters has been found
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
+ if (GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
// add MCS effect for next step
AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
//Extrapolate trackCandidate to chamber "ch1"
AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch1),
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
// try to add the current cluster accuratly
chi2OfCluster = TryOneCluster(extrapTrackParamAtCh, clusterCh1, extrapTrackParamAtCluster1,
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ GetRecoParam()->UseSmoother());
// if good chi2 then consider to add clusterCh1
// We do not try to attach a cluster in the other chamber too since it has already been done above
clusterCh1->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) {
+ if (GetRecoParam()->UseSmoother()) {
// save extrapolated parameters for smoother
extrapTrackParamAtCluster1.SetExtrapParameters(extrapTrackParamAtCluster1.GetParameters());
// skip track with absolute bending momentum out of limits
bendingMomentum = TMath::Abs(1. / extrapTrackParamAtCluster1.GetInverseBendingMomentum());
- if (bendingMomentum < AliMUONReconstructor::GetRecoParam()->GetMinBendingMomentum() ||
- bendingMomentum > AliMUONReconstructor::GetRecoParam()->GetMaxBendingMomentum()) continue;
+ if (bendingMomentum < GetRecoParam()->GetMinBendingMomentum() ||
+ bendingMomentum > GetRecoParam()->GetMaxBendingMomentum()) continue;
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
UpdateTrack(*newTrack,extrapTrackParamAtCluster1,addChi2TrackAtCluster1);
}
// fill out the best track if required else clean up the fRecTracksPtr array
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (!GetRecoParam()->TrackAllTracks()) {
if (foundTwoClusters) {
UpdateTrack(trackCandidate,bestTrackParamAtCluster1,bestTrackParamAtCluster2,bestAddChi2TrackAtCluster1,bestAddChi2TrackAtCluster2);
/// Update chi2 of the track
// Flag cluster as being (not) removable
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(trackParamAtCluster.GetClusterPtr()->GetChamberId()/2))
+ if (GetRecoParam()->RequestStation(trackParamAtCluster.GetClusterPtr()->GetChamberId()/2))
trackParamAtCluster.SetRemovable(kFALSE);
else trackParamAtCluster.SetRemovable(kTRUE);
trackParamAtCluster.SetLocalChi2(0.); // --> Local chi2 not used
if (!trackParamAtCluster->IsRemovable()) return kFALSE;
// reset the current cluster as being not removable if it is on a required station
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextStation+1)) trackParamAtCluster->SetRemovable(kFALSE);
+ if (GetRecoParam()->RequestStation(nextStation+1)) trackParamAtCluster->SetRemovable(kFALSE);
// Pick up cluster with the worst chi2
localChi2 = trackParamAtCluster->GetLocalChi2();
// skip track with absolute bending momentum out of limits
Double_t bendingMomentum = TMath::Abs(1. / ((AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First())->GetInverseBendingMomentum());
- if (bendingMomentum < AliMUONReconstructor::GetRecoParam()->GetMinBendingMomentum() ||
- bendingMomentum > AliMUONReconstructor::GetRecoParam()->GetMaxBendingMomentum()) return kFALSE;
+ if (bendingMomentum < GetRecoParam()->GetMinBendingMomentum() ||
+ bendingMomentum > GetRecoParam()->GetMaxBendingMomentum()) return kFALSE;
// Look for new cluster(s) in next station
return FollowTrackInStation(trackCandidate, clusterStore, nextStation);
Int_t chamberId, detElemId;
Double_t chi2OfCluster, addChi2TrackAtCluster, bestAddChi2TrackAtCluster;
- Double_t maxChi2OfCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t maxChi2OfCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
Bool_t foundOneCluster, trackModified;
AliMUONVCluster *cluster;
AliMUONTrackParam *trackParam, *previousTrackParam, *nextTrackParam, trackParamAtCluster, bestTrackParamAtCluster;
Double_t localChi2, worstLocalChi2;
AliMUONTrackParam *trackParamAtCluster, *worstTrackParamAtCluster, *nextTrackParam;
Bool_t smoothed;
- Double_t sigmaCut2 = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForImprovement() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForImprovement();
+ Double_t sigmaCut2 = GetRecoParam()->GetSigmaCutForImprovement() *
+ GetRecoParam()->GetSigmaCutForImprovement();
while (!track.IsImproved()) {
// identify removable clusters
- track.TagRemovableClusters();
+ track.TagRemovableClusters(GetRecoParam()->RequestedStationMask());
// Run smoother if required
smoothed = kFALSE;
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) smoothed = RunSmoother(track);
+ if (GetRecoParam()->UseSmoother()) smoothed = RunSmoother(track);
// Use standard procedure to compute local chi2 if smoother not required or not working
if (!smoothed) {
while (trackParamAtCluster) {
// save parameters into smooth parameters in case of smoother did not work properly
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother() && !smoothed) {
+ if (GetRecoParam()->UseSmoother() && !smoothed) {
trackParamAtCluster->SetSmoothParameters(trackParamAtCluster->GetParameters());
trackParamAtCluster->SetSmoothCovariances(trackParamAtCluster->GetCovariances());
}
// update track parameters (using smoother if required) if not already done
if (!track.IsImproved()) {
smoothed = kFALSE;
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) smoothed = RunSmoother(track);
+ if (GetRecoParam()->UseSmoother()) smoothed = RunSmoother(track);
if (!smoothed) track.UpdateCovTrackParamAtCluster();
- } else smoothed = AliMUONReconstructor::GetRecoParam()->UseSmoother();
+ } else smoothed = GetRecoParam()->UseSmoother();
// copy smoothed parameters and covariances if any
if (smoothed) {
/// re-fit the given track
// check validity of the track
- if (!track.IsValid()) {
+ if (!track.IsValid(GetRecoParam()->RequestedStationMask())) {
AliWarning("the track does not contain enough clusters --> unable to refit");
return kFALSE;
}
// Improve the reconstructed tracks if required
track.SetImproved(kFALSE);
- if (enableImprovement && AliMUONReconstructor::GetRecoParam()->ImproveTracks()) ImproveTrack(track);
+ if (enableImprovement && GetRecoParam()->ImproveTracks()) ImproveTrack(track);
// Fill AliMUONTrack data members
FinalizeTrack(track);
public:
- AliMUONTrackReconstructorK(AliMUONVClusterServer* clusterServer); // default Constructor
+ AliMUONTrackReconstructorK(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer); // default Constructor
virtual ~AliMUONTrackReconstructorK(); // Destructor
virtual Bool_t RefitTrack(AliMUONTrack &track, Bool_t enableImprovement = kTRUE);
//_____________________________________________________________________________
-AliMUONTracker::AliMUONTracker(AliMUONVClusterServer* clusterServer,
+AliMUONTracker::AliMUONTracker(const AliMUONRecoParam* recoParam,
+ AliMUONVClusterServer* clusterServer,
const AliMUONVDigitStore& digitStore,
const AliMUONDigitMaker* digitMaker,
const AliMUONGeometryTransformer* transformer,
const AliMUONTriggerCircuit* triggerCircuit)
: AliTracker(),
- fDigitMaker(digitMaker), // not owner
- fTransformer(transformer), // not owner
- fTriggerCircuit(triggerCircuit), // not owner
- fTrackHitPatternMaker(0x0),
- fTrackReco(0x0),
- fClusterStore(0x0),
- fTriggerStore(0x0),
- fClusterServer(clusterServer),
- fIsOwnerOfClusterServer(kFALSE),
- fDigitStore(digitStore), // not owner
- fInputClusterStore(0x0),
- fTriggerTrackStore(0x0)
+fDigitMaker(digitMaker), // not owner
+fTransformer(transformer), // not owner
+fTriggerCircuit(triggerCircuit), // not owner
+fTrackHitPatternMaker(0x0),
+fTrackReco(0x0),
+fClusterStore(0x0),
+fTriggerStore(0x0),
+fClusterServer(clusterServer),
+fIsOwnerOfClusterServer(kFALSE),
+fDigitStore(digitStore), // not owner
+fInputClusterStore(0x0),
+fTriggerTrackStore(0x0),
+fRecoParam(recoParam)
{
/// constructor
if (fTransformer && fDigitMaker)
- fTrackHitPatternMaker = new AliMUONTrackHitPattern(*fTransformer,*fDigitMaker);
+ fTrackHitPatternMaker = new AliMUONTrackHitPattern(recoParam,*fTransformer,*fDigitMaker);
if (!fClusterServer)
{
}
delete fClusterServer;
fClusterServer = new AliMUONLegacyClusterServer(*fTransformer,fInputClusterStore,
- AliMUONReconstructor::GetRecoParam()->BypassSt4(),
- AliMUONReconstructor::GetRecoParam()->BypassSt5());
+ GetRecoParam()->BypassSt4(),
+ GetRecoParam()->BypassSt5());
SetupClusterServer(*fClusterServer);
}
if (!fTrackReco)
{
- fTrackReco = CreateTrackReconstructor(AliMUONReconstructor::GetRecoParam()->GetTrackingMode(),fClusterServer);
+ fTrackReco = CreateTrackReconstructor(GetRecoParam(),fClusterServer);
}
// if the required tracking mode does not exist
fTrackReco->EventReconstructTrigger(*fTriggerCircuit,*fTriggerStore,*(TriggerTrackStore()));
}
- if ( ( AliMUONReconstructor::GetRecoParam()->BypassSt4() ||
- AliMUONReconstructor::GetRecoParam()->BypassSt5() ) &&
+ if ( ( GetRecoParam()->BypassSt4() ||
+ GetRecoParam()->BypassSt5() ) &&
TriggerTrackStore()->GetSize() > 5 )
{
// Hard cut to reject shower events
AliMUONLocalTrigger* locTrg;
AliESDMuonTrack esdTrack;
TIter next(trackStore.CreateIterator());
- if (AliMUONReconstructor::GetRecoParam()->SaveFullClusterInESD() &&
- gRandom->Uniform(100.) <= AliMUONReconstructor::GetRecoParam()->GetPercentOfFullClusterInESD()) {
+ if (GetRecoParam()->SaveFullClusterInESD() &&
+ gRandom->Uniform(100.) <= GetRecoParam()->GetPercentOfFullClusterInESD()) {
while ( ( track = static_cast<AliMUONTrack*>(next()) ) ) {
}
//_____________________________________________________________________________
-AliMUONVTrackReconstructor* AliMUONTracker::CreateTrackReconstructor(const char* trackingMode, AliMUONVClusterServer* clusterServer)
+AliMUONVTrackReconstructor* AliMUONTracker::CreateTrackReconstructor(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer)
{
/// Create track reconstructor, depending on tracking mode set in RecoParam
AliMUONVTrackReconstructor* trackReco(0x0);
- TString opt(trackingMode);
+ TString opt(recoParam->GetTrackingMode());
opt.ToUpper();
if (strstr(opt,"ORIGINAL"))
{
- trackReco = new AliMUONTrackReconstructor(clusterServer);
+ trackReco = new AliMUONTrackReconstructor(recoParam,clusterServer);
}
else if (strstr(opt,"KALMAN"))
{
- trackReco = new AliMUONTrackReconstructorK(clusterServer);
+ trackReco = new AliMUONTrackReconstructorK(recoParam,clusterServer);
}
else
{
{
/// Setup the cluster server
- if ( AliMUONReconstructor::GetRecoParam()->BypassSt4() ||
- AliMUONReconstructor::GetRecoParam()->BypassSt5() )
+ if ( GetRecoParam()->BypassSt4() ||
+ GetRecoParam()->BypassSt5() )
{
Bool_t ok = clusterServer.UseTriggerTrackStore(TriggerTrackStore());
TString msg1;
TString msg2;
- if ( AliMUONReconstructor::GetRecoParam()->BypassSt45() )
+ if ( GetRecoParam()->BypassSt45() )
{
msg1 = "STATIONS 4 AND 5";
msg2 = "THOSE TWO STATIONS";
}
- else if ( AliMUONReconstructor::GetRecoParam()->BypassSt4() )
+ else if ( GetRecoParam()->BypassSt4() )
{
msg1 = "STATION 4";
msg2 = "THAT STATION";
}
- else if ( AliMUONReconstructor::GetRecoParam()->BypassSt5() )
+ else if ( GetRecoParam()->BypassSt5() )
{
msg1 = "STATION 5";
msg2 = "THAT STATION";
class AliESDEvent;
class AliMUONDigitMaker;
class AliMUONGeometryTransformer;
+class AliMUONRecoParam;
class AliMUONTrackHitPattern;
class AliMUONTriggerCircuit;
class AliMUONVClusterServer;
{
public:
- AliMUONTracker(AliMUONVClusterServer* clusterServer,
+ AliMUONTracker(const AliMUONRecoParam* recoParam,
+ AliMUONVClusterServer* clusterServer,
const AliMUONVDigitStore& digitStore,
const AliMUONDigitMaker* digitMaker=0,
const AliMUONGeometryTransformer* transformer=0,
virtual void UnloadClusters();
+ const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
+
/// Dummy implementation
virtual Int_t PropagateBack(AliESDEvent* /*event*/) {return 0;}
/// Dummy implementation
/// Dummy implementation
virtual AliCluster *GetCluster(Int_t /*index*/) const {return 0;}
- static AliMUONVTrackReconstructor* CreateTrackReconstructor(const char* trackingMode, AliMUONVClusterServer* clusterServer);
+ static AliMUONVTrackReconstructor* CreateTrackReconstructor(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer);
private:
/// Not implemented
const AliMUONVDigitStore& fDigitStore; //!< digit info to fill in ESD
mutable AliMUONVClusterStore* fInputClusterStore; //!< cluster container
mutable AliMUONVTriggerTrackStore* fTriggerTrackStore; //!< trigger track store
+ const AliMUONRecoParam* fRecoParam; //!< pointer to reco param
ClassDef(AliMUONTracker,0) //tracker base class for MUON
};
}
//_____________________________________________________________________________
-AliMUONTrackerCalibratedDataMaker::AliMUONTrackerCalibratedDataMaker(Int_t runNumber,
+AliMUONTrackerCalibratedDataMaker::AliMUONTrackerCalibratedDataMaker(const AliMUONRecoParam* recoParam,
+ Int_t runNumber,
AliRawReader* reader,
const char* cdbpath,
const char* calibMode,
/// Ctor in which this object will NOT be owner of the reader,
/// and can NOT apply rewind to it, nor use Next on it
- Ctor(runNumber,calibMode,histogram,xmin,xmax);
+ Ctor(recoParam,runNumber,calibMode,histogram,xmin,xmax);
}
//_____________________________________________________________________________
-AliMUONTrackerCalibratedDataMaker::AliMUONTrackerCalibratedDataMaker(AliRawReader* reader,
+AliMUONTrackerCalibratedDataMaker::AliMUONTrackerCalibratedDataMaker(const AliMUONRecoParam* recoParam,
+ AliRawReader* reader,
const char* cdbpath,
const char* calibMode,
Bool_t histogram,
fRawReader->RewindEvents();
}
- Ctor(runNumber,calibMode,histogram,xmin,xmax);
+ Ctor(recoParam,runNumber,calibMode,histogram,xmin,xmax);
}
//_____________________________________________________________________________
void
-AliMUONTrackerCalibratedDataMaker::Ctor(Int_t runNumber, const char* calibMode,
+AliMUONTrackerCalibratedDataMaker::Ctor(const AliMUONRecoParam* recoParam,
+ Int_t runNumber, const char* calibMode,
Bool_t histogram, Double_t xmin, Double_t xmax)
{
/// "designated" constructor.
AliCDBManager::Instance()->SetDefaultStorage(storage);
}
- const AliMUONRecoParam* recoParams = AliMUONReconstructor::GetRecoParam();
- fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,recoParams,calibMode);
+ fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,recoParam,calibMode);
//FIXME: get the reco param from GUI and/or from OCDB if not used from the QA code ?
}
}
class AliMUONVTrackerData;
class AliMUONVStore;
class AliMUONVDigitStore;
+class AliMUONRecoParam;
class AliMUONTrackerCalibratedDataMaker : public AliMUONVTrackerDataMaker
{
AliMUONTrackerCalibratedDataMaker(TRootIOCtor* ioCtor);
- AliMUONTrackerCalibratedDataMaker(Int_t runNumber,
+ AliMUONTrackerCalibratedDataMaker(const AliMUONRecoParam* recoParam,
+ Int_t runNumber,
AliRawReader* reader,
const char* cdbpath=0x0,
const char* calibMode=0x0,
Double_t xmax=4096.0,
Bool_t useHPdecoder=kTRUE);
- AliMUONTrackerCalibratedDataMaker(AliRawReader* reader = 0x0,
+ AliMUONTrackerCalibratedDataMaker(const AliMUONRecoParam* recoParam,
+ AliRawReader* reader = 0x0,
const char* cdbpath=0x0,
const char* calibMode=0x0,
Bool_t histogram=kFALSE,
/// Not implemented
AliMUONTrackerCalibratedDataMaker& operator=(const AliMUONTrackerCalibratedDataMaker& rhs);
- void Ctor(Int_t runNumber, const char* calibMode,
+ void Ctor(const AliMUONRecoParam* recoParam,
+ Int_t runNumber, const char* calibMode,
Bool_t histogram, Double_t xmin, Double_t xmax);
private:
/// \endcond
//__________________________________________________________________________
-AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(AliMUONVClusterServer* clusterServer)
- : TObject(),
- fRecTracksPtr(0x0),
- fNRecTracks(0),
- fClusterServer(clusterServer)
+AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(const AliMUONRecoParam* recoParam,
+ AliMUONVClusterServer* clusterServer)
+: TObject(),
+fRecTracksPtr(0x0),
+fNRecTracks(0),
+fClusterServer(clusterServer),
+fRecoParam(recoParam)
{
/// Constructor for class AliMUONVTrackReconstructor
/// WARNING: if clusterServer=0x0, no clusterization will be possible at this level
MakeTrackCandidates(clusterStore);
// Look for extra candidates from clusters in stations(1..) 4 and 5
- if (AliMUONReconstructor::GetRecoParam()->MakeMoreTrackCandidates()) MakeMoreTrackCandidates(clusterStore);
+ if (GetRecoParam()->MakeMoreTrackCandidates()) MakeMoreTrackCandidates(clusterStore);
// Stop tracking if no candidate found
if (fRecTracksPtr->GetEntriesFast() == 0) return;
FollowTracks(clusterStore);
// Complement the reconstructed tracks
- if (AliMUONReconstructor::GetRecoParam()->ComplementTracks()) ComplementTracks(clusterStore);
+ if (GetRecoParam()->ComplementTracks()) ComplementTracks(clusterStore);
// Improve the reconstructed tracks
- if (AliMUONReconstructor::GetRecoParam()->ImproveTracks()) ImproveTracks();
+ if (GetRecoParam()->ImproveTracks()) ImproveTracks();
// Remove double tracks
RemoveDoubleTracks();
nonBendingSlope = (cluster1->GetX() - cluster2->GetX()) / (cluster1->GetZ() - cluster2->GetZ());
// check if non bending slope is within tolerances
- if (TMath::Abs(nonBendingSlope) > AliMUONReconstructor::GetRecoParam()->GetMaxNonBendingSlope()) continue;
+ if (TMath::Abs(nonBendingSlope) > GetRecoParam()->GetMaxNonBendingSlope()) continue;
// bending slope
bendingSlope = (cluster1->GetY() - cluster2->GetY()) / (cluster1->GetZ() - cluster2->GetZ());
bendingMomentum = TMath::Abs(AliMUONTrackExtrap::GetBendingMomentumFromImpactParam(impactParam));
// check if bending momentum is within tolerances
- if (bendingMomentum < AliMUONReconstructor::GetRecoParam()->GetMinBendingMomentum() ||
- bendingMomentum > AliMUONReconstructor::GetRecoParam()->GetMaxBendingMomentum()) continue;
+ if (bendingMomentum < GetRecoParam()->GetMinBendingMomentum() ||
+ bendingMomentum > GetRecoParam()->GetMaxBendingMomentum()) continue;
} else {
// check if non bending slope is within tolerances
- if (TMath::Abs(bendingSlope) > AliMUONReconstructor::GetRecoParam()->GetMaxBendingSlope()) continue;
+ if (TMath::Abs(bendingSlope) > GetRecoParam()->GetMaxBendingSlope()) continue;
}
// make new segment
/// Ask the clustering to reconstruct new clusters around the track candidate position
// check if the current chamber is useable
- if (!fClusterServer || !AliMUONReconstructor::GetRecoParam()->UseChamber(chamber)) return;
+ if (!fClusterServer || !GetRecoParam()->UseChamber(chamber)) return;
// maximum distance between the center of the chamber and a detection element
// (accounting for the inclination of the chamber)
Double_t errX2 = kParamCov(0,0) + kMaxDZ * kMaxDZ * kParamCov(1,1) + 2. * kMaxDZ * TMath::Abs(kParamCov(0,1));
Double_t errY2 = kParamCov(2,2) + kMaxDZ * kMaxDZ * kParamCov(3,3) + 2. * kMaxDZ * TMath::Abs(kParamCov(2,3));
Double_t dX = TMath::Abs(trackParam.GetNonBendingSlope()) * kMaxDZ +
- AliMUONReconstructor::GetRecoParam()->GetMaxNonBendingDistanceToTrack() +
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errX2);
+ GetRecoParam()->GetMaxNonBendingDistanceToTrack() +
+ GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errX2);
Double_t dY = TMath::Abs(trackParam.GetBendingSlope()) * kMaxDZ +
- AliMUONReconstructor::GetRecoParam()->GetMaxBendingDistanceToTrack() +
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errY2);
+ GetRecoParam()->GetMaxBendingDistanceToTrack() +
+ GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errY2);
TVector2 dimensions(dX, dY);
TVector2 position(extrapTrackParam.GetNonBendingCoor(), extrapTrackParam.GetBendingCoor());
AliMpArea area(position, dimensions);
Double_t errX2 = kParamCov(0,0) + dZ * dZ * kParamCov(1,1) + 2. * dZ * kParamCov(0,1);
Double_t errY2 = kParamCov(2,2) + dZ * dZ * kParamCov(3,3) + 2. * dZ * kParamCov(2,3);
- Double_t dXmax = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errX2) +
- AliMUONReconstructor::GetRecoParam()->GetMaxNonBendingDistanceToTrack();
- Double_t dYmax = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errY2) +
- AliMUONReconstructor::GetRecoParam()->GetMaxBendingDistanceToTrack();
+ Double_t dXmax = GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errX2) +
+ GetRecoParam()->GetMaxNonBendingDistanceToTrack();
+ Double_t dYmax = GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errY2) +
+ GetRecoParam()->GetMaxBendingDistanceToTrack();
if (TMath::Abs(dX) > dXmax || TMath::Abs(dY) > dYmax) return kFALSE;
AliDebug(1,Form("Enter FollowLinearTrackInChamber(1..) %d", nextChamber+1));
Double_t chi2WithOneCluster = 1.e10;
- Double_t maxChi2WithOneCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t maxChi2WithOneCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
Double_t bestChi2WithOneCluster = maxChi2WithOneCluster;
Bool_t foundOneCluster = kFALSE;
AliMUONTrack *newTrack = 0x0;
cluster->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextChamber/2))
+ if (GetRecoParam()->RequestStation(nextChamber/2))
extrapTrackParamAtCluster.SetRemovable(kFALSE);
else extrapTrackParamAtCluster.SetRemovable(kTRUE);
newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster,*cluster);
}
// fill out the best track if required else clean up the fRecTracksPtr array
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (!GetRecoParam()->TrackAllTracks()) {
if (foundOneCluster) {
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextChamber/2))
+ if (GetRecoParam()->RequestStation(nextChamber/2))
bestTrackParamAtCluster.SetRemovable(kFALSE);
else bestTrackParamAtCluster.SetRemovable(kTRUE);
trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster,*(bestTrackParamAtCluster.GetClusterPtr()));
Double_t chi2WithOneCluster = 1.e10;
Double_t chi2WithTwoClusters = 1.e10;
- Double_t maxChi2WithOneCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
- Double_t maxChi2WithTwoClusters = 4. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 4 because 4 quantities in chi2
+ Double_t maxChi2WithOneCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t maxChi2WithTwoClusters = 4. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 4 because 4 quantities in chi2
Double_t bestChi2WithOneCluster = maxChi2WithOneCluster;
Double_t bestChi2WithTwoClusters = maxChi2WithTwoClusters;
Bool_t foundOneCluster = kFALSE;
clusterCh1->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new clusters
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
extrapTrackParamAtCluster1.SetRemovable(kTRUE);
if (!foundSecondCluster) {
foundOneCluster = kTRUE;
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextStation))
+ if (GetRecoParam()->RequestStation(nextStation))
extrapTrackParamAtCluster2.SetRemovable(kFALSE);
else extrapTrackParamAtCluster2.SetRemovable(kTRUE);
newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster2,*clusterCh2);
// look for candidates in chamber 1 not already attached to a track
// if we want to keep all possible tracks or if no good couple of clusters has been found
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
+ if (GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
clusterCh1->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextStation))
+ if (GetRecoParam()->RequestStation(nextStation))
extrapTrackParamAtCluster1.SetRemovable(kFALSE);
else extrapTrackParamAtCluster1.SetRemovable(kTRUE);
newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster1,*clusterCh1);
}
// fill out the best track if required else clean up the fRecTracksPtr array
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (!GetRecoParam()->TrackAllTracks()) {
if (foundTwoClusters) {
bestTrackParamAtCluster1.SetRemovable(kTRUE);
trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster1,*(bestTrackParamAtCluster1.GetClusterPtr()));
}
} else if (foundOneCluster) {
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextStation))
+ if (GetRecoParam()->RequestStation(nextStation))
bestTrackParamAtCluster1.SetRemovable(kFALSE);
else bestTrackParamAtCluster1.SetRemovable(kTRUE);
trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster1,*(bestTrackParamAtCluster1.GetClusterPtr()));
class AliMUONDigitMaker;
class AliMUONTriggerCircuit;
class TClonesArray;
+class AliMUONRecoParam;
class AliMUONVTrackReconstructor : public TObject {
public:
- AliMUONVTrackReconstructor(AliMUONVClusterServer* clusterServer); // default Constructor
+ AliMUONVTrackReconstructor(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer); // default Constructor
virtual ~AliMUONVTrackReconstructor(); // Destructor
+
void EventReconstruct(AliMUONVClusterStore& clusterStore,
AliMUONVTrackStore& trackStore);
const AliMUONVTriggerTrackStore& triggerTrackStore,
const AliMUONVTriggerStore& triggerStore,
const AliMUONTrackHitPattern& trackHitPattern);
+
+ const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
/// re-fit the given track
virtual Bool_t RefitTrack(AliMUONTrack &track, Bool_t enableImprovement = kTRUE) = 0;
+ // methods previously got from the static muonrecoparam:
+ //
+ // MakeMoreTrackCandidates()
+ //
+ // ComplementTracks()
+ //
+ // ImproveTracks()
+ //
+ // GetMaxNonBendingSlope()
+ // GetMaxBendingSlope()
+ //
+ // GetMinBendingMomentum()
+ // GetMaxBendingMomentum()
+ //
+ // UseChamber(Int_t chamberId)
+ //
+ // GetMaxNonBendingDistanceToTrack()
+ // GetSigmaCutForTracking()
+ // GetMaxBendingDistanceToTrack()
+ // GetSigmaCutForTracking()
+ // TrackAllTracks()
+ // RequestStation(Int_t stationId)
+
protected:
TClonesArray *fRecTracksPtr; ///< pointer to array of reconstructed tracks
AliMUONVClusterServer* fClusterServer; ///< reference to our cluster server
+ const AliMUONRecoParam* fRecoParam; ///< reference to reco parameters
+
// Functions
AliMUONVTrackReconstructor (const AliMUONVTrackReconstructor& rhs); ///< copy constructor
AliMUONVTrackReconstructor& operator=(const AliMUONVTrackReconstructor& rhs); ///< assignment operator
MuonRec->SetLoadAlignData("MUON");
MuonRec->SetNumberOfEventsPerFile(1000);
MuonRec->SetOption("MUON",recoptions);
- // MuonRec->SetEventRange(319,319);
- MuonRec->SetWriteAOD();
-
- AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
- //muonRecoParam->CombineClusterTrackReco(kTRUE);
- //muonRecoParam->SaveFullClusterInESD(kTRUE,100.);
- //muonRecoParam->SetClusteringMode("PEAKFIT");
- //muonRecoParam->SetClusteringMode("PEAKCOG");
- muonRecoParam->Print("FULL");
- AliMUONReconstructor::SetRecoParam(muonRecoParam);
-
MuonRec->SetRunQA("MUON:ALL");
MuonRec->Run();
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff