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

#ifndef ALIITSCLUSTERSSD_H
#define ALIITSCLUSTERSSD_H

#include "TObject.h"
#include "TArrayI.h"
#include "TClonesArray.h"

class AliITSdigitSSD;

class AliITSclusterSSD : public TObject
{


//Piotr Krzysztof Skowronski
//Warsaw University of Technology
//skowron@if.pw.edu.pl
//
// Describes set of neighbouring digits on one side of detector,
// that are supposed to be generated by one particle.
// includes information about clusters on other side that it crosses with

public:

  AliITSclusterSSD();    //Default Constructor
  virtual ~AliITSclusterSSD();
  AliITSclusterSSD(Int_t ndigits, Int_t *DigitIndexes, TObjArray *Digits, Bool_t side);		
  AliITSclusterSSD(const AliITSclusterSSD &source); 
  AliITSclusterSSD&  operator=( const AliITSclusterSSD & source);
		
  void            AddDigit(Int_t index){
                                       // //adds on digit
                                       (*fDigitsIndex)[fNDigits++]=index;
                                       } 
  TObjArray*      GetPointer2Digits(){
                                     // comment to be written 
                                     return fDigits;
                                     }

//  TArrayI*        GetDigitsIndexes(Int_t &ndigits);	
//  void            SetDigitIndex(Int_t index);

  void            SetPointer2Digits(TObjArray *digits){
                                                      // comment to be written
                                                      fDigits = digits;
                                                      }
  Int_t           GetNumOfDigits(){
                                  //Returns number of digits that creates this cluster
                                  return fNDigits;
                                  }
  Int_t           GetDigitSignal(Int_t digit);      

  
  AliITSdigitSSD *GetDigit(Int_t idx) {
                                      // comment to be written
                                      return (AliITSdigitSSD *)((*fDigits)[GetDigitIndex(idx)]);
                                      }
  Int_t           GetDigitIndex (Int_t digit) {
                                              // comment to be written
                                              return (*fDigitsIndex)[digit];
                                              }
  Int_t           GetDigitStripNo(Int_t digit);
  Int_t           GetFirstDigitStripNo(){
                                        // comment to be written
                                        return GetDigitStripNo(0);
                                        }
  Int_t           GetLastDigitStripNo(){
                                       // comment to be written
                                       return GetDigitStripNo(fNDigits-1);
                                       }
  Int_t           SplitCluster(Int_t where,Int_t *outdigits); //splits this one side cluster for two
  void            AddCross(Int_t clIndex);  //Add index of cluster that it crosses with
  Int_t           GetCross(Int_t crIndex);  //return index of cluster that it crosses with
  Int_t           GetCrossNo() {
                               // Returns number of crosses
                               return fNCrosses;
                               } 
  void            DelCross(Int_t index);
  
  Double_t        GetPosition();
  Double_t        GetPositionError();
  Float_t         GetTotalSignal();  
  Float_t         GetTotalSignalError();
  void            CutTotalSignal(Float_t sx) {
    // comment to be written
    if (fTotalSignal>sx) fTotalSignal-=sx;
  }
  
  Bool_t      	  GetRightNeighbour() const {
                                            // comment to be written
                                            return fRightNeighbour;
                                            }
  Bool_t      	  GetLeftNeighbour() const {
                                           // comment to be written
                                           return fLeftNeighbour;
                                           }
  void	      	  SetRightNeighbour(Bool_t nei) {
                                           // comment to be written
                                           fRightNeighbour=nei;
                                           }
  void	      	  SetLeftNeighbour(Bool_t nei) {
                                           // comment to be written
                                           fLeftNeighbour=nei;
                                           }

  void   SetNTracks(Int_t ntracks) {
    // set ntracks
    fNTracks=ntracks;
  }


  Int_t          GetNTracks(){
                           // comment to be written
                           return fNTracks;
                           }

  Bool_t          GetSide(){
                           // comment to be written
                           return fSide;
                           }
  Int_t           CheckSatus(Int_t *tracks){
                                           //check if digits comes from the same track
                                           return 0;
                                           }  
  Int_t          *GetTracks(Int_t &nt);
  void            Consume(){
                           // comment
                           fConsumed = kTRUE;
                           }
  Bool_t          IsConsumed() const{ 
                                    // comment
                                    return fConsumed;
                                    }
  Bool_t          IsCrossingWith(Int_t idx);
  
protected:

  Bool_t          fSide;           //True if P
  TObjArray      *fDigits;         //Pointer to List of Digitsbelonging to AliITS
		
  Int_t           fNDigits;        //Number of digits that make up that cluster 
  TArrayI        *fDigitsIndex;    // Digit indexes in fDigits array
		
  Int_t           fNCrosses;       //Number of crossed one side clusters on the other siede 
                                   //   (max 8 : it is not aribtrary)
  TArrayI        *fCrossedClusterIndexes; //Array of inedexes of crossed clusters (in TClonesArray)
                                          // not in TArrayI in package

  Bool_t          fLeftNeighbour;   // comment to be written
  Bool_t          fRightNeighbour;  // comment to be written 
  Bool_t          fConsumed;        // comment to be written
  
  Float_t         fTotalSignal;     // comment to be written
  Int_t           fTrack[10];       // comment to be written
  Int_t           fNTracks;         // comment to be written

  Double_t        CentrOfGravity();
  Double_t        EtaAlgorithm();

private:
								
/*************************************/
/*************************************/						
  ClassDef(AliITSclusterSSD,1)          // Cluster class for reconstructing SSD
};

#endif
Commit	Line	Data
b0f5e3fc	1	#ifndef ALIITSCLUSTERSSD_H
	2	#define ALIITSCLUSTERSSD_H
	3
	4	#include "TObject.h"
	5	#include "TArrayI.h"
b0f5e3fc	6	#include "TClonesArray.h"
b0f5e3fc	7
e8189707	8	class AliITSdigitSSD;
b0f5e3fc	9
	10	class AliITSclusterSSD : public TObject
	11	{
	12
	13
	14	//Piotr Krzysztof Skowronski
	15	//Warsaw University of Technology
	16	//skowron@if.pw.edu.pl
	17	//
	18	// Describes set of neighbouring digits on one side of detector,
	19	// that are supposed to be generated by one particle.
	20	// includes information about clusters on other side that it crosses with
	21
	22	public:
	23
	24	AliITSclusterSSD(); //Default Constructor
766ef0c8	25	virtual ~AliITSclusterSSD();
b0f5e3fc	26	AliITSclusterSSD(Int_t ndigits, Int_t DigitIndexes, TObjArray Digits, Bool_t side);
	27	AliITSclusterSSD(const AliITSclusterSSD &source);
	28	AliITSclusterSSD& operator=( const AliITSclusterSSD & source);
	29
	30	void AddDigit(Int_t index){
	31	// //adds on digit
	32	(*fDigitsIndex)[fNDigits++]=index;
	33	}
	34	TObjArray* GetPointer2Digits(){
	35	// comment to be written
	36	return fDigits;
	37	}
	38
	39	// TArrayI* GetDigitsIndexes(Int_t &ndigits);
	40	// void SetDigitIndex(Int_t index);
	41
	42	void SetPointer2Digits(TObjArray *digits){
	43	// comment to be written
	44	fDigits = digits;
	45	}
	46	Int_t GetNumOfDigits(){
	47	//Returns number of digits that creates this cluster
	48	return fNDigits;
	49	}
	50	Int_t GetDigitSignal(Int_t digit);
	51
	52
	53	AliITSdigitSSD *GetDigit(Int_t idx) {
	54	// comment to be written
	55	return (AliITSdigitSSD )((fDigits)[GetDigitIndex(idx)]);
	56	}
	57	Int_t GetDigitIndex (Int_t digit) {
	58	// comment to be written
	59	return (*fDigitsIndex)[digit];
	60	}
	61	Int_t GetDigitStripNo(Int_t digit);
	62	Int_t GetFirstDigitStripNo(){
	63	// comment to be written
	64	return GetDigitStripNo(0);
	65	}
	66	Int_t GetLastDigitStripNo(){
	67	// comment to be written
	68	return GetDigitStripNo(fNDigits-1);
	69	}
	70	Int_t SplitCluster(Int_t where,Int_t *outdigits); //splits this one side cluster for two
	71	void AddCross(Int_t clIndex); //Add index of cluster that it crosses with
	72	Int_t GetCross(Int_t crIndex); //return index of cluster that it crosses with
	73	Int_t GetCrossNo() {
	74	// Returns number of crosses
	75	return fNCrosses;
	76	}
	77	void DelCross(Int_t index);
	78
	79	Double_t GetPosition();
	80	Double_t GetPositionError();
	81	Float_t GetTotalSignal();
	82	Float_t GetTotalSignalError();
	83	void CutTotalSignal(Float_t sx) {
	84	// comment to be written
	85	if (fTotalSignal>sx) fTotalSignal-=sx;
	86	}
	87
	88	Bool_t GetRightNeighbour() const {
	89	// comment to be written
90	return fRightNeighbour;
91	}
92	Bool_t GetLeftNeighbour() const {
93	// comment to be written
94	return fLeftNeighbour;
95	}
96	void SetRightNeighbour(Bool_t nei) {
97	// comment to be written
98	fRightNeighbour=nei;
99	}
100	void SetLeftNeighbour(Bool_t nei) {
101	// comment to be written
102	fLeftNeighbour=nei;
103	}
f239b2fe	104
	105	void SetNTracks(Int_t ntracks) {
	106	// set ntracks
	107	fNTracks=ntracks;
	108	}
	109
	110
	111	Int_t GetNTracks(){
	112	// comment to be written
	113	return fNTracks;
	114	}
	115
b0f5e3fc	116	Bool_t GetSide(){
	117	// comment to be written
	118	return fSide;
	119	}
	120	Int_t CheckSatus(Int_t *tracks){
	121	//check if digits comes from the same track
	122	return 0;
	123	}
	124	Int_t *GetTracks(Int_t &nt);
	125	void Consume(){
	126	// comment
	127	fConsumed = kTRUE;
	128	}
	129	Bool_t IsConsumed() const{
	130	// comment
	131	return fConsumed;
	132	}
	133	Bool_t IsCrossingWith(Int_t idx);
	134
	135	protected:
	136
	137	Bool_t fSide; //True if P
	138	TObjArray *fDigits; //Pointer to List of Digitsbelonging to AliITS
	139
	140	Int_t fNDigits; //Number of digits that make up that cluster
	141	TArrayI *fDigitsIndex; // Digit indexes in fDigits array
	142
	143	Int_t fNCrosses; //Number of crossed one side clusters on the other siede
	144	// (max 8 : it is not aribtrary)
	145	TArrayI *fCrossedClusterIndexes; //Array of inedexes of crossed clusters (in TClonesArray)
	146	// not in TArrayI in package
	147
	148	Bool_t fLeftNeighbour; // comment to be written
	149	Bool_t fRightNeighbour; // comment to be written
	150	Bool_t fConsumed; // comment to be written
	151
	152	Float_t fTotalSignal; // comment to be written
	153	Int_t fTrack[10]; // comment to be written
f239b2fe	154	Int_t fNTracks; // comment to be written
b0f5e3fc	155
	156	Double_t CentrOfGravity();
	157	Double_t EtaAlgorithm();
	158
	159	private:
	160
	161	/*************************************/
	162	/*************************************/
766ef0c8	163	ClassDef(AliITSclusterSSD,1) // Cluster class for reconstructing SSD
b0f5e3fc	164	};
	165
	166	#endif