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