]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSTriggerConditions.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bug fix in the vertex selection
[u/mrichter/AliRoot.git] / ITS / AliITSTriggerConditions.cxx
CommitLineData
ad7f2bfa 1////////////////////////////////////////////////////////////////////////////////////
2// Author: Henrik Tydesjo //
3// //
4// Implementation of conditions data from Pixel Trigger (PIT) //
5// //
6// The information is propagated from pixel trigger system to DCS file exchange //
7// server (text file format). The ReadFromTextFile method will populate this //
8// object with the values from the text file. Via a Preprocessor, this object //
9// can be stored in OCDB. //
10// //
11// One can also manually create conditions data that may be interesting for //
12// simulation. //
13// //
14////////////////////////////////////////////////////////////////////////////////////
15
16#include "AliITSTriggerConditions.h"
17#include "AliITSTriggerAlgorithmConditions.h"
18#include <TError.h>
19#include <fstream>
20
21ClassImp(AliITSTriggerConditions)
22
23//__________________________________________________________________________________
24AliITSTriggerConditions::AliITSTriggerConditions() :
25TObject(),
26fRunNumber(0),
27fFirmWareVersion(0),
28fGlobalDescription("n/a"),
29fVersionRegister(0),
30fInputConditionsVersion(0),
31fParametersVersion(0),
32fInActiveChips(1200),
33fNumAlgo(0),
34fAlgoList(TObjArray(10))
35{
36 // default constructor
37 fAlgoList.SetOwner(kTRUE);
38}
39//__________________________________________________________________________________
40AliITSTriggerConditions::AliITSTriggerConditions(const AliITSTriggerConditions& cond) :
41TObject(),
42fRunNumber(cond.fRunNumber),
43fFirmWareVersion(cond.fFirmWareVersion),
44fGlobalDescription(cond.fGlobalDescription),
45fVersionRegister(cond.fVersionRegister),
46fInputConditionsVersion(cond.fInputConditionsVersion),
47fParametersVersion(cond.fParametersVersion),
48fInActiveChips(cond.fInActiveChips),
49fNumAlgo(cond.fNumAlgo),
50fAlgoList(cond.fAlgoList)
51{
52 // copy constructor
53 fAlgoList.SetOwner(kTRUE);
54}
55//__________________________________________________________________________________
56AliITSTriggerConditions::~AliITSTriggerConditions()
57{
58 // destructor
59 ClearAlgorithms();
60}
61//______________________________________________________________________
62AliITSTriggerConditions& AliITSTriggerConditions::operator=(const AliITSTriggerConditions& cond) {
63 // assignment operator
64 if (this!=&cond) {
65 fRunNumber = cond.fRunNumber;
66 fFirmWareVersion = cond.fFirmWareVersion;
67 fGlobalDescription = cond.fGlobalDescription;
68 fVersionRegister = cond.fVersionRegister;
69 fInputConditionsVersion = cond.fInputConditionsVersion;
70 fParametersVersion = cond.fParametersVersion;
71 fInActiveChips = cond.fInActiveChips;
72 fNumAlgo = cond.fNumAlgo;
73 fAlgoList = cond.fAlgoList;
74 }
75 return *this;
76}
77//__________________________________________________________________________________
78void AliITSTriggerConditions::DumpAll() const {
79 // Dumps all conditions data
80
81 printf("[Header]\n");
82 printf("RUN_NUMBER = %d\n",fRunNumber);
83 printf("PROCESSING_FIRMWARE_VERSION = %d\n",fFirmWareVersion);
84 printf("GLOBAL_DESCRIPTION = %s\n",fGlobalDescription.Data());
85 printf("VERSION_REGISTER_VALUE = %d\n",fVersionRegister);
86 printf("INPUT_CONDITIONS_VERSION = %d\n",fInputConditionsVersion);
87 printf("PARAMETERS_VERSION = %d\n",fParametersVersion);
88 printf("\n");
89
90 printf("[Outputs]\n");
91 for (UInt_t i=0; i<fNumAlgo; i++) {
92 printf("%d = '%s', '%s'\n", GetAlgoIDI(i), GetAlgoLabelI(i), GetAlgoDescriptionI(i));
93 }
94 printf("\n");
95
96 printf("[Output_parameters]\n");
97 for (UInt_t i=0; i<fNumAlgo; i++) {
98 printf("%d =", GetAlgoIDI(i));
99 for (Short_t p=0; p<GetNumAlgoParamI(i); p++) {
100 printf(" '%s', %d;", GetAlgoParamNameII(i,p), GetAlgoParamValueII(i,p));
101 }
102 printf("\n");
103 }
104 printf("\n");
105
106 printf("[Active_chips]\n");
107 for (UInt_t eq=0; eq<20; eq++) {
108 for (UInt_t hs=0; hs<6; hs++) {
109 UInt_t nActiveOnHs = 0;
110 TString inactiveStr = "";
111 for (UInt_t chip=0; chip<10; chip++) {
112 Bool_t isChipActive = IsChipActive(eq,hs,chip);
113 inactiveStr.Append(Form("%d",isChipActive));
114 nActiveOnHs+=isChipActive;
115 }
116 if (nActiveOnHs<10) {
117 printf("%d,%c,%d=%s\n", eq%10, eq<10 ? 'A' : 'C', hs, inactiveStr.Data());
118 }
119 }
120 }
121
122}
123//__________________________________________________________________________________
124void AliITSTriggerConditions::ResetAll() {
125 // clear all data, and put default values
126 fRunNumber=0;
127 fFirmWareVersion=0;
128 fGlobalDescription="n/a";
129 fVersionRegister=0;
130 fInputConditionsVersion=0;
131 fParametersVersion=0;
132 ResetInActiveChips();
133 ClearAlgorithms();
134}
135//__________________________________________________________________________________
136void AliITSTriggerConditions::ClearAlgorithms() {
137 // clears the list of algorithms
138 fAlgoList.Clear();
139 fNumAlgo=0;
140}
141//__________________________________________________________________________________
142void AliITSTriggerConditions::ClearAlgoParamsI(UShort_t aIndex) {
143 // clears the list of parameters for algorithm with index aIndex
144 if (aIndex>=fNumAlgo) {
145 Error("AliITSTriggerConditions::ClearAlgoParamsI", "index %d out of range", aIndex);
146 return;
147 }
148 ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(aIndex))->ClearParams();
149}
150//__________________________________________________________________________________
151void AliITSTriggerConditions::ClearAlgoParamsL(const Char_t* aLabel) {
152 // clears the list of parameters for algorithm with label aLabel
153 UShort_t findIndex=fNumAlgo;
154 for (UInt_t i=0; i<fNumAlgo; i++) {
155 if (strcmp(((AliITSTriggerAlgorithmConditions*)fAlgoList.At(i))->GetLabel(),aLabel) == 0) {
156 findIndex = i;
157 break;
158 }
159 }
160 if (findIndex==fNumAlgo) {
161 Error("AliITSTriggerConditions::ClearAlgoParamsL", "label %s not found", aLabel);
162 }
163 ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(findIndex))->ClearParams();
164}
165//__________________________________________________________________________________
166void AliITSTriggerConditions::AddAlgo(UShort_t id, const Char_t* aLabel, const Char_t* aDescr) {
167 // adds a new algorithm with id 'id', label aLabel, and description aDescr
168 // if the id or label is already used in the list of algorithms, the old entry will be over-written
169 UShort_t findIndex=fNumAlgo;
170 for (UInt_t i=0; i<fNumAlgo; i++) {
171 if (strcmp(((AliITSTriggerAlgorithmConditions*)fAlgoList.At(i))->GetLabel(), aLabel) == 0 ||
172 ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(i))->GetID() == id ) {
173 findIndex = i;
174 break;
175 }
176 }
177 if (findIndex<fNumAlgo) {
178 delete fAlgoList.At(findIndex);
179 fAlgoList.AddAt(new AliITSTriggerAlgorithmConditions(id,aLabel,aDescr),findIndex);
180 }
181 else {
182 fAlgoList.AddAtAndExpand(new AliITSTriggerAlgorithmConditions(id,aLabel,aDescr),fNumAlgo);
183 fNumAlgo++;
184 }
185}
186//__________________________________________________________________________________
187void AliITSTriggerConditions::AddAlgoParam(UShort_t id, const Char_t* name, Int_t value) {
188 // adds a new parameter with name 'name' and value 'value', for the algorithm with id 'id'
189 UShort_t findIndex=fNumAlgo;
190 for (UInt_t i=0; i<fNumAlgo; i++) {
191 if (((AliITSTriggerAlgorithmConditions*)fAlgoList.At(i))->GetID() == id) {
192 findIndex = i;
193 break;
194 }
195 }
196 if (findIndex==fNumAlgo) {
197 Error("AliITSTriggerConditions::AddAlgoParam", "id %d not found", id);
198 return;
199 }
200 ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(findIndex))->AddParam(name, value);
201}
202//__________________________________________________________________________________
203Short_t AliITSTriggerConditions::GetAlgoIndexL(const Char_t* aLabel) const {
204 // returns the index for the algorithm with label aLabel
205 UShort_t findIndex=fNumAlgo;
206 for (UInt_t i=0; i<fNumAlgo; i++) {
207 if (strcmp(((AliITSTriggerAlgorithmConditions*)fAlgoList.At(i))->GetLabel(), aLabel) == 0) {
208 findIndex = i;
209 break;
210 }
211 }
212 if (findIndex==fNumAlgo) {
213 Error("AliITSTriggerConditions::GetAlgoIndexL", "label %s not found", aLabel);
214 return -1;
215 }
216 return findIndex;
217}
218//__________________________________________________________________________________
219Short_t AliITSTriggerConditions::GetAlgoIDI(UShort_t aIndex) const {
220 // returns the ID for the algorithm with index aIndex (in real life, could be 1-10)
221 if (aIndex>=fNumAlgo) {
222 Error("AliITSTriggerConditions::GetAlgoIDI", "index %d out of range", aIndex);
223 return -1;
224 }
225 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(aIndex))->GetID();
226}
227//__________________________________________________________________________________
228const Char_t* AliITSTriggerConditions::GetAlgoLabelI(UShort_t aIndex) const {
229 // returns the label for the algorithm with index aIndex
230 if (aIndex>=fNumAlgo) {
231 Error("AliITSTriggerConditions::GetAlgoLabelI", "index %d out of range", aIndex);
232 return "";
233 }
234 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(aIndex))->GetLabel();
235}
236//__________________________________________________________________________________
237const Char_t* AliITSTriggerConditions::GetAlgoDescriptionI(UShort_t aIndex) const {
238 // returns the description for the algorithm with index aIndex
239 if (aIndex>=fNumAlgo) {
240 Error("AliITSTriggerConditions::GetAlgoDescriptionI", "index %d out of range", aIndex);
241 return "";
242 }
243 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(aIndex))->GetDescription();
244}
245//__________________________________________________________________________________
246Short_t AliITSTriggerConditions::GetNumAlgoParamI(UShort_t aIndex) const {
247 // returns the number of parameters, corresponding to the algorithm with index aIndex
248 if (aIndex>=fNumAlgo) {
249 Error("AliITSTriggerConditions::GetNumAlgoParamI", "index %d out of range", aIndex);
250 return -1;
251 }
252 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(aIndex))->GetNumParam();
253}
254//__________________________________________________________________________________
255const Char_t* AliITSTriggerConditions::GetAlgoParamNameII(UShort_t aIndex, UShort_t pIndex) const {
256 // returns the parameter name for the parameter with index pIndex, corresponding to the algorithm with index aIndex
257 if (aIndex>=fNumAlgo) {
258 Error("AliITSTriggerConditions::GetAlgoParamNameII", "index %d out of range", aIndex);
259 return "";
260 }
261 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(aIndex))->GetParamNameI(pIndex);
262}
263//__________________________________________________________________________________
264Int_t AliITSTriggerConditions::GetAlgoParamValueII(UShort_t aIndex, UShort_t pIndex) const {
265 // returns the parameter value for the parameter with index pIndex, corresponding to the algorithm with index aIndex
266 if (aIndex>=fNumAlgo) {
267 Error("AliITSTriggerConditions::GetAlgoParamValueII", "index %d out of range", aIndex);
268 return -1;
269 }
270 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(aIndex))->GetParamValueI(pIndex);
271}
272//__________________________________________________________________________________
273Int_t AliITSTriggerConditions::GetAlgoParamValueIN(UShort_t aIndex, const Char_t* pName) const {
274 // returns parameter value for the parameter named pName, corresponding to the algorithm with index aIndex
275 if (aIndex>=fNumAlgo) {
276 Error("AliITSTriggerConditions::GetAlgoParamValueIN", "index %d out of range", aIndex);
277 return -1;
278 }
279 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(aIndex))->GetParamValueN(pName);
280}
281//__________________________________________________________________________________
282Short_t AliITSTriggerConditions::GetNumAlgoParamL(const Char_t* aLabel) const {
283 // returns the number of parameters, corresponding to the algorithm with label aLabel
284 UShort_t findIndex=fNumAlgo;
285 for (UInt_t i=0; i<fNumAlgo; i++) {
286 if (strcmp(((AliITSTriggerAlgorithmConditions*)fAlgoList.At(i))->GetLabel(), aLabel) == 0) {
287 findIndex = i;
288 break;
289 }
290 }
291 if (findIndex==fNumAlgo) {
292 Error("AliITSTriggerConditions::GetNumAlgoParamL", "label %s not found", aLabel);
293 return -1;
294 }
295 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(findIndex))->GetNumParam();
296}
297//__________________________________________________________________________________
298const Char_t* AliITSTriggerConditions::GetAlgoParamNameLI(const Char_t* aLabel, UShort_t pIndex) const {
299 // returns parameter name for the parameter with index pIndex, corresponding to the algorithm with label aLabel
300 UShort_t findIndex=fNumAlgo;
301 for (UInt_t i=0; i<fNumAlgo; i++) {
302 if (strcmp(((AliITSTriggerAlgorithmConditions*)fAlgoList.At(i))->GetLabel(), aLabel) == 0) {
303 findIndex = i;
304 break;
305 }
306 }
307 if (findIndex==fNumAlgo) {
308 Error("AliITSTriggerConditions::GetAlgoParamNameLI", "label %s not found", aLabel);
309 return "";
310 }
311 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(findIndex))->GetParamNameI(pIndex);
312}
313//__________________________________________________________________________________
314Int_t AliITSTriggerConditions::GetAlgoParamValueLI(const Char_t* aLabel, UShort_t pIndex) const {
315 // returns parameter value for the parameter with index pIndex, corresponding to the algorithm with label aLabel
316 UShort_t findIndex=fNumAlgo;
317 for (UInt_t i=0; i<fNumAlgo; i++) {
318 if (strcmp(((AliITSTriggerAlgorithmConditions*)fAlgoList.At(i))->GetLabel(), aLabel) == 0) {
319 findIndex = i;
320 break;
321 }
322 }
323 if (findIndex==fNumAlgo) {
324 Error("AliITSTriggerConditions::GetAlgoParamValueLI", "label %s not found", aLabel);
325 return -1;
326 }
327 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(findIndex))->GetParamValueI(pIndex);
328}
329//__________________________________________________________________________________
330Int_t AliITSTriggerConditions::GetAlgoParamValueLN(const Char_t* aLabel, const Char_t* pName) const {
331 // returns parameter value for the parameter named pName, corresponding to the algorithm with label aLabel
332 UShort_t findIndex=fNumAlgo;
333 for (UInt_t i=0; i<fNumAlgo; i++) {
334 if (strcmp(((AliITSTriggerAlgorithmConditions*)fAlgoList.At(i))->GetLabel(), aLabel) == 0) {
335 findIndex = i;
336 break;
337 }
338 }
339 if (findIndex==fNumAlgo) {
340 Error("AliITSTriggerConditions::GetAlgoParamValueLN", "label %s not found", aLabel);
341 return -1;
342 }
343 return ((AliITSTriggerAlgorithmConditions*)fAlgoList.At(findIndex))->GetParamValueN(pName);
344}
345//__________________________________________________________________________________
346UInt_t AliITSTriggerConditions::GetChipKey(Int_t eq, Int_t hs, Int_t chip) const {
347 // translates eq,hs,chip numbers into one integer key (0-1199)
348 if (eq<0 || eq>=20 || hs<0 || hs>=6 || chip<0 || chip>=10) {
349 Error("AliITSTriggerConditions::GetChipKey", "eq,hs,chip = %d,%d,%d out of range",eq,hs,chip);
350 return 0;
351 }
352 return eq*60 + hs*10 + chip;
353}
354//__________________________________________________________________________________
355void AliITSTriggerConditions::GetChipFromKey(UInt_t key, Int_t& eq, Int_t& hs, Int_t& chip) const {
356 // translates a chip key back into eq,hs,chip numbers
357 if (key>=1200) {
358 Error("AliITSTriggerConditions::GetChipFromKey", "key = %d out of range", key);
359 return;
360 }
361 eq = key/60;
362 hs = (key%60)/10;
363 chip = key%10;
364}
365//__________________________________________________________________________________
366Bool_t AliITSTriggerConditions::GetNextInActiveChip(Int_t& eq, Int_t& hs, Int_t& chip) const {
367 // Returns true if an in-active chip was found (start looking after the bit number
368 // corresponding to the input parameters eq,hs,chip).
369 // If either of eq,hs,chip < 0 , start from beginning of TBits array.
370 // See example of usage in AliITSDetTypeRec::RemoveFastOrFiredInActive.
371 UInt_t searchIndex;
372 if (eq<0 || hs<0 || chip<0) searchIndex = 0;
373 else searchIndex = GetChipKey(eq, hs, chip) + 1;
374 UInt_t nextIndex = fInActiveChips.FirstSetBit(searchIndex);
375 if (nextIndex==1200) return kFALSE;
376 GetChipFromKey(nextIndex, eq, hs, chip);
377 return kTRUE;
378}
379//__________________________________________________________________________________
380void AliITSTriggerConditions::DumpInActiveChips() const {
381 // Prints a list of all inactive chips
382 UInt_t startBit=0;
383 UInt_t occ=0;
384 while (startBit<1200) {
385 startBit = fInActiveChips.FirstSetBit(startBit);
386 if (startBit<1200) {
387 occ++;
388 Int_t eq,hs,chip;
389 GetChipFromKey(startBit,eq,hs,chip);
390 printf("%3d: %d,%d,%d\n",occ,eq,hs,chip);
391 startBit++;
392 }
393 }
394}
395//__________________________________________________________________________________
396void AliITSTriggerConditions::ReadFromTextFile(const Char_t* fileName) {
397 // Reads conditions from text file (file format is used online by PIT system)
398
399 ResetAll();
400
401 const Int_t maxS = 500;
402 enum headers {HEAD, OUTPUT, PARAM, ACTIVECHIP};
403
404 ifstream file;
405 file.open(fileName, ifstream::in);
406 if (file.fail()) {
407 Error("AliITSTriggerConditions::ReadFromTextFile","No file (%s) present.",fileName);
408 return;
409 }
410
411 Int_t headType = -1; // no header read from start
412 UInt_t nl = 0;
413 Char_t cline[maxS];
414 while(!file.eof()) {
415 // *** get line
416 nl++;
417 file.getline(cline,maxS);
418 TString line(cline);
419
420 // *** remove comments from line
421 Int_t skipPos = line.First('#');
422 if (skipPos>=0) {
423 line.Remove(skipPos,maxS);
424 }
425
426 // *** check what type of information the line has (header or not...)
427 Int_t brackPos1 = line.First('[');
428 Int_t brackPos2 = line.First(']');
429 if (brackPos1==0 && brackPos2-1>brackPos1) {
430 // *** parse header line (header has to come first on the line)
431 TString headword = line(brackPos1+1,brackPos2-1-brackPos1);
432 if (headword.CompareTo("Header", TString::kIgnoreCase) == 0) headType = HEAD;
433 else if (headword.CompareTo("Outputs", TString::kIgnoreCase) == 0) headType = OUTPUT;
434 else if (headword.CompareTo("Output_parameters",TString::kIgnoreCase) == 0) headType = PARAM;
435 else if (headword.CompareTo("Active_chips", TString::kIgnoreCase) == 0) headType = ACTIVECHIP;
436 }
437 else {
438 // *** parse non-header line
439
440 // HEAD data
441 if (headType==HEAD) {
442 TString descrWord, valueWord;
443 if (! SplitStringIn2(line,descrWord,valueWord,'=')) continue;
444 descrWord.ReplaceAll(" ","");
445 valueWord.Remove(TString::kBoth,' ');
446
447 if (descrWord.CompareTo("RUN_NUMBER",TString::kIgnoreCase) == 0 && valueWord.IsDigit()) {
448 SetRunNumber(valueWord.Atoi());
449 }
450 else if (descrWord.CompareTo("PROCESSING_FIRMWARE_VERSION",TString::kIgnoreCase) == 0 && valueWord.IsDigit()) {
451 SetFirmWareVersion(valueWord.Atoi());
452 }
453 else if (descrWord.CompareTo("GLOBAL_DESCRIPTION",TString::kIgnoreCase) == 0) {
454 SetGlobalDescription(valueWord.Data());
455 }
456 else if (descrWord.CompareTo("VERSION_REGISTER_VALUE",TString::kIgnoreCase) == 0 && valueWord.IsDigit()) {
457 SetVersionRegister(valueWord.Atoi());
458 }
459 else if (descrWord.CompareTo("INPUT_CONDITIONS_VERSION",TString::kIgnoreCase) == 0 && valueWord.IsDigit()) {
460 SetInputConditionsVersion(valueWord.Atoi());
461 }
462 else if (descrWord.CompareTo("PARAMETERS_VERSION",TString::kIgnoreCase) == 0 && valueWord.IsDigit()) {
463 SetParametersVersion(valueWord.Atoi());
464 }
465 }
466 // OUTPUT data
467 else if (headType==OUTPUT) {
468 TString idWord, labelWord, descrWord, restWord;
469 if (! SplitStringIn2(line,idWord,restWord,'=')) continue;
470 if (! idWord.IsDigit()) continue;
471 if (! SplitStringIn2(restWord,labelWord,descrWord,',')) continue;
472 labelWord = GetStringBetween(labelWord,'\'','\'');
473 descrWord = GetStringBetween(descrWord,'\'','\'');
474 if (labelWord.Length()==0 || descrWord.Length()==0) continue;
475 // printf("id: %d , label '%s' , descr '%s'\n", idWord.Atoi(),labelWord.Data(),descrWord.Data());
476 AddAlgo(idWord.Atoi(),labelWord.Data(),descrWord.Data());
477 }
478 // PARAM data
479 else if (headType==PARAM) {
480 TString idWord, restWord;
481 if (! SplitStringIn2(line,idWord,restWord,'=')) continue;
482 if (! idWord.IsDigit()) continue;
483 while (restWord.Length()>0) {
484 TString parWord, nameWord, valWord;
485 SplitStringIn2(restWord,parWord,restWord,';');
486 if (! SplitStringIn2(parWord,nameWord,valWord,',')) break;
487 nameWord = GetStringBetween(nameWord,'\'','\'');
488 if (nameWord.Length()==0 || valWord.Length()==0 || ! valWord.IsDigit()) break;
489 // printf("id %d , param %s , value %d\n",idWord.Atoi(),nameWord.Data(),valWord.Atoi());
490 AddAlgoParam(idWord.Atoi(),nameWord.Data(),valWord.Atoi());
491 }
492 }
493 // ACTIVECHIP data
494 if (headType==ACTIVECHIP) {
495 TString eqWord, sideWord, hsWord, chipWord, restWord;
496 if (! SplitStringIn2(line,eqWord,restWord,',')) continue;
497 if (! eqWord.IsDigit()) continue;
498 UInt_t eq = eqWord.Atoi();
499 if (eq>=20) continue;
500 if (! SplitStringIn2(restWord,sideWord,restWord,',')) continue;
501 sideWord.ReplaceAll(" ","");
502 if (sideWord.CompareTo("A",TString::kIgnoreCase) == 0) {}
503 else if (sideWord.CompareTo("C",TString::kIgnoreCase) == 0) eq+=10;
504 else continue;
505 if (! SplitStringIn2(restWord,hsWord,chipWord,'=')) continue;
506 if (! hsWord.IsDigit()) continue;
507 UInt_t hs = hsWord.Atoi();
508 if (hs>=6) continue;
509 chipWord.ReplaceAll(" ","");
510 if (chipWord.Length()!=10) continue;
511 for (UInt_t chip=0; chip<10; chip++) {
512 if (chipWord[9-chip]=='0') {
513 // printf("Chip %d,%d,%d inactive\n",eq,hs,chip);
514 SetInActiveChip(eq,hs,chip);
515 }
516 }
517 }
518
519 }
520 }
521 file.close();
522}
523//__________________________________________________________________________________
524Bool_t AliITSTriggerConditions::SplitStringIn2(TString orig, TString& word1, TString& word2, Char_t sep) {
525 // splits a string in two parts (one before separator character and one after)
526 Int_t sepPos = orig.First(sep);
527 if (sepPos<0) sepPos = orig.Length();
528 word1 = orig(0,sepPos);
529 word2 = orig(sepPos+1,orig.Length());
530 return (word1.Length()>0 && word2.Length()>0);
531}
532//__________________________________________________________________________________
533TString AliITSTriggerConditions::GetStringBetween(TString orig, Char_t sep1, Char_t sep2) {
534 // returns string between separator character 1 and separator character 2
535 Int_t pos1 = orig.First(sep1);
536 if (pos1<0) return "";
537 TString ret = orig(pos1+1,orig.Length());
538 Int_t pos2 = ret.First(sep2);
539 if (pos2<0) return "";
540 ret = ret(0,pos2);
541 return ret;
542}
543//__________________________________________________________________________________
544Bool_t AliITSTriggerConditions::IsEqualTo(AliITSTriggerConditions *cond) const {
545 // checks if this object contains the same information as the input cond object
546 if (fRunNumber != cond->GetRunNumber()) return kFALSE;
547 if (fFirmWareVersion != cond->GetFirmWareVersion()) return kFALSE;
548 if (fGlobalDescription.CompareTo(cond->GetGlobalDescription()) !=0) return kFALSE;
549 if (fVersionRegister != cond->GetVersionRegister()) return kFALSE;
550 if (fInputConditionsVersion != cond->GetInputConditionsVersion()) return kFALSE;
551 if (fParametersVersion != cond->GetParametersVersion()) return kFALSE;
552
553 for (UInt_t eq=0; eq<20; eq++) {
554 for (UInt_t hs=0; hs<6; hs++) {
555 for (UInt_t chip=0; chip<10; chip++) {
556 if (IsChipActive(eq,hs,chip) != cond->IsChipActive(eq,hs,chip)) return kFALSE;
557 }
558 }
559 }
560
561 if (fNumAlgo != cond->GetNumAlgo()) return kFALSE;
562 for (Short_t alg1=0; alg1<fNumAlgo; alg1++) {
563 Short_t alg2 = cond->GetAlgoIndexL(GetAlgoLabelI(alg1));
564 if (alg2<0) return kFALSE;
565 if (GetAlgoIDI(alg1) != cond->GetAlgoIDI(alg2)) return kFALSE;
566 if (strcmp(GetAlgoDescriptionI(alg1), cond->GetAlgoDescriptionI(alg2)) != 0) return kFALSE;
567 if (GetNumAlgoParamI(alg1) != cond->GetNumAlgoParamI(alg2)) return kFALSE;
568 for (Short_t par1=0; par1<GetNumAlgoParamI(alg1); par1++) {
569 const Char_t* paramName = GetAlgoParamNameII(alg1,par1);
570 if (GetAlgoParamValueIN(alg1,paramName) != cond->GetAlgoParamValueIN(alg2,paramName)) return kFALSE;
571 }
572 }
573
574 return kTRUE;
575}