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