Added two missing includes to allow macro compilation (thanks to Laurent for remarkin...
[u/mrichter/AliRoot.git] / ITS / AliITSTriggerConditions.cxx
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
21 ClassImp(AliITSTriggerConditions)
22
23 //__________________________________________________________________________________
24 AliITSTriggerConditions::AliITSTriggerConditions() :
25 TObject(),
26 fRunNumber(0),
27 fFirmWareVersion(0),
28 fGlobalDescription("n/a"),
29 fVersionRegister(0),
30 fInputConditionsVersion(0),
31 fParametersVersion(0),
32 fInActiveChips(1200),
33 fNumAlgo(0),
34 fAlgoList(TObjArray(10))
35 {
36   // default constructor
37   fAlgoList.SetOwner(kTRUE);
38 }
39 //__________________________________________________________________________________
40 AliITSTriggerConditions::AliITSTriggerConditions(const AliITSTriggerConditions& cond) :
41 TObject(),
42 fRunNumber(cond.fRunNumber),
43 fFirmWareVersion(cond.fFirmWareVersion),
44 fGlobalDescription(cond.fGlobalDescription),
45 fVersionRegister(cond.fVersionRegister),
46 fInputConditionsVersion(cond.fInputConditionsVersion),
47 fParametersVersion(cond.fParametersVersion),
48 fInActiveChips(cond.fInActiveChips),
49 fNumAlgo(cond.fNumAlgo),
50 fAlgoList(cond.fAlgoList)
51 {
52   // copy constructor
53   fAlgoList.SetOwner(kTRUE);
54 }
55 //__________________________________________________________________________________
56 AliITSTriggerConditions::~AliITSTriggerConditions() 
57 {
58   // destructor
59   ClearAlgorithms();
60 }
61 //______________________________________________________________________
62 AliITSTriggerConditions& 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 //__________________________________________________________________________________
78 void 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 //__________________________________________________________________________________
124 void 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 //__________________________________________________________________________________
136 void AliITSTriggerConditions::ClearAlgorithms() {
137   // clears the list of algorithms
138   fAlgoList.Clear();
139   fNumAlgo=0;
140 }
141 //__________________________________________________________________________________
142 void 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 //__________________________________________________________________________________
151 void 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 //__________________________________________________________________________________
166 void 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 //__________________________________________________________________________________
187 void 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 //__________________________________________________________________________________
203 Short_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 //__________________________________________________________________________________
219 Short_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 //__________________________________________________________________________________
228 const 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 //__________________________________________________________________________________
237 const 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 //__________________________________________________________________________________
246 Short_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 //__________________________________________________________________________________
255 const 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 //__________________________________________________________________________________
264 Int_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 //__________________________________________________________________________________
273 Int_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 //__________________________________________________________________________________
282 Short_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 //__________________________________________________________________________________
298 const 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 //__________________________________________________________________________________
314 Int_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 //__________________________________________________________________________________
330 Int_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 //__________________________________________________________________________________
346 UInt_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 //__________________________________________________________________________________
355 void 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 //__________________________________________________________________________________
366 Bool_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 //__________________________________________________________________________________
380 void 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 //__________________________________________________________________________________
396 void 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 //__________________________________________________________________________________
524 Bool_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 //__________________________________________________________________________________
533 TString 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 //__________________________________________________________________________________
544 Bool_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 }