[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUCATrackingStation.h

//-*- Mode: C++ -*-
// ************************************************************************
// This file is property of and copyright by the ALICE ITSU Project       *
// ALICE Experiment at CERN, All rights reserved.                         *
// See cxx source for full Copyright notice                               *
//                                                                        *
//*************************************************************************

#ifndef ALIITSUCATRACKINGSTATION_H
#define ALIITSUCATRACKINGSTATION_H

#include <algorithm>
#include <vector>
#include <TObject.h>
#include <TClonesArray.h>
#include "AliITSURecoLayer.h"
#include "AliITSUClusterPix.h"
#include <assert.h>

class AliVertex;

class AliITSUCATrackingStation
{
  
public:
  struct ClsInfo   // cluster info, optionally XY origin at vertex
  {
    float x,y,z,phi,r;    // lab params
    int   zphibin; // bins is z,phi
    int   index;          // index in RecPoints array
    int   detid;          // detector index //RS ??? Do we need it?
    bool operator<(const ClsInfo &rhs) const {return zphibin < rhs.zphibin;}
    //
  };
  typedef struct ClsInfo ClsInfo_t;
  //
  struct ClBinInfo  // info on bin clusters start, number of clusters
  {
    unsigned short ncl;    // number of clusters
    unsigned short first;  // entry of 1st cluster in sorted vector of ClsInfo
    int            index;  // index in the vector containing cells with non-0 occupancy
  };
  typedef struct ClBinInfo ClBinInfo_t;
  //
  struct ITSDetInfo  // info on sensor
  {
    int index; // sensor vid
    float xTF,xTFmisal,phiTF,sinTF,cosTF; //tracking frame parameters of the detector
  };
  typedef struct ITSDetInfo ITSDetInfo_t;
  
  
  AliITSUCATrackingStation();
  AliITSUCATrackingStation(int nzbins,int nphibins, AliITSURecoLayer *lr, AliITSUGeomTGeo *geo);
  virtual ~AliITSUCATrackingStation();
  AliITSUCATrackingStation::ClsInfo_t* operator[](int i) const
    {return (AliITSUCATrackingStation::ClsInfo_t*)&fSortedClInfo[i];}
  //
  int     GetVIDOffset()                const {return fVIDOffset;}
  int     GetNClusters()                const {return fNClusters;}
  int     GetNZBins()                   const {return fNZBins;}
  int     GetNPhiBins()                 const {return fNPhiBins;}
  float   GetZMin()                     const {return fZMin;}
  float   GetZMax()                     const {return fZMax;}
  //
  void    SetNZBins(int v)                    {fNZBins = v;}
  void    SetNPhiBins(int v)                  {fNPhiBins = v;}
  void    SetZMin(float v)                    {fZMin = v;}
  void    SetZMax(float v)                    {fZMax = v;}
  //
  void Init(AliITSURecoLayer *lr, AliITSUGeomTGeo *geo);
  //
  void SortClusters(const AliVertex* vtx = 0);
  int  GetPhiBin(float phi)             const {return phi * fDPhiInv;}
  int  GetZBin  (float z)               const {return (z - fZMin) * fDZInv;}
  int  GetBinIndex(int iz, int iphi)    const {return iphi * fNZBins + iz;}
  int  GetBinZ(int ipz)                 const {return ipz % fNZBins;}
  int  GetBinPhi(int ipz)               const {return ipz / fNZBins;}
  void GetBinZPhi(int ipz,int &iz,int &iphi) const {iz = GetBinZ(ipz); iphi=GetBinPhi(ipz);}
  //
  int  SelectClusters(float zmin,float zmax,float phimin,float phimax);
  int  GetNFoundBins()                  const {return fFoundBins.size();}
  int  GetFoundBin(int i)               const {return fFoundBins[i];}
  int  GetFoundBinClusters(int i, int &first)  const;
  void ResetFoundIterator();
  AliITSUCATrackingStation::ClsInfo_t* GetClusterInfo(int i) const
    {return (AliITSUCATrackingStation::ClsInfo_t*)&fSortedClInfo[i];}
  AliITSUCATrackingStation::ClsInfo_t* GetNextClusterInfo();
  int                     GetNextClusterInfoID();
  AliITSUClusterPix*         GetNextCluster();
  AliITSUClusterPix*         GetClusterSorted(int i)   const
    {return (AliITSUClusterPix*)fClusters->UncheckedAt(fSortedClInfo[i].index);}
  AliITSUClusterPix*         GetClusterUnSorted(int i) const
    {return (AliITSUClusterPix*)fClusters->UncheckedAt(i);}
  //
  AliITSUCATrackingStation::ITSDetInfo_t& GetDetInfo(int id)     const
  {assert(fIndex[id] > -1 && "Empty sensor");return (ITSDetInfo_t&)fDetectors[fIndex[id]];}
  int                   GetNDetectors()           const
    {return fDetectors.size();}
  
  void         ClearSortedInfo();
  virtual void Clear(Option_t *opt="");
  virtual void Print(Option_t *opt="")  const;
  
protected:
  AliITSUCATrackingStation(const AliITSUCATrackingStation &);
  AliITSUCATrackingStation &operator=(const AliITSUCATrackingStation &);
  TClonesArray* fClusters;    // externally supplied clusters
  int   fVIDOffset;           // offset of VID for detectors of this layer
  int   fNClusters;           // N clusters
  //
  float fZMin;                // Zmin
  float fZMax;                // Zmax
  float fDZInv;               // inverse size of Z bin
  float fDPhiInv;             // inverse size of Phi bin
  int   fNZBins;             // N cells in Z
  int   fNPhiBins;           // N cells in Phi
  //
  int   fQueryZBmin;         // min bin in Z of the query
  int   fQueryZBmax;         // max bin in Z of the query
  int   fQueryPhiBmin;       // min bin in phi of the query
  int   fQueryPhiBmax;       // max bin in phi of the query
  ClBinInfo_t* fBins;           // 2D (z,phi) grid of clusters binned in z,phi
  int* fOccBins;              // id's of bins with non-0 occupancy
  int  fNOccBins;             // number of occupied bins
  int  fNFoundClusters;       // number of found clusters in the query zone
  int  fFoundClusterIterator; // at which cluster within the bin we are?
  int  fFoundBinIterator;     // at which foune bin we are?
  std::vector<int>     fIndex;
  std::vector<int>     fFoundBins;    // occupied bins satisfying to query
  std::vector<ClsInfo_t> fSortedClInfo; // processed cluster info
  std::vector<ITSDetInfo_t> fDetectors; // detector params
  //
};

//_____________________________________________________
inline int AliITSUCATrackingStation::GetFoundBinClusters(int i, int &first)  const {
  // set the entry of the first cl.info in the fSortedClInfo
  // and return n clusters in the bin
  ClBinInfo_t& bin = fBins[GetFoundBin(i)];
  first = bin.first;
  return bin.ncl;
}

//_____________________________________________________
inline AliITSUClusterPix* AliITSUCATrackingStation::GetNextCluster() {
  // return next cluster
  ClsInfo_t* cli = GetNextClusterInfo();
  return cli ? (AliITSUClusterPix*)fClusters->UncheckedAt(cli->index) : 0;
}

//_____________________________________________________________
inline AliITSUCATrackingStation::ClsInfo_t* AliITSUCATrackingStation::GetNextClusterInfo()
{
  // return cluster info for next matching cluster
  int id = GetNextClusterInfoID();
  return id < 0 ? 0 : (AliITSUCATrackingStation::ClsInfo_t*)&fSortedClInfo[id];
}

#endif
Commit	Line	Data
14fb7846	1	//-- Mode: C++ --
	2	// ************************************************************************
	3	// This file is property of and copyright by the ALICE ITSU Project *
	4	// ALICE Experiment at CERN, All rights reserved. *
	5	// See cxx source for full Copyright notice *
	6	// *
	7	//*************************************************************************
	8
	9	#ifndef ALIITSUCATRACKINGSTATION_H
	10	#define ALIITSUCATRACKINGSTATION_H
	11
	12	#include <algorithm>
	13	#include <vector>
	14	#include <TObject.h>
	15	#include <TClonesArray.h>
	16	#include "AliITSURecoLayer.h"
	17	#include "AliITSUClusterPix.h"
	18	#include <assert.h>
	19
	20	class AliVertex;
	21
	22	class AliITSUCATrackingStation
	23	{
	24
	25	public:
	26	struct ClsInfo // cluster info, optionally XY origin at vertex
	27	{
	28	float x,y,z,phi,r; // lab params
	29	int zphibin; // bins is z,phi
	30	int index; // index in RecPoints array
	31	int detid; // detector index //RS ??? Do we need it?
	32	bool operator<(const ClsInfo &rhs) const {return zphibin < rhs.zphibin;}
	33	//
	34	};
	35	typedef struct ClsInfo ClsInfo_t;
	36	//
	37	struct ClBinInfo // info on bin clusters start, number of clusters
	38	{
	39	unsigned short ncl; // number of clusters
	40	unsigned short first; // entry of 1st cluster in sorted vector of ClsInfo
	41	int index; // index in the vector containing cells with non-0 occupancy
	42	};
	43	typedef struct ClBinInfo ClBinInfo_t;
	44	//
	45	struct ITSDetInfo // info on sensor
	46	{
	47	int index; // sensor vid
	48	float xTF,xTFmisal,phiTF,sinTF,cosTF; //tracking frame parameters of the detector
	49	};
	50	typedef struct ITSDetInfo ITSDetInfo_t;
	51
	52
	53	AliITSUCATrackingStation();
	54	AliITSUCATrackingStation(int nzbins,int nphibins, AliITSURecoLayer lr, AliITSUGeomTGeo geo);
	55	virtual ~AliITSUCATrackingStation();
	56	AliITSUCATrackingStation::ClsInfo_t* operator[](int i) const
	57	{return (AliITSUCATrackingStation::ClsInfo_t*)&fSortedClInfo[i];}
	58	//
	59	int GetVIDOffset() const {return fVIDOffset;}
	60	int GetNClusters() const {return fNClusters;}
	61	int GetNZBins() const {return fNZBins;}
	62	int GetNPhiBins() const {return fNPhiBins;}
	63	float GetZMin() const {return fZMin;}
	64	float GetZMax() const {return fZMax;}
65	//
66	void SetNZBins(int v) {fNZBins = v;}
67	void SetNPhiBins(int v) {fNPhiBins = v;}
68	void SetZMin(float v) {fZMin = v;}
69	void SetZMax(float v) {fZMax = v;}
70	//
71	void Init(AliITSURecoLayer lr, AliITSUGeomTGeo geo);
72	//
73	void SortClusters(const AliVertex* vtx = 0);
74	int GetPhiBin(float phi) const {return phi * fDPhiInv;}
75	int GetZBin (float z) const {return (z - fZMin) * fDZInv;}
76	int GetBinIndex(int iz, int iphi) const {return iphi * fNZBins + iz;}
77	int GetBinZ(int ipz) const {return ipz % fNZBins;}
78	int GetBinPhi(int ipz) const {return ipz / fNZBins;}
79	void GetBinZPhi(int ipz,int &iz,int &iphi) const {iz = GetBinZ(ipz); iphi=GetBinPhi(ipz);}
80	//
81	int SelectClusters(float zmin,float zmax,float phimin,float phimax);
82	int GetNFoundBins() const {return fFoundBins.size();}
83	int GetFoundBin(int i) const {return fFoundBins[i];}
84	int GetFoundBinClusters(int i, int &first) const;
85	void ResetFoundIterator();
86	AliITSUCATrackingStation::ClsInfo_t* GetClusterInfo(int i) const
87	{return (AliITSUCATrackingStation::ClsInfo_t*)&fSortedClInfo[i];}
88	AliITSUCATrackingStation::ClsInfo_t* GetNextClusterInfo();
89	int GetNextClusterInfoID();
90	AliITSUClusterPix* GetNextCluster();
91	AliITSUClusterPix* GetClusterSorted(int i) const
92	{return (AliITSUClusterPix*)fClusters->UncheckedAt(fSortedClInfo[i].index);}
93	AliITSUClusterPix* GetClusterUnSorted(int i) const
94	{return (AliITSUClusterPix*)fClusters->UncheckedAt(i);}
95	//
96	AliITSUCATrackingStation::ITSDetInfo_t& GetDetInfo(int id) const
97	{assert(fIndex[id] > -1 && "Empty sensor");return (ITSDetInfo_t&)fDetectors[fIndex[id]];}
98	int GetNDetectors() const
99	{return fDetectors.size();}
100
101	void ClearSortedInfo();
102	virtual void Clear(Option_t *opt="");
103	virtual void Print(Option_t *opt="") const;
104
105	protected:
bf255f08	106	AliITSUCATrackingStation(const AliITSUCATrackingStation &);
bf255f08	107	AliITSUCATrackingStation &operator=(const AliITSUCATrackingStation &);
14fb7846	108	TClonesArray* fClusters; // externally supplied clusters
14fb7846	109	int fVIDOffset; // offset of VID for detectors of this layer
	110	int fNClusters; // N clusters
	111	//
	112	float fZMin; // Zmin
	113	float fZMax; // Zmax
	114	float fDZInv; // inverse size of Z bin
	115	float fDPhiInv; // inverse size of Phi bin
	116	int fNZBins; // N cells in Z
	117	int fNPhiBins; // N cells in Phi
	118	//
	119	int fQueryZBmin; // min bin in Z of the query
	120	int fQueryZBmax; // max bin in Z of the query
	121	int fQueryPhiBmin; // min bin in phi of the query
	122	int fQueryPhiBmax; // max bin in phi of the query
	123	ClBinInfo_t* fBins; // 2D (z,phi) grid of clusters binned in z,phi
	124	int* fOccBins; // id's of bins with non-0 occupancy
	125	int fNOccBins; // number of occupied bins
	126	int fNFoundClusters; // number of found clusters in the query zone
	127	int fFoundClusterIterator; // at which cluster within the bin we are?
	128	int fFoundBinIterator; // at which foune bin we are?
	129	std::vector<int> fIndex;
	130	std::vector<int> fFoundBins; // occupied bins satisfying to query
	131	std::vector<ClsInfo_t> fSortedClInfo; // processed cluster info
	132	std::vector<ITSDetInfo_t> fDetectors; // detector params
	133	//
	134	};
	135
	136	//_____________________________________________________
	137	inline int AliITSUCATrackingStation::GetFoundBinClusters(int i, int &first) const {
	138	// set the entry of the first cl.info in the fSortedClInfo
	139	// and return n clusters in the bin
	140	ClBinInfo_t& bin = fBins[GetFoundBin(i)];
	141	first = bin.first;
	142	return bin.ncl;
	143	}
	144
	145	//_____________________________________________________
	146	inline AliITSUClusterPix* AliITSUCATrackingStation::GetNextCluster() {
	147	// return next cluster
	148	ClsInfo_t* cli = GetNextClusterInfo();
	149	return cli ? (AliITSUClusterPix*)fClusters->UncheckedAt(cli->index) : 0;
	150	}
	151
	152	//_____________________________________________________________
	153	inline AliITSUCATrackingStation::ClsInfo_t* AliITSUCATrackingStation::GetNextClusterInfo()
	154	{
	155	// return cluster info for next matching cluster
	156	int id = GetNextClusterInfoID();
	157	return id < 0 ? 0 : (AliITSUCATrackingStation::ClsInfo_t*)&fSortedClInfo[id];
	158	}
	159
	160	#endif