VZERO/AliVZEROCalibData.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: AliVZEROCalibData.cxx,                                            */
  17
  18 /////////////////////////////////////////////////////////////////////////////
  19 //                                                                         //
  20 // class for VZERO calibration                                             //
  21 //                                                                         //
  22 /////////////////////////////////////////////////////////////////////////////
  23
  24 #include <TMath.h>
  25 #include <TObjString.h>
  26 #include <TMap.h>
  27
  28 #include "AliDCSValue.h"
  29 #include "AliVZEROCalibData.h"
  30 #include "AliVZERODataDCS.h"
  31 #include "AliLog.h"
  32
  33 ClassImp(AliVZEROCalibData)
  34
  35 //________________________________________________________________
  36 AliVZEROCalibData::AliVZEROCalibData()
  37 {
  38   // default constructor
  39
  40     for(int t=0; t<64; t++) {
  41         fMeanHV[t]      = 100.0;
  42         fWidthHV[t]     = 0.0;
  43         fTimeOffset[t]  = 0.0;
  44         fTimeGain[t]    = 1.0;
  45         fDeadChannel[t]= kFALSE;
  46     }
  47     for(int t=0; t<128; t++) {
  48         fPedestal[t]    = 0.0;
  49         fSigma[t]       = 0.0;
  50         fADCmean[t]     = 0.0;
  51         fADCsigma[t]    = 0.0;
  52         fGain[t]        = 1.0;
  53     }
  54     for(int i=0; i<kNCIUBoards ;i++) {
  55         fTimeResolution[i]  = 25./256.;     // Default time resolution
  56         fWidthResolution[i] = 25./64.;     // Default time width resolution
  57         fMatchWindow[i] = 4;
  58         fSearchWindow[i] = 16;
  59         fTriggerCountOffset[i] = 3247;
  60         fRollOver[i] = 3563;
  61     }
  62
  63 }
  64
  65 //________________________________________________________________
  66 void AliVZEROCalibData::Reset()
  67 {
  68   // reset
  69 }
  70
  71 //________________________________________________________________
  72 AliVZEROCalibData::AliVZEROCalibData(const char* name)
  73 {
  74   // Constructor
  75    TString namst = "Calib_";
  76    namst += name;
  77    SetName(namst.Data());
  78    SetTitle(namst.Data());
  79    for(int t=0; t<64; t++) {
  80        fMeanHV[t]      = 100.0;
  81        fWidthHV[t]     = 0.0;
  82        fTimeOffset[t]  = 0.0;
  83        fTimeGain[t]    = 1.0;
  84        fDeadChannel[t]= kFALSE;
  85     }
  86    for(int t=0; t<128; t++) {
  87        fPedestal[t]    = 0.0;
  88        fSigma[t]       = 0.0;
  89        fADCmean[t]     = 0.0;
  90        fADCsigma[t]    = 0.0;
  91        fGain[t]        = 1.0;
  92    }
  93    for(int i=0; i<kNCIUBoards ;i++) {
  94        fTimeResolution[i]  = 25./256.;    // Default time resolution in ns / channel
  95        fWidthResolution[i] = 25./64.;     // Default time width resolution in ns / channel
  96        fMatchWindow[i] = 4;
  97        fSearchWindow[i] = 16;
  98        fTriggerCountOffset[i] = 3247;
  99        fRollOver[i] = 3563;
 100    }
 101
 102 }
 103
 104 //________________________________________________________________
 105 AliVZEROCalibData::AliVZEROCalibData(const AliVZEROCalibData& calibda) :
 106   TNamed(calibda)
 107 {
 108 // copy constructor
 109
 110   SetName(calibda.GetName());
 111   SetTitle(calibda.GetName());
 112
 113   for(int t=0; t<128; t++) {
 114       fPedestal[t] = calibda.GetPedestal(t);
 115       fSigma[t]    = calibda.GetSigma(t);
 116       fADCmean[t]  = calibda.GetADCmean(t);
 117       fADCsigma[t] = calibda.GetADCsigma(t);
 118       fGain[t]     = calibda.GetGain(t); }
 119
 120   for(int t=0; t<64; t++) {
 121       fMeanHV[t]       = calibda.GetMeanHV(t);
 122       fWidthHV[t]      = calibda.GetWidthHV(t);
 123       fTimeOffset[t]   = calibda.GetTimeOffset(t);
 124       fTimeGain[t]     = calibda.GetTimeGain(t);
 125       fDeadChannel[t]  = calibda.IsChannelDead(t);
 126   }
 127
 128   for(int i=0; i<kNCIUBoards ;i++) {
 129       fTimeResolution[i]  = calibda.GetTimeResolution(i);
 130       fWidthResolution[i] = calibda.GetWidthResolution(i);
 131       fMatchWindow[i] = calibda.GetMatchWindow(i);
 132       fSearchWindow[i] = calibda.GetSearchWindow(i);
 133       fTriggerCountOffset[i] = calibda.GetTriggerCountOffset(i);
 134       fRollOver[i] = calibda.GetRollOver(i);
 135   }
 136
 137 }
 138
 139 //________________________________________________________________
 140 AliVZEROCalibData &AliVZEROCalibData::operator =(const AliVZEROCalibData& calibda)
 141 {
 142 // assignment operator
 143
 144   SetName(calibda.GetName());
 145   SetTitle(calibda.GetName());
 146
 147   for(int t=0; t<128; t++) {
 148       fPedestal[t] = calibda.GetPedestal(t);
 149       fSigma[t]    = calibda.GetSigma(t);
 150       fADCmean[t]  = calibda.GetADCmean(t);
 151       fADCsigma[t] = calibda.GetADCsigma(t);
 152       fGain[t]     = calibda.GetGain(t); }
 153
 154   for(int t=0; t<64; t++) {
 155       fMeanHV[t]       = calibda.GetMeanHV(t);
 156       fWidthHV[t]      = calibda.GetWidthHV(t);
 157       fTimeOffset[t]   = calibda.GetTimeOffset(t);
 158       fTimeGain[t]     = calibda.GetTimeGain(t);
 159       fDeadChannel[t]  = calibda.IsChannelDead(t);
 160   }
 161   for(int i=0; i<kNCIUBoards ;i++) {
 162       fTimeResolution[i]  = calibda.GetTimeResolution(i);
 163       fWidthResolution[i] = calibda.GetWidthResolution(i);
 164       fMatchWindow[i] = calibda.GetMatchWindow(i);
 165       fSearchWindow[i] = calibda.GetSearchWindow(i);
 166       fTriggerCountOffset[i] = calibda.GetTriggerCountOffset(i);
 167       fRollOver[i] = calibda.GetRollOver(i);
 168   }
 169
 170   return *this;
 171
 172 }
 173
 174 //________________________________________________________________
 175 AliVZEROCalibData::~AliVZEROCalibData()
 176 {
 177   // destructor
 178 }
 179 //_____________________________________________________________________________
 180 void AliVZEROCalibData::FillDCSData(AliVZERODataDCS * data){
 181         // Set all parameters from the data get by the shuttle
 182         TMap * params = data->GetFEEParameters();
 183         TIter iter(params);
 184         TObjString* aliasName;
 185
 186         while ((  aliasName = (TObjString*) iter.Next() ))  {
 187                 AliDCSValue* aValue = (AliDCSValue*) params->GetValue(aliasName);
 188                 Int_t val;
 189                 if(aValue) {
 190                         val = aValue->GetUInt();
 191                         AliInfo(Form("%s : %d",aliasName->String().Data(), val));
 192                         SetParameter(aliasName->String(),val);
 193                 }
 194         }
 195
 196         SetMeanHV(data->GetMeanHV());
 197         SetWidthHV(data->GetWidthHV());
 198         SetDeadMap(data->GetDeadMap());
 199
 200 }
 201 //_____________________________________________________________________________
 202 void AliVZEROCalibData::SetParameter(TString name, Int_t val){
 203         // Set given parameter
 204
 205         Int_t iBoard = -1;
 206
 207         TSeqCollection* nameSplit = name.Tokenize("/");
 208         TObjString * boardName = (TObjString *)nameSplit->At(2);
 209         sscanf(boardName->String().Data(),"CIU%d",&iBoard);
 210
 211         if(name.Contains("TimeResolution")) SetTimeResolution((UShort_t) val,iBoard);
 212         else if(name.Contains("WidthResolution")) SetWidthResolution((UShort_t) val,iBoard);
 213         else if(name.Contains("MatchWindow")) SetMatchWindow((UInt_t) val,iBoard);
 214         else if(name.Contains("SearchWindow")) SetSearchWindow((UInt_t) val,iBoard);
 215         else if(name.Contains("TriggerCountOffset")) SetTriggerCountOffset((UInt_t) val,iBoard);
 216         else if(name.Contains("RollOver")) SetRollOver((UInt_t) val,iBoard);
 217         else AliError(Form("No Setter found for FEE parameter : %s",name.Data()));
 218 }
 219
 220 //________________________________________________________________
 221 void AliVZEROCalibData::SetPedestal(const Float_t* Pedestal)
 222 {
 223   if(Pedestal) for(int t=0; t<128; t++) fPedestal[t] = Pedestal[t];
 224   else for(int t=0; t<128; t++) fPedestal[t] = 0.0;
 225 }
 226
 227 //________________________________________________________________
 228 void AliVZEROCalibData::SetSigma(const Float_t* Sigma)
 229 {
 230   if(Sigma) for(int t=0; t<128; t++) fSigma[t] = Sigma[t];
 231   else for(int t=0; t<128; t++) fSigma[t] = 0.0;
 232 }
 233
 234 //________________________________________________________________
 235 void AliVZEROCalibData::SetADCmean(const Float_t* ADCmean)
 236 {
 237   if(ADCmean) for(int t=0; t<128; t++) fADCmean[t] = ADCmean[t];
 238   else for(int t=0; t<128; t++) fADCmean[t] = 0.0;
 239 }
 240
 241 //________________________________________________________________
 242 void AliVZEROCalibData::SetADCsigma(const Float_t* ADCsigma)
 243 {
 244   if(ADCsigma) for(int t=0; t<128; t++) fADCsigma[t] = ADCsigma[t];
 245   else for(int t=0; t<128; t++) fADCsigma[t] = 0.0;
 246 }
 247
 248 //________________________________________________________________
 249 void AliVZEROCalibData::SetMeanHV(const Float_t* MeanHV)
 250 {
 251   if(MeanHV) for(int t=0; t<64; t++) fMeanHV[t] = MeanHV[t];
 252   else for(int t=0; t<64; t++) fMeanHV[t] = 0.0;
 253 }
 254
 255 //________________________________________________________________
 256 void AliVZEROCalibData::SetWidthHV(const Float_t* WidthHV)
 257 {
 258   if(WidthHV) for(int t=0; t<64; t++) fWidthHV[t] = WidthHV[t];
 259   else for(int t=0; t<64; t++) fWidthHV[t] = 0.0;
 260 }
 261
 262 //________________________________________________________________
 263 void AliVZEROCalibData::SetDeadMap(const Bool_t* deadMap)
 264 {
 265   if(deadMap) for(int t=0; t<64; t++) fDeadChannel[t] = deadMap[t];
 266   else for(int t=0; t<64; t++) fDeadChannel[t] = kFALSE;
 267 }
 268
 269 //________________________________________________________________
 270 void AliVZEROCalibData::SetGain(const Float_t* Gain)
 271 {
 272   if(Gain) for(int t=0; t<128; t++) fGain[t] = Gain[t];
 273   else for(int t=0; t<128; t++) fGain[t] = 0.0;
 274 }
 275
 276 //________________________________________________________________
 277 void AliVZEROCalibData::SetTimeOffset(const Float_t* TimeOffset)
 278 {
 279   if(TimeOffset) for(int t=0; t<64; t++) fTimeOffset[t] = TimeOffset[t];
 280   else for(int t=0; t<64; t++) fTimeOffset[t] = 0.0;
 281 }
 282
 283 //________________________________________________________________
 284 void AliVZEROCalibData::SetTimeGain(const Float_t* TimeGain)
 285 {
 286   if(TimeGain) for(int t=0; t<64; t++) fTimeGain[t] = TimeGain[t];
 287   else for(int t=0; t<64; t++) fTimeGain[t] = 0.0;
 288 }
 289
 290 //_____________________________________________________________________________
 291 Float_t AliVZEROCalibData::GetMIPperADC(Int_t channel) const {
 292
 293         // Computes the MIP conversion factor - MIP per ADC channel -
 294         // Argument passed is the PM number (aliroot numbering)
 295
 296         Float_t p0[64] = {
 297                 7.094891, 7.124938, 7.089708, 7.098169, 7.094482, 7.147250, 7.170978, 7.183392,
 298                 7.145760, 7.148096, 7.153840, 7.143544, 7.186069, 7.194580, 7.203516, 7.195176,
 299                 7.188333, 7.198607, 7.209412, 7.226565, 7.221695, 7.205132, 7.191238, 7.227724,
 300                 7.232810, 7.252655, 7.230309, 7.273518, 7.273518, 7.242969, 7.252859, 7.252655,
 301                 7.026802, 7.079913, 7.134147, 7.092387, 7.079561, 7.072848, 7.123192, 7.003141,
 302                 7.024667, 7.124784, 7.123442, 7.129744, 7.110671, 7.143031, 7.139439, 7.178109,
 303                 7.247803, 7.139396, 7.293809, 7.094454, 6.992198, 7.206448, 7.244765, 7.056197,
 304                 7.263595, 7.138569, 7.089582, 7.215683, 7.266183, 7.165123, 7.243276, 7.235135 };
 305         Float_t p1[64] = {
 306                 0.135569, 0.146405, 0.142425, 0.144278, 0.142307, 0.141648, 0.128477, 0.138239,
 307                 0.144173, 0.143419, 0.143572, 0.144482, 0.138024, 0.136542, 0.135955, 0.138537,
 308                 0.148521, 0.141999, 0.139627, 0.130014, 0.134970, 0.135635, 0.139094, 0.140634,
 309                 0.137971, 0.142080, 0.142793, 0.142778, 0.142778, 0.146045, 0.139133, 0.142080,
 310                 0.144121, 0.142311, 0.136564, 0.142686, 0.138792, 0.166285, 0.136387, 0.155391,
 311                 0.176082, 0.140408, 0.164738, 0.144270, 0.142766, 0.147486, 0.141951, 0.138012,
 312                 0.132394, 0.142849, 0.140477, 0.144592, 0.141558, 0.157646, 0.143758, 0.173385,
 313                 0.146489, 0.143279, 0.145230, 0.147203, 0.147333, 0.144979, 0.148597, 0.138985 };
 314
 315         // High Voltage retrieval from Calibration Data Base:
 316         Float_t  hv = fMeanHV[channel];
 317         Float_t mip = -1;
 318         if (hv>0)
 319           mip = 0.6/TMath::Exp((TMath::Log(hv) - p0[channel] )/p1[channel]);
 320         return mip;
 321
 322 }
 323 //________________________________________________________________
 324 void AliVZEROCalibData::SetTimeResolution(UShort_t *resols){
 325         // Set Time Resolution of the TDC
 326         if(resols)  for(int t=0; t<kNCIUBoards; t++) SetTimeResolution(resols[t],t);
 327         else AliError("Time Resolution not defined.");
 328
 329 }
 330 //________________________________________________________________
 331 void AliVZEROCalibData::SetTimeResolution(UShort_t resol, Int_t board)
 332 {
 333         // Set Time Resolution of the TDC
 334         if((board>=0) && (board<kNCIUBoards)) {
 335                 switch(resol){
 336                         case 0:
 337                                 fTimeResolution[board] = 25./256.;
 338                                 break;
 339                         case 1:
 340                                 fTimeResolution[board] = 25./128.;
 341                                 break;
 342                         case 2:
 343                                 fTimeResolution[board] = 25./64.;
 344                                 break;
 345                         case 3:
 346                                 fTimeResolution[board] = 25./32.;
 347                                 break;
 348                         case 4:
 349                                 fTimeResolution[board] = 25./16.;
 350                                 break;
 351                         case 5:
 352                                 fTimeResolution[board] = 25./8.;
 353                                 break;
 354                         case 6:
 355                                 fTimeResolution[board] = 6.25;
 356                                 break;
 357                         case 7:
 358                                 fTimeResolution[board] = 12.5;
 359                                 break;
 360                 }
 361                 AliInfo(Form("Time Resolution of board %d set to %f",board,fTimeResolution[board]));
 362         } else AliError(Form("Board %d is not valid",board));
 363 }
 364 //________________________________________________________________
 365 void AliVZEROCalibData::SetWidthResolution(UShort_t *resols){
 366         // Set Time Width Resolution of the TDC
 367         if(resols)  for(int t=0; t<kNCIUBoards; t++) SetWidthResolution(resols[t],t);
 368         else AliError("Width Resolution not defined.");
 369
 370 }
 371 //________________________________________________________________
 372 void AliVZEROCalibData::SetWidthResolution(UShort_t resol, Int_t board)
 373 {
 374         // Set Time Width Resolution of the TDC
 375         if((board>=0) && (board<kNCIUBoards)){
 376                 switch(resol){
 377                         case 0:
 378                                 fWidthResolution[board] = 25./256.;
 379                                 break;
 380                         case 1:
 381                                 fWidthResolution[board] = 25./128.;
 382                                 break;
 383                         case 2:
 384                                 fWidthResolution[board] = 25./64.;
 385                                 break;
 386                         case 3:
 387                                 fWidthResolution[board] = 25./32.;
 388                                 break;
 389                         case 4:
 390                                 fWidthResolution[board] = 25./16.;
 391                                 break;
 392                         case 5:
 393                                 fWidthResolution[board] = 25./8.;
 394                                 break;
 395                         case 6:
 396                                 fWidthResolution[board] = 6.25;
 397                                 break;
 398                         case 7:
 399                                 fWidthResolution[board] = 12.5;
 400                                 break;
 401                         case 8:
 402                                 fWidthResolution[board] = 25.;
 403                                 break;
 404                         case 9:
 405                                 fWidthResolution[board] = 50.;
 406                                 break;
 407                         case 10:
 408                                 fWidthResolution[board] = 100.;
 409                                 break;
 410                         case 11:
 411                                 fWidthResolution[board] = 200.;
 412                                 break;
 413                         case 12:
 414                                 fWidthResolution[board] = 400.;
 415                                 break;
 416                         case 13:
 417                                 fWidthResolution[board] = 800.;
 418                                 break;
 419
 420                 }
 421                 AliInfo(Form("Width Resolution of board %d set to %f",board,fWidthResolution[board]));
 422         }else AliError(Form("Board %d is not valid",board));
 423 }
 424
 425 //________________________________________________________________
 426 void AliVZEROCalibData::SetMatchWindow(UInt_t *windows)
 427 {
 428   // Set Match window of the HPTDC
 429   // The units are 25ns
 430   if(windows)  for(Int_t b=0; b<kNCIUBoards; b++) SetMatchWindow(windows[b],b);
 431   else AliError("Match windows not defined.");
 432 }
 433
 434 //________________________________________________________________
 435 void AliVZEROCalibData::SetMatchWindow(UInt_t window, Int_t board)
 436 {
 437   // Set Match window of the HPTDC
 438   // The units are 25ns
 439   if((board>=0) && (board<kNCIUBoards)){
 440     fMatchWindow[board] = window;
 441     AliInfo(Form("Match window of board %d set to %d",board,fMatchWindow[board]));
 442   }
 443   else
 444     AliError(Form("Board %d is not valid",board));
 445 }
 446
 447 //________________________________________________________________
 448 void AliVZEROCalibData::SetSearchWindow(UInt_t *windows)
 449 {
 450   // Set Search window of the HPTDC
 451   // The units are 25ns
 452   if(windows)  for(Int_t b=0; b<kNCIUBoards; b++) SetSearchWindow(windows[b],b);
 453   else AliError("Search windows not defined.");
 454 }
 455
 456 //________________________________________________________________
 457 void  AliVZEROCalibData::SetSearchWindow(UInt_t window, Int_t board)
 458 {
 459   // Set Search window of the HPTDC
 460   // The units are 25ns
 461   if((board>=0) && (board<kNCIUBoards)){
 462     fSearchWindow[board] = window;
 463     AliInfo(Form("Search window of board %d set to %d",board,fSearchWindow[board]));
 464   }
 465   else
 466     AliError(Form("Board %d is not valid",board));
 467 }
 468
 469 //________________________________________________________________
 470 void AliVZEROCalibData::SetTriggerCountOffset(UInt_t *offsets)
 471 {
 472   // Set trigger-count offset of the HPTDC
 473   // The units are 25ns
 474   if(offsets)  for(Int_t b=0; b<kNCIUBoards; b++) SetTriggerCountOffset(offsets[b],b);
 475   else AliError("Trigger count offsets not defined.");
 476 }
 477
 478 //________________________________________________________________
 479 void AliVZEROCalibData::SetTriggerCountOffset(UInt_t offset, Int_t board)
 480 {
 481   // Set trigger-count offsets of the HPTDC
 482   // The units are 25ns
 483   if((board>=0) && (board<kNCIUBoards)){
 484     fTriggerCountOffset[board] = offset;
 485     AliInfo(Form("Trigger-count offset of board %d set to %d",board,fTriggerCountOffset[board]));
 486   }
 487   else
 488     AliError(Form("Board %d is not valid",board));
 489 }
 490
 491 //________________________________________________________________
 492 void AliVZEROCalibData::SetRollOver(UInt_t *offsets)
 493 {
 494   // Set Roll-over of the HPTDC
 495   // The units are 25ns
 496   if(offsets)  for(Int_t b=0; b<kNCIUBoards; b++) SetRollOver(offsets[b],b);
 497   else AliError("Roll-over offsets not defined.");
 498 }
 499
 500 //________________________________________________________________
 501 void AliVZEROCalibData::SetRollOver(UInt_t offset, Int_t board)
 502 {
 503   // Set Roll-over of the HPTDC
 504   // The units are 25ns
 505   if((board>=0) && (board<kNCIUBoards)){
 506     fRollOver[board] = offset;
 507     AliInfo(Form("Roll-over offset of board %d set to %d",board,fRollOver[board]));
 508   }
 509   else
 510     AliError(Form("Board %d is not valid",board));
 511 }