ITS/AliITStrackerANN.h

   1 // AliITStrackerANN header file.
   2 // Class definition for the Neural Tracking implementation
   3 // for the ALICE ITS stand-alone.
   4 // Author: A. Pulvirenti
   5 // Email : alberto.pulvirenti@ct.infn.it
   6
   7 #ifndef ALIITSTRACKERANN_H
   8 #define ALIITSTRACKERANN_H
   9
  10 #include "AliITStrackerV2.h"
  11
  12 class AliITSgeom;
  13 class TArrayI;
  14
  15 class AliITStrackerANN : public AliITStrackerV2
  16 {
  17 public:
  18
  19
  20         /* Constructors */
  21         AliITStrackerANN() : AliITStrackerV2() { /* does nothing */ };
  22         AliITStrackerANN(const AliITSgeom *geom, Int_t msglev = 0);
  23         AliITStrackerANN(const AliITStrackerANN &n) : AliITStrackerV2((AliITStrackerV2&)n)
  24                 { /* nothing */ }
  25         AliITStrackerANN& operator=(const AliITStrackerANN& /*arg*/)
  26                 { return *this; }
  27
  28         /* Destructor */
  29         // virtual ~AliITStrackerANN();
  30
  31
  32         /*********************************************
  33           >> AliITSnode <<
  34           ----------------
  35           An ITS point in the global reference frame.
  36          *********************************************/
  37         class AliITSnode : public TObject {
  38         public:
  39
  40                 AliITSnode();
  41                 ~AliITSnode();
  42                 AliITSnode(const AliITSnode &n) : TObject((TObject&)n)
  43                 { /* nothing */ }
  44                 AliITSnode& operator=(const AliITSnode& /*arg*/)
  45                 { return *this; }
  46
  47                 /* (NODE) Function to extract layer info from cluster index */
  48                 Int_t  GetLayer() const {Int_t lay = (fClusterRef & 0xf0000000) >> 28; return lay;}
  49
  50                 /* (NODE) Getter and Setter for the 'fUsed' flag */
  51                 Bool_t IsUsed() const {return fUsed;}
  52                 void   Use()          {fUsed = kTRUE;}
  53
  54                 /* (NODE) Geometrical functions */
  55                 Double_t  GetR2()    const  {return TMath::Sqrt(GetR2sq());}   // xy  radius
  56                 Double_t  GetR3()    const  {return TMath::Sqrt(GetR3sq());}   // xyz radius
  57                 Double_t  GetR2sq()  const  {return fX*fX+fY*fY;}              // xy  radius^2
  58                 Double_t  GetR3sq()  const  {return GetR2sq()+fZ*fZ;}          // xyz radius^2
  59                 Double_t  GetPhi()   const;
  60                 Double_t  GetTheta() const  {return TMath::ATan2(GetR2(),fZ);} // polar angle
  61                 Double_t  GetError(Option_t *opt);                             // errors on coords
  62
  63                 /* Data members references */
  64                 Double_t& X()            {return fX;}
  65                 Double_t& Y()            {return fY;}
  66                 Double_t& Z()            {return fZ;}
  67                 Double_t& ErrX2()        {return fEX2;}
  68                 Double_t& ErrY2()        {return fEY2;}
  69                 Double_t& ErrZ2()        {return fEZ2;}
  70                 Int_t&    ClusterRef()   {return fClusterRef;}
  71
  72                 TObjArray*&   Matches()  {return fMatches;}
  73                 TObjArray*&   InnerOf()  {return fInnerOf;}
  74                 TObjArray*&   OuterOf()  {return fOuterOf;}
  75                 AliITSnode*&  Next()     {return fNext;}
  76                 AliITSnode*&  Prev()     {return fPrev;}
  77
  78         private:
  79
  80                 Double_t    fX;           // X in global reference system
  81                 Double_t    fY;           // Y in global reference system
  82                 Double_t    fZ;           // Z in global reference system
  83                 Double_t    fEX2;         // X error in global reference system
  84                 Double_t    fEY2;         // Y error in global reference system
  85                 Double_t    fEZ2;         // Z error in global reference system
  86
  87                 Bool_t      fUsed;        //  usage flag
  88                 Int_t       fClusterRef;  //  reference index for related cluster
  89                 TObjArray  *fMatches;     //! array of well-matched cluster indexes
  90                 TObjArray  *fInnerOf;     //! array of neurons starting from *this
  91                 TObjArray  *fOuterOf;     //! array of neurons entering *this
  92                 AliITSnode *fNext;        //! pointer to the next node in the found track
  93                 AliITSnode *fPrev;        //! pointer to the previous node in the found track
  94
  95         };
  96         /* End of AliITSnode class */
  97
  98
  99         /***************************************
 100           >> AliITSneuron <<
 101           ------------------
 102           A single unit in the neural network.
 103          ***************************************/
 104         class AliITSneuron : public TObject {
 105         public:
 106
 107                 /* (NEURON) Constructor: alocates the sequenced units array */
 108                 AliITSneuron() : fUsed(0), fActivation(0.), fInner(0), fOuter(0), fGain(0)
 109                         {fGain = new TObjArray;}
 110                 AliITSneuron(AliITSnode *inner, AliITSnode *outer, Double_t minAct, Double_t maxAct);
 111                 AliITSneuron(const AliITSneuron &n) : TObject((TObject&)n)
 112                 { /* nothing */ }
 113                 AliITSneuron& operator=(const AliITSneuron& /*arg*/)
 114                 { return *this; }
 115
 116
 117                 /* (NEURON) Destructor: frees memory from dynamic allocated objects */
 118                 virtual ~AliITSneuron()
 119                         { fInner = fOuter = 0; fGain->SetOwner(kFALSE); fGain->Clear(); delete fGain; }
 120
 121                 /* Compute neural activation from the network */
 122                 Double_t  Activate(Double_t temperature);
 123
 124                 /* Data members references */
 125                 Int_t&        Used()        {return fUsed;}
 126                 Double_t&     Activation()  {return fActivation;}
 127                 AliITSnode*&  Inner()       {return fInner;}
 128                 AliITSnode*&  Outer()       {return fOuter;}
 129                 TObjArray*&   Gain()        {return fGain;}
 130
 131         private:
 132
 133                 Int_t             fUsed;        //  utility flag
 134                 Double_t          fActivation;  //  Activation value
 135                 AliITSnode       *fInner;       //! inner point
 136                 AliITSnode       *fOuter;       //! outer point
 137                 TObjArray        *fGain;        //! list of sequenced units
 138
 139         };
 140         /* End of NEURON class */
 141
 142
 143         /**************************************************
 144           >> AliITSlink <<
 145           ----------------
 146           A synaptic connected unit in the neural network.
 147          **************************************************/
 148         class AliITSlink : public TObject {
 149         public:
 150
 151                 AliITSlink() {fWeight = 0.0; fLinked = 0;}
 152                 AliITSlink(Double_t w, AliITSneuron *n) : fWeight(w), fLinked(n) { }
 153                 virtual ~AliITSlink() {fLinked = 0;}
 154                 AliITSlink(const AliITSlink &n) : TObject((TObject&)n)
 155                 { /* nothing */ }
 156                 AliITSlink& operator=(const AliITSlink& /*arg*/)
 157                 { return *this; }
 158
 159                 /* contribution */
 160                 Double_t Contribution() {return fLinked->Activation() * fWeight;}
 161
 162         private:
 163
 164                 Double_t      fWeight;  //  Weight value
 165                 AliITSneuron *fLinked;  //! Connected neuron
 166
 167         };
 168         /* End of AliITSlink class */
 169
 170         /**************************************
 171           >> AliITStrackANN <<
 172           ----------------
 173           A track found by the neural network.
 174          **************************************/
 175         class AliITStrackANN : public TObject {
 176         public:
 177
 178                 AliITStrackANN(Int_t dim = 0);
 179                 AliITStrackANN(const AliITStrackANN &n) : TObject((TObject&)n)
 180                 { /* nothing */ }
 181                 AliITStrackANN& operator=(const AliITStrackANN& /*arg*/)
 182                 { return *this; }
 183
 184                 Double_t&  XCenter()                 {return fXCenter;}
 185                 Double_t&  YCenter()                 {return fYCenter;}
 186                 Double_t&  Radius()                  {return fRadius;}
 187                 Double_t&  Curv()                    {return fCurv;}
 188                 Double_t&  ImpactParameterTrans()    {return fDTrans;}
 189                 Double_t&  ImpactParameterLong()     {return fDLong;}
 190                 Double_t&  TanLambda()               {return fTanLambda;}
 191                 Double_t&  Phi()                     {return fPhi;}
 192
 193                 AliITSnode* operator[](Int_t i) const {return ((i>=0&&i<fNPoints)?fNode[i]:0);}
 194                 AliITSnode* GetNode(Int_t i) const {return ((i>=0&&i<fNPoints)?fNode[i]:0);}
 195                 void        SetNode(Int_t i, AliITSnode*& ref) {if (i>=0&&i<fNPoints) fNode[i] = ref;}
 196
 197                 Int_t  CheckOccupation() const;
 198                 Bool_t RiemannFit();
 199
 200         private:
 201
 202                 Int_t      fNPoints;    // nuber of track elements
 203
 204                 Double_t   fXCenter;    // X of bending circle center
 205                 Double_t   fYCenter;    // Y of bending circle center
 206                 Double_t   fRadius;     // radius of bending circle
 207                 Double_t   fCurv;       // signed curvature of bending circle
 208                 Double_t   fDTrans;     // transverse impact parameter
 209                 Double_t   fDLong;      // longitudinal impact parameter
 210                 Double_t   fTanLambda;  // tangent of dip angle
 211                 Double_t   fPhi;        // initial direction of transverse momentum
 212
 213                 AliITSnode **fNode;     // pointers to track elements
 214
 215         };
 216         /* End of AliITStrackANN class */
 217
 218         /* Geometry setter */
 219         void SetITSgeom(AliITSgeom *geom)             {fGeom = (AliITSgeom*)geom;}
 220
 221         /* Flag setter */
 222         void SetMessageLevel(Int_t lev)               {fMsgLevel = lev;}
 223
 224         /* Cut setters */
 225         void SetCuts(Int_t ncurv = 0, Double_t *curv = 0, // curvature (number of cuts and array)
 226                      Double_t *theta2D = 0,               // cut in theta 2D (rho-z)
 227                 Double_t *theta3D = 0,               // cut in theta 3D (x-y-z)
 228                 Double_t *helix = 0);                // cut for helix-matching
 229
 230         /* Setter for overall Theta cut */
 231         void SetPolarInterval(Double_t dtheta)        {fPolarInterval=dtheta;}
 232
 233         /* Neural work-flow setters */
 234         void SetActThreshold(Double_t val)            {fActMinimum = val;}
 235         void SetWeightExponent(Double_t a)            {fExponent = a;}
 236         void SetGainToCostRatio(Double_t a)           {fGain2CostRatio = a;}
 237         void SetInitInterval(Double_t a, Double_t b)  {fEdge1 = a; fEdge2 = b;}
 238         void SetTemperature(Double_t a)               {fTemperature = a;}
 239         void SetVariationLimit(Double_t a)            {fStabThreshold = a;}
 240
 241         /* Vertex setter */
 242         void SetVertex(Double_t x, Double_t y, Double_t z) {fVertexX=x;fVertexY=y;fVertexZ=z;}
 243
 244         /* Node management for neural network creation */
 245         Bool_t      GetGlobalXYZ(Int_t refClust,
 246                                  Double_t &x, Double_t &y, Double_t &z,
 247                                                                          Double_t &ex2, Double_t &ey2, Double_t &ez2);
 248         AliITSnode* AddNode(Int_t index);
 249         void        CreateArrayStructure(Int_t nsecs);
 250         Int_t       ArrangePoints(char *exportFile = 0);
 251         void        StoreOverallMatches();
 252         Bool_t      PassCurvCut(AliITSnode *p1, AliITSnode *p2, Int_t curvStep, Double_t vx, Double_t vy, Double_t vz);
 253         Int_t       PassAllCuts(AliITSnode *p1, AliITSnode *p2, Int_t curvStep, Double_t vx, Double_t vy, Double_t vz);
 254         void        PrintMatches(Bool_t stop = kTRUE);
 255
 256         /* Neural tracking operations */
 257         // void     NeuralTracking(const char* filesave, TCanvas*& display);
 258         void     ResetNodes(Int_t isector);
 259         Int_t    CreateNetwork(Int_t sector, Int_t curvStep);  // create network
 260         Int_t    CreateNeurons(AliITSnode *node, Int_t curvStep, Double_t vx, Double_t vy, Double_t vz);  // create neurons starting from given point
 261         Int_t    LinkNeurons();                // create neural connections
 262         Bool_t   Update();                     // an updating cycle
 263         void     FollowChains(Int_t sector);   // follows the chains of active neurons
 264         Int_t    SaveTracks(Int_t sector);     // saves the found tracks
 265         void     CleanNetwork();               // removes deactivated units and resolve competitions
 266         //Int_t    Save(Int_t sector);     // save found tracks for # sector
 267         Int_t    StoreTracks();                // save found tracks for # sector
 268
 269         /* Fit procedures */
 270         void     ExportTracks(const char *file) const;
 271
 272 private:
 273
 274         /* Neural synaptic weight */
 275         Double_t Weight(AliITSneuron *nAB, AliITSneuron *nBC);
 276
 277         /* Usefuls constant angle values */
 278         static const Double_t fgkPi; // pi
 279         static const Double_t fgkHalfPi; // pi / 2
 280         static const Double_t fgkTwoPi; // 2 * pi
 281
 282         /* Primary vertex position */
 283         Double_t fVertexX; // X
 284         Double_t fVertexY; // Y
 285         Double_t fVertexZ; // Z
 286
 287         /* ITS barrel sectioning */
 288         Int_t        fSectorNum;      //  number of azimutal sectors
 289         Double_t     fSectorWidth;    //  width of barrel sector (in RAD) [used internally]
 290         Double_t     fPolarInterval;  //  width of a polar sector (in DEGREES)
 291
 292         /* Cuts */
 293         Double_t     fThetaCut2D[5];     //  upper edge of theta cut range (in DEGREES)
 294         Double_t     fThetaCut3D[5];     //  upper edge of theta cut range (in DEGREES)
 295         Double_t     fHelixMatchCut[5];  //  lower edge of helix matching cut range
 296         Int_t        fCurvNum;           //  # of curvature cut steps
 297         Double_t    *fCurvCut;           //! value of all curvature cuts
 298
 299         /* Neural network work-flow parameters */
 300         Double_t     fActMinimum;      //  minimum activation to turn 'on' the unit at the end
 301         Double_t     fEdge1, fEdge2;   //  initialization interval for activations
 302         Double_t     fStabThreshold;   //  stability threshold
 303         Double_t     fTemperature;     //  slope in logistic function
 304         Double_t     fGain2CostRatio;  //  ratio between inhibitory and excitory contributions
 305         Double_t     fExponent;        //  alignment-dependent weight term
 306
 307         /* Object arrays for data storing and related counters */
 308         Int_t        fNLayers;          //  Number of ITS layers
 309         Int_t       *fFirstModInLayer;  //! Index of first module index for each layer
 310         TArrayI    **fIndexMap;         //! Map of cluster indexes (in AliITSlayer) with reference to
 311                                         //  the location in the cluster Tree (module, pos in array)
 312         Int_t        fTrackClust[6];    //  Track point in layers
 313         TObjArray   *fFoundTracks;      //! Found tracks
 314         TObjArray ***fNodes;            //! recpoints arranged into sectors for processing
 315         TObjArray   *fNeurons;          //! neurons
 316
 317         /* Flags */
 318         Int_t   fMsgLevel;        // To allow the on-screen printing of messages
 319         Bool_t  fStructureOK;     // Check if the nested TObjArray structure of nodes is created
 320
 321         /* ALICE related objects */
 322         AliITSgeom  *fGeom;       //! ITS Geometry
 323
 324         friend class AliITStrackerANN::AliITStrackANN;
 325
 326         /* ROOT class implementation routines */
 327         ClassDef(AliITStrackerANN, 1)
 328 };
 329
 330 #endif