Improved QAchecker and plots for DQM
[u/mrichter/AliRoot.git] / TOF / AliTOFPreprocessor.cxx
CommitLineData
c9fe8530 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
9edefa04 16/* $Id$ */
9d883ed9 17
3aaf7a5f 18
a174d599 19//#include <Riostream.h>
20//#include <stdio.h>
21//#include <stdlib.h>
c9fe8530 22
9edefa04 23#include <TFile.h>
9edefa04 24#include <TH2S.h>
ea932f75 25#include <TH1F.h>
26#include <TCanvas.h>
9edefa04 27#include <TMath.h>
28#include <TObjArray.h>
29#include <TObjString.h>
30#include <TTimeStamp.h>
c9fe8530 31
32#include "AliCDBMetaData.h"
7fffa85b 33#include "AliCDBEntry.h"
c9fe8530 34#include "AliLog.h"
17149e6b 35#include "AliTOFChannelOnlineArray.h"
36#include "AliTOFChannelOnlineStatusArray.h"
9edefa04 37#include "AliTOFDataDCS.h"
b7a60cff 38#include "AliTOFDCSmaps.h"
ea932f75 39#include "AliTOFLvHvDataPoints.h"
10056aa6 40#include "AliTOFGeometry.h"
9edefa04 41#include "AliTOFPreprocessor.h"
db83b789 42#include "AliTOFFEEReader.h"
3dda26a0 43#include "AliTOFRawStream.h"
44#include "AliTOFCableLengthMap.h"
b06d5296 45#include "AliTOFcalibHisto.h"
69355034 46#include "AliTOFFEEDump.h"
104ba366 47#include "TChain.h"
48#include "AliTOFDeltaBCOffset.h"
49#include "AliTOFCTPLatency.h"
f04b3a69 50#include "AliTOFRunParams.h"
104ba366 51#include "AliTOFT0FillOnlineCalib.h"
52#include "AliTOFHitField.h"
53#include "AliTOFChannelOffline.h"
54#include "TF1.h"
55#include "TGeoManager.h"
56#include "AliGeomManager.h"
5b4ed716 57#include "AliTOFReadoutInfo.h"
c9fe8530 58
c9fe8530 59// TOF preprocessor class.
60// It takes data from DCS and passes them to the class AliTOFDataDCS, which
61// processes them. The result is then written to the CDB.
17149e6b 62// Analogously, it takes data form DAQ (both at Run level and inclusive -
c9fe8530 63// of all the runs - level, processes them, and stores both Reference Data
64// and Online Calibration files in the CDB.
17149e6b 65// Processing of Pulser/Noise Run data and of TOF FEE DCS map included also.
7fffa85b 66
67// return codes:
68// return=0 : all ok
69// return=1 : no DCS input data Map
70// return=2 : no DCS input data processing
71// return=3 : no DCS processed data was stored in Ref Data
72// return=4 : no DAQ input for Ref Data
73// return=5 : failed to store DAQ Ref Data
74// return=6 : failed to retrieve DAQ data for calibration
75// return=7 : problems in processing histos in the input DAQ file
76// return=8 : failed to store Online Delays
77// return=9 : failed to store Reference Data for Pulser
78// return=10: failed to retrieve Pulser data
79// return=11: failed to store Pulser map in OCDB
80// return=12: failed to store Reference Data for Noise
81// return=13: failed to retrieve Noise data
82// return=14: failed to store Noise map in OCDB
db83b789 83// return=15: failed to retrieve FEE data from FXS
84// return=16: failed to retrieve FEE data from OCDB
85// return=17: failed to store FEE data in OCDB
86// return=18: failed to store FEE reference data in OCDB
17149e6b 87// return=20: failed in retrieving status variable
1dd76a9f 88// return=100 : no DCS input data Map (HV and LV status)
89// return=200 : no DCS input data processing (HV and LV status)
90// return=300 : no DCS processed data was stored in Ref Data (HV and LV status)
c9fe8530 91
92ClassImp(AliTOFPreprocessor)
93
7fffa85b 94const Int_t AliTOFPreprocessor::fgkBinRangeAve = 13; // number of bins where to calculate the mean
95const Double_t AliTOFPreprocessor::fgkIntegralThr = 100; // min number of entries to perform computation of delay per channel
96const Double_t AliTOFPreprocessor::fgkThrPar = 0.013; // parameter used to trigger the calculation of the delay
c9fe8530 97
98//_____________________________________________________________________________
99
708db10b 100AliTOFPreprocessor::AliTOFPreprocessor(AliShuttleInterface* shuttle) :
101 AliPreprocessor("TOF", shuttle),
c9fe8530 102 fData(0),
ea932f75 103 fHVLVmaps(0),
c9fe8530 104 fCal(0),
10056aa6 105 fNChannels(0),
7fffa85b 106 fStoreRefData(kTRUE),
17149e6b 107 fFDRFlag(kFALSE),
013ac2dd 108 fStatus(0),
02ede0c4 109 fMatchingWindow(0),
ea932f75 110 fLatencyWindow(0),
111 fIsStatusMapChanged(0)
c9fe8530 112{
113 // constructor
370aeff7 114 AddRunType("PHYSICS");
115 AddRunType("PULSER");
116 AddRunType("NOISE");
10056aa6 117
c9fe8530 118}
119
120//_____________________________________________________________________________
121
122AliTOFPreprocessor::~AliTOFPreprocessor()
123{
124 // destructor
125}
126
127//______________________________________________________________________________
128void AliTOFPreprocessor::Initialize(Int_t run, UInt_t startTime,
129 UInt_t endTime)
130{
131 // Creates AliTOFDataDCS object
132
133 AliPreprocessor::Initialize(run, startTime, endTime);
134
ff326f84 135 AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", run,
c9fe8530 136 TTimeStamp(startTime).AsString(),
ff326f84 137 TTimeStamp(endTime).AsString(), ((TTimeStamp)GetStartTimeDCSQuery()).AsString(), ((TTimeStamp)GetEndTimeDCSQuery()).AsString()));
c9fe8530 138
ff326f84 139 fData = new AliTOFDataDCS(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
ea932f75 140 fHVLVmaps = new AliTOFLvHvDataPoints(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
10056aa6 141 fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
c9fe8530 142}
7fffa85b 143//_____________________________________________________________________________
144Bool_t AliTOFPreprocessor::ProcessDCS(){
145
146 // check whether DCS should be processed or not...
c9fe8530 147
7fffa85b 148 TString runType = GetRunType();
149 Log(Form("RunType %s",runType.Data()));
150
55454922 151 if (runType != "PHYSICS"){
7fffa85b 152 return kFALSE;
153 }
154
155 return kTRUE;
156}
c9fe8530 157//_____________________________________________________________________________
158
104ba366 159UInt_t AliTOFPreprocessor::ProcessDCSDataPoints(TMap *dcsAliasMap)
c9fe8530 160{
161 // Fills data into a AliTOFDataDCS object
162
7fffa85b 163
164 Log("Processing DCS DP");
708db10b 165 TH1::AddDirectory(0);
5936ab02 166
7885c291 167 Bool_t resultDCSMap=kFALSE;
168 Bool_t resultDCSStore=kFALSE;
c9fe8530 169
170 // processing DCS
171
172 if (!dcsAliasMap){
5936ab02 173 Log("No DCS map found: TOF exiting from Shuttle");
cd695de9 174 if (fData) {
e88f3330 175 delete fData;
176 fData = 0;
177 }
5936ab02 178 return 1;// return error Code for DCS input data not found
c9fe8530 179 }
180 else {
4856f488 181
cd695de9 182 if (!fData) {
183 Log("No DCSdata map initialized: TOF exiting from Shuttle");
184 return 0;// return error Code for DCS data map not initialized
185 }
186
ce4b5362 187 fData->SetFDRFlag(fFDRFlag);
188
189 // The processing of the DCS input data is forwarded to AliTOFDataDCS
7885c291 190 resultDCSMap=fData->ProcessData(*dcsAliasMap);
191 if(!resultDCSMap){
192 Log("Some problems occurred while processing DCS data, TOF exiting from Shuttle");
cd695de9 193 if (fData) {
e88f3330 194 delete fData;
195 fData = 0;
196 }
5936ab02 197 return 2;// return error Code for processed DCS data not stored
c9fe8530 198 }
7885c291 199 else{
200 AliCDBMetaData metaDataDCS;
201 metaDataDCS.SetBeamPeriod(0);
202 metaDataDCS.SetResponsible("Chiara Zampolli");
203 metaDataDCS.SetComment("This preprocessor fills an AliTOFDataDCS object.");
204 AliInfo("Storing DCS Data");
b0d8f3fc 205 resultDCSStore = StoreReferenceData("Calib","DCSData",fData, &metaDataDCS);
7885c291 206 if (!resultDCSStore){
b0d8f3fc 207 Log("Some problems occurred while storing DCS data results in Reference Data, TOF exiting from Shuttle");
e88f3330 208 if (fData){
209 delete fData;
210 fData = 0;
211 }
7885c291 212 return 3;// return error Code for processed DCS data not stored
b0d8f3fc 213 // in reference data
7885c291 214
215 }
216 }
c9fe8530 217 }
e88f3330 218 if (fData){
219 delete fData;
220 fData = 0;
221 }
222
ee3e792b 223 return 0;
224}
225//_____________________________________________________________________________
226
104ba366 227UInt_t AliTOFPreprocessor::ProcessHVandLVdps(TMap *dcsAliasMap)
ea932f75 228{
229 //
230 //Fills data into a AliTOFLvHvDataPoints object
231 // Merges fStatus object with LV and HV status at SOR
232 // Updates fStatus object with LV and HV status
233 // at EOR in case of correct end of run
234 // at last but two value in case of end-of-run caused by TOF detector.
235 //
236
237 Log("Processing HV and LV DCS DPs");
238 TH1::AddDirectory(0);
239
240 Bool_t resultDCSMap=kFALSE;
241
1dd76a9f 242 // processing DCS HV and LV data points
ea932f75 243
ea932f75 244 if (!dcsAliasMap){
245 Log("No DCS map found: TOF exiting from Shuttle");
246 if (fHVLVmaps){
247 delete fHVLVmaps;
248 fHVLVmaps = 0;
249 }
1dd76a9f 250 return 100;// return error Code for DCS input data not found
ea932f75 251 }
252 else {
253
cd695de9 254 if (!fHVLVmaps) {
255 Log("No HVLVdata map initialized: TOF exiting from Shuttle");
256 return 200;// return error Code for HVLV data map not initialized
257 }
258
ce4b5362 259 fHVLVmaps->SetFDRFlag(fFDRFlag);
260
ea932f75 261 // The processing of the DCS input data is forwarded to AliTOFDataDCS
cd695de9 262
ea932f75 263 resultDCSMap = fHVLVmaps->ProcessData(*dcsAliasMap);
264 if (!resultDCSMap) {
265 Log("Some problems occurred while processing DCS data, TOF exiting from Shuttle");
266 if (fHVLVmaps) {
267 delete fHVLVmaps;
268 fHVLVmaps = 0;
269 }
1dd76a9f 270 return 200;// return error Code for processed DCS data not stored
ea932f75 271 }
272 else {
273
274 // check with plots. Start...
275 /*
276 TH1F *hROsor = new TH1F("hROsor","RO status map at SOR",91*96*18,-0.5,91*96*18-0.5);
277 for (Int_t ii=1; ii<=91*96*18; ii++) hROsor->SetBinContent(ii,-1);
278 for (Int_t ii=0; ii<91*96*18; ii++) {
279 if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWBad)
280 hROsor->SetBinContent(ii+1,0);
281 else if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWOk)
282 hROsor->SetBinContent(ii+1,1);
283 }
284
285 TH1F *hROandHVandLVsor = new TH1F("hROandHVandLVsor","RO.and.HV.andLV status map at SOR",91*96*18,-0.5,91*96*18-0.5);
286 for (Int_t ii=1; ii<=91*96*18; ii++) hROandHVandLVsor->SetBinContent(ii,-1);
287 TH1F *hROandHVandLVeor = new TH1F("hROandHVandLVeor","RO.and.HV.andLV status map at EOR",91*96*18,-0.5,91*96*18-0.5);
288 for (Int_t ii=1; ii<=91*96*18; ii++) hROandHVandLVeor->SetBinContent(ii,-1);
289 */
290
291 AliTOFDCSmaps * lvANDhvMap = (AliTOFDCSmaps*)fHVLVmaps->GetHVandLVmapAtSOR(); // Get LV.and.HV status map at SOR
292 for (Int_t index=0; index<fNChannels; index++) {
293 if ( ( lvANDhvMap->GetCellValue(index)==0 &&
294 fStatus->GetHWStatus(index) != AliTOFChannelOnlineStatusArray::kTOFHWBad ) ||
295 ( lvANDhvMap->GetCellValue(index)==1 &&
296 fStatus->GetHWStatus(index) != AliTOFChannelOnlineStatusArray::kTOFHWOk ) ) {
297 fStatus->SetHWStatus(index, AliTOFChannelOnlineStatusArray::kTOFHWBad);
298 fIsStatusMapChanged=kTRUE;
299 }
300 }
104ba366 301
ea932f75 302 // check with plots. Start...
303 /*
304 for (Int_t ii=0; ii<91*96*18; ii++) {
305 if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWBad)
306 hROandHVandLVsor->SetBinContent(ii+1,0);
307 else if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWOk)
308 hROandHVandLVsor->SetBinContent(ii+1,1);
309 }
310 */
311
312 lvANDhvMap = (AliTOFDCSmaps*)fHVLVmaps->GetHVandLVmapAtEOR(); // Get LV.and.HV status map at EOR
313 for (Int_t index=0; index<fNChannels; index++) {
314 if ( ( lvANDhvMap->GetCellValue(index)==0 &&
315 fStatus->GetHWStatus(index)!=AliTOFChannelOnlineStatusArray::kTOFHWBad ) ||
316 ( lvANDhvMap->GetCellValue(index)==1 &&
317 fStatus->GetHWStatus(index) != AliTOFChannelOnlineStatusArray::kTOFHWOk ) ) {
318 fStatus->SetHWStatus(index, AliTOFChannelOnlineStatusArray::kTOFHWBad);
319 fIsStatusMapChanged=kTRUE;
320 }
321 }
322
323 // check with plots. Start...
324 /*
325 for (Int_t ii=0; ii<91*96*18; ii++) {
326 if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWBad)
327 hROandHVandLVeor->SetBinContent(ii+1,0);
328 else if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWOk)
329 hROandHVandLVeor->SetBinContent(ii+1,1);
330 }
331
332 TCanvas *canvas = new TCanvas("canvas","",10,10,1000,1000);
333 canvas->SetFillColor(0);
334 canvas->Divide(2,2);
335 canvas->cd(1);
336 hROsor->SetLineWidth(2);
337 hROsor->Draw();
338 canvas->cd(2);
339 hROandHVandLVsor->SetLineWidth(2);
340 hROandHVandLVsor->Draw();
341 canvas->cd(3);
342 hROandHVandLVeor->SetLineWidth(2);
343 hROandHVandLVeor->Draw();
344 canvas->cd();
345 */
346
347 }
cd695de9 348
ea932f75 349 }
350
351
352 /* check whether we don't need to update OCDB.
353 * in this case we can return without errors. */
354
355 if (!fIsStatusMapChanged) {
5e52c907 356 AliInfo("TOF HW status config has not changed. Do not overwrite stored file.");
ea932f75 357 return 0; // return ok
358 }
359
360 TString runType = GetRunType();
361 if (runType != "PHYSICS") {
362 AliInfo(Form("Run Type = %s, waiting to store status map",GetRunType()));
363 return 0; // return ok
364 }
365
366 // update the OCDB with the current FEE.and.HV.and.LV
367 // since even a little difference has been detected.
368
369 AliCDBMetaData metaData;
370 metaData.SetBeamPeriod(0);
371 metaData.SetResponsible("Roberto Preghenella");
5e52c907 372 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object from FEE.and.HV.and.LV data.");
373 AliInfo("Storing Status data from current run. Collected RO.and.HV.and.LV infos @ EOR");
1dd76a9f 374 // store TOF channel status
ea932f75 375 if (!Store("Calib", "Status", fStatus, &metaData, 0, kTRUE)) {
376 // failed
377 Log("problems while storing RO.and.HV.and.LV Status data object");
378 if (fStatus){
379 delete fStatus;
380 fStatus = 0;
381 }
382 if (fHVLVmaps) {
383 delete fHVLVmaps;
384 fHVLVmaps = 0;
385 }
1dd76a9f 386 return 17; // return error code for problems while TOF channel status
ea932f75 387 }
388
389 // everything fine. return
390
391 if (fStatus){
392 delete fStatus;
393 fStatus = 0;
394 }
395
396 if (fHVLVmaps) {
397 delete fHVLVmaps;
398 fHVLVmaps = 0;
399 }
400
401 return 0;
402}
104ba366 403
ea932f75 404//_____________________________________________________________________________
405
ee3e792b 406UInt_t AliTOFPreprocessor::ProcessOnlineDelays()
407{
7fffa85b 408 // Processing data from DAQ for online calibration
409
965fa008 410 Bool_t updateOCDB = kFALSE;
7fffa85b 411 Log("Processing DAQ delays");
ee3e792b 412
17149e6b 413 // reading configuration map
414 TString compDelays = "kFALSE";
415 Int_t deltaStartingRun = fRun;
416 Int_t startingRun = fRun-deltaStartingRun;
417 Int_t binRangeAve = fgkBinRangeAve;
418 Double_t integralThr = fgkIntegralThr;
419 Double_t thrPar = fgkThrPar;
420
421 AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Config");
422 if (!cdbEntry) {
423 Log(Form("No Configuration entry found in CDB, using default values: ComputingDelays = %s, StartingRun = %i",compDelays.Data(), startingRun));
424 }
425 else {
426 TMap *configMap = (TMap*)cdbEntry->GetObject();
427 if (!configMap){
428 Log(Form("No map found in Config entry in CDB, using default values: ComputingDelays = %s, StartingRun = %i",compDelays.Data(), startingRun));
429 }
430 else{
431 TObjString *strDelays = (TObjString*)configMap->GetValue("ComputingDelays");
432 if (strDelays) {
433 compDelays = (TString) strDelays->GetString();
434 }
435 else {
436 Log(Form("No ComputingDelays value found in Map from Config entry in CDB, using default value: ComputingDelays = %s",compDelays.Data()));
437 }
438 TObjString *strRun = (TObjString*)configMap->GetValue("StartingRun");
439 if (strRun) {
440 TString tmpstr = strRun->GetString();
441 startingRun = tmpstr.Atoi();
442 deltaStartingRun = fRun - startingRun;
443 }
444 else {
445 Log(Form("No StartingRun value found in Map from Config entry in CDB, using default value: StartingRun = %i",startingRun));
446 }
447 TObjString *strBinRangeAve = (TObjString*)configMap->GetValue("BinRangeAve");
448 if (strBinRangeAve) {
449 TString tmpstr = strBinRangeAve->GetString();
450 binRangeAve = tmpstr.Atoi();
451 }
452 else {
453 Log(Form("No BinRangeAve value found in Map from Config entry in CDB, using default value: BinRangeAve = %i",binRangeAve));
454 }
455 TObjString *strIntegralThr = (TObjString*)configMap->GetValue("IntegralThr");
456 if (strIntegralThr) {
457 TString tmpstr = strIntegralThr->GetString();
458 integralThr = tmpstr.Atof();
459 }
460 else {
4682c56e 461 Log(Form("No IntegralThr value found in Map from Config entry in CDB, using default value: IntegralThr = %f",integralThr));
17149e6b 462 }
463 TObjString *strThrPar = (TObjString*)configMap->GetValue("ThrPar");
464 if (strThrPar) {
465 TString tmpstr = strThrPar->GetString();
466 thrPar = tmpstr.Atof();
467 }
468 else {
4682c56e 469 Log(Form("No ThrPar value found in Map from Config entry in CDB, using default value: ThrPar = %f",thrPar));
17149e6b 470 }
471 }
472 }
473 if (compDelays == "kTRUE") fFDRFlag = kFALSE;
474 else fFDRFlag = kTRUE;
475
e88f3330 476 delete cdbEntry;
477 cdbEntry = 0x0;
478
17149e6b 479 Log(Form("ComputingDelays = %s, StartingRun = %i",compDelays.Data(),startingRun));
480
965fa008 481 /* init array with current calibration, if any */
482 fCal = new AliTOFChannelOnlineArray(fNChannels);
483 AliTOFChannelOnlineArray *curCal = NULL;
484
485 AliCDBEntry *cdbEntry2 = GetFromOCDB("Calib","ParOnlineDelay");
486 if (!cdbEntry2 || !cdbEntry2->GetObject()) {
487 /* no CDB entry found. set update flag */
488 Log(" ************ WARNING ************");
489 Log("No CDB ParOnlineDelay entry found, creating a new one!");
490 Log(" *********************************");
491 updateOCDB = kTRUE;
492 }
493 else {
494 Log("Found previous ParOnlineDelay entry. Using it to init calibration");
495 curCal = (AliTOFChannelOnlineArray *)cdbEntry2->GetObject();
496 for (Int_t i = 0; i < fNChannels; i++)
497 fCal->SetDelay(i, curCal->GetDelay(i));
498 }
499
17149e6b 500
ee3e792b 501 TH1::AddDirectory(0);
502
503 Bool_t resultDAQRef=kFALSE;
7fffa85b 504 Bool_t resultTOFPP=kFALSE;
e88f3330 505 TH2S *h2 = 0x0;
c9fe8530 506 // processing DAQ
7885c291 507
c9fe8530 508 TFile * daqFile=0x0;
7885c291 509
5936ab02 510 if(fStoreRefData){
511 //retrieving data at Run level
17149e6b 512 TList* list = GetFileSources(kDAQ, "RUNLevel");
513 if (list !=0x0 && list->GetEntries()!=0)
514 {
515 AliInfo("The following sources produced files with the id RUNLevel");
516 list->Print();
517 for (Int_t jj=0;jj<list->GetEntries();jj++){
518 TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
f18b69a1 519 if (!str) {
520 AliError("dynamic_cast returned NULL");
521 return 4;
522 }
17149e6b 523 AliInfo(Form("found source %s", str->String().Data()));
524 // file to be stored run per run
525 TString fileNameRun = GetFile(kDAQ, "RUNLevel", str->GetName());
526 if (fileNameRun.Length()>0){
527 AliInfo(Form("Got the file %s, now we can store the Reference Data for the current Run.", fileNameRun.Data()));
528 daqFile = new TFile(fileNameRun.Data(),"READ");
e88f3330 529 h2 = (TH2S*) daqFile->Get("htof");
17149e6b 530 AliCDBMetaData metaDataHisto;
531 metaDataHisto.SetBeamPeriod(0);
532 metaDataHisto.SetResponsible("Chiara Zampolli");
533 metaDataHisto.SetComment("This preprocessor stores the array of histos object as Reference Data.");
534 AliInfo("Storing Reference Data");
e88f3330 535 resultDAQRef = StoreReferenceData("Calib","DAQData",h2, &metaDataHisto);
17149e6b 536 if (!resultDAQRef){
537 Log("some problems occurred::No Reference Data stored, TOF exiting from Shuttle");
e88f3330 538 delete h2;
539 delete list;
540 delete fCal;
541 fCal=0x0;
17149e6b 542 return 5;//return error code for failure in storing Ref Data
543 }
544 daqFile->Close();
545 delete daqFile;
546 }
547
548 else{
549 Log("The input data file from DAQ (run-level) was not found, TOF exiting from Shuttle ");
e88f3330 550 delete list;
551 delete fCal;
552 fCal=0x0;
17149e6b 553 return 4;//return error code for failure in retrieving Ref Data
554 }
555 }
556 delete list;
557 }
5936ab02 558 else{
17149e6b 559 Log("The input data file list from DAQ (run-level) was not found, TOF exiting from Shuttle ");
e88f3330 560 delete fCal;
561 fCal=0x0;
17149e6b 562 return 4;//return error code for failure in retrieving Ref Data
563 }
9bc469d1 564 }
565
9bc469d1 566
17149e6b 567 //Total files, with cumulative histos
5936ab02 568
9bc469d1 569 TList* listTot = GetFileSources(kDAQ, "DELAYS");
bf76be9c 570 if (listTot !=0x0 && listTot->GetEntries()!=0)
17149e6b 571 {
572 AliInfo("The following sources produced files with the id DELAYS");
573 listTot->Print();
574 for (Int_t jj=0;jj<listTot->GetEntries();jj++){
792c8d52 575 TObjString * str = dynamic_cast<TObjString*> (listTot->At(jj));
576 if (!str) {
577 AliError("dynamic_cast returned NULL");
578 return 4;
579 }
17149e6b 580 AliInfo(Form("found source %s", str->String().Data()));
581
582 // file with summed histos, to extract calib params
583 TString fileName = GetFile(kDAQ, "DELAYS", str->GetName());
584 if (fileName.Length()>0){
585 AliInfo(Form("Got the file %s, now we can extract some values.", fileName.Data()));
586
587 daqFile = new TFile(fileName.Data(),"READ");
e88f3330 588 if (h2) delete h2;
589 h2 = (TH2S*) daqFile->Get("htoftot");
590 if (!h2){
17149e6b 591 Log("some problems occurred:: No histo retrieved, TOF exiting from Shuttle");
e88f3330 592 delete listTot;
17149e6b 593 delete daqFile;
e88f3330 594 delete fCal;
595 fCal=0x0;
17149e6b 596 return 7; //return error code for histograms not existing/junky
597 }
598 else {
e88f3330 599 static const Int_t kSize=h2->GetNbinsX();
600 static const Int_t kNBins=h2->GetNbinsY();
601 static const Double_t kXBinmin=h2->GetYaxis()->GetBinLowEdge(1);
17149e6b 602 if (kSize != fNChannels){
603 Log(" number of bins along x different from number of pads, found only a subset of the histograms, TOF exiting from Shuttle");
e88f3330 604 delete listTot;
605 delete h2;
17149e6b 606 delete daqFile;
e88f3330 607 delete fCal;
608 fCal=0x0;
17149e6b 609 return 7; //return error code for histograms not existing/junky
610 }
611 Int_t nNotStatistics = 0; // number of channel with not enough statistics
3dda26a0 612
b06d5296 613 /* FDR flag set. do not compute delays, use nominal cable delays */
3dda26a0 614 if (fFDRFlag) {
615
616 Log(" Not computing delays according to flag set in Config entry in OCDB!");
b06d5296 617 FillWithCosmicCalibration(fCal);
965fa008 618
619 /* check whether the new calibration is different from the previous one */
620 if (curCal) { /* well, check also whether we have a previous calibration */
621 for (Int_t i = 0; i < fNChannels; i++) {
622 if (fCal->GetDelay(i) != curCal->GetDelay(i)) {
623 updateOCDB = kTRUE;
624 break;
625 }
626 }
627 }
628 else /* otherwise update OCDB */
629 updateOCDB = kTRUE;
630
3dda26a0 631 }
17149e6b 632
633 else { // computing delays if not in FDR runs
965fa008 634
635 updateOCDB = kTRUE; /* always update OCDB when computing delays */
636
17149e6b 637 for (Int_t ich=0;ich<kSize;ich++){
638 /* check whether channel has been read out during current run.
639 * if the status is bad it means it has not been read out.
640 * in this case skip channel in order to not affect the mean */
641 if (fStatus->GetHWStatus(ich) == AliTOFChannelOnlineStatusArray::kTOFHWBad){
642 AliDebug(2,Form(" Channel %i found bad according to FEEmap, (HW status = %i), skipping from delay computing",ich, (Int_t)fStatus->GetHWStatus(ich)));
643 continue;
644 }
645 AliDebug(2,Form(" Channel %i found ok according to FEEmap, starting delay computing",ich));
646 TH1S *h1 = new TH1S("h1","h1",kNBins,kXBinmin-0.5,kNBins*1.+kXBinmin-0.5);
647 for (Int_t ibin=0;ibin<kNBins;ibin++){
e88f3330 648 h1->SetBinContent(ibin+1,h2->GetBinContent(ich+1,ibin+1));
17149e6b 649 }
650 if(h1->Integral()<integralThr) {
651 nNotStatistics++;
652 Log(Form(" Not enough statistics for bin %i, skipping this channel",ich)); // printing message only if not in FDR runs
653 delete h1;
654 h1=0x0;
655 continue;
656 }
657 Bool_t found=kFALSE;
658 Float_t minContent=h1->Integral()*thrPar;
659 Int_t nbinsX = h1->GetNbinsX();
660 Int_t startBin=1;
661 for (Int_t j=1; j<=nbinsX; j++){
662 if ((
663 h1->GetBinContent(j) +
664 h1->GetBinContent(j+1)+
665 h1->GetBinContent(j+2)+
666 h1->GetBinContent(j+3))>minContent){
667 found=kTRUE;
668 startBin=j;
669 break;
670 }
671 }
672 if(!found) AliInfo(Form("WARNING!!! no start of fit found for histo # %i",ich));
673 // Now calculate the mean over the interval.
674 Double_t mean = 0;
675 Double_t sumw2 = 0;
676 Double_t nent = 0;
677 for(Int_t k=0;k<binRangeAve;k++){
678 mean=mean+h1->GetBinCenter(startBin+k)*h1->GetBinContent(startBin+k);
679 nent=nent+h1->GetBinContent(startBin+k);
680 sumw2=sumw2+(h1->GetBinCenter(startBin+k))*(h1->GetBinCenter(startBin+k))*(h1->GetBinContent(startBin+k));
681 }
682 mean= mean/nent; //<x>
683 sumw2=sumw2/nent; //<x^2>
684 Double_t rmsmean= 0;
685 rmsmean = TMath::Sqrt((sumw2-mean*mean)/nent);
686 if (ich<fNChannels) {
687 Float_t delay = mean*AliTOFGeometry::TdcBinWidth()*1.E-3; // delay in ns
688 fCal->SetDelay(ich,delay); // delay in ns
689 AliDebug(2,Form("Setting delay %f (ns) for channel %i",delay,ich));
690 }
691 delete h1;
692 h1=0x0;
693 }
694 }
695 if (nNotStatistics!=0) Log(Form("Too little statistics for %d channels!",nNotStatistics));
696 }
e88f3330 697 delete h2;
17149e6b 698 daqFile->Close();
699 delete daqFile;
700 }
701 else{
702 Log("The Cumulative data file from DAQ does not exist, TOF exiting from Shuttle");
e88f3330 703 delete listTot;
704 delete fCal;
705 fCal=0x0;
17149e6b 706 return 6;//return error code for problems in retrieving DAQ data
707 }
7fffa85b 708 }
17149e6b 709 delete listTot;
c9fe8530 710 }
c9fe8530 711 else{
9d883ed9 712 Log("Problem: no list for Cumulative data file from DAQ was found, TOF exiting from Shuttle");
e88f3330 713 delete fCal;
714 fCal=0x0;
7885c291 715 return 6; //return error code for problems in retrieving DAQ data
c9fe8530 716 }
717
965fa008 718 /* check whether we don't need to update OCDB.
719 * in this case we can return without errors and
720 * the current FEE is stored in the fStatus object. */
721 if (!updateOCDB) {
722 AliInfo("update OCDB flag not set. Do not overwrite stored file.");
723 return 0; /* return ok */
724 }
725
c9fe8530 726 daqFile=0;
7fffa85b 727 AliCDBMetaData metaData;
728 metaData.SetBeamPeriod(0);
729 metaData.SetResponsible("Chiara Zampolli");
17149e6b 730 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineArray object for online calibration - delays.");
7fffa85b 731 AliInfo("Storing Calibration Data");
17149e6b 732 resultTOFPP = Store("Calib","ParOnlineDelay",fCal, &metaData,deltaStartingRun,kTRUE);
7fffa85b 733 if(!resultTOFPP){
734 Log("Some problems occurred while storing online object resulting from DAQ data processing");
e88f3330 735 delete fCal;
736 fCal=0x0;
7fffa85b 737 return 8;//return error code for problems in storing DAQ data
738 }
9d883ed9 739
e88f3330 740 if (fCal){
741 delete fCal;
742 fCal = 0;
743 }
744
5936ab02 745 return 0;
c9fe8530 746}
104ba366 747
748//_____________________________________________________________________________
749
750UInt_t
751AliTOFPreprocessor::ProcessT0Fill()
752{
753 // Processing data from DAQ for T0-fill measurement
754
755 Log("Processing T0-fill");
756
757#if 0
758 /* instance and setup CDB manager */
759 AliCDBManager *cdb = AliCDBManager::Instance();
760 /* load geometry */
761 if (!gGeoManager) AliGeomManager::LoadGeometry();
762#endif
763
764 /* get params from OCDB */
765 AliCDBEntry *cdbe = NULL;
766
3fd7a5cd 767 /*
768 * check UseLHCClockPhase flag in RunParams.
769 * if set do nothing and return successfully
770 */
771 cdbe = GetFromOCDB("Calib", "RunParams");
772 if (!cdbe) {
773 Log("cannot get \"RunParams\" entry from OCDB");
774 return 21;
775 }
776 AliTOFRunParams *runparams = (AliTOFRunParams *)cdbe->GetObject();
777 if (runparams->GetUseLHCClockPhase()) {
778 Log("UseLHCClockPhase flag is set in RunParams: online T0-fill not computed");
779 return 0;
780 }
781
f04b3a69 782 /*
783 * at this stage status object is not on OCDB yet
784 * since it will be stored later. nevertheless we
785 * should have the array in memory since it has been
786 * already setup by ProcessFEF.
787 */
788
789 /* check status and latency window available */
790 if (!fStatus || !fLatencyWindow){
791 AliError("No valid fStatus or fLatencyWindow found, some errors must have occurred!!");
104ba366 792 return 21;
793 }
104ba366 794
795 /* get offline calibration from OCDB */
796 cdbe = GetFromOCDB("Calib", "ParOffline");
797 if (!cdbe) {
798 Log("cannot get \"ParOffline\" entry from OCDB");
799 return 21;
800 }
801 TObjArray *offlineArray = (TObjArray *)cdbe->GetObject();
802 AliTOFChannelOffline *channelOffline;
803 if (!offlineArray) {
804 Log("cannot get \"ParOffline\" object from CDB entry");
805 return 21;
806 }
807 Log("got \"ParOffline\" object");
808
809 /* get deltaBC offset from OCDB */
810 cdbe = GetFromOCDB("Calib", "DeltaBCOffset");
811 if (!cdbe) {
812 Log("cannot get \"DeltaBCOffset\" entry from OCDB");
813 return 21;
814 }
815 AliTOFDeltaBCOffset *deltaBCOffsetObject = (AliTOFDeltaBCOffset *)cdbe->GetObject();
816 if (!deltaBCOffsetObject) {
817 Log("cannot get \"DeltaBCOffset\" object from CDB entry");
818 return 21;
819 }
820 Int_t deltaBCOffset = deltaBCOffsetObject->GetDeltaBCOffset();
821 Log(Form("got \"DeltaBCOffset\" object: deltaBCOffset=%d (BC bins)", deltaBCOffset));
822
823 /* get CTP latency from OCDB */
824 cdbe = GetFromOCDB("Calib", "CTPLatency");
825 if (!cdbe) {
826 Log("cannot get \"CTPLatency\" entry from OCDB");
827 return 21;
828 }
829 AliTOFCTPLatency *ctpLatencyObject = (AliTOFCTPLatency *)cdbe->GetObject();
830 if (!ctpLatencyObject) {
831 Log("cannot get \"CTPLatency\" object from CDB entry");
832 return 21;
833 }
834 Float_t ctpLatency = ctpLatencyObject->GetCTPLatency();
835 Log(Form("got \"CTPLatency\" object: ctpLatency=%f (ps)", ctpLatency));
836
837 /* get file sources from FXS */
838 TList *fileList = GetFileSources(kDAQ, "HITS");
839 if (!fileList || fileList->GetEntries() == 0) {
840 Log("cannot get DAQ source file list or empty list");
841 return 21;
842 }
843 Log(Form("got DAQ source file list: %d files", fileList->GetEntries()));
844 fileList->Print();
845
846 /* create tree chain using file sources */
847 TChain chain("hitTree");
848 for (Int_t ifile = 0; ifile < fileList->GetEntries(); ifile++) {
849 TObjString *str = (TObjString *)fileList->At(ifile);
850 TString filename = GetFile(kDAQ, "HITS", str->GetName());
851 chain.Add(filename);
852 Log(Form("file added to input chain: source=%s, filename=%s", str->String().Data(), filename.Data()));
853 }
854 Int_t nhits = chain.GetEntries();
855 Log(Form("input chain ready: %d hits", nhits));
856
857 /* setup input chain */
858 AliTOFHitField *hit = new AliTOFHitField();
859 chain.SetBranchAddress("hit", &hit);
860
861 /* create calib histo and geometry */
862 AliTOFcalibHisto calibHisto;
863 calibHisto.LoadCalibHisto();
864 AliTOFGeometry tofGeo;
865
866 /* constants */
867 Float_t c = TMath::C() * 1.e2 / 1.e12; /* cm/ps */
868 Float_t c_1 = 1. / c;
869 /* variables */
870 Int_t index, timebin, totbin, deltaBC, l0l1latency, det[5];
871 Float_t timeps, totns, corrps, length, timeexp, timezero, pos[3], latencyWindow;
872
873 /* histos */
874 TH1F *hT0Fill = new TH1F("hT0Fill", "T0 fill;t - t_{exp}^{(c)} (ps);", 2000, -24400., 24400.);
875
876 /* loop over hits */
877 for (Int_t ihit = 0; ihit < nhits; ihit++) {
878
879 /* get entry */
880 chain.GetEntry(ihit);
881
882 /* get hit info */
883 index = hit->GetIndex();
884 timebin = hit->GetTimeBin();
885 totbin = hit->GetTOTBin();
886 deltaBC = hit->GetDeltaBC();
887 l0l1latency = hit->GetL0L1Latency();
f04b3a69 888 latencyWindow = fLatencyWindow[index] * 1.e3;
104ba366 889
890 /* convert time in ps and tot in ns */
891 timeps = timebin * AliTOFGeometry::TdcBinWidth();
892 totns = totbin * AliTOFGeometry::ToTBinWidth() * 1.e-3;
893 /* get calibration correction in ps */
5b4ed716 894
895
104ba366 896 channelOffline = (AliTOFChannelOffline *)offlineArray->At(index);
897 if (totns < AliTOFGeometry::SlewTOTMin()) totns = AliTOFGeometry::SlewTOTMin();
898 if (totns > AliTOFGeometry::SlewTOTMax()) totns = AliTOFGeometry::SlewTOTMax();
899 corrps = 0.;
900 for (Int_t ipar = 0; ipar < 6; ipar++) corrps += channelOffline->GetSlewPar(ipar) * TMath::Power(totns, ipar);
901 corrps *= 1.e3;
902 /* perform time correction */
f04b3a69 903 // timeps = timeps + (deltaBC - deltaBCOffset) * AliTOFGeometry::BunchCrossingBinWidth() + l0l1latency * AliTOFGeometry::BunchCrossingBinWidth() + ctpLatency - latencyWindow - corrps; /* deltaBC correction removed for the time being */
904 timeps = timeps + l0l1latency * AliTOFGeometry::BunchCrossingBinWidth() + ctpLatency - latencyWindow - corrps;
104ba366 905 /* compute length and expected time */
906 tofGeo.GetVolumeIndices(index, det);
907 tofGeo.GetPosPar(det, pos);
908 length = 0.;
909 for (Int_t i = 0; i < 3; i++) length += pos[i] * pos[i];
910 length = TMath::Sqrt(length);
911 timeexp = length * c_1;
912 /* compute time zero */
913 timezero = timeps - timeexp;
914
915 /* fill histos */
916 hT0Fill->Fill(timezero);
917 }
918
919 /* rebin until maximum bin has required minimum entries */
920 Int_t maxBin = hT0Fill->GetMaximumBin();
17f2cd01 921 Float_t maxBinContent = hT0Fill->GetBinContent(maxBin);
104ba366 922 Float_t binWidth = hT0Fill->GetBinWidth(maxBin);
923 while (maxBinContent < 400 && binWidth < 90.) {
924 hT0Fill->Rebin(2);
925 maxBin = hT0Fill->GetMaximumBin();
926 maxBinContent = hT0Fill->GetBinContent(maxBin);
927 binWidth = hT0Fill->GetBinWidth(maxBin);
928 }
929 Float_t maxBinCenter = hT0Fill->GetBinCenter(maxBin);
930
5b4ed716 931 /* rough fit of the edge */
932 TF1 *gaus = (TF1 *)gROOT->GetFunction("gaus");
933 gaus->SetParameter(1, maxBinCenter);
f04b3a69 934 Float_t fitMin = maxBinCenter - 1000.; /* fit from 1 ns before max */
5b4ed716 935 Float_t fitMax = maxBinCenter + 1000.; /* fit until 1 ns above max */
936 hT0Fill->Fit("gaus", "q0", "", fitMin, fitMax);
937 /* better fit of the edge */
938 Float_t mean, sigma;
939 for (Int_t istep = 0; istep < 10; istep++) {
940 mean = gaus->GetParameter(1);
941 sigma = gaus->GetParameter(2);
942 fitMin = mean - 3. * sigma;
943 fitMax = mean;
944 hT0Fill->Fit("gaus", "q0", "", fitMin, fitMax);
945 }
104ba366 946 /* print params */
5b4ed716 947 mean = gaus->GetParameter(1);
948 sigma = gaus->GetParameter(2);
949 Float_t meane = gaus->GetParError(1);
950 Float_t sigmae = gaus->GetParError(2);
104ba366 951 Log(Form("edge fit: mean = %f +- %f ps", mean, meane));
952 Log(Form("edge fit: sigma = %f +- %f ps", sigma, sigmae));
5b4ed716 953 /* check error */
954 if (meane > 300.) {
955 Log("error on mean is large: store default T0-fill value (0 ps)");
956 mean = 0.;
957 }
958 if (sigmae > 300.) {
959 Log("error on sigma is large: store default TOFreso value (200 ps)");
960 sigma = 200.;
f04b3a69 961 }
104ba366 962
206685e8 963 /* scratch values from the fit and use max bin center as t0-fill */
964 mean = maxBinCenter;
965 sigma = -1.;
966 Log(Form("do not care about fitted value, just use max bin as t0-fill: %f ps", mean));
967
f04b3a69 968 /* create RunParams object */
969 UInt_t timestamp[1] = {0};
5b4ed716 970 Float_t t0[1] = {mean};
971 Float_t tofReso[1] = {sigma};
f04b3a69 972 Float_t t0Spread[1] = {-1.};
973 AliTOFRunParams *runParamsObject = new AliTOFRunParams(1);
974 runParamsObject->SetTimestamp(timestamp);
975 runParamsObject->SetT0(t0);
976 runParamsObject->SetTOFResolution(tofReso);
977 runParamsObject->SetT0Spread(t0Spread);
3fd7a5cd 978 runParamsObject->SetUseLHCClockPhase(kFALSE);
104ba366 979
980 /* store reference data */
981 if(fStoreRefData){
982 AliCDBMetaData metaDataHisto;
983 metaDataHisto.SetBeamPeriod(0);
984 metaDataHisto.SetResponsible("Roberto Preghenella");
985 metaDataHisto.SetComment("online T0-fill histogram");
986 if (!StoreReferenceData("Calib","T0Fill", hT0Fill, &metaDataHisto)) {
987 Log("error while storing reference data");
988 delete hT0Fill;
989 delete hit;
f04b3a69 990 delete runParamsObject;
104ba366 991 return 21;
992 }
993 Log("reference data successfully stored");
994 }
995
996 AliCDBMetaData metaData;
997 metaData.SetBeamPeriod(0);
998 metaData.SetResponsible("Roberto Preghenella");
f04b3a69 999 metaData.SetComment("online RunParams measurement");
1000 if (!Store("Calib", "RunParams", runParamsObject, &metaData, 0, kFALSE)) {
1001 Log("error while storing RunParams object");
104ba366 1002 delete hT0Fill;
1003 delete hit;
f04b3a69 1004 delete runParamsObject;
104ba366 1005 return 21;
1006 }
f04b3a69 1007 Log("RunParams object successfully stored");
104ba366 1008
1009 delete hT0Fill;
1010 delete hit;
f04b3a69 1011 delete runParamsObject;
104ba366 1012 return 0;
1013
1014}
1015
f04b3a69 1016//_____________________________________________________________________________
1017
1018UInt_t
1019AliTOFPreprocessor::ProcessNoiseCalibTrg()
1020{
1021 // Processing data from DAQ using calibration triggers for noise measurement
1022
1023 Log("Processing Noise (calibration trigger)");
1024
1025 /* check status and matching window available */
1026 if (!fStatus || !fMatchingWindow){
1027 AliError("No valid fStatus or fMatchingWindow found, some errors must have occurred!!");
1028 return 22;
1029 }
1030
1031 Float_t noiseThr = 1000.; // setting default threshold for noise to 1000 Hz
1032 // reading config map
1033 AliCDBEntry *cdbEntry = GetFromOCDB("Calib","ConfigNoise");
4682c56e 1034 if (!cdbEntry) Log(Form("No Configuration entry found in CDB, using default values: NoiseThr = %f",noiseThr));
f04b3a69 1035 else {
1036 TMap *configMap = (TMap*)cdbEntry->GetObject();
4682c56e 1037 if (!configMap) Log(Form("No map found in Config entry in CDB, using default values: NoiseThr = %f", noiseThr));
f04b3a69 1038 else {
1039 TObjString *strNoiseThr = (TObjString*)configMap->GetValue("NoiseThr");
1040 if (strNoiseThr) {
1041 TString tmpstr = strNoiseThr->GetString();
1042 noiseThr = tmpstr.Atoi();
1043 }
4682c56e 1044 else Log(Form("No NoiseThr value found in Map from ConfigNoise entry in CDB, using default value: NoiseThr = %f",noiseThr));
f04b3a69 1045 }
1046 }
1047
1048 /* get file sources from FXS */
1049 TList *fileList = GetFileSources(kDAQ, "CALIB");
1050 if (!fileList || fileList->GetEntries() == 0) {
1051 Log("cannot get DAQ source file list or empty list");
1052 return 22;
1053 }
1054 Log(Form("got DAQ source file list: %d files", fileList->GetEntries()));
1055 fileList->Print();
1056
1057 /* open input file (only one expected) */
1058 TObjString *str = (TObjString *)fileList->At(0);
1059 TString filename = GetFile(kDAQ, "CALIB", str->GetName());
1060 Log(Form("opening input file: source=%s, filename=%s", str->String().Data(), filename.Data()));
1061 TFile *filein = TFile::Open(filename.Data());
1062 if (!filein || !filein->IsOpen()) {
1063 Log("cannot open input file");
1064 return 22;
1065 }
1066
1067 /* get histo from input file */
1068 TH1F *hCalibHit = (TH1F *)filein->Get("hCalibHit");
1069 if (!hCalibHit) {
1070 Log("cannot get \"hCalibHit\" histo");
1071 return 22;
1072 }
1073
1074 /* create and set noise rate histo and check rate */
1075 TH1F *hNoiseRate = new TH1F("hNoiseRate", ";index;rate (Hz)", fNChannels, 0., fNChannels);
1076 Float_t rate, rate_err;
1077 for (Int_t ich = 0; ich < fNChannels; ich++) {
1078 /* check channel enabled */
1079 if (fStatus->GetHWStatus(ich) == AliTOFChannelOnlineStatusArray::kTOFHWBad) continue;
1080 /* set noise rate histo */
1081 rate = hCalibHit->GetBinContent(ich + 1);
1082 rate_err = hCalibHit->GetBinError(ich + 1);
1083 rate /= fMatchingWindow[ich] * 1.e-9;
1084 rate_err /= fMatchingWindow[ich] * 1.e-9;
1085 hNoiseRate->SetBinContent(ich + 1, rate);
1086 hNoiseRate->SetBinError(ich + 1, rate_err);
c1150dd0 1087 /* check error */
1088 if (rate_err == 0.) continue;
f04b3a69 1089 /* check noise rate and set noise flags */
1090 if ((rate - 3. * rate_err) > noiseThr) {
1091 Log(Form("channel %d detected as noisy: rate = (%f +- %f) Hz", ich, rate, rate_err));
1092 if (fStatus->GetNoiseStatus(ich) == AliTOFChannelOnlineStatusArray::kTOFNoiseOk) {
1093 Log(Form("channel %d noise status changed from Ok to Bad", ich));
1094 fStatus->SetNoiseStatus(ich, AliTOFChannelOnlineStatusArray::kTOFNoiseBad);
1095 fIsStatusMapChanged = kTRUE;
1096 }
1097 else Log(Form("channel %d noise status unchanged", ich));
1098 }
5b4ed716 1099 else if ((rate + 3. * rate_err) < noiseThr) {
f04b3a69 1100 if (fStatus->GetNoiseStatus(ich) == AliTOFChannelOnlineStatusArray::kTOFNoiseBad) {
1101 Log(Form("channel %d noise status changed from Bad to Ok", ich));
1102 fStatus->SetNoiseStatus(ich, AliTOFChannelOnlineStatusArray::kTOFNoiseOk);
1103 fIsStatusMapChanged = kTRUE;
1104 }
1105 }
1106 }
1107
1108 /* store reference data */
1109 if(fStoreRefData){
1110 AliCDBMetaData metaDataHisto;
1111 metaDataHisto.SetBeamPeriod(0);
1112 metaDataHisto.SetResponsible("Roberto Preghenella");
1113 metaDataHisto.SetComment("calibration trigger noise rate histogram");
1114 if (!StoreReferenceData("Calib","CalibNoise", hNoiseRate, &metaDataHisto)) {
1115 Log("error while storing reference data");
1116 delete hNoiseRate;
1117 filein->Close();
1118 return 22;
1119 }
1120 Log("reference data successfully stored");
1121 }
1122
1123 delete hNoiseRate;
1124 filein->Close();
1125 return 0;
1126}
104ba366 1127
ee3e792b 1128//_____________________________________________________________________________
1129
5b4ed716 1130UInt_t
1131AliTOFPreprocessor::ProcessReadout()
1132{
1133 // Processing data from DAQ to compute reaodut efficiency
1134
1135 Log("Processing Readout");
1136
1137 /* get file sources from FXS */
1138 TList *fileList = GetFileSources(kDAQ, "READOUT");
1139 if (!fileList || fileList->GetEntries() == 0) {
1140 Log("cannot get DAQ source file list or empty list");
1141 return 22;
1142 }
1143 Log(Form("got DAQ source file list: %d files", fileList->GetEntries()));
1144 fileList->Print();
1145
1146 /* open input file (only one expected) */
1147 TObjString *str = (TObjString *)fileList->At(0);
1148 TString filename = GetFile(kDAQ, "READOUT", str->GetName());
1149 Log(Form("opening input file: source=%s, filename=%s", str->String().Data(), filename.Data()));
1150 TFile *filein = TFile::Open(filename.Data());
1151 if (!filein || !filein->IsOpen()) {
1152 Log("cannot open input file");
1153 return 23;
1154 }
1155
1156 /* get histo from input file */
1157 TH1F *hChainEfficiency = (TH1F *)filein->Get("hChainEfficiency");
1158 if (!hChainEfficiency) {
1159 Log("cannot get \"hChainEfficiency\" histo");
1160 return 23;
1161 }
1162
1163 /* fill channel efficiency histo */
1164
1165 /* temporarly disable warnings */
1166 AliLog::EType_t logLevel = (AliLog::EType_t)AliLog::GetGlobalLogLevel();
1167 AliLog::SetGlobalLogLevel(AliLog::kError);
1168
1169 TH1F *hChannelEfficiency = new TH1F("hChannelEfficiency", "Channel readout efficiency;index;efficiency", fNChannels, 0., fNChannels);
1170 Int_t chainIndex, det[5], dummy, index;
1171 Float_t effi, effi_err;
1172 /* loop over DDLs */
1173 for (Int_t iddl = 0; iddl < 72; iddl++) {
1174 /* loop over TRMs */
1175 for (Int_t itrm = 0; itrm < 10; itrm++) {
1176 /* loop over chains */
1177 for (Int_t ichain = 0; ichain < 2; ichain++) {
1178 chainIndex = ichain + 2 * itrm + 20 * iddl;
1179 effi = hChainEfficiency->GetBinContent(chainIndex + 1);
1180 effi_err = hChainEfficiency->GetBinError(chainIndex + 1);
1181 /* loop over TDCs */
1182 for (Int_t itdc = 0; itdc < 15; itdc++) {
1183 /* loop over channels */
1184 for (Int_t ichannel = 0; ichannel < 8; ichannel++) {
1185
1186 /* get channel index */
1187 AliTOFRawStream::EquipmentId2VolumeId(iddl, itrm + 3, ichain, itdc, ichannel, det);
1188 dummy = det[4];
1189 det[4] = det[3];
1190 det[3] = dummy;
1191 /* check valid index */
1192 if (det[0] < 0 || det[0] > 17 ||
1193 det[1] < 0 || det[1] > 5 ||
1194 det[2] < 0 || det[2] > 18 ||
1195 det[3] < 0 || det[3] > 1 ||
1196 det[4] < 0 || det[4] > 47) continue;
1197 index = AliTOFGeometry::GetIndex(det);
1198
1199 /* set channel efficiency */
1200 hChannelEfficiency->SetBinContent(index + 1, effi);
1201 hChannelEfficiency->SetBinError(index + 1, effi_err);
1202
1203 }
1204 }
1205 }
1206 }
1207 }
1208
1209 /* re-enable warnings */
1210 AliLog::SetGlobalLogLevel(logLevel);
1211
1212 /* store reference data */
1213 if(fStoreRefData){
1214 /* setup TOF readout info object */
1215 AliTOFReadoutInfo readoutInfo;
1216 readoutInfo.SetChainEfficiency((TH1F *)filein->Get("hChainEfficiency"));
1217 readoutInfo.SetTRMData((TH1F *)filein->Get("hTRMData"));
1218 readoutInfo.SetTRMEmptyEvent((TH1F *)filein->Get("hTRMEmptyEvent"));
1219 readoutInfo.SetTRMBadEventCounter((TH1F *)filein->Get("hTRMBadEventCounter"));
1220 readoutInfo.SetTRMBadCRC((TH1F *)filein->Get("hTRMBadCRC"));
1221 readoutInfo.SetChainData((TH1F *)filein->Get("hChainData"));
1222 readoutInfo.SetChainBadStatus((TH1F *)filein->Get("hChainBadStatus"));
1223 readoutInfo.SetChainBadEventCounter((TH1F *)filein->Get("hChainBadEventCounter"));
1224 readoutInfo.SetTDCError((TH1F *)filein->Get("hTDCError"));
1225 readoutInfo.SetTDCErrorFlags((TH2F *)filein->Get("hTDCErrorFlags"));
1226
1227 AliCDBMetaData metaDataHisto;
1228 metaDataHisto.SetBeamPeriod(0);
1229 metaDataHisto.SetResponsible("Roberto Preghenella");
1230 metaDataHisto.SetComment("readout info data");
1231 if (!StoreReferenceData("Calib","ReadoutInfo", &readoutInfo, &metaDataHisto)) {
1232 Log("error while storing reference data");
1233 filein->Close();
1234 return 23;
1235 }
1236 Log("reference data successfully stored");
1237 }
1238
1239 AliCDBMetaData metaData;
1240 metaData.SetBeamPeriod(0);
1241 metaData.SetResponsible("Roberto Preghenella");
1242 metaData.SetComment("online ReadoutEfficiency measurement");
1243 if (!Store("Calib", "ReadoutEfficiency", hChannelEfficiency, &metaData, 0, kFALSE)) {
1244 Log("error while storing ReadoutEfficiency object");
1245 delete hChannelEfficiency;
1246 filein->Close();
1247 return 23;
1248 }
1249 Log("ReadoutEfficiency object successfully stored");
1250
1251 delete hChannelEfficiency;
1252 filein->Close();
1253 return 0;
1254}
1255
1256//_____________________________________________________________________________
1257
ee3e792b 1258UInt_t AliTOFPreprocessor::ProcessPulserData()
1259{
7fffa85b 1260 // Processing Pulser Run data for TOF channel status
1261
1262 Log("Processing Pulser");
ee3e792b 1263
17149e6b 1264 if (fStatus==0x0){
1265 AliError("No valid fStatus found, some errors must have occurred!!");
1266 return 20;
1267 }
ee3e792b 1268
17149e6b 1269 TH1::AddDirectory(0);
1270
ee3e792b 1271 Bool_t resultPulserRef=kFALSE;
7fffa85b 1272 Bool_t resultPulser=kFALSE;
17149e6b 1273
a174d599 1274 static const Int_t kSize = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
1275 TH1S * htofPulser = new TH1S("hTOFpulser","histo with signals on TOF during pulser", kSize,-0.5,kSize-0.5);
1276 for (Int_t ibin =1;ibin<=kSize;ibin++){
17149e6b 1277 htofPulser->SetBinContent(ibin,-1);
7fffa85b 1278 }
17149e6b 1279
ee3e792b 1280 // processing pulser
1281
1282 TFile * daqFile=0x0;
1283 TH1S *h1=0x0;
1284
1285 //retrieving Pulser data
1286 TList* listPulser = GetFileSources(kDAQ, "PULSER");
bf76be9c 1287 if (listPulser !=0x0 && listPulser->GetEntries()!=0)
e88f3330 1288 {
1289 AliInfo("The following sources produced files with the id PULSER");
1290 listPulser->Print();
1291 Int_t nPulser = 0;
1292 for (Int_t jj=0;jj<listPulser->GetEntries();jj++){
1293 Int_t nPulserSource = 0;
1294 TObjString * str = dynamic_cast<TObjString*> (listPulser->At(jj));
f18b69a1 1295 if (!str) {
1296 AliError("dynamic_cast returned NULL");
1297 return 4;
1298 }
e88f3330 1299 AliInfo(Form("found source %s", str->String().Data()));
1300 // file to be stored run per run
1301 TString fileNamePulser = GetFile(kDAQ, "PULSER", str->GetName());
1302 if (fileNamePulser.Length()>0){
1303 // storing refernce data
1304 AliInfo(Form("Got the file %s, now we can process pulser data.", fileNamePulser.Data()));
1305 daqFile = new TFile(fileNamePulser.Data(),"READ");
1306 h1 = (TH1S*) daqFile->Get("hTOFpulser");
1307 for (Int_t ibin=0;ibin<kSize;ibin++){
1308 if ((h1->GetBinContent(ibin+1))!=-1){
1309 if ((htofPulser->GetBinContent(ibin+1))==-1){
1310 htofPulser->SetBinContent(ibin+1,h1->GetBinContent(ibin+1));
1311 }
1312 else {
1313 Log(Form("Something strange occurred during Pulser run, channel %i already read by another LDC, please check!",ibin));
1314 }
1315 }
1316 }
1317
1318 // elaborating infos
1319 Double_t mean =0;
1320 Int_t nread=0;
1321 Int_t nreadNotEmpty=0;
1322 for (Int_t ientry=1;ientry<=h1->GetNbinsX();ientry++){
1323
1324 AliDebug(3,Form(" channel %i pulser status before pulser = %i, with global status = %i",ientry,(Int_t)fStatus->GetPulserStatus(ientry),(Int_t)fStatus->GetStatus(ientry)));
1325 /* check whether channel has been read out during current run.
1326 * if the status is bad it means it has not been read out.
1327 * in this case skip channel in order to not affect the mean */
1328 if (fStatus->GetHWStatus(ientry-1) == AliTOFChannelOnlineStatusArray::kTOFHWBad)
1329 continue;
1330 nPulser++;
1331 nPulserSource++;
1332 if (h1->GetBinContent(ientry)==-1) continue;
1333 else {
1334 if (h1->GetBinContent(ientry)>0) {
1335 nreadNotEmpty++;
1336 AliDebug(2,Form(" channel %i is ok with entry = %f; so far %i channels added ",ientry-1,h1->GetBinContent(ientry),nreadNotEmpty));
1337 }
1338 mean+=h1->GetBinContent(ientry);
1339 nread++;
1340 }
1341 }
1342 if (nread!=0) {
1343 mean/=nread;
1344 AliDebug(2,Form(" nread = %i , nreadNotEmpty = %i, mean = %f",nread,nreadNotEmpty,mean));
1345 for (Int_t ich =0;ich<fNChannels;ich++){
1346 if (h1->GetBinContent(ich+1)==-1) continue;
1347 AliDebug(3,Form(" channel %i pulser status before pulser = %i",ich,(Int_t)fStatus->GetPulserStatus(ich)));
1348
1349 /* check whether channel has been read out during current run.
1350 * if the status is bad it means it has not been read out.
1351 * in this case skip channel in order to leave its status
1352 * unchanged */
1353 if (fStatus->GetHWStatus(ich) == AliTOFChannelOnlineStatusArray::kTOFHWBad)
1354 continue;
1355
1356 if (h1->GetBinContent(ich+1)<0.05*mean){
1357 fStatus->SetPulserStatus(ich,AliTOFChannelOnlineStatusArray::kTOFPulserBad); // bad status for pulser
1358 AliDebug(2,Form( " channel %i pulser status after pulser = %i (bad, content = %f), with global status = %i",ich,(Int_t)fStatus->GetPulserStatus(ich),h1->GetBinContent(ich+1),(Int_t)fStatus->GetStatus(ich)));
1359 }
1360 else {
1361 fStatus->SetPulserStatus(ich,AliTOFChannelOnlineStatusArray::kTOFPulserOk); // good status for pulser
1362 AliDebug(2,Form( " channel %i pulser status after pulser = %i (good), with global status = %i",ich,(Int_t)fStatus->GetPulserStatus(ich),(Int_t)fStatus->GetStatus(ich)));
1363 }
1364 }
1365 }
1366 else {
1367 Log("No channels read!! No action taken, keeping old status");
1368 }
1369
1370 daqFile->Close();
1371 delete daqFile;
1372 delete h1;
17149e6b 1373 }
1a1486e7 1374
e88f3330 1375 else{
1376 Log("The input data file from DAQ (pulser) was not found, TOF exiting from Shuttle ");
1377 delete listPulser;
1378 delete htofPulser;
1379 htofPulser = 0x0;
1380 if (fStatus){
1381 delete fStatus;
1382 fStatus = 0;
1383 }
1384 return 10;//return error code for failure in retrieving Ref Data
1a1486e7 1385 }
e88f3330 1386 AliDebug(2,Form(" Number of channels processed during pulser run from source %i = %i",jj, nPulserSource));
1a1486e7 1387 }
e88f3330 1388 AliDebug(2,Form(" Number of channels processed during pulser run = %i",nPulser));
1389 delete listPulser;
ee3e792b 1390 }
7fffa85b 1391
ee3e792b 1392 else{
17149e6b 1393 Log("The input data file list from DAQ (pulser) was not found, TOF exiting from Shuttle ");
e88f3330 1394 delete htofPulser;
1395 htofPulser = 0x0;
1396 if (fStatus){
1397 delete fStatus;
1398 fStatus = 0;
1399 }
17149e6b 1400 return 10;//return error code for failure in retrieving Ref Data
ee3e792b 1401 }
17149e6b 1402
7fffa85b 1403 //storing in OCDB
17149e6b 1404
7fffa85b 1405 AliCDBMetaData metaData;
1406 metaData.SetBeamPeriod(0);
1407 metaData.SetResponsible("Chiara Zampolli");
17149e6b 1408 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object after a Pulser run.");
7fffa85b 1409 AliInfo("Storing Calibration Data from Pulser Run");
17149e6b 1410 resultPulser = Store("Calib","Status",fStatus, &metaData,0,kTRUE);
7fffa85b 1411 if(!resultPulser){
1412 Log("Some problems occurred while storing online object resulting from Pulser data processing");
e88f3330 1413 delete htofPulser;
1414 htofPulser = 0x0;
1415 if (fStatus){
1416 delete fStatus;
1417 fStatus = 0;
1418 }
7fffa85b 1419 return 11;//return error code for problems in storing Pulser data
1420 }
1421
ee3e792b 1422 if(fStoreRefData){
1423
1424 AliCDBMetaData metaDataHisto;
1425 metaDataHisto.SetBeamPeriod(0);
1426 metaDataHisto.SetResponsible("Chiara Zampolli");
f18b69a1 1427 metaDataHisto.SetComment("This preprocessor stores the Ref data from a pulser run.");
ee3e792b 1428 AliInfo("Storing Reference Data");
db83b789 1429 resultPulserRef = StoreReferenceData("Calib","PulserData",htofPulser, &metaDataHisto);
ee3e792b 1430 if (!resultPulserRef){
7fffa85b 1431 Log("some problems occurred::No Reference Data for pulser stored, TOF exiting from Shuttle");
e88f3330 1432 delete htofPulser;
1433 htofPulser = 0x0;
1434 if (fStatus){
1435 delete fStatus;
1436 fStatus = 0;
1437 }
7fffa85b 1438 return 9;//return error code for failure in storing Ref Data
ee3e792b 1439 }
1440 }
1441
1442 daqFile=0;
1443
e88f3330 1444 delete htofPulser;
1445 htofPulser = 0x0;
1446
1447 if (fStatus){
1448 delete fStatus;
1449 fStatus = 0;
1450 }
1451
ee3e792b 1452 return 0;
1453}
1454//_____________________________________________________________________________
1455
1456UInt_t AliTOFPreprocessor::ProcessNoiseData()
1457{
7fffa85b 1458
1459 // Processing Noise Run data for TOF channel status
1460
1461 Log("Processing Noise");
ee3e792b 1462
17149e6b 1463 if (fStatus==0x0){
1464 AliError("No valid fStatus found, some errors must have occurred!!");
1465 return 20;
1466 }
1467
013ac2dd 1468 Float_t noiseThr = 1; // setting default threshold for noise to 1 Hz
1469 // reading config map
1470 AliCDBEntry *cdbEntry = GetFromOCDB("Calib","ConfigNoise");
1471 if (!cdbEntry) {
4682c56e 1472 Log(Form("No Configuration entry found in CDB, using default values: NoiseThr = %f",noiseThr));
013ac2dd 1473 }
1474 else {
1475 TMap *configMap = (TMap*)cdbEntry->GetObject();
1476 if (!configMap){
4682c56e 1477 Log(Form("No map found in Config entry in CDB, using default values: NoiseThr = %f", noiseThr));
013ac2dd 1478 }
1479 else{
1480 TObjString *strNoiseThr = (TObjString*)configMap->GetValue("NoiseThr");
1481 if (strNoiseThr) {
1482 TString tmpstr = strNoiseThr->GetString();
1483 noiseThr = tmpstr.Atoi();
1484 }
1485 else {
4682c56e 1486 Log(Form("No NoiseThr value found in Map from ConfigNoise entry in CDB, using default value: NoiseThr = %f",noiseThr));
013ac2dd 1487 }
1488 }
1489 }
1490
1491 delete cdbEntry;
1492 cdbEntry = 0x0;
1493
ee3e792b 1494 TH1::AddDirectory(0);
1495
1496 Bool_t resultNoiseRef=kFALSE;
7fffa85b 1497 Bool_t resultNoise=kFALSE;
ee3e792b 1498
a174d599 1499 static const Int_t kSize = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
17149e6b 1500 TH1F * htofNoise = new TH1F("hTOFnoise","histo with signals on TOF during noise", kSize,-0.5,kSize-0.5);
a174d599 1501 for (Int_t ibin =1;ibin<=kSize;ibin++){
17149e6b 1502 htofNoise->SetBinContent(ibin,-1);
ee3e792b 1503 }
17149e6b 1504
ee3e792b 1505 // processing noise
1506
1507 TFile * daqFile=0x0;
1508 TH1F * h1=0x0;
1509
013ac2dd 1510 // useful counters
1511 Int_t nNoise = 0;
1512 Int_t nNoisyChannels = 0;
1513 Int_t nNotNoisyChannels = 0;
1514 Int_t nChannelsFromDA = 0;
1515 Int_t nMatchingWindowNullNonZero = 0;
1516 Int_t nMatchingWindowNullEqualZero = 0;
1517
1518 // retrieving Noise data
ee3e792b 1519 TList* listNoise = GetFileSources(kDAQ, "NOISE");
bf76be9c 1520 if (listNoise !=0x0 && listNoise->GetEntries()!=0)
e88f3330 1521 {
1522 AliInfo("The following sources produced files with the id NOISE");
1523 listNoise->Print();
e88f3330 1524 for (Int_t jj=0;jj<listNoise->GetEntries();jj++){
1525 Int_t nNoiseSource = 0;
1526 TObjString * str = dynamic_cast<TObjString*> (listNoise->At(jj));
f18b69a1 1527 if (!str) {
1528 AliError("dynamic_cast returned NULL");
1529 return 4;
1530 }
e88f3330 1531 AliInfo(Form("found source %s", str->String().Data()));
1532 // file to be stored run per run
1533 TString fileNameNoise = GetFile(kDAQ, "NOISE", str->GetName());
1534 if (fileNameNoise.Length()>0){
1535 // storing reference data
1536 AliInfo(Form("Got the file %s, now we can process noise data.", fileNameNoise.Data()));
1537 daqFile = new TFile(fileNameNoise.Data(),"READ");
1538 h1 = (TH1F*) daqFile->Get("hTOFnoise");
1539 for (Int_t ibin=0;ibin<kSize;ibin++){
1540 if ((h1->GetBinContent(ibin+1))!=-1){
013ac2dd 1541 nNoiseSource++;
1542 // checking the matching window for current channel
1543 if (fMatchingWindow[ibin] == 0){
fc143ab2 1544 Log(Form("Matching window for channel %i null, but the channel was read by the LDC! skipping channel, BUT Please check!",ibin));
013ac2dd 1545 if ((h1->GetBinContent(ibin+1))!=0) nMatchingWindowNullNonZero++;
1546 if ((h1->GetBinContent(ibin+1))==0) nMatchingWindowNullEqualZero++;
1547 continue;
1548 }
e88f3330 1549 if ((htofNoise->GetBinContent(ibin+1))==-1){
013ac2dd 1550 htofNoise->SetBinContent(ibin+1,h1->GetBinContent(ibin+1)/(fMatchingWindow[ibin]*1.E-9));
1551 if ((h1->GetBinContent(ibin+1))!= 0) AliDebug(2,Form("Channel = %i, Matching window = %i, Content = %f", ibin, fMatchingWindow[ibin], htofNoise->GetBinContent(ibin+1)));
e88f3330 1552 }
1553 else {
1554 Log(Form("Something strange occurred during Noise run, channel %i already read by another LDC, please check!",ibin));
1555 }
1556 }
1557 }
013ac2dd 1558
1559 Log(Form(" Number of channels processed during noise run from source %i = %i",jj, nNoiseSource));
e88f3330 1560 daqFile->Close();
1561 delete daqFile;
1562 delete h1;
013ac2dd 1563 daqFile = 0x0;
1564 h1 = 0x0;
1565
e88f3330 1566 }
e88f3330 1567 else{
1568 Log("The input data file from DAQ (noise) was not found, TOF exiting from Shuttle ");
1569 delete listNoise;
013ac2dd 1570 listNoise = 0x0;
e88f3330 1571 delete htofNoise;
1572 htofNoise = 0x0;
1573 if (fStatus){
1574 delete fStatus;
1575 fStatus = 0;
1576 }
013ac2dd 1577 if (fMatchingWindow){
1578 delete [] fMatchingWindow;
1579 fMatchingWindow = 0;
1580 }
e88f3330 1581 return 13;//return error code for failure in retrieving Ref Data
1582 }
013ac2dd 1583 }
ee3e792b 1584 }
013ac2dd 1585
e88f3330 1586 else{
1587 Log("The input data file list from DAQ (noise) was not found, TOF exiting from Shuttle ");
1588 delete htofNoise;
1589 htofNoise = 0x0;
1590 if (fStatus){
1591 delete fStatus;
1592 fStatus = 0;
ee3e792b 1593 }
013ac2dd 1594 if (fMatchingWindow){
1595 delete [] fMatchingWindow;
1596 fMatchingWindow = 0;
1597 }
7fffa85b 1598 return 13;//return error code for failure in retrieving Ref Data
ee3e792b 1599 }
1600
013ac2dd 1601 // elaborating infos to set NOISE status
1602 for (Int_t ich =0;ich<fNChannels;ich++){
1603 if (htofNoise->GetBinContent(ich+1)== -1) continue;
1604
1605 nChannelsFromDA++;
1606
1607 AliDebug(3,Form(" channel %i noise status before noise = %i, with global status = %i",ich,(Int_t)fStatus->GetNoiseStatus(ich),(Int_t)fStatus->GetStatus(ich)));
1608 //AliDebug(2,Form( " channel %i status before noise = %i",ich,(Int_t)fStatus->GetNoiseStatus(ich)));
1609
1610 /* check whether channel has been read out during current run.
1611 * if the status is bad it means it has not been read out.
1612 * in this case skip channel in order to leave its status
1613 * unchanged */
1614
1615 if ((fStatus->GetHWStatus(ich)) == AliTOFChannelOnlineStatusArray::kTOFHWBad)
1616 continue;
1617
1618 nNoise++;
1619 if (htofNoise->GetBinContent(ich+1) >= noiseThr){
1620 fStatus->SetNoiseStatus(ich,AliTOFChannelOnlineStatusArray::kTOFNoiseBad); // bad status for noise
1621 AliDebug(3,Form( " channel %i noise status after noise = %i, with global status = %i",ich,(Int_t)fStatus->GetNoiseStatus(ich),(Int_t)fStatus->GetStatus(ich)));
1622 nNoisyChannels++;
1623 }
1624 else {
1625 fStatus->SetNoiseStatus(ich,AliTOFChannelOnlineStatusArray::kTOFNoiseOk); // good status for noise
1626 AliDebug(3,Form(" channel %i noise status after noise = %i, with global status = %i",ich,(Int_t)fStatus->GetNoiseStatus(ich),(Int_t)fStatus->GetStatus(ich)));
1627 nNotNoisyChannels++;
1628 }
1629 }
1630
1631 Log(Form(" Number of channels processed by DA during noise run, independetly from TOFFEE = %i",nChannelsFromDA));
1632 Log(Form(" Number of channels processed during noise run (that were ON according to TOFFEE) = %i",nNoise));
1633 Log(Form(" Number of noisy channels found during noise run = %i",nNoisyChannels));
1634 Log(Form(" Number of not noisy channels found during noise run = %i",nNotNoisyChannels));
1635 Log(Form(" Number of channels with matching window NULL (so skipped), but Non Zero content = %i",nMatchingWindowNullNonZero));
1636 Log(Form(" Number of channels with matching window NULL (so skipped), and Zero content = %i",nMatchingWindowNullEqualZero));
1637
1638 delete listNoise;
1639
1640 //daqFile=0;
e88f3330 1641
7fffa85b 1642 //storing in OCDB
e88f3330 1643
7fffa85b 1644 AliCDBMetaData metaData;
1645 metaData.SetBeamPeriod(0);
1646 metaData.SetResponsible("Chiara Zampolli");
17149e6b 1647 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object after a Noise run.");
7fffa85b 1648 AliInfo("Storing Calibration Data from Noise Run");
17149e6b 1649 resultNoise = Store("Calib","Status",fStatus, &metaData,0,kTRUE);
7fffa85b 1650 if(!resultNoise){
1651 Log("Some problems occurred while storing online object resulting from Noise data processing");
e88f3330 1652 delete htofNoise;
1653 htofNoise = 0x0;
1654 if (fStatus){
1655 delete fStatus;
1656 fStatus = 0;
1657 }
013ac2dd 1658 if (fMatchingWindow){
1659 delete [] fMatchingWindow;
1660 fMatchingWindow = 0;
1661 }
7fffa85b 1662 return 14;//return error code for problems in storing Noise data
1663 }
1664
ee3e792b 1665 if(fStoreRefData){
1666
1667 AliCDBMetaData metaDataHisto;
1668 metaDataHisto.SetBeamPeriod(0);
1669 metaDataHisto.SetResponsible("Chiara Zampolli");
f18b69a1 1670 metaDataHisto.SetComment("This preprocessor stores the Ref data from a noise run. ");
ee3e792b 1671 AliInfo("Storing Reference Data");
db83b789 1672 resultNoiseRef = StoreReferenceData("Calib","NoiseData",htofNoise, &metaDataHisto);
ee3e792b 1673 if (!resultNoiseRef){
1674 Log("some problems occurred::No Reference Data for noise stored");
e88f3330 1675 delete htofNoise;
1676 htofNoise = 0x0;
1677 if (fStatus){
1678 delete fStatus;
1679 fStatus = 0;
1680 }
013ac2dd 1681 if (fMatchingWindow){
1682 delete [] fMatchingWindow;
1683 fMatchingWindow = 0;
1684 }
7fffa85b 1685 return 12;//return error code for failure in storing Ref Data
ee3e792b 1686 }
1687 }
1688
e88f3330 1689 delete htofNoise;
1690 htofNoise = 0x0;
1691
1692 if (fStatus){
1693 delete fStatus;
1694 fStatus = 0;
1695 }
1696
013ac2dd 1697 if (fMatchingWindow){
1698 delete [] fMatchingWindow;
1699 fMatchingWindow = 0;
1700 }
1701
ee3e792b 1702 return 0;
1703}
1704//_____________________________________________________________________________
1705
db83b789 1706UInt_t AliTOFPreprocessor::ProcessFEEData()
ee3e792b 1707{
7fffa85b 1708 // Processing Pulser Run data for TOF channel status
1709 // dummy for the time being
ee3e792b 1710
db83b789 1711 Log("Processing FEE");
1712
ea932f75 1713 //Bool_t updateOCDB = kFALSE;
db83b789 1714 AliTOFFEEReader feeReader;
17149e6b 1715
db83b789 1716 TH1C hCurrentFEE("hCurrentFEE","histo with current FEE channel status", fNChannels, 0, fNChannels);
1717
69355034 1718 /* load current TOF FEE(dump) from DCS FXS,
1719 * setup TOFFEEdump object */
1720
1721 const char * toffeeFileName = GetFile(kDCS,"TofFeeMap","");
1722 AliInfo(Form("toffee file name = %s", toffeeFileName));
1723 if (toffeeFileName == NULL) {
1724 return 15;
1725 }
1726 AliTOFFEEDump feedump;
1727 feedump.ReadFromFile(toffeeFileName);
1728
1729 /* load current TOF FEE(light) config from DCS FXS, parse,
db83b789 1730 * fill current FEE histogram and set FEE status */
1731
fceb731d 1732 const char * nameFile = GetFile(kDCS,"TofFeeLightMap","");
69355034 1733 AliInfo(Form("toffeeLight file name = %s",nameFile));
db83b789 1734 if (nameFile == NULL) {
1735 return 15;
1736 }
fceb731d 1737 feeReader.LoadFEElightConfig(nameFile);
1738 Int_t parseFee = feeReader.ParseFEElightConfig();
1739 AliDebug(2,Form("%i enabled channels found in FEElight configuration",parseFee));
db83b789 1740 /* load stored TOF FEE from OCDB and compare it with current FEE.
1741 * if stored FEE is different from current FEE set update flag.
1742 * if there is no stored FEE in OCDB set update flag */
1743
013ac2dd 1744 fMatchingWindow = new Int_t[fNChannels];
02ede0c4 1745 fLatencyWindow = new Int_t[fNChannels];
1746
17149e6b 1747 AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Status");
1748 if (!cdbEntry) {
1749 /* no CDB entry found. set update flag */
1750 Log(" ************ WARNING ************");
1751 Log("No CDB Status entry found, creating a new one!");
1752 Log(" *********************************");
1753 fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
ea932f75 1754 //updateOCDB = kTRUE;
1755 fIsStatusMapChanged = kTRUE;
db83b789 1756 }
db83b789 1757 else {
e88f3330 1758 if (cdbEntry) cdbEntry->SetOwner(kFALSE);
17149e6b 1759 /* CDB entry OK. loop over channels */
1760 fStatus = (AliTOFChannelOnlineStatusArray*) cdbEntry->GetObject();
e88f3330 1761 delete cdbEntry;
1762 cdbEntry = 0x0;
134e5594 1763 /* cehck whether status object has latency window data */
1764 if (!fStatus->HasLatencyWindow()) {
1765 /* create new status object and update OCDB */
1766 Log(" ************ WARNING ************");
1767 Log("CDB Status entry found but has no latency window data, creating a new one!");
1768 Log(" *********************************");
1769 delete fStatus;
1770 fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
ea932f75 1771 //updateOCDB = kTRUE;
1772 fIsStatusMapChanged = kTRUE;
134e5594 1773 }
db83b789 1774 }
17149e6b 1775 for (Int_t iChannel = 0; iChannel < fNChannels; iChannel++){
1776 //AliDebug(2,Form("********** channel %i",iChannel));
1777 /* compare current FEE channel status with stored one
1778 * if different set update flag and break loop */
1779 //AliDebug(2,Form( " channel %i status before FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
013ac2dd 1780 fMatchingWindow[iChannel] = feeReader.GetMatchingWindow(iChannel);
02ede0c4 1781 fLatencyWindow[iChannel] = feeReader.GetLatencyWindow(iChannel);
17149e6b 1782 if (feeReader.IsChannelEnabled(iChannel)) {
1783 hCurrentFEE.SetBinContent(iChannel + 1, 1);
1784 if (fStatus->GetHWStatus(iChannel)!=AliTOFChannelOnlineStatusArray::kTOFHWOk){
ea932f75 1785 //updateOCDB = kTRUE;
1786 fIsStatusMapChanged = kTRUE;
17149e6b 1787 fStatus->SetHWStatus(iChannel,AliTOFChannelOnlineStatusArray::kTOFHWOk);
013ac2dd 1788 AliDebug(3,Form( " changed into enabled: channel %i status after FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
17149e6b 1789 }
02ede0c4 1790 if (fStatus->GetLatencyWindow(iChannel)!=fLatencyWindow[iChannel]){
ea932f75 1791 //updateOCDB = kTRUE;
1792 fIsStatusMapChanged = kTRUE;
02ede0c4 1793 fStatus->SetLatencyWindow(iChannel,fLatencyWindow[iChannel]);
1794 AliDebug(3,Form( " changed latency window: channel %i latency window after FEE = %i",iChannel,fStatus->GetLatencyWindow(iChannel)));
1795 }
17149e6b 1796 }
1797 else {
1798 if (fStatus->GetHWStatus(iChannel)!=AliTOFChannelOnlineStatusArray::kTOFHWBad){
ea932f75 1799 //updateOCDB = kTRUE;
1800 fIsStatusMapChanged = kTRUE;
17149e6b 1801 fStatus->SetHWStatus(iChannel,AliTOFChannelOnlineStatusArray::kTOFHWBad);
013ac2dd 1802 AliDebug(3,Form( " changed into disabled: channel %i status after FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
17149e6b 1803 }
1804 }
1805 }
1806
db83b789 1807
1808 /* check whether we don't have to store reference data.
1809 * in this case we return without errors. */
1810 if (fStoreRefData) {
69355034 1811 /* store reference data */
1812 AliCDBMetaData metaDataHisto;
1813 metaDataHisto.SetBeamPeriod(0);
1814 metaDataHisto.SetResponsible("Roberto Preghenella");
1815 metaDataHisto.SetComment("This preprocessor stores the FEE Ref data of the current run.");
1816 AliInfo("Storing FEE reference data");
1817 /* store FEE reference data */
1818 if (!StoreReferenceData("Calib", "FEEData", &hCurrentFEE, &metaDataHisto)) {
1819 /* failed */
1820 Log("problems while storing FEE reference data");
1821 if (fStatus){
1822 delete fStatus;
1823 fStatus = 0;
1824 }
1825 return 18; /* error return code for problems while storing FEE reference data */
1826 }
1827
1828 /* store TOF FEE dump reference data */
1829 AliCDBMetaData metaDatadump;
1830 metaDatadump.SetBeamPeriod(0);
1831 metaDatadump.SetResponsible("Roberto Preghenella");
1832 metaDatadump.SetComment("This preprocessor stores the TOF FEE dump Ref data of the current run.");
1833 AliInfo("Storing TOF FEE dump reference data");
1834 /* store FEE reference data */
1835 if (!StoreReferenceData("Calib", "FEEDump", &feedump, &metaDatadump)) {
1836 /* failed */
1837 Log("problems while storing TOF FEE dump reference data");
1838 return 18; /* error return code for problems while storing FEE reference data */
1839 }
db83b789 1840 }
1841
7fffa85b 1842 return 0;
1843
1844}
1845
1846//_____________________________________________________________________________
1847
104ba366 1848UInt_t AliTOFPreprocessor::Process(TMap *dcsAliasMap)
7fffa85b 1849{
a174d599 1850 //
ea932f75 1851 // Main AliTOFPreprocessor method called by SHUTTLE
a174d599 1852 //
7fffa85b 1853
1854 TString runType = GetRunType();
1855 Log(Form("RunType %s",runType.Data()));
bf76be9c 1856
ee3e792b 1857 // processing
1858
db83b789 1859 /* always process FEE data */
1860 Int_t iresultFEE = ProcessFEEData();
1861 if (iresultFEE != 0)
1862 return iresultFEE;
1863
7fffa85b 1864 if (runType == "PULSER") {
1865 Int_t iresultPulser = ProcessPulserData();
1866 return iresultPulser;
1867 }
17149e6b 1868
7fffa85b 1869 if (runType == "NOISE") { // for the time being associating noise runs with pedestal runs; proper run type to be defined
1870 Int_t iresultNoise = ProcessNoiseData();
1871 return iresultNoise;
1872 }
104ba366 1873
7fffa85b 1874 if (runType == "PHYSICS") {
104ba366 1875 // Int_t iresultDAQ = ProcessOnlineDelays();
1876 Int_t iresultDAQ = ProcessT0Fill();
f04b3a69 1877 Int_t iresultNoiseCalib = ProcessNoiseCalibTrg();
1f4ce44e 1878 Int_t iresultReadout = ProcessReadout();
f04b3a69 1879 Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
1880 Int_t iResultHVandLVdps = ProcessHVandLVdps(dcsAliasMap);
1f4ce44e 1881 return iresultDAQ+iresultNoiseCalib+iresultDCS+iResultHVandLVdps+iresultReadout;
ee3e792b 1882 }
1883
7fffa85b 1884 // storing
ee3e792b 1885 return 0;
1886}
c9fe8530 1887
1888
b06d5296 1889//_____________________________________________________________________________
1890
1891void
1892AliTOFPreprocessor::FillWithCosmicCalibration(AliTOFChannelOnlineArray *cal)
1893{
1894 /*
1895 * fill with cosmic calibration
1896 */
1897
1898 Log(" Using cosmic-ray calibration.");
1899
1900 AliTOFcalibHisto calibHisto;
97a29b32 1901 calibHisto.SetFullCorrectionFlag(AliTOFcalibHisto::kTimeSlewingCorr, kFALSE);
1902 Log(Form(" loading calibration histograms from %s", calibHisto.GetCalibHistoFileName()));
b06d5296 1903 Log(Form(" loading calibration parameters from %s", calibHisto.GetCalibParFileName()));
1904 calibHisto.LoadCalibPar();
1905
1906 /* loop over channel index */
1907 for (Int_t iIndex = 0; iIndex < fNChannels; iIndex++) {
9155334b 1908 cal->SetDelay(iIndex, calibHisto.GetFullCorrection(iIndex));
b06d5296 1909 }
1910
1911}
1912
b06d5296 1913//_____________________________________________________________________________
1914
1915void
1916AliTOFPreprocessor::FillWithCableLengthMap(AliTOFChannelOnlineArray *cal)
1917{
1918 /*
1919 * fill with cosmic calibration
1920 */
1921
1922 Log(" Using cable-length map.");
1923 AliTOFRawStream tofrs;
1924 Int_t det[5], dummy, index;
1925 Float_t cableTimeShift;
1926
1927 /* temporarly disable warnings */
1928 AliLog::EType_t logLevel = (AliLog::EType_t)AliLog::GetGlobalLogLevel();
1929 AliLog::SetGlobalLogLevel(AliLog::kError);
1930
1931 /* loop over EO indeces */
1932 for (Int_t iddl = 0; iddl < 72; iddl++)
1933 for (Int_t islot = 3; islot <= 12; islot++)
1934 for (Int_t ichain = 0; ichain < 2; ichain++)
1935 for (Int_t itdc = 0; itdc < 15; itdc++)
1936 for (Int_t ichannel = 0; ichannel < 8; ichannel++) {
1937
1938 /* get DO index */
1939 tofrs.EquipmentId2VolumeId(iddl, islot, ichain, itdc, ichannel, det);
1940
1941 /* swap det[3] and det[4] indeces (needed to obtain correct channel index) */
1942 dummy = det[3];
1943 det[3] = det[4];
1944 det[4] = dummy;
1945
1946 /* check DO index */
1947 if (det[0] < 0 || det[0] > 17 ||
1948 det[1] < 0 || det[1] > 4 ||
1949 det[2] < 0 || det[2] > 18 ||
1950 det[3] < 0 || det[3] > 1 ||
1951 det[4] < 0 || det[4] > 47)
1952 continue;
1953
1954 /* get channel index */
1955 index = AliTOFGeometry::GetIndex(det);
f18b69a1 1956 if (index < 0) continue;
b06d5296 1957
1958 /* get cable time shift */
1959 cableTimeShift = AliTOFCableLengthMap::GetCableTimeShift(iddl, islot, ichain, itdc);
1960
1961 /* set delay */
1962 if (index<fNChannels) {
1963 cal->SetDelay(index,cableTimeShift); // delay in ns
1964 AliDebug(2,Form("Setting delay %f (ns) for channel %i",cableTimeShift,index));
1965 }
1966
1967 } /* loop over EO indeces */
1968
1969 /* re-enable warnings */
1970 AliLog::SetGlobalLogLevel(logLevel);
1971
1972}
1973
1974