//PH virtual void RemapTrackHitIDs(Int_t * map);
protected:
+ /// Not implemented
AliMUON(const AliMUON& rMUON);
+ /// Not implemented
AliMUON& operator = (const AliMUON& rhs);
const AliMUONGeometry* GetGeometry() const;
fCurrentI(-1),
fCurrentJ(-1)
{
- // default ctor
+ /// default ctor
Reset();
}
//_____________________________________________________________________________
AliMUON2DMapIterator::~AliMUON2DMapIterator()
{
- // dtor
+ /// dtor
delete fIter2;
}
TObject*
AliMUON2DMapIterator::GetValue(TExMapIter& iter, Int_t& theKey) const
{
- // return the value corresponding to theKey in iterator iter
+ /// return the value corresponding to theKey in iterator iter
theKey = -1;
Long_t key, value;
Bool_t ok = iter.Next(key,value);
AliMpExMap*
AliMUON2DMapIterator::GetMap(TExMapIter& iter, Int_t& key)
{
- // get the map corresponding to key
+ /// get the map corresponding to key
AliMpExMap* rv(0x0);
TObject* o = GetValue(iter,key);
if (o)
TObject*
AliMUON2DMapIterator::Next()
{
- // logic :
- // get TObject* from fIter2
- // if null, increment fIter2 by getting next on fIter
+ /// logic :
+ /// get TObject* from fIter2
+ /// if null, increment fIter2 by getting next on fIter
if (!fIter2) return 0x0;
void
AliMUON2DMapIterator::Reset()
{
- // rewind the iterator
+ /// rewind the iterator
delete fIter2;
fIter.Reset();
AliMpExMap* m = GetMap(fIter,fCurrentI);
Bool_t
AliMUON2DMapIterator::Remove()
{
- // to be implemented if needed
+ /// to be implemented if needed
AliInfo("Not supported yet");
return kFALSE;
}
virtual Bool_t Remove();
private:
- // copy ctor will not implemented
- AliMUON2DMapIterator(const AliMUON2DMapIterator&);
- // assignement operator will not implemented
+ /// copy ctor will not implemented
+ AliMUON2DMapIterator(const AliMUON2DMapIterator&);
+ /// assignement operator will not implemented
AliMUON2DMapIterator& operator=(const AliMUON2DMapIterator&);
- TObject* GetValue(TExMapIter& iter, Int_t& key) const;
+ TObject* GetValue(TExMapIter& iter, Int_t& key) const;
AliMpExMap* GetMap(TExMapIter& iter, Int_t& key);
private:
- TExMapIter fIter; //! first iterator
- TExMapIter* fIter2; //! second iterator
- Int_t fCurrentI; //! current index in direction i
- Int_t fCurrentJ; //! current index in direction j
+ TExMapIter fIter; //!< first iterator
+ TExMapIter* fIter2; //!< second iterator
+ Int_t fCurrentI; //!< current index in direction i
+ Int_t fCurrentJ; //!< current index in direction j
ClassDef(AliMUON2DMapIterator,0) // VDataIterator for 2D maps
};
AliMUONV2DStore* GetStatus() const { return fStatus; }
+ /// Reports what is missing, trying to be as concise as possible.
void Report(TList& lines) const;
static void Report(TList& lines, const TObjArray& chambers);
private:
-
+ /// Not implemented
AliMUON2DStoreValidator(const AliMUON2DStoreValidator&);
+ /// Not implemented
AliMUON2DStoreValidator& operator=(const AliMUON2DStoreValidator&);
void AddMissingChannel(Int_t detElemId, Int_t manuId, Int_t manuChannel);
static void ReportManu(TList& list, AliMUONCheckItem& manu);
private:
- TList* fManuList; //! List of (DE,manuID) pairs.
- TObjArray* fChambers; //! Array of AliMUONCheckItem.
- AliMUONV2DStore* fStatus; //! Statuses
+ TList* fManuList; //!< List of (DE,manuID) pairs.
+ TObjArray* fChambers; //!< Array of AliMUONCheckItem.
+ AliMUONV2DStore* fStatus; //!< Statuses
ClassDef(AliMUON2DStoreValidator,2) // Validator of 2DStore
};
virtual ~AliMUONAlignment();
void ProcessTrack(AliMUONTrack *track);
+ /// Set geometry transformer
void SetGeometryTransformer(AliMUONGeometryTransformer * transformer) {
fTransform = transformer;
}
void SetNonLinear(Int_t param);
void AddConstraint(Double_t *factor, Double_t value );
void InitGlobalParameters(Double_t *par);
+ /// Set array of local derivatives
void SetLocalDerivative(Int_t index, Double_t value) {
fLocalDerivatives[index] = value;
}
+ /// Set array of global derivatives
void SetGlobalDerivative(Int_t index, Double_t value) {
fGlobalDerivatives[index] = value;
}
AliMUONGeometryTransformer*
ReAlign(const AliMUONGeometryTransformer * transformer, double *misAlignments, Bool_t verbose);
- protected:
+ private:
+ /// Not implemented
AliMUONAlignment(const AliMUONAlignment& right);
+ /// Not implemented
AliMUONAlignment& operator = (const AliMUONAlignment& right);
-
-
- private:
void Init(Int_t nGlobal, Int_t nLocal, Int_t nStdDev);
void ConstrainT(Int_t lDetElem, Int_t lCh, Double_t *lConstraintT, Int_t iVar);
TGeoCombiTrans ReAlign(const TGeoCombiTrans& transform, double *detElemMisAlignment) const;
- Bool_t fBFieldOn; // Flag for Magnetic filed On/Off
+ Bool_t fBFieldOn; ///< Flag for Magnetic filed On/Off
- Bool_t fDoF[3]; // Flags degrees of freedom to align (x,y,phi)
- Double_t fAllowVar[3]; // "Encouraged" variation for degrees of freedom
- Double_t fStartFac; // Initial value for chi2 cut
- // if > 1 Iterations in AliMillepede are turned on
- Double_t fResCutInitial; // Cut on residual for first iteration
- Double_t fResCut; // Cut on residual for other iterations
-
- AliMillepede *fMillepede; // Detector independent alignment class
+ Bool_t fDoF[3]; ///< Flags degrees of freedom to align (x,y,phi)
+ Double_t fAllowVar[3]; ///< "Encouraged" variation for degrees of freedom
+ Double_t fStartFac; ///< Initial value for chi2 cut
+ ///< if > 1 Iterations in AliMillepede are turned on
+ Double_t fResCutInitial; ///< Cut on residual for first iteration
+ Double_t fResCut; ///< Cut on residual for other iterations
+
+ AliMillepede *fMillepede; ///< Detector independent alignment class
- TClonesArray *fTrackParamAtHit; // Array of track parameters
- TClonesArray *fHitForRecAtHit; // Array of track hits
- AliMUONTrack *fTrack; // AliMUONTrack
- AliMUONHitForRec *fRecHit; // AliMUONHitForRec
- AliMUONTrackParam *fTrackParam; // Track parameters
-
- Int_t fNGlobal; // Number of global parameters
- Int_t fNLocal; // Number of local parameters
- Int_t fNStdDev; // Number of standard deviations for chi2 cut
- Double_t fClustPos[3]; // Cluster position
- Double_t fClustPosLoc[3]; // Cluster position in local coordinates
- Double_t fTrackSlope0[2]; // Track slope at reference point
- Double_t fTrackSlope[2]; // Track slope at current point
- Double_t fTrackPos0[3]; // Track intersection at reference point
- Double_t fTrackPos[3]; // Track intersection at current point
- Double_t fTrackPosLoc[3]; // Track intersection at current point in local coordinates
- Double_t fMeas[2]; // Current measurement (depend on B field On/Off)
- Double_t fSigma[2]; // Estimated resolution on measurement
-
- Double_t fGlobalDerivatives[468]; // Array of global derivatives
- Double_t fLocalDerivatives[4]; // Array of local derivatives
-
- Double_t fConstraintX[468]; // Array for constraint equation all X
- Double_t fConstraintY[468]; // Array for constraint equation all Y
- Double_t fConstraintP[468]; // Array for constraint equation all P
- Double_t fConstraintXT[468]; // Array for constraint equation X Top half
- Double_t fConstraintYT[468]; // Array for constraint equation Y Top half
- Double_t fConstraintPT[468]; // Array for constraint equation P Top half
- Double_t fConstraintXB[468]; // Array for constraint equation X Bottom half
- Double_t fConstraintYB[468]; // Array for constraint equation Y Bottom half
- Double_t fConstraintPB[468]; // Array for constraint equation P Bottom half
- Double_t fConstraintXR[468]; // Array for constraint equation X Right half
- Double_t fConstraintYR[468]; // Array for constraint equation Y Right half
- Double_t fConstraintPR[468]; // Array for constraint equation P Right half
- Double_t fConstraintXL[468]; // Array for constraint equation X Left half
- Double_t fConstraintYL[468]; // Array for constraint equation Y Left half
- Double_t fConstraintPL[468]; // Array for constraint equation P Left half
- Double_t fConstraintX3[468]; // Array for constraint equation St3 X
- Double_t fConstraintY3[468]; // Array for constraint equation St3 Y
- Double_t fConstraintX4[468]; // Array for constraint equation St4 X
- Double_t fConstraintY4[468]; // Array for constraint equation St4 Y
- Double_t fConstraintP4[468]; // Array for constraint equation St4 P
- Double_t fConstraintX5[468]; // Array for constraint equation St5 X
- Double_t fConstraintY5[468]; // Array for constraint equation St5 Y
-
- Int_t fDetElemId; // Detection element id
- Int_t fDetElemNumber; // Detection element number
- Double_t fPhi; // Azimuthal tilt of detection element
- Double_t fCosPhi; // Cosine of fPhi
- Double_t fSinPhi; // Sine of fPhi
- Double_t fDetElemPos[3]; // Position of detection element
-
- AliMUONGeometryTransformer *fTransform; // Geometry transformation
-
- static Int_t fgNSt; // Number tracking stations
- static Int_t fgNCh; // Number tracking chambers
- static Int_t fgNParCh; // Number of degrees of freedom per chamber
- static Int_t fgNDetElem; // Total number of detection elements
- static Int_t fgNDetElemCh[10]; // Number of detection elements per chamber
- static Int_t fgSNDetElemCh[10];// Sum of detection elements up to this chamber (inc)
+ TClonesArray *fTrackParamAtHit; ///< Array of track parameters
+ TClonesArray *fHitForRecAtHit; ///< Array of track hits
+ AliMUONTrack *fTrack; ///< AliMUONTrack
+ AliMUONHitForRec *fRecHit; ///< AliMUONHitForRec
+ AliMUONTrackParam *fTrackParam; ///< Track parameters
+
+ Int_t fNGlobal; ///< Number of global parameters
+ Int_t fNLocal; ///< Number of local parameters
+ Int_t fNStdDev; ///< Number of standard deviations for chi2 cut
+ Double_t fClustPos[3]; ///< Cluster position
+ Double_t fClustPosLoc[3]; ///< Cluster position in local coordinates
+ Double_t fTrackSlope0[2]; ///< Track slope at reference point
+ Double_t fTrackSlope[2]; ///< Track slope at current point
+ Double_t fTrackPos0[3]; ///< Track intersection at reference point
+ Double_t fTrackPos[3]; ///< Track intersection at current point
+ Double_t fTrackPosLoc[3]; ///< Track intersection at current point in local coordinates
+ Double_t fMeas[2]; ///< Current measurement (depend on B field On/Off)
+ Double_t fSigma[2]; ///< Estimated resolution on measurement
+
+ Double_t fGlobalDerivatives[468]; ///< Array of global derivatives
+ Double_t fLocalDerivatives[4]; ///< Array of local derivatives
+
+ Double_t fConstraintX[468]; ///< Array for constraint equation all X
+ Double_t fConstraintY[468]; ///< Array for constraint equation all Y
+ Double_t fConstraintP[468]; ///< Array for constraint equation all P
+ Double_t fConstraintXT[468]; ///< Array for constraint equation X Top half
+ Double_t fConstraintYT[468]; ///< Array for constraint equation Y Top half
+ Double_t fConstraintPT[468]; ///< Array for constraint equation P Top half
+ Double_t fConstraintXB[468]; ///< Array for constraint equation X Bottom half
+ Double_t fConstraintYB[468]; ///< Array for constraint equation Y Bottom half
+ Double_t fConstraintPB[468]; ///< Array for constraint equation P Bottom half
+ Double_t fConstraintXR[468]; ///< Array for constraint equation X Right half
+ Double_t fConstraintYR[468]; ///< Array for constraint equation Y Right half
+ Double_t fConstraintPR[468]; ///< Array for constraint equation P Right half
+ Double_t fConstraintXL[468]; ///< Array for constraint equation X Left half
+ Double_t fConstraintYL[468]; ///< Array for constraint equation Y Left half
+ Double_t fConstraintPL[468]; ///< Array for constraint equation P Left half
+ Double_t fConstraintX3[468]; ///< Array for constraint equation St3 X
+ Double_t fConstraintY3[468]; ///< Array for constraint equation St3 Y
+ Double_t fConstraintX4[468]; ///< Array for constraint equation St4 X
+ Double_t fConstraintY4[468]; ///< Array for constraint equation St4 Y
+ Double_t fConstraintP4[468]; ///< Array for constraint equation St4 P
+ Double_t fConstraintX5[468]; ///< Array for constraint equation St5 X
+ Double_t fConstraintY5[468]; ///< Array for constraint equation St5 Y
+
+ Int_t fDetElemId; ///< Detection element id
+ Int_t fDetElemNumber; ///< Detection element number
+ Double_t fPhi; ///< Azimuthal tilt of detection element
+ Double_t fCosPhi; ///< Cosine of fPhi
+ Double_t fSinPhi; ///< Sine of fPhi
+ Double_t fDetElemPos[3]; ///< Position of detection element
+
+ AliMUONGeometryTransformer *fTransform; ///< Geometry transformation
+
+ static Int_t fgNSt; ///< Number tracking stations
+ static Int_t fgNCh; ///< Number tracking chambers
+ static Int_t fgNParCh; ///< Number of degrees of freedom per chamber
+ static Int_t fgNDetElem; ///< Total number of detection elements
+ static Int_t fgNDetElemCh[10]; ///< Number of detection elements per chamber
+ static Int_t fgSNDetElemCh[10];///< Sum of detection elements up to this chamber (inc)
ClassDef(AliMUONAlignment, 0)};
/// \ingroup base
/// \class AliMUONChamber
/// \brief MUON tracking chamber class
+///
+/// Now only providing DisIntegration function
#include <TObject.h>
#include <TObjArray.h>
virtual void SetChargeCorrel(Float_t correl) {fResponse->SetChargeCorrel(correl);}
protected:
+ /// Not implemented
AliMUONChamber(const AliMUONChamber & rChamber);
- // assignment operator
+ /// Not implemented
AliMUONChamber& operator =(const AliMUONChamber& rhs);
Int_t fId; ///< chamber number
///
/// Implementation of AliMUONChamber for the trigger
///
-/// This class is to be deprecated.
+/// \deprecated This class is to be deprecated.
///
/// \cond CLASSIMP
Int_t& nnew, Float_t newclust[6][500]);
protected:
+ /// Not implemented
AliMUONChamberTrigger(const AliMUONChamberTrigger& right);
+ /// Not implemented
AliMUONChamberTrigger& operator = (const AliMUONChamberTrigger& right);
const AliMUONGeometryTransformer* fkGeomTransformer;///< geometry transformations
void SetEventsToCheck(Int_t firstEvent, Int_t lastEvent);
private:
+ /// Not implemented
AliMUONCheck(const AliMUONCheck& rhs);
+ /// Not implemented
AliMUONCheck& operator=(const AliMUONCheck& rhs);
private:
AliMUONCheckItem(Int_t id, Int_t maxNumber, const char* name);
virtual ~AliMUONCheckItem();
+ /// Return the identifier of this item
Int_t GetID() const { return fID; }
TObject* GetItem(Int_t id) const;
void Print(Option_t* opt="") const;
private:
+ /// Not implemented
AliMUONCheckItem(const AliMUONCheckItem&);
+ /// Not implemented
AliMUONCheckItem& operator=(const AliMUONCheckItem&);
+
void ComputeDead() const;
private:
Int_t Next(); // commands for drawing
Bool_t FindEvCh(Int_t nev, Int_t ch); // find requested event and chamber
void FillMuon(Int_t nfit, const Double_t *parOk, const Double_t *errOk); // fill muon info
- void ResetMuon() { fxyMu[0][6] = fxyMu[1][6] = 9999; } // reset muons
+ void ResetMuon() { fxyMu[0][6] = fxyMu[1][6] = 9999; } ///< reset muons
void UpdateCluster(Int_t npad); // update cluster after removing non-overlapped pads
private:
// Functions
+ /// Not implemented
AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs);
+ /// Not implemented
AliMUONClusterDrawAZ& operator=(const AliMUONClusterDrawAZ& rhs);
+
void Init(); // initialization
void ModifyHistos(); // modify histograms
void DrawHits(); // draw simulated and reconstructed hits
void FindRawClusters(); // the same interface as for old cluster finder
void EventLoop(Int_t nev = 0, Int_t ch = 0); // first event
Bool_t TestTrack(Int_t t) const; // test if track was selected
+
+ /// Return the number of pads in the cluster on the given cathode
Int_t GetNPads(Int_t cath) const { return fnPads[cath]; }
+ /// Return pad information \todo add more details
Int_t GetIJ(Int_t indx, Int_t iPad) const { return fPadIJ[indx][iPad]; }
+ /// Return pad information \todo add more details
Float_t GetXyq(Int_t indx, Int_t iPad) const { return fXyq[indx][iPad]; }
+ /// Return the z-coordinate of the hit
Float_t GetZpad() const { return fZpad; }
+ /// Return the flag for used pads
Bool_t GetUsed(Int_t cath, Int_t dig) const { return fUsed[cath][dig]; }
- void SetUsed(Int_t cath, Int_t dig) { fUsed[cath][dig] = kTRUE; } // mark used digits
- void SetUnused(Int_t cath, Int_t dig) { fUsed[cath][dig] = kFALSE; } // unmark digits
- 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
-
+
+ /// Mark used digits
+ void SetUsed(Int_t cath, Int_t dig) { fUsed[cath][dig] = kTRUE; }
+ /// Unmark digits
+ void SetUnused(Int_t cath, Int_t dig) { fUsed[cath][dig] = kFALSE; }
+ /// Set reco flag
+ void SetReco(Int_t iReco) { fReco = iReco; }
+ /// Start \todo add more details
+ void SetStart(Int_t iCath, Int_t iPad) { fCathBeg = iCath; fPadBeg[0] = fPadBeg[1] = 0; fPadBeg[fCathBeg] = iPad; }
+
private:
// Some constants
static const Int_t fgkDim = 10000; ///< array size
static AliMUONClusterFinderAZ* fgClusterFinder; ///< the ClusterFinderAZ instance
Int_t fnPads[2]; //!< number of pads in the cluster on 2 cathodes
- Float_t fXyq[7][fgkDim]; //!< pad information
- Int_t fPadIJ[4][fgkDim]; //!< pad information
+ Float_t fXyq[7][fgkDim]; //!< pad information \todo add more details
+ Int_t fPadIJ[4][fgkDim]; //!< pad information \todo add more details
AliMUONVGeometryDESegmentation *fSegmentation[2]; //!< new segmentation
Float_t fZpad; //!< z-coordinate of the hit
Int_t fNpar; //!< number of fit parameters
// Functions
+ /// Not implemented
AliMUONClusterFinderAZ(const AliMUONClusterFinderAZ& rhs);
+ /// Not implemented
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
Double_t dyc, Double_t dxc, Double_t qtot,
Double_t &yrec, Double_t &xrec, Double_t &erry, Double_t &errx);
- // Dummy methods for overloading warnings
+ /// Dummy method for overloading warnings
void FindCluster(int, int, int, AliMUONRawCluster&) {return;}
+ /// Dummy method for overloading warnings
void FindLocalMaxima(AliMUONRawCluster*) {return;}
+ /// Dummy method for overloading warnings
void Split(AliMUONRawCluster*) {return;}
+ /// Dummy method for overloading warnings
void AddRawCluster(AliMUONRawCluster&) {return;}
ClassDef(AliMUONClusterFinderAZ,0) // cluster finder in MUON arm of ALICE
/// \ingroup rec
/// \class AliMUONClusterFinderVS
/// \brief Class for clustering and reconstruction of space points
+///
+/// (Not used by default)
#include <TObject.h>
public:
AliMUONClusterFinderVS();
virtual ~AliMUONClusterFinderVS();
-// Decluster ?
+/// Decluster ?
virtual void SetDeclusterFlag(Int_t flag=1) {fDeclusterFlag =flag;}
-// Set max. cluster size ; bigger clusters will deconvoluted
+/// Set max. cluster size ; bigger clusters will deconvoluted
virtual void SetClusterSize(Int_t clsize=5) {fClusterSize = clsize;}
-// Set max. number of pads per local cluster
+/// Set max. number of pads per local cluster
virtual void SetNperMax(Int_t npermax=5) {fNperMax = npermax;}
// Search for raw clusters
virtual void FindRawClusters();
// Build up full cluster information
virtual void FillCluster(AliMUONRawCluster *cluster, Int_t flag, Int_t cath);
virtual void FillCluster(AliMUONRawCluster *cluster, Int_t cath);
+/// \todo add comment
virtual void FillCluster(AliMUONRawCluster *cluster) {FillCluster(cluster,1,0);}
// Add a new raw cluster
virtual void AddRawCluster(AliMUONRawCluster& cluster);
-// Set tracks for debugging
+/// Set tracks for debugging
virtual void SetTracks(Int_t t1, Int_t t2) {fTrack[0]=t1; fTrack[1]=t2;}
+/// Set cut in charge matching chi2
void SetGhostChi2Cut(Float_t cut) {fGhostChi2Cut = cut;}
-// get raw cluster pointer
+/// Get raw cluster pointer
TClonesArray* GetRawClusters() {return fRawClusters;}
-// reset raw clusters
+/// Reset raw clusters
void ResetRawClusters();
// set evt number
void SetEventNumber(Int_t evtNumber) {fEvtNumber = evtNumber;}
Int_t fEvtNumber; ///< evt number for AZ
private:
+ /// Not implemented
AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
-// Assignment operator
+ /// Not implemented assignment operator
AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
ClassDef(AliMUONClusterFinderVS,3) //Class for clustering and reconstruction of space points
void SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig);
void SetCluster(AliMUONRawCluster* cluster);
// Access functions
+ /// Return the current chamber number
Int_t Chamber() const {return fChamber;}
+ /// Return i-th digit for given cath
AliMUONDigit* Digit(Int_t cath, Int_t i) const {return (AliMUONDigit*) (fDigits[cath]->UncheckedAt(i));}
+ /// Return the array of digits for given cathod
TClonesArray* Digits(Int_t cath) const {return fDigits[cath];}
+ /// Return number of digits for given cathod
Int_t NDigits(Int_t cath) const {return fNDigits[cath];}
+ /// Return geometry segmentation for given cathod
AliMUONGeometrySegmentation* Segmentation2(Int_t cath) const {return fSegmentation2[cath];}
+ /// Return Mathieson
AliMUONMathieson* Mathieson() const {return fgMathieson;}
+ /// Return charge correlation
Float_t ChargeCorrel() const {return fChargeCorrel;}
+ /// Return detection elt id
Int_t DetElemId() const {return fDetElemId;}
// Fitting
+ /// Return the fitter
TMinuit* Fitter() const {return fgMinuit;}
// Current cluster information
+ /// Return the total charge for given cathod
Float_t TotalCharge(Int_t cath) const {return fChargeTot[cath];}
+ /// Return the charge for the given cluster and cathod
Float_t Charge(Int_t dig, Int_t cath) const {return fCharge[dig][cath];}
+ /// Return the x-position for the given cluster and cathod
Int_t Ix(Int_t dig, Int_t cath) const {return fix[dig][cath];}
+ /// Return the y-position for the given cluster and cathod
Int_t Iy(Int_t dig, Int_t cath) const {return fiy[dig][cath];}
+ /// Return the cluster multiplicity for given cathod
Int_t Nmul(Int_t cath) const {return fNmul[cath];}
+
// Helpers for Fit
Float_t DiscrChargeS1(Int_t i,Double_t *par);
Float_t DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath);
#include "TClass.h"
///
+/// \class AliMUONConstants
/// This class holds various constants to be used in many places,
/// such as the number of tracking and trigger chambers,
/// some geometrical constants (to build the initial geometry for simulation)
/* $Id$ */
-/// AliMUONData class
+/// \class AliMUONData class
///
/// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
/// The classe makes the lik between the MUON data lists and the event trees from loaders
///
-/// Gines Martinez, Subatech, September 2003
+/// \author Gines Martinez, Subatech, September 2003
///
#include "AliMUONData.h"
//
/// \ingroup base
/// \class AliMUONData
-/// \brief MUON data
-///
-/// Class containing MUON data: hits, digits, rawclusters, globaltrigger,
+/// \brief Class containing MUON data: hits, digits, rawclusters, globaltrigger,
/// localtrigger, etc ...
///
-/// Author: Gines Martinez, Subatech, September 2003
+// Author: Gines Martinez, Subatech, September 2003
#include <TNamed.h>
/// (for performance reason mainly, and because anyway we know we have to do it
/// here, at the digitization level).
///
+/// \author Laurent Aphecetche
namespace
{
/// \ingroup rec
/// \class AliMUONEventRecoCombi
/// \brief Combined cluster / track finder in the MUON arm of ALICE
+/// \author Alexander Zinchenko, JINR Dubna
#include <TObject.h>
#include <TArrayD.h>
//
// Class AliMUONGeometryEnvelope
// -----------------------------
-// Helper class for definititon an assembly of volumes.
+// Helper class for definititon of an assembly of volumes.
// Author: Ivana Hrivnacova, IPN Orsay
// 23/01/2004
/// \class AliMUONGeometryModuleTransformer
/// \brief Geometry transformer for a detector module
///
-/// Class for definition of the trasformation for adetector module
+/// Class for definition of the transformation for a detector module
/// and its detection elements
///
/// \author Ivana Hrivnacova, IPN Orsay
* provided "as is" without express or implied warranty. *
**************************************************************************/
+/* $Id$ */
+
//
// Class AliMUONGeometrySegmentation
// -------------------------------
//
// Author:Ivana Hrivnacova, IPN Orsay
-/* $Id$ */
-
#include "AliMUONGeometrySegmentation.h"
#include "AliMUONVGeometryDESegmentation.h"
#include "AliMUONGeometryModuleTransformer.h"
/* $Id$ */
-//*-- Author: Rachid Guernane (LPCCFd)
-// GLOBAL TRIGGER IMPLEMENTATION
-// INPUTS ARE REGIONAL RESPONSES
-// OUTPUT IS A 12-BIT WORD
-// 4 BITS PER TRIGGER LEVEL
+/// \class AliMUONGlobalTriggerBoard
+/// Global trigger implementation:
+/// - inputs are regional responses
+/// - output is a 12-bit word
+/// - 4 bits per trigger level
+///
+/// \author Rachid Guernane (LPCCFd)
#include "AliMUONGlobalTriggerBoard.h"
#include "AliLog.h"
/// \ingroup sim
/// \class AliMUONGlobalTriggerBoard
-/// \brief GLOBAL TRIGGER
+/// \brief Global trigger
///
-/// \author Rachid Guernane (LPCCFd)
+// Author: Rachid Guernane (LPCCFd)
#include "AliMUONTriggerBoard.h"
/// \ingroup rec
/// \class AliMUONHitForRec
/// \brief Hit for reconstruction in ALICE dimuon spectrometer
+///
+/// \author J. Gosset
#include <TObject.h>
/* $Id$ */
-// -------------------------------------
-// Class AliMUONPixel
-// -------------------------------------
-// Basic object of the cluster / rec. point finder based
-// on Expectation-Minimization approach (AZ cluster finder)
-// Author: Alexander Zinchenko, JINR Dubna
+/// \class AliMUONPixel
+/// Basic object of the cluster / rec. point finder based
+/// on Expectation-Minimization approach (AZ cluster finder)
+///
+/// \author Alexander Zinchenko, JINR Dubna
#include "AliMUONPixel.h"
/// \class AliMUONPixel
/// \brief Pixel for MLEM method of cluster finding
///
-/// \author Alexander Zinchenko, JINR Dubna
+// Author Alexander Zinchenko, JINR Dubna
#include <TObject.h>
* provided "as is" without express or implied warranty. *
**************************************************************************/
+/* $Id $ */
+
///////////////////////////////////////////////////////////////////////////////
///
+/// \class AliMUONRawStreamTracker
/// This class provides access to MUON digits in raw data.
///
/// It loops over all MUON digits in the raw data given by the AliRawReader.
///
/// First version implement for Tracker
///
+/// \author Christian Finck
///////////////////////////////////////////////////////////////////////////////
#include "AliMUONRawStreamTracker.h"
/// \class AliMUONRawStreamTracker
/// \brief Class for reading MUON raw digits
///
-/// \author Christian Finck
-///
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to MUON digits in raw data.
-///
-///////////////////////////////////////////////////////////////////////////////
+// Author: Christian Finck
#include <TObject.h>
#include "AliMUONPayloadTracker.h"
* provided "as is" without express or implied warranty. *
**************************************************************************/
+/* $Id $ */
///////////////////////////////////////////////////////////////////////////////
///
+/// \class AliMUONRawStreamTrigger
/// This class provides access to MUON digits in raw data.
///
/// It loops over all MUON digits in the raw data given by the AliRawReader.
/// in payload class.
///
/// First version implement for Trigger
+/// \author Christian Finck
///
///////////////////////////////////////////////////////////////////////////////
/// \class AliMUONRawStreamTrigger
/// \brief Class for reading MUON raw digits
///
-/// \author Christian Finck
-///
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to MUON digits in raw data.
-///
-///////////////////////////////////////////////////////////////////////////////
+// Author: Christian Finck
#include <TObject.h>
#include "AliMUONPayloadTrigger.h"
/* $Id$ */
-// ----------------------
-// Class AliMUONRecoTrack
-// ----------------------
-// This class represents a reconstructed muon track
-// in the tree of reconstructed events.
-// Authors: Mihaela Gheata, Andrei Gheata 09/10/00
+/// \class AliMUONRecoTrack
+/// This class represents a reconstructed muon track
+/// in the tree of reconstructed events.
+///
+/// \author Mihaela Gheata, Andrei Gheata 09/10/00
#include <Riostream.h>
/// \class AliMUONRecoTrack
/// \brief A reconstructed muon track
///
-/// \author M.Gheata, A.Gheata 09/10/00
+// Author: M.Gheata, A.Gheata 09/10/00
#include <TObject.h>
#include <TMath.h>
/* $Id$ */
-//*-- Author: Rachid Guernane (LPCCFd)
-// DIMUON REGIONAL TRIGGER IMPLEMENTATION
-// ENTRY ARE LOCAL BOARD RESPONSES
-// OUTPUT IS 12-BIT WORD
-// ALGORITHM IS SIMILAR TO THE GLOBAL ONE
+/// \class AliMUONRegionalTriggerBoard
+/// Dimuon regional trigger implementation:
+/// - entry are local board responses
+/// - output is 12-bit word
+/// - algorithm is similar to the global one
+///
+/// \author Rachid Guernane (LPCCFd)
#include "AliMUONRegionalTriggerBoard.h"
/// \ingroup sim
/// \class AliMUONRegionalTriggerBoard
-/// \brief REGIONAL TRIGGER
-/// REAL HW ALGORITHM IS IMPLEMENTED
-/// \author Rachid Guernane (LPCCFd)
+/// \brief Regional trigger - real HW algorithm is implemented
+///
+// Author: Rachid Guernane (LPCCFd)
#include "AliMUONTriggerBoard.h"
///-----------------NON-BENDING------------------------------------- /n
/// Returns list of 10 next neighbours for given Y strip (ix, iy) /n
/// neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list /n
- /// \_______/ \_______/ /n
+ /// |_______| |_______/ /n
+
/// left right /n
for (Int_t i=0; i<10; i++) {
virtual void SetPitch(Float_t p1) {fMathieson->SetPitch(p1);};
/// Set Mathieson parameters
- /// Mathieson \sqrt{Kx3} and derived Kx2 and Kx4
+ /// Mathieson sqrt{Kx3} and derived Kx2 and Kx4
/// passing pointer to class Mathieson for backward compatibility
virtual void SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3);
- /// Mathieson \sqrt{Kx3}
+ /// Mathieson sqrt{Kx3}
virtual void SetSqrtKx3(Float_t p1) {fMathieson->SetSqrtKx3(p1);};
/// Mathieson Kx2
virtual void SetKx2(Float_t p1) {fMathieson->SetKx2(p1);};
/// Mathieson Kx4
virtual void SetKx4(Float_t p1) {fMathieson->SetKx4(p1);};
- /// Mathieson \sqrt{Ky3} and derived Ky2 and Ky4
+ /// Mathieson sqrt{Ky3} and derived Ky2 and Ky4
virtual void SetSqrtKy3AndDeriveKy2Ky4(Float_t SqrtKy3);
- /// Mathieson \sqrt{Ky3}
+ /// Mathieson sqrt{Ky3}
virtual void SetSqrtKy3(Float_t p1) {fMathieson->SetSqrtKy3(p1);};
/// Mathieson Ky2
virtual void SetKy2(Float_t p1) {fMathieson->SetKy2(p1);};
/* $Id$ */
-/// \class AliMUONVTrackReconstructor
////////////////////////////////////
///
+/// \class AliMUONVTrackReconstructor
/// Virtual MUON track reconstructor in ALICE (class renamed from AliMUONEventReconstructor)
///
/// This class contains as data:
/// * EventReconstruct to build the muon tracks
/// * EventReconstructTrigger to build the trigger tracks
///
+/// \author Philippe Pillot
+///
////////////////////////////////////
#include "AliMUONVTrackReconstructor.h"
/// \class AliMUONVTrackReconstructor
/// \brief Virtual class for the MUON track reconstruction
///
-/////////////////////////////////////////////
-/// Virtual MUON track reconstructor in ALICE
-/////////////////////////////////////////////
+// Author: Philippe Pillot
#include <TObject.h>
virtual Int_t SetGlobalConstraint(double dercs[], double rhs);
virtual Int_t SetLocalEquation(double dergb[], double derlc[], double rmeas, double sigma);
virtual Int_t LocalFit(int n, double localParams[], Bool_t bSingleFit);
+ /// Get number of local equations
virtual Int_t GetNLocalEquations() const {return fNLocalEquations;};
+ /// Set number of local equations
virtual void SetNLocalEquations(int value) {fNLocalEquations = value;};
virtual Int_t PrintGlobalParameters() const;
virtual Int_t SetIterations (double cutfac);
// Max. dimensions
- static const int fgkMaxGlobalPar = 1000; // Max. number of global parameters
- static const int fgkMaxLocalPar = 20; // Max. number of local parameters
- static const int fgkMaxGloCsts = 10; // Max. number of constraint equations
- static const int fgkMaxGloPC = 1010; // fgkMaxGlobalPar+fgkMaxGloCsts
+ static const int fgkMaxGlobalPar = 1000; ///< Max. number of global parameters
+ static const int fgkMaxLocalPar = 20; ///< Max. number of local parameters
+ static const int fgkMaxGloCsts = 10; ///< Max. number of constraint equations
+ static const int fgkMaxGloPC = 1010; ///< fgkMaxGlobalPar+fgkMaxGloCsts
// Private methods
- Double_t GetParCorrelation(int i, int j);
+ // Double_t GetParCorrelation(int i, int j);
int SpmInv(double v[][fgkMaxGloPC], double b[], int n);
int SpmInv(double v[][fgkMaxLocalPar], double b[], int n);
// Matrices
- double fMatCGlo[fgkMaxGloPC][fgkMaxGloPC]; // Matrix C global
- double fMatCLoc[fgkMaxLocalPar][fgkMaxLocalPar]; // Matrix C local
- double fMatCGloLoc[fgkMaxGlobalPar][fgkMaxLocalPar]; // Rectangular matrix C g*l
- double fMatCGloCorr[fgkMaxGlobalPar][fgkMaxGlobalPar];// Correction of matrix C global
- double fMatDerConstr[fgkMaxGloCsts][fgkMaxGlobalPar]; // Constrained derivatives
+ double fMatCGlo[fgkMaxGloPC][fgkMaxGloPC]; ///< Matrix C global
+ double fMatCLoc[fgkMaxLocalPar][fgkMaxLocalPar]; ///< Matrix C local
+ double fMatCGloLoc[fgkMaxGlobalPar][fgkMaxLocalPar]; ///< Rectangular matrix C g*l
+ double fMatCGloCorr[fgkMaxGlobalPar][fgkMaxGlobalPar];///< Correction of matrix C global
+ double fMatDerConstr[fgkMaxGloCsts][fgkMaxGlobalPar]; ///< Constrained derivatives
// Vectors and useful variables
- double fDiagCGlo[fgkMaxGloPC]; // Initial diagonal elements of C global matrix
- double fVecBGlo[fgkMaxGloPC]; // Vector B global (parameters)
- double fVecBGloCorr[fgkMaxGlobalPar]; // Correction of vector B global
- double fVecBLoc[fgkMaxLocalPar]; // Vector B local (parameters)
+ double fDiagCGlo[fgkMaxGloPC]; ///< Initial diagonal elements of C global matrix
+ double fVecBGlo[fgkMaxGloPC]; ///< Vector B global (parameters)
+ double fVecBGloCorr[fgkMaxGlobalPar]; ///< Correction of vector B global
+ double fVecBLoc[fgkMaxLocalPar]; ///< Vector B local (parameters)
- double fInitPar[fgkMaxGlobalPar]; // Initial global parameters
- double fDeltaPar[fgkMaxGlobalPar]; // Variation of global parameters
- double fSigmaPar[fgkMaxGlobalPar]; // Sigma of allowed variation of global parameter
+ double fInitPar[fgkMaxGlobalPar]; ///< Initial global parameters
+ double fDeltaPar[fgkMaxGlobalPar]; ///< Variation of global parameters
+ double fSigmaPar[fgkMaxGlobalPar]; ///< Sigma of allowed variation of global parameter
- double fLagMult[fgkMaxGloCsts]; // Lagrange multipliers of constrained equations
+ double fLagMult[fgkMaxGloCsts]; ///< Lagrange multipliers of constrained equations
- Bool_t fIsNonLinear[fgkMaxGlobalPar]; // Flag for non linear parameters
- int fGlo2CGLRow[fgkMaxGlobalPar]; // Global parameter to row in "used" g*l matrix
- int fCGLRow2Glo[fgkMaxGlobalPar]; // Row in "used" g*l matrix to global parameter
+ Bool_t fIsNonLinear[fgkMaxGlobalPar]; ///< Flag for non linear parameters
+ int fGlo2CGLRow[fgkMaxGlobalPar]; ///< Global parameter to row in "used" g*l matrix
+ int fCGLRow2Glo[fgkMaxGlobalPar]; ///< Row in "used" g*l matrix to global parameter
- TArrayI fIndexLocEq; // Table of parameter indexes in local equation
- TArrayD fDerivLocEq; // Table of local equation derivatives wrt. parameter
- TArrayI fIndexAllEqs; // Index in all loc. eq. storage for iterations
- TArrayD fDerivAllEqs; // derivative in all loc. eq. storage for iterations
- TArrayI fLocEqPlace; // Loc. Eq. position in AllEqs storage
+ TArrayI fIndexLocEq; ///< Table of parameter indexes in local equation
+ TArrayD fDerivLocEq; ///< Table of local equation derivatives wrt. parameter
+ TArrayI fIndexAllEqs; ///< Index in all loc. eq. storage for iterations
+ TArrayD fDerivAllEqs; ///< derivative in all loc. eq. storage for iterations
+ TArrayI fLocEqPlace; ///< Loc. Eq. position in AllEqs storage
- Int_t fNIndexLocEq; // Number of entries in fIndexLocEq
- Int_t fNDerivLocEq; // Number of entries in fDerivLocEq
- Int_t fNIndexAllEqs; // Number of entries in fIndexAllEqs
- Int_t fNDerivAllEqs; // Number of entries in fDerivAllEqs
- Int_t fNLocEqPlace; // Number of entries in fLocEqPlace
+ Int_t fNIndexLocEq; ///< Number of entries in fIndexLocEq
+ Int_t fNDerivLocEq; ///< Number of entries in fDerivLocEq
+ Int_t fNIndexAllEqs; ///< Number of entries in fIndexAllEqs
+ Int_t fNDerivAllEqs; ///< Number of entries in fDerivAllEqs
+ Int_t fNLocEqPlace; ///< Number of entries in fLocEqPlace
- int fNLocalEquations; // Number of local equations
- double fResCutInit; // Cut in residual for first iterartion
- double fResCut; // Cut in residual for other iterartiona
-
- double fChi2CutFactor; // Cut factor for chi2 cut to accept local fit
- double fChi2CutRef; // Reference cut for chi2 cut to accept local fit
-
- int fIter; // Current iteration
- int fMaxIter; // Maximum number of iterations
- int fNStdDev; // Number of standard deviations for chi2 cut
- int fNGlobalConstraints; // Number of constraint equations
- int fNLocalFits; // Number of local fits
- int fNLocalFitsRejected; // Number of local fits rejected
- int fNGlobalPar; // Number of global parameters
- int fNLocalPar; // Number of local parameters
+ int fNLocalEquations; ///< Number of local equations
+ double fResCutInit; ///< Cut in residual for first iterartion
+ double fResCut; ///< Cut in residual for other iterartiona
+
+ double fChi2CutFactor; ///< Cut factor for chi2 cut to accept local fit
+ double fChi2CutRef; ///< Reference cut for chi2 cut to accept local fit
+
+ int fIter; ///< Current iteration
+ int fMaxIter; ///< Maximum number of iterations
+ int fNStdDev; ///< Number of standard deviations for chi2 cut
+ int fNGlobalConstraints; ///< Number of constraint equations
+ int fNLocalFits; ///< Number of local fits
+ int fNLocalFitsRejected; ///< Number of local fits rejected
+ int fNGlobalPar; ///< Number of global parameters
+ int fNLocalPar; ///< Number of local parameters
ClassDef(AliMillepede, 0) // Millepede Class
};
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff