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.SetSlotName("PMT amplitude in Volt");
  30 // a.SetGain(250.7);
  31 // a.SetSlotName("Time of flight in ns",2);
  32 // a.SetOffset(-22.5,2);
  33 // a.SetSlotName("PMT amplitude in ADC",3);
  34 // a.SetGain(1340,3);
  35 // a.SetSlotName("TDC",4);
  36 // a.SetOffset(10.75,"TDC");
  37 // a.SetEdgeOn(3);
  38 // a.SetDead(1);
  39 // a.List();
  40 //
  41 //--- Author: Nick van Eijndhoven 18-sep-2003 Utrecht University
  42 //- Modified: NvE $Date$ Utrecht University
  43 ///////////////////////////////////////////////////////////////////////////
  44
  45 #include "AliAttrib.h"
  46 #include "Riostream.h"
  47
  48 ClassImp(AliAttrib) // Class implementation to enable ROOT I/O
  49
  50 AliAttrib::AliAttrib()
  51 {
  52 // Creation of an AliAttrib object and initialisation of parameters.
  53 // Several values of the same type (e.g. gain) can be stored in different slots.
  54 // If needed, the storage for values will be expanded automatically
  55 // when entering values.
  56  fGains=0;
  57  fOffsets=0;
  58  fCalflags=0;
  59  fNames=0;
  60  fCalfuncs=0;
  61  fDecalfuncs=0;
  62 }
  63 ///////////////////////////////////////////////////////////////////////////
  64 AliAttrib::~AliAttrib()
  65 {
  66 // Destructor to delete dynamically allocated memory
  67  if (fGains)
  68  {
  69   delete fGains;
  70   fGains=0;
  71  }
  72  if (fOffsets)
  73  {
  74   delete fOffsets;
  75   fOffsets=0;
  76  }
  77  if (fCalflags)
  78  {
  79   delete fCalflags;
  80   fCalflags=0;
  81  }
  82  if (fNames)
  83  {
  84   delete fNames;
  85   fNames=0;
  86  }
  87  if (fCalfuncs)
  88  {
  89   delete fCalfuncs;
  90   fCalfuncs=0;
  91  }
  92  if (fDecalfuncs)
  93  {
  94   delete fDecalfuncs;
  95   fDecalfuncs=0;
  96  }
  97 }
  98 ///////////////////////////////////////////////////////////////////////////
  99 AliAttrib::AliAttrib(const AliAttrib& a)
 100 {
 101 // Copy constructor
 102  fGains=0;
 103  fOffsets=0;
 104  fCalflags=0;
 105  fNames=0;
 106  fCalfuncs=0;
 107  fDecalfuncs=0;
 108
 109  Int_t n=0;
 110  Double_t val=0;
 111
 112  n=a.GetNgains();
 113  for (Int_t ig=1; ig<=n; ig++)
 114  {
 115   val=a.GetGain(ig);
 116   if (a.GetGainFlag(ig)) SetGain(val,ig);
 117  }
 118
 119  n=a.GetNoffsets();
 120  for (Int_t io=1; io<=n; io++)
 121  {
 122   val=a.GetOffset(io);
 123   if (a.GetOffsetFlag(io)) SetOffset(val,io);
 124  }
 125
 126  n=a.GetNcalflags();
 127  for (Int_t ic=1; ic<=n; ic++)
 128  {
 129   SetEdgeValue(a.GetEdgeValue(ic),ic);
 130   if (a.GetDeadValue(ic)) SetDead(ic);
 131  }
 132
 133  n=a.GetNnames();
 134  TString s;
 135  for (Int_t in=1; in<=n; in++)
 136  {
 137   s=a.GetSlotName(in);
 138   if (s!="") SetSlotName(s,in);
 139  }
 140
 141  n=a.GetNcalfuncs();
 142  for (Int_t icalf=1; icalf<=n; icalf++)
 143  {
 144   TF1* f=a.GetCalFunction(icalf);
 145   if (f) SetCalFunction(f,icalf);
 146  }
 147
 148  n=a.GetNdecalfuncs();
 149  for (Int_t idecalf=1; idecalf<=n; idecalf++)
 150  {
 151   TF1* f=a.GetDecalFunction(idecalf);
 152   if (f) SetDecalFunction(f,idecalf);
 153  }
 154 }
 155 ///////////////////////////////////////////////////////////////////////////
 156 Int_t AliAttrib::GetNgains() const
 157 {
 158 // Provide the number of specified gains for this attribute.
 159
 160  if (!fGains) return 0;
 161
 162  Int_t n=0;
 163  for (Int_t i=1; i<=fGains->GetSize(); i++)
 164  {
 165   if (GetGainFlag(i)) n=i;
 166  }
 167
 168  return n;
 169 }
 170 ///////////////////////////////////////////////////////////////////////////
 171 Int_t AliAttrib::GetNoffsets() const
 172 {
 173 // Provide the number of specified offsets for this attribute.
 174
 175  if (!fOffsets) return 0;
 176
 177  Int_t n=0;
 178  for (Int_t i=1; i<=fOffsets->GetSize(); i++)
 179  {
 180   if (GetOffsetFlag(i)) n=i;
 181  }
 182
 183  return n;
 184 }
 185 ///////////////////////////////////////////////////////////////////////////
 186 Int_t AliAttrib::GetNcalflags() const
 187 {
 188 // Provide the number of specified calib. flags for this attribute.
 189
 190  if (!fCalflags) return 0;
 191
 192  Int_t n=0;
 193  for (Int_t i=1; i<=fCalflags->GetSize(); i++)
 194  {
 195   if (fCalflags->At(i-1)) n=i;
 196  }
 197
 198  return n;
 199 }
 200 ///////////////////////////////////////////////////////////////////////////
 201 Int_t AliAttrib::GetNnames() const
 202 {
 203 // Provide the maximum number of specified names for this attribute.
 204
 205  if (!fNames) return 0;
 206
 207  Int_t n=0;
 208  for (Int_t i=1; i<=fNames->GetSize(); i++)
 209  {
 210   if (fNames->At(i-1)) n=i;
 211  }
 212
 213  return n;
 214 }
 215 ///////////////////////////////////////////////////////////////////////////
 216 void AliAttrib::SetGain(Double_t gain,Int_t j)
 217 {
 218 // Store gain value of the j-th (default j=1) attribute slot.
 219 // Note : The first attribute slot is at j=1.
 220 // In case the value of the index j exceeds the maximum number of reserved
 221 // slots for gain values, the number of reserved slots for the gain
 222 // values is increased automatically.
 223
 224  if (j<1)
 225  {
 226   cout << " *AliAttrib::SetGain* Invalid argument j = " << j << endl;
 227   return;
 228  }
 229
 230  if (!fGains)
 231  {
 232   fGains=new TArrayF(j);
 233  }
 234
 235  Int_t size=fGains->GetSize();
 236
 237  if (j>size)
 238  {
 239   fGains->Set(j);
 240  }
 241
 242  fGains->AddAt(float(gain),j-1);
 243
 244  Int_t oflag=GetOffsetFlag(j);
 245
 246  SetCalFlags(1,oflag,j);
 247 }
 248 ///////////////////////////////////////////////////////////////////////////
 249 void AliAttrib::SetGain(Double_t gain,TString name)
 250 {
 251 // Store gain value of the name-specified attribute slot.
 252 //
 253 // This procedure involves a slot-index search based on the specified name
 254 // at each invokation. This may become slow in case many slots have been
 255 // defined and/or when this procedure is invoked many times.
 256 // In such cases it is preferable to use indexed addressing in the user code
 257 // either directly or via a few invokations of GetSlotIndex().
 258
 259  Int_t j=GetSlotIndex(name);
 260  if (j>0) SetGain(gain,j);
 261 }
 262 ///////////////////////////////////////////////////////////////////////////
 263 void AliAttrib::SetOffset(Double_t off,Int_t j)
 264 {
 265 // Store offset value of the j-th (default j=1) attribute slot.
 266 // Note : The first attribute slot is at j=1.
 267 // In case the value of the index j exceeds the maximum number of reserved
 268 // slots for offset values, the number of reserved slots for the offset
 269 // values is increased automatically.
 270
 271  if (j<1)
 272  {
 273   cout << " *AliAttrib::GetOffset* Invalid argument j = " << j << endl;
 274   return;
 275  }
 276
 277  if (!fOffsets)
 278  {
 279   fOffsets=new TArrayF(j);
 280  }
 281
 282  Int_t size=fOffsets->GetSize();
 283
 284  if (j>size)
 285  {
 286   fOffsets->Set(j);
 287  }
 288
 289  fOffsets->AddAt(float(off),j-1);
 290
 291  Int_t gflag=GetGainFlag(j);
 292
 293  SetCalFlags(gflag,1,j);
 294 }
 295 ///////////////////////////////////////////////////////////////////////////
 296 void AliAttrib::SetOffset(Double_t off,TString name)
 297 {
 298 // Store offset value of the name-specified attribute slot.
 299 //
 300 // This procedure involves a slot-index search based on the specified name
 301 // at each invokation. This may become slow in case many slots have been
 302 // defined and/or when this procedure is invoked many times.
 303 // In such cases it is preferable to use indexed addressing in the user code
 304 // either directly or via a few invokations of GetSlotIndex().
 305
 306  Int_t j=GetSlotIndex(name);
 307  if (j>0) SetOffset(off,j);
 308 }
 309 ///////////////////////////////////////////////////////////////////////////
 310 void AliAttrib::SetCalFlags(Int_t gainflag,Int_t offsetflag,Int_t j)
 311 {
 312 // Store calibration flags of the j-th (default j=1) attribute slot.
 313 // Note : The first attribute slot is at j=1.
 314 // In case the value of the index j exceeds the maximum number of reserved
 315 // slots for the calib. flags, the number of reserved slots for the calib.
 316 // flags is increased automatically.
 317 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 318
 319  if (j<1)
 320  {
 321   cout << " *AliAttrib::GetCalFlags* Invalid argument j = " << j << endl;
 322   return;
 323  }
 324
 325  if (!fCalflags)
 326  {
 327   fCalflags=new TArrayI(j);
 328  }
 329
 330  Int_t size=fCalflags->GetSize();
 331
 332  if (j>size)
 333  {
 334   fCalflags->Set(j);
 335  }
 336
 337  Int_t edge=GetEdgeValue(j);
 338  Int_t dead=GetDeadValue(j);
 339
 340  Int_t word=1000*edge+100*dead+10*gainflag+offsetflag;
 341
 342  fCalflags->AddAt(word,j-1);
 343 }
 344 ///////////////////////////////////////////////////////////////////////////
 345 Int_t AliAttrib::GetGainFlag(Int_t j) const
 346 {
 347 // Provide gain flag of the j-th (default j=1) attribute slot.
 348 //
 349 // flag = 1 : Gain was set
 350 //        0 : Gain was not set
 351 //
 352 // Note : The first attribute slot is at j=1.
 353 // In case j is invalid, 0 is returned.
 354
 355  if (j<1)
 356  {
 357   cout << " *AliAttrib::GetGainFlag* Invalid argument j = " << j << endl;
 358   return 0;
 359  }
 360  Int_t gflag=0;
 361  if (fCalflags)
 362  {
 363   if (j>0 && j<=(fCalflags->GetSize()))
 364   {
 365    Int_t word=fCalflags->At(j-1);
 366    word=word%100;
 367    gflag=word/10;
 368   }
 369  }
 370  return gflag;
 371 }
 372 ///////////////////////////////////////////////////////////////////////////
 373 Int_t AliAttrib::GetGainFlag(TString name) const
 374 {
 375 // Provide gain flag of the name-specified attribute slot.
 376 //
 377 // flag = 1 : Gain was set
 378 //        0 : Gain was not set
 379 //
 380 //
 381 // This procedure involves a slot-index search based on the specified name
 382 // at each invokation. This may become slow in case many slots have been
 383 // defined and/or when this procedure is invoked many times.
 384 // In such cases it is preferable to use indexed addressing in the user code
 385 // either directly or via a few invokations of GetSlotIndex().
 386
 387  Int_t j=GetSlotIndex(name);
 388  Int_t flag=0;
 389  if (j>0) flag=GetGainFlag(j);
 390  return flag;
 391 }
 392 ///////////////////////////////////////////////////////////////////////////
 393 Int_t AliAttrib::GetOffsetFlag(Int_t j) const
 394 {
 395 // Provide offset flag of the j-th (default j=1) attribute slot.
 396 //
 397 // flag = 1 : Offset was set
 398 //        0 : Offset was not set
 399 //
 400 // Note : The first attribute slot is at j=1.
 401 // In case j is invalid, 0 is returned.
 402
 403  if (j<1)
 404  {
 405   cout << " *AliAttrib::GetOffsetFlag* Invalid argument j = " << j << endl;
 406   return 0;
 407  }
 408
 409  Int_t oflag=0;
 410  if (fCalflags)
 411  {
 412   if (j>0 && j<=(fCalflags->GetSize()))
 413   {
 414    Int_t word=fCalflags->At(j-1);
 415    oflag=word%10;
 416   }
 417  }
 418  return oflag;
 419 }
 420 ///////////////////////////////////////////////////////////////////////////
 421 Int_t AliAttrib::GetOffsetFlag(TString name) const
 422 {
 423 // Provide ofset flag of the name-specified attribute slot.
 424 //
 425 // flag = 1 : Offset was set
 426 //        0 : Offset was not set
 427 //
 428 //
 429 // This procedure involves a slot-index search based on the specified name
 430 // at each invokation. This may become slow in case many slots have been
 431 // defined and/or when this procedure is invoked many times.
 432 // In such cases it is preferable to use indexed addressing in the user code
 433 // either directly or via a few invokations of GetSlotIndex().
 434
 435  Int_t j=GetSlotIndex(name);
 436  Int_t flag=0;
 437  if (j>0) flag=GetOffsetFlag(j);
 438  return flag;
 439 }
 440 ///////////////////////////////////////////////////////////////////////////
 441 Int_t AliAttrib::GetCalWord(Int_t j) const
 442 {
 443 // Provide calib. word of the j-th (default j=1) attribute slot.
 444 // The word value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 445 //
 446 // Note : The first attribute slot is at j=1.
 447 // In case j is invalid, 0 is returned.
 448
 449  if (j<1)
 450  {
 451   cout << " *AliAttrib::GetCalWord* Invalid argument j = " << j << endl;
 452   return 0;
 453  }
 454
 455  Int_t word=0;
 456  if (fCalflags)
 457  {
 458   if (j>0 && j<=(fCalflags->GetSize())) word=fCalflags->At(j-1);
 459  }
 460  return word;
 461 }
 462 ///////////////////////////////////////////////////////////////////////////
 463 Int_t AliAttrib::GetCalWord(TString name) const
 464 {
 465 // Provide calib. word of the name-specified attribute slot.
 466 // The word value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 467 //
 468 // This procedure involves a slot-index search based on the specified name
 469 // at each invokation. This may become slow in case many slots have been
 470 // defined and/or when this procedure is invoked many times.
 471 // In such cases it is preferable to use indexed addressing in the user code
 472 // either directly or via a few invokations of GetSlotIndex().
 473
 474  Int_t j=GetSlotIndex(name);
 475  Int_t word=0;
 476  if (j>0) word=GetCalWord(j);
 477  return word;
 478 }
 479 ///////////////////////////////////////////////////////////////////////////
 480 Float_t AliAttrib::GetGain(Int_t j) const
 481 {
 482 // Provide gain value of the j-th (default j=1) attribute slot.
 483 // The first attribute slot is at j=1.
 484 // In case no gain value was set or the argument j is invalid, 0 is returned.
 485 // Note : Use GetGainFlag(j) to check whether this gain was set or not.
 486
 487  if (j<1)
 488  {
 489   cout << " *AliAttrib::GetGain* Invalid argument j = " << j << endl;
 490   return 0;
 491  }
 492
 493  Float_t gain=0;
 494  if (fGains)
 495  {
 496   if (j>0 && j<=(fGains->GetSize()))
 497   {
 498    if (GetGainFlag(j)) gain=fGains->At(j-1);
 499   }
 500  }
 501  return gain;
 502 }
 503 ///////////////////////////////////////////////////////////////////////////
 504 Float_t AliAttrib::GetGain(TString name) const
 505 {
 506 // Provide gain value of the name-specified attribute slot.
 507 //
 508 // This procedure involves a slot-index search based on the specified name
 509 // at each invokation. This may become slow in case many slots have been
 510 // defined and/or when this procedure is invoked many times.
 511 // In such cases it is preferable to use indexed addressing in the user code
 512 // either directly or via a few invokations of GetSlotIndex().
 513
 514  Int_t j=GetSlotIndex(name);
 515  Float_t gain=0;
 516  if (j>0) gain=GetGain(j);
 517  return gain;
 518 }
 519 ///////////////////////////////////////////////////////////////////////////
 520 Float_t AliAttrib::GetOffset(Int_t j) const
 521 {
 522 // Provide offset value of the j-th (default j=1) attribute slot.
 523 // The first attribute slot at j=1.
 524 // In case no offset value was set or the argument j is invalid, 0 is returned.
 525 // Note : Use GetOffsetFlag(j) to check whether this offset was set or not.
 526
 527  if (j<1)
 528  {
 529   cout << " *AliAttrib::GetOffset* Invalid argument j = " << j << endl;
 530   return 0;
 531  }
 532
 533  Float_t offset=0;
 534  if (fOffsets)
 535  {
 536   if (j>0 && j<=(fOffsets->GetSize()))
 537   {
 538    if (GetOffsetFlag(j)) offset=fOffsets->At(j-1);
 539   }
 540  }
 541  return offset;
 542 }
 543 ///////////////////////////////////////////////////////////////////////////
 544 Float_t AliAttrib::GetOffset(TString name) const
 545 {
 546 // Provide offset value of the name-specified attribute slot.
 547 //
 548 // This procedure involves a slot-index search based on the specified name
 549 // at each invokation. This may become slow in case many slots have been
 550 // defined and/or when this procedure is invoked many times.
 551 // In such cases it is preferable to use indexed addressing in the user code
 552 // either directly or via a few invokations of GetSlotIndex().
 553
 554  Int_t j=GetSlotIndex(name);
 555  Float_t offset=0;
 556  if (j>0) offset=GetOffset(j);
 557  return offset;
 558 }
 559 ///////////////////////////////////////////////////////////////////////////
 560 void AliAttrib::ResetGain(Int_t j)
 561 {
 562 // Reset the gain value of the j-th (default j=1) attribute slot.
 563 // Notes : The first attribute slot is at j=1.
 564 //         j=0 ==> All gain values will be reset.
 565
 566  if (!fGains) return;
 567
 568  Int_t size=fGains->GetSize();
 569
 570  if ((j>=0) && (j<=size))
 571  {
 572   if (j)
 573   {
 574    fGains->AddAt(0,j-1);
 575    Int_t oflag=GetOffsetFlag(j);
 576    SetCalFlags(0,oflag,j);
 577   }
 578   else
 579   {
 580    for (Int_t i=0; i<size; i++)
 581    {
 582     fGains->AddAt(0,i);
 583     Int_t oflag=GetOffsetFlag(i);
 584     SetCalFlags(0,oflag,i);
 585    }
 586   }
 587  }
 588  else
 589  {
 590   cout << " *AliAttrib::ResetGain* Index j = " << j << " invalid." << endl;
 591   return;
 592  }
 593 }
 594 ///////////////////////////////////////////////////////////////////////////
 595 void AliAttrib::ResetGain(TString name)
 596 {
 597 // Reset the gain value of the name-specified attribute slot.
 598 //
 599 // This procedure involves a slot-index search based on the specified name
 600 // at each invokation. This may become slow in case many slots have been
 601 // defined and/or when this procedure is invoked many times.
 602 // In such cases it is preferable to use indexed addressing in the user code
 603 // either directly or via a few invokations of GetSlotIndex().
 604
 605  Int_t j=GetSlotIndex(name);
 606  if (j>0) ResetGain(j);
 607 }
 608 ///////////////////////////////////////////////////////////////////////////
 609 void AliAttrib::ResetOffset(Int_t j)
 610 {
 611 // Reset the offset value of the j-th (default j=1) attribute slot.
 612 // Notes : The first attribute slot is at j=1.
 613 //         j=0 ==> All offset values will be reset.
 614
 615  if (!fOffsets) return;
 616
 617  Int_t size=fOffsets->GetSize();
 618
 619  if ((j>=0) && (j<=size))
 620  {
 621   if (j)
 622   {
 623    fOffsets->AddAt(0,j-1);
 624    Int_t gflag=GetGainFlag(j);
 625    SetCalFlags(gflag,0,j);
 626   }
 627   else
 628   {
 629    for (Int_t i=0; i<size; i++)
 630    {
 631     fOffsets->AddAt(0,i);
 632     Int_t gflag=GetGainFlag(i);
 633     SetCalFlags(gflag,0,i);
 634    }
 635   }
 636  }
 637  else
 638  {
 639   cout << " *AliAttrib::ResetOffset* Index j = " << j << " invalid." << endl;
 640   return;
 641  }
 642 }
 643 ///////////////////////////////////////////////////////////////////////////
 644 void AliAttrib::ResetOffset(TString name)
 645 {
 646 // Reset the offset value of the name-specified attribute slot.
 647 //
 648 // This procedure involves a slot-index search based on the specified name
 649 // at each invokation. This may become slow in case many slots have been
 650 // defined and/or when this procedure is invoked many times.
 651 // In such cases it is preferable to use indexed addressing in the user code
 652 // either directly or via a few invokations of GetSlotIndex().
 653
 654  Int_t j=GetSlotIndex(name);
 655  if (j>0) ResetOffset(j);
 656 }
 657 ///////////////////////////////////////////////////////////////////////////
 658 void AliAttrib::DeleteCalibrations(Int_t mode)
 659 {
 660 // User selected delete of all gains and/or offsets.
 661 // mode = 0 : All attributes (names,gains,offsets,(de)calfuncs, edge and dead values) are deleted.
 662 //        1 : Only the gains are deleted.
 663 //        2 : Only the offsets are deleted.
 664 //        3 : Gains, offsets and (de)calfuncs are deleted, but names, edge and dead values are kept.
 665 //        4 : Only the calib. functions are deleted.
 666 //        5 : Only the de-calib. functions are deleted.
 667 //        6 : Only the calib. and de-calib. functions are deleted.
 668 //
 669 // The default when invoking DeleteCalibrations() corresponds to mode=0.
 670
 671  if (mode<0 || mode>6)
 672  {
 673   cout << " *AliAttrib::DeleteCalibrations* Unknown mode : " << mode << endl;
 674   cout << " Default mode=0 will be used." << endl;
 675   mode=0;
 676  }
 677
 678  if (mode==0 || mode==3)
 679  {
 680   ResetGain(0);
 681   if (fGains)
 682   {
 683    delete fGains;
 684    fGains=0;
 685   }
 686   ResetOffset(0);
 687   if (fOffsets)
 688   {
 689    delete fOffsets;
 690    fOffsets=0;
 691   }
 692   if (fCalflags && mode==0)
 693   {
 694    delete fCalflags;
 695    fCalflags=0;
 696   }
 697   if (fNames && mode==0)
 698   {
 699    delete fNames;
 700    fNames=0;
 701   }
 702   if (fCalfuncs)
 703   {
 704    delete fCalfuncs;
 705    fCalfuncs=0;
 706   }
 707   if (fDecalfuncs)
 708   {
 709    delete fDecalfuncs;
 710    fDecalfuncs=0;
 711   }
 712   return;
 713  }
 714
 715  if (mode==1)
 716  {
 717   ResetGain(0);
 718   if (fGains)
 719   {
 720    delete fGains;
 721    fGains=0;
 722   }
 723  }
 724
 725  if (mode==2)
 726  {
 727   ResetOffset(0);
 728   if (fOffsets)
 729   {
 730    delete fOffsets;
 731    fOffsets=0;
 732   }
 733  }
 734
 735  if (mode==4 || mode==6)
 736  {
 737   if (fCalfuncs)
 738   {
 739    delete fCalfuncs;
 740    fCalfuncs=0;
 741   }
 742  }
 743
 744  if (mode==5 || mode==6)
 745  {
 746   if (fDecalfuncs)
 747   {
 748    delete fDecalfuncs;
 749    fDecalfuncs=0;
 750   }
 751  }
 752 }
 753 ///////////////////////////////////////////////////////////////////////////
 754 void AliAttrib::SetDead(Int_t j)
 755 {
 756 // Set the dead flag to 1 for the j-th (default j=1) attribute slot.
 757 // Note : The first attribute slot is at j=1.
 758 // In case the value of the index j exceeds the maximum number of reserved
 759 // slots for the flags, the number of reserved slots for the flags
 760 // is increased automatically.
 761 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 762
 763  if (j<1)
 764  {
 765   cout << " *AliAttrib::SetDead* Invalid argument j = " << j << endl;
 766   return;
 767  }
 768
 769  if (!fCalflags)
 770  {
 771   fCalflags=new TArrayI(j);
 772  }
 773
 774  Int_t size=fCalflags->GetSize();
 775
 776  if (j>size)
 777  {
 778   fCalflags->Set(j);
 779  }
 780
 781  Int_t dead=1;
 782  Int_t oflag=GetOffsetFlag(j);
 783  Int_t gflag=GetGainFlag(j);
 784  Int_t edge=GetEdgeValue(j);
 785
 786  Int_t word=1000*edge+100*dead+10*gflag+oflag;
 787
 788  fCalflags->AddAt(word,j-1);
 789 }
 790 ///////////////////////////////////////////////////////////////////////////
 791 void AliAttrib::SetDead(TString name)
 792 {
 793 // Set the dead flag to 1 for the name-specified attribute slot.
 794 //
 795 // This procedure involves a slot-index search based on the specified name
 796 // at each invokation. This may become slow in case many slots have been
 797 // defined and/or when this procedure is invoked many times.
 798 // In such cases it is preferable to use indexed addressing in the user code
 799 // either directly or via a few invokations of GetSlotIndex().
 800
 801  Int_t j=GetSlotIndex(name);
 802  if (j>0) SetDead(j);
 803 }
 804 ///////////////////////////////////////////////////////////////////////////
 805 void AliAttrib::SetAlive(Int_t j)
 806 {
 807 // Set the dead flag to 0 for the j-th (default j=1) attribute slot.
 808 // Note : The first attribute slot is at j=1.
 809 // In case the value of the index j exceeds the maximum number of reserved
 810 // slots for the flags, no action is taken since by default the dead flag is 0.
 811 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 812
 813  if (j<1)
 814  {
 815   cout << " *AliAttrib::SetAlive* Invalid argument j = " << j << endl;
 816   return;
 817  }
 818
 819  if (!fCalflags || j>fCalflags->GetSize()) return;
 820
 821  Int_t dead=0;
 822  Int_t oflag=GetOffsetFlag(j);
 823  Int_t gflag=GetGainFlag(j);
 824  Int_t edge=GetEdgeValue(j);
 825
 826  Int_t word=1000*edge+100*dead+10*gflag+oflag;
 827
 828  fCalflags->AddAt(word,j-1);
 829 }
 830 ///////////////////////////////////////////////////////////////////////////
 831 void AliAttrib::SetAlive(TString name)
 832 {
 833 // Set the dead flag to 0 for the name-specified attribute slot.
 834 //
 835 // This procedure involves a slot-index search based on the specified name
 836 // at each invokation. This may become slow in case many slots have been
 837 // defined and/or when this procedure is invoked many times.
 838 // In such cases it is preferable to use indexed addressing in the user code
 839 // either directly or via a few invokations of GetSlotIndex().
 840
 841  Int_t j=GetSlotIndex(name);
 842  if (j>0) SetAlive(j);
 843 }
 844 ///////////////////////////////////////////////////////////////////////////
 845 void AliAttrib::SetEdgeOn(Int_t j)
 846 {
 847 // Set the edge value to 1 for the j-th (default j=1) attribute slot.
 848 // Note : The first attribute slot is at j=1.
 849 // In case the value of the index j exceeds the maximum number of reserved
 850 // slots for the flags, the number of reserved slots for the flags
 851 // is increased automatically.
 852 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 853
 854  if (j<1)
 855  {
 856   cout << " *AliAttrib::SetEdgeOn* Invalid argument j = " << j << endl;
 857   return;
 858  }
 859
 860  SetEdgeValue(1,j);
 861 }
 862 ///////////////////////////////////////////////////////////////////////////
 863 void AliAttrib::SetEdgeOn(TString name)
 864 {
 865 // Set the edge value to 1 for the name-specified attribute slot.
 866 //
 867 // This procedure involves a slot-index search based on the specified name
 868 // at each invokation. This may become slow in case many slots have been
 869 // defined and/or when this procedure is invoked many times.
 870 // In such cases it is preferable to use indexed addressing in the user code
 871 // either directly or via a few invokations of GetSlotIndex().
 872
 873  Int_t j=GetSlotIndex(name);
 874  if (j>0) SetEdgeOn(j);
 875 }
 876 ///////////////////////////////////////////////////////////////////////////
 877 void AliAttrib::SetEdgeOff(Int_t j)
 878 {
 879 // Set the edge value to 0 for the j-th (default j=1) attribute slot.
 880 // Note : The first attribute slot is at j=1.
 881 // In case the value of the index j exceeds the maximum number of reserved
 882 // slots for the flags, no action is taken since by default the edge flag is 0.
 883 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 884
 885  if (j<1)
 886  {
 887   cout << " *AliAttrib::SetEdgeOff* Invalid argument j = " << j << endl;
 888   return;
 889  }
 890
 891  if (!fCalflags || j>fCalflags->GetSize()) return;
 892
 893  SetEdgeValue(0,j);
 894 }
 895 ///////////////////////////////////////////////////////////////////////////
 896 void AliAttrib::SetEdgeOff(TString name)
 897 {
 898 // Set the edge value to 0 for the name-specified attribute slot.
 899 //
 900 // This procedure involves a slot-index search based on the specified name
 901 // at each invokation. This may become slow in case many slots have been
 902 // defined and/or when this procedure is invoked many times.
 903 // In such cases it is preferable to use indexed addressing in the user code
 904 // either directly or via a few invokations of GetSlotIndex().
 905
 906  Int_t j=GetSlotIndex(name);
 907  if (j>0) SetEdgeOff(j);
 908 }
 909 ///////////////////////////////////////////////////////////////////////////
 910 void AliAttrib::SetEdgeValue(Int_t val,Int_t j)
 911 {
 912 // Set the edge value to "val" for the j-th (default j=1) attribute slot.
 913 // Note : The first attribute slot is at j=1.
 914 // In case the value of the index j exceeds the maximum number of reserved
 915 // slots for the flags, the number of reserved slots for the flags
 916 // is increased automatically.
 917 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 918
 919  if (j<1)
 920  {
 921   cout << " *AliAttrib::SetEdgeValue* Invalid argument j = " << j << endl;
 922   return;
 923  }
 924
 925  if (!fCalflags)
 926  {
 927   fCalflags=new TArrayI(j);
 928  }
 929
 930  Int_t size=fCalflags->GetSize();
 931
 932  if (j>size)
 933  {
 934   fCalflags->Set(j);
 935  }
 936
 937  Int_t edge=val;
 938  Int_t dead=GetDeadValue(j);
 939  Int_t gflag=GetGainFlag(j);
 940  Int_t oflag=GetOffsetFlag(j);
 941
 942  Int_t word=1000*edge+100*dead+10*gflag+oflag;
 943
 944  fCalflags->AddAt(word,j-1);
 945 }
 946 ///////////////////////////////////////////////////////////////////////////
 947 void AliAttrib::SetEdgeValue(Int_t val,TString name)
 948 {
 949 // Set the edge value to "val" for the name-specified attribute slot.
 950 //
 951 // This procedure involves a slot-index search based on the specified name
 952 // at each invokation. This may become slow in case many slots have been
 953 // defined and/or when this procedure is invoked many times.
 954 // In such cases it is preferable to use indexed addressing in the user code
 955 // either directly or via a few invokations of GetSlotIndex().
 956
 957  Int_t j=GetSlotIndex(name);
 958  if (j>0) SetEdgeValue(val,j);
 959 }
 960 ///////////////////////////////////////////////////////////////////////////
 961 void AliAttrib::IncreaseEdgeValue(Int_t j)
 962 {
 963 // Increase the edge value by 1 for the j-th (default j=1) attribute slot.
 964 // Note : The first attribute slot is at j=1.
 965 // In case the value of the index j exceeds the maximum number of reserved
 966 // slots for the flags, the number of reserved slots for the flags
 967 // is increased automatically.
 968 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
 969
 970  if (j<1)
 971  {
 972   cout << " *AliAttrib::IncreaseEdgeValue* Invalid argument j = " << j << endl;
 973   return;
 974  }
 975
 976  Int_t edge=GetEdgeValue();
 977  SetEdgeValue(edge+1,j);
 978 }
 979 ///////////////////////////////////////////////////////////////////////////
 980 void AliAttrib::IncreaseEdgeValue(TString name)
 981 {
 982 // Increase the edge value by 1 for the name-specified attribute slot.
 983 //
 984 // This procedure involves a slot-index search based on the specified name
 985 // at each invokation. This may become slow in case many slots have been
 986 // defined and/or when this procedure is invoked many times.
 987 // In such cases it is preferable to use indexed addressing in the user code
 988 // either directly or via a few invokations of GetSlotIndex().
 989
 990  Int_t j=GetSlotIndex(name);
 991  if (j>0) IncreaseEdgeValue(j);
 992 }
 993 ///////////////////////////////////////////////////////////////////////////
 994 void AliAttrib::DecreaseEdgeValue(Int_t j)
 995 {
 996 // Decrease the edge value by 1 for the j-th (default j=1) attribute slot.
 997 // Note : The first attribute slot is at j=1.
 998 // In case the value of the index j exceeds the maximum number of reserved
 999 // slots for the flags, the number of reserved slots for the flags
1000 // is increased automatically.
1001 // The value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
1002
1003  if (j<1)
1004  {
1005   cout << " *AliAttrib::DecreaseEdgeValue* Invalid argument j = " << j << endl;
1006   return;
1007  }
1008
1009  Int_t edge=GetEdgeValue();
1010  SetEdgeValue(edge-1,j);
1011 }
1012 ///////////////////////////////////////////////////////////////////////////
1013 void AliAttrib::DecreaseEdgeValue(TString name)
1014 {
1015 // Decrease the edge value by 1 for the name-specified attribute slot.
1016 //
1017 // This procedure involves a slot-index search based on the specified name
1018 // at each invokation. This may become slow in case many slots have been
1019 // defined and/or when this procedure is invoked many times.
1020 // In such cases it is preferable to use indexed addressing in the user code
1021 // either directly or via a few invokations of GetSlotIndex().
1022
1023  Int_t j=GetSlotIndex(name);
1024  if (j>0) DecreaseEdgeValue(j);
1025 }
1026 ///////////////////////////////////////////////////////////////////////////
1027 Int_t AliAttrib::GetEdgeValue(Int_t j) const
1028 {
1029 // Provide edge value of the j-th (default j=1) attribute slot.
1030 // Note : The first attribute slot is at j=1.
1031 // In case j is invalid, 0 is returned.
1032
1033  if (j<1)
1034  {
1035   cout << " *AliAttrib::GetEdgeValue* Invalid argument j = " << j << endl;
1036   return 0;
1037  }
1038
1039  Int_t edge=0;
1040  if (fCalflags)
1041  {
1042   if (j>0 && j<=(fCalflags->GetSize()))
1043   {
1044    Int_t word=fCalflags->At(j-1);
1045    edge=word/1000;
1046   }
1047  }
1048  return edge;
1049 }
1050 ///////////////////////////////////////////////////////////////////////////
1051 Int_t AliAttrib::GetEdgeValue(TString name) const
1052 {
1053 // Provide edge value of the name-specified attribute slot.
1054 //
1055 // This procedure involves a slot-index search based on the specified name
1056 // at each invokation. This may become slow in case many slots have been
1057 // defined and/or when this procedure is invoked many times.
1058 // In such cases it is preferable to use indexed addressing in the user code
1059 // either directly or via a few invokations of GetSlotIndex().
1060
1061  Int_t j=GetSlotIndex(name);
1062  Int_t val=0;
1063  if (j>0) val=GetEdgeValue(j);
1064  return val;
1065 }
1066 ///////////////////////////////////////////////////////////////////////////
1067 Int_t AliAttrib::GetDeadValue(Int_t j) const
1068 {
1069 // Provide dead value of the j-th (default j=1) attribute slot.
1070 // Note : The first attribute slot is at j=1.
1071 // In case j is invalid, 0 is returned.
1072
1073  if (j<1)
1074  {
1075   cout << " *AliAttrib::GetDeadValue* Invalid argument j = " << j << endl;
1076   return 0;
1077  }
1078
1079  Int_t dead=0;
1080  if (fCalflags)
1081  {
1082   if (j>0 && j<=(fCalflags->GetSize()))
1083   {
1084    Int_t word=fCalflags->At(j-1);
1085    word=word%1000;
1086    dead=word/100;
1087   }
1088  }
1089  return dead;
1090 }
1091 ///////////////////////////////////////////////////////////////////////////
1092 Int_t AliAttrib::GetDeadValue(TString name) const
1093 {
1094 // Provide dead value of the name-specified attribute slot.
1095 //
1096 // This procedure involves a slot-index search based on the specified name
1097 // at each invokation. This may become slow in case many slots have been
1098 // defined and/or when this procedure is invoked many times.
1099 // In such cases it is preferable to use indexed addressing in the user code
1100 // either directly or via a few invokations of GetSlotIndex().
1101
1102  Int_t j=GetSlotIndex(name);
1103  Int_t val=0;
1104  if (j>0) val=GetDeadValue(j);
1105  return val;
1106 }
1107 ///////////////////////////////////////////////////////////////////////////
1108 Int_t AliAttrib::GetNslots() const
1109 {
1110 // Provide the number of existing slots.
1111
1112   Int_t n=GetNcalflags();
1113   Int_t nn=GetNnames();
1114   Int_t ncalf=GetNcalfuncs();
1115   Int_t ndecalf=GetNdecalfuncs();
1116   if (n<nn) n=nn;
1117   if (n<ncalf) n=ncalf;
1118   if (n<ndecalf) n=ndecalf;
1119
1120   return n;
1121 }
1122 ///////////////////////////////////////////////////////////////////////////
1123 void AliAttrib::AddNamedSlot(TString s)
1124 {
1125 // Add a new slot with the specified name.
1126 // In case a slot with the specified name already exists, no action is taken.
1127
1128  if (GetSlotIndex(s)) return;
1129
1130  Int_t n=GetNslots();
1131  SetSlotName(s,n+1);
1132 }
1133 ///////////////////////////////////////////////////////////////////////////
1134 void AliAttrib::SetSlotName(TString s,Int_t j)
1135 {
1136 // Set a user defined name for the j-th (default j=1) slot.
1137 // Note : The first attribute slot is at j=1.
1138 // In case the value of the index j exceeds the maximum number of reserved
1139 // slots for the names, the number of reserved slots for the names
1140 // is increased automatically to the corresponding value.
1141
1142  if (j<1)
1143  {
1144   cout << " *AliAttrib::SetSlotName* Invalid argument j = " << j << endl;
1145   return;
1146  }
1147
1148  if (!fNames)
1149  {
1150   fNames=new TObjArray(j);
1151   fNames->SetOwner();
1152  }
1153
1154  if (j>fNames->GetSize()) fNames->Expand(j);
1155
1156  TObjString* so=(TObjString*)fNames->At(j-1);
1157  if (!so)
1158  {
1159   so=new TObjString(s.Data());
1160   fNames->AddAt(so,j-1);
1161  }
1162  else
1163  {
1164   so->SetString(s);
1165  }
1166 }
1167 ///////////////////////////////////////////////////////////////////////////
1168 TString AliAttrib::GetSlotName(Int_t j) const
1169 {
1170 // Provide the user defined name for the j-th (default j=1) slot.
1171 // Note : The first attribute slot is at j=1.
1172
1173  TString s="";
1174  if (j<1)
1175  {
1176   cout << " *AliAttrib::GetSlotName* Invalid argument j = " << j << endl;
1177   return s;
1178  }
1179
1180  if (fNames)
1181  {
1182   if (j<=fNames->GetSize())
1183   {
1184    TObjString* so=(TObjString*)fNames->At(j-1);
1185    if (so) s=so->GetString();
1186   }
1187  }
1188  return s;
1189 }
1190 ///////////////////////////////////////////////////////////////////////////
1191 Int_t AliAttrib::GetSlotIndex(TString name) const
1192 {
1193 // Provide the slot index for the matching name.
1194 // If no matching name is found, 0 is returned.
1195 // Note : The first attribute slot is at j=1.
1196
1197  Int_t index=0;
1198
1199  if (fNames)
1200  {
1201   TString s;
1202   Int_t size=fNames->GetSize();
1203   for (Int_t i=0; i<size; i++)
1204   {
1205    TObjString* so=(TObjString*)fNames->At(i);
1206    if (so) s=so->GetString();
1207    if (s==name)
1208    {
1209     index=i+1;
1210     break;
1211    }
1212   }
1213  }
1214  return index;
1215 }
1216 ///////////////////////////////////////////////////////////////////////////
1217 void AliAttrib::List(Int_t j) const
1218 {
1219 // Provide attribute information for the j-th slot.
1220 // The first slot is at j=1.
1221 // In case j=0 (default) the data of all slots will be listed.
1222
1223  if (j<0)
1224  {
1225   cout << " *AliAttrib::Data* Invalid argument j = " << j << endl;
1226   return;
1227  }
1228
1229  if (j>0)
1230  {
1231   if (GetGainFlag(j)) cout << " gain : " << GetGain(j);
1232   if (GetOffsetFlag(j)) cout << " offset : " << GetOffset(j);
1233   if (GetEdgeValue(j)) cout << " edge : " << GetEdgeValue(j);
1234   if (GetDeadValue(j)) cout << " dead : " << GetDeadValue(j);
1235   if (GetCalFunction(j)) cout << " *Fcalib*";
1236   if (GetDecalFunction(j)) cout << " *Fdecalib*";
1237   TString s=GetSlotName(j);
1238   if (s!="") cout << " name : " << s.Data();
1239  }
1240  else
1241  {
1242   Int_t ng=GetNgains();
1243   Int_t no=GetNoffsets();
1244   Int_t nf=0;
1245   if (fCalflags) nf=fCalflags->GetSize();
1246   Int_t nn=GetNnames();
1247   Int_t n=ng;
1248   if (n<no) n=no;
1249   if (n<nn) n=nn;
1250   if (n<nf) n=nf;
1251   Int_t printf=0;
1252   TString s;
1253   for (Int_t i=1; i<=n; i++)
1254   {
1255    printf=0;
1256    if (GetGainFlag(i))      {cout << " gain : " << GetGain(i); printf=1;}
1257    if (GetOffsetFlag(i))    {cout << " offset : " << GetOffset(i); printf=1;}
1258    if (GetEdgeValue(i))     {cout << " edge : " << GetEdgeValue(i); printf=1;}
1259    if (GetDeadValue(i))     {cout << " dead : " << GetDeadValue(i); printf=1;}
1260    if (GetCalFunction(i))   {cout << " *Fcalib*"; printf=1;}
1261    if (GetDecalFunction(i)) {cout << " *Fdecalib*"; printf=1;}
1262    s=GetSlotName(i);
1263    if (s!="") {cout << " name : " << s.Data(); printf=1;}
1264    if (printf) cout << endl;
1265   }
1266  }
1267 }
1268 ///////////////////////////////////////////////////////////////////////////
1269 void AliAttrib::List(TString name) const
1270 {
1271 // Provide attribute information for the name-specified slot.
1272 //
1273 // This procedure involves a slot-index search based on the specified name
1274 // at each invokation. This may become slow in case many slots have been
1275 // defined and/or when this procedure is invoked many times.
1276 // In such cases it is preferable to use indexed addressing in the user code
1277 // either directly or via a few invokations of GetSlotIndex().
1278
1279  Int_t j=GetSlotIndex(name);
1280  if (j>0) List(j);
1281 }
1282 ///////////////////////////////////////////////////////////////////////////
1283 void AliAttrib::Load(AliAttrib& a,Int_t j)
1284 {
1285 // Load attributes of the j-th slot of the input AliAttrib into this AliAttrib object.
1286 //
1287 // Note : if j=0, then all attributes of all slots are loaded
1288 //
1289 // The default is j=0.
1290
1291  if (j<0)
1292  {
1293   cout << " *AliAttrib::Load* Invalid argument j = " << j << endl;
1294   return;
1295  }
1296
1297  Int_t n=0;
1298
1299  if (j==0) // load attributes for all slots
1300  {
1301   n=a.GetNgains();
1302   for (Int_t ig=1; ig<=n; ig++)
1303   {
1304    if (a.GetGainFlag(ig))
1305    {
1306     SetGain(a.GetGain(ig),ig);
1307    }
1308    else
1309    {
1310     ResetGain(ig);
1311    }
1312   }
1313   n=a.GetNoffsets();
1314   for (Int_t io=1; io<=n; io++)
1315   {
1316    if (a.GetOffsetFlag(io))
1317    {
1318     SetOffset(a.GetOffset(io),io);
1319    }
1320    else
1321    {
1322     ResetOffset(io);
1323    }
1324   }
1325   n=a.GetNcalflags();
1326   for (Int_t ic=1; ic<=n; ic++)
1327   {
1328    SetEdgeValue(a.GetEdgeValue(ic),ic);
1329    if (a.GetDeadValue(ic))
1330    {
1331     SetDead(ic);
1332    }
1333    else
1334    {
1335     SetAlive(ic);
1336    }
1337   }
1338   n=a.GetNnames();
1339   TString s;
1340   for (Int_t in=1; in<=n; in++)
1341   {
1342    s=a.GetSlotName(in);
1343    SetSlotName(s,in);
1344   }
1345   n=a.GetNcalfuncs();
1346   for (Int_t icalf=1; icalf<=n; icalf++)
1347   {
1348    TF1* f=a.GetCalFunction(icalf);
1349    SetCalFunction(f,icalf);
1350   }
1351   n=a.GetNdecalfuncs();
1352   for (Int_t idecalf=1; idecalf<=n; idecalf++)
1353   {
1354    TF1* f=a.GetDecalFunction(idecalf);
1355    SetDecalFunction(f,idecalf);
1356   }
1357  }
1358  else // load attributes for specified j-th slot only
1359  {
1360   n=a.GetNgains();
1361   if (j<=n)
1362   {
1363    if (a.GetGainFlag(j))
1364    {
1365     SetGain(a.GetGain(j),j);
1366    }
1367    else
1368    {
1369     ResetGain(j);
1370    }
1371   }
1372   n=a.GetNoffsets();
1373   if (j<=n)
1374   {
1375    if (a.GetOffsetFlag(j))
1376    {
1377     SetOffset(a.GetOffset(j),j);
1378    }
1379    else
1380    {
1381     ResetOffset(j);
1382    }
1383   }
1384   n=a.GetNcalflags();
1385   if (j<=n)
1386   {
1387    SetEdgeValue(a.GetEdgeValue(j),j);
1388    if (a.GetDeadValue(j))
1389    {
1390     SetDead(j);
1391    }
1392    else
1393    {
1394     SetAlive(j);
1395    }
1396   }
1397   n=a.GetNnames();
1398   TString s;
1399   if (j<=n)
1400   {
1401    s=a.GetSlotName(j);
1402    SetSlotName(s,j);
1403   }
1404   n=a.GetNcalfuncs();
1405   if (j<=n)
1406   {
1407    TF1* f=a.GetCalFunction(j);
1408    SetCalFunction(f,j);
1409   }
1410   n=a.GetNdecalfuncs();
1411   if (j<=n)
1412   {
1413    TF1* f=a.GetDecalFunction(j);
1414    SetDecalFunction(f,j);
1415   }
1416  }
1417 }
1418 ///////////////////////////////////////////////////////////////////////////
1419 void AliAttrib::Load(AliAttrib& a,TString name)
1420 {
1421 // Load attributes of the name-specified slot of the input AliAttrib into
1422 // this AliAttrib object.
1423 //
1424 // This procedure involves a slot-index search based on the specified name
1425 // at each invokation. This may become slow in case many slots have been
1426 // defined and/or when this procedure is invoked many times.
1427 // In such cases it is preferable to use indexed addressing in the user code
1428 // either directly or via a few invokations of GetSlotIndex().
1429
1430  Int_t j=GetSlotIndex(name);
1431  if (j>0) Load(a,j);
1432 }
1433 ///////////////////////////////////////////////////////////////////////////
1434 Int_t AliAttrib::GetNcalfuncs() const
1435 {
1436 // Provide the number of specified calib. functions for this attribute.
1437
1438  if (!fCalfuncs) return 0;
1439
1440  Int_t n=0;
1441  for (Int_t i=1; i<=fCalfuncs->GetSize(); i++)
1442  {
1443   if (fCalfuncs->At(i-1)) n=i;
1444  }
1445  return n;
1446 }
1447 ///////////////////////////////////////////////////////////////////////////
1448 Int_t AliAttrib::GetNdecalfuncs() const
1449 {
1450 // Provide the number of specified de-calib. functions for this attribute.
1451
1452  if (!fDecalfuncs) return 0;
1453
1454  Int_t n=0;
1455  for (Int_t i=1; i<=fDecalfuncs->GetSize(); i++)
1456  {
1457   if (fDecalfuncs->At(i-1)) n=i;
1458  }
1459  return n;
1460 }
1461 ///////////////////////////////////////////////////////////////////////////
1462 TF1* AliAttrib::GetCalFunction(Int_t j) const
1463 {
1464 // Provide pointer to the calib. function of the j-th (default j=1) slot.
1465 // Note : The first attribute slot is at j=1.
1466
1467  TF1* f=0;
1468  if (j>0 && j<=GetNcalfuncs()) f=(TF1*)fCalfuncs->At(j-1);
1469  return f;
1470 }
1471 ///////////////////////////////////////////////////////////////////////////
1472 TF1* AliAttrib::GetCalFunction(TString name) const
1473 {
1474 // Provide pointer to the calib. function of the name-specified slot.
1475 // In case no match is found, zero is returned.
1476
1477  TF1* f=0;
1478  Int_t j=GetSlotIndex(name);
1479  if (j>0) f=GetCalFunction(j);
1480  return f;
1481 }
1482 ///////////////////////////////////////////////////////////////////////////
1483 void AliAttrib::SetCalFunction(TF1* f,Int_t j)
1484 {
1485 // Set the calib. function of the j-th (default j=1) slot.
1486 // Note : The first attribute slot is at j=1.
1487 //
1488 // In case the value of the index j exceeds the maximum number of reserved
1489 // positions for the functions, the number of reserved positions for the functions
1490 // is increased automatically.
1491 //
1492 // In case the function pointer argument has the same value as the current function
1493 // pointer value, no action is taken since the user has already modified the actual
1494 // function.
1495 //
1496 // In case the function pointer argument is zero, the current function
1497 // is deleted and the pointer set to zero.
1498 //
1499 // In all other cases the current function is deleted and a new
1500 // copy of the input function is created which becomes the current function.
1501
1502  if (j<1) return;
1503
1504  if (!fCalfuncs)
1505  {
1506   fCalfuncs=new TObjArray(j);
1507   fCalfuncs->SetOwner();
1508  }
1509
1510  if (j > fCalfuncs->GetSize()) fCalfuncs->Expand(j);
1511
1512  TF1* fcur=(TF1*)fCalfuncs->At(j-1);
1513  if (f != fcur)
1514  {
1515   if (fcur)
1516   {
1517    fCalfuncs->Remove(fcur);
1518    delete fcur;
1519    fcur=0;
1520   }
1521   if (f)
1522   {
1523    fcur=new TF1(*f);
1524    fCalfuncs->AddAt(fcur,j-1);
1525   }
1526  }
1527 }
1528 ///////////////////////////////////////////////////////////////////////////
1529 void AliAttrib::SetCalFunction(TF1* f,TString name)
1530 {
1531 // Set the calib. function of the name-specified slot.
1532 //
1533 // In case the function pointer argument has the same value as the current function
1534 // pointer value, no action is taken since the user has already modified the actual
1535 // function.
1536 //
1537 // In case the function pointer argument is zero, the current function
1538 // is deleted and the pointer set to zero.
1539 //
1540 // In all other cases the current function is deleted and a new
1541 // copy of the input function is created which becomes the current function.
1542
1543  Int_t j=GetSlotIndex(name);
1544  if (j>0) SetCalFunction(f,j);
1545 }
1546 ///////////////////////////////////////////////////////////////////////////
1547 TF1* AliAttrib::GetDecalFunction(Int_t j) const
1548 {
1549 // Provide pointer to the de-calib. function of the j-th (default j=1) slot.
1550 // Note : The first attribute slot is at j=1.
1551
1552  TF1* f=0;
1553  if (j>0 && j<=GetNdecalfuncs()) f=(TF1*)fDecalfuncs->At(j-1);
1554  return f;
1555 }
1556 ///////////////////////////////////////////////////////////////////////////
1557 TF1* AliAttrib::GetDecalFunction(TString name) const
1558 {
1559 // Provide pointer to the de-calib. function of the name-specified slot.
1560 // In case no match is found, zero is returned.
1561
1562  TF1* f=0;
1563  Int_t j=GetSlotIndex(name);
1564  if (j>0) f=GetDecalFunction(j);
1565  return f;
1566 }
1567 ///////////////////////////////////////////////////////////////////////////
1568 void AliAttrib::SetDecalFunction(TF1* f,Int_t j)
1569 {
1570 // Set the de-calib. function of the j-th (default j=1) slot.
1571 // Note : The first attribute slot is at j=1.
1572 //
1573 // In case the value of the index j exceeds the maximum number of reserved
1574 // positions for the functions, the number of reserved positions for the functions
1575 // is increased automatically.
1576 //
1577 // In case the function pointer argument has the same value as the current function
1578 // pointer value, no action is taken since the user has already modified the actual
1579 // function.
1580 //
1581 // In case the function pointer argument is zero, the current function
1582 // is deleted and the pointer set to zero.
1583 //
1584 // In all other cases the current function is deleted and a new
1585 // copy of the input function is created which becomes the current function.
1586
1587  if (j<1) return;
1588
1589  if (!fDecalfuncs)
1590  {
1591   fDecalfuncs=new TObjArray(j);
1592   fDecalfuncs->SetOwner();
1593  }
1594
1595  if (j > fDecalfuncs->GetSize()) fDecalfuncs->Expand(j);
1596
1597  TF1* fcur=(TF1*)fDecalfuncs->At(j-1);
1598  if (f != fcur)
1599  {
1600   if (fcur)
1601   {
1602    fDecalfuncs->Remove(fcur);
1603    delete fcur;
1604    fcur=0;
1605   }
1606   if (f)
1607   {
1608    fcur=new TF1(*f);
1609    fDecalfuncs->AddAt(fcur,j-1);
1610   }
1611  }
1612 }
1613 ///////////////////////////////////////////////////////////////////////////
1614 void AliAttrib::SetDecalFunction(TF1* f,TString name)
1615 {
1616 // Set the de-calib. function of the name-specified slot.
1617 //
1618 // In case the function pointer argument has the same value as the current function
1619 // pointer value, no action is taken since the user has already modified the actual
1620 // function.
1621 //
1622 // In case the function pointer argument is zero, the current function
1623 // is deleted and the pointer set to zero.
1624 //
1625 // In all other cases the current function is deleted and a new
1626 // copy of the input function is created which becomes the current function.
1627
1628  Int_t j=GetSlotIndex(name);
1629  if (j>0) SetDecalFunction(f,j);
1630 }
1631 ///////////////////////////////////////////////////////////////////////////