Line data    Source code

       1             : //-*- Mode: C++ -*-
       2             : // $Id$
       3             : 
       4             : #ifndef ALIHLTALTROTIMEBINAVERAGECOMPONENT_H
       5             : #define ALIHLTALTROTIMEBINAVERAGECOMPONENT_H
       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   AliHLTAltroTimebinAverageComponent.h
      11             :     @author Kalliopi Kanaki, Oystein Djuvsland, Matthias Richter
      12             :     @date   
      13             :     @brief  
      14             : */
      15             : 
      16             : #include "AliHLTProcessor.h"
      17             : 
      18             : /**
      19             :  * @class AliHLTAltroTimebin Averager Component
      20             :  * The component reduces the RCU/ALTRO raw data by averaging adjacent
      21             :  * timebins. By default, two timebins are averaged.
      22             :  *
      23             :  * @ingroup alihlt_rcu
      24             :  */
      25             : class AliHLTAltroTimebinAverageComponent : public AliHLTProcessor {
      26             :  public:
      27             :   /** default constructor */
      28             :   AliHLTAltroTimebinAverageComponent();
      29             :   /** destructor */
      30             :   virtual ~AliHLTAltroTimebinAverageComponent();
      31             : 
      32             :   /**
      33             :    * The id of the component.
      34             :    * @return component id (string)
      35             :    */
      36             :   virtual const char* GetComponentID();
      37             : 
      38             :   /**
      39             :    * Get the input data types of the component.
      40             :    * @return list of data types in the vector reference
      41             :    */
      42             :   void GetInputDataTypes( AliHLTComponentDataTypeList& );
      43             : 
      44             :   /**
      45             :    * Get the output data type of the component.
      46             :    * If kAliHLTMultipleDataType is returned, the framework invokes
      47             :    * @ref GetOutputDataTypes.
      48             :    * @return output data type
      49             :    */
      50             :   AliHLTComponentDataType GetOutputDataType();
      51             : 
      52             :   /**
      53             :    * Get the output data types of the component.
      54             :    * The function can be implemented to indicate multiple output data types
      55             :    * in the target array.
      56             :    * @ref GetOutputDataType must return kAliHLTMultipleDataType in order
      57             :    * to invoke this method.
      58             :    * @param tgtList          list to receive the data types
      59             :    * @return no of output data types, data types in the target list
      60             :    */
      61             :   int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
      62             : 
      63             :   /**
      64             :    * Get a ratio by how much the data volume is shrinked or enhanced.
      65             :    * @param constBase        <i>return</i>: additive part, independent of the
      66             :    *                                   input data volume  
      67             :    * @param inputMultiplier  <i>return</i>: multiplication ratio
      68             :    * @return values in the reference variables
      69             :    */
      70             :   void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
      71             : 
      72             :   /**
      73             :    * Spawn function.
      74             :    * @return new class instance
      75             :    */
      76             :   virtual AliHLTComponent* Spawn();
      77             : 
      78             :  protected:
      79             : 
      80             :   /**
      81             :    * Data processing method for the component.
      82             :    * Filters the incoming data descriptors according to the rules and forwards
      83             :    * them into the output.
      84             :    * @return neg. error code if failed 
      85             :    */
      86             :   int DoEvent( const AliHLTComponentEventData& evtData,
      87             :                const AliHLTComponentBlockData* blocks, 
      88             :                AliHLTComponentTriggerData& trigData,
      89             :                AliHLTUInt8_t* outputPtr, 
      90             :                AliHLTUInt32_t& size,
      91             :                AliHLTComponentBlockDataList& outputBlocks );
      92             :   
      93             :   using AliHLTProcessor::DoEvent;
      94             : 
      95             :   /**
      96             :    * Component initialisation and argument scan.
      97             :    */
      98             :   int DoInit( int argc, const char** argv );
      99             : 
     100             :   /**
     101             :    * Component cleanup.
     102             :    */
     103             :   int DoDeinit();
     104             : 
     105             :  private:
     106             :   /** copy constructor prohibited */
     107             :   AliHLTAltroTimebinAverageComponent(const AliHLTAltroTimebinAverageComponent&);
     108             :   /** assignment operator prohibited */
     109             :   AliHLTAltroTimebinAverageComponent& operator=(const AliHLTAltroTimebinAverageComponent&);
     110             : 
     111             :   /** First timebin to include in zerosuppression */
     112             :   Int_t fStartTimeBin;                                             //! transient
     113             : 
     114             :   /** Lasr timebin to include in zerosuppression */
     115             :   Int_t fEndTimeBin;                                               //! transient
     116             : 
     117             :   /** Number of timebins */
     118             :   Int_t fNTimeBins;                                                //! transient
     119             : 
     120           6 :   ClassDef(AliHLTAltroTimebinAverageComponent, 0);
     121             : };
     122             : 
     123             : #endif