HLT/TPCLib/AliHLTTPCClusterFinderComponent.h

   1 // @(#) $Id$
   2
   3 #ifndef ALIHLTTPCCLUSTERFINDERCOMPONENT_H
   4 #define ALIHLTTPCCLUSTERFINDERCOMPONENT_H
   5
   6 //* This file is property of and copyright by the ALICE HLT Project        *
   7 //* ALICE Experiment at CERN, All rights reserved.                         *
   8 //* See cxx source for full Copyright notice                               *
   9
  10 /** @file   AliHLTTPCClusterFinderComponent.h
  11     @author Timm Steinbeck, Matthias Richter, Kenneth Aamodt
  12     @date
  13     @brief  The TPC cluster finder component.
  14 */
  15
  16 #include "AliHLTProcessor.h"
  17
  18 class AliHLTTPCClusterFinder;
  19 class AliHLTTPCDigitReader;
  20
  21 /**
  22  * @class AliHLTTPCClusterFinderComponent
  23  * Implementation of the cluster finder component.
  24  * The component implements the interface methods of the @ref AliHLTProcessor.
  25  * The actual cluster finding algorithm is implemented in @ref AliHLTTPCClusterFinder.
  26  * Two components are registered, TPCClusterFinderPacked and TPCClusterFinderDecoder.
  27  * TPCClusterFinderDecoder use the AliTPCRawStream class for decoding of the data, while TPCClusterFinderDecoder
  28  * use the AliAltroDecoder for decoding the data.
  29  *
  30  * TPCClusterFinderDecoder is the fastest of the two, this is due to that the AliAltroDecoder
  31  * returns data in a bunch format. A bunch consist of consecutive signals.
  32  * TPCClusterFinderPacked first have to read the data one by one, which means that row, pad and
  33  * time signals have to be compared between each new digit, which leads to a slower alorithm.
  34  *
  35  * Component ID: \b TPCClusterFinderDecoder and TPCClusterFinderPacked <br>
  36  * Library: \b libAliHLTTPC
  37  *
  38  * Mandatory arguments: <br>
  39  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
  40  *
  41  * Optional arguments: <br>
  42  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
  43  * \li -deconvolute-time <br>
  44  *      Turns on deconvolution in the time direction.
  45  * \li -deconvolute-pad <br>
  46  *      Turns on deconvolution in the pad direction.
  47  * \li -timebins <br>
  48  *      Sets the number of timebins (446 for simulated data, and 1024 for real data) Default:1024
  49  * \li -first-timebin <br>
  50  *      First timebin taken into consideration when reading the data.
  51  * \li -last-timebin <br>
  52  *      Last timebin taken into consideration when reading the data.
  53  * \li -sorted <br>
  54  *      Switch off unsorted reading of data. Equivalent to the old argument unsorted 0.
  55  * \li -active-pads <br>
  56  *      Switch off unsorted reading of data. Equivalent to the old argument unsorted 0.
  57  * \li -occupancy-limit <br>
  58  *      Set the occupancy limit for the sorted clusterfinding.
  59  *
  60  *
  61  * Obsolete arguments: <br>
  62  * \li occupancy-limit <br>
  63  * \li rawreadermode   <br>
  64  * \li pp-run          <br>
  65  * \li adc-threshold   <br>
  66  * \li oldrcuformat    <br>
  67  * \li unsorted        <br>
  68  * \li nsigma-threshold <br>
  69  *
  70  * @ingroup alihlt_tpc_components
  71  */
  72 class AliHLTTPCClusterFinderComponent : public AliHLTProcessor
  73     {
  74     public:
  75       /**
  76        * Defines for the cluster finder type.
  77        * The cluster finders can work on different formats of input data,
  78        * the AliHLTTPCDigitReader interface provides a transparent way to
  79        * read the data.
  80        */
  81       enum {
  82         /** real data, offline AliAltroRawStream used for data decoding */
  83         kClusterFinderPacked,
  84         /** Unpacked data of format AliHLTTPCUnpackedRawData */
  85         kClusterFinderUnpacked,
  86         /** real data, fast AliAltroDecoder used for data decoding */
  87         kClusterFinderDecoder,
  88         /** real data, offline altro decoder 32 bit format*/
  89         kClusterFinder32Bit
  90       };
  91
  92         /**
  93          * constructor
  94          * @param mode    input type see e.g. @ref kClusterFinderUnpacked
  95          */
  96         AliHLTTPCClusterFinderComponent(int mode);
  97         /** destructor */
  98         virtual ~AliHLTTPCClusterFinderComponent();
  99
 100         // Public functions to implement AliHLTComponent's interface.
 101         // These functions are required for the registration process
 102
 103   /** interface function, see AliHLTComponent for description */
 104   const char* GetComponentID();
 105   /** interface function, see AliHLTComponent for description */
 106   void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
 107   /** interface function, see AliHLTComponent for description */
 108   AliHLTComponentDataType GetOutputDataType();
 109   /** interface function, see AliHLTComponent for description */
 110   int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
 111   /** interface function, see AliHLTComponent for description */
 112   virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
 113   /** interface function, see AliHLTComponent for description */
 114   AliHLTComponent* Spawn();
 115
 116     protected:
 117
 118         // Protected functions to implement AliHLTComponent's interface.
 119         // These functions provide initialization as well as the actual processing
 120         // capabilities of the component.
 121
 122         int DoInit( int argc, const char** argv );
 123         int DoDeinit();
 124         int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
 125                      AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
 126                      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
 127         int Configure(const char* arguments);
 128         int Reconfigure(const char* cdbEntry, const char* chainId);
 129
 130         using AliHLTProcessor::DoEvent;
 131
 132     private:
 133         /** standard constructor prohibited */
 134         AliHLTTPCClusterFinderComponent();
 135         /** copy constructor prohibited */
 136         AliHLTTPCClusterFinderComponent(const AliHLTTPCClusterFinderComponent&);
 137         /** assignment operator prohibited */
 138         AliHLTTPCClusterFinderComponent& operator=(const AliHLTTPCClusterFinderComponent&);
 139         /** the cluster finder object */
 140         AliHLTTPCClusterFinder* fClusterFinder;                                      //!transient
 141         /** the reader object for data decoding */
 142         AliHLTTPCDigitReader* fReader;                                               //!transient
 143
 144         /** flag to deconvolute in time direction */
 145         Bool_t fDeconvTime;                                                          //!transient
 146
 147         /** flag to deconvolute in pad direction */
 148         Bool_t fDeconvPad;                                                           //!transient
 149         /** flag to switch on/off deconvolution in pad and time directions (used by sorted clusterfinding method) */
 150         bool fClusterDeconv;                                                         //!transient
 151         /** Error in xy of cluster */
 152         float fXYClusterError;                                                       //!transient
 153         /** Error in Z direction of cluster */
 154         float fZClusterError; //!transient
 155         /**
 156          * switch to indicated the reader
 157          * use fModeSwitch = 0 for packed inputtype "gkDDLPackedRawDataType"
 158          * use fModeSwitch = 1 for unpacked inputtype "gkUnpackedRawDataType"
 159          * use fModeSwitch = 2 for packed inputtype "gkDDLPackedRawDataType" with new digit reader
 160          * use fModeSwitch = 3 for packed inputtype "gkDDLPackedRawDataType" with 32bit digit reader
 161          */
 162         Int_t fModeSwitch;                                                            // see above
 163
 164         /*
 165          * Reads the data the new unsorted way if true
 166          *
 167          */
 168         Int_t fUnsorted;                                                               //!transient
 169
 170         /*
 171          * Patch number to be read, currently given as component argument,
 172          * will be changed later.
 173          */
 174         Int_t fPatch;                                                                  //!transient
 175
 176         /*
 177          * Switch to specify if one ship out a list of active pads (pads conected to a cluster).
 178          */
 179         Int_t fGetActivePads;                                                          //!transient
 180
 181         /** First timebin taken into account when reading the data */
 182         Int_t fFirstTimeBin;                                                           //!transient
 183
 184         /** Last timebin taken in to account when reading the data */
 185         Int_t fLastTimeBin;                                                            //!transient
 186
 187         Bool_t fDoMC;
 188
 189         ClassDef(AliHLTTPCClusterFinderComponent, 6)
 190
 191 };
 192 #endif