//_____________________________________________________________________________
AliMUONClusterDrawAZ::AliMUONClusterDrawAZ()
- : TObject()
+ : TObject(),
+ fData(0x0),
+ fFind(0x0),
+ fnMu(0),
+ fEvent(0),
+ fChamber(0),
+ fidDE(0),
+ fDebug(0),
+ fModif(0)
{
/// Default constructor
- fFind = NULL; fData = NULL;
for (Int_t i=0; i<4; i++) fHist[i] = NULL;
}
//_____________________________________________________________________________
AliMUONClusterDrawAZ::AliMUONClusterDrawAZ(AliMUONClusterFinderAZ *clusFinder)
- : TObject()
+ : TObject(),
+ fData(0x0),
+ fFind(clusFinder),
+ fnMu(0),
+ fEvent(0),
+ fChamber(0),
+ fidDE(0),
+ fDebug(1),
+ fModif(0)
{
/// Constructor
- fFind = clusFinder;
for (Int_t i=0; i<4; i++) fHist[i] = NULL;
- fDebug = 1;
- fEvent = fChamber = fidDE = 0;
- fModif = 0; //0;
Init();
}
/// Destructor
}
-//_____________________________________________________________________________
-AliMUONClusterDrawAZ::AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs)
- : TObject(rhs)
-{
-/// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-
-//_____________________________________________________________________________
-AliMUONClusterDrawAZ&
-AliMUONClusterDrawAZ::operator=(const AliMUONClusterDrawAZ& rhs)
-{
-/// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
- return *this;
-}
-
//_____________________________________________________________________________
void AliMUONClusterDrawAZ::Init()
{
void ResetMuon() { fxyMu[0][6] = fxyMu[1][6] = 9999; } // reset muons
void UpdateCluster(Int_t npad); // update cluster after removing non-overlapped pads
-protected:
- AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs);
- AliMUONClusterDrawAZ& operator=(const AliMUONClusterDrawAZ& rhs);
-
private:
AliMUONData *fData; //!< pointer to muon data container
AliMUONClusterFinderAZ* fFind; //!< pointer to ClusterFinder
// Functions
+ AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs);
+ AliMUONClusterDrawAZ& operator=(const AliMUONClusterDrawAZ& rhs);
void Init(); // initialization
void ModifyHistos(); // modify histograms
void DrawHits(); // draw simulated and reconstructed hits
//_____________________________________________________________________________
AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw)
- : AliMUONClusterFinderVS()
+ : AliMUONClusterFinderVS(),
+ fZpad(0),
+ fNpar(0),
+ fQtot(0),
+ fReco(1),
+ fCathBeg(0),
+ fDraw(0x0),
+ fPixArray(0x0),
+ fnCoupled(0),
+ fDebug(0)
{
/// Constructor
fnPads[0]=fnPads[1]=0;
fSegmentation[1] = fSegmentation[0] = 0x0;
- fZpad = 0;
- fQtot = 0;
- fPadBeg[0] = fPadBeg[1] = fCathBeg = fNpar = fnCoupled = 0;
+ fPadBeg[0] = fPadBeg[1] = 0;
if (!fgMinuit) fgMinuit = new TMinuit(8);
if (!fgClusterFinder) fgClusterFinder = this;
fPixArray = new TObjArray(20);
- fDebug = 0; //0;
- fReco = 1;
- fDraw = 0x0;
if (draw) {
fDebug = 1;
fReco = 0;
cout << " *** Running AZ cluster finder *** " << endl;
}
-//_____________________________________________________________________________
-AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(const AliMUONClusterFinderAZ& rhs)
- : AliMUONClusterFinderVS(rhs)
-{
-/// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
//_____________________________________________________________________________
AliMUONClusterFinderAZ::~AliMUONClusterFinderAZ()
{
delete [] used; used = 0;
}
-//_____________________________________________________________________________
-AliMUONClusterFinderAZ&
-AliMUONClusterFinderAZ::operator=(const AliMUONClusterFinderAZ& rhs)
-{
-/// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
//_____________________________________________________________________________
void AliMUONClusterFinderAZ::AddVirtualPad()
{
void SetReco(Int_t iReco) { fReco = iReco; } // set reco flag
void SetStart(Int_t iCath, Int_t iPad) { fCathBeg = iCath; fPadBeg[0] = fPadBeg[1] = 0; fPadBeg[fCathBeg] = iPad; } // start
-protected:
- AliMUONClusterFinderAZ(const AliMUONClusterFinderAZ& rhs);
- AliMUONClusterFinderAZ& operator=(const AliMUONClusterFinderAZ& rhs);
-
- private:
+private:
// Some constants
static const Int_t fgkDim = 10000; ///< array size
static const Double_t fgkCouplMin; ///< threshold on coupling
// Functions
+ AliMUONClusterFinderAZ(const AliMUONClusterFinderAZ& rhs);
+ AliMUONClusterFinderAZ& operator=(const AliMUONClusterFinderAZ& rhs);
void AddPad(Int_t cath, Int_t digit); // add a pad to the cluster
Bool_t Overlap(Int_t cath, AliMUONDigit *dig); // check if the pad from one cathode overlaps with a pad in the cluster on the other cathode
Bool_t Overlap(Float_t *xy1, Int_t iPad, Float_t *xy12, Int_t iSkip); // check if pads xy1 and iPad overlap and return overlap area
ClassImp(AliMUONClusterFinderVS)
AliMUONClusterFinderVS::AliMUONClusterFinderVS()
- : TObject()
+ : TObject(),
+ fInput(AliMUONClusterInput::Instance()),
+ fDeclusterFlag(0),
+ fClusterSize(0),
+ fNperMax(0),
+ fGhostChi2Cut(1e6),
+ fNPeaks(0),
+ fNRawClusters(0),
+ fRawClusters(0x0),
+ fZPlane(0.),
+ fSector(0),
+ fFitStat(0)
{
/// Default constructor
- fInput=AliMUONClusterInput::Instance();
fDigitMap[0] = 0;
fDigitMap[1] = 0;
fTrack[0]=fTrack[1]=-1;
- fGhostChi2Cut = 1e6; // nothing done by default
fSeg2[0] = 0;
fSeg2[1] = 0;
}
}
fRawClusters = new TClonesArray("AliMUONRawCluster",1000);
- fNRawClusters = 0;
}
//____________________________________________________________________________
AliMUONClusterFinderVS::~AliMUONClusterFinderVS()
}
}
-AliMUONClusterFinderVS::AliMUONClusterFinderVS(const AliMUONClusterFinderVS & clusterFinder):TObject(clusterFinder)
-{
-/// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
//____________________________________________________________________________
void AliMUONClusterFinderVS::ResetRawClusters()
{
void ResetRawClusters();
protected:
- AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
-// Assignment operator
- AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
AliMUONClusterInput* fInput; //!< AliMUONClusterInput instance
AliMUONDigitMapA1* fDigitMap[2]; ///< Hit Maps for cathode 1 and 2
Int_t fTrack[2]; ///< Only digits with main contributions from these tracks are
// considered
- // Return pointer to raw clusters
+ private:
+ AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
+// Assignment operator
+ AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
+
ClassDef(AliMUONClusterFinderVS,2) //Class for clustering and reconstruction of space points
};
#endif
AliMUONClusterInput::AliMUONClusterInput()
: TObject(),
+ fNseg(0),
+ fChamber(0),
fCluster(0),
+ fZ(0.),
fChargeCorrel(1.),
fDetElemId(0)
fgMathieson = 0;
}
-AliMUONClusterInput::AliMUONClusterInput(const AliMUONClusterInput& clusterInput):TObject(clusterInput)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig1, TClonesArray* dig2)
{
// Set pointer to digits with corresponding segmentations and responses (two cathode planes)
//_________________________________________________________________________
AliMUONDetElement::AliMUONDetElement()
- : TObject()
+ : TObject(),
+ fidDE(0),
+ fIndex(0),
+ fChamber(0),
+ fZ(0.),
+ fNHitsForRec(0),
+ fRawClus(0x0),
+ fHitsForRec(0x0),
+ fRecModel(0x0)
{
/// Default constructor
for (Int_t i = 0; i < 2; i++) {
fDigits[i] = NULL;
fSeg[i] = NULL;
}
- fRawClus = fHitsForRec = NULL;
- fRecModel = NULL;
}
//_________________________________________________________________________
AliMUONDetElement::AliMUONDetElement(Int_t idDE, AliMUONDigit *dig, AliMUONClusterFinderAZ *recModel)
- : TObject()
+ : TObject(),
+ fidDE(idDE),
+ fIndex(0),
+ fChamber(idDE / 100 - 1),
+ fZ(0.),
+ fNHitsForRec(0),
+ fRawClus(0x0),
+ fHitsForRec(0x0),
+ fRecModel(recModel)
{
/// Constructor
- fidDE = idDE;
- fChamber = fidDE / 100 - 1;
fDigits[0] = new TObjArray(10);
fDigits[1] = new TObjArray(10);
fRawClus = new TObjArray(10);
fHitsForRec = new TClonesArray("AliMUONHitForRec",10);
- fNHitsForRec = 0;
- fRecModel = recModel;
AliMUON *pMUON = (AliMUON*) gAlice->GetModule("MUON");
AliMUONSegmentation *pSegmentation = pMUON->GetSegmentation();
fSeg[0] = pSegmentation->GetModuleSegmentation(fChamber, 0);
delete fHitsForRec; fHitsForRec = 0;
}
-//_________________________________________________________________________
-AliMUONDetElement::AliMUONDetElement (const AliMUONDetElement& rhs)
- : TObject(rhs)
-{
-/// Copy constructor
-
- AliFatal("Not implemented.");
-}
-
-//________________________________________________________________________
-AliMUONDetElement & AliMUONDetElement::operator = (const AliMUONDetElement& rhs)
-{
-/// Assignement operator
-
- if (this == &rhs) return *this;
- AliFatal( "Not implemented.");
- return *this;
-}
-
//_________________________________________________________________________
Int_t AliMUONDetElement::Compare(const TObject* detElem) const
{
AliMUONDetElement();
AliMUONDetElement(Int_t idDE, AliMUONDigit *dig, AliMUONClusterFinderAZ *recModel); // constructor
- AliMUONDetElement(const AliMUONDetElement & rhs); // copy constructor
- AliMUONDetElement& operator = (const AliMUONDetElement& rhs); // assignment operator
virtual ~AliMUONDetElement(); // Destructor
Int_t IdDE(void) const { return fidDE; } // det. elem. ID
Bool_t IsSortable() const { return kTRUE; }
Int_t Compare(const TObject* detElem) const; // "Compare" function for sorting
- protected:
-
private:
Int_t fidDE; ///< det. elem. ID
AliMUONClusterFinderAZ *fRecModel; ///< cluster finder
// Functions
+ AliMUONDetElement(const AliMUONDetElement & rhs); // copy constructor
+ AliMUONDetElement& operator = (const AliMUONDetElement& rhs); // assignment operator
ClassDef(AliMUONDetElement,0) // detection element object
};
ClassImp(AliMUONEventRecoCombi)
//_________________________________________________________________________
-AliMUONEventRecoCombi::AliMUONEventRecoCombi() : TObject()
+ AliMUONEventRecoCombi::AliMUONEventRecoCombi()
+ : TObject(),
+ fDetElems(0x0),
+ fZ(0x0),
+ fNZ(0),
+ fDEvsZ(0x0)
{
// Ctor
fDetElems = new TClonesArray("AliMUONDetElement", 20);
fZ = new TArrayD(20);
- fNZ = 0;
- fDEvsZ = NULL;
}
//_________________________________________________________________________
delete [] fDEvsZ;
}
-//_________________________________________________________________________
-AliMUONEventRecoCombi::AliMUONEventRecoCombi (const AliMUONEventRecoCombi& rhs)
- : TObject(rhs)
-{
- // Protected copy constructor
- AliFatal("Not implemented.");
-}
-
-//_________________________________________________________________________
-AliMUONEventRecoCombi & AliMUONEventRecoCombi::operator = (const AliMUONEventRecoCombi& rhs)
-{
- // Protected assignment operator
-
- // check assignement to self
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
//_________________________________________________________________________
void AliMUONEventRecoCombi::FillEvent(AliMUONData *data, AliMUONClusterFinderAZ *recModel)
{
protected:
AliMUONEventRecoCombi();
- AliMUONEventRecoCombi(const AliMUONEventRecoCombi& rhs);
- AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
private:
static AliMUONEventRecoCombi* fgRecoCombi; //!< singleton instance
Int_t fNZ; //!< number of different Z's
Int_t **fDEvsZ; //!< list of DE's vs Z-coordinates
+ AliMUONEventRecoCombi(const AliMUONEventRecoCombi& rhs);
+ AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
+
ClassDef(AliMUONEventRecoCombi, 0) // Combined cluster/track finder steering class
};
#endif
//__________________________________________________________________________
AliMUONHitForRec::AliMUONHitForRec()
- : TObject()
+ : TObject(),
+ fBendingCoor(0.),
+ fNonBendingCoor(0.),
+ fZ(0.),
+ fBendingReso2(0.),
+ fNonBendingReso2(0.),
+ fChamberNumber(0),
+ fDetElemId(0),
+ fHitNumber(0),
+ fTTRTrack(0),
+ fTrackRefSignal(0),
+ fIndexOfFirstSegment(0),
+ fNSegments(0),
+ fFirstTrackHitPtr(0x0),
+ fLastTrackHitPtr(0x0),
+ fNTrackHits(0)
{
/// Default Constructor
- fFirstTrackHitPtr = 0;
- fLastTrackHitPtr = 0;
}
//__________________________________________________________________________
AliMUONHitForRec::AliMUONHitForRec(AliTrackReference* theGhit)
- : TObject()
+ : TObject(),
+ fBendingCoor(theGhit->Y()),
+ fNonBendingCoor(theGhit->X()),
+ fZ(theGhit->Z()),
+ fBendingReso2(0.),
+ fNonBendingReso2(0.),
+ fChamberNumber(0),
+ fDetElemId(0),
+ fHitNumber(0),
+ fTTRTrack(0),
+ fTrackRefSignal(0),
+ fIndexOfFirstSegment(-1),
+ fNSegments(0),
+ fFirstTrackHitPtr(0x0),
+ fLastTrackHitPtr(0x0),
+ fNTrackHits(0)
{
/// Constructor for AliMUONHitForRec from a track ref. hit.
/// Fills the bending, non bending, and Z coordinates,
/// the track number (track ref. and not TH),
/// and the chamber number (0...).
- fBendingCoor = theGhit->Y();
- fNonBendingCoor = theGhit->X();
- fZ = theGhit->Z();
// fTrack = theGhit->fTrack; ?????????
fDetElemId = theGhit->UserId();
if (fDetElemId) fChamberNumber = fDetElemId / 100 - 1;
else fChamberNumber = AliMUONConstants::ChamberNumber(fZ);
// other fields will be updated in
- // AliMUONEventReconstructor::NewHitForRecFromTrackRef,
- // except the following ones
- fIndexOfFirstSegment = -1;
- fNSegments = 0;
- fFirstTrackHitPtr = fLastTrackHitPtr = NULL;
- fNTrackHits = 0;
+ // AliMUONEventReconstructor::NewHitForRecFromTrackRef
return;
}
//__________________________________________________________________________
AliMUONHitForRec::AliMUONHitForRec(AliMUONRawCluster* theRawCluster)
- : TObject()
+ : TObject(),
+ fBendingCoor(theRawCluster->GetY(0)),
+ fNonBendingCoor(theRawCluster->GetX(0)),
+ fZ(0.),
+ fBendingReso2(0.),
+ fNonBendingReso2(0.),
+ fChamberNumber(0),
+ fDetElemId(theRawCluster->GetDetElemId()),
+ fHitNumber(0),
+ fTTRTrack(-1),
+ fTrackRefSignal(-1),
+ fIndexOfFirstSegment(-1),
+ fNSegments(0),
+ fFirstTrackHitPtr(0x0),
+ fLastTrackHitPtr(0x0),
+ fNTrackHits(0)
{
/// Constructor for AliMUONHitForRec from a raw cluster.
/// Fills the bending and non bending coordinates.
- fNonBendingCoor = theRawCluster->GetX(0);
- fBendingCoor = theRawCluster->GetY(0);
- fDetElemId = theRawCluster->GetDetElemId();
// other fields will be updated in
// AliMUONEventReconstructor::AddHitsForRecFromRawClusters,
- // except the following ones
- fTTRTrack = -1;
- fTrackRefSignal = -1;
- fIndexOfFirstSegment = -1;
- fNSegments = 0;
- fFirstTrackHitPtr = fLastTrackHitPtr = NULL;
- fNTrackHits = 0;
return;
}
//__________________________________________________________________________
AliMUONHitForRec::AliMUONHitForRec (const AliMUONHitForRec& theMUONHitForRec)
- : TObject(theMUONHitForRec)
+ : TObject(theMUONHitForRec),
+ fBendingCoor(theMUONHitForRec.fBendingCoor),
+ fNonBendingCoor(theMUONHitForRec.fNonBendingCoor),
+ fZ(theMUONHitForRec.fZ),
+ fBendingReso2(theMUONHitForRec.fBendingReso2),
+ fNonBendingReso2(theMUONHitForRec.fNonBendingReso2),
+ fChamberNumber(theMUONHitForRec.fChamberNumber),
+ fDetElemId(theMUONHitForRec.fDetElemId),
+ fHitNumber(theMUONHitForRec.fHitNumber),
+ fTTRTrack(theMUONHitForRec.fTTRTrack),
+ fTrackRefSignal(theMUONHitForRec.fTrackRefSignal),
+ fIndexOfFirstSegment(theMUONHitForRec.fIndexOfFirstSegment),
+ fNSegments(theMUONHitForRec.fNSegments),
+ fFirstTrackHitPtr(theMUONHitForRec.fFirstTrackHitPtr),
+ fLastTrackHitPtr(theMUONHitForRec.fLastTrackHitPtr),
+ fNTrackHits(theMUONHitForRec.fNTrackHits)
{
/// Copy constructor
- fBendingCoor = theMUONHitForRec.fBendingCoor;
- fNonBendingCoor = theMUONHitForRec.fNonBendingCoor;
- fZ = theMUONHitForRec.fZ;
- fBendingReso2 = theMUONHitForRec.fBendingReso2;
- fNonBendingReso2 = theMUONHitForRec.fNonBendingReso2;
- fChamberNumber = theMUONHitForRec.fChamberNumber;
- fDetElemId = theMUONHitForRec.fDetElemId;
- fHitNumber = theMUONHitForRec.fHitNumber;
- fTTRTrack = theMUONHitForRec.fTTRTrack;
- fTrackRefSignal = theMUONHitForRec.fTrackRefSignal;
- fIndexOfFirstSegment = theMUONHitForRec.fIndexOfFirstSegment;
- fNSegments = theMUONHitForRec.fNSegments;
- fFirstTrackHitPtr = theMUONHitForRec.fFirstTrackHitPtr;
- fLastTrackHitPtr = theMUONHitForRec.fLastTrackHitPtr;
- fNTrackHits = theMUONHitForRec.fNTrackHits;
}
//__________________________________________________________________________
//_____________________________________________________________________________
AliMUONPixel::AliMUONPixel()
- : TObject()
+ : TObject(),
+ fCharge(0),
+ fFlag(0)
{
/// Default constructor
- fXY[0] = fXY[1] = fSize[0] = fSize[1] = fCharge = 0;
- fFlag = 0;
+ fXY[0] = fXY[1] = fSize[0] = fSize[1] = 0;
}
//_____________________________________________________________________________
AliMUONPixel::AliMUONPixel(Double_t xc, Double_t yc, Double_t wx, Double_t wy, Double_t charge)
- : TObject()
+ : TObject(),
+ fCharge(charge),
+ fFlag(0)
{
/// Constructor
- fXY[0] = xc; fXY[1] = yc; fSize[0] = wx; fSize[1] = wy; fCharge = charge;
- fFlag = 0;
+ fXY[0] = xc; fXY[1] = yc; fSize[0] = wx; fSize[1] = wy;
}
//_____________________________________________________________________________
/// \endcond
//_____________________________________________________________________________
-AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader)
+ AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader)
+ : TObject(),
+ fRunLoader(0x0),
+ fMUONData(0x0),
+ fMuonTrackRef(0x0),
+ fTrackReco(0x0),
+ fReconstructibleTracks(0),
+ fRecoTracks(0)
{
/// Constructor
fRunLoader->LoadTrackRefs("READ");
loader->LoadTracks("READ");
- fReconstructibleTracks = 0;
- fRecoTracks = 0;
}
//_____________________________________________________________________________
/// Return reference muon tracks
TClonesArray *GetMuonTrackRef() {return fMuonTrackRef;}
-protected:
- AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
- AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
-
private:
AliRunLoader* fRunLoader; ///< alice run loader
Int_t fReconstructibleTracks; ///< number of reconstructible tracks
Int_t fRecoTracks; ///< number of reconstructed tracks
- ClassDef(AliMUONRecoCheck, 0) //Utility class to check reconstruction
+ AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
+ AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
+
+ ClassDef(AliMUONRecoCheck, 0) //Utility class to check reconstruction
};
#endif
ClassImp(AliMUONRecoTrack)
+//-------------------------------------------------------------------
+AliMUONRecoTrack::AliMUONRecoTrack()
+ : TObject(),
+ fSign(0),
+ fFlag(0),
+ fZvr(0.),
+ fChi2r(0.)
+{
+//Default constructor
+}
+
//-------------------------------------------------------------------
AliMUONRecoTrack::AliMUONRecoTrack(Bool_t active)
- : TObject()
+ : TObject(),
+ fSign(0),
+ fFlag(0),
+ fZvr(0.),
+ fChi2r(0.)
{
//Constructor of AliMUONRecoTrack
- fSign = 0;
- fZvr = 0.0;
- fChi2r = 0.0;
if (active) {
for (Int_t axis=0; axis<3; axis++) {
fPr[axis] = 0.0;
class AliMUONRecoTrack : public TObject
{
public:
- AliMUONRecoTrack() { }
+ AliMUONRecoTrack();
AliMUONRecoTrack(Bool_t active);
virtual ~AliMUONRecoTrack() { } //desctructor
Double_t GetChi2r() const {return fChi2r;};
//__________________________________________________________________________
AliMUONSegment::AliMUONSegment()
- : TObject()
+ : TObject(),
+ fHitForRecPtr1(0x0),
+ fHitForRecPtr2(0x0),
+ fBendingCoor(0.),
+ fBendingSlope(0.),
+ fBendingCoorReso2(0.),
+ fBendingSlopeReso2(0.),
+ fBendingCoorSlopeReso2(0.),
+ fBendingImpact(0.),
+ fNonBendingCoor(0.),
+ fNonBendingSlope(0.),
+ fNonBendingCoorReso2(0.),
+ fNonBendingSlopeReso2(0.),
+ fNonBendingCoorSlopeReso2(0.),
+ fNonBendingImpact(0.),
+ fZ(0.),
+ fInTrack(kFALSE)
{
// Default constructor
- fHitForRecPtr1 = 0; // pointer to HitForRec in first chamber
- fHitForRecPtr2 = 0; // pointer to HitForRec in second chamber
- // Bending plane:
- fBendingCoor = 0.0; // Coordinate in bending plane
- fBendingSlope = 0.0; // Slope in bending plane
- // Covariance in bending plane:
- fBendingCoorReso2 = 0.0; // Covariance(coordinate C1 in first chamber)
- fBendingSlopeReso2 = 0.0; // Covariance(slope)
- fBendingCoorSlopeReso2 = 0.0; // Covariance(C1,slope)
- fBendingImpact = 0.0; // Impact parameter in bending plane
- // Non Bending plane:
- fNonBendingCoor = 0.0; // Coordinate in non bending plane
- fNonBendingSlope = 0.0; // Slope in non bending plane
- // Covariance in non bending plane:
- fNonBendingCoorReso2 = 0.0; // Covariance(coordinate C1 in first chamber)
- fNonBendingSlopeReso2 = 0.0; // Covariance(slope)
- fNonBendingCoorSlopeReso2 = 0.0; // Covariance(C1,slope)
- fZ = 0.0; // z in first plane
- fNonBendingImpact = 0.0; // Impact parameter in non bending plane
- fInTrack = kFALSE; // TRUE if segment belongs to one track
+
}
//__________________________________________________________________________
AliMUONSegment::AliMUONSegment(AliMUONHitForRec* Hit1, AliMUONHitForRec* Hit2)
- : TObject()
+ : TObject(),
+ fHitForRecPtr1(Hit1),
+ fHitForRecPtr2(Hit2),
+ fBendingCoor(Hit1->GetBendingCoor()),
+ fBendingSlope(0.),
+ fBendingCoorReso2(Hit1->GetBendingReso2()),
+ fBendingSlopeReso2(0.),
+ fBendingCoorSlopeReso2(0.),
+ fBendingImpact(0.),
+ fNonBendingCoor(Hit1->GetNonBendingCoor()),
+ fNonBendingSlope(0.),
+ fNonBendingCoorReso2(Hit1->GetNonBendingReso2()),
+ fNonBendingSlopeReso2(0.),
+ fNonBendingCoorSlopeReso2(0.),
+ fNonBendingImpact(0.),
+ fZ(Hit1->GetZ()),
+ fInTrack(kFALSE)
{
// Constructor for AliMUONSegment from two HitForRec's,
// one, in the first chamber of the station, pointed to by "Hit1",
// in bending and non bending planes.
// Puts the "fInTrack" flag to "kFALSE".
Double_t dz;
- // pointers to HitForRec's
- fHitForRecPtr1 = Hit1;
- fHitForRecPtr2 = Hit2;
dz = Hit1->GetZ() - Hit2->GetZ();
- fZ = Hit1->GetZ();
+
// bending plane
- fBendingCoor = Hit1->GetBendingCoor();
fBendingSlope = (fBendingCoor - Hit2->GetBendingCoor()) / dz;
fBendingImpact = fBendingCoor - Hit1->GetZ() * fBendingSlope;
- fBendingCoorReso2 = Hit1->GetBendingReso2();
fBendingSlopeReso2 = ( Hit1->GetBendingReso2() +
Hit2->GetBendingReso2() ) / dz / dz;
fBendingCoorSlopeReso2 = Hit1->GetBendingReso2() / dz;
// non bending plane
- fNonBendingCoor = Hit1->GetNonBendingCoor();
fNonBendingSlope = (fNonBendingCoor - Hit2->GetNonBendingCoor()) / dz;
fNonBendingImpact = fNonBendingCoor - Hit1->GetZ() * fNonBendingSlope;
- fNonBendingCoorReso2 = Hit1->GetNonBendingReso2();
fNonBendingSlopeReso2 = ( Hit1->GetNonBendingReso2() +
Hit2->GetNonBendingReso2() ) / dz / dz;
fNonBendingCoorSlopeReso2 = Hit1->GetNonBendingReso2() / dz;
- // "fInTrack" flag to "kFALSE"
- fInTrack = kFALSE;
return;
}
-AliMUONSegment::AliMUONSegment (const AliMUONSegment& theMUONSegment)
- : TObject(theMUONSegment)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-AliMUONSegment & AliMUONSegment::operator=(const AliMUONSegment& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
//__________________________________________________________________________
Int_t AliMUONSegment::Compare(const TObject* Segment) const
{
Bool_t IsSortable() const { return kTRUE; }
Int_t Compare(const TObject* Segment) const; // "Compare" function for sorting
- protected:
- AliMUONSegment (const AliMUONSegment& AliMUONSegment); // copy constructor
- AliMUONSegment& operator=(const AliMUONSegment& AliMUONSegment); // assignment operator
-
private:
AliMUONHitForRec* fHitForRecPtr1; ///< pointer to HitForRec in first chamber
AliMUONHitForRec* fHitForRecPtr2; ///< pointer to HitForRec in second chamber
Double_t fZ; ///< Z of the segment
Bool_t fInTrack; ///< TRUE if segment belongs to one track
+ AliMUONSegment (const AliMUONSegment& AliMUONSegment); // copy constructor
+ AliMUONSegment& operator=(const AliMUONSegment& AliMUONSegment); // assignment operator
+
ClassDef(AliMUONSegment, 1) // Segment for reconstruction in ALICE dimuon spectrometer
};
//__________________________________________________________________________
AliMUONTrack::AliMUONTrack()
- : TObject()
+ : TObject(),
+ fTrackReconstructor(0x0),
+ fTrackParamAtVertex(),
+ fTrackParamAtHit(0x0),
+ fHitForRecAtHit(0x0),
+ fTrackHitsPtr(0x0),
+ fNTrackHits(0),
+ fFitMCS(0),
+ fFitNParam(0),
+ fFitStart(0),
+ fFitFMin(-1.),
+ fMatchTrigger(kFALSE),
+ fChi2MatchTrigger(0.),
+ fTrackID(0)
{
// Default constructor
fgFitter = 0;
- fTrackReconstructor = 0;
- fTrackHitsPtr = NULL;
- fTrackParamAtHit = NULL;
- fHitForRecAtHit = NULL;
- fTrackID = 0;
}
//__________________________________________________________________________
AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegment, AliMUONTrackReconstructor* TrackReconstructor)
- : TObject()
+ : TObject(),
+ fTrackReconstructor(TrackReconstructor),
+ fTrackParamAtVertex(),
+ fTrackParamAtHit(0x0),
+ fHitForRecAtHit(0x0),
+ fTrackHitsPtr(new TObjArray(10)),
+ fNTrackHits(0),
+ fFitMCS(0),
+ fFitNParam(3),
+ fFitStart(1),
+ fFitFMin(-1.),
+ fMatchTrigger(kFALSE),
+ fChi2MatchTrigger(0.),
+ fTrackID(0)
{
// Constructor from two Segment's
- fTrackReconstructor = TrackReconstructor; // link back to TrackReconstructor
- // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
- fTrackHitsPtr = new TObjArray(10);
- fNTrackHits = 0;
+
if (BegSegment) { //AZ
AddSegment(BegSegment); // add hits from BegSegment
AddSegment(EndSegment); // add hits from EndSegment
}
fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
- // set fit conditions...
- fFitMCS = 0;
- fFitNParam = 3;
- fFitStart = 1;
- fFitFMin = -1.0;
- fMatchTrigger = kFALSE;
- fChi2MatchTrigger = 0;
- fTrackID = 0;
return;
}
//__________________________________________________________________________
AliMUONTrack::AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec, AliMUONTrackReconstructor* TrackReconstructor)
- : TObject()
+ : TObject(),
+ fTrackReconstructor(TrackReconstructor),
+ fTrackParamAtVertex(),
+ fTrackParamAtHit(0x0),
+ fHitForRecAtHit(0x0),
+ fTrackHitsPtr(new TObjArray(10)),
+ fNTrackHits(0),
+ fFitMCS(0),
+ fFitNParam(3),
+ fFitStart(1),
+ fFitFMin(-1.),
+ fMatchTrigger(kFALSE),
+ fChi2MatchTrigger(0.),
+ fTrackID(0)
{
// Constructor from one Segment and one HitForRec
- fTrackReconstructor = TrackReconstructor; // link back to TrackReconstructor
- // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
- fTrackHitsPtr = new TObjArray(10);
- fNTrackHits = 0;
+
AddSegment(Segment); // add hits from Segment
AddHitForRec(HitForRec); // add HitForRec
fTrackHitsPtr->Sort(); // sort TrackHits according to increasing Z
SetTrackParamAtVertex(); // set track parameters at vertex
fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
- // set fit conditions...
- fFitMCS = 0;
- fFitNParam = 3;
- fFitStart = 1;
- fFitFMin = -1.0;
- fMatchTrigger = kFALSE;
- fChi2MatchTrigger = 0;
- fTrackID = 0;
return;
}
//__________________________________________________________________________
AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
- : TObject(theMUONTrack)
+ : TObject(theMUONTrack),
+ fTrackReconstructor(theMUONTrack.fTrackReconstructor),
+ fTrackParamAtVertex(theMUONTrack.fTrackParamAtVertex),
+ fTrackParamAtHit(0x0),
+ fHitForRecAtHit(0x0),
+ fTrackHitsPtr(0x0),
+ fNTrackHits(theMUONTrack.fNTrackHits),
+ fFitMCS(theMUONTrack.fFitMCS),
+ fFitNParam(theMUONTrack.fFitNParam),
+ fFitStart(theMUONTrack.fFitStart),
+ fFitFMin(theMUONTrack.fFitFMin),
+ fMatchTrigger(theMUONTrack.fMatchTrigger),
+ fChi2MatchTrigger(theMUONTrack.fChi2MatchTrigger),
+ fTrackID(theMUONTrack.fTrackID)
{
//fTrackReconstructor = new AliMUONTrackReconstructor(*MUONTrack.fTrackReconstructor);
// is it right ?
// NO, because it would use dummy copy constructor
// and AliMUONTrack is not the owner of its TrackReconstructor
- fTrackReconstructor = theMUONTrack.fTrackReconstructor;
- fTrackParamAtVertex = theMUONTrack.fTrackParamAtVertex;
+ //fTrackParamAtVertex = theMUONTrack.fTrackParamAtVertex;
// necessary to make a copy of the objects and not only the pointers in TObjArray.
- fTrackHitsPtr = 0;
if (theMUONTrack.fTrackHitsPtr) {
fTrackHitsPtr = new TObjArray(10);
for (Int_t index = 0; index < (theMUONTrack.fTrackHitsPtr)->GetEntriesFast(); index++) {
}
// necessary to make a copy of the objects and not only the pointers in TClonesArray.
- fTrackParamAtHit = 0;
if (theMUONTrack.fTrackParamAtHit) {
fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
for (Int_t index = 0; index < (theMUONTrack.fTrackParamAtHit)->GetEntriesFast(); index++) {
}
// necessary to make a copy of the objects and not only the pointers in TClonesArray.
- fHitForRecAtHit = 0;
if (theMUONTrack.fHitForRecAtHit) {
fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
for (Int_t index = 0; index < (theMUONTrack.fHitForRecAtHit)->GetEntriesFast(); index++) {
}
}
- fNTrackHits = theMUONTrack.fNTrackHits;
- fFitMCS = theMUONTrack.fFitMCS;
- fFitNParam = theMUONTrack.fFitNParam;
- fFitFMin = theMUONTrack.fFitFMin;
- fFitStart = theMUONTrack.fFitStart;
- fMatchTrigger = theMUONTrack.fMatchTrigger;
- fChi2MatchTrigger = theMUONTrack.fChi2MatchTrigger;
- fTrackID = theMUONTrack.fTrackID;
}
//__________________________________________________________________________
//__________________________________________________________________________
AliMUONTrackHit::AliMUONTrackHit()
- : TObject()
+ : TObject(),
+ fTrackParam(),
+ fHitForRecPtr(0x0),
+ fNextTrackHitWithSameHitForRec(0x0),
+ fPrevTrackHitWithSameHitForRec(0x0)
{
/// Default constructor
- fHitForRecPtr = 0;
- fNextTrackHitWithSameHitForRec = 0;
- fPrevTrackHitWithSameHitForRec = 0;
}
//__________________________________________________________________________
AliMUONTrackHit::AliMUONTrackHit (const AliMUONTrackHit& theMUONTrackHit)
- : TObject(theMUONTrackHit)
+ : TObject(theMUONTrackHit),
+ fTrackParam(theMUONTrackHit.fTrackParam),
+ fHitForRecPtr(theMUONTrackHit.fHitForRecPtr),
+ fNextTrackHitWithSameHitForRec(theMUONTrackHit.fNextTrackHitWithSameHitForRec),
+ fPrevTrackHitWithSameHitForRec(theMUONTrackHit.fPrevTrackHitWithSameHitForRec)
{
/// Copy constructor
- fTrackParam = theMUONTrackHit.fTrackParam;
- fHitForRecPtr = theMUONTrackHit.fHitForRecPtr;
- fNextTrackHitWithSameHitForRec = theMUONTrackHit.fNextTrackHitWithSameHitForRec;
- fPrevTrackHitWithSameHitForRec = theMUONTrackHit.fPrevTrackHitWithSameHitForRec;
}
//__________________________________________________________________________
AliMUONTrackHit & AliMUONTrackHit::operator=(const AliMUONTrackHit& theMUONTrackHit)
}
//__________________________________________________________________________
AliMUONTrackHit::AliMUONTrackHit(AliMUONHitForRec* Hit)
+ : TObject(),
+ fTrackParam(),
+ fHitForRecPtr(Hit),
+ fNextTrackHitWithSameHitForRec(0x0),
+ fPrevTrackHitWithSameHitForRec(0x0)
{
/// Constructor from the HitForRec pointed to by "Hit"
- fHitForRecPtr = Hit; // pointer to HitForRec
// links from/to HitForRec
if (Hit->GetNTrackHits() == 0) {
fPrevTrackHitWithSameHitForRec = NULL;
//__________________________________________________________________________
AliMUONTrackK::AliMUONTrackK()
- //AZ: TObject()
- : AliMUONTrack()
+ : AliMUONTrack(),
+ fStartSegment(0x0),
+ fPosition(0.),
+ fPositionNew(0.),
+ fChi2(0.),
+ fTrackHits(0x0),
+ fNmbTrackHits(0),
+ fTrackDir(1),
+ fBPFlag(kFALSE),
+ fRecover(0),
+ fSkipHit(0x0),
+ fTrackPar(0x0),
+ fTrackParNew(0x0),
+ fCovariance(0x0),
+ fWeight(0x0),
+ fParExtrap(0x0),
+ fParFilter(0x0),
+ fParSmooth(0x0),
+ fCovExtrap(0x0),
+ fCovFilter(0x0),
+ fJacob(0x0),
+ fNSteps(0),
+ fSteps(0x0),
+ fChi2Array(0x0),
+ fChi2Smooth(0x0)
{
/// Default constructor
fgHitForRec = NULL; // pointer to points
fgNOfPoints = 0; // number of points
- fStartSegment = NULL;
- fTrackHits = NULL;
- fNmbTrackHits = 0;
- fTrackPar = fTrackParNew = NULL;
- fCovariance = fWeight = NULL;
- fSkipHit = NULL;
- fParExtrap = fParFilter = fParSmooth = NULL;
- fCovExtrap = fCovFilter = NULL;
- fJacob = NULL;
- fSteps = NULL; fNSteps = 0;
- fChi2Array = NULL;
- fChi2Smooth = NULL;
-
return;
}
//__________________________________________________________________________
AliMUONTrackK::AliMUONTrackK(AliMUONTrackReconstructor *TrackReconstructor, TClonesArray *hitForRec)
- : AliMUONTrack()
+ : AliMUONTrack(),
+ fStartSegment(0x0),
+ fPosition(0.),
+ fPositionNew(0.),
+ fChi2(0.),
+ fTrackHits(0x0),
+ fNmbTrackHits(0),
+ fTrackDir(1),
+ fBPFlag(kFALSE),
+ fRecover(0),
+ fSkipHit(0x0),
+ fTrackPar(0x0),
+ fTrackParNew(0x0),
+ fCovariance(0x0),
+ fWeight(0x0),
+ fParExtrap(0x0),
+ fParFilter(0x0),
+ fParSmooth(0x0),
+ fCovExtrap(0x0),
+ fCovFilter(0x0),
+ fJacob(0x0),
+ fNSteps(0),
+ fSteps(0x0),
+ fChi2Array(0x0),
+ fChi2Smooth(0x0)
{
/// Constructor
fgNOfPoints = fgHitForRec->GetEntriesFast(); // number of points
fgCombi = NULL;
if (fgTrackReconstructor->GetTrackMethod() == 3) fgCombi = AliMUONEventRecoCombi::Instance();
-
- fStartSegment = NULL;
- fTrackHits = NULL;
- fNmbTrackHits = 0;
- fChi2 = 0;
- fTrackPar = fTrackParNew = NULL;
- fCovariance = fWeight = NULL;
- fSkipHit = NULL;
- fParExtrap = fParFilter = fParSmooth = NULL;
- fCovExtrap = fCovFilter = NULL;
- fJacob = NULL;
- fSteps = NULL; fNSteps = 0;
- fChi2Array = NULL;
- fChi2Smooth = NULL;
}
//__________________________________________________________________________
AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
//: AliMUONTrack(segment, segment, fgTrackReconstructor)
- : AliMUONTrack(NULL, segment, fgTrackReconstructor)
+ : AliMUONTrack(NULL, segment, fgTrackReconstructor),
+ fStartSegment(segment),
+ fPosition(0.),
+ fPositionNew(0.),
+ fChi2(0.),
+ fTrackHits(new TObjArray(13)),
+ fNmbTrackHits(2),
+ fTrackDir(1),
+ fBPFlag(kFALSE),
+ fRecover(0),
+ fSkipHit(0x0),
+ fTrackPar(new TMatrixD(fgkSize,1)),
+ fTrackParNew(new TMatrixD(fgkSize,1)),
+ fCovariance(new TMatrixD(fgkSize,fgkSize)),
+ fWeight(new TMatrixD(fgkSize,fgkSize)),
+ fParExtrap(new TObjArray(15)),
+ fParFilter(new TObjArray(15)),
+ fParSmooth(0x0),
+ fCovExtrap(new TObjArray(15)),
+ fCovFilter(new TObjArray(15)),
+ fJacob(new TObjArray(15)),
+ fNSteps(0),
+ fSteps(new TArrayD(15)),
+ fChi2Array(new TArrayD(13)),
+ fChi2Smooth(0x0)
{
/// Constructor from a segment
Double_t dX, dY, dZ;
AliMUONRawCluster *clus;
TClonesArray *rawclusters;
- fStartSegment = segment;
- fRecover = 0;
- fSkipHit = NULL;
// Pointers to hits from the segment
hit1 = segment->GetHitForRec1();
hit2 = segment->GetHitForRec2();
hit1 = hit2;
hit2 = segment->GetHitForRec1();
}
- // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
- fTrackHits = new TObjArray(13);
- fNmbTrackHits = 2;
- fChi2 = 0;
- fBPFlag = kFALSE;
- fTrackPar = new TMatrixD(fgkSize,1); // track parameters
- fTrackParNew = new TMatrixD(fgkSize,1); // track parameters
- fCovariance = new TMatrixD(fgkSize,fgkSize); // covariance matrix
- fWeight = new TMatrixD(fgkSize,fgkSize); // weight matrix (inverse of covariance)
// Fill array of track parameters
if (hit1->GetChamberNumber() > 7) {
// Evaluate covariance (and weight) matrix
EvalCovariance(dZ);
- // For smoother
- fParExtrap = new TObjArray(15);
- fParFilter = new TObjArray(15);
- fCovExtrap = new TObjArray(15);
- fCovFilter = new TObjArray(15);
- fJacob = new TObjArray(15);
- fSteps = new TArrayD(15);
- fNSteps = 0;
- fChi2Array = new TArrayD(13);
- fChi2Smooth = NULL;
- fParSmooth = NULL;
-
if (fgDebug < 0 ) return;
cout << fgTrackReconstructor->GetNRecTracks()-1 << " " << fgTrackReconstructor->GetBendingMomentumFromImpactParam(segment->GetBendingImpact()) << " " << 1/(*fTrackPar)(4,0) << " ";
if (fgTrackReconstructor->GetRecTrackRefHits()) {
delete fJacob;
}
- //__________________________________________________________________________
-AliMUONTrackK::AliMUONTrackK (const AliMUONTrackK& source)
- : AliMUONTrack(source)
-{
-/// Protected copy constructor
- AliFatal("Not implemented.");
-}
-
//__________________________________________________________________________
AliMUONTrackK & AliMUONTrackK::operator=(const AliMUONTrackK& source)
{
protected:
- AliMUONTrackK (const AliMUONTrackK& source); // copy constructor
AliMUONTrackK& operator=(const AliMUONTrackK& source); // assignment operator
private:
// Functions
+ AliMUONTrackK (const AliMUONTrackK& source); // copy constructor
void EvalCovariance(Double_t dZ);
void ParPropagation(Double_t zEnd);
void WeightPropagation(Double_t zEnd, Bool_t smooth);
//_________________________________________________________________________
AliMUONTrackParam::AliMUONTrackParam()
- : TObject()
+ : TObject(),
+ fInverseBendingMomentum(0.),
+ fBendingSlope(0.),
+ fNonBendingSlope(0.),
+ fZ(0.),
+ fBendingCoor(0.),
+ fNonBendingCoor(0.)
{
// Constructor
- fInverseBendingMomentum = 0;
- fBendingSlope = 0;
- fNonBendingSlope = 0;
- fZ = 0;
- fBendingCoor = 0;
- fNonBendingCoor = 0;
}
//_________________________________________________________________________
}
//_________________________________________________________________________
AliMUONTrackParam::AliMUONTrackParam(const AliMUONTrackParam& theMUONTrackParam)
- : TObject(theMUONTrackParam)
+ : TObject(theMUONTrackParam),
+ fInverseBendingMomentum(theMUONTrackParam.fInverseBendingMomentum),
+ fBendingSlope(theMUONTrackParam.fBendingSlope),
+ fNonBendingSlope(theMUONTrackParam.fNonBendingSlope),
+ fZ(theMUONTrackParam.fZ),
+ fBendingCoor(theMUONTrackParam.fBendingCoor),
+ fNonBendingCoor(theMUONTrackParam.fNonBendingCoor)
{
// Copy constructor
- fInverseBendingMomentum = theMUONTrackParam.fInverseBendingMomentum;
- fBendingSlope = theMUONTrackParam.fBendingSlope;
- fNonBendingSlope = theMUONTrackParam.fNonBendingSlope;
- fZ = theMUONTrackParam.fZ;
- fBendingCoor = theMUONTrackParam.fBendingCoor;
- fNonBendingCoor = theMUONTrackParam.fNonBendingCoor;
+
}
//_________________________________________________________________________
//__________________________________________________________________________
AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliLoader* loader, AliMUONData* data)
- : TObject()
+ : TObject(),
+ fTrackMethod(1), //AZ - tracking method (1-default, 2-Kalman)
+ fMinBendingMomentum(fgkDefaultMinBendingMomentum),
+ fMaxBendingMomentum(fgkDefaultMaxBendingMomentum),
+ fMaxChi2(fgkDefaultMaxChi2),
+ fMaxSigma2Distance(fgkDefaultMaxSigma2Distance),
+ fBendingResolution(fgkDefaultBendingResolution),
+ fNonBendingResolution(fgkDefaultNonBendingResolution),
+ fChamberThicknessInX0(fgkDefaultChamberThicknessInX0),
+ fSimpleBValue(fgkDefaultSimpleBValue),
+ fSimpleBLength(fgkDefaultSimpleBLength),
+ fSimpleBPosition(fgkDefaultSimpleBPosition),
+ fRecTrackRefHits(fgkDefaultRecTrackRefHits),
+ fEfficiency(fgkDefaultEfficiency),
+ // Initializions for track ref. background events
+ fBkgTrackRefFile(0x0),
+ fBkgTrackRefTK(0x0),
+ fBkgTrackRefParticles(0x0),
+ fBkgTrackRefTTR(0x0),
+ fBkgTrackRefEventNumber(-1),
+ fHitsForRecPtr(0x0),
+ fNHitsForRec(0),
+ fRecTracksPtr(0x0),
+ fNRecTracks(0),
+ fRecTrackHitsPtr(0x0),
+ fNRecTrackHits(0),
+ fMUONData(data),
+ fLoader(loader),
+ fMuons(0)
{
// Constructor for class AliMUONTrackReconstructor
SetReconstructionParametersToDefaults();
- fTrackMethod = 1; //AZ - tracking method (1-default, 2-Kalman)
+
// Memory allocation for the TClonesArray of hits for reconstruction
// Is 10000 the right size ????
fHitsForRecPtr = new TClonesArray("AliMUONHitForRec", 10000);
- fNHitsForRec = 0; // really needed or GetEntriesFast sufficient ????
+
// Memory allocation for the TClonesArray's of segments in stations
// Is 2000 the right size ????
for (Int_t st = 0; st < AliMUONConstants::NTrackingCh()/2; st++) {
// Memory allocation for the TClonesArray of reconstructed tracks
// Is 10 the right size ????
fRecTracksPtr = new TClonesArray("AliMUONTrack", 10);
- fNRecTracks = 0; // really needed or GetEntriesFast sufficient ????
+
// Memory allocation for the TClonesArray of hits on reconstructed tracks
// Is 100 the right size ????
fRecTrackHitsPtr = new TClonesArray("AliMUONTrackHit", 100);
- fNRecTrackHits = 0; // really needed or GetEntriesFast sufficient ????
// Sign of fSimpleBValue according to sign of Bx value at (50,50,-950).
Float_t b[3], x[3];
AliDebug(1,"Magnetic field from root file:");
if ( AliLog::GetGlobalDebugLevel()>0) gAlice->Field()->Dump();
-
- // Initializions for track ref. background events
- fBkgTrackRefFile = 0;
- fBkgTrackRefTK = 0;
- fBkgTrackRefParticles = 0;
- fBkgTrackRefTTR = 0;
- fBkgTrackRefEventNumber = -1;
-
- // initialize loader's
- fLoader = loader;
-
// initialize container
// fMUONData = new AliMUONData(fLoader,"MUON","MUON");
- fMUONData = data;
+ //fMUONData = data;
return;
}
- //__________________________________________________________________________
-AliMUONTrackReconstructor::AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs)
- : TObject(rhs)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-AliMUONTrackReconstructor &
-AliMUONTrackReconstructor::operator=(const AliMUONTrackReconstructor& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
//__________________________________________________________________________
AliMUONTrackReconstructor::~AliMUONTrackReconstructor(void)
{
// Set reconstruction parameters to default values
// Would be much more convenient with a structure (or class) ????
- fMinBendingMomentum = fgkDefaultMinBendingMomentum;
- fMaxBendingMomentum = fgkDefaultMaxBendingMomentum;
- fMaxChi2 = fgkDefaultMaxChi2;
- fMaxSigma2Distance = fgkDefaultMaxSigma2Distance;
// ******** Parameters for making HitsForRec
// minimum radius,
fSegmentMaxDistBending[4] = TMath::Abs( 6.0 *
(AliMUONConstants::DefaultChamberZ(9) - AliMUONConstants::DefaultChamberZ(8)) / 20.0);
-
- fBendingResolution = fgkDefaultBendingResolution;
- fNonBendingResolution = fgkDefaultNonBendingResolution;
- fChamberThicknessInX0 = fgkDefaultChamberThicknessInX0;
- fSimpleBValue = fgkDefaultSimpleBValue;
- fSimpleBLength = fgkDefaultSimpleBLength;
- fSimpleBPosition = fgkDefaultSimpleBPosition;
- fRecTrackRefHits = fgkDefaultRecTrackRefHits;
- fEfficiency = fgkDefaultEfficiency;
return;
}
AliMUONData* GetMUONData() {return fMUONData;}
- protected:
- AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); // copy constructor
- AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); // assignment operator
-
private:
// Constants which should be elsewhere ????
Int_t fMuons; ///< AZ - number of muons within acceptance - just for tests
// Functions
+ AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); // copy constructor
+ AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); // assignment operator
void ResetHitsForRec(void);
void MakeEventToBeReconstructed(void);
void AddHitsForRecFromTrackRef(TTree *TTR, Int_t Signal);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff