fb231c7ecb87a7db95f9764ab4768b87b3842cf9
[u/mrichter/AliRoot.git] / RALICE / AliAttrib.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 // $Id$
17
18 ///////////////////////////////////////////////////////////////////////////
19 // Class AliAttrib
20 // Generic handling of detector signal (calibration) attributes.
21 // Normally this class is only used as a base class to provide the various
22 // attributes to the derived class. An example of this is AliSignal.
23 // However, one can of course also use this class on its own as shown
24 // in the simple example hereafter.
25 //
26 // Example :
27 // ---------
28 // AliAttrib a;
29 // a.SetGain(250.7);
30 // a.SetSlotName("PMT amplitude in Volt");
31 // a.SetGain(1340,3);
32 // a.SetSlotName("PMT amplitude in ADC",3);
33 // a.SetEdgeOn(3);
34 // a.SetOffset(-22.5,2);
35 // a.SetSlotName("Time of flight in ns",2);
36 // a.SetDead(1);
37 // a.List();
38 //
39 //--- Author: Nick van Eijndhoven 18-sep-2003 Utrecht University
40 //- Modified: NvE $Date$ Utrecht University
41 ///////////////////////////////////////////////////////////////////////////
42
43 #include "AliAttrib.h"
44 #include "Riostream.h"
45  
46 ClassImp(AliAttrib) // Class implementation to enable ROOT I/O
47  
48 AliAttrib::AliAttrib()
49 {
50 // Creation of an AliAttrib object and initialisation of parameters.
51 // Several values of the same type (e.g. gain) can be stored in different slots.
52 // If needed, the storage for values will be expanded automatically
53 // when entering values.
54  fGains=0;
55  fOffsets=0;
56  fCalflags=0;
57  fNames=0;
58 }
59 ///////////////////////////////////////////////////////////////////////////
60 AliAttrib::~AliAttrib()
61 {
62 // Destructor to delete dynamically allocated memory
63  if (fGains)
64  {
65   delete fGains;
66   fGains=0;
67  }
68  if (fOffsets)
69  {
70   delete fOffsets;
71   fOffsets=0;
72  }
73  if (fCalflags)
74  {
75   delete fCalflags;
76   fCalflags=0;
77  }
78  if (fNames)
79  {
80   delete fNames;
81   fNames=0;
82  }
83 }
84 ///////////////////////////////////////////////////////////////////////////
85 AliAttrib::AliAttrib(const AliAttrib& a)
86 {
87 // Copy constructor
88  fGains=0;
89  fOffsets=0;
90  fCalflags=0;
91  fNames=0;
92
93  Int_t n=0;
94  Double_t val=0;
95
96  n=a.GetNgains();
97  for (Int_t ig=1; ig<=n; ig++)
98  {
99   val=a.GetGain(ig);
100   if (a.GetGainFlag(ig)) SetGain(val,ig);
101  }
102
103  n=a.GetNoffsets();
104  for (Int_t io=1; io<=n; io++)
105  {
106   val=a.GetOffset(io);
107   if (a.GetOffsetFlag(io)) SetOffset(val,io);
108  }
109
110  n=a.GetNcalflags();
111  for (Int_t ic=1; ic<=n; ic++)
112  {
113   SetEdgeValue(a.GetEdgeValue(ic),ic);
114   if (a.GetDeadValue(ic)) SetDead(ic);
115  }
116
117  n=a.GetNnames();
118  TString s;
119  for (Int_t in=1; in<=n; in++)
120  {
121   s=a.GetSlotName(in);
122   if (s!="") SetSlotName(s,in);
123  }
124 }
125 ///////////////////////////////////////////////////////////////////////////
126 Int_t AliAttrib::GetNgains() const
127 {
128 // Provide the number of specified gains for this attribute.
129  Int_t n=0;
130  if (fGains) n=fGains->GetSize();
131  return n;
132 }
133 ///////////////////////////////////////////////////////////////////////////
134 Int_t AliAttrib::GetNoffsets() const
135 {
136 // Provide the number of specified offsets for this attribute.
137  Int_t n=0;
138  if (fOffsets) n=fOffsets->GetSize();
139  return n;
140 }
141 ///////////////////////////////////////////////////////////////////////////
142 Int_t AliAttrib::GetNcalflags() const
143 {
144 // Provide the number of specified calib. flags for this attribute.
145  Int_t n=0;
146  if (fCalflags) n=fCalflags->GetSize();
147  return n;
148 }
149 ///////////////////////////////////////////////////////////////////////////
150 Int_t AliAttrib::GetNnames() const
151 {
152 // Provide the maximum number of specified names for this attribute.
153  Int_t n=0;
154  if (fNames) n=fNames->GetSize();
155  return n;
156 }
157 ///////////////////////////////////////////////////////////////////////////
158 void AliAttrib::SetGain(Double_t gain,Int_t j)
159 {
160 // Store gain value of the j-th (default j=1) attribute slot.
161 // Note : The first attribute slot is at j=1.
162 // In case the value of the index j exceeds the maximum number of reserved
163 // slots for gain values, the number of reserved slots for the gain
164 // values is increased automatically.
165
166  if (j<1) 
167  {
168   cout << " *AliAttrib::SetGain* Invalid argument j = " << j << endl;
169   return;
170  }
171
172  if (!fGains)
173  {
174   fGains=new TArrayF(j);
175  }
176
177  Int_t size=fGains->GetSize();
178
179  if (j>size)
180  {
181   fGains->Set(j);
182  }
183
184  fGains->AddAt(float(gain),j-1);
185
186  Int_t oflag=GetOffsetFlag(j);
187
188  SetCalFlags(1,oflag,j);
189 }
190 ///////////////////////////////////////////////////////////////////////////
191 void AliAttrib::SetGain(Double_t gain,TString name)
192 {
193 // Store gain value of the name-specified attribute slot.
194 //
195 // This procedure involves a slot-index search based on the specified name
196 // at each invokation. This may become slow in case many slots have been
197 // defined and/or when this procedure is invoked many times.
198 // In such cases it is preferable to use indexed addressing in the user code
199 // either directly or via a few invokations of GetSlotIndex().
200
201  Int_t j=GetSlotIndex(name);
202  if (j>0) SetGain(gain,j);
203 }
204 ///////////////////////////////////////////////////////////////////////////
205 void AliAttrib::SetOffset(Double_t off,Int_t j)
206 {
207 // Store offset value of the j-th (default j=1) attribute slot.
208 // Note : The first attribute slot is at j=1.
209 // In case the value of the index j exceeds the maximum number of reserved
210 // slots for offset values, the number of reserved slots for the offset
211 // values is increased automatically.
212
213  if (j<1) 
214  {
215   cout << " *AliAttrib::GetOffset* Invalid argument j = " << j << endl;
216   return;
217  }
218
219  if (!fOffsets)
220  {
221   fOffsets=new TArrayF(j);
222  }
223
224  Int_t size=fOffsets->GetSize();
225
226  if (j>size)
227  {
228   fOffsets->Set(j);
229  }
230
231  fOffsets->AddAt(float(off),j-1);
232
233  Int_t gflag=GetGainFlag(j);
234
235  SetCalFlags(gflag,1,j);
236 }
237 ///////////////////////////////////////////////////////////////////////////
238 void AliAttrib::SetOffset(Double_t off,TString name)
239 {
240 // Store offset value of the name-specified attribute slot.
241 //
242 // This procedure involves a slot-index search based on the specified name
243 // at each invokation. This may become slow in case many slots have been
244 // defined and/or when this procedure is invoked many times.
245 // In such cases it is preferable to use indexed addressing in the user code
246 // either directly or via a few invokations of GetSlotIndex().
247
248  Int_t j=GetSlotIndex(name);
249  if (j>0) SetOffset(off,j);
250 }
251 ///////////////////////////////////////////////////////////////////////////
252 void AliAttrib::SetCalFlags(Int_t gainflag,Int_t offsetflag,Int_t j)
253 {
254 // Store calibration flags of the j-th (default j=1) attribute slot.
255 // Note : The first attribute slot is at j=1.
256 // In case the value of the index j exceeds the maximum number of reserved
257 // slots for the calib. flags, the number of reserved slots for the calib.
258 // flags is increased automatically.
259 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
260
261  if (j<1) 
262  {
263   cout << " *AliAttrib::GetCalFlags* Invalid argument j = " << j << endl;
264   return;
265  }
266
267  if (!fCalflags)
268  {
269   fCalflags=new TArrayI(j);
270  }
271
272  Int_t size=fCalflags->GetSize();
273
274  if (j>size)
275  {
276   fCalflags->Set(j);
277  }
278
279  Int_t edge=GetEdgeValue(j);
280  Int_t dead=GetDeadValue(j);
281
282  Int_t word=1000*edge+100*dead+10*gainflag+offsetflag;
283  
284  fCalflags->AddAt(word,j-1);
285 }
286 ///////////////////////////////////////////////////////////////////////////
287 Int_t AliAttrib::GetGainFlag(Int_t j) const
288 {
289 // Provide gain flag of the j-th (default j=1) attribute slot.
290 //
291 // flag = 1 : Gain was set
292 //        0 : Gain was not set
293 //
294 // Note : The first attribute slot is at j=1.
295 // In case j is invalid, 0 is returned.
296
297  if (j<1) 
298  {
299   cout << " *AliAttrib::GetGainFlag* Invalid argument j = " << j << endl;
300   return 0;
301  }
302  Int_t gflag=0;
303  if (fCalflags)
304  {
305   if (j>0 && j<=(fCalflags->GetSize()))
306   {
307    Int_t word=fCalflags->At(j-1);
308    word=word%100;
309    gflag=word/10;
310   }
311  }
312  return gflag;
313 }
314 ///////////////////////////////////////////////////////////////////////////
315 Int_t AliAttrib::GetGainFlag(TString name) const
316 {
317 // Provide gain flag of the name-specified attribute slot.
318 //
319 // flag = 1 : Gain was set
320 //        0 : Gain was not set
321 //
322 //
323 // This procedure involves a slot-index search based on the specified name
324 // at each invokation. This may become slow in case many slots have been
325 // defined and/or when this procedure is invoked many times.
326 // In such cases it is preferable to use indexed addressing in the user code
327 // either directly or via a few invokations of GetSlotIndex().
328
329  Int_t j=GetSlotIndex(name);
330  Int_t flag=0;
331  if (j>0) flag=GetGainFlag(j);
332  return flag;
333 }
334 ///////////////////////////////////////////////////////////////////////////
335 Int_t AliAttrib::GetOffsetFlag(Int_t j) const
336 {
337 // Provide offset flag of the j-th (default j=1) attribute slot.
338 //
339 // flag = 1 : Offset was set
340 //        0 : Offset was not set
341 //
342 // Note : The first attribute slot is at j=1.
343 // In case j is invalid, 0 is returned.
344
345  if (j<1) 
346  {
347   cout << " *AliAttrib::GetOffsetFlag* Invalid argument j = " << j << endl;
348   return 0;
349  }
350
351  Int_t oflag=0;
352  if (fCalflags)
353  {
354   if (j>0 && j<=(fCalflags->GetSize()))
355   {
356    Int_t word=fCalflags->At(j-1);
357    oflag=word%10;
358   }
359  }
360  return oflag;
361 }
362 ///////////////////////////////////////////////////////////////////////////
363 Int_t AliAttrib::GetOffsetFlag(TString name) const
364 {
365 // Provide ofset flag of the name-specified attribute slot.
366 //
367 // flag = 1 : Offset was set
368 //        0 : Offset was not set
369 //
370 //
371 // This procedure involves a slot-index search based on the specified name
372 // at each invokation. This may become slow in case many slots have been
373 // defined and/or when this procedure is invoked many times.
374 // In such cases it is preferable to use indexed addressing in the user code
375 // either directly or via a few invokations of GetSlotIndex().
376
377  Int_t j=GetSlotIndex(name);
378  Int_t flag=0;
379  if (j>0) flag=GetOffsetFlag(j);
380  return flag;
381 }
382 ///////////////////////////////////////////////////////////////////////////
383 Float_t AliAttrib::GetGain(Int_t j) const
384 {
385 // Provide gain value of the j-th (default j=1) attribute slot.
386 // The first attribute slot is at j=1.
387 // In case no gain value was set or the argument j is invalid, 0 is returned.
388 // Note : Use GetGainFlag(j) to check whether this gain was set or not.
389
390  if (j<1) 
391  {
392   cout << " *AliAttrib::GetGain* Invalid argument j = " << j << endl;
393   return 0;
394  }
395
396  Float_t gain=0;
397  if (fGains)
398  {
399   if (j>0 && j<=(fGains->GetSize()))
400   {
401    if (GetGainFlag(j)) gain=fGains->At(j-1);
402   }
403  }
404  return gain;
405 }
406 ///////////////////////////////////////////////////////////////////////////
407 Float_t AliAttrib::GetGain(TString name) const
408 {
409 // Provide gain value of the name-specified attribute slot.
410 //
411 // This procedure involves a slot-index search based on the specified name
412 // at each invokation. This may become slow in case many slots have been
413 // defined and/or when this procedure is invoked many times.
414 // In such cases it is preferable to use indexed addressing in the user code
415 // either directly or via a few invokations of GetSlotIndex().
416
417  Int_t j=GetSlotIndex(name);
418  Float_t gain=0;
419  if (j>0) gain=GetGain(j);
420  return gain;
421 }
422 ///////////////////////////////////////////////////////////////////////////
423 Float_t AliAttrib::GetOffset(Int_t j) const
424 {
425 // Provide offset value of the j-th (default j=1) attribute slot.
426 // The first attribute slot at j=1.
427 // In case no offset value was set or the argument j is invalid, 0 is returned.
428 // Note : Use GetOffsetFlag(j) to check whether this offset was set or not.
429
430  if (j<1) 
431  {
432   cout << " *AliAttrib::GetOffset* Invalid argument j = " << j << endl;
433   return 0;
434  }
435
436  Float_t offset=0;
437  if (fOffsets)
438  {
439   if (j>0 && j<=(fOffsets->GetSize()))
440   {
441    if (GetOffsetFlag(j)) offset=fOffsets->At(j-1);
442   }
443  }
444  return offset;
445 }
446 ///////////////////////////////////////////////////////////////////////////
447 Float_t AliAttrib::GetOffset(TString name) const
448 {
449 // Provide offset value of the name-specified attribute slot.
450 //
451 // This procedure involves a slot-index search based on the specified name
452 // at each invokation. This may become slow in case many slots have been
453 // defined and/or when this procedure is invoked many times.
454 // In such cases it is preferable to use indexed addressing in the user code
455 // either directly or via a few invokations of GetSlotIndex().
456
457  Int_t j=GetSlotIndex(name);
458  Float_t offset=0;
459  if (j>0) offset=GetOffset(j);
460  return offset;
461 }
462 ///////////////////////////////////////////////////////////////////////////
463 void AliAttrib::ResetGain(Int_t j)
464 {
465 // Reset the gain value of the j-th (default j=1) attribute slot.
466 // Notes : The first attribute slot is at j=1.
467 //         j=0 ==> All gain values will be reset.
468  
469  if (!fGains) return;
470
471  Int_t size=fGains->GetSize();
472
473  if ((j>=0) && (j<=size))
474  {
475   if (j)
476   {
477    fGains->AddAt(0,j-1);
478    Int_t oflag=GetOffsetFlag(j);
479    SetCalFlags(0,oflag,j);
480   }
481   else
482   {
483    for (Int_t i=0; i<size; i++)
484    {
485     fGains->AddAt(0,i);
486     Int_t oflag=GetOffsetFlag(i);
487     SetCalFlags(0,oflag,i);
488    }
489   }
490  }
491  else
492  {
493   cout << " *AliAttrib::ResetGain* Index j = " << j << " invalid." << endl;
494   return;
495  }
496 }
497 ///////////////////////////////////////////////////////////////////////////
498 void AliAttrib::ResetGain(TString name)
499 {
500 // Reset the gain value of the name-specified attribute slot.
501 //
502 // This procedure involves a slot-index search based on the specified name
503 // at each invokation. This may become slow in case many slots have been
504 // defined and/or when this procedure is invoked many times.
505 // In such cases it is preferable to use indexed addressing in the user code
506 // either directly or via a few invokations of GetSlotIndex().
507
508  Int_t j=GetSlotIndex(name);
509  if (j>0) ResetGain(j);
510 }
511 ///////////////////////////////////////////////////////////////////////////
512 void AliAttrib::ResetOffset(Int_t j)
513 {
514 // Reset the offset value of the j-th (default j=1) attribute slot.
515 // Notes : The first attribute slot is at j=1.
516 //         j=0 ==> All offset values will be reset.
517  
518  if (!fOffsets) return;
519
520  Int_t size=fOffsets->GetSize();
521
522  if ((j>=0) && (j<=size))
523  {
524   if (j)
525   {
526    fOffsets->AddAt(0,j-1);
527    Int_t gflag=GetGainFlag(j);
528    SetCalFlags(gflag,0,j);
529   }
530   else
531   {
532    for (Int_t i=0; i<size; i++)
533    {
534     fOffsets->AddAt(0,i);
535     Int_t gflag=GetGainFlag(i);
536     SetCalFlags(gflag,0,i);
537    }
538   }
539  }
540  else
541  {
542   cout << " *AliAttrib::ResetOffset* Index j = " << j << " invalid." << endl;
543   return;
544  }
545 }
546 ///////////////////////////////////////////////////////////////////////////
547 void AliAttrib::ResetOffset(TString name)
548 {
549 // Reset the offset value of the name-specified attribute slot.
550 //
551 // This procedure involves a slot-index search based on the specified name
552 // at each invokation. This may become slow in case many slots have been
553 // defined and/or when this procedure is invoked many times.
554 // In such cases it is preferable to use indexed addressing in the user code
555 // either directly or via a few invokations of GetSlotIndex().
556
557  Int_t j=GetSlotIndex(name);
558  if (j>0) ResetOffset(j);
559 }
560 ///////////////////////////////////////////////////////////////////////////
561 void AliAttrib::DeleteCalibrations(Int_t mode)
562 {
563 // User selected delete of all gains and/or offsets.
564 // mode = 0 : All attributes (names, gains, offsets, edge and dead values) are deleted.
565 //        1 : Only the gains are deleted.
566 //        2 : Only the offsets are deleted.
567 //        3 : Both gains and offsets are deleted, but names, edge and dead values are kept.
568 //
569 // The default when invoking DeleteCalibrations() corresponds to mode=0.
570
571  if (mode<0 || mode>3)
572  {
573   cout << " *AliAttrib::DeleteCalibrations* Unknown mode : " << mode << endl;
574   cout << " Default mode=0 will be used." << endl;
575   mode=0;
576  }
577
578  if (mode==0 || mode==3)
579  {
580   ResetGain(0);
581   if (fGains)
582   {
583    delete fGains;
584    fGains=0;
585   }
586   ResetOffset(0);
587   if (fOffsets)
588   {
589    delete fOffsets;
590    fOffsets=0;
591   }
592   if (fCalflags && mode==0)
593   {
594    delete fCalflags;
595    fCalflags=0;
596   }
597   if (fNames && mode==0)
598   {
599    delete fNames;
600    fNames=0;
601   }
602   return;
603  }
604
605  if (mode==1)
606  {
607   ResetGain(0);
608   if (fGains)
609   {
610    delete fGains;
611    fGains=0;
612   }
613  }
614  else
615  {
616   ResetOffset(0);
617   if (fOffsets)
618   {
619    delete fOffsets;
620    fOffsets=0;
621   }
622  }
623 }
624 ///////////////////////////////////////////////////////////////////////////
625 void AliAttrib::SetDead(Int_t j)
626 {
627 // Set the dead flag to 1 for the j-th (default j=1) attribute slot.
628 // Note : The first attribute slot is at j=1.
629 // In case the value of the index j exceeds the maximum number of reserved
630 // slots for the flags, the number of reserved slots for the flags
631 // is increased automatically.
632 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
633
634  if (j<1) 
635  {
636   cout << " *AliAttrib::SetDead* Invalid argument j = " << j << endl;
637   return;
638  }
639
640  if (!fCalflags)
641  {
642   fCalflags=new TArrayI(j);
643  }
644
645  Int_t size=fCalflags->GetSize();
646
647  if (j>size)
648  {
649   fCalflags->Set(j);
650  }
651
652  Int_t dead=1;
653  Int_t oflag=GetOffsetFlag(j);
654  Int_t gflag=GetGainFlag(j);
655  Int_t edge=GetEdgeValue(j);
656
657  Int_t word=1000*edge+100*dead+10*gflag+oflag;
658  
659  fCalflags->AddAt(word,j-1);
660 }
661 ///////////////////////////////////////////////////////////////////////////
662 void AliAttrib::SetDead(TString name)
663 {
664 // Set the dead flag to 1 for the name-specified attribute slot.
665 //
666 // This procedure involves a slot-index search based on the specified name
667 // at each invokation. This may become slow in case many slots have been
668 // defined and/or when this procedure is invoked many times.
669 // In such cases it is preferable to use indexed addressing in the user code
670 // either directly or via a few invokations of GetSlotIndex().
671
672  Int_t j=GetSlotIndex(name);
673  if (j>0) SetDead(j);
674 }
675 ///////////////////////////////////////////////////////////////////////////
676 void AliAttrib::SetAlive(Int_t j)
677 {
678 // Set the dead flag to 0 for the j-th (default j=1) attribute slot.
679 // Note : The first attribute slot is at j=1.
680 // In case the value of the index j exceeds the maximum number of reserved
681 // slots for the flags, no action is taken since by default the dead flag is 0.
682 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
683
684  if (j<1) 
685  {
686   cout << " *AliAttrib::SetAlive* Invalid argument j = " << j << endl;
687   return;
688  }
689
690  if (!fCalflags || j>fCalflags->GetSize()) return;
691
692  Int_t dead=0;
693  Int_t oflag=GetOffsetFlag(j);
694  Int_t gflag=GetGainFlag(j);
695  Int_t edge=GetEdgeValue(j);
696
697  Int_t word=1000*edge+100*dead+10*gflag+oflag;
698  
699  fCalflags->AddAt(word,j-1);
700 }
701 ///////////////////////////////////////////////////////////////////////////
702 void AliAttrib::SetAlive(TString name)
703 {
704 // Set the dead flag to 0 for the name-specified attribute slot.
705 //
706 // This procedure involves a slot-index search based on the specified name
707 // at each invokation. This may become slow in case many slots have been
708 // defined and/or when this procedure is invoked many times.
709 // In such cases it is preferable to use indexed addressing in the user code
710 // either directly or via a few invokations of GetSlotIndex().
711
712  Int_t j=GetSlotIndex(name);
713  if (j>0) SetAlive(j);
714 }
715 ///////////////////////////////////////////////////////////////////////////
716 void AliAttrib::SetEdgeOn(Int_t j)
717 {
718 // Set the edge value to 1 for the j-th (default j=1) attribute slot.
719 // Note : The first attribute slot is at j=1.
720 // In case the value of the index j exceeds the maximum number of reserved
721 // slots for the flags, the number of reserved slots for the flags
722 // is increased automatically.
723 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
724
725  if (j<1) 
726  {
727   cout << " *AliAttrib::SetEdgeOn* Invalid argument j = " << j << endl;
728   return;
729  }
730
731  SetEdgeValue(1,j);
732 }
733 ///////////////////////////////////////////////////////////////////////////
734 void AliAttrib::SetEdgeOn(TString name)
735 {
736 // Set the edge value to 1 for the name-specified attribute slot.
737 //
738 // This procedure involves a slot-index search based on the specified name
739 // at each invokation. This may become slow in case many slots have been
740 // defined and/or when this procedure is invoked many times.
741 // In such cases it is preferable to use indexed addressing in the user code
742 // either directly or via a few invokations of GetSlotIndex().
743
744  Int_t j=GetSlotIndex(name);
745  if (j>0) SetEdgeOn(j);
746 }
747 ///////////////////////////////////////////////////////////////////////////
748 void AliAttrib::SetEdgeOff(Int_t j)
749 {
750 // Set the edge value to 0 for the j-th (default j=1) attribute slot.
751 // Note : The first attribute slot is at j=1.
752 // In case the value of the index j exceeds the maximum number of reserved
753 // slots for the flags, no action is taken since by default the edge flag is 0.
754 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
755
756  if (j<1) 
757  {
758   cout << " *AliAttrib::SetEdgeOff* Invalid argument j = " << j << endl;
759   return;
760  }
761
762  if (!fCalflags || j>fCalflags->GetSize()) return;
763
764  SetEdgeValue(0,j);
765 }
766 ///////////////////////////////////////////////////////////////////////////
767 void AliAttrib::SetEdgeOff(TString name)
768 {
769 // Set the edge value to 0 for the name-specified attribute slot.
770 //
771 // This procedure involves a slot-index search based on the specified name
772 // at each invokation. This may become slow in case many slots have been
773 // defined and/or when this procedure is invoked many times.
774 // In such cases it is preferable to use indexed addressing in the user code
775 // either directly or via a few invokations of GetSlotIndex().
776
777  Int_t j=GetSlotIndex(name);
778  if (j>0) SetEdgeOff(j);
779 }
780 ///////////////////////////////////////////////////////////////////////////
781 void AliAttrib::SetEdgeValue(Int_t val,Int_t j)
782 {
783 // Set the edge value to "val" for the j-th (default j=1) attribute slot.
784 // Note : The first attribute slot is at j=1.
785 // In case the value of the index j exceeds the maximum number of reserved
786 // slots for the flags, the number of reserved slots for the flags
787 // is increased automatically.
788 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
789
790  if (j<1) 
791  {
792   cout << " *AliAttrib::SetEdgeValue* Invalid argument j = " << j << endl;
793   return;
794  }
795
796  if (!fCalflags)
797  {
798   fCalflags=new TArrayI(j);
799  }
800
801  Int_t size=fCalflags->GetSize();
802
803  if (j>size)
804  {
805   fCalflags->Set(j);
806  }
807
808  Int_t edge=val;
809  Int_t dead=GetDeadValue(j);
810  Int_t gflag=GetGainFlag(j);
811  Int_t oflag=GetOffsetFlag(j);
812
813  Int_t word=1000*edge+100*dead+10*gflag+oflag;
814  
815  fCalflags->AddAt(word,j-1);
816 }
817 ///////////////////////////////////////////////////////////////////////////
818 void AliAttrib::SetEdgeValue(Int_t val,TString name)
819 {
820 // Set the edge value to "val" for the name-specified attribute slot.
821 //
822 // This procedure involves a slot-index search based on the specified name
823 // at each invokation. This may become slow in case many slots have been
824 // defined and/or when this procedure is invoked many times.
825 // In such cases it is preferable to use indexed addressing in the user code
826 // either directly or via a few invokations of GetSlotIndex().
827
828  Int_t j=GetSlotIndex(name);
829  if (j>0) SetEdgeValue(val,j);
830 }
831 ///////////////////////////////////////////////////////////////////////////
832 void AliAttrib::IncreaseEdgeValue(Int_t j)
833 {
834 // Increase the edge value by 1 for the j-th (default j=1) attribute slot.
835 // Note : The first attribute slot is at j=1.
836 // In case the value of the index j exceeds the maximum number of reserved
837 // slots for the flags, the number of reserved slots for the flags
838 // is increased automatically.
839 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
840
841  if (j<1) 
842  {
843   cout << " *AliAttrib::IncreaseEdgeValue* Invalid argument j = " << j << endl;
844   return;
845  }
846
847  Int_t edge=GetEdgeValue();
848  SetEdgeValue(edge+1,j);
849 }
850 ///////////////////////////////////////////////////////////////////////////
851 void AliAttrib::IncreaseEdgeValue(TString name)
852 {
853 // Increase the edge value by 1 for the name-specified attribute slot.
854 //
855 // This procedure involves a slot-index search based on the specified name
856 // at each invokation. This may become slow in case many slots have been
857 // defined and/or when this procedure is invoked many times.
858 // In such cases it is preferable to use indexed addressing in the user code
859 // either directly or via a few invokations of GetSlotIndex().
860
861  Int_t j=GetSlotIndex(name);
862  if (j>0) IncreaseEdgeValue(j);
863 }
864 ///////////////////////////////////////////////////////////////////////////
865 void AliAttrib::DecreaseEdgeValue(Int_t j)
866 {
867 // Decrease the edge value by 1 for the j-th (default j=1) attribute slot.
868 // Note : The first attribute slot is at j=1.
869 // In case the value of the index j exceeds the maximum number of reserved
870 // slots for the flags, the number of reserved slots for the flags
871 // is increased automatically.
872 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
873
874  if (j<1) 
875  {
876   cout << " *AliAttrib::DecreaseEdgeValue* Invalid argument j = " << j << endl;
877   return;
878  }
879
880  Int_t edge=GetEdgeValue();
881  SetEdgeValue(edge-1,j);
882 }
883 ///////////////////////////////////////////////////////////////////////////
884 void AliAttrib::DecreaseEdgeValue(TString name)
885 {
886 // Decrease the edge value by 1 for the name-specified attribute slot.
887 //
888 // This procedure involves a slot-index search based on the specified name
889 // at each invokation. This may become slow in case many slots have been
890 // defined and/or when this procedure is invoked many times.
891 // In such cases it is preferable to use indexed addressing in the user code
892 // either directly or via a few invokations of GetSlotIndex().
893
894  Int_t j=GetSlotIndex(name);
895  if (j>0) DecreaseEdgeValue(j);
896 }
897 ///////////////////////////////////////////////////////////////////////////
898 Int_t AliAttrib::GetEdgeValue(Int_t j) const
899 {
900 // Provide edge value of the j-th (default j=1) attribute slot.
901 // Note : The first attribute slot is at j=1.
902 // In case j is invalid, 0 is returned.
903
904  if (j<1) 
905  {
906   cout << " *AliAttrib::GetEdgeValue* Invalid argument j = " << j << endl;
907   return 0;
908  }
909
910  Int_t edge=0;
911  if (fCalflags)
912  {
913   if (j>0 && j<=(fCalflags->GetSize()))
914   {
915    Int_t word=fCalflags->At(j-1);
916    edge=word/1000;
917   }
918  }
919  return edge;
920 }
921 ///////////////////////////////////////////////////////////////////////////
922 Int_t AliAttrib::GetEdgeValue(TString name) const
923 {
924 // Provide edge value of the name-specified attribute slot.
925 //
926 // This procedure involves a slot-index search based on the specified name
927 // at each invokation. This may become slow in case many slots have been
928 // defined and/or when this procedure is invoked many times.
929 // In such cases it is preferable to use indexed addressing in the user code
930 // either directly or via a few invokations of GetSlotIndex().
931
932  Int_t j=GetSlotIndex(name);
933  Int_t val=0;
934  if (j>0) val=GetEdgeValue(j);
935  return val;
936 }
937 ///////////////////////////////////////////////////////////////////////////
938 Int_t AliAttrib::GetDeadValue(Int_t j) const
939 {
940 // Provide dead value of the j-th (default j=1) attribute slot.
941 // Note : The first attribute slot is at j=1.
942 // In case j is invalid, 0 is returned.
943
944  if (j<1) 
945  {
946   cout << " *AliAttrib::GetDeadValue* Invalid argument j = " << j << endl;
947   return 0;
948  }
949
950  Int_t dead=0;
951  if (fCalflags)
952  {
953   if (j>0 && j<=(fCalflags->GetSize()))
954   {
955    Int_t word=fCalflags->At(j-1);
956    word=word%1000;
957    dead=word/100;
958   }
959  }
960  return dead;
961 }
962 ///////////////////////////////////////////////////////////////////////////
963 Int_t AliAttrib::GetDeadValue(TString name) const
964 {
965 // Provide dead value of the name-specified attribute slot.
966 //
967 // This procedure involves a slot-index search based on the specified name
968 // at each invokation. This may become slow in case many slots have been
969 // defined and/or when this procedure is invoked many times.
970 // In such cases it is preferable to use indexed addressing in the user code
971 // either directly or via a few invokations of GetSlotIndex().
972
973  Int_t j=GetSlotIndex(name);
974  Int_t val=0;
975  if (j>0) val=GetDeadValue(j);
976  return val;
977 }
978 ///////////////////////////////////////////////////////////////////////////
979 void AliAttrib::SetSlotName(TString s,Int_t j)
980 {
981 // Set a user defined name for the j-th (default j=1) slot. 
982 // Note : The first attribute slot is at j=1.
983
984  if (j<1) 
985  {
986   cout << " *AliAttrib::SetSlotName* Invalid argument j = " << j << endl;
987   return;
988  }
989
990  if (!fNames)
991  {
992   fNames=new TObjArray(j);
993   fNames->SetOwner();
994  }
995
996  if (j>fNames->GetSize()) fNames->Expand(j);
997
998  TObjString* so=(TObjString*)fNames->At(j-1);
999  if (!so)
1000  {
1001   so=new TObjString(s.Data());
1002   fNames->AddAt(so,j-1);
1003  }
1004  else
1005  {
1006   so->SetString(s);
1007  }
1008 }
1009 ///////////////////////////////////////////////////////////////////////////
1010 TString AliAttrib::GetSlotName(Int_t j) const
1011 {
1012 // Provide the user defined name for the j-th (default j=1) slot. 
1013 // Note : The first attribute slot is at j=1.
1014
1015  TString s="";
1016  if (j<1) 
1017  {
1018   cout << " *AliAttrib::GetSlotName* Invalid argument j = " << j << endl;
1019   return s;
1020  }
1021
1022  if (fNames)
1023  {
1024   if (j<=fNames->GetSize())
1025   {
1026    TObjString* so=(TObjString*)fNames->At(j-1);
1027    if (so) s=so->GetString();
1028   }
1029  }
1030  return s;
1031 }
1032 ///////////////////////////////////////////////////////////////////////////
1033 Int_t AliAttrib::GetSlotIndex(TString name) const
1034 {
1035 // Provide the slot index for the matching name.
1036 // If no matching name is found, 0 is returned.
1037 // Note : The first attribute slot is at j=1.
1038
1039  Int_t index=0;
1040
1041  if (fNames)
1042  {
1043   TString s;
1044   Int_t size=fNames->GetSize();
1045   for (Int_t i=0; i<size; i++)
1046   {
1047    TObjString* so=(TObjString*)fNames->At(i);
1048    if (so) s=so->GetString();
1049    if (s==name) index=i+1;
1050   }
1051  }
1052  return index;
1053 }
1054 ///////////////////////////////////////////////////////////////////////////
1055 void AliAttrib::List(Int_t j) const
1056 {
1057 // Provide attribute information for the j-th slot.
1058 // The first slot is at j=1.
1059 // In case j=0 (default) the data of all slots will be listed.
1060
1061  if (j<0) 
1062  {
1063   cout << " *AliAttrib::Data* Invalid argument j = " << j << endl;
1064   return;
1065  }
1066
1067  if (j>0)
1068  {
1069   if (GetGainFlag(j)) cout << " gain : " << GetGain(j);
1070   if (GetOffsetFlag(j)) cout << " offset : " << GetOffset(j);
1071   if (GetEdgeValue(j)) cout << " edge : " << GetEdgeValue(j);
1072   if (GetDeadValue(j)) cout << " dead : " << GetDeadValue(j);
1073   TString s=GetSlotName(j);
1074   if (s!="") cout << " name : " << s.Data();
1075  }
1076  else
1077  {
1078   Int_t ng=GetNgains();
1079   Int_t no=GetNoffsets();
1080   Int_t nf=0;
1081   if (fCalflags) nf=fCalflags->GetSize();
1082   Int_t nn=GetNnames();
1083   Int_t n=ng;
1084   if (n<no) n=no;
1085   if (n<nn) n=nn;
1086   if (n<nf) n=nf;
1087   Int_t printf=0;
1088   TString s;
1089   for (Int_t i=1; i<=n; i++)
1090   {
1091    printf=0;
1092    if (GetGainFlag(i))   {cout << " gain : " << GetGain(i); printf=1;}
1093    if (GetOffsetFlag(i)) {cout << " offset : " << GetOffset(i); printf=1;}
1094    if (GetEdgeValue(i))  {cout << " edge : " << GetEdgeValue(i); printf=1;}
1095    if (GetDeadValue(i))  {cout << " dead : " << GetDeadValue(i); printf=1;}
1096    s=GetSlotName(i);
1097    if (s!="") {cout << " name : " << s.Data(); printf=1;}
1098    if (printf) cout << endl;
1099   }
1100  }
1101
1102 ///////////////////////////////////////////////////////////////////////////
1103 void AliAttrib::List(TString name) const
1104 {
1105 // Provide attribute information for the name-specified slot.
1106 //
1107 // This procedure involves a slot-index search based on the specified name
1108 // at each invokation. This may become slow in case many slots have been
1109 // defined and/or when this procedure is invoked many times.
1110 // In such cases it is preferable to use indexed addressing in the user code
1111 // either directly or via a few invokations of GetSlotIndex().
1112
1113  Int_t j=GetSlotIndex(name);
1114  if (j>0) List(j);
1115 }
1116 ///////////////////////////////////////////////////////////////////////////
1117 void AliAttrib::Load(AliAttrib& a,Int_t j)
1118 {
1119 // Load attributes of the j-th slot of the input AliAttrib into this AliAttrib object.
1120 // 
1121 // Note : if j=0, then all attributes of all slots are loaded
1122 //
1123 // The default is j=0.
1124
1125  if (j<0) 
1126  {
1127   cout << " *AliAttrib::Load* Invalid argument j = " << j << endl;
1128   return;
1129  }
1130
1131  Int_t n=0;
1132
1133  if (j==0) // load attributes for all slots
1134  {
1135   n=a.GetNgains();
1136   for (Int_t ig=1; ig<=n; ig++)
1137   {
1138    if (a.GetGainFlag(ig))
1139    {
1140     SetGain(a.GetGain(ig),ig);
1141    }
1142    else
1143    {
1144     ResetGain(ig);
1145    }
1146   }
1147   n=a.GetNoffsets();
1148   for (Int_t io=1; io<=n; io++)
1149   {
1150    if (a.GetOffsetFlag(io))
1151    {
1152     SetOffset(a.GetOffset(io),io);
1153    }
1154    else
1155    {
1156     ResetOffset(io);
1157    }
1158   }
1159   n=a.GetNcalflags();
1160   for (Int_t ic=1; ic<=n; ic++)
1161   {
1162    SetEdgeValue(a.GetEdgeValue(ic),ic);
1163    if (a.GetDeadValue(ic))
1164    {
1165     SetDead(ic);
1166    }
1167    else
1168    {
1169     SetAlive(ic);
1170    }
1171   }
1172   n=a.GetNnames();
1173   {
1174    TString s;
1175    for (Int_t in=1; in<=n; in++)
1176    {
1177     s=a.GetSlotName(in);
1178     if (s!="") SetSlotName(s,in);
1179    }
1180   }
1181  }
1182  else // load attributes for specified j-th slot only
1183  {
1184   n=a.GetNgains();
1185   if (j<=n)
1186   {
1187    if (a.GetGainFlag(j))
1188    {
1189     SetGain(a.GetGain(j),j);
1190    }
1191    else
1192    {
1193     ResetGain(j);
1194    }
1195   }
1196   n=a.GetNoffsets();
1197   if (j<=n)
1198   {
1199    if (a.GetOffsetFlag(j))
1200    {
1201     SetOffset(a.GetOffset(j),j);
1202    }
1203    else
1204    {
1205     ResetOffset(j);
1206    } 
1207   }
1208   n=a.GetNcalflags();
1209   if (j<=n)
1210   {
1211    SetEdgeValue(a.GetEdgeValue(j),j);
1212    if (a.GetDeadValue(j))
1213    {
1214     SetDead(j);
1215    }
1216    else
1217    {
1218     SetAlive(j);
1219    }
1220   }
1221   n=a.GetNnames();
1222   {
1223    TString s;
1224    if (j<=n)
1225    {
1226     s=a.GetSlotName(j);
1227     if (s!="") SetSlotName(s,j);
1228    }
1229   }
1230  }
1231 }
1232 ///////////////////////////////////////////////////////////////////////////
1233 void AliAttrib::Load(AliAttrib& a,TString name)
1234 {
1235 // Load attributes of the name-specified slot of the input AliAttrib into
1236 // this AliAttrib object.
1237 //
1238 // This procedure involves a slot-index search based on the specified name
1239 // at each invokation. This may become slow in case many slots have been
1240 // defined and/or when this procedure is invoked many times.
1241 // In such cases it is preferable to use indexed addressing in the user code
1242 // either directly or via a few invokations of GetSlotIndex().
1243
1244  Int_t j=GetSlotIndex(name);
1245  if (j>0) Load(a,j);
1246 }
1247 ///////////////////////////////////////////////////////////////////////////