[u/mrichter/AliRoot.git] / PMD / AliPMDClusteringV1.h

#ifndef ALIPMDCLUSTERINGV1_H
#define ALIPMDCLUSTERINGV1_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */
//-----------------------------------------------------//
//                                                     //
//  Header File : PMDClustering.h, Version 00          //
//                                                     //
//  Date   : September 26 2002                         //
//                                                     //
//  clustering code for alice pmd                      //
//                                                     //
//-----------------------------------------------------//
/* --------------------------------------------------------------------
   Code developed by S. C. Phatak, Institute of Physics,
   Bhubaneswar 751 005 ( phatak@iopb.res.in ) Given the energy deposited
   ( or ADC value ) in each cell of supermodule ( pmd or cpv ), the code
   builds up superclusters and breaks them into clusters. The input is 
   in array d[ndimx][ndimy] and cluster information is in array
   clusters[5][5000]. integer clno gives total number of clusters in the
   supermodule.
   d, clno  and clusters are the only global ( public ) variables. Others
   are local ( private ) to the code.
   At the moment, the data is read for whole detector ( all supermodules
   and pmd as well as cpv. This will have to be modify later )
   LAST UPDATE  :  October 23, 2002
-----------------------------------------------------------------------*/
#include "Rtypes.h"
#include "AliPMDClustering.h"

class TNtuple;
class TObjArray;
class AliPMDcluster;

class AliPMDClusteringV1: public AliPMDClustering
{

 public:
  AliPMDClusteringV1();
  virtual ~AliPMDClusteringV1();

  void     DoClust(Int_t idet, Int_t ismn, Double_t celladc[][96],
		   TObjArray *pmdcont);
  void     Order();
  
  Int_t    CrClust(Double_t ave, Double_t cutoff, Int_t nmx1);
  void     RefClust(Int_t incr);
  void     GaussFit(Int_t ncell, Int_t nclust, Double_t &x,
		    Double_t &y, Double_t &z, Double_t &xc,
		    Double_t &yc, Double_t &zc, Double_t &rc);
  Double_t Distance(Double_t x1, Double_t y1,
		    Double_t x2, Double_t y2);
  Double_t Ranmar() const;
  void     SetEdepCut(Float_t decut);
  
 protected:

  static const Double_t fgkSqroot3by2;  // fgkSqroot3by2 = sqrt(3.)/2.
  /*enum {
    kNMX   = 4608,
    kNDIMX = 48,
    kNDIMY = 96
  };*/
  /*
    Proposed changes inNMX, kNDIMX and kNDIMY by S. C. Phatak to account
    for rectangular ( vs rhomboid ) geometry.
    To keep the clustering functional, we define a rhomboid which
    superscribes the rectangle. So we need to pad up dummy cells in x
    direction. The number of these cells is 96/2-1=47 in each row ( value
    of x ). For first two rows, all dummy cells are to the left. For
    every two rows add one cell to right and subtract one from left.
    So previous (i,j) values go over to ( i',j) i'=i+(96-j)/2-1
    Note we use C++ convention so i and j run from 0 to 47 or 95.
  */

  enum {
    kNMX    = 9120,
    kNDIMX  = 95,
    kNDIMY  = 96,
    kNDIMXr = 48,
    kNDIMYr = 96
  };
  /*
    kNMX   : # of cells in a supermodule
    kNDIMX : maximum number of cells along x direction (origin at one corner)
    kNDIMY : maximum number of cells along axis at 60 degrees with x axis
  */

  Double_t fEdepCell[kNDIMX][kNDIMY]; //energy(ADC) in each cell of the supermodule
  Double_t fClusters[5][5000]; // Cluster informations
  Int_t    fClno;   // number of clusters in a supermodule

  /*
    clusters[0][i] --- x position of the cluster center
    clusters[1][i] --- y position of the cluster center
    clusters[2][i] --- total energy in the cluster
    clusters[3][i] --- number of cells forming the cluster
                       ( possibly fractional )
    clusters[4][i] --- cluster radius
  */

  Int_t    fIord[2][kNMX]; // ordered list of i and j according to decreasing energy dep.
  Int_t    fInfocl[2][kNDIMX][kNDIMY]; // cellwise information on the cluster to which the cell
  Int_t    fInfcl[3][kNMX]; // cluster information [0][i] -- cluster number
  Double_t fCoord[2][kNDIMX][kNDIMY];

  /*
    fIord --- ordered list of i and j according to decreasing energy dep.
    fInfocl --- cellwise information on the cluster to which the cell
    belongs and whether it has largest energy dep. or not
    ( now redundant - probably )
    fInfcl ---  cluster information [0][i] -- cluster number
    [1][i] -- i of the cell
    [2][i] -- j of the cell
    coord --- x and y coordinates of center of each cell
  */

  Float_t fCutoff; // Energy(ADC) cutoff per cell before clustering

  ClassDef(AliPMDClusteringV1,1) // Does clustering for PMD
};
#endif
Commit	Line	Data
3edbbba2	1	#ifndef ALIPMDCLUSTERINGV1_H
	2	#define ALIPMDCLUSTERINGV1_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5	//-----------------------------------------------------//
	6	// //
	7	// Header File : PMDClustering.h, Version 00 //
	8	// //
	9	// Date : September 26 2002 //
	10	// //
	11	// clustering code for alice pmd //
	12	// //
	13	//-----------------------------------------------------//
	14	/* --------------------------------------------------------------------
	15	Code developed by S. C. Phatak, Institute of Physics,
	16	Bhubaneswar 751 005 ( phatak@iopb.res.in ) Given the energy deposited
	17	( or ADC value ) in each cell of supermodule ( pmd or cpv ), the code
	18	builds up superclusters and breaks them into clusters. The input is
	19	in array d[ndimx][ndimy] and cluster information is in array
	20	clusters[5][5000]. integer clno gives total number of clusters in the
	21	supermodule.
	22	d, clno and clusters are the only global ( public ) variables. Others
	23	are local ( private ) to the code.
	24	At the moment, the data is read for whole detector ( all supermodules
	25	and pmd as well as cpv. This will have to be modify later )
	26	LAST UPDATE : October 23, 2002
	27	-----------------------------------------------------------------------*/
	28	#include "Rtypes.h"
	29	#include "AliPMDClustering.h"
	30
	31	class TNtuple;
	32	class TObjArray;
	33	class AliPMDcluster;
	34
	35	class AliPMDClusteringV1: public AliPMDClustering
	36	{
	37
	38	public:
	39	AliPMDClusteringV1();
	40	virtual ~AliPMDClusteringV1();
	41
	42	void DoClust(Int_t idet, Int_t ismn, Double_t celladc[][96],
	43	TObjArray *pmdcont);
	44	void Order();
	45
	46	Int_t CrClust(Double_t ave, Double_t cutoff, Int_t nmx1);
	47	void RefClust(Int_t incr);
	48	void GaussFit(Int_t ncell, Int_t nclust, Double_t &x,
	49	Double_t &y, Double_t &z, Double_t &xc,
	50	Double_t &yc, Double_t &zc, Double_t &rc);
	51	Double_t Distance(Double_t x1, Double_t y1,
	52	Double_t x2, Double_t y2);
	53	Double_t Ranmar() const;
	54	void SetEdepCut(Float_t decut);
	55
	56	protected:
	57
	58	static const Double_t fgkSqroot3by2; // fgkSqroot3by2 = sqrt(3.)/2.
	59	/*enum {
	60	kNMX = 4608,
	61	kNDIMX = 48,
	62	kNDIMY = 96
	63	};*/
	64	/*
65	Proposed changes inNMX, kNDIMX and kNDIMY by S. C. Phatak to account
66	for rectangular ( vs rhomboid ) geometry.
67	To keep the clustering functional, we define a rhomboid which
68	superscribes the rectangle. So we need to pad up dummy cells in x
69	direction. The number of these cells is 96/2-1=47 in each row ( value
70	of x ). For first two rows, all dummy cells are to the left. For
71	every two rows add one cell to right and subtract one from left.
72	So previous (i,j) values go over to ( i',j) i'=i+(96-j)/2-1
73	Note we use C++ convention so i and j run from 0 to 47 or 95.
74	*/
75
76	enum {
77	kNMX = 9120,
78	kNDIMX = 95,
79	kNDIMY = 96,
80	kNDIMXr = 48,
81	kNDIMYr = 96
82	};
83	/*
84	kNMX : # of cells in a supermodule
85	kNDIMX : maximum number of cells along x direction (origin at one corner)
86	kNDIMY : maximum number of cells along axis at 60 degrees with x axis
87	*/
88
89	Double_t fEdepCell[kNDIMX][kNDIMY]; //energy(ADC) in each cell of the supermodule
90	Double_t fClusters[5][5000]; // Cluster informations
91	Int_t fClno; // number of clusters in a supermodule
92
93	/*
94	clusters[0][i] --- x position of the cluster center
95	clusters[1][i] --- y position of the cluster center
96	clusters[2][i] --- total energy in the cluster
97	clusters[3][i] --- number of cells forming the cluster
98	( possibly fractional )
99	clusters[4][i] --- cluster radius
100	*/
101
102	Int_t fIord[2][kNMX]; // ordered list of i and j according to decreasing energy dep.
103	Int_t fInfocl[2][kNDIMX][kNDIMY]; // cellwise information on the cluster to which the cell
104	Int_t fInfcl[3][kNMX]; // cluster information [0][i] -- cluster number
105	Double_t fCoord[2][kNDIMX][kNDIMY];
106
107	/*
108	fIord --- ordered list of i and j according to decreasing energy dep.
109	fInfocl --- cellwise information on the cluster to which the cell
110	belongs and whether it has largest energy dep. or not
111	( now redundant - probably )
112	fInfcl --- cluster information [0][i] -- cluster number
113	[1][i] -- i of the cell
114	[2][i] -- j of the cell
115	coord --- x and y coordinates of center of each cell
116	*/
117
118	Float_t fCutoff; // Energy(ADC) cutoff per cell before clustering
119
120	ClassDef(AliPMDClusteringV1,1) // Does clustering for PMD
121	};
122	#endif