Added ClassDef and ClassImp for AliITSneuron class, so that it is compatible
[u/mrichter/AliRoot.git] / ITS / AliITSneuralTracker.h
1 #ifndef AliITSneuralTracker_h
2 #define AliITSneuralTracker_h
3
4 #include <TObject.h>
5
6 #include "AliITSglobalRecPoint.h"
7 class TObjArray;
8
9 class AliITSneuron;
10 class AliITSneuralTrack;
11 //class AliITSglobalRecPoint;
12
13 ///////////////////////////////////////////////////////////////////////
14 //
15 // AliITSneuralTracker: 
16 //
17 // neural network MFT algorithm 
18 // for track finding in ITS stand alone
19 // according to the Denby-Peterson model with adaptments to the 
20 // ALICE multiplicity
21 // 
22 ///////////////////////////////////////////////////////////////////////
23
24 class AliITSneuralTracker : public TObject {
25
26 public:
27         
28         // constructors & destructor
29         AliITSneuralTracker();
30         AliITSneuralTracker(Int_t nsecs, Int_t nc, Double_t *c, Double_t theta);
31         virtual ~AliITSneuralTracker();
32         
33         // file reading and points array population
34         Int_t ReadFile(const Text_t *fname, Int_t evnum);
35         
36         // setters for working parameters (NOT cuts)
37         void SetDiff(Double_t a) {fDiff=a;}                 // helix adaptment parameter
38         void SetExponent(Double_t a) {fExp = a;}            // exponent which selects the high excitory values
39         void SetGainToCostRatio(Double_t a) {fRatio = a;}   // ratio between the gain and cost contributions
40         void SetTemperature(Double_t a) {fTemp = a;}        // temperature parameter in activation function
41         void SetVariationLimit(Double_t a) {fVar = a;}      // stability threshold
42         void SetInitLimits(Double_t a, Double_t b)          // intervals for initial random activations
43                 {fMin = (a<=b) ? a : b; fMax = (a<=b)? b : a;}
44         void SetVertex(Double_t x, Double_t y, Double_t z)  // estimated vertex position
45                 { fVPos[0] = x; fVPos[1] = y; fVPos[2] = z;}
46         
47         // neuron managin methods
48         Bool_t   SetEdge(AliITSneuron *n, AliITSglobalRecPoint *p, const char what); // sets the neuron's edges
49         Bool_t   CalcParams(AliITSneuron *n);              // calculation of helix parameters for the neuron
50         
51         // neural tracking (the argument is the ROOT file to store results)
52         void Go(const char* filesave, Bool_t flag = kFALSE); 
53                         
54 private:
55                 
56         // These methods are private to prevent the users to use them in incorrect sequences
57                 
58         // neuron management methods (not to be used publically)
59         Bool_t   ResetNeuron(AliITSneuron *n);             // resets all neuron's fields like in the constructor
60         Int_t    CountExits (AliITSneuron *n);             // counter for # of neurons going into n's tail
61         Int_t    CountEnters(AliITSneuron *n);             // counter for # of neurons startins from n's head
62         Double_t Angle(AliITSneuron *n, AliITSneuron *m);  // angle between two neural segments
63         Double_t Weight(AliITSneuron *n, AliITSneuron *m); // synaptic weight between two neural segments
64         
65         // neural network work-flow
66         Int_t  Initialize(Int_t snum, Int_t cnum, Bool_t flag = kFALSE); 
67                                                               // resets (or creates) neurons array for a new neural tracking
68         Bool_t Update();                            // updates the neurons and checks if stabilization has occurred
69         Int_t  Save();                              // saves the found tracks after stabilization
70         void   DoSector(Int_t sect, Bool_t flag);   // complete work on a single sector
71                 
72         Int_t     fCurvNum;  //  # of curvature cut steps
73         Double_t *fCurvCut;  //! value of all curvature cuts
74         
75         Int_t     fSectorNum;    // no. of azymuthal sectors
76         Double_t  fSectorWidth;  // width of an azymuthal sector
77         
78         Double_t fVPos[3]; // estimated vertex coords
79         
80         Double_t fMin;      // min initial random activations
81         Double_t fMax;      // max initial random activations
82         Double_t fThetaCut; // polar angle cut
83         Int_t    fThetaNum; // size of theta sectionement
84         Double_t fTemp;     // logistic function parameter
85         Double_t fVar;      // stability threshold (for mean rel. activations)
86         Double_t fRatio;    // ratio between inhibitory and excitory contributions
87         Double_t fExp;      // alignment weight
88         Double_t fDiff;     // max allowed difference between TanL exstimations from the two neuron edges
89         
90         TObjArray ***fPoints[6];  //! Collection of recpoints (sectioned in azym. secs)
91         TObjArray   *fNeurons[6]; //! Collection of neurons
92         TObjArray   *fTracks;     //! Collection of tracks
93         
94         ClassDef(AliITSneuralTracker, 1)
95 };
96         
97
98 ////////////////////////////////////////////////////////////////////////////////
99
100
101 class AliITSneuron : public TObject {
102         
103         friend class AliITSneuralTracker;
104         
105 public:
106                 
107                  AliITSneuron();
108         virtual ~AliITSneuron();
109         
110         Bool_t   ContainsID(Int_t ID) 
111                 { return (fInner->HasID(ID) && fOuter->HasID(ID)); }
112         
113 private:
114                 
115         Double_t fActivation; // Activation value
116
117         Double_t fCurv;    // curvature [= 1 / R]
118         Double_t fCX;      // curvature centre (X) in changed RF
119         Double_t fCY;      // curvature centre (X) in changed RF
120         Double_t fTanL;    // tan(dip angle) = C / freq
121         Double_t fPhase;   // 'phase' parameter
122         Double_t fDiff;    // difference between tan(lambda) estimated by the two different points
123         Double_t fLength;  // segment length
124         
125         AliITSneuron *fNext; // best outgoing unit
126         AliITSneuron *fPrev; // best incoming unit
127         
128         AliITSglobalRecPoint *fInner; // inner point 
129         AliITSglobalRecPoint *fOuter; // outer point
130         ClassDef(AliITSneuron,1) // neural tracker helper class
131 };
132
133         
134 #endif