1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
16 /* $Id: AliVZEROCalibData.cxx, */
18 /////////////////////////////////////////////////////////////////////////////
20 // class for VZERO calibration //
22 /////////////////////////////////////////////////////////////////////////////
25 #include <TObjString.h>
28 #include "AliDCSValue.h"
29 #include "AliVZEROCalibData.h"
30 #include "AliVZERODataDCS.h"
33 ClassImp(AliVZEROCalibData)
35 //________________________________________________________________
36 AliVZEROCalibData::AliVZEROCalibData()
38 // default constructor
40 for(int t=0; t<64; t++) {
45 fDeadChannel[t]= kFALSE;
48 for(int t=0; t<128; t++) {
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
58 fSearchWindow[i] = 16;
59 fTriggerCountOffset[i] = 3247;
65 //________________________________________________________________
66 void AliVZEROCalibData::Reset()
71 //________________________________________________________________
72 AliVZEROCalibData::AliVZEROCalibData(const char* name)
75 TString namst = "Calib_";
77 SetName(namst.Data());
78 SetTitle(namst.Data());
79 for(int t=0; t<64; t++) {
84 fDeadChannel[t]= kFALSE;
87 for(int t=0; t<128; t++) {
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
97 fSearchWindow[i] = 16;
98 fTriggerCountOffset[i] = 3247;
104 //________________________________________________________________
105 AliVZEROCalibData::AliVZEROCalibData(const AliVZEROCalibData& calibda) :
110 SetName(calibda.GetName());
111 SetTitle(calibda.GetName());
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); }
119 for(int t=0; t<64; t++) {
120 fMeanHV[t] = calibda.GetMeanHV(t);
121 fWidthHV[t] = calibda.GetWidthHV(t);
122 fTimeOffset[t] = calibda.GetTimeOffset(t);
123 fTimeGain[t] = calibda.GetTimeGain(t);
124 fDeadChannel[t] = calibda.IsChannelDead(t);
125 fDiscriThr[t] = calibda.GetDiscriThr(t);
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);
139 //________________________________________________________________
140 AliVZEROCalibData &AliVZEROCalibData::operator =(const AliVZEROCalibData& calibda)
142 // assignment operator
144 SetName(calibda.GetName());
145 SetTitle(calibda.GetName());
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); }
153 for(int t=0; t<64; t++) {
154 fMeanHV[t] = calibda.GetMeanHV(t);
155 fWidthHV[t] = calibda.GetWidthHV(t);
156 fTimeOffset[t] = calibda.GetTimeOffset(t);
157 fTimeGain[t] = calibda.GetTimeGain(t);
158 fDeadChannel[t] = calibda.IsChannelDead(t);
159 fDiscriThr[t] = calibda.GetDiscriThr(t);
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);
174 //________________________________________________________________
175 AliVZEROCalibData::~AliVZEROCalibData()
179 //_____________________________________________________________________________
180 void AliVZEROCalibData::FillDCSData(AliVZERODataDCS * data){
181 // Set all parameters from the data get by the shuttle
182 TMap * params = data->GetFEEParameters();
184 TObjString* aliasName;
186 while (( aliasName = (TObjString*) iter.Next() )) {
187 AliDCSValue* aValue = (AliDCSValue*) params->GetValue(aliasName);
190 val = aValue->GetUInt();
191 AliInfo(Form("%s : %d",aliasName->String().Data(), val));
192 SetParameter(aliasName->String(),val);
196 SetMeanHV(data->GetMeanHV());
197 SetWidthHV(data->GetWidthHV());
198 SetDeadMap(data->GetDeadMap());
201 //_____________________________________________________________________________
202 void AliVZEROCalibData::SetParameter(TString name, Int_t val){
203 // Set given parameter
208 TSeqCollection* nameSplit = name.Tokenize("/");
209 TObjString * boardName = (TObjString *)nameSplit->At(2);
210 sscanf(boardName->String().Data(),"CIU%d",&iBoard);
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);
217 if(name.Contains("TimeResolution")) SetTimeResolution((UShort_t) val,iBoard);
218 else if(name.Contains("WidthResolution")) SetWidthResolution((UShort_t) val,iBoard);
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);
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));
225 else AliError(Form("No Setter found for FEE parameter : %s",name.Data()));
228 //________________________________________________________________
229 void AliVZEROCalibData::SetPedestal(const Float_t* Pedestal)
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;
235 //________________________________________________________________
236 void AliVZEROCalibData::SetSigma(const Float_t* Sigma)
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;
242 //________________________________________________________________
243 void AliVZEROCalibData::SetADCmean(const Float_t* ADCmean)
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;
249 //________________________________________________________________
250 void AliVZEROCalibData::SetADCsigma(const Float_t* ADCsigma)
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;
256 //________________________________________________________________
257 void AliVZEROCalibData::SetMeanHV(const Float_t* MeanHV)
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;
263 //________________________________________________________________
264 void AliVZEROCalibData::SetWidthHV(const Float_t* WidthHV)
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;
270 //________________________________________________________________
271 void AliVZEROCalibData::SetDeadMap(const Bool_t* deadMap)
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;
277 //________________________________________________________________
278 void AliVZEROCalibData::SetTimeOffset(Float_t val, Int_t board, Int_t channel)
280 Int_t ch = AliVZEROCalibData::GetOfflineChannelNumber(board,channel);
283 AliInfo(Form("Time offset for channel %d set to %f",ch,fTimeOffset[ch]));
286 AliError("Board/Channel numbers are not valid");
289 //________________________________________________________________
290 void AliVZEROCalibData::SetTimeOffset(const Float_t* TimeOffset)
292 if(TimeOffset) for(int t=0; t<64; t++) fTimeOffset[t] = TimeOffset[t];
293 else for(int t=0; t<64; t++) fTimeOffset[t] = 5.0;
296 //________________________________________________________________
297 void AliVZEROCalibData::SetTimeGain(const Float_t* TimeGain)
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;
303 //_____________________________________________________________________________
304 Float_t AliVZEROCalibData::GetMIPperADC(Int_t channel) const {
306 // Computes the MIP conversion factor - MIP per ADC channel -
307 // Argument passed is the PM number (aliroot numbering)
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,
313 7.232810, 7.252655, 7.230309, 7.140891, 7.273518, 7.242969, 7.252859, 7.252655,
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 };
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,
322 0.137971, 0.142080, 0.142793, 0.136054, 0.142778, 0.146045, 0.139133, 0.142080,
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 };
328 // High Voltage retrieval from Calibration Data Base:
329 Float_t hv = fMeanHV[channel];
332 mip = 0.6/TMath::Exp((TMath::Log(hv) - p0[channel] )/p1[channel]);
337 //________________________________________________________________
338 Float_t AliVZEROCalibData::GetGain(Int_t channel) const
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};
359 // High Voltage retrieval from Calibration Data Base:
360 Float_t hv = fMeanHV[channel];
363 gain = TMath::Exp(a[channel]+b[channel]*TMath::Log(hv));
367 //________________________________________________________________
368 void 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);
371 else AliError("Time Resolution not defined.");
374 //________________________________________________________________
375 void AliVZEROCalibData::SetTimeResolution(UShort_t resol, Int_t board)
377 // Set Time Resolution of the TDC
378 if((board>=0) && (board<kNCIUBoards)) {
381 fTimeResolution[board] = 25./256.;
384 fTimeResolution[board] = 25./128.;
387 fTimeResolution[board] = 25./64.;
390 fTimeResolution[board] = 25./32.;
393 fTimeResolution[board] = 25./16.;
396 fTimeResolution[board] = 25./8.;
399 fTimeResolution[board] = 6.25;
402 fTimeResolution[board] = 12.5;
405 AliInfo(Form("Time Resolution of board %d set to %f",board,fTimeResolution[board]));
406 } else AliError(Form("Board %d is not valid",board));
408 //________________________________________________________________
409 void 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);
412 else AliError("Width Resolution not defined.");
415 //________________________________________________________________
416 void AliVZEROCalibData::SetWidthResolution(UShort_t resol, Int_t board)
418 // Set Time Width Resolution of the TDC
419 if((board>=0) && (board<kNCIUBoards)){
422 fWidthResolution[board] = 25./256.;
425 fWidthResolution[board] = 25./128.;
428 fWidthResolution[board] = 25./64.;
431 fWidthResolution[board] = 25./32.;
434 fWidthResolution[board] = 25./16.;
437 fWidthResolution[board] = 25./8.;
440 fWidthResolution[board] = 6.25;
443 fWidthResolution[board] = 12.5;
446 fWidthResolution[board] = 25.;
449 fWidthResolution[board] = 50.;
452 fWidthResolution[board] = 100.;
455 fWidthResolution[board] = 200.;
458 fWidthResolution[board] = 400.;
461 fWidthResolution[board] = 800.;
465 AliInfo(Form("Width Resolution of board %d set to %f",board,fWidthResolution[board]));
466 }else AliError(Form("Board %d is not valid",board));
469 //________________________________________________________________
470 void AliVZEROCalibData::SetMatchWindow(UInt_t *windows)
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.");
478 //________________________________________________________________
479 void AliVZEROCalibData::SetMatchWindow(UInt_t window, Int_t board)
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]));
488 AliError(Form("Board %d is not valid",board));
491 //________________________________________________________________
492 void AliVZEROCalibData::SetSearchWindow(UInt_t *windows)
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.");
500 //________________________________________________________________
501 void AliVZEROCalibData::SetSearchWindow(UInt_t window, Int_t board)
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]));
510 AliError(Form("Board %d is not valid",board));
513 //________________________________________________________________
514 void AliVZEROCalibData::SetTriggerCountOffset(UInt_t *offsets)
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.");
522 //________________________________________________________________
523 void AliVZEROCalibData::SetTriggerCountOffset(UInt_t offset, Int_t board)
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]));
532 AliError(Form("Board %d is not valid",board));
535 //________________________________________________________________
536 void AliVZEROCalibData::SetRollOver(UInt_t *offsets)
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.");
544 //________________________________________________________________
545 void AliVZEROCalibData::SetRollOver(UInt_t offset, Int_t board)
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]));
554 AliError(Form("Board %d is not valid",board));
557 //________________________________________________________________
558 void AliVZEROCalibData::SetDiscriThr(Float_t thr, Int_t board, Int_t channel)
560 // Set the TDC discriminator
561 // threshold values expressed in units of ADC
562 Int_t ch = AliVZEROCalibData::GetOfflineChannelNumber(board,channel);
566 AliInfo(Form("Discriminator threshold for channel %d set to %f",ch,fDiscriThr[ch]));
569 AliWarning(Form("Ignore wrong threshold value (%f) for channel %d !",thr,ch));
573 AliError("Board/Channel numbers are not valid");
576 //________________________________________________________________
577 void AliVZEROCalibData::SetDiscriThr(const Float_t* thresholds)
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;
585 Int_t AliVZEROCalibData::GetOfflineChannelNumber(Int_t board, Int_t channel)
587 // Get the offline channel number from
588 // the FEE board and channel indexes
590 if (board < 0 || board >= 8) {
591 AliErrorClass(Form("Wrong FEE board number: %d",board));
594 if (channel < 0 || channel >= 8) {
595 AliErrorClass(Form("Wrong FEE channel number: %d",channel));
599 Int_t offCh = (board < 4) ? (8 * board + 32) : (8 * board -32);
600 offCh += (7 - channel);
605 Int_t AliVZEROCalibData::GetBoardNumber(Int_t channel)
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);
612 AliErrorClass(Form("Wrong channel index: %d",channel));
616 Int_t AliVZEROCalibData::GetFEEChannelNumber(Int_t channel)
618 // Get FEE channel number
619 // from offline channel index
620 if (channel >= 0 && channel < 64) return (7 - (channel % 8));
622 AliErrorClass(Form("Wrong channel index: %d",channel));