HLT/BASE/AliHLTCTPData.h

   1 //-*- Mode: C++ -*-
   2 // $Id$
   3
   4 #ifndef ALIHLTCTPDATA_H
   5 #define ALIHLTCTPDATA_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   AliHLTCTPData.h
  11     @author Matthias Richter
  12     @date   2009-08-20
  13     @brief  Container for CTP trigger classes and counters
  14 */
  15
  16 #include "TNamed.h"
  17 #include "TClonesArray.h"
  18 #include "TArrayL64.h"
  19 #include "AliHLTLogging.h"
  20 #include "AliHLTDataTypes.h"
  21
  22 /**
  23  * @class AliHLTCTPData
  24  * This is a container for the CTP trigger classes, the mapping to the bit
  25  * field, and counters.
  26  *
  27  * The class is initialized from CTP_TRIGGER_CLASSES part of the ECS parameters.
  28  * and stores internally a list of trigger classes holding the information on bit
  29  * position, class name and involved detectors. The general format og the parameter
  30  * is as follows:
  31  * <pre>
  32  * [bit position]:[Trigger class identifier string]:[detector-id-nr]-[detector-id-nr]-...,[bit position]:.....
  33  * </pre>
  34  *
  35  * The list of participating detectors is converted into an AliHLTReadoutList
  36  * object named after the trigger class name, and can be used as mask for the
  37  * readout list generated by a component.
  38  *
  39  * The object is also stored as part of the HLTGlobalTriggerDecision
  40  * @ingroup alihlt_trigger
  41  */
  42 class AliHLTCTPData: public TNamed, public AliHLTLogging
  43 {
  44  public:
  45   /// default constructor
  46   AliHLTCTPData();
  47   /// standard constructor including initialization from CTP_TRIGGER_CLASS
  48   AliHLTCTPData(const char* parameter);
  49   /// copy constructor
  50   AliHLTCTPData(const AliHLTCTPData&);
  51   ///assignment operator
  52   AliHLTCTPData& operator=(const AliHLTCTPData&);
  53   /// destructor
  54   virtual ~AliHLTCTPData();
  55
  56   /// Add counters
  57   AliHLTCTPData& operator += (const AliHLTCTPData&);
  58   /// Add counters
  59   AliHLTCTPData operator + (const AliHLTCTPData&) const;
  60
  61   /// Subtract counters
  62   AliHLTCTPData& operator -= (const AliHLTCTPData&);
  63   /// Subtract counters
  64   AliHLTCTPData operator - (const AliHLTCTPData&) const;
  65
  66   /**
  67    * Init the class ids and mapping from the CTP_TRIGGER_CLASS parameter.
  68    * The general format of the parameter is as follows:
  69    */
  70   int InitCTPTriggerClasses(const char* ctpString);
  71
  72   /// etract the active trigger mask from the trigger data
  73   static AliHLTUInt64_t ActiveTriggers(const AliHLTComponentTriggerData& trigData);
  74
  75   /**
  76    * Evaluate an expression of trigger class ids with respect to the trigger mask.
  77    */
  78   bool EvaluateCTPTriggerClass(const char* expression, const AliHLTComponentTriggerData& trigData) const;
  79
  80   /**
  81    * Evaluate an expression of trigger class ids with respect to the trigger mask.
  82    */
  83   bool EvaluateCTPTriggerClass(const char* expression, AliHLTUInt64_t triggerMask) const;
  84
  85   /**
  86    * Evaluate an expression of trigger class ids with respect to the current trigger mask.
  87    */
  88   bool EvaluateCTPTriggerClass(const char* expression) const {
  89     return EvaluateCTPTriggerClass(expression, fTriggers);
  90   }
  91
  92   /**
  93    * Reset all counters
  94    */
  95   void ResetCounters();
  96
  97   /**
  98    * Get index of a trigger class in the tigger pattern
  99    */
 100   int Index(const char* name) const;
 101
 102   /**
 103    * Check state of a trigger class.
 104    * If the class name is not part of the current trigger setup (i.e. ECS parameter
 105    * does not contain a trigger definition for this class name) the function
 106    * returns -1
 107    * @return -1 class name not initialized,
 108    *          0 trigger not active
 109    *          1 trigger active
 110    */
 111   int CheckTrigger(const char* name) const;
 112
 113   /**
 114    * Increment counter for CTP trigger classes
 115    * @param classIds  comma separated list of class ids
 116    */
 117   void Increment(const char* classIds);
 118
 119   /**
 120    * Increment counter for CTP trigger classes
 121    * @param triggerPattern  corresponds to the 50bit trigger mask in the CDH
 122    */
 123   void Increment(AliHLTUInt64_t triggerPattern);
 124
 125   /**
 126    * Increment counter for a CTP trigger class
 127    * @param classIdx  index of the class in the 50bit trigger mask
 128    */
 129   void Increment(int classIdx);
 130
 131   /**
 132    * Increment counters according to the trigger data struct.
 133    * First extract trigger pattern from the CDH and then
 134    * increment from the trigger pattern.
 135    */
 136   int Increment(AliHLTComponentTriggerData& trigData);
 137
 138   /**
 139    * Return a readout list for the active trigger classes.
 140    * The list is an 'OR' of the active trugger classes.
 141    */
 142   AliHLTEventDDL ReadoutList(const AliHLTComponentTriggerData& trigData) const;
 143
 144   /**
 145    * Return a readout list for the active trigger classes.
 146    * The list is an 'OR' of the active trugger classes.
 147    */
 148   AliHLTEventDDL ReadoutList(AliHLTUInt64_t  triggerMask) const;
 149
 150   /**
 151    * Return a readout list for the active trigger classes.
 152    * The list is an 'OR' of the active trugger classes.
 153    */
 154   AliHLTEventDDL ReadoutList() const {
 155     return ReadoutList(fTriggers);
 156   }
 157
 158   /**
 159    * Inherited from TObject, this prints the contents of the trigger decision.
 160    */
 161   virtual void Print(Option_t* option = "") const;
 162
 163   AliHLTUInt64_t   Mask() const { return fMask; }
 164   AliHLTUInt64_t   Triggers() const { return fTriggers; }
 165   void             SetTriggers(AliHLTUInt64_t triggers) { fTriggers=triggers; }
 166   void             SetTriggers(AliHLTComponentTriggerData trigData) {SetTriggers(ActiveTriggers(trigData));}
 167   const TArrayL64& Counters() const { return fCounters; }
 168   AliHLTUInt64_t   Counter(int index) const;
 169   AliHLTUInt64_t   Counter(const char* classId) const;
 170   const char*      Name(int index) const;
 171
 172  protected:
 173  private:
 174   /**
 175    * Add counters.
 176    * Base methods for operators.
 177    * @param src    instance to add
 178    * @param factor +1/-1 for addition/subtraction
 179    * @skipped      target to get the numner of not matching class names
 180    */
 181   int Add(const AliHLTCTPData& src, int factor, int &skipped);
 182
 183   /**
 184    * Read the map of trigger class indexes
 185    * The map is used in the generation of the TFormula from the trigger
 186    * expression in order to handle similar class names correctly.
 187    * For names like 'base', 'baseA', 'baseB' the class with the longer name
 188    * has to be replaced first.
 189    */
 190   int ReadMap(vector<unsigned> &map) const;
 191
 192   int ReadMap() {return ReadMap(fMap);}
 193
 194   AliHLTUInt64_t fMask;      /// mask of initialized trigger classes
 195   AliHLTUInt64_t fTriggers;  /// current trigger
 196   TClonesArray   fClassIds;  /// array of trigger class ids
 197   TArrayL64      fCounters;  /// trigger class counters
 198   vector<unsigned> fMap;     //! index map for trigger expression evaluation
 199
 200   ClassDef(AliHLTCTPData, 2)
 201 };
 202
 203 #endif