ROOT logo
#ifndef ALITRDPTRGPARAM_H
#define ALITRDPTRGPARAM_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

// --------------------------------------------------------
// 
// Singleton class to hold the parameters steering the PTRG 
// 
// --------------------------------------------------------

class TArrayI;
class TObjArray;
#include "TObject.h"

 

class AliTRDptrgParam : public TObject {
 public:
  enum AliTRDptrgFEBType_t{ kUndefined = (Int_t)0, 
                            kTZERO = (Int_t)1, 
                            kVZERO = (Int_t)2 };
  enum AliTRDptrgOperatingMode_t{ kHits = (Int_t)0, kDigits = (Int_t)1 };
  enum AliTRDptrgFEBPosition_t{ kB = (Int_t)0, 
                                kA = (Int_t)1, 
                                kC = (Int_t)2,
                                kUnknown = (Int_t)3 };

  struct AliTRDptrgPTmasks {
    Bool_t fCBA[2]; // contribute CB-A look up results to pretrigger decision?
    Bool_t fCBC[2]; // contribute CB-C look up results to pretrigger decision?
    Bool_t fLUTs[3]; // CB-B look up results contribution to pretrigger decision
    Bool_t fTLMU[8]; // TLMU output signal contribution to pretrigger decisions

    AliTRDptrgPTmasks() {
      fCBA[0] = kFALSE;
      fCBA[1] = kFALSE;
      fCBC[0] = kFALSE;
      fCBC[1] = kFALSE;
      fLUTs[0] = kFALSE;
      fLUTs[1] = kFALSE;
      fLUTs[2] = kFALSE;
      for (Int_t i = 0; i < 8; i++) {
        fTLMU[i] = kFALSE;
      } 
    }
  };
  virtual ~AliTRDptrgParam();

  static AliTRDptrgParam *Instance(); // Singleton
  static void Terminate();  // delete Singleton
  
  void LoadStandardConfiguration(); // initialize with standard values
  Bool_t LoadConfigurationFromFile(TString filename); // load file 
  
  Int_t GenerateLUTs(); // generates all LUTs

  // --- GETTER FUNCTIONS -----------------------------------------------------
  // -- TLMU --
  const UInt_t* GetTLMUInputMask() const { return this->fTLMUInputMask; };
  // get TLMU input mask
   
  UInt_t** GetTLMUcmatrices() const { return this->fTLMUcmatrices; };
  // get TLMU coincidence matrices
  
  UInt_t** GetTLMUmultiplicity() const { return this->fTLMUmultiplicity; };
  // get TLMU multiplicity slices

  Int_t** GetTLMUoutput() const { return this->fTLMUoutput; };
  // get TLMU output mux configuration

  // -- T0 --
  UInt_t* GetFEBT0Thresholds(AliTRDptrgFEBPosition_t FEBposition) const;
  // get T0 FEB Thresholds

  Int_t* GetFEBT0LUT(AliTRDptrgFEBPosition_t FEBposition, Int_t iLUT); 
  // get T0 FEB LUTs
 
  // -- V0 --
  UInt_t* GetFEBV0Thresholds(AliTRDptrgFEBPosition_t FEBposition, Int_t iCard) const;
  // get V0 FEB Thresholds

  Int_t* GetFEBV0LUT(AliTRDptrgFEBPosition_t FEBposition, Int_t iCard, 
                     Int_t iLUT);
  // get V0 FEB LUTs

  Int_t* GetCBLUT(UInt_t CB, Int_t LUTid);
  // returns the corresponding LUT (control boxes only)

  const AliTRDptrgPTmasks* GetPTmasks() const { return &fPTmasks; };
  // returns the list containing the information which CB-B inputs are masked
  // out or forwarded as pre trigger output to the CTP


  Int_t CheckVariables() const; // returns -1 if a variable is already deleted

 protected:
  UInt_t GetMultiplicity(UInt_t BitVector) const; 
  // returns the multiplicity ('1's) 
  
  UInt_t GetMultiplicity(Int_t BitVector) const;  
  // returns the multiplicity ('1's)

  // helper functions for configuration file reading
  // -----------------------------------------------
  Bool_t ParseTLMU(TString identifier, TString value);
  // parses the TLMU configuration parameters

  Bool_t ParseCBB(TString identifier, TString value);
  // parses the CBB configuration parameters
  
  Bool_t ParseCBAC(TString identifier, TString value);
  // parses the CB-A and CB-C configuration parameters

  Bool_t ParseFEB(TString identifier, TString value);
  // parses the FEB configuration parameters

  Bool_t ParseMultiplicityCondition(TString condition, UInt_t* threshold,
                                    UInt_t* mask);
  // parses a multiplicity condition "M(#mask#)>#threshold#"

  UInt_t BinaryTStringToInt(TString number) const;
  // converts TString containing a binary number to a unsigned integer

  void SplitUpValues(TString value, TObjArray& arr);
  // splits a value string which contains multiple values seperated by ' ' 
  // and '\t'

  TString CleanTString(TString string);
  // removes ' ' and '\t' in a TString

  void PrepareLine(TString line, TString& identifier, TString& value);
  // divides identifier and value (seperator is the first ' ' or '\t'  

  
  // (helper) functions for conversion of logical equations into LUTs 
  // ----------------------------------------------------------------
  Int_t LookUp(TString* const identifier) const; // translates an identifier used in a
  // logical equation into an address bit of the corresponding LUT
  
  void MergeResults(TArrayI*& partResult1, TArrayI*& partResult2, 
                    TArrayI*& results, TArrayI*& signalsInvolved1, 
                    TArrayI*& signalsInvolved2, TArrayI*& signalsInvolved,
                    Bool_t useOR);
  // merges the results of to logical equation parts
  
  void ConvertLogicalEqToBitVectors(TString eq, TArrayI*& results,
                                    TArrayI*& signalsInvolved);
  // converts logical equations to bit vectors
  // neglected input signals are for now assumed to be 0!
  
  void CheckSignalsInvolved(TArrayI*& results, TArrayI*& signalsInvolved,
			    Int_t inputWidth);
  // adds all signal combinations needed to behave correctly in every state of
  // neglected signals
  
  Int_t* GenerateLUTbasedOnEq(TString eq, Int_t inputWidth, Int_t initValue);
  // generates a lut based on a logical functions (uses the functions above)

  static AliTRDptrgParam *fgInstance; // instance pointer

  // TLMU configuration --------------------------------------------------------
  UInt_t fTLMUInputMask[18]; // masks TOF-to-TRD bits
  UInt_t fTLMUInputStretch; // designates how long TLMU input is stretched   
  UInt_t** fTLMUcmatrices; // [matrix][section] unsigned int values
  // Bits 0..17 identify supermodules, bits equal 1 are checked for coincidence

  UInt_t** fTLMUmultiplicity; // [slice][0 = lower bound, 1 = upper bound]
  // use a lower bound above 576 to disable
  
  Int_t** fTLMUoutput; // [output][0 = cmatrix, 1 = multslice] 
  // output bit assignment, -1 disables

  // T0 ------------------------------------------------------------------------
  // [position][channel] 12 channels at A and C side
  UInt_t** fFEBT0Thresholds; // threshold for analog value discrimination
  
  // [position][LUT][0 = threshold, 1 = bitmask] 2 LUTs at A and C side  
  UInt_t*** fFEBT0Multiplicities; // multiplicity threshold for T0
  Int_t*** fFEBT0LUTs; // look up tables [position][LUT][entry]
    
  // V0 ------------------------------------------------------------------------
  // [position][feb][channel] 4x8 channels per side (A and C)
  UInt_t*** fFEBV0Thresholds; // threshold for analog value discrimation

  // [position][feb][LUT][0 = threshold, 1 = bitmask] 2 LUTs per FEB 
  // (4 per Side) at each side ( A and C)
  UInt_t**** fFEBV0Multiplicities; // multiplicity threshold for V0   
  Int_t**** fFEBV0LUTs; // look up tables [position][feb][LUT][entry] 

  // CB-{A/B/C}
  // 0 = B, 1 = A, 2 = C
  Int_t*** fCBLUTs; // control box look up tables

  // CB-A ----------------------------------------------------------------------
  TString fCBALUTequ[2]; // logical equations used for LUT generation for CB-A

  // CB-C ----------------------------------------------------------------------
  TString fCBCLUTequ[2]; // logical equations used for LUT generation for CB-C

  // CBB -----------------------------------------------------------------------
  TString fCBBLUTequ[3]; // logical equations used for LUT generation for CB-B

  // CTP -----------------------------------------------------------------------
  // PT mask
  AliTRDptrgPTmasks fPTmasks; 
  // masks usage of internal signals for the pretrigger wake up signal
                              
 private:
  AliTRDptrgParam();			     // instance only via Instance()
  AliTRDptrgParam(const AliTRDptrgParam &rhs); // not implemented
  AliTRDptrgParam& operator=(const AliTRDptrgParam &rhs); // not implemented

  ClassDef(AliTRDptrgParam, 1);
};
#endif
 AliTRDptrgParam.h:1
 AliTRDptrgParam.h:2
 AliTRDptrgParam.h:3
 AliTRDptrgParam.h:4
 AliTRDptrgParam.h:5
 AliTRDptrgParam.h:6
 AliTRDptrgParam.h:7
 AliTRDptrgParam.h:8
 AliTRDptrgParam.h:9
 AliTRDptrgParam.h:10
 AliTRDptrgParam.h:11
 AliTRDptrgParam.h:12
 AliTRDptrgParam.h:13
 AliTRDptrgParam.h:14
 AliTRDptrgParam.h:15
 AliTRDptrgParam.h:16
 AliTRDptrgParam.h:17
 AliTRDptrgParam.h:18
 AliTRDptrgParam.h:19
 AliTRDptrgParam.h:20
 AliTRDptrgParam.h:21
 AliTRDptrgParam.h:22
 AliTRDptrgParam.h:23
 AliTRDptrgParam.h:24
 AliTRDptrgParam.h:25
 AliTRDptrgParam.h:26
 AliTRDptrgParam.h:27
 AliTRDptrgParam.h:28
 AliTRDptrgParam.h:29
 AliTRDptrgParam.h:30
 AliTRDptrgParam.h:31
 AliTRDptrgParam.h:32
 AliTRDptrgParam.h:33
 AliTRDptrgParam.h:34
 AliTRDptrgParam.h:35
 AliTRDptrgParam.h:36
 AliTRDptrgParam.h:37
 AliTRDptrgParam.h:38
 AliTRDptrgParam.h:39
 AliTRDptrgParam.h:40
 AliTRDptrgParam.h:41
 AliTRDptrgParam.h:42
 AliTRDptrgParam.h:43
 AliTRDptrgParam.h:44
 AliTRDptrgParam.h:45
 AliTRDptrgParam.h:46
 AliTRDptrgParam.h:47
 AliTRDptrgParam.h:48
 AliTRDptrgParam.h:49
 AliTRDptrgParam.h:50
 AliTRDptrgParam.h:51
 AliTRDptrgParam.h:52
 AliTRDptrgParam.h:53
 AliTRDptrgParam.h:54
 AliTRDptrgParam.h:55
 AliTRDptrgParam.h:56
 AliTRDptrgParam.h:57
 AliTRDptrgParam.h:58
 AliTRDptrgParam.h:59
 AliTRDptrgParam.h:60
 AliTRDptrgParam.h:61
 AliTRDptrgParam.h:62
 AliTRDptrgParam.h:63
 AliTRDptrgParam.h:64
 AliTRDptrgParam.h:65
 AliTRDptrgParam.h:66
 AliTRDptrgParam.h:67
 AliTRDptrgParam.h:68
 AliTRDptrgParam.h:69
 AliTRDptrgParam.h:70
 AliTRDptrgParam.h:71
 AliTRDptrgParam.h:72
 AliTRDptrgParam.h:73
 AliTRDptrgParam.h:74
 AliTRDptrgParam.h:75
 AliTRDptrgParam.h:76
 AliTRDptrgParam.h:77
 AliTRDptrgParam.h:78
 AliTRDptrgParam.h:79
 AliTRDptrgParam.h:80
 AliTRDptrgParam.h:81
 AliTRDptrgParam.h:82
 AliTRDptrgParam.h:83
 AliTRDptrgParam.h:84
 AliTRDptrgParam.h:85
 AliTRDptrgParam.h:86
 AliTRDptrgParam.h:87
 AliTRDptrgParam.h:88
 AliTRDptrgParam.h:89
 AliTRDptrgParam.h:90
 AliTRDptrgParam.h:91
 AliTRDptrgParam.h:92
 AliTRDptrgParam.h:93
 AliTRDptrgParam.h:94
 AliTRDptrgParam.h:95
 AliTRDptrgParam.h:96
 AliTRDptrgParam.h:97
 AliTRDptrgParam.h:98
 AliTRDptrgParam.h:99
 AliTRDptrgParam.h:100
 AliTRDptrgParam.h:101
 AliTRDptrgParam.h:102
 AliTRDptrgParam.h:103
 AliTRDptrgParam.h:104
 AliTRDptrgParam.h:105
 AliTRDptrgParam.h:106
 AliTRDptrgParam.h:107
 AliTRDptrgParam.h:108
 AliTRDptrgParam.h:109
 AliTRDptrgParam.h:110
 AliTRDptrgParam.h:111
 AliTRDptrgParam.h:112
 AliTRDptrgParam.h:113
 AliTRDptrgParam.h:114
 AliTRDptrgParam.h:115
 AliTRDptrgParam.h:116
 AliTRDptrgParam.h:117
 AliTRDptrgParam.h:118
 AliTRDptrgParam.h:119
 AliTRDptrgParam.h:120
 AliTRDptrgParam.h:121
 AliTRDptrgParam.h:122
 AliTRDptrgParam.h:123
 AliTRDptrgParam.h:124
 AliTRDptrgParam.h:125
 AliTRDptrgParam.h:126
 AliTRDptrgParam.h:127
 AliTRDptrgParam.h:128
 AliTRDptrgParam.h:129
 AliTRDptrgParam.h:130
 AliTRDptrgParam.h:131
 AliTRDptrgParam.h:132
 AliTRDptrgParam.h:133
 AliTRDptrgParam.h:134
 AliTRDptrgParam.h:135
 AliTRDptrgParam.h:136
 AliTRDptrgParam.h:137
 AliTRDptrgParam.h:138
 AliTRDptrgParam.h:139
 AliTRDptrgParam.h:140
 AliTRDptrgParam.h:141
 AliTRDptrgParam.h:142
 AliTRDptrgParam.h:143
 AliTRDptrgParam.h:144
 AliTRDptrgParam.h:145
 AliTRDptrgParam.h:146
 AliTRDptrgParam.h:147
 AliTRDptrgParam.h:148
 AliTRDptrgParam.h:149
 AliTRDptrgParam.h:150
 AliTRDptrgParam.h:151
 AliTRDptrgParam.h:152
 AliTRDptrgParam.h:153
 AliTRDptrgParam.h:154
 AliTRDptrgParam.h:155
 AliTRDptrgParam.h:156
 AliTRDptrgParam.h:157
 AliTRDptrgParam.h:158
 AliTRDptrgParam.h:159
 AliTRDptrgParam.h:160
 AliTRDptrgParam.h:161
 AliTRDptrgParam.h:162
 AliTRDptrgParam.h:163
 AliTRDptrgParam.h:164
 AliTRDptrgParam.h:165
 AliTRDptrgParam.h:166
 AliTRDptrgParam.h:167
 AliTRDptrgParam.h:168
 AliTRDptrgParam.h:169
 AliTRDptrgParam.h:170
 AliTRDptrgParam.h:171
 AliTRDptrgParam.h:172
 AliTRDptrgParam.h:173
 AliTRDptrgParam.h:174
 AliTRDptrgParam.h:175
 AliTRDptrgParam.h:176
 AliTRDptrgParam.h:177
 AliTRDptrgParam.h:178
 AliTRDptrgParam.h:179
 AliTRDptrgParam.h:180
 AliTRDptrgParam.h:181
 AliTRDptrgParam.h:182
 AliTRDptrgParam.h:183
 AliTRDptrgParam.h:184
 AliTRDptrgParam.h:185
 AliTRDptrgParam.h:186
 AliTRDptrgParam.h:187
 AliTRDptrgParam.h:188
 AliTRDptrgParam.h:189
 AliTRDptrgParam.h:190
 AliTRDptrgParam.h:191
 AliTRDptrgParam.h:192
 AliTRDptrgParam.h:193
 AliTRDptrgParam.h:194
 AliTRDptrgParam.h:195
 AliTRDptrgParam.h:196
 AliTRDptrgParam.h:197
 AliTRDptrgParam.h:198
 AliTRDptrgParam.h:199
 AliTRDptrgParam.h:200
 AliTRDptrgParam.h:201
 AliTRDptrgParam.h:202
 AliTRDptrgParam.h:203
 AliTRDptrgParam.h:204
 AliTRDptrgParam.h:205
 AliTRDptrgParam.h:206
 AliTRDptrgParam.h:207
 AliTRDptrgParam.h:208
 AliTRDptrgParam.h:209
 AliTRDptrgParam.h:210
 AliTRDptrgParam.h:211
 AliTRDptrgParam.h:212
 AliTRDptrgParam.h:213
 AliTRDptrgParam.h:214
 AliTRDptrgParam.h:215
 AliTRDptrgParam.h:216
 AliTRDptrgParam.h:217
 AliTRDptrgParam.h:218