- fixing major bug in clusterizer causing almost all events to contain only one cluster
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterizer.h
1 //-*- Mode: C++ -*-\r
2 // $Id$\r
3 \r
4 /**************************************************************************\r
5  * This file is property of and copyright by the ALICE HLT Project        * \r
6  * All rights reserved.                                                   *\r
7  *                                                                        *\r
8  * Primary Authors: Oystein Djuvsland                                     *\r
9  *                                                                        *\r
10  * Permission to use, copy, modify and distribute this software and its   *\r
11  * documentation strictly for non-commercial purposes is hereby granted   *\r
12  * without fee, provided that the above copyright notice appears in all   *\r
13  * copies and that both the copyright notice and this permission notice   *\r
14  * appear in the supporting documentation. The authors make no claims     *\r
15  * about the suitability of this software for any purpose. It is          * \r
16  * provided "as is" without express or implied warranty.                  *\r
17  **************************************************************************/\r
18 \r
19 #ifndef ALIHLTCALOCLUSTERIZER_H\r
20 #define ALIHLTCALOCLUSTERIZER_H\r
21 \r
22 \r
23 /**\r
24  * Class does clusterization in for Calorimeters on an event basis. It is intended \r
25  * for use in HLT, but can also be used offline\r
26  *\r
27  * @file   AliHLTCaloClusterizer.h\r
28  * @author Oystein Djuvsland\r
29  * @date\r
30  * @brief  Clusterizer for CALO HLT\r
31  */\r
32 \r
33 // see header file for class documentation\r
34 // or\r
35 // refer to README to build package\r
36 // or\r
37 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt\r
38 \r
39 //#include "AliHLTCaloBase.h"\r
40 \r
41 #include "AliHLTCaloRecPointContainerStruct.h"\r
42 #include "AliHLTCaloRecPointDataStruct.h"\r
43 #include "AliHLTCaloDigitContainerDataStruct.h"\r
44 #include "AliHLTCaloDigitDataStruct.h"\r
45 #include "TString.h"\r
46 #include "AliHLTCaloConstantsHandler.h"\r
47 \r
48 //#include "AliPHOSGeometry.h"\r
49 #include "AliHLTLogging.h"\r
50 \r
51 class TClonesArray;\r
52 class TString;\r
53 //class AliPHOSDigit;\r
54 //class AliPHOSRecoParamEmc;\r
55 //class AliPHOSRecoParam;\r
56 \r
57 /** \r
58  * @class AliHLTCaloClusterizer\r
59  * Clusterizer for CALO HLT. The clusterizer takes digits as input, either\r
60  * in the form of a container of AliHLTCaloDigitDataStruct or a\r
61  * TClonesArray of AliPHOSDigit through an instance of a AliPHOSLoader\r
62  *\r
63  * @ingroup alihlt_calo\r
64  */\r
65 \r
66 \r
67 class AliHLTCaloClusterizer : public AliHLTCaloConstantsHandler, public AliHLTLogging\r
68 {\r
69   \r
70 public:\r
71   \r
72   /** Constructor */\r
73   AliHLTCaloClusterizer(TString det);    \r
74 \r
75   /** Destructor */\r
76   virtual ~AliHLTCaloClusterizer();\r
77   \r
78   /** Set digit container */\r
79   void SetDigitContainer(AliHLTCaloDigitContainerDataStruct* digitContainerPtr)\r
80   { fDigitContainerPtr = digitContainerPtr; }\r
81 \r
82   /** Set array with digits */\r
83   void SetDigitArray(AliHLTCaloDigitDataStruct **digitPointerArr)\r
84   { fDigitsPointerArray = digitPointerArr; } \r
85 \r
86   /** Set rec point data buffer */\r
87   void SetRecPointDataPtr(AliHLTCaloRecPointDataStruct* recPointDataPtr);\r
88 \r
89   /** Set reco parameters */\r
90   //  void SetRecoParameters(AliPHOSRecoParam* recoPars);\r
91 \r
92   /** Set emc clustering threshold */\r
93   void SetEmcClusteringThreshold(Float_t threshold) { fEmcClusteringThreshold = threshold; }\r
94 \r
95   /** Set emc min energy threshold */\r
96   void SetEmcMinEnergyThreshold(Float_t threshold) { fEmcMinEnergyThreshold = threshold; }\r
97 \r
98   /** Set emc time gate */\r
99   void SetEmcTimeGate(Float_t gate) { fEmcTimeGate = gate; }\r
100   \r
101   /** Starts clusterization of the event */ \r
102   virtual Int_t ClusterizeEvent(Int_t nDigits);\r
103   \r
104   /**\r
105    * For a given digit this digit scans for neighbouring digits which \r
106    * passes the threshold for inclusion in a rec point. If one is found \r
107    * it is added to the current rec point\r
108    * @param digIndex index of the digit in the digit container\r
109    * @param recPoint pointer to the current rec point\r
110    */\r
111   virtual Int_t ScanForNeighbourDigits(Int_t digIndex, AliHLTCaloRecPointDataStruct* recPoint);\r
112 \r
113   /**\r
114    * Checks if two digits are neighbours\r
115    * @param d1 first digit\r
116    * @param d2 second digit\r
117    */\r
118   virtual Int_t AreNeighbours(AliHLTCaloDigitDataStruct* d1, AliHLTCaloDigitDataStruct* d2);\r
119 \r
120   /**\r
121   * Get pointer to the rec points array\r
122   */\r
123   AliHLTCaloRecPointDataStruct** GetRecPoints() const { return fRecPointArray; }\r
124 \r
125   /** \r
126   * Sort the digits by energy\r
127   */\r
128   void SetSortDigitsByEnergy();\r
129   \r
130   /** \r
131   * Sort the digits by position\r
132   */\r
133   void SetSortDigitsByPosition();\r
134   \r
135   /** \r
136   * Set the sorting function (as required by stdlib's qsort) if you don't want to use the provided ones \r
137   */\r
138   void SetSortingFunction(Int_t (*compare)(const void*, const void*)) { fCompareFunction = compare; }\r
139   \r
140   /** Set the detector (PHOS or EMCAL) */\r
141   void SetDetector(TString det);\r
142   \r
143 protected:\r
144 \r
145    /** \r
146    * Check the rec point buffer size and resize the buffer if necessary\r
147    */\r
148   virtual Int_t CheckBuffer(); //COMMENT\r
149   \r
150    /** \r
151    * Check the rec point array size and resize the array if necessary\r
152    */\r
153   virtual Int_t CheckArray(); //COMMENT\r
154   \r
155   /** \r
156   * Sort the digits\r
157   */\r
158   void SortDigits();\r
159 \r
160   /** \r
161   * Compare digits by position\r
162   */\r
163   static Int_t CompareDigitsByPosition(const void *dig0, const void *dig);\r
164   \r
165   /** \r
166   * Compare digits by energy\r
167   */\r
168   static Int_t CompareDigitsByEnergy(const void *dig0, const void *dig);\r
169   \r
170   /** \r
171   * Pointer to the compare function for the sorting of digits\r
172   */\r
173   //Int_t (AliHLTCaloClusterizer::*fCompareFunction)(const void*, const void*);\r
174   Int_t (*fCompareFunction)(const void*, const void*);\r
175   \r
176   /** Check if two modules are connected */\r
177   Bool_t AreEdgeCells(AliHLTCaloDigitDataStruct *digit0, AliHLTCaloDigitDataStruct *digit1);\r
178   \r
179   /** Array of pointers to the rec point output */\r
180   AliHLTCaloRecPointDataStruct **fRecPointArray; //COMMENT\r
181 \r
182    /** Pointer to the rec point output */\r
183   AliHLTCaloRecPointDataStruct *fRecPointDataPtr; //COMMENT\r
184 \r
185   /** The first rec point in the list */\r
186   AliHLTCaloRecPointDataStruct *fFirstRecPointPtr; //COMMENT\r
187 \r
188   /** Size of the rec point array */\r
189   Int_t fArraySize;\r
190   \r
191   /** Available size for the rec point output */\r
192   Int_t fAvailableSize;\r
193 \r
194   /** The used size for the rec point output */\r
195   Int_t fUsedSize;\r
196   \r
197   /** Number of rec points created so far */\r
198   Int_t fNRecPoints;\r
199   \r
200   /** Pointer to the digit index array in the rec point */\r
201   Int_t* fDigitIndexPtr;                                       //! transient\r
202 \r
203   /** Energy threshold for starting a cluster for the calorimeter */\r
204   Float_t fEmcClusteringThreshold;                             //COMMENT\r
205 \r
206   /** Energy threshold for including a crystal in a cluster */\r
207   Float_t fEmcMinEnergyThreshold;                              //COMMENT\r
208 \r
209   /** Maximum time difference for inclusion in a rec point */\r
210   Float_t fEmcTimeGate;                                        //COMMENT\r
211 \r
212   /** Counts the digits in a rec point */\r
213   Int_t fDigitsInCluster;                                      //COMMENT\r
214 \r
215   /** Array of our digits */\r
216   AliHLTCaloDigitDataStruct **fDigitsPointerArray;             //! transient\r
217 \r
218   /** Contains the digits from one event */\r
219   AliHLTCaloDigitContainerDataStruct *fDigitContainerPtr;      //! transient\r
220 \r
221   /** Maximum difference in index to be a neighbour */\r
222   Int_t fMaxDigitIndexDiff;                                    //COMMENT\r
223 \r
224   /** Number of digits in event */\r
225   Int_t fNDigits;                                              //COMMENT\r
226   \r
227   /** Are we sorting digits by position? */\r
228   Bool_t fSortedByPosition; //COMMENT\r
229 \r
230   /** Are we sorting digits by energy? */\r
231   Bool_t fSortedByEnergy; //COMMENT\r
232 \r
233    /** Are we sorting at all? */\r
234    Bool_t fSortDigits; //COMMENT\r
235    \r
236    /** Is this running for EMCAL */\r
237    Bool_t fIsEMCAL; //COMMENT\r
238 \r
239 private:\r
240 \r
241   /** Default constructor, prohibited */\r
242   AliHLTCaloClusterizer();                          // COMMENT\r
243   \r
244   /** Copy constructor, prohibited */\r
245   AliHLTCaloClusterizer (const AliHLTCaloClusterizer &); //COMMENT\r
246   \r
247   /** Assignment operator, prohibited */\r
248   AliHLTCaloClusterizer & operator = (const AliHLTCaloClusterizer &); //COMMENT\r
249 \r
250   UChar_t* fBuffer; // Buffer for storing of Cluster Data\r
251 \r
252   ClassDef(AliHLTCaloClusterizer, 0);\r
253 \r
254 };\r
255 \r
256 #endif\r