[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 <TTree.h>

#include "AliITSNeuralPoint.h"

class AliITSNeuralTracker : public TObject {

public:

	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():fPosInTree(0),fInnerOf(0),fOuterOf(0),fMatches(0),fNext(0),fPrev(0){}
		
		AliITSNode(AliITSNeuralPoint *p, Bool_t init = kTRUE): AliITSNeuralPoint(p),fPosInTree(0),fInnerOf(0),fOuterOf(0),fMatches(0),fNext(0),fPrev(0) {
			if (init) { fInnerOf = new TObjArray; fOuterOf = new TObjArray; fMatches = new TObjArray;}}
		AliITSNode(AliITSRecPoint *p, AliITSgeomMatrix *gm)
			: AliITSNeuralPoint(p,gm),fPosInTree(0),fInnerOf(0),fOuterOf(0),fMatches(0),fNext(0),fPrev(0) {}

		virtual  ~AliITSNode() 
			{fInnerOf = fOuterOf = fMatches = 0; fNext = fPrev = 0;}
			
	
		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:
		AliITSNode(const AliITSNode &t);
		AliITSNode& operator=(const AliITSNode& t);
		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) { }
		
		virtual    ~AliITSneuron() {fInner=fOuter=0;fGain=0;}
		
		
		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:

		AliITSneuron(const AliITSneuron &t); 
		AliITSneuron& operator=(const AliITSneuron& t);

		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) { }
		
		virtual ~AliITSlink()   {fLinked = 0;}
				
		
		Double_t& Weight() {return fWeight;}
		AliITSneuron*& Linked() {return fLinked;}
		
	private:
		
		AliITSlink(const AliITSlink &t);
		AliITSlink& operator=(const AliITSlink& t);

		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() const             {return fChains;}
	void     WriteChains()                 {fChains->Write();}

private:

	AliITSNeuralTracker(const AliITSNeuralTracker &n);
	AliITSNeuralTracker& operator=(const AliITSNeuralTracker& t);

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