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

///////////////////////////////////////////////////////////////////////
//
// AliITSneuralTracker:
//
// neural network MFT algorithm
// for track finding in ITS stand alone
// according to the Denby-Peterson model with adaptments to the
// ALICE multiplicity
//
///////////////////////////////////////////////////////////////////////

#ifndef ALIITSNEURALTRACKER_H
#define ALIITSNEURALTRACKER_H

class TObjArray;
class TCanvas;

#include "AliITSNeuralPoint.h"

class AliITSNeuralTracker : public TObject {

public:

	AliITSNeuralTracker();
	AliITSNeuralTracker(const AliITSNeuralTracker &t);
	AliITSNeuralTracker& operator=(const AliITSNeuralTracker&);
	
	virtual ~AliITSNeuralTracker();

	// ******************************************************************************
	// * Embedded utility class --> >>> NODE <<<
	// ******************************************************************************
	// * This class inherits from AliITSNeuralPoint and adds some
	// * utility pointers for quick path-finding among neurons.
	// ******************************************************************************
	class AliITSNode : public AliITSNeuralPoint {
	public:
		AliITSNode() {fInnerOf = fOuterOf = fMatches = 0; fNext = fPrev = 0;}
		AliITSNode(const AliITSNode &t);
		AliITSNode(AliITSNeuralPoint *p, Bool_t init = kTRUE) // declared inline
			: AliITSNeuralPoint(p) { fInnerOf = fOuterOf = fMatches = 0; fNext = fPrev = 0;
			if (init) { fInnerOf = new TObjArray; fOuterOf = new TObjArray; fMatches = new TObjArray;}}
		AliITSNode(AliITSRecPoint *p, AliITSgeomMatrix *gm)
			: AliITSNeuralPoint(p,gm) {fInnerOf = fOuterOf = fMatches = 0; fNext = fPrev = 0;}

		virtual  ~AliITSNode() 
			{fInnerOf = fOuterOf = fMatches = 0; fNext = fPrev = 0;}
			
		AliITSNode& operator=(const AliITSNode&);
		
		Double_t  ThetaDeg()                    {return GetTheta()*180.0/TMath::Pi();}

		Int_t     GetSector(Double_t secwidth) const {return (Int_t)(GetPhi()/secwidth);}
		Int_t     GetThetaCell()                {return (Int_t)(ThetaDeg());}
		
		Int_t&     PosInTree() {return fPosInTree;}
		
		TObjArray*&  InnerOf() {return fInnerOf;}
		TObjArray*&  OuterOf() {return fOuterOf;}
		TObjArray*&  Matches() {return fMatches;}
		
		AliITSNode*& Next() {return fNext;}
		AliITSNode*& Prev() {return fPrev;}
		
	private:
		
		Int_t        fPosInTree;  // position in tree of converted points

		TObjArray   *fInnerOf; //!
		TObjArray   *fOuterOf; //! 
		TObjArray   *fMatches; //!

		AliITSNode  *fNext; //!
		AliITSNode  *fPrev; //!
	};
	// ******************************************************************************


	// ******************************************************************************
	// * Embedded utility class --> >>> NEURON <<<
	// ******************************************************************************
	// * Simple class implementing the neural unit.
	// * Contains the activation and some other pointers
	// * for purposes similar to the ones in AliITSnode.
	// ******************************************************************************
	class AliITSneuron : public TObject {
	public:
		AliITSneuron():fUsed(0),fActivation(0.),fInner(0),fOuter(0),fGain(0) { }
		AliITSneuron(const AliITSneuron &t); 
		virtual    ~AliITSneuron() {fInner=fOuter=0;fGain=0;}
		
		AliITSneuron& operator=(const AliITSneuron&);

		Double_t    Weight(AliITSneuron *n);
		void        Add2Gain(AliITSneuron *n, Double_t multconst, Double_t exponent);
		
		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
	};
	// ******************************************************************************


	// ******************************************************************************
	// * Embedded utility class --> >>> CONNECTION <<<
	// ******************************************************************************
	// * Used to implement the neural weighted connection
	// * in such a way to speed up the retrieval of the
	// * links among neuron, for a fast update procedure.
	// ******************************************************************************
	class AliITSlink : public TObject {
	public:
		AliITSlink() : fWeight(0.), fLinked(0) { }
		AliITSlink(const AliITSlink &t);
		virtual ~AliITSlink()   {fLinked = 0;}
		
		AliITSlink& operator=(const AliITSlink&);
		
		Double_t& Weight() {return fWeight;}
		AliITSneuron*& Linked() {return fLinked;}
		
	private:

		Double_t      fWeight;  //  Weight value
		AliITSneuron *fLinked;  //! the connected neuron
	};
	// ******************************************************************************


	// Cut related setters

	void     SetHelixMatchCuts(Double_t *min, Double_t *max);
	void     SetThetaCuts2D(Double_t *min, Double_t *max);
	void     SetThetaCuts3D(Double_t *min, Double_t *max);
	void     SetCurvatureCuts(Int_t n, Double_t *cuts);
	void     SetVertex(Double_t x, Double_t y, Double_t z)  {fVX=x; fVY=y; fVZ=z;}
	void     SetPolarInterval(Double_t dtheta) {fPolarInterval=dtheta;}

	// Neural work-flow related setters

	void     SetActThreshold(Double_t val)            {fActMinimum = val;}
	void     SetWeightExponent(Double_t a)            {fAlignExponent = 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;}

	// Points array arrangement & control

	void     CreateArrayStructure(Int_t nsecs);
	Int_t    ArrangePoints(TTree *ptstree);
	void     StoreAbsoluteMatches();
	Bool_t   PassCurvCut(AliITSNode *p1, AliITSNode *p2, Int_t curvidx, Double_t vx, Double_t vy, Double_t vz);
	Int_t    PassAllCuts(AliITSNode *p1, AliITSNode *p2, Int_t curvidx, Double_t vx, Double_t vy, Double_t vz);
	void     PrintPoints();
	void     PrintMatches(Bool_t stop = kTRUE);

	// Neural tracker work-flow

	void     NeuralTracking(const char* filesave, TCanvas*& display);
	void     Display(TCanvas*& canvas) const;
	void     ResetNodes(Int_t isector);
	Int_t    CreateNeurons(Int_t sector, Int_t curv);  // create neurons
	Int_t    LinkNeurons() const;          // create neural connections
	Double_t Activate(AliITSneuron* &n);   // calculates the new neural activation
	Bool_t   Update();                     // an updating cycle
	void     CleanNetwork();               // removes deactivated units and resolves competitions
	Int_t    Save(Int_t sectoridx);        // save found tracks for # sector
	TTree*   GetChains()                   {return fChains;}
	void     WriteChains()                 {fChains->Write();}

private:

	Bool_t       CheckOccupation() const; 

	Int_t        fSectorNum;            //  number of azymuthal sectors
	Double_t     fSectorWidth;          //  width of an azymuthal sector (in RADIANS) [used internally]
	Double_t     fPolarInterval;        //  width of a polar sector (in DEGREES)

	Double_t     fThetaCut2DMin[5];     //  lower edge of theta cut range (in DEGREES)
	Double_t     fThetaCut2DMax[5];     //  upper edge of theta cut range (in DEGREES)
	Double_t     fThetaCut3DMin[5];     //  lower edge of theta cut range (in DEGREES)
	Double_t     fThetaCut3DMax[5];     //  upper edge of theta cut range (in DEGREES)
	Double_t     fHelixMatchCutMin[5];  //  lower edge of helix matching cut range
	Double_t     fHelixMatchCutMax[5];  //  lower edge of helix matching cut range
	Int_t        fCurvNum;              //  # of curvature cut steps
	Double_t    *fCurvCut;              //! value of all curvature cuts

	Bool_t       fStructureOK;          // flag to avoid MANY segfault errors

	Double_t     fVX, fVY, fVZ;         //  estimated vertex coords (for helix matching cut)

	Double_t     fActMinimum;           //  minimum activation to turn 'on' the unit at the end
	Double_t     fEdge1, fEdge2;        //  initialization interval for activations

	Double_t     fTemperature;          //  logistic function temperature parameter
	Double_t     fStabThreshold;        //  stability threshold
	Double_t     fGain2CostRatio;       //  ratio between inhibitory and excitory contributions
	Double_t     fAlignExponent;        //  alignment-dependent weight term

	Int_t        fPoint[6];             //  Track point in layers
	TTree       *fChains;               //! Output tree

	TObjArray   *fPoints[6][180];       //! recpoints arranged into sectors for processing
	TObjArray   *fNeurons;              //! neurons

	ClassDef(AliITSNeuralTracker, 1)
};


////////////////////////////////////////////////////////////////////////////////

#endif
Commit	Line	Data
b9d722bc	1	///////////////////////////////////////////////////////////////////////
	2	//
	3	// AliITSneuralTracker:
	4	//
	5	// neural network MFT algorithm
	6	// for track finding in ITS stand alone
	7	// according to the Denby-Peterson model with adaptments to the
	8	// ALICE multiplicity
	9	//
	10	///////////////////////////////////////////////////////////////////////
	11
ddcce466	12	#ifndef ALIITSNEURALTRACKER_H
	13	#define ALIITSNEURALTRACKER_H
	14
	15	class TObjArray;
	16	class TCanvas;
	17
	18	#include "AliITSNeuralPoint.h"
	19
b9d722bc	20	class AliITSNeuralTracker : public TObject {
	21
	22	public:
	23
ddcce466	24	AliITSNeuralTracker();
	25	AliITSNeuralTracker(const AliITSNeuralTracker &t);
	26	AliITSNeuralTracker& operator=(const AliITSNeuralTracker&);
	27
b9d722bc	28	virtual ~AliITSNeuralTracker();
	29
	30	// ******************************************************************************
	31	// * Embedded utility class --> >>> NODE <<<
	32	// ******************************************************************************
	33	// * This class inherits from AliITSNeuralPoint and adds some
	34	// * utility pointers for quick path-finding among neurons.
	35	// ******************************************************************************
	36	class AliITSNode : public AliITSNeuralPoint {
	37	public:
ddcce466	38	AliITSNode() {fInnerOf = fOuterOf = fMatches = 0; fNext = fPrev = 0;}
ddcce466	39	AliITSNode(const AliITSNode &t);
b9d722bc	40	AliITSNode(AliITSNeuralPoint *p, Bool_t init = kTRUE) // declared inline
ddcce466	41	: AliITSNeuralPoint(p) { fInnerOf = fOuterOf = fMatches = 0; fNext = fPrev = 0;
ddcce466	42	if (init) { fInnerOf = new TObjArray; fOuterOf = new TObjArray; fMatches = new TObjArray;}}
b9d722bc	43	AliITSNode(AliITSRecPoint p, AliITSgeomMatrix gm)
ddcce466	44	: AliITSNeuralPoint(p,gm) {fInnerOf = fOuterOf = fMatches = 0; fNext = fPrev = 0;}
b9d722bc	45
	46	virtual ~AliITSNode()
	47	{fInnerOf = fOuterOf = fMatches = 0; fNext = fPrev = 0;}
ddcce466	48
	49	AliITSNode& operator=(const AliITSNode&);
	50
b9d722bc	51	Double_t ThetaDeg() {return GetTheta()*180.0/TMath::Pi();}
b9d722bc	52
ddcce466	53	Int_t GetSector(Double_t secwidth) const {return (Int_t)(GetPhi()/secwidth);}
b9d722bc	54	Int_t GetThetaCell() {return (Int_t)(ThetaDeg());}
b9d722bc	55
ddcce466	56	Int_t& PosInTree() {return fPosInTree;}
	57
	58	TObjArray*& InnerOf() {return fInnerOf;}
	59	TObjArray*& OuterOf() {return fOuterOf;}
	60	TObjArray*& Matches() {return fMatches;}
	61
	62	AliITSNode*& Next() {return fNext;}
	63	AliITSNode*& Prev() {return fPrev;}
	64
	65	private:
	66
853a0f19	67	Int_t fPosInTree; // position in tree of converted points
b9d722bc	68
	69	TObjArray *fInnerOf; //!
	70	TObjArray *fOuterOf; //!
	71	TObjArray *fMatches; //!
	72
	73	AliITSNode *fNext; //!
	74	AliITSNode *fPrev; //!
	75	};
	76	// ******************************************************************************
	77
	78
	79
	80	// ******************************************************************************
	81	// * Embedded utility class --> >>> NEURON <<<
	82	// ******************************************************************************
	83	// * Simple class implementing the neural unit.
	84	// * Contains the activation and some other pointers
	85	// * for purposes similar to the ones in AliITSnode.
	86	// ******************************************************************************
	87	class AliITSneuron : public TObject {
	88	public:
ddcce466	89	AliITSneuron():fUsed(0),fActivation(0.),fInner(0),fOuter(0),fGain(0) { }
ddcce466	90	AliITSneuron(const AliITSneuron &t);
b9d722bc	91	virtual ~AliITSneuron() {fInner=fOuter=0;fGain=0;}
ddcce466	92
ddcce466	93	AliITSneuron& operator=(const AliITSneuron&);
b9d722bc	94
b9d722bc	95	Double_t Weight(AliITSneuron *n);
ddcce466	96	void Add2Gain(AliITSneuron *n, Double_t multconst, Double_t exponent);
	97
	98	Int_t& Used() {return fUsed;}
	99	Double_t& Activation() {return fActivation;}
	100	AliITSNode*& Inner() {return fInner;}
	101	AliITSNode*& Outer() {return fOuter;}
	102	TObjArray*& Gain() {return fGain;}
	103
	104	private:
b9d722bc	105
	106	Int_t fUsed; // utility flag
	107	Double_t fActivation; // Activation value
	108	AliITSNode *fInner; //! inner point
	109	AliITSNode *fOuter; //! outer point
	110	TObjArray *fGain; //! list of sequenced units
	111	};
	112	// ******************************************************************************
	113
	114
	115
	116	// ******************************************************************************
	117	// * Embedded utility class --> >>> CONNECTION <<<
	118	// ******************************************************************************
	119	// * Used to implement the neural weighted connection
	120	// * in such a way to speed up the retrieval of the
	121	// * links among neuron, for a fast update procedure.
	122	// ******************************************************************************
	123	class AliITSlink : public TObject {
	124	public:
ddcce466	125	AliITSlink() : fWeight(0.), fLinked(0) { }
ddcce466	126	AliITSlink(const AliITSlink &t);
b9d722bc	127	virtual ~AliITSlink() {fLinked = 0;}
ddcce466	128
	129	AliITSlink& operator=(const AliITSlink&);
	130
	131	Double_t& Weight() {return fWeight;}
	132	AliITSneuron*& Linked() {return fLinked;}
	133
	134	private:
b9d722bc	135
	136	Double_t fWeight; // Weight value
	137	AliITSneuron *fLinked; //! the connected neuron
	138	};
	139	// ******************************************************************************
	140
	141
	142	// Cut related setters
	143
	144	void SetHelixMatchCuts(Double_t min, Double_t max);
	145	void SetThetaCuts2D(Double_t min, Double_t max);
	146	void SetThetaCuts3D(Double_t min, Double_t max);
	147	void SetCurvatureCuts(Int_t n, Double_t *cuts);
	148	void SetVertex(Double_t x, Double_t y, Double_t z) {fVX=x; fVY=y; fVZ=z;}
	149	void SetPolarInterval(Double_t dtheta) {fPolarInterval=dtheta;}
	150
	151	// Neural work-flow related setters
	152
	153	void SetActThreshold(Double_t val) {fActMinimum = val;}
	154	void SetWeightExponent(Double_t a) {fAlignExponent = a;}
	155	void SetGainToCostRatio(Double_t a) {fGain2CostRatio = a;}
	156	void SetInitInterval(Double_t a, Double_t b) {fEdge1 = a; fEdge2 = b;}
	157	void SetTemperature(Double_t a) {fTemperature = a;}
	158	void SetVariationLimit(Double_t a) {fStabThreshold = a;}
	159
	160	// Points array arrangement & control
	161
	162	void CreateArrayStructure(Int_t nsecs);
ddcce466	163	Int_t ArrangePoints(TTree *ptstree);
b9d722bc	164	void StoreAbsoluteMatches();
ddcce466	165	Bool_t PassCurvCut(AliITSNode p1, AliITSNode p2, Int_t curvidx, Double_t vx, Double_t vy, Double_t vz);
ddcce466	166	Int_t PassAllCuts(AliITSNode p1, AliITSNode p2, Int_t curvidx, Double_t vx, Double_t vy, Double_t vz);
b9d722bc	167	void PrintPoints();
	168	void PrintMatches(Bool_t stop = kTRUE);
	169
	170	// Neural tracker work-flow
	171
	172	void NeuralTracking(const char* filesave, TCanvas*& display);
853a0f19	173	void Display(TCanvas*& canvas) const;
b9d722bc	174	void ResetNodes(Int_t isector);
b9d722bc	175	Int_t CreateNeurons(Int_t sector, Int_t curv); // create neurons
853a0f19	176	Int_t LinkNeurons() const; // create neural connections
b9d722bc	177	Double_t Activate(AliITSneuron* &n); // calculates the new neural activation
	178	Bool_t Update(); // an updating cycle
	179	void CleanNetwork(); // removes deactivated units and resolves competitions
ddcce466	180	Int_t Save(Int_t sectoridx); // save found tracks for # sector
b9d722bc	181	TTree* GetChains() {return fChains;}
	182	void WriteChains() {fChains->Write();}
	183
	184	private:
	185
853a0f19	186	Bool_t CheckOccupation() const;
b9d722bc	187
	188	Int_t fSectorNum; // number of azymuthal sectors
	189	Double_t fSectorWidth; // width of an azymuthal sector (in RADIANS) [used internally]
	190	Double_t fPolarInterval; // width of a polar sector (in DEGREES)
	191
	192	Double_t fThetaCut2DMin[5]; // lower edge of theta cut range (in DEGREES)
	193	Double_t fThetaCut2DMax[5]; // upper edge of theta cut range (in DEGREES)
	194	Double_t fThetaCut3DMin[5]; // lower edge of theta cut range (in DEGREES)
	195	Double_t fThetaCut3DMax[5]; // upper edge of theta cut range (in DEGREES)
	196	Double_t fHelixMatchCutMin[5]; // lower edge of helix matching cut range
	197	Double_t fHelixMatchCutMax[5]; // lower edge of helix matching cut range
	198	Int_t fCurvNum; // # of curvature cut steps
	199	Double_t *fCurvCut; //! value of all curvature cuts
	200
	201	Bool_t fStructureOK; // flag to avoid MANY segfault errors
	202
	203	Double_t fVX, fVY, fVZ; // estimated vertex coords (for helix matching cut)
	204
	205	Double_t fActMinimum; // minimum activation to turn 'on' the unit at the end
	206	Double_t fEdge1, fEdge2; // initialization interval for activations
	207
	208	Double_t fTemperature; // logistic function temperature parameter
	209	Double_t fStabThreshold; // stability threshold
	210	Double_t fGain2CostRatio; // ratio between inhibitory and excitory contributions
	211	Double_t fAlignExponent; // alignment-dependent weight term
	212
	213	Int_t fPoint[6]; // Track point in layers
	214	TTree *fChains; //! Output tree
	215
	216	TObjArray *fPoints[6][180]; //! recpoints arranged into sectors for processing
	217	TObjArray *fNeurons; //! neurons
	218
	219	ClassDef(AliITSNeuralTracker, 1)
	220	};
	221
	222
	223	////////////////////////////////////////////////////////////////////////////////
	224
	225	#endif