Merge branch 'master' into TPCdev

[u/mrichter/AliRoot.git] / ITS / AliITSMultReconstructor.h

diff --git a/ITS/AliITSMultReconstructor.h b/ITS/AliITSMultReconstructor.h
index b153c47d9c6629a80ec17072eb336bf1b3ef573f..f0cf25ccd7dbae1dcb075daca5dae599730ae68e 100644 (file)
--- a/ITS/AliITSMultReconstructor.h
+++ b/ITS/AliITSMultReconstructor.h
@@ -32,6 +32,7 @@ class AliVertex;
 class AliESDVertex;
 class AliMultiplicity;
 class AliRefArray;
+class AliITSRecPoint;
 
 class AliITSMultReconstructor : public AliTrackleter
 {
@@ -46,7 +47,7 @@ public:
 
   void Reconstruct(AliESDEvent* esd, TTree* treeRP);
   void Reconstruct(TTree* tree, Float_t* vtx, Float_t* vtxRes=0);   // old reconstructor invocation
-  void ReconstructMix(TTree* clusterTree, TTree* clusterTreeMix, Float_t* vtx, Float_t* vtrRes=0);
+  void ReconstructMix(TTree* clusterTree, TTree* clusterTreeMix, const Float_t* vtx, Float_t* vtrRes=0);
   void FindTracklets(const Float_t* vtx); 
   void LoadClusterFiredChips(TTree* tree);
   void FlagClustersInOverlapRegions(Int_t ic1,Int_t ic2);
@@ -72,14 +73,17 @@ public:
   Int_t GetNClustersLayer(Int_t i) const {return fNClustersLay[i];}
   Int_t GetNTracklets() const {return fNTracklets;}
   Int_t GetNSingleClusters() const {return fNSingleCluster;}
+  Int_t GetNSingleClustersLr(int lr) const {return lr==0 ? fNSingleCluster-fNSingleClusterSPD2:(GetStoreSPD2SingleCl() ? fNSingleClusterSPD2 : -1) ;}
   Short_t GetNFiredChips(Int_t layer) const {return fNFiredChips[layer];}
 
-  Float_t* GetClusterLayer1(Int_t n) {return &fClustersLay[0][n*kClNPar];}
-  Float_t* GetClusterLayer2(Int_t n) {return &fClustersLay[1][n*kClNPar];}
-  Float_t* GetClusterOfLayer(Int_t lr,Int_t n) {return &fClustersLay[lr][n*kClNPar];}
+  Float_t* GetClusterLayer1(Int_t n) const {return &fClustersLay[0][n*kClNPar];}
+  Float_t* GetClusterLayer2(Int_t n) const {return &fClustersLay[1][n*kClNPar];}
+  Float_t* GetClusterOfLayer(Int_t lr,Int_t n) const {return &fClustersLay[lr][n*kClNPar];}
+  Int_t    GetClusterCopyIndex(Int_t lr,Int_t n) const {return fClusterCopyIndex[lr] ? fClusterCopyIndex[lr][n] : -1;}
+  AliITSRecPoint* GetRecPoint(Int_t lr, Int_t n) const;
   
-  Float_t* GetTracklet(Int_t n) {return fTracklets[n];}
-  Float_t* GetCluster(Int_t n) {return fSClusters[n];}
+  Float_t* GetTracklet(Int_t n) const {return fTracklets[n];}
+  Float_t* GetCluster(Int_t n) const {return fSClusters[n];}
 
   void     SetScaleDThetaBySin2T(Bool_t v=kTRUE)         {fScaleDTBySin2T = v;}
   Bool_t   GetScaleDThetaBySin2T()               const   {return fScaleDTBySin2T;}
@@ -89,7 +93,13 @@ public:
   //
   void SetHistOn(Bool_t b=kFALSE) {fHistOn=b;}
   void SaveHists();
-
+  //
+  void   SetBuildRefs(Bool_t v=kTRUE)                    {fBuildRefs = v;}
+  Bool_t GetBuildRefs()                          const   {return fBuildRefs;}
+  //
+  void   SetStoreSPD2SingleCl(Bool_t v)                  {fStoreSPD2SingleCl = v;}
+  Bool_t GetStoreSPD2SingleCl()                  const   {return fStoreSPD2SingleCl;}
+  //
   AliITSDetTypeRec *GetDetTypeRec() const {return fDetTypeRec;}
   void SetDetTypeRec(AliITSDetTypeRec *ptr){fDetTypeRec = ptr;}
   //
@@ -137,7 +147,7 @@ public:
   //
   void  InitAux();
   void  ClusterPos2Angles(const Float_t *vtx);
-  void  ClusterPos2Angles(Float_t *clPar, const Float_t *vtx);
+  void  ClusterPos2Angles(Float_t *clPar, const Float_t *vtx) const;
   Int_t AssociateClusterOfL1(Int_t iC1);
   Int_t StoreTrackletForL2Cluster(Int_t iC2);
   void  StoreL1Singles();
@@ -150,7 +160,9 @@ public:
   Bool_t IsRecoDone()                          const {return fRecoDone;}
   void  SetCreateClustersCopy(Bool_t v=kTRUE)        {fCreateClustersCopy=v;}
   //
-  Float_t* GetClustersArray(Int_t lr)          const {return (Float_t*) (lr==0) ? fClustersLay[0]:fClustersLay[1];}
+  //  Float_t* GetClustersArray(Int_t lr)          const {return (Float_t*) (lr==0) ? fClustersLay[0]:fClustersLay[1];}
+  Float_t* GetClustersArray(Int_t lr)          const {if(lr==0){return fClustersLay[0];} 
+                                                      else {return fClustersLay[1];}}
   Int_t*   GetPartnersOfL2()                   const {return (Int_t*)fPartners;}
   Float_t* GetMinDistsOfL2()                   const {return (Float_t*)fMinDists;}
   Double_t GetDPhiShift()                      const {return fDPhiShift;}
@@ -171,6 +183,7 @@ public:
   //
   Float_t*      fClustersLay[2];            //! clusters in the SPD layers of ITS 
   Int_t*        fDetectorIndexClustersLay[2];  //! module index for clusters in ITS layers
+  Int_t*        fClusterCopyIndex[2];         //! when clusters copy is requested, store here the reference on the index
   Bool_t*       fOverlapFlagClustersLay[2];  //! flag for clusters in the overlap regions in ITS layers
 
   Float_t**     fTracklets;            //! tracklets 
@@ -179,6 +192,7 @@ public:
   Int_t         fNClustersLay[2];      // Number of clusters on each layer
   Int_t         fNTracklets;           // Number of tracklets
   Int_t         fNSingleCluster;       // Number of unassociated clusters
+  Int_t         fNSingleClusterSPD2;   // Number of unassociated clusters on 2nd lr
   Short_t       fNFiredChips[2];       // Number of fired chips in the two SPD layers
   //
   // Following members are set via AliITSRecoParam
@@ -250,17 +264,19 @@ public:
   Bool_t        fCreateClustersCopy;   //  read and clone clusters directly from the tree
   Bool_t        fClustersLoaded;       // flag of clusters loaded
   Bool_t        fRecoDone;             // flag that reconstruction is done
+  Bool_t        fBuildRefs;            // build cluster to tracks references
+  Bool_t        fStoreSPD2SingleCl;    // do we store SPD2 singles
   //
   AliITSsegmentationSPD fSPDSeg;       // SPD segmentation model
   //
   void LoadClusterArrays(TTree* tree, TTree* treeMix=0);
   void LoadClusterArrays(TTree* tree,int il);
 
-  ClassDef(AliITSMultReconstructor,10)
+  ClassDef(AliITSMultReconstructor,11)
 };
 
 //____________________________________________________________________
-inline void AliITSMultReconstructor::ClusterPos2Angles(Float_t *clPar, const Float_t *vtx)
+inline void AliITSMultReconstructor::ClusterPos2Angles(Float_t *clPar, const Float_t *vtx) const
 {
   // convert cluster coordinates to angles wrt vertex
   Float_t x = clPar[kClTh] - vtx[0];