provide OCDB URI as macro argument

[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterizer.h

//-*- Mode: C++ -*-\r
// $Id$\r
\r
/**************************************************************************\r
 * This file is property of and copyright by the ALICE HLT Project        * \r
 * All rights reserved.                                                   *\r
 *                                                                        *\r
 * Primary Authors: Oystein Djuvsland                                     *\r
 *                                                                        *\r
 * Permission to use, copy, modify and distribute this software and its   *\r
 * documentation strictly for non-commercial purposes is hereby granted   *\r
 * without fee, provided that the above copyright notice appears in all   *\r
 * copies and that both the copyright notice and this permission notice   *\r
 * appear in the supporting documentation. The authors make no claims     *\r
 * about the suitability of this software for any purpose. It is          * \r
 * provided "as is" without express or implied warranty.                  *\r
 **************************************************************************/\r
\r
#ifndef ALIHLTCALOCLUSTERIZER_H\r
#define ALIHLTCALOCLUSTERIZER_H\r
\r
\r
/**\r
 * Class does clusterization in for Calorimeters on an event basis. It is intended \r
 * for use in HLT, but can also be used offline\r
 *\r
 * @file   AliHLTCaloClusterizer.h\r
 * @author Oystein Djuvsland\r
 * @date\r
 * @brief  Clusterizer for CALO HLT\r
 */\r
\r
// see header file for class documentation\r
// or\r
// refer to README to build package\r
// or\r
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt\r
\r
//#include "AliHLTCaloBase.h"\r
\r
#include "AliHLTCaloRecPointContainerStruct.h"\r
#include "AliHLTCaloRecPointDataStruct.h"\r
#include "AliHLTCaloDigitContainerDataStruct.h"\r
#include "AliHLTCaloDigitDataStruct.h"\r
#include "TString.h"\r
#include "AliHLTCaloConstantsHandler.h"\r
\r
//#include "AliPHOSGeometry.h"\r
#include "AliHLTLogging.h"\r
\r
class TClonesArray;\r
class TString;\r
//class AliPHOSDigit;\r
//class AliPHOSRecoParamEmc;\r
//class AliPHOSRecoParam;\r
\r
/** \r
 * @class AliHLTCaloClusterizer\r
 * Clusterizer for CALO HLT. The clusterizer takes digits as input, either\r
 * in the form of a container of AliHLTCaloDigitDataStruct or a\r
 * TClonesArray of AliPHOSDigit through an instance of a AliPHOSLoader\r
 *\r
 * @ingroup alihlt_calo\r
 */\r
\r
\r
class AliHLTCaloClusterizer : public AliHLTCaloConstantsHandler, public AliHLTLogging\r
{\r
  \r
public:\r
  \r
  /** Constructor */\r
  AliHLTCaloClusterizer(TString det);    \r
\r
  /** Destructor */\r
  virtual ~AliHLTCaloClusterizer();\r
  \r
  /** Set digit container */\r
  void SetDigitContainer(AliHLTCaloDigitContainerDataStruct* digitContainerPtr)\r
  { fDigitContainerPtr = digitContainerPtr; }\r
\r
  /** Set array with digits */\r
  void SetDigitArray(AliHLTCaloDigitDataStruct **digitPointerArr)\r
  { fDigitsPointerArray = digitPointerArr; } \r
\r
  /** Set rec point data buffer */\r
  void SetRecPointDataPtr(AliHLTCaloRecPointDataStruct* recPointDataPtr);\r
\r
  /** Set reco parameters */\r
  //  void SetRecoParameters(AliPHOSRecoParam* recoPars);\r
\r
  /** Set emc clustering threshold */\r
  void SetEmcClusteringThreshold(Float_t threshold) { fEmcClusteringThreshold = threshold; }\r
\r
  /** Set emc min energy threshold */\r
  void SetEmcMinEnergyThreshold(Float_t threshold) { fEmcMinEnergyThreshold = threshold; }\r
\r
  /** Set emc time gate */\r
  void SetEmcTimeGate(Float_t gate) { fEmcTimeGate = gate; }\r
  \r
  /** Starts clusterization of the event */ \r
  virtual Int_t ClusterizeEvent(Int_t nDigits);\r
  \r
  /**\r
   * For a given digit this digit scans for neighbouring digits which \r
   * passes the threshold for inclusion in a rec point. If one is found \r
   * it is added to the current rec point\r
   * @param digIndex index of the digit in the digit container\r
   * @param recPoint pointer to the current rec point\r
   */\r
  virtual Int_t ScanForNeighbourDigits(Int_t digIndex, AliHLTCaloRecPointDataStruct* recPoint);\r
\r
  /**\r
   * Checks if two digits are neighbours\r
   * @param d1 first digit\r
   * @param d2 second digit\r
   */\r
  virtual Int_t AreNeighbours(AliHLTCaloDigitDataStruct* d1, AliHLTCaloDigitDataStruct* d2);\r
\r
  /**\r
  * Get pointer to the rec points array\r
  */\r
  AliHLTCaloRecPointDataStruct** GetRecPoints() const { return fRecPointArray; }\r
\r
  /** \r
  * Sort the digits by energy\r
  */\r
  void SetSortDigitsByEnergy();\r
  \r
  /** \r
  * Sort the digits by position\r
  */\r
  void SetSortDigitsByPosition();\r
  \r
  /** \r
  * Set the sorting function (as required by stdlib's qsort) if you don't want to use the provided ones \r
  */\r
  void SetSortingFunction(Int_t (*compare)(const void*, const void*)) { fCompareFunction = compare; }\r
  \r
  /** Set the detector (PHOS or EMCAL) */\r
  void SetDetector(TString det);\r
  \r
protected:\r
\r
   /** \r
   * Check the rec point buffer size and resize the buffer if necessary\r
   */\r
  virtual Int_t CheckBuffer(); //COMMENT\r
  \r
   /** \r
   * Check the rec point array size and resize the array if necessary\r
   */\r
  virtual Int_t CheckArray(); //COMMENT\r
  \r
  /** \r
  * Sort the digits\r
  */\r
  void SortDigits();\r
\r
  /** \r
  * Compare digits by position\r
  */\r
  static Int_t CompareDigitsByPosition(const void *dig0, const void *dig);\r
  \r
  /** \r
  * Compare digits by energy\r
  */\r
  static Int_t CompareDigitsByEnergy(const void *dig0, const void *dig);\r
  \r
  /** \r
  * Pointer to the compare function for the sorting of digits\r
  */\r
  //Int_t (AliHLTCaloClusterizer::*fCompareFunction)(const void*, const void*);\r
  Int_t (*fCompareFunction)(const void*, const void*);\r
  \r
  /** Check if two modules are connected */\r
  Bool_t AreEdgeCells(AliHLTCaloDigitDataStruct *digit0, AliHLTCaloDigitDataStruct *digit1);\r
  \r
  /** Array of pointers to the rec point output */\r
  AliHLTCaloRecPointDataStruct **fRecPointArray; //COMMENT\r
\r
   /** Pointer to the rec point output */\r
  AliHLTCaloRecPointDataStruct *fRecPointDataPtr; //COMMENT\r
\r
  /** The first rec point in the list */\r
  AliHLTCaloRecPointDataStruct *fFirstRecPointPtr; //COMMENT\r
\r
  /** Size of the rec point array */\r
  Int_t fArraySize;\r
  \r
  /** Available size for the rec point output */\r
  Int_t fAvailableSize;\r
\r
  /** The used size for the rec point output */\r
  Int_t fUsedSize;\r
  \r
  /** Number of rec points created so far */\r
  Int_t fNRecPoints;\r
  \r
  /** Pointer to the digit index array in the rec point */\r
  Int_t* fDigitIndexPtr;                                       //! transient\r
\r
  /** Energy threshold for starting a cluster for the calorimeter */\r
  Float_t fEmcClusteringThreshold;                             //COMMENT\r
\r
  /** Energy threshold for including a crystal in a cluster */\r
  Float_t fEmcMinEnergyThreshold;                              //COMMENT\r
\r
  /** Maximum time difference for inclusion in a rec point */\r
  Float_t fEmcTimeGate;                                        //COMMENT\r
\r
  /** Counts the digits in a rec point */\r
  Int_t fDigitsInCluster;                                      //COMMENT\r
\r
  /** Array of our digits */\r
  AliHLTCaloDigitDataStruct **fDigitsPointerArray;             //! transient\r
\r
  /** Contains the digits from one event */\r
  AliHLTCaloDigitContainerDataStruct *fDigitContainerPtr;      //! transient\r
\r
  /** Maximum difference in index to be a neighbour */\r
  Int_t fMaxDigitIndexDiff;                                    //COMMENT\r
\r
  /** Number of digits in event */\r
  Int_t fNDigits;                                              //COMMENT\r
  \r
  /** Are we sorting digits by position? */\r
  Bool_t fSortedByPosition; //COMMENT\r
\r
  /** Are we sorting digits by energy? */\r
  Bool_t fSortedByEnergy; //COMMENT\r
\r
   /** Are we sorting at all? */\r
   Bool_t fSortDigits; //COMMENT\r
   \r
   /** Is this running for EMCAL */\r
   Bool_t fIsEMCAL; //COMMENT\r
\r
private:\r
\r
  /** Default constructor, prohibited */\r
  AliHLTCaloClusterizer();                          // COMMENT\r
  \r
  /** Copy constructor, prohibited */\r
  AliHLTCaloClusterizer (const AliHLTCaloClusterizer &); //COMMENT\r
  \r
  /** Assignment operator, prohibited */\r
  AliHLTCaloClusterizer & operator = (const AliHLTCaloClusterizer &); //COMMENT\r
\r
  UChar_t* fBuffer; // Buffer for storing of Cluster Data\r
\r
  ClassDef(AliHLTCaloClusterizer, 0);\r
\r
};\r
\r
#endif\r