[u/mrichter/AliRoot.git] / TRD / AliTRDptrgParam.h

#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 
// 
// --------------------------------------------------------
#include "TObject.h"

  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 };


class AliTRDptrgParam : public TObject {
 public:
  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[2]; // 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;
      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
  //UInt_t** fFEBT0Delays; // delay is not used in simulation right now //TODO
  
  // [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
  //UInt_t** fFEBV0Delays; // delay is not used in simulation right now //TODO

  // [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 fCBALUTequX; // logical equation used for generation of LUT X of CB-A
  TString fCBALUTequY; // logical equation used for generation of LUT Y of CB-A

  // CB-C ----------------------------------------------------------------------
  TString fCBCLUTequX; // logical equation used for generation of LUT X of CB-C
  TString fCBCLUTequY; // logical equation used for generation of LUT Y of CB-C

  // CBB -----------------------------------------------------------------------
  TString fCBBLUTequX; // logical equation used for generation of LUT X of CB-B 
  TString fCBBLUTequY; // logical equation used for generation of LUT Y of CB-B

  // CTP -----------------------------------------------------------------------
  // PT mask
  AliTRDptrgPTmasks fPTmasks; 
  // masks usage of internal signals for the pretrigger wake up signal
                              

  // CBB-LUT to TriggerInput assignment
  
  // class state ---------------------------------------------------------------

 private:
  AliTRDptrgParam();			     // instance only via Instance()
  AliTRDptrgParam(const AliTRDptrgParam &rhs); // not implemented
  AliTRDptrgParam& operator=(const AliTRDptrgParam &rhs); // not implemented

  ClassDef(AliTRDptrgParam, 1);
};
#endif
Commit	Line	Data
f9720615	1	#ifndef ALITRDPTRGPARAM_H
	2	#define ALITRDPTRGPARAM_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	// --------------------------------------------------------
	9	//
	10	// Singleton class to hold the parameters steering the PTRG
	11	//
	12	// --------------------------------------------------------
	13	#include "TObject.h"
	14
	15	enum AliTRDptrgFEBType_t{ kUndefined = (Int_t)0,
	16	kTZERO = (Int_t)1,
	17	kVZERO = (Int_t)2 };
	18	enum AliTRDptrgOperatingMode_t{ kHits = (Int_t)0, kDigits = (Int_t)1 };
	19	enum AliTRDptrgFEBPosition_t{ kB = (Int_t)0,
	20	kA = (Int_t)1,
	21	kC = (Int_t)2,
	22	kUnknown = (Int_t)3 };
	23
	24
	25	class AliTRDptrgParam : public TObject {
	26	public:
	27	struct AliTRDptrgPTmasks {
	28	Bool_t fCBA[2]; // contribute CB-A look up results to pretrigger decision?
	29	Bool_t fCBC[2]; // contribute CB-C look up results to pretrigger decision?
	30	Bool_t fLUTs[2]; // CB-B look up results contribution to pretrigger decision
	31	Bool_t fTLMU[8]; // TLMU output signal contribution to pretrigger decisions
	32
	33	AliTRDptrgPTmasks() {
	34	fCBA[0] = kFALSE;
	35	fCBA[1] = kFALSE;
	36	fCBC[0] = kFALSE;
	37	fCBC[1] = kFALSE;
	38	fLUTs[0] = kFALSE;
	39	fLUTs[1] = kFALSE;
	40	for (Int_t i = 0; i < 8; i++) {
	41	fTLMU[i] = kFALSE;
	42	}
	43	}
	44	};
	45	virtual ~AliTRDptrgParam();
	46
	47	static AliTRDptrgParam *Instance(); // Singleton
	48	static void Terminate(); // delete Singleton
	49
	50	void LoadStandardConfiguration(); // initialize with standard values
	51	Bool_t LoadConfigurationFromFile(TString filename); // load file
	52
	53	Int_t GenerateLUTs(); // generates all LUTs
	54
	55	// --- GETTER FUNCTIONS -----------------------------------------------------
	56	// -- TLMU --
	57	const UInt_t* GetTLMUInputMask() const { return this->fTLMUInputMask; };
	58	// get TLMU input mask
	59
	60	UInt_t** GetTLMUcmatrices() const { return this->fTLMUcmatrices; };
	61	// get TLMU coincidence matrices
	62
	63	UInt_t** GetTLMUmultiplicity() const { return this->fTLMUmultiplicity; };
	64	// get TLMU multiplicity slices
65
66	Int_t** GetTLMUoutput() const { return this->fTLMUoutput; };
67	// get TLMU output mux configuration
68
69	// -- T0 --
70	UInt_t* GetFEBT0Thresholds(AliTRDptrgFEBPosition_t FEBposition) const;
71	// get T0 FEB Thresholds
72
73	Int_t* GetFEBT0LUT(AliTRDptrgFEBPosition_t FEBposition, Int_t iLUT);
74	// get T0 FEB LUTs
75
76	// -- V0 --
77	UInt_t* GetFEBV0Thresholds(AliTRDptrgFEBPosition_t FEBposition, Int_t iCard) const;
78	// get V0 FEB Thresholds
79
80	Int_t* GetFEBV0LUT(AliTRDptrgFEBPosition_t FEBposition, Int_t iCard,
81	Int_t iLUT);
82	// get V0 FEB LUTs
83
84	Int_t* GetCBLUT(UInt_t CB, Int_t LUTid);
85	// returns the corresponding LUT (control boxes only)
86
87	const AliTRDptrgPTmasks* GetPTmasks() const { return &fPTmasks; };
88	// returns the list containing the information which CB-B inputs are masked
89	// out or forwarded as pre trigger output to the CTP
90
91
92	Int_t CheckVariables() const; // returns -1 if a variable is already deleted
93
94	protected:
95	UInt_t GetMultiplicity(UInt_t BitVector) const;
96	// returns the multiplicity ('1's)
97
98	UInt_t GetMultiplicity(Int_t BitVector) const;
99	// returns the multiplicity ('1's)
100
101	// helper functions for configuration file reading
102	// -----------------------------------------------
103	Bool_t ParseTLMU(TString identifier, TString value);
104	// parses the TLMU configuration parameters
105
106	Bool_t ParseCBB(TString identifier, TString value);
107	// parses the CBB configuration parameters
108
109	Bool_t ParseCBAC(TString identifier, TString value);
110	// parses the CB-A and CB-C configuration parameters
111
112	Bool_t ParseFEB(TString identifier, TString value);
113	// parses the FEB configuration parameters
114
115	Bool_t ParseMultiplicityCondition(TString condition, UInt_t* threshold,
116	UInt_t* mask);
117	// parses a multiplicity condition "M(#mask#)>#threshold#"
118
119	UInt_t BinaryTStringToInt(TString number) const;
120	// converts TString containing a binary number to a unsigned integer
121
122	void SplitUpValues(TString value, TObjArray& arr);
123	// splits a value string which contains multiple values seperated by ' '
124	// and '\t'
125
126	TString CleanTString(TString string);
127	// removes ' ' and '\t' in a TString
128
129	void PrepareLine(TString line, TString& identifier, TString& value);
130	// divides identifier and value (seperator is the first ' ' or '\t'
131
132
133	// (helper) functions for conversion of logical equations into LUTs
134	// ----------------------------------------------------------------
135	Int_t LookUp(TString* const identifier) const; // translates an identifier used in a
136	// logical equation into an address bit of the corresponding LUT
137
138	void MergeResults(TArrayI& partResult1, TArrayI& partResult2,
139	TArrayI& results, TArrayI& signalsInvolved1,
140	TArrayI& signalsInvolved2, TArrayI& signalsInvolved,
141	Bool_t useOR);
142	// merges the results of to logical equation parts
143
144	void ConvertLogicalEqToBitVectors(TString eq, TArrayI*& results,
145	TArrayI*& signalsInvolved);
146	// converts logical equations to bit vectors
147	// neglected input signals are for now assumed to be 0!
148
149	void CheckSignalsInvolved(TArrayI& results, TArrayI& signalsInvolved,
150	Int_t inputWidth);
151	// adds all signal combinations needed to behave correctly in every state of
152	// neglected signals
153
154	Int_t* GenerateLUTbasedOnEq(TString eq, Int_t inputWidth, Int_t initValue);
155	// generates a lut based on a logical functions (uses the functions above)
156
157	static AliTRDptrgParam *fgInstance; // instance pointer
158
159	// TLMU configuration --------------------------------------------------------
160	UInt_t fTLMUInputMask[18]; // masks TOF-to-TRD bits
161	UInt_t fTLMUInputStretch; // designates how long TLMU input is stretched
162	UInt_t** fTLMUcmatrices; // [matrix][section] unsigned int values
163	// Bits 0..17 identify supermodules, bits equal 1 are checked for coincidence
164
165	UInt_t** fTLMUmultiplicity; // [slice][0 = lower bound, 1 = upper bound]
166	// use a lower bound above 576 to disable
167
168	Int_t** fTLMUoutput; // [output][0 = cmatrix, 1 = multslice]
169	// output bit assignment, -1 disables
170
171	// T0 ------------------------------------------------------------------------
172	// [position][channel] 12 channels at A and C side
173	UInt_t** fFEBT0Thresholds; // threshold for analog value discrimination
174	//UInt_t** fFEBT0Delays; // delay is not used in simulation right now //TODO
175
176	// [position][LUT][0 = threshold, 1 = bitmask] 2 LUTs at A and C side
177	UInt_t*** fFEBT0Multiplicities; // multiplicity threshold for T0
178	Int_t*** fFEBT0LUTs; // look up tables [position][LUT][entry]
179
180	// V0 ------------------------------------------------------------------------
181	// [position][feb][channel] 4x8 channels per side (A and C)
182	UInt_t*** fFEBV0Thresholds; // threshold for analog value discrimation
183	//UInt_t** fFEBV0Delays; // delay is not used in simulation right now //TODO
184
185	// [position][feb][LUT][0 = threshold, 1 = bitmask] 2 LUTs per FEB
186	// (4 per Side) at each side ( A and C)
187	UInt_t**** fFEBV0Multiplicities; // multiplicity threshold for V0
188	Int_t**** fFEBV0LUTs; // look up tables [position][feb][LUT][entry]
189
190	// CB-{A/B/C}
191	// 0 = B, 1 = A, 2 = C
192	Int_t*** fCBLUTs; // control box look up tables
193
194	// CB-A ----------------------------------------------------------------------
195	TString fCBALUTequX; // logical equation used for generation of LUT X of CB-A
196	TString fCBALUTequY; // logical equation used for generation of LUT Y of CB-A
197
198	// CB-C ----------------------------------------------------------------------
199	TString fCBCLUTequX; // logical equation used for generation of LUT X of CB-C
200	TString fCBCLUTequY; // logical equation used for generation of LUT Y of CB-C
201
202	// CBB -----------------------------------------------------------------------
203	TString fCBBLUTequX; // logical equation used for generation of LUT X of CB-B
204	TString fCBBLUTequY; // logical equation used for generation of LUT Y of CB-B
205
206	// CTP -----------------------------------------------------------------------
207	// PT mask
208	AliTRDptrgPTmasks fPTmasks;
209	// masks usage of internal signals for the pretrigger wake up signal
210
211
212	// CBB-LUT to TriggerInput assignment
213
214	// class state ---------------------------------------------------------------
215
216	private:
217	AliTRDptrgParam(); // instance only via Instance()
218	AliTRDptrgParam(const AliTRDptrgParam &rhs); // not implemented
219	AliTRDptrgParam& operator=(const AliTRDptrgParam &rhs); // not implemented
220
221	ClassDef(AliTRDptrgParam, 1);
222	};
223	#endif