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

// AliITStrackerANN header file.
// Class definition for the Neural Tracking implementation
// for the ALICE ITS stand-alone.
// Author: A. Pulvirenti
// Email : alberto.pulvirenti@ct.infn.it

#ifndef ALIITSTRACKERANN_H
#define ALIITSTRACKERANN_H

#include "AliITStrackerV2.h"

class AliITSgeom;
class TArrayI;

class AliITStrackerANN : public AliITStrackerV2 
{
public:


	/* Constructors */
        AliITStrackerANN();
	AliITStrackerANN(const AliITSgeom *geom, Int_t msglev = 0);
	AliITStrackerANN(const AliITStrackerANN &n);
	AliITStrackerANN& operator=(const AliITStrackerANN& arg);
	
	/* Destructor */
	// virtual ~AliITStrackerANN();
	
	
	/*********************************************
	  >> AliITSnode <<
	  ----------------
	  An ITS point in the global reference frame.                      
	 *********************************************/
	class AliITSnode : public TObject {
	public:
	
		AliITSnode();
		~AliITSnode();
		AliITSnode(const AliITSnode &n); 
 
		AliITSnode& operator=(const AliITSnode& /*arg*/)
		{ return *this; }
	
		/* (NODE) Function to extract layer info from cluster index */
		Int_t  GetLayer() const {Int_t lay = (fClusterRef & 0xf0000000) >> 28; return lay;}
		
		/* (NODE) Getter and Setter for the 'fUsed' flag */
		Bool_t IsUsed() const {return fUsed;}
		void   Use()          {fUsed = kTRUE;}
		
		/* (NODE) Geometrical functions */
		Double_t  GetR2()    const  {return TMath::Sqrt(GetR2sq());}   // xy  radius
		Double_t  GetR3()    const  {return TMath::Sqrt(GetR3sq());}   // xyz radius
		Double_t  GetR2sq()  const  {return fX*fX+fY*fY;}              // xy  radius^2
		Double_t  GetR3sq()  const  {return GetR2sq()+fZ*fZ;}          // xyz radius^2
		Double_t  GetPhi()   const;
		Double_t  GetTheta() const  {return TMath::ATan2(GetR2(),fZ);} // polar angle
		Double_t  GetError(Option_t *opt);                             // errors on coords
		
		/* Data members references */
		Double_t& X()            {return fX;}
		Double_t& Y()            {return fY;}
		Double_t& Z()            {return fZ;}
		Double_t& ErrX2()        {return fEX2;}
		Double_t& ErrY2()        {return fEY2;}
		Double_t& ErrZ2()        {return fEZ2;}
		Int_t&    ClusterRef()   {return fClusterRef;}
		
		TObjArray*&   Matches()  {return fMatches;}
		TObjArray*&   InnerOf()  {return fInnerOf;}
		TObjArray*&   OuterOf()  {return fOuterOf;}
		AliITSnode*&  Next()     {return fNext;}
		AliITSnode*&  Prev()     {return fPrev;}
		
	private:
		
		Double_t    fX;           // X in global reference system
		Double_t    fY;           // Y in global reference system
		Double_t    fZ;           // Z in global reference system
		Double_t    fEX2;         // X error in global reference system
		Double_t    fEY2;         // Y error in global reference system
		Double_t    fEZ2;         // Z error in global reference system
		
		Bool_t      fUsed;        //  usage flag
		Int_t       fClusterRef;  //  reference index for related cluster
		TObjArray  *fMatches;     //! array of well-matched cluster indexes
		TObjArray  *fInnerOf;     //! array of neurons starting from *this
		TObjArray  *fOuterOf;     //! array of neurons entering *this
		AliITSnode *fNext;        //! pointer to the next node in the found track
		AliITSnode *fPrev;        //! pointer to the previous node in the found track
		
	};
	/* End of AliITSnode class */
	
		
	/***************************************
	  >> AliITSneuron <<
	  ------------------
	  A single unit in the neural network.
	 ***************************************/
	class AliITSneuron : public TObject {
	public:
	
		/* (NEURON) Constructor: alocates the sequenced units array */
		AliITSneuron() : fUsed(0), fActivation(0.), fInner(0), fOuter(0), fGain(0) 
			{fGain = new TObjArray;}
		AliITSneuron(AliITSnode *inner, AliITSnode *outer, Double_t minAct, Double_t maxAct);
		AliITSneuron(const AliITSneuron &n);
		AliITSneuron& operator=(const AliITSneuron& arg)
		{this->~AliITSneuron();new(this) AliITSneuron(arg);
		return *this; }
		
								
		/* (NEURON) Destructor: frees memory from dynamic allocated objects */
		virtual ~AliITSneuron()	
			{ fInner = fOuter = 0; fGain->SetOwner(kFALSE); fGain->Clear(); delete fGain; }

		/* Compute neural activation from the network */
		Double_t  Activate(Double_t temperature);
		
		/* Data members references */
		Int_t&        Used()        {return fUsed;}
		Double_t&     Activation()  {return fActivation;}
		AliITSnode*&  Inner()       {return fInner;}
		AliITSnode*&  Outer()       {return fOuter;}
		TObjArray*&   Gain()        {return fGain;}
		
	private:
	
		Int_t             fUsed;        //  utility flag
		Double_t          fActivation;  //  Activation value
		AliITSnode       *fInner;       //! inner point
		AliITSnode       *fOuter;       //! outer point
		TObjArray        *fGain;        //! list of sequenced units
		
	};
	/* End of NEURON class */
	
	
	/**************************************************
	  >> AliITSlink <<
	  ----------------
	  A synaptic connected unit in the neural network.
	 **************************************************/
	class AliITSlink : public TObject {
	public:
	
		AliITSlink():fWeight(0.0),fLinked() {}
		AliITSlink(Double_t w, AliITSneuron *n) : fWeight(w), fLinked(n) { }
		virtual ~AliITSlink() {fLinked = 0;}
		AliITSlink(const AliITSlink &n) : TObject((TObject&)n),fWeight(n.fWeight),fLinked(n.fLinked) {}
		AliITSlink& operator=(const AliITSlink& arg)
		{ this->~AliITSlink();new(this) AliITSlink(arg);
		return *this; }
		
		/* contribution */
		Double_t Contribution() {return fLinked->Activation() * fWeight;}
		
	private:
	
		Double_t      fWeight;  //  Weight value
		AliITSneuron *fLinked;  //! Connected neuron
	
	};
	/* End of AliITSlink class */
	
	/**************************************
	  >> AliITStrackANN <<
	  ----------------
	  A track found by the neural network.
	 **************************************/
	class AliITStrackANN : public TObject {
	public:
	
		AliITStrackANN(Int_t dim = 0);
		AliITStrackANN(const AliITStrackANN &n); 
		AliITStrackANN& operator=(const AliITStrackANN& /*arg*/)
		{ return *this; }
	
		Double_t&  XCenter()                 {return fXCenter;}
		Double_t&  YCenter()                 {return fYCenter;}
		Double_t&  Radius()                  {return fRadius;}
		Double_t&  Curv()                    {return fCurv;}
		Double_t&  ImpactParameterTrans()    {return fDTrans;}
		Double_t&  ImpactParameterLong()     {return fDLong;}
		Double_t&  TanLambda()               {return fTanLambda;}
		Double_t&  Phi()                     {return fPhi;}
		
		AliITSnode* operator[](Int_t i) const {return ((i>=0&&i<fNPoints)?fNode[i]:0);}
		AliITSnode* GetNode(Int_t i) const {return ((i>=0&&i<fNPoints)?fNode[i]:0);}
		void        SetNode(Int_t i, AliITSnode*& ref) {if (i>=0&&i<fNPoints) fNode[i] = ref;}
		
		Int_t  CheckOccupation() const;
		Bool_t RiemannFit();
	
	private:
	
		Int_t      fNPoints;    // nuber of track elements
		
		Double_t   fXCenter;    // X of bending circle center
		Double_t   fYCenter;    // Y of bending circle center
		Double_t   fRadius;     // radius of bending circle
		Double_t   fCurv;       // signed curvature of bending circle 
		Double_t   fDTrans;     // transverse impact parameter
		Double_t   fDLong;      // longitudinal impact parameter
		Double_t   fTanLambda;  // tangent of dip angle
		Double_t   fPhi;        // initial direction of transverse momentum
		
		AliITSnode **fNode;     // pointers to track elements
		
	};
	/* End of AliITStrackANN class */
	
	/* Geometry setter */
	void SetITSgeom(AliITSgeom *geom)             {fGeom = (AliITSgeom*)geom;}
	
	/* Flag setter */
	void SetMessageLevel(Int_t lev)               {fMsgLevel = lev;}
		
	/* Cut setters */
	void SetCuts(Int_t ncurv = 0, Double_t *curv = 0, // curvature (number of cuts and array)
	             Double_t *theta2D = 0,               // cut in theta 2D (rho-z)
                Double_t *theta3D = 0,               // cut in theta 3D (x-y-z)
                Double_t *helix = 0);                // cut for helix-matching
	
	/* Setter for overall Theta cut */
	void SetPolarInterval(Double_t dtheta)        {fPolarInterval=dtheta;}

	/* Neural work-flow setters */
	void SetActThreshold(Double_t val)            {fActMinimum = val;}
	void SetWeightExponent(Double_t a)            {fExponent = a;}
	void SetGainToCostRatio(Double_t a)           {fGain2CostRatio = a;}
	void SetInitInterval(Double_t a, Double_t b)  {fEdge1 = a; fEdge2 = b;}
	void SetTemperature(Double_t a)               {fTemperature = a;}
	void SetVariationLimit(Double_t a)            {fStabThreshold = a;}
	
	/* Vertex setter */
	void SetVertex(Double_t x, Double_t y, Double_t z) {fVertexX=x;fVertexY=y;fVertexZ=z;}
	
	/* Node management for neural network creation */
	Bool_t      GetGlobalXYZ(Int_t refClust, 
	                         Double_t &x, Double_t &y, Double_t &z,
									 Double_t &ex2, Double_t &ey2, Double_t &ez2);
	AliITSnode* AddNode(Int_t index);
	void        CreateArrayStructure(Int_t nsecs);
	Int_t       ArrangePoints(char *exportFile = 0);
	void        StoreOverallMatches();
	Bool_t      PassCurvCut(AliITSnode *p1, AliITSnode *p2, Int_t curvStep, Double_t vx, Double_t vy, Double_t vz);
	Int_t       PassAllCuts(AliITSnode *p1, AliITSnode *p2, Int_t curvStep, Double_t vx, Double_t vy, Double_t vz);
	void        PrintMatches(Bool_t stop = kTRUE);
	
	/* Neural tracking operations */
	// void     NeuralTracking(const char* filesave, TCanvas*& display);
	void     ResetNodes(Int_t isector);
	Int_t    CreateNetwork(Int_t sector, Int_t curvStep);  // create network
	Int_t    CreateNeurons(AliITSnode *node, Int_t curvStep, Double_t vx, Double_t vy, Double_t vz);  // create neurons starting from given point
	Int_t    LinkNeurons();                // create neural connections
	Bool_t   Update();                     // an updating cycle
	void     FollowChains(Int_t sector);   // follows the chains of active neurons
	Int_t    SaveTracks(Int_t sector);     // saves the found tracks
	void     CleanNetwork();               // removes deactivated units and resolve competitions
	//Int_t    Save(Int_t sector);     // save found tracks for # sector
	Int_t    StoreTracks();                // save found tracks for # sector
	
	/* Fit procedures */
	void     ExportTracks(const char *file) const;
	
private:

	/* Neural synaptic weight */
	Double_t Weight(AliITSneuron *nAB, AliITSneuron *nBC); 

	/* Usefuls constant angle values */
	static const Double_t fgkPi; // pi
	static const Double_t fgkHalfPi; // pi / 2
	static const Double_t fgkTwoPi; // 2 * pi
	
	/* Primary vertex position */
	Double_t fVertexX; // X
	Double_t fVertexY; // Y  
	Double_t fVertexZ; // Z
	
	/* ITS barrel sectioning */
	Int_t        fSectorNum;      //  number of azimutal sectors
	Double_t     fSectorWidth;    //  width of barrel sector (in RAD) [used internally]
	Double_t     fPolarInterval;  //  width of a polar sector (in DEGREES)

	/* Cuts */
	Double_t     fThetaCut2D[5];     //  upper edge of theta cut range (in DEGREES)
	Double_t     fThetaCut3D[5];     //  upper edge of theta cut range (in DEGREES)
	Double_t     fHelixMatchCut[5];  //  lower edge of helix matching cut range
	Int_t        fCurvNum;           //  # of curvature cut steps
	Double_t    *fCurvCut;           //! value of all curvature cuts
	
	/* Neural network work-flow parameters */
	Double_t     fActMinimum;      //  minimum activation to turn 'on' the unit at the end
	Double_t     fEdge1, fEdge2;   //  initialization interval for activations
	Double_t     fStabThreshold;   //  stability threshold
	Double_t     fTemperature;     //  slope in logistic function
	Double_t     fGain2CostRatio;  //  ratio between inhibitory and excitory contributions
	Double_t     fExponent;        //  alignment-dependent weight term
	
	/* Object arrays for data storing and related counters */
	Int_t        fNLayers;          //  Number of ITS layers
	Int_t       *fFirstModInLayer;  //! Index of first module index for each layer
	TArrayI    **fIndexMap;         //! Map of cluster indexes (in AliITSlayer) with reference to
	                                //  the location in the cluster Tree (module, pos in array)
	Int_t        fTrackClust[6];    //  Track point in layers
	TObjArray   *fFoundTracks;      //! Found tracks
	TObjArray ***fNodes;            //! recpoints arranged into sectors for processing
	TObjArray   *fNeurons;          //! neurons
	
	/* Flags */ 
	Int_t   fMsgLevel;        // To allow the on-screen printing of messages
	Bool_t  fStructureOK;     // Check if the nested TObjArray structure of nodes is created
	
	/* ALICE related objects */
	AliITSgeom  *fGeom;       //! ITS Geometry
	
	/* ROOT class implementation routines */
	ClassDef(AliITStrackerANN, 1)
};

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