HLT/CALO/AliHLTCaloClusterizer.h

   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   { fDigitContainerPtr = digitContainerPtr; }
  81
  82   /** Set array with digits */
  83   void SetDigitArray(AliHLTCaloDigitDataStruct **digitPointerArr)
  84   { 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   void SetEmcClusteringThreshold(Float_t threshold) { fEmcClusteringThreshold = threshold; }
  94
  95   /** Set emc min energy threshold */
  96   void SetEmcMinEnergyThreshold(Float_t threshold) { fEmcMinEnergyThreshold = threshold; }
  97
  98   /** Set emc time gate */
  99   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   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   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   ClassDef(AliHLTCaloClusterizer, 0);
 253
 254 };
 255
 256 #endif