Added global tracker and seed prototype classes.
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Nov 2012 03:00:00 +0000 (03:00 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Nov 2012 03:00:00 +0000 (03:00 +0000)
18 files changed:
ITS/UPGRADE/AliITSUAux.h
ITS/UPGRADE/AliITSUClusterPix.h
ITS/UPGRADE/AliITSURecoDet.cxx
ITS/UPGRADE/AliITSURecoDet.h
ITS/UPGRADE/AliITSURecoLayer.cxx
ITS/UPGRADE/AliITSURecoLayer.h
ITS/UPGRADE/AliITSURecoParam.cxx
ITS/UPGRADE/AliITSURecoParam.h
ITS/UPGRADE/AliITSURecoSens.cxx
ITS/UPGRADE/AliITSURecoSens.h
ITS/UPGRADE/AliITSUSeed.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUSeed.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUTrackerGlo.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUTrackerGlo.h [new file with mode: 0644]
ITS/UPGRADE/CMakelibITSUpgradeRec.pkg
ITS/UPGRADE/ITSUpgradeRecLinkDef.h
ITS/UPGRADE/testITSU/Config.C
ITS/UPGRADE/testITSU/rec.C

index 79483cd..cec6231 100644 (file)
@@ -21,6 +21,9 @@ namespace AliITSUAux {
   void   BringTo02Pi(double &phi);
   Bool_t OKforPhiMin(double phiMin,double phi);
   Bool_t OKforPhiMax(double phiMax,double phi);
+  //
+  const Double_t kNominalBz = 5.01;           // nominal field
+  const Double_t kPionMass = 1.3957e-01;
 }
 
 //_________________________________________________________________________________
index aeccc8e..085a54f 100644 (file)
@@ -66,9 +66,9 @@ class AliITSUClusterPix : public AliCluster
   //
  protected:
   //
-  UShort_t                fNxNz;          // effective cluster size in X (1st byte) and Z (2nd byte) directions
-  static UInt_t           fgMode;         // general mode (sorting mode etc)
-  static AliITSUGeomTGeo* fgGeom;         // pointer on the geometry data
+  UShort_t                fNxNz;          //  effective cluster size in X (1st byte) and Z (2nd byte) directions
+  static UInt_t           fgMode;         //! general mode (sorting mode etc)
+  static AliITSUGeomTGeo* fgGeom;         //! pointer on the geometry data
 
   ClassDef(AliITSUClusterPix,1)
 };
index c02a0c2..ef2c106 100644 (file)
@@ -6,19 +6,20 @@
 ClassImp(AliITSURecoDet)
 
 //______________________________________________________
-AliITSURecoDet::AliITSURecoDet(const char* name)
+AliITSURecoDet::AliITSURecoDet(AliITSUGeomTGeo* geom, const char* name)
 :  fNLayers(0)
   ,fNLayersActive(0)
   ,fRMax(-1)
   ,fRMin(-1)
   ,fLayers(0)
   ,fLayersActive(0)
-  ,fITSGeom(0)
+  ,fGeom(geom)
 {
   // def. c-tor
   SetNameTitle(name,name);
   fLayers.SetOwner(kTRUE);        // layers belong to this array
   fLayersActive.SetOwner(kFALSE); // this one just points on active layers in fLayers
+  Build();
 }
 
 //______________________________________________________
@@ -27,7 +28,6 @@ AliITSURecoDet::~AliITSURecoDet()
   // def. d-tor
   fLayersActive.Clear(); 
   fLayers.Clear();         // owned!
-  delete fITSGeom;
 }
 
 //______________________________________________________
@@ -56,21 +56,19 @@ Bool_t AliITSURecoDet::Build()
 {
   // build detector from TGeo
   //
-  fITSGeom = new AliITSUGeomTGeo(kTRUE,kTRUE);
-  int nlr = fITSGeom->GetNLayers();
+  if (!fGeom) AliFatal("Geometry interface is not set");
+  int nlr = fGeom->GetNLayers();
   if (!nlr) AliFatal("No geometry loaded");
   //
   // build active ITS layers
   for (int ilr=0;ilr<nlr;ilr++) {
-    int lrTyp = fITSGeom->GetLayerDetTypeID(ilr);
-    int nLad = fITSGeom->GetNLadders(ilr);
-    int nDet = fITSGeom->GetNDetectors(ilr);
+    int lrTyp = fGeom->GetLayerDetTypeID(ilr);
     // name layer according its active id, detector type and segmentation tyoe
-    AliITSURecoLayer* lra = new AliITSURecoLayer( Form("Lr%d%s%d",ilr,fITSGeom->GetDetTypeName(lrTyp),
-                                                      lrTyp%AliITSUGeomTGeo::kMaxSegmPerDetType),
-                                                 ilr,nLad*nDet,fITSGeom);
-    lra->Build();
+    AliITSURecoLayer* lra = new AliITSURecoLayer(Form("Lr%d%s%d",ilr,fGeom->GetDetTypeName(lrTyp),
+                                                     lrTyp%AliITSUGeomTGeo::kMaxSegmPerDetType),
+                                                ilr,fGeom);
     AddLayer(lra);
   }
   return kTRUE;
 }
+
index 79d3ad0..edb63bc 100644 (file)
@@ -18,7 +18,7 @@ class AliITSURecoDet : public TNamed
 {
  public:
   //
-  AliITSURecoDet(const char* name="");
+  AliITSURecoDet(AliITSUGeomTGeo* geom, const char* name="");
   virtual ~AliITSURecoDet();
   //
   Double_t           GetRMin()                     const {return fRMin;}
@@ -28,16 +28,20 @@ class AliITSURecoDet : public TNamed
   Int_t              GetLrIDActive(Int_t lrActID)  const;
   AliITSURecoLayer*  GetLayer(Int_t i)             const;
   AliITSURecoLayer*  GetLayerActive(Int_t i)       const;
-  AliITSUGeomTGeo*   GetGeom()                     const {return fITSGeom;}
+  AliITSUGeomTGeo*   GetGeom()                     const {return fGeom;}
   //
   void               SetRMin(Double_t r)                 {fRMin = r;}
   void               SetRMax(Double_t r)                 {fRMax = r;}
   //
   void               AddLayer(const AliITSURecoLayer* lr);
-  Bool_t             Build();
+  //
+  void               ProcessClusters(Int_t mode=0);
   //
   virtual void       Print(Option_t* option = "")  const;
   //
+ protected:
+  Bool_t             Build();
+  //
  protected:
   Int_t              fNLayers;        // total number of layers
   Int_t              fNLayersActive;  // N of active layers
@@ -45,7 +49,7 @@ class AliITSURecoDet : public TNamed
   Double_t           fRMin;           // min  R
   TObjArray          fLayers;         // layers
   TObjArray          fLayersActive;   // active layers
-  AliITSUGeomTGeo*   fITSGeom;        // ITS geometry
+  AliITSUGeomTGeo*   fGeom;           // ITS geometry
   //
  private:
   AliITSURecoDet(const AliITSURecoDet &source); 
@@ -77,5 +81,11 @@ inline AliITSURecoLayer* AliITSURecoDet::GetLayerActive(Int_t i) const
   return i<fNLayersActive ? (AliITSURecoLayer*)fLayersActive.UncheckedAt(i):0;
 }
 
+//______________________________________________________
+inline void AliITSURecoDet::ProcessClusters(Int_t mode)
+{
+  // prepare clsuters for reconstrunction
+  for (int ilr=fNLayersActive;ilr--;) GetLayerActive(ilr)->ProcessClusters(mode);
+}
 
 #endif
index 5fd3134..7d33104 100644 (file)
@@ -1,8 +1,9 @@
+#include <TClonesArray.h>
 #include "AliITSURecoLayer.h"
 #include "AliITSUGeomTGeo.h"
 #include "AliITSsegmentation.h"
-#include "AliITSURecoSens.h"
 #include "AliITSUAux.h"
+#include "AliITSUClusterPix.h"
 
 using namespace AliITSUAux;
 using namespace TMath;
@@ -26,16 +27,17 @@ AliITSURecoLayer::AliITSURecoLayer(const char* name)
   ,fPhiOffs(0)
   ,fSensDZInv(0)
   ,fDPhiLadInv(0)
+  ,fMaxStep(0.5)
   ,fSensors(0)
   ,fITSGeom(0)
+  ,fClusters(0)
 {
   // def. c-tor
   SetNameTitle(name,name);
-  fSensors.SetOwner(kTRUE);
 }
 
 //______________________________________________________
-AliITSURecoLayer::AliITSURecoLayer(const char* name,Int_t activeID,Int_t nsens, AliITSUGeomTGeo* gm)
+AliITSURecoLayer::AliITSURecoLayer(const char* name, Int_t activeID, AliITSUGeomTGeo* gm)
   :fActiveID(activeID)
   ,fNSensors(0)
   ,fNSensInLadder(0)
@@ -50,18 +52,23 @@ AliITSURecoLayer::AliITSURecoLayer(const char* name,Int_t activeID,Int_t nsens,
   ,fPhiOffs(0)
   ,fSensDZInv(0)
   ,fDPhiLadInv(0)
-  ,fSensors(nsens)
+  ,fMaxStep(0.5)
+  ,fSensors(0)
   ,fITSGeom(gm)
+  ,fClusters(0)
 {
   // def. c-tor
   SetNameTitle(name,name);
-  fSensors.SetOwner(kTRUE);
+  Build();
 }
 
 //______________________________________________________
 AliITSURecoLayer::~AliITSURecoLayer()
 {
   // def. d-tor
+  delete[] fSensors;
+  delete[] fPhiLadMax;
+  delete[] fPhiLadMin;
 }
 
 //______________________________________________________
@@ -74,11 +81,14 @@ void AliITSURecoLayer::Print(Option_t* opt) const
 }
 
 //______________________________________________________
-Bool_t AliITSURecoLayer::Build()
+void AliITSURecoLayer::Build()
 {
   // build internal structures
+  if (fActiveID<0) return;
   fNLadders = fITSGeom->GetNLadders(fActiveID);
   fNSensInLadder = fITSGeom->GetNDetectors(fActiveID);
+  fNSensors = fNLadders*fNSensInLadder;
+  fSensors = new AliITSURecoSens*[fNSensors];
   const AliITSsegmentation* kSegm = fITSGeom->GetSegmentation(fActiveID);
   //
   // name layer according its active id, detector type and segmentation tyoe
@@ -98,7 +108,7 @@ Bool_t AliITSURecoLayer::Build()
     //
     for (int idt=0;idt<fNSensInLadder;idt++) {
       AliITSURecoSens* sens = new AliITSURecoSens(fNSensors++);
-      fSensors.AddLast(sens);
+      fSensors[idt] = sens;
       //
       double phiMin=1e9,phiMax=-1e9,zMin=1e9,zMax=-1e9;
       mmod = *fITSGeom->GetMatrix(fActiveID,ild,idt);
@@ -176,12 +186,13 @@ Bool_t AliITSURecoLayer::Build()
          int neighbID = ildN*fNSensInLadder+idtN;
          //      
          int zType = 1;  // side
-         if (sens->GetZMin()-zTol>sensN->GetZMax()) continue; // too large distance
-         if (sensN->GetZMin()-zTol>sens->GetZMax()) continue; // too large distance
+         if (sens->GetZMin()-zTol  > sensN->GetZMax()) continue; // too large distance
+         if (sensN->GetZMin()-zTol > sens->GetZMax() ) continue; // too large distance
          if      (sens->GetZMin()-zTol>sensN->GetZMin()) zType =  0;     // bottom
          else if (sensN->GetZMin()-zTol>sens->GetZMin()) zType =  2;     // top
          //
          int phiType = 1;
+
          double phiTstMn = sensN->GetPhiMin()-phiTol;
          BringTo02Pi(phiTstMn);
          if (!OKforPhiMax(sens->GetPhiMax(),phiTstMn)) continue; // too large angle      
@@ -203,19 +214,10 @@ Bool_t AliITSURecoLayer::Build()
   } // ladders
   //
   //
-  return kTRUE;
-}
-
-//______________________________________________________
-void AliITSURecoLayer::AddSensor(const AliITSURecoSens* mod)
-{
-  //add new module
-  fSensors.AddLast((TObject*)mod);
-  fNSensors++;
 }
 
 //______________________________________________________
-Int_t AliITSURecoLayer::FindSensors(const double* impPar, AliITSURecoSens **sensors)
+Int_t AliITSURecoLayer::FindSensors(const double* impPar, AliITSURecoSens *sensors[AliITSURecoSens::kNNeighbors])
 {
   // find sensors having intersection with track
   // impPar contains: lab phi of track, dphi, labZ, dz
@@ -264,3 +266,27 @@ Int_t AliITSURecoLayer::FindSensors(const double* impPar, AliITSURecoSens **sens
   return nsens;
 }
 
+//______________________________________________________
+void AliITSURecoLayer::ProcessClusters(Int_t mode)
+{
+  // register in each sensor of the layer its cluster.
+  // the clusters of the layer must be sorted per sensor
+  int ncl = fClusters->GetEntriesFast();
+  int curSensID = -1;
+  AliITSURecoSens* curSens = 0;
+  for (int icl=0;icl<ncl;icl++) {
+    AliITSUClusterPix* cl = (AliITSUClusterPix*) fClusters->UncheckedAt(icl);
+    cl->GoToFrameTrk();
+    int vID = cl->GetVolumeId();
+    if (vID<curSensID) {AliFatal("Clusters are not sorted in increasing sensorID");}
+    if (vID>curSensID) {
+      if (curSens) curSens->ProcessClusters(mode);    // prepare clusters for reconstruction
+      curSens   = GetSensor(vID - fITSGeom->GetFirstModIndex(fActiveID));
+      curSensID = vID;
+      curSens->SetFirstClusterId(icl);
+    }
+    curSens->IncNClusters();
+  }
+  if (curSens) curSens->ProcessClusters(mode); // last sensor was not processed yet
+  //
+}
index ccf2264..86dab15 100644 (file)
@@ -3,9 +3,11 @@
 
 #include <TNamed.h>
 #include <TObjArray.h>
+#include "AliITSURecoSens.h"
+class TClonesArray;
 class AliITSUGeomTGeo;
 class AliITSsegmentation;
-class AliITSURecoSens;
+
 
 ///////////////////////////////////////////////////////////////////////
 //                                                                   //
@@ -21,17 +23,19 @@ class AliITSURecoLayer : public TNamed
   //
   enum {kPassive=BIT(14)};
   AliITSURecoLayer(const char* name);
-  AliITSURecoLayer(const char* name, Int_t activeID,Int_t nsens,AliITSUGeomTGeo* gm);
+  AliITSURecoLayer(const char* name, Int_t activeID,AliITSUGeomTGeo* gm);
   virtual ~AliITSURecoLayer();
   //
-  Bool_t             Build();
+  void               ProcessClusters(Int_t mode=0);
   //
   Int_t              GetID()                       const {return (int)GetUniqueID();}
   Int_t              GetActiveID()                 const {return fActiveID;}
   Int_t              GetNSensors()                 const {return fNSensors;}
   Double_t           GetRMin()                     const {return fRMin;}
   Double_t           GetRMax()                     const {return fRMax;}
+  Double_t           GetDR()                       const {return fRMax-fRMin;}
   Double_t           GetR()                        const {return fR;}
+  Double_t           GetMaxStep()                  const {return fMaxStep;}
   Bool_t             IsActive()                    const {return !TestBit(kPassive);}
   Bool_t             IsPassive()                   const {return TestBit(kPassive);}
   //
@@ -41,16 +45,20 @@ class AliITSURecoLayer : public TNamed
   void               SetRMax(Double_t r)                 {fRMax = r;}
   void               SetR(Double_t r)                    {fR = r;}
   void               SetPassive(Bool_t v=kTRUE)          {SetBit(kPassive,v);}
-
+  void               SetMaxStep(Double_t st)             {fMaxStep = st>0 ? st : 0.1;}
   //
-  AliITSURecoSens*   GetSensor(Int_t i)            const {return (AliITSURecoSens*)fSensors.UncheckedAt(i);}
+  AliITSURecoSens*   GetSensor(Int_t i)            const {return (AliITSURecoSens*)fSensors[i];}
   AliITSURecoSens*   GetSensor(Int_t ld,Int_t is)  const {return GetSensor(ld*fNSensInLadder+is);}
-  void               AddSensor(const AliITSURecoSens* mod); 
+  TClonesArray*      GetClusters()                 const {return (TClonesArray*)fClusters;}
+  void               SetClusters(TClonesArray* cl)       {fClusters = cl;}
   //
-  Int_t              FindSensors(const double* impPar, AliITSURecoSens **sensors);
+  Int_t              FindSensors(const double* impPar, AliITSURecoSens *sensors[AliITSURecoSens::kNNeighbors]);
   //
   virtual void       Print(Option_t* option = "")  const;
-
+  //
+ protected:
+  void               Build();
+  //
  protected:
   Int_t              fActiveID;  // ID within active layers
   Int_t              fNSensors;  // N of modules
@@ -66,8 +74,10 @@ class AliITSURecoLayer : public TNamed
   Double_t           fPhiOffs;   // offset in phi for 1st ladder
   Double_t           fSensDZInv; // inverse mean sensor Z span
   Double_t           fDPhiLadInv;// inverse mean ladder dphi
-  TObjArray          fSensors;   // sensors
+  Double_t           fMaxStep;   // max step in tracking X allowed within layer
+  AliITSURecoSens**  fSensors;   // sensors
   AliITSUGeomTGeo*   fITSGeom;   // geometry interface
+  TClonesArray*      fClusters;  // clusters of the layer
   //
  private:
   AliITSURecoLayer(const AliITSURecoLayer &source); 
index de3ffda..e8d5965 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-
-
 ClassImp(AliITSURecoParam)
 
-
 //_____________________________________________________________________________
 AliITSURecoParam::AliITSURecoParam()
+:  fNLayers(0)
+  ,fTanLorentzAngle(0)
+{
+  // def c-tor
+  SetName("ITS");
+  SetTitle("ITS");
+}
+
+//_____________________________________________________________________________
+AliITSURecoParam::AliITSURecoParam(Int_t nLr)
+:  fNLayers(0)
+  ,fTanLorentzAngle(0)
 {
   // def c-tor
   SetName("ITS");
   SetTitle("ITS");
+  SetNLayers(nLr);
 }
 
 //_____________________________________________________________________________
 AliITSURecoParam::~AliITSURecoParam() 
 {
   // destructor
+  delete[] fTanLorentzAngle;
 }
 
 //_____________________________________________________________________________
@@ -70,3 +81,25 @@ AliITSURecoParam *AliITSURecoParam::GetCosmicTestParam()
   return param;
 }
 
+//_____________________________________________________________________________
+void  AliITSURecoParam::SetNLayers(Int_t n)
+{
+  // set n layers and init all layer dependent arrays
+  if (fNLayers>0) AliFatal(Form("Number of layers was already set to %d",fNLayers));
+  if (n<1) n = 1; // in case we want to have dummy params
+  fNLayers = n;
+  fTanLorentzAngle = new Double_t[n];
+  //
+  for (int i=n;i--;) {
+    fTanLorentzAngle[i] = 0;
+  }
+  //
+}
+
+//_____________________________________________________________________________
+void  AliITSURecoParam::SetTanLorentzAngle(Int_t lr, Double_t v)
+{
+  // set Lorentz angle value
+  if (lr>=fNLayers) AliFatal(Form("Number of defined layers is %d",fNLayers));
+  fTanLorentzAngle[lr] = v;
+}
index 164984f..e1e332a 100644 (file)
@@ -18,23 +18,37 @@ class AliITSURecoParam : public AliDetectorRecoParam
 {
  public: 
   AliITSURecoParam();
+  AliITSURecoParam(Int_t nLr);
   virtual ~AliITSURecoParam();
 
   static AliITSURecoParam *GetLowFluxParam();// make reco parameters for low flux env.
   static AliITSURecoParam *GetHighFluxParam();// make reco parameters for high flux env. 
   static AliITSURecoParam *GetCosmicTestParam();// special setting for cosmic  
 
- protected:
+  Double_t    GetTanLorentzAngle(Int_t lr)                 const;
   //
+  void        SetNLayers(Int_t n);
+  void        SetTanLorentzAngle(Int_t lr, Double_t v=0.);
 
- private:
 
+ protected:
+  Int_t          fNLayers;          // number of layers 
+  Double_t*      fTanLorentzAngle;  //[fNLayers] Optional Lorentz angle for each layer
+  //
+ private:
   AliITSURecoParam(const AliITSURecoParam & param);
   AliITSURecoParam & operator=(const AliITSURecoParam &param);
 
   ClassDef(AliITSURecoParam,1) // ITS reco parameters
 };
 
+//_____________________________________________________________________________
+inline Double_t AliITSURecoParam::GetTanLorentzAngle(Int_t lr) const 
+{
+  // get tg of Lorentz Angle for the layer
+  return lr<fNLayers ? fTanLorentzAngle[lr]:0;
+}
+
 #endif
 
 
index 8c18335..ec0e49c 100644 (file)
@@ -6,7 +6,9 @@ ClassImp(AliITSURecoSens)
 
 //______________________________________________________
 AliITSURecoSens::AliITSURecoSens(Int_t id)
-:  fXTF(0)
+:  fNClusters(0)
+  ,fFirstClusterId(-1)
+  ,fXTF(0)
   ,fPhiTF(0)
   ,fPhiMin(0)
   ,fPhiMax(0)
@@ -21,6 +23,8 @@ AliITSURecoSens::AliITSURecoSens(Int_t id)
 //______________________________________________________
 AliITSURecoSens::AliITSURecoSens(const AliITSURecoSens &source)
   :TObject(source)
+  ,fNClusters(source.fNClusters)
+  ,fFirstClusterId(source.fFirstClusterId)
   ,fXTF(source.fXTF)
   ,fPhiTF(source.fPhiTF)
   ,fPhiMin(source.fPhiMin)
@@ -38,6 +42,8 @@ AliITSURecoSens& AliITSURecoSens::operator=(const AliITSURecoSens &source)
   // = operator
   if (&source==this) return *this;
   TObject::operator=(source);
+  fNClusters = source.fNClusters;
+  fFirstClusterId = source.fFirstClusterId;
   fXTF = source.fXTF;
   fPhiTF = source.fPhiTF;
   fPhiMin = source.fPhiMin;
@@ -68,3 +74,18 @@ void AliITSURecoSens::Print(Option_t*) const
   for (int i=0;i<kNNeighbors;i++) printf(" %4d",fNeighbors[i]); printf("\n");
 }
 
+//______________________________________________________
+void AliITSURecoSens::ResetClusters()
+{
+  // discard old clusters
+  fNClusters = 0;
+  fFirstClusterId = -1;
+}
+
+//______________________________________________________
+void AliITSURecoSens::ProcessClusters(Int_t)
+{
+  // create structures for fast finding
+  //
+  // to do
+}
index f1995c9..56ed682 100644 (file)
@@ -31,16 +31,27 @@ class AliITSURecoSens : public TObject
   //
   Int_t              GetNeighborID(int i)          const {return fNeighbors[i];}
   //
+  Int_t              GetNClusters()                const {return fNClusters;}
+  Int_t              GetFirstClusterId()           const {return fFirstClusterId;}
+  //
   void               SetID(Int_t i)                      {SetUniqueID(i);}
   void               SetXTF(double v)                    {fXTF = v;}
   void               SetPhiTF(double v)                  {fPhiTF = v;}
   void               SetNeighborID(int i, int id)        {fNeighbors[i] = id;}
   void               SetBoundaries(double phiMn,double phiMx, double zMn, double zMx);
   //
+  void               SetNClusters(Int_t ncl)             {fNClusters = ncl;}
+  void               IncNClusters()                      {fNClusters++;}
+  void               SetFirstClusterId(Int_t id)         {fFirstClusterId = id;}
+  void               ResetClusters(); 
+  void               ProcessClusters(Int_t mode=0);
+  //
   virtual void       Print(Option_t* option = "")  const;
 
  protected:
   Int_t              fNeighbors[kNNeighbors];      // id of neighbors  
+  Int_t              fNClusters;                   // number of clusters
+  Int_t              fFirstClusterId;              // index of the 1st cluster in the layer's clusters array
   Double_t           fXTF;                         // X in tracking frame
   Double_t           fPhiTF;                       // phi of tracking frame
   Double_t           fPhiMin;                      // lab phi min
diff --git a/ITS/UPGRADE/AliITSUSeed.cxx b/ITS/UPGRADE/AliITSUSeed.cxx
new file mode 100644 (file)
index 0000000..62b608e
--- /dev/null
@@ -0,0 +1,38 @@
+#include <TMath.h>
+#include "AliITSUSeed.h"
+#include "AliITSUAux.h"
+using namespace AliITSUAux;
+using namespace TMath;
+
+ClassImp(AliITSUSeed)
+
+//_________________________________________________________________________
+AliITSUSeed::AliITSUSeed() 
+: fMass(kPionMass)
+{
+  // def c-tor
+}
+
+//_________________________________________________________________________
+AliITSUSeed::~AliITSUSeed()
+{
+  // d-rot
+}
+
+//_________________________________________________________________________
+AliITSUSeed::AliITSUSeed(const AliITSUSeed& src) 
+  : AliExternalTrackParam(src)
+  , fMass(src.fMass)
+{
+  // def c-tor
+}
+
+//_________________________________________________________________________
+AliITSUSeed &AliITSUSeed::operator=(const AliITSUSeed& src) 
+{
+  // def c-tor
+  if (this == &src) return *this;
+  fMass = src.fMass;
+  AliExternalTrackParam::operator=(src);
+  return *this;
+}
diff --git a/ITS/UPGRADE/AliITSUSeed.h b/ITS/UPGRADE/AliITSUSeed.h
new file mode 100644 (file)
index 0000000..d74bf45
--- /dev/null
@@ -0,0 +1,22 @@
+#ifndef ALIITSUSEED_H
+#define ALIITSUSEED_H
+
+#include "AliExternalTrackParam.h"
+
+
+class AliITSUSeed: public AliExternalTrackParam
+{
+ public:
+  AliITSUSeed();
+  AliITSUSeed(const AliITSUSeed& src);
+  AliITSUSeed &operator=(const AliITSUSeed &src);
+  virtual ~AliITSUSeed();
+  //
+ protected:
+  Double_t         fMass;
+  
+  ClassDef(AliITSUSeed,1)
+};
+
+
+#endif
diff --git a/ITS/UPGRADE/AliITSUTrackerGlo.cxx b/ITS/UPGRADE/AliITSUTrackerGlo.cxx
new file mode 100644 (file)
index 0000000..ca0421c
--- /dev/null
@@ -0,0 +1,302 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/*
+  TO CHECK
+  GetBz usage
+
+ */
+
+//-------------------------------------------------------------------------
+//  Implementation of the ITS Upgrade tracker mother class.              
+//-------------------------------------------------------------------------
+#include <TTree.h>
+#include <Riostream.h> 
+#include <TMath.h>
+
+#include "AliITSUTrackerGlo.h"
+#include "AliESDEvent.h"
+#include "AliESDtrack.h"
+#include "AliITSURecoDet.h"
+#include "AliITSURecoSens.h"
+#include "AliITSUReconstructor.h"
+#include "AliITSReconstructor.h"
+#include "AliITSUSeed.h"
+#include "AliITSUAux.h"
+using namespace AliITSUAux;
+using namespace TMath;
+
+
+ClassImp(AliITSUTrackerGlo)
+//_________________________________________________________________________
+AliITSUTrackerGlo::AliITSUTrackerGlo(AliITSUReconstructor* rec)
+:  fReconstructor(rec)
+  ,fITS(0)
+  ,fCurrMass(kPionMass)
+  ,fSeedsPool("AliITSUSeed",100)
+{
+  // Default constructor
+  if (rec) Init(rec);
+}
+
+//_________________________________________________________________________
+AliITSUTrackerGlo::~AliITSUTrackerGlo()
+{
+ // Default destructor
+ //  
+  delete fITS;
+  //
+}
+
+//_________________________________________________________________________
+void AliITSUTrackerGlo::Init(AliITSUReconstructor* rec)
+{
+  // init with external reconstructor
+  fITS = new AliITSURecoDet(rec->GetGeom(),"ITSURecoInterface");
+  for (int ilr=fITS->GetNLayersActive();ilr--;) {
+    fITS->GetLayerActive(ilr)->SetClusters(rec->GetClusters(ilr));
+  }
+}
+
+//_________________________________________________________________________
+Int_t AliITSUTrackerGlo::Clusters2Tracks(AliESDEvent *esdEv)
+{
+  //
+  //
+  fITS->ProcessClusters();
+  // select ESD tracks to propagate
+  int nTrESD = esdEv->GetNumberOfTracks();
+  for (int itr=0;itr<nTrESD;itr++) {
+    AliESDtrack *esdTr = esdEv->GetTrack(itr);
+    FindTrack(esdTr);
+  }
+
+  return 0;
+}
+
+//_________________________________________________________________________
+Int_t AliITSUTrackerGlo::PropagateBack(AliESDEvent * /*event*/)
+{
+  //
+  // To be implemented 
+  //
+  
+ Info("PropagateBack","To be implemented");
+  return 0;
+}
+
+//_________________________________________________________________________
+Int_t AliITSUTrackerGlo::RefitInward(AliESDEvent * /*event*/)
+{
+  //
+  // To be implemented 
+  //
+  
+  Info("RefitInward","To be implemented");
+  return 0;
+}
+
+//_________________________________________________________________________
+Int_t AliITSUTrackerGlo::LoadClusters(TTree * treeRP)
+{
+  // read from tree (if pointer provided) or directly from the ITS reco interface
+  //
+  return fReconstructor->LoadClusters(treeRP);
+} 
+
+//_________________________________________________________________________
+void AliITSUTrackerGlo::UnloadClusters()
+{
+  //
+  // To be implemented 
+  //
+  
+  Info("UnloadClusters","To be implemented");
+} 
+//_________________________________________________________________________
+AliCluster * AliITSUTrackerGlo::GetCluster(Int_t /*index*/) const
+{
+  //
+  // To be implemented 
+  //
+  
+  Info("GetCluster","To be implemented");
+  return 0x0;
+} 
+
+//_________________________________________________________________________
+Bool_t AliITSUTrackerGlo::NeedToProlong(AliESDtrack* esdTr)
+{
+  // do we need to match this track to ITS?
+  //
+  static double bz = GetBz();
+  if (!esdTr->IsOn(AliESDtrack::kTPCin) ||
+      esdTr->IsOn(AliESDtrack::kTPCout) ||
+      esdTr->IsOn(AliESDtrack::kITSin)  ||
+      esdTr->GetKinkIndex(0)>0) return kFALSE;
+  //
+  if (esdTr->Pt()<AliITSReconstructor::GetRecoParam()->GetMinPtForProlongation()) return kFALSE;
+  //
+  float dtz[2];
+  esdTr->GetDZ(GetX(),GetY(),GetZ(),bz,dtz); 
+  // if track is not V0 candidata but has large offset wrt IP, reject it. RS TOCHECK
+  if ( !(esdTr->GetV0Index(0)>0 && dtz[0]>AliITSReconstructor::GetRecoParam()->GetMaxDforV0dghtrForProlongation()) 
+       && (Abs(dtz[0])>AliITSReconstructor::GetRecoParam()->GetMaxDForProlongation() ||
+          Abs(dtz[1])>AliITSReconstructor::GetRecoParam()->GetMaxDZForProlongation())) return kFALSE;
+  //
+  return kTRUE;
+}
+
+//_________________________________________________________________________
+void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr)
+{
+  // find prolongaion candidates finding for single seed
+  //
+  if (!NeedToProlong(esdTr)) return;  // are we interested in this track?
+  if (!InitSeed(esdTr))         return;  // initialize prolongations hypotheses tree
+  //
+  double rwData[kNTrData];
+  AliITSURecoSens *hitSens[AliITSURecoSens::kNNeighbors];
+  AliITSUSeed seed0;
+  //
+  for (int ila=fITS->GetNLayersActive();ila--;) {
+    int ilaUp = ila+1;                         // prolong seeds from layer above
+    int nSeedsUp = GetNSeeds(ilaUp);
+    for (int isd=0;isd<nSeedsUp;isd++) {
+      seed0 = *GetSeed(ilaUp,isd);  // copy of the seed on prev.active layer
+      // go till next active layer
+      if (!TransportToLayer(&seed0, fITS->GetLrIDActive(ilaUp), fITS->GetLrIDActive(ila)) ) {
+       //
+       // Check if the seed satisfies to track definition
+       if (NeedToKill(&seed0,kTransportFailed)) KillSeed(ilaUp,isd); 
+       continue; // RS TODO: decide what to do with tracks stopped on higher layers w/o killing
+      }
+      AliITSURecoLayer* lrA = fITS->GetLayerActive(ila);
+      if (!GetRoadWidth(&seed0, ila, rwData)) { // failed to find road width on the layer
+       if (NeedToKill(&seed0,kRWCheckFailed)) KillSeed(ilaUp,isd); 
+       continue;
+      }
+      int nsens = lrA->FindSensors(&rwData[kTrPhi0], hitSens);  // find detectors which may be hit by the track (max 4)
+      //
+      for (int isn=nsens;isn--;) {
+
+
+      }
+      
+    }
+  }
+  //
+}
+
+//_________________________________________________________________________
+Bool_t AliITSUTrackerGlo::InitSeed(AliESDtrack *esdTr)
+{
+  // int prolongaion candidates finding for single seed
+  fCurrMass = esdTr->GetMass();
+  if (fCurrMass<kPionMass*0.9) fCurrMass = kPionMass; // don't trust to mu, e identification from TPCin
+  return kTRUE;
+  // TO DO
+}
+
+//_________________________________________________________________________
+Bool_t AliITSUTrackerGlo::TransportToLayer(AliITSUSeed* seed, Int_t lFrom, Int_t lTo)
+{
+  // transport seed from layerFrom to the entrance of layerTo
+  //  
+  const double kToler = 1e-6; // tolerance for layer on-surface check
+  //
+  int dir = lTo > lFrom ? 1:-1;
+  AliITSURecoLayer* lrFr = fITS->GetLayer(lFrom); // this can be 0 when extrapolation from TPC to ITS is requested
+  Bool_t checkFirst = kTRUE;
+  while(lFrom!=lTo) {
+    double curR2 = seed->GetX()*seed->GetX() + seed->GetY()*seed->GetY(); // current radius
+    if (lrFr) {
+      Bool_t doLayer = kTRUE;
+      double xToGo = dir>0 ? lrFr->GetRMax() : lrFr->GetRMin();
+      if (checkFirst) { // do we need to track till the surface of the current layer ?
+       checkFirst = kFALSE;
+       if      (dir>0) { if (curR2-xToGo*xToGo>kToler) doLayer = kFALSE; } // on the surface or outside of the layer
+       else if (dir<0) { if (xToGo*xToGo-curR2>kToler) doLayer = kFALSE; } // on the surface or outside of the layer
+      }
+      if (doLayer) {
+       if (!seed->GetXatLabR(xToGo,xToGo,GetBz(),dir)) return kFALSE;
+       // go via layer to its boundary, applying material correction.
+       if (!PropagateTrackTo(seed,xToGo,fCurrMass, lrFr->GetMaxStep(), kFALSE, -1, 0, kTRUE)) return kFALSE;
+      }
+    }
+    AliITSURecoLayer* lrTo =  fITS->GetLayer( (lFrom+=dir) );
+    if (!lrTo) AliFatal(Form("Layer %d does not exist",lFrom));
+    //
+    // go the entrance of the layer, assuming no materials in between
+    double xToGo = dir>0 ? lrTo->GetRMin() : lrTo->GetRMax();
+    if (seed->GetXatLabR(xToGo,xToGo,GetBz(),dir)) return kFALSE;
+    if (!seed->PropagateTo(xToGo, GetBz())) return kFALSE; // RS: do we need BxByBz?
+    lrFr = lrTo;
+  }
+  return kTRUE;
+  //
+}
+
+//_________________________________________________________________________
+Bool_t AliITSUTrackerGlo::GetRoadWidth(AliITSUSeed* seed, int ilrA, double* rwData)
+{
+  // calculate road width in terms of phi and z for the track which MUST be on the external radius of the layer
+  // as well as some aux info
+  double bz = GetBz();
+  AliITSURecoLayer* lrA = fITS->GetLayerActive(ilrA);
+  seed->GetXYZ(&rwData[kTrXIn]);    // lab position at the entrance from above
+  //
+  rwData[kTrPhiIn] = ATan2(rwData[kTrYIn],rwData[kTrXIn]);
+  if (!seed->Rotate(rwData[kTrPhiIn])) return kFALSE; // go to the frame of the entry point into the layer
+  double dr  = lrA->GetDR();                          // approximate X dist at the inner radius
+  if (!seed->GetXYZAt(seed->GetX()-dr, bz, rwData + kTrXOut)) {
+    // special case: track does not reach inner radius, might be tangential
+    double r = seed->GetD(0,0,bz);
+    double x;
+    if (!seed->GetXatLabR(r,x,bz,-1)) {
+      AliError(Form("This should not happen: r=%f",r));
+      seed->Print();
+      return kFALSE;
+    }
+    dr = Abs(seed->GetX() - x);
+    if (!seed->GetXYZAt(x, bz, rwData + kTrXOut)) {
+      AliError(Form("This should not happen: x=%f",x));
+      seed->Print();
+      return kFALSE;      
+    }
+  }
+  //
+  rwData[kTrPhiOut] = ATan2(rwData[kTrYOut],rwData[kTrXOut]);
+  double sgy = seed->GetSigmaY2() + dr*seed->GetSigmaSnp2() + AliITSReconstructor::GetRecoParam()->GetSigmaY2(ilrA);
+  double sgz = seed->GetSigmaZ2() + dr*seed->GetSigmaTgl2() + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilrA);
+  sgy = Sqrt(sgy)*AliITSReconstructor::GetRecoParam()->GetNSigmaRoadY();
+  sgz = Sqrt(sgz)*AliITSReconstructor::GetRecoParam()->GetNSigmaRoadZ();
+  rwData[kTrPhi0] = 0.5*(rwData[kTrPhiOut]+rwData[kTrPhiIn]);
+  rwData[kTrZ0]   = 0.5*(rwData[kTrZOut]+rwData[kTrPhiIn]);
+  rwData[kTrDPhi] = 0.5*Abs(rwData[kTrPhiOut]-rwData[kTrPhiIn]) + sgy/lrA->GetR();
+  rwData[kTrDZ]   = 0.5*Abs(rwData[kTrZOut]-rwData[kTrPhiIn])   + sgz;
+  //  
+  return kTRUE;
+}
+
+//_________________________________________________________________________
+AliITSUSeed* AliITSUTrackerGlo::NewSeed(const AliITSUSeed* src)
+{
+  // create new seed, optionally copying from the source
+  return src ? 
+    new(fSeedsPool[fSeedsPool.GetEntriesFast()]) AliITSUSeed(*src) :
+    new(fSeedsPool[fSeedsPool.GetEntriesFast()]) AliITSUSeed();
+}
diff --git a/ITS/UPGRADE/AliITSUTrackerGlo.h b/ITS/UPGRADE/AliITSUTrackerGlo.h
new file mode 100644 (file)
index 0000000..f8429fa
--- /dev/null
@@ -0,0 +1,74 @@
+#ifndef ALIITSTRACKERU_H
+#define ALIITSTRACKERU_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//-------------------------------------------------------------------------
+//                ITS upgrade tracker base class
+//-------------------------------------------------------------------------
+
+#include "AliTracker.h"
+#include "AliESDEvent.h"
+
+class AliITSUReconstructor;
+class AliITSURecoDet;
+class AliITSUSeed;
+class TTree;
+
+//-------------------------------------------------------------------------
+class AliITSUTrackerGlo : public AliTracker {
+
+  public:
+  enum { // info from track extrapolation to layer for cluster check
+    kTrXIn ,kTrYIn ,kTrZIn ,kTrPhiIn , // entrance (outer) point on the layer from above 
+    kTrXOut,kTrYOut,kTrZOut,kTrPhiOut, // exit (inner) point on the layer
+    kTrPhi0, kTrDPhi, kTrZ0, kTrDZ,     // mean phi,dPhi, mean z, dZ (don't change this order)
+    kNTrData};
+  //
+  enum {kTransportFailed=1  // seed did not reach target layer
+       ,kRWCheckFailed =2  // failed to rotate the seed to frame of the layer impact point
+  };
+
+  AliITSUTrackerGlo(AliITSUReconstructor* rec);
+  virtual ~AliITSUTrackerGlo();
+
+  virtual Int_t          Clusters2Tracks(AliESDEvent *event);
+  virtual Int_t          PropagateBack(AliESDEvent *event);
+  virtual Int_t          RefitInward(AliESDEvent *event);
+  virtual Int_t          LoadClusters(TTree * treeRP=0);
+  virtual void           UnloadClusters();
+  virtual AliCluster*    GetCluster(Int_t index) const;
+
+
+  //------------------------------------
+  Bool_t                 NeedToProlong(AliESDtrack* estTr);
+  void                   Init(AliITSUReconstructor* rec);
+  void                   FindTrack(AliESDtrack* esdTr);
+  Bool_t                 InitSeed(AliESDtrack *esdTr);
+  Int_t                  GetNSeeds(Int_t lr)              const {return 0;} //todo
+  AliITSUSeed*           GetSeed(Int_t lr, Int_t sID)     const {return 0;} //todo
+  Bool_t                 TransportToLayer(AliITSUSeed* seed, Int_t lFrom, Int_t lTo);
+  Bool_t                 NeedToKill(AliITSUSeed* seed, Int_t flag) {return kFALSE;} // todo
+  void                   KillSeed(Int_t ilr, Int_t id) {} // todo
+  Bool_t                 GetRoadWidth(AliITSUSeed* seed, int ilrA, double* rwData);
+  //
+  AliITSUSeed*           NewSeed(const AliITSUSeed* src=0);
+
+ private:
+  
+  AliITSUTrackerGlo(const AliITSUTrackerGlo&);
+  AliITSUTrackerGlo &operator=(const AliITSUTrackerGlo &tr);
+  //
+ protected:
+  AliITSUReconstructor*           fReconstructor;  // ITS global reconstructor 
+  AliITSURecoDet*                 fITS;            // interface to ITS
+  Double_t                        fCurrMass;       // current track mass
+  //
+
+  TClonesArray                    fSeedsPool;      // pool for seeds
+
+  ClassDef(AliITSUTrackerGlo,1)   //ITS upgrade tracker
+    
+};
+#endif
+
index e4eff80..f9038e5 100644 (file)
@@ -34,6 +34,8 @@ set ( SRCS
     AliITSURecoLayer.cxx
     AliITSURecoDet.cxx
     AliITSUClusterPix.cxx
+    AliITSUSeed.cxx
+    AliITSUTrackerGlo.cxx
 #
 #    v0/AliITSlayerUpgrade.cxx 
 #    v0/AliITStrackerUpgrade.cxx 
index 1b2f9f4..a6e5c92 100644 (file)
@@ -20,6 +20,8 @@
 #pragma link C++ class AliITSURecoLayer+;
 #pragma link C++ class AliITSURecoDet+;
 #pragma link C++ class AliITSUClusterPix+;
+#pragma link C++ class AliITSUSeed+;
+#pragma link C++ class AliITSUTrackerGlo+;
 
 //
 
index b52dd0e..4bfaf77 100644 (file)
@@ -224,7 +224,7 @@ void Config()
   Int_t   iSHIL  =  0;
   Int_t   iT0    =  0;
   Int_t   iTOF   =  0;
-  Int_t   iTPC   =  0;
+  Int_t   iTPC   =  1;
   Int_t   iTRD   =  0;
   Int_t   iZDC   =  0;
   Int_t   iEMCAL =  0;
index 29c0751..8660412 100644 (file)
@@ -29,6 +29,8 @@ void rec() {
                         Form("local://%s",gSystem->pwd()));
   rec.SetSpecificStorage("ITS/Align/Data",
                         Form("local://%s",gSystem->pwd()));
+  rec.SetSpecificStorage("ITS/Calib/RecoParam",
+                        Form("local://%s",gSystem->pwd()));
   
 
   rec.SetRunQA(":");