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::SetOffset(Double_t off,Int_t j)
 192 {
 193 // Store offset value of the j-th (default j=1) attribute slot.
 194 // Note : The first attribute slot is at j=1.
 195 // In case the value of the index j exceeds the maximum number of reserved
 196 // slots for offset values, the number of reserved slots for the offset
 197 // values is increased automatically.
 198
 199  if (j<1)
 200  {
 201   cout << " *AliAttrib::GetOffset* Invalid argument j = " << j << endl;
 202   return;
 203  }
 204
 205  if (!fOffsets)
 206  {
 207   fOffsets=new TArrayF(j);
 208  }
 209
 210  Int_t size=fOffsets->GetSize();
 211
 212  if (j>size)
 213  {
 214   fOffsets->Set(j);
 215  }
 216
 217  fOffsets->AddAt(float(off),j-1);
 218
 219  Int_t gflag=GetGainFlag(j);
 220
 221  SetCalFlags(gflag,1,j);
 222 }
 223 ///////////////////////////////////////////////////////////////////////////
 224 void AliAttrib::SetCalFlags(Int_t gainflag,Int_t offsetflag,Int_t j)
 225 {
 226 // Store calibration flags of the j-th (default j=1) attribute slot.
 227 // Note : The first attribute slot is at j=1.
 228 // In case the value of the index j exceeds the maximum number of reserved
 229 // slots for the calib. flags, the number of reserved slots for the calib.
 230 // flags is increased automatically.
 231 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 232
 233  if (j<1)
 234  {
 235   cout << " *AliAttrib::GetCalFlags* Invalid argument j = " << j << endl;
 236   return;
 237  }
 238
 239  if (!fCalflags)
 240  {
 241   fCalflags=new TArrayI(j);
 242  }
 243
 244  Int_t size=fCalflags->GetSize();
 245
 246  if (j>size)
 247  {
 248   fCalflags->Set(j);
 249  }
 250
 251  Int_t edge=GetEdgeValue(j);
 252  Int_t dead=GetDeadValue(j);
 253
 254  Int_t word=1000*edge+100*dead+10*gainflag+offsetflag;
 255
 256  fCalflags->AddAt(word,j-1);
 257 }
 258 ///////////////////////////////////////////////////////////////////////////
 259 Int_t AliAttrib::GetGainFlag(Int_t j) const
 260 {
 261 // Provide gain flag of the j-th (default j=1) attribute slot.
 262 //
 263 // flag = 1 : Gain was set
 264 //        0 : Gain was not set
 265 //
 266 // Note : The first attribute slot is at j=1.
 267 // In case j is invalid, 0 is returned.
 268
 269  if (j<1)
 270  {
 271   cout << " *AliAttrib::GetGainFlag* Invalid argument j = " << j << endl;
 272   return 0;
 273  }
 274  Int_t gflag=0;
 275  if (fCalflags)
 276  {
 277   if (j>0 && j<=(fCalflags->GetSize()))
 278   {
 279    Int_t word=fCalflags->At(j-1);
 280    word=word%100;
 281    gflag=word/10;
 282   }
 283  }
 284  return gflag;
 285 }
 286 ///////////////////////////////////////////////////////////////////////////
 287 Int_t AliAttrib::GetOffsetFlag(Int_t j) const
 288 {
 289 // Provide offset flag of the j-th (default j=1) attribute slot.
 290 //
 291 // flag = 1 : Offset was set
 292 //        0 : Offset 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::GetOffsetFlag* Invalid argument j = " << j << endl;
 300   return 0;
 301  }
 302
 303  Int_t oflag=0;
 304  if (fCalflags)
 305  {
 306   if (j>0 && j<=(fCalflags->GetSize()))
 307   {
 308    Int_t word=fCalflags->At(j-1);
 309    oflag=word%10;
 310   }
 311  }
 312  return oflag;
 313 }
 314 ///////////////////////////////////////////////////////////////////////////
 315 Float_t AliAttrib::GetGain(Int_t j) const
 316 {
 317 // Provide gain value of the j-th (default j=1) attribute slot.
 318 // The first attribute slot is at j=1.
 319 // In case no gain value was set or the argument j is invalid, 0 is returned.
 320 // Note : Use GetGainFlag(j) to check whether this gain was set or not.
 321
 322  if (j<1)
 323  {
 324   cout << " *AliAttrib::GetGain* Invalid argument j = " << j << endl;
 325   return 0;
 326  }
 327
 328  Float_t gain=0;
 329  if (fGains)
 330  {
 331   if (j>0 && j<=(fGains->GetSize()))
 332   {
 333    if (GetGainFlag(j)) gain=fGains->At(j-1);
 334   }
 335  }
 336  return gain;
 337 }
 338 ///////////////////////////////////////////////////////////////////////////
 339 Float_t AliAttrib::GetOffset(Int_t j) const
 340 {
 341 // Provide offset value of the j-th (default j=1) attribute slot.
 342 // The first attribute slot at j=1.
 343 // In case no offset value was set or the argument j is invalid, 0 is returned.
 344 // Note : Use GetOffsetFlag(j) to check whether this offset was set or not.
 345
 346  if (j<1)
 347  {
 348   cout << " *AliAttrib::GetOffset* Invalid argument j = " << j << endl;
 349   return 0;
 350  }
 351
 352  Float_t offset=0;
 353  if (fOffsets)
 354  {
 355   if (j>0 && j<=(fOffsets->GetSize()))
 356   {
 357    if (GetOffsetFlag(j)) offset=fOffsets->At(j-1);
 358   }
 359  }
 360  return offset;
 361 }
 362 ///////////////////////////////////////////////////////////////////////////
 363 void AliAttrib::ResetGain(Int_t j)
 364 {
 365 // Reset the gain value of the j-th (default j=1) attribute slot.
 366 // Notes : The first attribute slot is at j=1.
 367 //         j=0 ==> All gain values will be reset.
 368
 369  if (!fGains) return;
 370
 371  Int_t size=fGains->GetSize();
 372
 373  if ((j>=0) && (j<=size))
 374  {
 375   if (j)
 376   {
 377    fGains->AddAt(0,j-1);
 378    Int_t oflag=GetOffsetFlag(j);
 379    SetCalFlags(0,oflag,j);
 380   }
 381   else
 382   {
 383    for (Int_t i=0; i<size; i++)
 384    {
 385     fGains->AddAt(0,i);
 386     Int_t oflag=GetOffsetFlag(i);
 387     SetCalFlags(0,oflag,i);
 388    }
 389   }
 390  }
 391  else
 392  {
 393   cout << " *AliAttrib::ResetGain* Index j = " << j << " invalid." << endl;
 394   return;
 395  }
 396 }
 397 ///////////////////////////////////////////////////////////////////////////
 398 void AliAttrib::ResetOffset(Int_t j)
 399 {
 400 // Reset the offset value of the j-th (default j=1) attribute slot.
 401 // Notes : The first attribute slot is at j=1.
 402 //         j=0 ==> All offset values will be reset.
 403
 404  if (!fOffsets) return;
 405
 406  Int_t size=fOffsets->GetSize();
 407
 408  if ((j>=0) && (j<=size))
 409  {
 410   if (j)
 411   {
 412    fOffsets->AddAt(0,j-1);
 413    Int_t gflag=GetGainFlag(j);
 414    SetCalFlags(gflag,0,j);
 415   }
 416   else
 417   {
 418    for (Int_t i=0; i<size; i++)
 419    {
 420     fOffsets->AddAt(0,i);
 421     Int_t gflag=GetGainFlag(i);
 422     SetCalFlags(gflag,0,i);
 423    }
 424   }
 425  }
 426  else
 427  {
 428   cout << " *AliAttrib::ResetOffset* Index j = " << j << " invalid." << endl;
 429   return;
 430  }
 431 }
 432 ///////////////////////////////////////////////////////////////////////////
 433 void AliAttrib::DeleteCalibrations(Int_t mode)
 434 {
 435 // User selected delete of all gains and/or offsets.
 436 // mode = 0 : All attributes (names, gains, offsets, edge and dead values) are deleted.
 437 //        1 : Only the gains are deleted.
 438 //        2 : Only the offsets are deleted.
 439 //        3 : Both gains and offsets are deleted, but names, edge and dead values are kept.
 440 //
 441 // The default when invoking DeleteCalibrations() corresponds to mode=0.
 442
 443  if (mode<0 || mode>3)
 444  {
 445   cout << " *AliAttrib::DeleteCalibrations* Unknown mode : " << mode << endl;
 446   cout << " Default mode=0 will be used." << endl;
 447   mode=0;
 448  }
 449
 450  if (mode==0 || mode==3)
 451  {
 452   ResetGain(0);
 453   if (fGains)
 454   {
 455    delete fGains;
 456    fGains=0;
 457   }
 458   ResetOffset(0);
 459   if (fOffsets)
 460   {
 461    delete fOffsets;
 462    fOffsets=0;
 463   }
 464   if (fCalflags && mode==0)
 465   {
 466    delete fCalflags;
 467    fCalflags=0;
 468   }
 469   if (fNames && mode==0)
 470   {
 471    delete fNames;
 472    fNames=0;
 473   }
 474   return;
 475  }
 476
 477  if (mode==1)
 478  {
 479   ResetGain(0);
 480   if (fGains)
 481   {
 482    delete fGains;
 483    fGains=0;
 484   }
 485  }
 486  else
 487  {
 488   ResetOffset(0);
 489   if (fOffsets)
 490   {
 491    delete fOffsets;
 492    fOffsets=0;
 493   }
 494  }
 495 }
 496 ///////////////////////////////////////////////////////////////////////////
 497 void AliAttrib::SetDead(Int_t j)
 498 {
 499 // Set the dead flag to 1 for the j-th (default j=1) attribute slot.
 500 // Note : The first attribute slot is at j=1.
 501 // In case the value of the index j exceeds the maximum number of reserved
 502 // slots for the flags, the number of reserved slots for the flags
 503 // is increased automatically.
 504 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 505
 506  if (j<1)
 507  {
 508   cout << " *AliAttrib::SetDead* Invalid argument j = " << j << endl;
 509   return;
 510  }
 511
 512  if (!fCalflags)
 513  {
 514   fCalflags=new TArrayI(j);
 515  }
 516
 517  Int_t size=fCalflags->GetSize();
 518
 519  if (j>size)
 520  {
 521   fCalflags->Set(j);
 522  }
 523
 524  Int_t dead=1;
 525  Int_t oflag=GetOffsetFlag(j);
 526  Int_t gflag=GetGainFlag(j);
 527  Int_t edge=GetEdgeValue(j);
 528
 529  Int_t word=1000*edge+100*dead+10*gflag+oflag;
 530
 531  fCalflags->AddAt(word,j-1);
 532 }
 533 ///////////////////////////////////////////////////////////////////////////
 534 void AliAttrib::SetAlive(Int_t j)
 535 {
 536 // Set the dead flag to 0 for the j-th (default j=1) attribute slot.
 537 // Note : The first attribute slot is at j=1.
 538 // In case the value of the index j exceeds the maximum number of reserved
 539 // slots for the flags, no action is taken since by default the dead flag is 0.
 540 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 541
 542  if (j<1)
 543  {
 544   cout << " *AliAttrib::SetAlive* Invalid argument j = " << j << endl;
 545   return;
 546  }
 547
 548  if (!fCalflags || j>fCalflags->GetSize()) return;
 549
 550  Int_t dead=0;
 551  Int_t oflag=GetOffsetFlag(j);
 552  Int_t gflag=GetGainFlag(j);
 553  Int_t edge=GetEdgeValue(j);
 554
 555  Int_t word=1000*edge+100*dead+10*gflag+oflag;
 556
 557  fCalflags->AddAt(word,j-1);
 558 }
 559 ///////////////////////////////////////////////////////////////////////////
 560 void AliAttrib::SetEdgeOn(Int_t j)
 561 {
 562 // Set the edge value to 1 for the j-th (default j=1) attribute slot.
 563 // Note : The first attribute slot is at j=1.
 564 // In case the value of the index j exceeds the maximum number of reserved
 565 // slots for the flags, the number of reserved slots for the flags
 566 // is increased automatically.
 567 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 568
 569  if (j<1)
 570  {
 571   cout << " *AliAttrib::SetEdgeOn* Invalid argument j = " << j << endl;
 572   return;
 573  }
 574
 575  SetEdgeValue(1,j);
 576 }
 577 ///////////////////////////////////////////////////////////////////////////
 578 void AliAttrib::SetEdgeOff(Int_t j)
 579 {
 580 // Set the edge value to 0 for the j-th (default j=1) attribute slot.
 581 // Note : The first attribute slot is at j=1.
 582 // In case the value of the index j exceeds the maximum number of reserved
 583 // slots for the flags, no action is taken since by default the edge flag is 0.
 584 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 585
 586  if (j<1)
 587  {
 588   cout << " *AliAttrib::SetEdgeOff* Invalid argument j = " << j << endl;
 589   return;
 590  }
 591
 592  if (!fCalflags || j>fCalflags->GetSize()) return;
 593
 594  SetEdgeValue(0,j);
 595 }
 596 ///////////////////////////////////////////////////////////////////////////
 597 void AliAttrib::SetEdgeValue(Int_t val,Int_t j)
 598 {
 599 // Set the edge value to "val" for the j-th (default j=1) attribute slot.
 600 // Note : The first attribute slot is at j=1.
 601 // In case the value of the index j exceeds the maximum number of reserved
 602 // slots for the flags, the number of reserved slots for the flags
 603 // is increased automatically.
 604 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 605
 606  if (j<1)
 607  {
 608   cout << " *AliAttrib::SetEdgeValue* Invalid argument j = " << j << endl;
 609   return;
 610  }
 611
 612  if (!fCalflags)
 613  {
 614   fCalflags=new TArrayI(j);
 615  }
 616
 617  Int_t size=fCalflags->GetSize();
 618
 619  if (j>size)
 620  {
 621   fCalflags->Set(j);
 622  }
 623
 624  Int_t edge=val;
 625  Int_t dead=GetDeadValue(j);
 626  Int_t gflag=GetGainFlag(j);
 627  Int_t oflag=GetOffsetFlag(j);
 628
 629  Int_t word=1000*edge+100*dead+10*gflag+oflag;
 630
 631  fCalflags->AddAt(word,j-1);
 632 }
 633 ///////////////////////////////////////////////////////////////////////////
 634 void AliAttrib::IncreaseEdgeValue(Int_t j)
 635 {
 636 // Increase the edge value by 1 for the j-th (default j=1) attribute slot.
 637 // Note : The first attribute slot is at j=1.
 638 // In case the value of the index j exceeds the maximum number of reserved
 639 // slots for the flags, the number of reserved slots for the flags
 640 // is increased automatically.
 641 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 642
 643  if (j<1)
 644  {
 645   cout << " *AliAttrib::IncreaseEdgeValue* Invalid argument j = " << j << endl;
 646   return;
 647  }
 648
 649  Int_t edge=GetEdgeValue();
 650  SetEdgeValue(edge+1,j);
 651 }
 652 ///////////////////////////////////////////////////////////////////////////
 653 void AliAttrib::DecreaseEdgeValue(Int_t j)
 654 {
 655 // Decrease the edge value by 1 for the j-th (default j=1) attribute slot.
 656 // Note : The first attribute slot is at j=1.
 657 // In case the value of the index j exceeds the maximum number of reserved
 658 // slots for the flags, the number of reserved slots for the flags
 659 // is increased automatically.
 660 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 661
 662  if (j<1)
 663  {
 664   cout << " *AliAttrib::DecreaseEdgeValue* Invalid argument j = " << j << endl;
 665   return;
 666  }
 667
 668  Int_t edge=GetEdgeValue();
 669  SetEdgeValue(edge-1,j);
 670 }
 671 ///////////////////////////////////////////////////////////////////////////
 672 Int_t AliAttrib::GetEdgeValue(Int_t j) const
 673 {
 674 // Provide edge value of the j-th (default j=1) attribute slot.
 675 // Note : The first attribute slot is at j=1.
 676 // In case j is invalid, 0 is returned.
 677
 678  if (j<1)
 679  {
 680   cout << " *AliAttrib::GetEdgeValue* Invalid argument j = " << j << endl;
 681   return 0;
 682  }
 683
 684  Int_t edge=0;
 685  if (fCalflags)
 686  {
 687   if (j>0 && j<=(fCalflags->GetSize()))
 688   {
 689    Int_t word=fCalflags->At(j-1);
 690    edge=word/1000;
 691   }
 692  }
 693  return edge;
 694 }
 695 ///////////////////////////////////////////////////////////////////////////
 696 Int_t AliAttrib::GetDeadValue(Int_t j) const
 697 {
 698 // Provide dead value of the j-th (default j=1) attribute slot.
 699 // Note : The first attribute slot is at j=1.
 700 // In case j is invalid, 0 is returned.
 701
 702  if (j<1)
 703  {
 704   cout << " *AliAttrib::GetDeadValue* Invalid argument j = " << j << endl;
 705   return 0;
 706  }
 707
 708  Int_t dead=0;
 709  if (fCalflags)
 710  {
 711   if (j>0 && j<=(fCalflags->GetSize()))
 712   {
 713    Int_t word=fCalflags->At(j-1);
 714    word=word%1000;
 715    dead=word/100;
 716   }
 717  }
 718  return dead;
 719 }
 720 ///////////////////////////////////////////////////////////////////////////
 721 void AliAttrib::SetSlotName(TString s,Int_t j)
 722 {
 723 // Set a user defined name for the j-th (default j=1) slot.
 724 // Note : The first attribute slot is at j=1.
 725
 726  if (j<1)
 727  {
 728   cout << " *AliAttrib::SetSlotName* Invalid argument j = " << j << endl;
 729   return;
 730  }
 731
 732  if (!fNames)
 733  {
 734   fNames=new TObjArray(j);
 735   fNames->SetOwner();
 736  }
 737
 738  if (j>fNames->GetSize()) fNames->Expand(j);
 739
 740  TObjString* so=(TObjString*)fNames->At(j-1);
 741  if (!so)
 742  {
 743   so=new TObjString(s.Data());
 744   fNames->AddAt(so,j-1);
 745  }
 746  else
 747  {
 748   so->SetString(s);
 749  }
 750 }
 751 ///////////////////////////////////////////////////////////////////////////
 752 TString AliAttrib::GetSlotName(Int_t j) const
 753 {
 754 // Provide the user defined name for the j-th (default j=1) slot.
 755 // Note : The first attribute slot is at j=1.
 756
 757  TString s="";
 758  if (j<1)
 759  {
 760   cout << " *AliAttrib::GetSlotName* Invalid argument j = " << j << endl;
 761   return s;
 762  }
 763
 764  if (fNames)
 765  {
 766   if (j<=fNames->GetSize())
 767   {
 768    TObjString* so=(TObjString*)fNames->At(j-1);
 769    if (so) s=so->GetString();
 770   }
 771  }
 772  return s;
 773 }
 774 ///////////////////////////////////////////////////////////////////////////
 775 Int_t AliAttrib::GetSlotIndex(TString name) const
 776 {
 777 // Provide the slot index for the matching name.
 778 // If no matching name is found, 0 is returned.
 779 // Note : The first attribute slot is at j=1.
 780
 781  Int_t index=0;
 782
 783  if (fNames)
 784  {
 785   TString s;
 786   Int_t size=fNames->GetSize();
 787   for (Int_t i=0; i<size; i++)
 788   {
 789    TObjString* so=(TObjString*)fNames->At(i);
 790    if (so) s=so->GetString();
 791    if (s==name) index=i+1;
 792   }
 793  }
 794  return index;
 795 }
 796 ///////////////////////////////////////////////////////////////////////////
 797 void AliAttrib::List(Int_t j) const
 798 {
 799 // Provide attribute information for the j-th slot.
 800 // The first slot is at j=1.
 801 // In case j=0 (default) the data of all slots will be listed.
 802
 803  if (j<0)
 804  {
 805   cout << " *AliAttrib::Data* Invalid argument j = " << j << endl;
 806   return;
 807  }
 808
 809  if (j>0)
 810  {
 811   if (GetGainFlag(j)) cout << " gain : " << GetGain(j);
 812   if (GetOffsetFlag(j)) cout << " offset : " << GetOffset(j);
 813   if (GetEdgeValue(j)) cout << " edge : " << GetEdgeValue(j);
 814   if (GetDeadValue(j)) cout << " dead : " << GetDeadValue(j);
 815   TString s=GetSlotName(j);
 816   if (s!="") cout << " name : " << s.Data();
 817  }
 818  else
 819  {
 820   Int_t ng=GetNgains();
 821   Int_t no=GetNoffsets();
 822   Int_t nf=0;
 823   if (fCalflags) nf=fCalflags->GetSize();
 824   Int_t nn=GetNnames();
 825   Int_t n=ng;
 826   if (n<no) n=no;
 827   if (n<nn) n=nn;
 828   if (n<nf) n=nf;
 829   Int_t printf=0;
 830   TString s;
 831   for (Int_t i=1; i<=n; i++)
 832   {
 833    printf=0;
 834    if (GetGainFlag(i))   {cout << " gain : " << GetGain(i); printf=1;}
 835    if (GetOffsetFlag(i)) {cout << " offset : " << GetOffset(i); printf=1;}
 836    if (GetEdgeValue(i))  {cout << " edge : " << GetEdgeValue(i); printf=1;}
 837    if (GetDeadValue(i))  {cout << " dead : " << GetDeadValue(i); printf=1;}
 838    s=GetSlotName(i);
 839    if (s!="") {cout << " name : " << s.Data(); printf=1;}
 840    if (printf) cout << endl;
 841   }
 842  }
 843 }
 844 ///////////////////////////////////////////////////////////////////////////
 845 void AliAttrib::Load(AliAttrib& a,Int_t j)
 846 {
 847 // Load attributes of the j-th slot of the input AliAttrib into this AliAttrib object.
 848 //
 849 // Note : if j=0, then all attributes of all slots are loaded
 850 //
 851 // The default is j=0.
 852
 853  if (j<0)
 854  {
 855   cout << " *AliAttrib::Load* Invalid argument j = " << j << endl;
 856   return;
 857  }
 858
 859  Int_t n=0;
 860
 861  if (j==0) // load attributes for all slots
 862  {
 863   n=a.GetNgains();
 864   for (Int_t ig=1; ig<=n; ig++)
 865   {
 866    if (a.GetGainFlag(ig))
 867    {
 868     SetGain(a.GetGain(ig),ig);
 869    }
 870    else
 871    {
 872     ResetGain(ig);
 873    }
 874   }
 875   n=a.GetNoffsets();
 876   for (Int_t io=1; io<=n; io++)
 877   {
 878    if (a.GetOffsetFlag(io))
 879    {
 880     SetOffset(a.GetOffset(io),io);
 881    }
 882    else
 883    {
 884     ResetOffset(io);
 885    }
 886   }
 887   n=a.GetNcalflags();
 888   for (Int_t ic=1; ic<=n; ic++)
 889   {
 890    SetEdgeValue(a.GetEdgeValue(ic),ic);
 891    if (a.GetDeadValue(ic))
 892    {
 893     SetDead(ic);
 894    }
 895    else
 896    {
 897     SetAlive(ic);
 898    }
 899   }
 900   n=a.GetNnames();
 901   {
 902    TString s;
 903    for (Int_t in=1; in<=n; in++)
 904    {
 905     s=a.GetSlotName(in);
 906     if (s!="") SetSlotName(s,in);
 907    }
 908   }
 909  }
 910  else // load attributes for specified j-th slot only
 911  {
 912   n=a.GetNgains();
 913   if (j<=n)
 914   {
 915    if (a.GetGainFlag(j))
 916    {
 917     SetGain(a.GetGain(j),j);
 918    }
 919    else
 920    {
 921     ResetGain(j);
 922    }
 923   }
 924   n=a.GetNoffsets();
 925   if (j<=n)
 926   {
 927    if (a.GetOffsetFlag(j))
 928    {
 929     SetOffset(a.GetOffset(j),j);
 930    }
 931    else
 932    {
 933     ResetOffset(j);
 934    }
 935   }
 936   n=a.GetNcalflags();
 937   if (j<=n)
 938   {
 939    SetEdgeValue(a.GetEdgeValue(j),j);
 940    if (a.GetDeadValue(j))
 941    {
 942     SetDead(j);
 943    }
 944    else
 945    {
 946     SetAlive(j);
 947    }
 948   }
 949   n=a.GetNnames();
 950   {
 951    TString s;
 952    if (j<=n)
 953    {
 954     s=a.GetSlotName(j);
 955     if (s!="") SetSlotName(s,j);
 956    }
 957   }
 958  }
 959 }
 960 ///////////////////////////////////////////////////////////////////////////