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
  31 ClassImp(AliVZEROCalibData)
  32
  33 //________________________________________________________________
  34 AliVZEROCalibData::AliVZEROCalibData()
  35 {
  36   // default constructor
  37
  38     for(int t=0; t<64; t++) {
  39         fMeanHV[t]      = 100.0;
  40         fWidthHV[t]     = 0.0;
  41         fTimeOffset[t]  = 0.0;
  42         fTimeGain[t]    = 1.0;
  43         fDeadChannel[t]= kFALSE;
  44     }
  45     for(int t=0; t<128; t++) {
  46         fPedestal[t]    = 0.0;
  47         fSigma[t]       = 0.0;
  48         fADCmean[t]     = 0.0;
  49         fADCsigma[t]    = 0.0;
  50         fGain[t]        = 1.0;
  51     }
  52     for(int i=0; i<kNCIUBoards ;i++) {
  53         fTimeResolution[i]  = 25./256.;     // Default time resolution
  54         fWidthResolution[i] = 25./64.;     // Default time width resolution
  55     }
  56
  57 }
  58
  59 //________________________________________________________________
  60 void AliVZEROCalibData::Reset()
  61 {
  62   // reset
  63 }
  64
  65 //________________________________________________________________
  66 AliVZEROCalibData::AliVZEROCalibData(const char* name)
  67 {
  68    TString namst = "Calib_";
  69    namst += name;
  70    SetName(namst.Data());
  71    SetTitle(namst.Data());
  72    for(int t=0; t<64; t++) {
  73        fMeanHV[t]      = 100.0;
  74        fWidthHV[t]     = 0.0;
  75        fTimeOffset[t]  = 0.0;
  76        fTimeGain[t]    = 1.0;
  77        fDeadChannel[t]= kFALSE;
  78     }
  79    for(int t=0; t<128; t++) {
  80        fPedestal[t]    = 0.0;
  81        fSigma[t]       = 0.0;
  82        fADCmean[t]     = 0.0;
  83        fADCsigma[t]    = 0.0;
  84        fGain[t]        = 1.0;
  85    }
  86    for(int i=0; i<kNCIUBoards ;i++) {
  87        fTimeResolution[i]  = 25./256.;    // Default time resolution in ns / channel
  88        fWidthResolution[i] = 25./64.;     // Default time width resolution in ns / channel
  89    }
  90
  91 }
  92
  93 //________________________________________________________________
  94 AliVZEROCalibData::AliVZEROCalibData(const AliVZEROCalibData& calibda) :
  95   TNamed(calibda)
  96 {
  97 // copy constructor
  98
  99   SetName(calibda.GetName());
 100   SetTitle(calibda.GetName());
 101
 102   for(int t=0; t<128; t++) {
 103       fPedestal[t] = calibda.GetPedestal(t);
 104       fSigma[t]    = calibda.GetSigma(t);
 105       fADCmean[t]  = calibda.GetADCmean(t);
 106       fADCsigma[t] = calibda.GetADCsigma(t);
 107       fGain[t]     = calibda.GetGain(t); }
 108
 109   for(int t=0; t<64; t++) {
 110       fMeanHV[t]       = calibda.GetMeanHV(t);
 111       fWidthHV[t]      = calibda.GetWidthHV(t);
 112       fTimeOffset[t]   = calibda.GetTimeOffset(t);
 113       fTimeGain[t]     = calibda.GetTimeGain(t);
 114       fDeadChannel[t]  = calibda.IsChannelDead(t);
 115   }
 116
 117   for(int i=0; i<kNCIUBoards ;i++) {
 118       fTimeResolution[i]  = calibda.GetTimeResolution(i);
 119       fWidthResolution[i] = calibda.GetWidthResolution(i);
 120   }
 121
 122 }
 123
 124 //________________________________________________________________
 125 AliVZEROCalibData &AliVZEROCalibData::operator =(const AliVZEROCalibData& calibda)
 126 {
 127 // assignment operator
 128
 129   SetName(calibda.GetName());
 130   SetTitle(calibda.GetName());
 131
 132   for(int t=0; t<128; t++) {
 133       fPedestal[t] = calibda.GetPedestal(t);
 134       fSigma[t]    = calibda.GetSigma(t);
 135       fADCmean[t]  = calibda.GetADCmean(t);
 136       fADCsigma[t] = calibda.GetADCsigma(t);
 137       fGain[t]     = calibda.GetGain(t); }
 138
 139   for(int t=0; t<64; t++) {
 140       fMeanHV[t]       = calibda.GetMeanHV(t);
 141       fWidthHV[t]      = calibda.GetWidthHV(t);
 142       fTimeOffset[t]   = calibda.GetTimeOffset(t);
 143       fTimeGain[t]     = calibda.GetTimeGain(t);
 144       fDeadChannel[t]  = calibda.IsChannelDead(t);
 145   }
 146   for(int i=0; i<kNCIUBoards ;i++) {
 147       fTimeResolution[i]  = calibda.GetTimeResolution(i);
 148       fWidthResolution[i] = calibda.GetWidthResolution(i);
 149   }
 150
 151   return *this;
 152
 153 }
 154
 155 //________________________________________________________________
 156 AliVZEROCalibData::~AliVZEROCalibData()
 157 {
 158   // destructor
 159 }
 160 //_____________________________________________________________________________
 161 void AliVZEROCalibData::FillDCSData(AliVZERODataDCS * data){
 162         // Set all parameters from the data get by the shuttle
 163         TMap * params = data->GetFEEParameters();
 164         TIter iter(params);
 165         TObjString* aliasName;
 166
 167         while ((  aliasName = (TObjString*) iter.Next() ))  {
 168                 AliDCSValue* aValue = (AliDCSValue*) params->GetValue(aliasName);
 169                 Float_t val;
 170                 if(aValue) {
 171                         val = aValue->GetFloat();
 172                         //AliInfo(Form("%s : %f",aliasName->String().Data(), val));
 173                         SetParameter(aliasName->String(),val);
 174                 }
 175         }
 176
 177         SetMeanHV(data->GetMeanHV());
 178         SetWidthHV(data->GetWidthHV());
 179         SetDeadMap(data->GetDeadMap());
 180
 181 }
 182 //_____________________________________________________________________________
 183 void AliVZEROCalibData::SetParameter(TString name, Float_t val){
 184         // Set given parameter
 185
 186         Int_t iBoard = -1;
 187
 188         TSeqCollection* nameSplit = name.Tokenize("/");
 189         TObjString * boardName = (TObjString *)nameSplit->At(2);
 190         sscanf(boardName->String().Data(),"CIU%d",&iBoard);
 191
 192         if(name.Contains("TimeResolution")) SetTimeResolution((UShort_t) val,iBoard-1);
 193         else if(name.Contains("WidthResolution")) SetWidthResolution((UShort_t) val,iBoard-1);
 194         else AliError(Form("No Setter found for FEE parameter : %s",name.Data()));
 195 }
 196
 197 //________________________________________________________________
 198 void AliVZEROCalibData::SetPedestal(Float_t* Pedestal)
 199 {
 200   if(Pedestal) for(int t=0; t<128; t++) fPedestal[t] = Pedestal[t];
 201   else for(int t=0; t<128; t++) fPedestal[t] = 0.0;
 202 }
 203
 204 //________________________________________________________________
 205 void AliVZEROCalibData::SetSigma(Float_t* Sigma)
 206 {
 207   if(Sigma) for(int t=0; t<128; t++) fSigma[t] = Sigma[t];
 208   else for(int t=0; t<128; t++) fSigma[t] = 0.0;
 209 }
 210
 211 //________________________________________________________________
 212 void AliVZEROCalibData::SetADCmean(Float_t* ADCmean)
 213 {
 214   if(ADCmean) for(int t=0; t<128; t++) fADCmean[t] = ADCmean[t];
 215   else for(int t=0; t<128; t++) fADCmean[t] = 0.0;
 216 }
 217
 218 //________________________________________________________________
 219 void AliVZEROCalibData::SetADCsigma(Float_t* ADCsigma)
 220 {
 221   if(ADCsigma) for(int t=0; t<128; t++) fADCsigma[t] = ADCsigma[t];
 222   else for(int t=0; t<128; t++) fADCsigma[t] = 0.0;
 223 }
 224
 225 //________________________________________________________________
 226 void AliVZEROCalibData::SetMeanHV(Float_t* MeanHV)
 227 {
 228   if(MeanHV) for(int t=0; t<64; t++) fMeanHV[t] = MeanHV[t];
 229   else for(int t=0; t<64; t++) fMeanHV[t] = 0.0;
 230 }
 231
 232 //________________________________________________________________
 233 void AliVZEROCalibData::SetWidthHV(Float_t* WidthHV)
 234 {
 235   if(WidthHV) for(int t=0; t<64; t++) fWidthHV[t] = WidthHV[t];
 236   else for(int t=0; t<64; t++) fWidthHV[t] = 0.0;
 237 }
 238
 239 //________________________________________________________________
 240 void AliVZEROCalibData::SetDeadMap(Bool_t* deadMap)
 241 {
 242   if(deadMap) for(int t=0; t<64; t++) fDeadChannel[t] = deadMap[t];
 243   else for(int t=0; t<64; t++) fDeadChannel[t] = kFALSE;
 244 }
 245
 246 //________________________________________________________________
 247 void AliVZEROCalibData::SetGain(Float_t* Gain)
 248 {
 249   if(Gain) for(int t=0; t<128; t++) fGain[t] = Gain[t];
 250   else for(int t=0; t<128; t++) fGain[t] = 0.0;
 251 }
 252
 253 //________________________________________________________________
 254 void AliVZEROCalibData::SetTimeOffset(Float_t* TimeOffset)
 255 {
 256   if(TimeOffset) for(int t=0; t<64; t++) fTimeOffset[t] = TimeOffset[t];
 257   else for(int t=0; t<64; t++) fTimeOffset[t] = 0.0;
 258 }
 259
 260 //________________________________________________________________
 261 void AliVZEROCalibData::SetTimeGain(Float_t* TimeGain)
 262 {
 263   if(TimeGain) for(int t=0; t<64; t++) fTimeGain[t] = TimeGain[t];
 264   else for(int t=0; t<64; t++) fTimeGain[t] = 0.0;
 265 }
 266
 267 //_____________________________________________________________________________
 268 Float_t AliVZEROCalibData::GetMIPperADC(Int_t channel) const {
 269
 270         // Computes the MIP conversion factor - MIP per ADC channel -
 271         // Argument passed is the PM number (aliroot numbering)
 272
 273         Float_t P0[64] = {
 274                 7.094891, 7.124938, 7.089708, 7.098169, 7.094482, 7.147250, 7.170978, 7.183392,
 275                 7.145760, 7.148096, 7.153840, 7.143544, 7.186069, 7.194580, 7.203516, 7.195176,
 276                 7.188333, 7.198607, 7.209412, 7.226565, 7.221695, 7.205132, 7.191238, 7.227724,
 277                 7.232810, 7.252655, 7.230309, 7.273518, 7.273518, 7.242969, 7.252859, 7.252655,
 278                 7.026802, 7.079913, 7.134147, 7.092387, 7.079561, 7.072848, 7.123192, 7.003141,
 279                 7.024667, 7.124784, 7.123442, 7.129744, 7.110671, 7.143031, 7.139439, 7.178109,
 280                 7.247803, 7.139396, 7.293809, 7.094454, 6.992198, 7.206448, 7.244765, 7.056197,
 281                 7.263595, 7.138569, 7.089582, 7.215683, 7.266183, 7.165123, 7.243276, 7.235135 };
 282         Float_t P1[64] = {
 283                 0.135569, 0.146405, 0.142425, 0.144278, 0.142307, 0.141648, 0.128477, 0.138239,
 284                 0.144173, 0.143419, 0.143572, 0.144482, 0.138024, 0.136542, 0.135955, 0.138537,
 285                 0.148521, 0.141999, 0.139627, 0.130014, 0.134970, 0.135635, 0.139094, 0.140634,
 286                 0.137971, 0.142080, 0.142793, 0.142778, 0.142778, 0.146045, 0.139133, 0.142080,
 287                 0.144121, 0.142311, 0.136564, 0.142686, 0.138792, 0.166285, 0.136387, 0.155391,
 288                 0.176082, 0.140408, 0.164738, 0.144270, 0.142766, 0.147486, 0.141951, 0.138012,
 289                 0.132394, 0.142849, 0.140477, 0.144592, 0.141558, 0.157646, 0.143758, 0.173385,
 290                 0.146489, 0.143279, 0.145230, 0.147203, 0.147333, 0.144979, 0.148597, 0.138985 };
 291
 292         // High Voltage retrieval from Calibration Data Base:
 293         Float_t  HV = fMeanHV[channel];
 294         Float_t MIP = -1;
 295         if (HV>0)
 296           MIP = 0.5/TMath::Exp((TMath::Log(HV) - P0[channel] )/P1[channel]);
 297         return MIP;
 298
 299 }
 300 //________________________________________________________________
 301 void AliVZEROCalibData::SetTimeResolution(UShort_t *resols){
 302         // Set Time Resolution of the TDC
 303         if(resols)  for(int t=0; t<kNCIUBoards; t++) SetTimeResolution(resols[t],t);
 304         else AliFatal("Time Resolution not defined.");
 305
 306 }
 307 //________________________________________________________________
 308 void AliVZEROCalibData::SetTimeResolution(UShort_t resol, Int_t board)
 309 {
 310         // Set Time Resolution of the TDC
 311         if((board<kNCIUBoards)) {
 312                 switch(resol){
 313                         case 0:
 314                                 fTimeResolution[board] = 25./256.;
 315                                 break;
 316                         case 1:
 317                                 fTimeResolution[board] = 25./128.;
 318                                 break;
 319                         case 2:
 320                                 fTimeResolution[board] = 25./64.;
 321                                 break;
 322                         case 3:
 323                                 fTimeResolution[board] = 25./32.;
 324                                 break;
 325                         case 4:
 326                                 fTimeResolution[board] = 25./16.;
 327                                 break;
 328                         case 5:
 329                                 fTimeResolution[board] = 25./8.;
 330                                 break;
 331                         case 6:
 332                                 fTimeResolution[board] = 6.25;
 333                                 break;
 334                         case 7:
 335                                 fTimeResolution[board] = 12.5;
 336                                 break;
 337                 }
 338         } else AliError(Form("Board %d is not valid",board));
 339 }
 340 //________________________________________________________________
 341 void AliVZEROCalibData::SetWidthResolution(UShort_t *resols){
 342         // Set Time Width Resolution of the TDC
 343         if(resols)  for(int t=0; t<kNCIUBoards; t++) SetWidthResolution(resols[t],t);
 344         else AliFatal("Width Resolution not defined.");
 345
 346 }
 347 //________________________________________________________________
 348 void AliVZEROCalibData::SetWidthResolution(UShort_t resol, Int_t board)
 349 {
 350         // Set Time Width Resolution of the TDC
 351         if((board<kNCIUBoards)){
 352                 switch(resol){
 353                         case 0:
 354                                 fWidthResolution[board] = 25./256.;
 355                                 break;
 356                         case 1:
 357                                 fWidthResolution[board] = 25./128.;
 358                                 break;
 359                         case 2:
 360                                 fWidthResolution[board] = 25./64.;
 361                                 break;
 362                         case 3:
 363                                 fWidthResolution[board] = 25./32.;
 364                                 break;
 365                         case 4:
 366                                 fWidthResolution[board] = 25./16.;
 367                                 break;
 368                         case 5:
 369                                 fWidthResolution[board] = 25./8.;
 370                                 break;
 371                         case 6:
 372                                 fWidthResolution[board] = 6.25;
 373                                 break;
 374                         case 7:
 375                                 fWidthResolution[board] = 12.5;
 376                                 break;
 377                         case 8:
 378                                 fWidthResolution[board] = 25.;
 379                                 break;
 380                         case 9:
 381                                 fWidthResolution[board] = 50.;
 382                                 break;
 383                         case 10:
 384                                 fWidthResolution[board] = 100.;
 385                                 break;
 386                         case 11:
 387                                 fWidthResolution[board] = 200.;
 388                                 break;
 389                         case 12:
 390                                 fWidthResolution[board] = 400.;
 391                                 break;
 392                         case 13:
 393                                 fWidthResolution[board] = 800.;
 394                                 break;
 395
 396                 }
 397         }else AliError(Form("Board %d is not valid",board));
 398 }
 399