With this commit the VZERO trigger simulation is recovered. 1. The main change in...
[u/mrichter/AliRoot.git] / VZERO / AliVZEROCalibData.cxx
CommitLineData
3191f471 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
706506da 24#include <TMath.h>
d5deaaa5 25#include <TObjString.h>
26#include <TMap.h>
706506da 27
d5deaaa5 28#include "AliDCSValue.h"
3191f471 29#include "AliVZEROCalibData.h"
32c24147 30#include "AliVZERODataDCS.h"
31#include "AliLog.h"
3191f471 32
33ClassImp(AliVZEROCalibData)
34
35//________________________________________________________________
36AliVZEROCalibData::AliVZEROCalibData()
37{
2f09013f 38 // default constructor
39
40 for(int t=0; t<64; t++) {
41 fMeanHV[t] = 100.0;
42 fWidthHV[t] = 0.0;
992e9cba 43 fTimeOffset[t] = 5.0;
2f09013f 44 fTimeGain[t] = 1.0;
45 fDeadChannel[t]= kFALSE;
6e2c3e87 46 fDiscriThr[t] = 2.5;
2f09013f 47 }
48 for(int t=0; t<128; t++) {
49 fPedestal[t] = 0.0;
50 fSigma[t] = 0.0;
51 fADCmean[t] = 0.0;
52 fADCsigma[t] = 0.0;
2f09013f 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
32cd3fdc 57 fMatchWindow[i] = 4;
58 fSearchWindow[i] = 16;
59 fTriggerCountOffset[i] = 3247;
60 fRollOver[i] = 3563;
2f09013f 61 }
d5deaaa5 62
3191f471 63}
64
65//________________________________________________________________
a3c86e1f 66void AliVZEROCalibData::Reset()
67{
d7a5c700 68 // reset
a3c86e1f 69}
70
71//________________________________________________________________
3191f471 72AliVZEROCalibData::AliVZEROCalibData(const char* name)
73{
32c24147 74 // Constructor
2f09013f 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;
992e9cba 82 fTimeOffset[t] = 5.0;
2f09013f 83 fTimeGain[t] = 1.0;
84 fDeadChannel[t]= kFALSE;
6e2c3e87 85 fDiscriThr[t] = 2.5;
2f09013f 86 }
87 for(int t=0; t<128; t++) {
88 fPedestal[t] = 0.0;
89 fSigma[t] = 0.0;
90 fADCmean[t] = 0.0;
91 fADCsigma[t] = 0.0;
2f09013f 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
32cd3fdc 96 fMatchWindow[i] = 4;
97 fSearchWindow[i] = 16;
98 fTriggerCountOffset[i] = 3247;
99 fRollOver[i] = 3563;
2f09013f 100 }
3191f471 101
102}
103
104//________________________________________________________________
105AliVZEROCalibData::AliVZEROCalibData(const AliVZEROCalibData& calibda) :
106 TNamed(calibda)
107{
108// copy constructor
109
110 SetName(calibda.GetName());
111 SetTitle(calibda.GetName());
112
fae0e0c0 113 for(int t=0; t<128; t++) {
3191f471 114 fPedestal[t] = calibda.GetPedestal(t);
fae0e0c0 115 fSigma[t] = calibda.GetSigma(t);
2a25ea57 116 fADCmean[t] = calibda.GetADCmean(t);
4e2652e8 117 fADCsigma[t] = calibda.GetADCsigma(t); }
fae0e0c0 118
119 for(int t=0; t<64; t++) {
d7a5c700 120 fMeanHV[t] = calibda.GetMeanHV(t);
2a25ea57 121 fWidthHV[t] = calibda.GetWidthHV(t);
122 fTimeOffset[t] = calibda.GetTimeOffset(t);
d5deaaa5 123 fTimeGain[t] = calibda.GetTimeGain(t);
2f09013f 124 fDeadChannel[t] = calibda.IsChannelDead(t);
6e2c3e87 125 fDiscriThr[t] = calibda.GetDiscriThr(t);
d5deaaa5 126 }
127
2f09013f 128 for(int i=0; i<kNCIUBoards ;i++) {
129 fTimeResolution[i] = calibda.GetTimeResolution(i);
130 fWidthResolution[i] = calibda.GetWidthResolution(i);
32cd3fdc 131 fMatchWindow[i] = calibda.GetMatchWindow(i);
132 fSearchWindow[i] = calibda.GetSearchWindow(i);
133 fTriggerCountOffset[i] = calibda.GetTriggerCountOffset(i);
134 fRollOver[i] = calibda.GetRollOver(i);
2f09013f 135 }
3191f471 136
137}
138
139//________________________________________________________________
140AliVZEROCalibData &AliVZEROCalibData::operator =(const AliVZEROCalibData& calibda)
141{
142// assignment operator
143
144 SetName(calibda.GetName());
145 SetTitle(calibda.GetName());
146
fae0e0c0 147 for(int t=0; t<128; t++) {
3191f471 148 fPedestal[t] = calibda.GetPedestal(t);
fae0e0c0 149 fSigma[t] = calibda.GetSigma(t);
2a25ea57 150 fADCmean[t] = calibda.GetADCmean(t);
4e2652e8 151 fADCsigma[t] = calibda.GetADCsigma(t); }
fae0e0c0 152
2a25ea57 153 for(int t=0; t<64; t++) {
d7a5c700 154 fMeanHV[t] = calibda.GetMeanHV(t);
2a25ea57 155 fWidthHV[t] = calibda.GetWidthHV(t);
156 fTimeOffset[t] = calibda.GetTimeOffset(t);
d5deaaa5 157 fTimeGain[t] = calibda.GetTimeGain(t);
2f09013f 158 fDeadChannel[t] = calibda.IsChannelDead(t);
6e2c3e87 159 fDiscriThr[t] = calibda.GetDiscriThr(t);
d5deaaa5 160 }
2f09013f 161 for(int i=0; i<kNCIUBoards ;i++) {
162 fTimeResolution[i] = calibda.GetTimeResolution(i);
163 fWidthResolution[i] = calibda.GetWidthResolution(i);
32cd3fdc 164 fMatchWindow[i] = calibda.GetMatchWindow(i);
165 fSearchWindow[i] = calibda.GetSearchWindow(i);
166 fTriggerCountOffset[i] = calibda.GetTriggerCountOffset(i);
167 fRollOver[i] = calibda.GetRollOver(i);
2f09013f 168 }
2a25ea57 169
3191f471 170 return *this;
171
172}
173
174//________________________________________________________________
175AliVZEROCalibData::~AliVZEROCalibData()
176{
d7a5c700 177 // destructor
3191f471 178}
d5deaaa5 179//_____________________________________________________________________________
180void 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);
5978520a 188 Int_t val;
d5deaaa5 189 if(aValue) {
692e31a4 190 val = aValue->GetUInt();
5978520a 191 AliInfo(Form("%s : %d",aliasName->String().Data(), val));
d5deaaa5 192 SetParameter(aliasName->String(),val);
193 }
194 }
195
196 SetMeanHV(data->GetMeanHV());
197 SetWidthHV(data->GetWidthHV());
198 SetDeadMap(data->GetDeadMap());
199
200}
201//_____________________________________________________________________________
5978520a 202void AliVZEROCalibData::SetParameter(TString name, Int_t val){
d5deaaa5 203 // Set given parameter
204
205 Int_t iBoard = -1;
57c7500a 206 Int_t iChannel = -1;
d5deaaa5 207
208 TSeqCollection* nameSplit = name.Tokenize("/");
209 TObjString * boardName = (TObjString *)nameSplit->At(2);
210 sscanf(boardName->String().Data(),"CIU%d",&iBoard);
57c7500a 211
212 TString paramName = ((TObjString *)nameSplit->At(3))->String();
213 Char_t channel[2] ; channel[1] = '\0';
214 channel[0] = paramName[paramName.Sizeof()-2];
215 sscanf(channel,"%d",&iChannel);
d5deaaa5 216
4bc15c46 217 if(name.Contains("TimeResolution")) SetTimeResolution((UShort_t) val,iBoard);
218 else if(name.Contains("WidthResolution")) SetWidthResolution((UShort_t) val,iBoard);
32cd3fdc 219 else if(name.Contains("MatchWindow")) SetMatchWindow((UInt_t) val,iBoard);
220 else if(name.Contains("SearchWindow")) SetSearchWindow((UInt_t) val,iBoard);
221 else if(name.Contains("TriggerCountOffset")) SetTriggerCountOffset((UInt_t) val,iBoard);
222 else if(name.Contains("RollOver")) SetRollOver((UInt_t) val,iBoard);
51980118 223 else if(name.Contains("DelayHit")) SetTimeOffset(0.01*(Float_t)val,iBoard,(iChannel-1));
224 else if(name.Contains("DiscriThr")) SetDiscriThr(((Float_t)val-2040.)/112.,iBoard,(iChannel-1));
d5deaaa5 225 else AliError(Form("No Setter found for FEE parameter : %s",name.Data()));
226}
3191f471 227
3191f471 228//________________________________________________________________
32c24147 229void AliVZEROCalibData::SetPedestal(const Float_t* Pedestal)
3191f471 230{
fae0e0c0 231 if(Pedestal) for(int t=0; t<128; t++) fPedestal[t] = Pedestal[t];
232 else for(int t=0; t<128; t++) fPedestal[t] = 0.0;
233}
234
235//________________________________________________________________
32c24147 236void AliVZEROCalibData::SetSigma(const Float_t* Sigma)
fae0e0c0 237{
238 if(Sigma) for(int t=0; t<128; t++) fSigma[t] = Sigma[t];
239 else for(int t=0; t<128; t++) fSigma[t] = 0.0;
3191f471 240}
241
242//________________________________________________________________
32c24147 243void AliVZEROCalibData::SetADCmean(const Float_t* ADCmean)
3191f471 244{
2a25ea57 245 if(ADCmean) for(int t=0; t<128; t++) fADCmean[t] = ADCmean[t];
246 else for(int t=0; t<128; t++) fADCmean[t] = 0.0;
3191f471 247}
248
fae0e0c0 249//________________________________________________________________
32c24147 250void AliVZEROCalibData::SetADCsigma(const Float_t* ADCsigma)
40b6a179 251{
252 if(ADCsigma) for(int t=0; t<128; t++) fADCsigma[t] = ADCsigma[t];
253 else for(int t=0; t<128; t++) fADCsigma[t] = 0.0;
254}
255
256//________________________________________________________________
32c24147 257void AliVZEROCalibData::SetMeanHV(const Float_t* MeanHV)
fae0e0c0 258{
2a25ea57 259 if(MeanHV) for(int t=0; t<64; t++) fMeanHV[t] = MeanHV[t];
260 else for(int t=0; t<64; t++) fMeanHV[t] = 0.0;
fae0e0c0 261}
262
263//________________________________________________________________
32c24147 264void AliVZEROCalibData::SetWidthHV(const Float_t* WidthHV)
fae0e0c0 265{
2a25ea57 266 if(WidthHV) for(int t=0; t<64; t++) fWidthHV[t] = WidthHV[t];
267 else for(int t=0; t<64; t++) fWidthHV[t] = 0.0;
fae0e0c0 268}
d7a5c700 269
270//________________________________________________________________
32c24147 271void AliVZEROCalibData::SetDeadMap(const Bool_t* deadMap)
7495d2be 272{
273 if(deadMap) for(int t=0; t<64; t++) fDeadChannel[t] = deadMap[t];
274 else for(int t=0; t<64; t++) fDeadChannel[t] = kFALSE;
275}
276
277//________________________________________________________________
51980118 278void AliVZEROCalibData::SetTimeOffset(Float_t val, Int_t board, Int_t channel)
57c7500a 279{
51980118 280 Int_t ch = AliVZEROCalibData::GetOfflineChannelNumber(board,channel);
281 if(ch >= 0){
282 fTimeOffset[ch]=val;
283 AliInfo(Form("Time offset for channel %d set to %f",ch,fTimeOffset[ch]));
57c7500a 284 }
285 else
51980118 286 AliError("Board/Channel numbers are not valid");
57c7500a 287}
288
289//________________________________________________________________
32c24147 290void AliVZEROCalibData::SetTimeOffset(const Float_t* TimeOffset)
d7a5c700 291{
2a25ea57 292 if(TimeOffset) for(int t=0; t<64; t++) fTimeOffset[t] = TimeOffset[t];
992e9cba 293 else for(int t=0; t<64; t++) fTimeOffset[t] = 5.0;
d7a5c700 294}
2a25ea57 295
296//________________________________________________________________
32c24147 297void AliVZEROCalibData::SetTimeGain(const Float_t* TimeGain)
2a25ea57 298{
299 if(TimeGain) for(int t=0; t<64; t++) fTimeGain[t] = TimeGain[t];
300 else for(int t=0; t<64; t++) fTimeGain[t] = 0.0;
301}
302
706506da 303//_____________________________________________________________________________
304Float_t AliVZEROCalibData::GetMIPperADC(Int_t channel) const {
305
306 // Computes the MIP conversion factor - MIP per ADC channel -
307 // Argument passed is the PM number (aliroot numbering)
308
32c24147 309 Float_t p0[64] = {
706506da 310 7.094891, 7.124938, 7.089708, 7.098169, 7.094482, 7.147250, 7.170978, 7.183392,
311 7.145760, 7.148096, 7.153840, 7.143544, 7.186069, 7.194580, 7.203516, 7.195176,
312 7.188333, 7.198607, 7.209412, 7.226565, 7.221695, 7.205132, 7.191238, 7.227724,
11b348f3 313 7.232810, 7.252655, 7.230309, 7.140891, 7.273518, 7.242969, 7.252859, 7.252655,
706506da 314 7.026802, 7.079913, 7.134147, 7.092387, 7.079561, 7.072848, 7.123192, 7.003141,
315 7.024667, 7.124784, 7.123442, 7.129744, 7.110671, 7.143031, 7.139439, 7.178109,
316 7.247803, 7.139396, 7.293809, 7.094454, 6.992198, 7.206448, 7.244765, 7.056197,
317 7.263595, 7.138569, 7.089582, 7.215683, 7.266183, 7.165123, 7.243276, 7.235135 };
32c24147 318 Float_t p1[64] = {
706506da 319 0.135569, 0.146405, 0.142425, 0.144278, 0.142307, 0.141648, 0.128477, 0.138239,
320 0.144173, 0.143419, 0.143572, 0.144482, 0.138024, 0.136542, 0.135955, 0.138537,
321 0.148521, 0.141999, 0.139627, 0.130014, 0.134970, 0.135635, 0.139094, 0.140634,
11b348f3 322 0.137971, 0.142080, 0.142793, 0.136054, 0.142778, 0.146045, 0.139133, 0.142080,
706506da 323 0.144121, 0.142311, 0.136564, 0.142686, 0.138792, 0.166285, 0.136387, 0.155391,
324 0.176082, 0.140408, 0.164738, 0.144270, 0.142766, 0.147486, 0.141951, 0.138012,
325 0.132394, 0.142849, 0.140477, 0.144592, 0.141558, 0.157646, 0.143758, 0.173385,
326 0.146489, 0.143279, 0.145230, 0.147203, 0.147333, 0.144979, 0.148597, 0.138985 };
327
328 // High Voltage retrieval from Calibration Data Base:
32c24147 329 Float_t hv = fMeanHV[channel];
330 Float_t mip = -1;
331 if (hv>0)
332 mip = 0.6/TMath::Exp((TMath::Log(hv) - p0[channel] )/p1[channel]);
333 return mip;
706506da 334
335}
4e2652e8 336
337//________________________________________________________________
338Float_t AliVZEROCalibData::GetGain(Int_t channel) const
339{
340 // Computes the PM gain factors
341 // Argument passed is the PM number (aliroot numbering)
342 Float_t a[64] = {-39.68,-35.83,-36.92,-36.42,-37.02,-37.50,-43.05,-39.39,
343 -36.62,-36.93,-37.30,-36.46,-39.51,-40.32,-39.92,-39.20,
344 -35.39,-37.95,-38.85,-42.76,-40.68,-40.32,-39.00,-37.36,
345 -39.64,-38.86,-37.59,-39.59,-37.97,-36.32,-38.88,-41.35,
346 -36.01,-36.82,-39.48,-36.86,-38.22,-32.55,-39.44,-35.08,
347 -29.91,-37.88,-33.25,-36.49,-37.25,-35.89,-40.31,-39.15,
348 -41.71,-37.07,-38.94,-36.04,-36.62,-32.96,-36.99,-30.71,
349 -36.66,-37.23,-35.98,-36.56,-35.64,-36.97,-35.88,-38.78};
350 Float_t b[64] = { 7.40, 6.83, 7.02, 6.94, 7.03, 7.04, 7.79, 7.27,
351 6.92, 6.96, 7.01, 6.90, 7.28, 7.38, 7.33, 7.23,
352 6.71, 7.05, 7.17, 7.69, 7.41, 7.38, 7.21, 7.11,
353 7.26, 7.12, 6.98, 7.35, 6.99, 6.79, 7.13, 7.58,
354 6.95, 7.01, 7.33, 7.01, 7.21, 6.01, 7.34, 6.44,
355 5.68, 7.12, 6.07, 6.92, 7.04, 6.82, 7.04, 7.24,
356 7.53, 6.99, 7.10, 6.89, 7.07, 6.35, 6.88, 5.77,
357 6.81, 7.01, 6.89, 6.84, 6.68, 6.95, 6.73, 7.14};
358
359 // High Voltage retrieval from Calibration Data Base:
360 Float_t hv = fMeanHV[channel];
361 Float_t gain = 0;
362 if (hv>0)
363 gain = TMath::Exp(a[channel]+b[channel]*TMath::Log(hv));
364 return gain;
365}
366
d5deaaa5 367//________________________________________________________________
368void AliVZEROCalibData::SetTimeResolution(UShort_t *resols){
369 // Set Time Resolution of the TDC
370 if(resols) for(int t=0; t<kNCIUBoards; t++) SetTimeResolution(resols[t],t);
4bc15c46 371 else AliError("Time Resolution not defined.");
d5deaaa5 372
373}
374//________________________________________________________________
375void AliVZEROCalibData::SetTimeResolution(UShort_t resol, Int_t board)
376{
377 // Set Time Resolution of the TDC
4bc15c46 378 if((board>=0) && (board<kNCIUBoards)) {
d5deaaa5 379 switch(resol){
380 case 0:
381 fTimeResolution[board] = 25./256.;
382 break;
383 case 1:
384 fTimeResolution[board] = 25./128.;
385 break;
386 case 2:
387 fTimeResolution[board] = 25./64.;
388 break;
389 case 3:
390 fTimeResolution[board] = 25./32.;
391 break;
392 case 4:
393 fTimeResolution[board] = 25./16.;
394 break;
395 case 5:
396 fTimeResolution[board] = 25./8.;
397 break;
398 case 6:
399 fTimeResolution[board] = 6.25;
400 break;
401 case 7:
402 fTimeResolution[board] = 12.5;
403 break;
404 }
4bc15c46 405 AliInfo(Form("Time Resolution of board %d set to %f",board,fTimeResolution[board]));
d5deaaa5 406 } else AliError(Form("Board %d is not valid",board));
407}
408//________________________________________________________________
409void AliVZEROCalibData::SetWidthResolution(UShort_t *resols){
410 // Set Time Width Resolution of the TDC
411 if(resols) for(int t=0; t<kNCIUBoards; t++) SetWidthResolution(resols[t],t);
4bc15c46 412 else AliError("Width Resolution not defined.");
d5deaaa5 413
414}
415//________________________________________________________________
416void AliVZEROCalibData::SetWidthResolution(UShort_t resol, Int_t board)
417{
418 // Set Time Width Resolution of the TDC
4bc15c46 419 if((board>=0) && (board<kNCIUBoards)){
d5deaaa5 420 switch(resol){
421 case 0:
422 fWidthResolution[board] = 25./256.;
423 break;
424 case 1:
425 fWidthResolution[board] = 25./128.;
426 break;
427 case 2:
428 fWidthResolution[board] = 25./64.;
429 break;
430 case 3:
431 fWidthResolution[board] = 25./32.;
432 break;
433 case 4:
434 fWidthResolution[board] = 25./16.;
435 break;
436 case 5:
437 fWidthResolution[board] = 25./8.;
438 break;
439 case 6:
440 fWidthResolution[board] = 6.25;
441 break;
442 case 7:
443 fWidthResolution[board] = 12.5;
444 break;
445 case 8:
446 fWidthResolution[board] = 25.;
447 break;
448 case 9:
449 fWidthResolution[board] = 50.;
450 break;
451 case 10:
452 fWidthResolution[board] = 100.;
453 break;
454 case 11:
455 fWidthResolution[board] = 200.;
456 break;
457 case 12:
458 fWidthResolution[board] = 400.;
459 break;
460 case 13:
461 fWidthResolution[board] = 800.;
462 break;
463
464 }
4bc15c46 465 AliInfo(Form("Width Resolution of board %d set to %f",board,fWidthResolution[board]));
d5deaaa5 466 }else AliError(Form("Board %d is not valid",board));
467}
706506da 468
32cd3fdc 469//________________________________________________________________
470void AliVZEROCalibData::SetMatchWindow(UInt_t *windows)
471{
472 // Set Match window of the HPTDC
473 // The units are 25ns
474 if(windows) for(Int_t b=0; b<kNCIUBoards; b++) SetMatchWindow(windows[b],b);
475 else AliError("Match windows not defined.");
476}
477
478//________________________________________________________________
479void AliVZEROCalibData::SetMatchWindow(UInt_t window, Int_t board)
480{
481 // Set Match window of the HPTDC
482 // The units are 25ns
483 if((board>=0) && (board<kNCIUBoards)){
484 fMatchWindow[board] = window;
485 AliInfo(Form("Match window of board %d set to %d",board,fMatchWindow[board]));
486 }
487 else
488 AliError(Form("Board %d is not valid",board));
489}
490
491//________________________________________________________________
492void AliVZEROCalibData::SetSearchWindow(UInt_t *windows)
493{
494 // Set Search window of the HPTDC
495 // The units are 25ns
496 if(windows) for(Int_t b=0; b<kNCIUBoards; b++) SetSearchWindow(windows[b],b);
497 else AliError("Search windows not defined.");
498}
499
500//________________________________________________________________
501void AliVZEROCalibData::SetSearchWindow(UInt_t window, Int_t board)
502{
503 // Set Search window of the HPTDC
504 // The units are 25ns
505 if((board>=0) && (board<kNCIUBoards)){
506 fSearchWindow[board] = window;
507 AliInfo(Form("Search window of board %d set to %d",board,fSearchWindow[board]));
508 }
509 else
510 AliError(Form("Board %d is not valid",board));
511}
512
513//________________________________________________________________
514void AliVZEROCalibData::SetTriggerCountOffset(UInt_t *offsets)
515{
516 // Set trigger-count offset of the HPTDC
517 // The units are 25ns
518 if(offsets) for(Int_t b=0; b<kNCIUBoards; b++) SetTriggerCountOffset(offsets[b],b);
519 else AliError("Trigger count offsets not defined.");
520}
521
522//________________________________________________________________
523void AliVZEROCalibData::SetTriggerCountOffset(UInt_t offset, Int_t board)
524{
525 // Set trigger-count offsets of the HPTDC
526 // The units are 25ns
527 if((board>=0) && (board<kNCIUBoards)){
528 fTriggerCountOffset[board] = offset;
529 AliInfo(Form("Trigger-count offset of board %d set to %d",board,fTriggerCountOffset[board]));
530 }
531 else
532 AliError(Form("Board %d is not valid",board));
533}
534
535//________________________________________________________________
536void AliVZEROCalibData::SetRollOver(UInt_t *offsets)
537{
538 // Set Roll-over of the HPTDC
539 // The units are 25ns
540 if(offsets) for(Int_t b=0; b<kNCIUBoards; b++) SetRollOver(offsets[b],b);
541 else AliError("Roll-over offsets not defined.");
542}
543
544//________________________________________________________________
545void AliVZEROCalibData::SetRollOver(UInt_t offset, Int_t board)
546{
547 // Set Roll-over of the HPTDC
548 // The units are 25ns
549 if((board>=0) && (board<kNCIUBoards)){
550 fRollOver[board] = offset;
551 AliInfo(Form("Roll-over offset of board %d set to %d",board,fRollOver[board]));
552 }
553 else
554 AliError(Form("Board %d is not valid",board));
555}
6e2c3e87 556
557//________________________________________________________________
51980118 558void AliVZEROCalibData::SetDiscriThr(Float_t thr, Int_t board, Int_t channel)
6e2c3e87 559{
560 // Set the TDC discriminator
561 // threshold values expressed in units of ADC
51980118 562 Int_t ch = AliVZEROCalibData::GetOfflineChannelNumber(board,channel);
563 if(ch >= 0){
6e2c3e87 564 if (thr > 0) {
51980118 565 fDiscriThr[ch]=thr;
566 AliInfo(Form("Discriminator threshold for channel %d set to %f",ch,fDiscriThr[ch]));
6e2c3e87 567 }
568 else {
51980118 569 AliWarning(Form("Ignore wrong threshold value (%f) for channel %d !",thr,ch));
6e2c3e87 570 }
571 }
572 else
51980118 573 AliError("Board/Channel numbers are not valid");
6e2c3e87 574}
575
576//________________________________________________________________
577void AliVZEROCalibData::SetDiscriThr(const Float_t* thresholds)
578{
579 // Set the TDC discriminator
580 // threshold values expressed in units of ADC
581 if(thresholds) for(int t=0; t<64; t++) fDiscriThr[t] = thresholds[t];
582 else for(int t=0; t<64; t++) fDiscriThr[t] = 2.5;
583}
51980118 584
585Int_t AliVZEROCalibData::GetOfflineChannelNumber(Int_t board, Int_t channel)
586{
587 // Get the offline channel number from
588 // the FEE board and channel indexes
589
590 if (board < 0 || board >= 8) {
591 AliErrorClass(Form("Wrong FEE board number: %d",board));
592 return -1;
593 }
594 if (channel < 0 || channel >= 8) {
595 AliErrorClass(Form("Wrong FEE channel number: %d",channel));
596 return -1;
597 }
598
599 Int_t offCh = (board < 4) ? (8 * board + 32) : (8 * board -32);
600 offCh += (7 - channel);
601
602 return offCh;
603}
604
605Int_t AliVZEROCalibData::GetBoardNumber(Int_t channel)
606{
607 // Get FEE board number
608 // from offline channel index
609 if (channel >= 0 && channel < 32) return (channel / 8 + 4);
610 if (channel >=32 && channel < 64) return (channel / 8 - 4);
611
612 AliErrorClass(Form("Wrong channel index: %d",channel));
613 return -1;
614}
d0ff6548 615
616Int_t AliVZEROCalibData::GetFEEChannelNumber(Int_t channel)
617{
618 // Get FEE channel number
619 // from offline channel index
620 if (channel >= 0 && channel < 64) return (7 - (channel % 8));
621
622 AliErrorClass(Form("Wrong channel index: %d",channel));
623 return -1;
624}