class AliITSMultReconstructor: public AliTrackleter
Implementation of the ITS-SPD trackleter class
It retrieves clusters in the pixels (theta and phi) and finds tracklets.
These can be used to extract charged particle multiplicity from the ITS.
A tracklet consists of two ITS clusters, one in the first pixel layer and
one in the second. The clusters are associated if the differences in
Phi (azimuth) and Theta (polar angle) are within fiducial windows.
In case of multiple candidates the candidate with minimum
distance is selected.
Two methods return the number of tracklets and the number of unassociated
clusters (i.e. not used in any tracklet) in the first SPD layer
(GetNTracklets and GetNSingleClusters)
The cuts on phi and theta depend on the interacting system (p-p or Pb-Pb)
and can be set via AliITSRecoParam class
(SetPhiWindow and SetThetaWindow)
Origin: Tiziano Virgili
Current support and development:
Domenico Elia, Maria Nicassio (INFN Bari)
Domenico.Elia@ba.infn.it, Maria.Nicassio@ba.infn.it
Most recent updates:
- multiple association forbidden (fOnlyOneTrackletPerC2 = kTRUE)
- phi definition changed to ALICE convention (0,2*TMath::pi())
- cluster coordinates taken with GetGlobalXYZ()
- fGeometry removed
- number of fired chips on the two layers
- option to cut duplicates in the overlaps
- options and fiducial cuts via AliITSRecoParam
- move from DeltaZeta to DeltaTheta cut
- update to the new algorithm by Mariella and Jan Fiete
- store also DeltaTheta in the ESD
- less new and delete calls when creating the needed arrays
- RS: to decrease the number of new/deletes the clusters data are stored
not in float[6] attached to float**, but in 1-D array.
- RS: Clusters are sorted in Z in roder to have the same numbering as in the ITS reco
- RS: Clusters used by ESDtrack are flagged, this information is passed to AliMulitiplicity object
when storing the tracklets and single cluster info
- MN: first MC label of single clusters stored
Function Members (Methods)
public:
protected:
| AliITSMultReconstructor(const AliITSMultReconstructor& mr) | |
| void | CalcThetaPhi(float x, float y, float z, float& theta, float& phi) const |
| virtual void | TObject::DoError(int level, const char* location, const char* fmt, va_list va) const |
| void | LoadClusterArrays(TTree* tree, TTree* treeMix = 0) |
| void | LoadClusterArrays(TTree* tree, int il) |
| void | TObject::MakeZombie() |
| AliITSMultReconstructor& | operator=(const AliITSMultReconstructor& mr) |
| void | SetClustersLoaded(Bool_t v = kTRUE) |
Data Members
public:
| enum { | kClTh | |
| kClPh | ||
| kClZ | ||
| kClMC0 | ||
| kClMC1 | ||
| kClMC2 | ||
| kClNPar | ||
| kTrTheta | ||
| kTrPhi | ||
| kTrDPhi | ||
| kTrDTheta | ||
| kTrLab1 | ||
| kTrLab2 | ||
| kClID1 | ||
| kClID2 | ||
| kTrNPar | ||
| kSCTh | ||
| kSCPh | ||
| kSCLab | ||
| kSCID | ||
| kSCNPar | ||
| kITSTPC | ||
| kITSSAP | ||
| kITSTPCBit | ||
| kITSSAPBit | ||
| }; | ||
| enum TObject::EStatusBits { | kCanDelete | |
| kMustCleanup | ||
| kObjInCanvas | ||
| kIsReferenced | ||
| kHasUUID | ||
| kCannotPick | ||
| kNoContextMenu | ||
| kInvalidObject | ||
| }; | ||
| enum TObject::[unnamed] { | kIsOnHeap | |
| kNotDeleted | ||
| kZombie | ||
| kBitMask | ||
| kSingleKey | ||
| kOverwrite | ||
| kWriteDelete | ||
| }; |
protected:
| Int_t* | fAssociatedLay1 | ! association flag |
| AliRefArray* | fBlackList | ! blacklisted cluster references |
| Bool_t | fBuildRefs | build cluster to tracks references |
| TClonesArray* | fClArr[2] | ! original clusters |
| Int_t* | fClusterCopyIndex[2] | ! when clusters copy is requested, store here the reference on the index |
| Float_t* | fClustersLay[2] | ! clusters in the SPD layers of ITS |
| Bool_t | fClustersLoaded | flag of clusters loaded |
| Bool_t | fCreateClustersCopy | read and clone clusters directly from the tree |
| Float_t | fCutChi2cGamma | max constrained chi2 cut for gammas |
| Float_t | fCutChi2cK0 | max constrained chi2 cut for K0s |
| Float_t | fCutDCArz | max DR or DZ for primares |
| Float_t | fCutGammaSFromDecay | min path*P for gammas |
| Float_t | fCutK0SFromDecay | min path*P for K0s |
| Float_t | fCutMassGamma | max gamma mass |
| Float_t | fCutMassGammaNSigma | max standard deviations from 0 for gamma |
| Float_t | fCutMassK0 | max K0 mass difference from PGD value |
| Float_t | fCutMassK0NSigma | max standard deviations for K0 mass from PDG value |
| Float_t | fCutMaxDCA | max DCA for V0 at ESD vertex |
| Float_t | fCutMaxDCADauther | max DCA of daughters at V0 |
| Float_t | fCutMinElectronProbESD | min probability for e+/e- PID not involving TPC |
| Float_t | fCutMinElectronProbTPC | min probability for e+/e- PID involving TPC |
| Float_t | fCutMinP | min P of V0 |
| Float_t | fCutMinPointAngle | min pointing angle cosine |
| Float_t | fCutMinRGamma | min transv. distance from ESDVertex to V0 for gammas |
| Float_t | fCutMinRK0 | min transv. distance from ESDVertex to V0 for K0s |
| Float_t | fCutPxDrSPDin | max P*DR for primaries involving at least 1 SPD |
| Float_t | fCutPxDrSPDout | max P*DR for primaries not involving any SPD |
| Float_t | fCutPxDz | max P*DZ for primaries |
| Double_t | fDPhiShift | shift in dphi due to the curvature |
| Float_t | fDPhiWindow | Search window in phi |
| Double_t | fDPhiWindow2 | phi window^2 |
| Float_t | fDThetaWindow | Search window in theta |
| Double_t | fDThetaWindow2 | theta window^2 |
| AliITSDetTypeRec* | fDetTypeRec | ! pointer to DetTypeRec |
| Int_t* | fDetectorIndexClustersLay[2] | ! module index for clusters in ITS layers |
| AliESDEvent* | fESDEvent | ! pointer to ESD event |
| Bool_t | fHistOn | Option to define and fill the histograms |
| Float_t* | fMinDists | ! smallest distances for L2->L1 |
| AliMultiplicity* | AliTrackleter::fMult | multiplicity object |
| Int_t | fNClustersLay[2] | Number of clusters on each layer |
| Short_t | fNFiredChips[2] | Number of fired chips in the two SPD layers |
| Int_t | fNSingleCluster | Number of unassociated clusters |
| Int_t | fNSingleClusterSPD2 | Number of unassociated clusters on 2nd lr |
| Float_t | fNStdDev | number of standard deviations to keep |
| Float_t | fNStdDevSq | sqrt of number of standard deviations to keep |
| Int_t | fNTracklets | Number of tracklets |
| Bool_t* | fOverlapFlagClustersLay[2] | ! flag for clusters in the overlap regions in ITS layers |
| Int_t* | fPartners | ! L2 partners of L1 |
| Float_t | fPhiOverlapCut | Fiducial window in phi for overlap cut |
| Float_t | fPhiRotationAngle | Angle to rotate the inner layer cluster for combinatorial reco only |
| Float_t | fPhiShift | Phi shift reference value (at 0.5 T) |
| Bool_t | fRecoDone | flag that reconstruction is done |
| Bool_t | fRemoveClustersFromOverlaps | Option to skip clusters in the overlaps |
| Float_t** | fSClusters | ! single clusters (unassociated) |
| AliITSsegmentationSPD | fSPDSeg | SPD segmentation model |
| Bool_t | fScaleDTBySin2T | use in distance definition |
| Bool_t | fStoreRefs[2][2] | ! which cluster to track refs to store |
| Bool_t | fStoreSPD2SingleCl | do we store SPD2 singles |
| Float_t** | fTracklets | ! tracklets |
| TTree* | fTreeRP | ! ITS recpoints |
| TTree* | fTreeRPMix | ! ITS recpoints for mixing |
| AliRefArray* | fUsedClusLay[2][2] | ! RS: clusters usage in ESD tracks |
| Float_t | fZetaOverlapCut | Fiducial window in eta for overlap cut |
| TH1F* | fhClustersDPhiAcc | Phi2 - Phi1 for tracklets |
| TH1F* | fhClustersDPhiAll | Phi2 - Phi1 all the combinations |
| TH1F* | fhClustersDThetaAcc | Theta2 - Theta1 for tracklets |
| TH1F* | fhClustersDThetaAll | Theta2 - Theta1 all the combinations |
| TH2F* | fhDPhiVsDThetaAcc | same plot for tracklets |
| TH2F* | fhDPhiVsDThetaAll | 2D plot for all the combinations |
| TH1F* | fhetaClustersLay1 | Pseudorapidity distr. for Clusters L. 1 |
| TH1F* | fhetaTracklets | Pseudorapidity distr. for tracklets |
| TH1F* | fhphiClustersLay1 | Azimuthal (Phi) distr. for Clusters L. 1 |
| TH1F* | fhphiTracklets | Azimuthal (Phi) distr. for tracklets |
Class Charts
| Inheritance Chart: | ||||||||||||
|
Function documentation
AliITSMultReconstructor(const AliITSMultReconstructor& mr)
Copy constructor :!!! RS ATTENTION: old c-tor reassigned the pointers instead of creating a new copy -> would crash on delete
void Reconstruct(AliESDEvent* esd, TTree* treeRP)
void Reconstruct(TTree* tree, Float_t* vtx, Float_t* vtxRes = 0)
RS NOTE - this is old reconstructor invocation, to be used from VertexFinder and in analysis mode
void ReconstructMix(TTree* clusterTree, TTree* clusterTreeMix, const Float_t* vtx, Float_t* vtrRes = 0)
RS NOTE - this is old reconstructor invocation, to be used from VertexFinder and in analysis mode
void FindTracklets(const Float_t* vtx)
- calls LoadClusterArrays that finds the position of the clusters (in global coord)
void LoadClusterArrays(TTree* tree, TTree* treeMix = 0)
load cluster info and prepare tracklets arrays
void LoadClusterArrays(TTree* tree, int il)
This method - gets the clusters from the cluster tree for layer il - convert them into global coordinates - store them in the internal arrays - count the number of cluster-fired chips RS: This method was strongly modified wrt original. In order to have the same numbering of clusters as in the ITS reco I had to introduce sorting in Z Also note that now the clusters data are stored not in float[6] attached to float**, but in 1-D array
void LoadClusterFiredChips(TTree* tree)
This method - gets the clusters from the cluster tree - counts the number of (cluster)fired chips
Int_t AssociateClusterOfL1(Int_t iC1)
search association of cluster iC1 of L1 with all clusters of L2
void ProcessESDTracks()
Flag the clusters used by ESD tracks Flag primary tracks to be used for multiplicity counting
void FlagTrackClusters(Int_t id)
RS: flag the SPD clusters of the track if it is useful for the multiplicity estimation
void FlagIfSecondary(AliESDtrack* track, const AliVertex* vtx)
RS: check if the track is primary and set the flag
AliITSRecPoint* GetRecPoint(Int_t lr, Int_t n) const
return a cluster of lr corresponding to orderer cluster index n
void SetPhiWindow(Float_t w = 0.08)
Following members are set via AliITSRecoParam
{fDPhiWindow=w; fDPhiWindow2 = w*w;}Int_t GetNSingleClustersLr(int lr) const
{return lr==0 ? fNSingleCluster-fNSingleClusterSPD2:(GetStoreSPD2SingleCl() ? fNSingleClusterSPD2 : -1) ;}Int_t GetClusterCopyIndex(Int_t lr, Int_t n) const
{return fClusterCopyIndex[lr] ? fClusterCopyIndex[lr][n] : -1;}void SetCreateClustersCopy(Bool_t v = kTRUE)
Float_t* GetClustersArray(Int_t lr) const {return (Float_t*) (lr==0) ? fClustersLay[0]:fClustersLay[1];}
{fCreateClustersCopy=v;}Float_t* GetClustersArray(Int_t lr) const