Improved QAchecker and plots for DQM
[u/mrichter/AliRoot.git] / TOF / AliTOFPreprocessor.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18
19//#include <Riostream.h>
20//#include <stdio.h>
21//#include <stdlib.h>
22
23#include <TFile.h>
24#include <TH2S.h>
25#include <TH1F.h>
26#include <TCanvas.h>
27#include <TMath.h>
28#include <TObjArray.h>
29#include <TObjString.h>
30#include <TTimeStamp.h>
31
32#include "AliCDBMetaData.h"
33#include "AliCDBEntry.h"
34#include "AliLog.h"
35#include "AliTOFChannelOnlineArray.h"
36#include "AliTOFChannelOnlineStatusArray.h"
37#include "AliTOFDataDCS.h"
38#include "AliTOFDCSmaps.h"
39#include "AliTOFLvHvDataPoints.h"
40#include "AliTOFGeometry.h"
41#include "AliTOFPreprocessor.h"
42#include "AliTOFFEEReader.h"
43#include "AliTOFRawStream.h"
44#include "AliTOFCableLengthMap.h"
45#include "AliTOFcalibHisto.h"
46#include "AliTOFFEEDump.h"
47#include "TChain.h"
48#include "AliTOFDeltaBCOffset.h"
49#include "AliTOFCTPLatency.h"
50#include "AliTOFRunParams.h"
51#include "AliTOFT0FillOnlineCalib.h"
52#include "AliTOFHitField.h"
53#include "AliTOFChannelOffline.h"
54#include "TF1.h"
55#include "TGeoManager.h"
56#include "AliGeomManager.h"
57#include "AliTOFReadoutInfo.h"
58
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.
62// Analogously, it takes data form DAQ (both at Run level and inclusive -
63// of all the runs - level, processes them, and stores both Reference Data
64// and Online Calibration files in the CDB.
65// Processing of Pulser/Noise Run data and of TOF FEE DCS map included also.
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
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
87// return=20: failed in retrieving status variable
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)
91
92ClassImp(AliTOFPreprocessor)
93
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
97
98//_____________________________________________________________________________
99
100AliTOFPreprocessor::AliTOFPreprocessor(AliShuttleInterface* shuttle) :
101 AliPreprocessor("TOF", shuttle),
102 fData(0),
103 fHVLVmaps(0),
104 fCal(0),
105 fNChannels(0),
106 fStoreRefData(kTRUE),
107 fFDRFlag(kFALSE),
108 fStatus(0),
109 fMatchingWindow(0),
110 fLatencyWindow(0),
111 fIsStatusMapChanged(0)
112{
113 // constructor
114 AddRunType("PHYSICS");
115 AddRunType("PULSER");
116 AddRunType("NOISE");
117
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
135 AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", run,
136 TTimeStamp(startTime).AsString(),
137 TTimeStamp(endTime).AsString(), ((TTimeStamp)GetStartTimeDCSQuery()).AsString(), ((TTimeStamp)GetEndTimeDCSQuery()).AsString()));
138
139 fData = new AliTOFDataDCS(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
140 fHVLVmaps = new AliTOFLvHvDataPoints(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
141 fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
142}
143//_____________________________________________________________________________
144Bool_t AliTOFPreprocessor::ProcessDCS(){
145
146 // check whether DCS should be processed or not...
147
148 TString runType = GetRunType();
149 Log(Form("RunType %s",runType.Data()));
150
151 if (runType != "PHYSICS"){
152 return kFALSE;
153 }
154
155 return kTRUE;
156}
157//_____________________________________________________________________________
158
159UInt_t AliTOFPreprocessor::ProcessDCSDataPoints(TMap *dcsAliasMap)
160{
161 // Fills data into a AliTOFDataDCS object
162
163
164 Log("Processing DCS DP");
165 TH1::AddDirectory(0);
166
167 Bool_t resultDCSMap=kFALSE;
168 Bool_t resultDCSStore=kFALSE;
169
170 // processing DCS
171
172 if (!dcsAliasMap){
173 Log("No DCS map found: TOF exiting from Shuttle");
174 if (fData) {
175 delete fData;
176 fData = 0;
177 }
178 return 1;// return error Code for DCS input data not found
179 }
180 else {
181
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
187 fData->SetFDRFlag(fFDRFlag);
188
189 // The processing of the DCS input data is forwarded to AliTOFDataDCS
190 resultDCSMap=fData->ProcessData(*dcsAliasMap);
191 if(!resultDCSMap){
192 Log("Some problems occurred while processing DCS data, TOF exiting from Shuttle");
193 if (fData) {
194 delete fData;
195 fData = 0;
196 }
197 return 2;// return error Code for processed DCS data not stored
198 }
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");
205 resultDCSStore = StoreReferenceData("Calib","DCSData",fData, &metaDataDCS);
206 if (!resultDCSStore){
207 Log("Some problems occurred while storing DCS data results in Reference Data, TOF exiting from Shuttle");
208 if (fData){
209 delete fData;
210 fData = 0;
211 }
212 return 3;// return error Code for processed DCS data not stored
213 // in reference data
214
215 }
216 }
217 }
218 if (fData){
219 delete fData;
220 fData = 0;
221 }
222
223 return 0;
224}
225//_____________________________________________________________________________
226
227UInt_t AliTOFPreprocessor::ProcessHVandLVdps(TMap *dcsAliasMap)
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
242 // processing DCS HV and LV data points
243
244 if (!dcsAliasMap){
245 Log("No DCS map found: TOF exiting from Shuttle");
246 if (fHVLVmaps){
247 delete fHVLVmaps;
248 fHVLVmaps = 0;
249 }
250 return 100;// return error Code for DCS input data not found
251 }
252 else {
253
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
259 fHVLVmaps->SetFDRFlag(fFDRFlag);
260
261 // The processing of the DCS input data is forwarded to AliTOFDataDCS
262
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 }
270 return 200;// return error Code for processed DCS data not stored
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 }
301
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 }
348
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) {
356 AliInfo("TOF HW status config has not changed. Do not overwrite stored file.");
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");
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");
374 // store TOF channel status
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 }
386 return 17; // return error code for problems while TOF channel status
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}
403
404//_____________________________________________________________________________
405
406UInt_t AliTOFPreprocessor::ProcessOnlineDelays()
407{
408 // Processing data from DAQ for online calibration
409
410 Bool_t updateOCDB = kFALSE;
411 Log("Processing DAQ delays");
412
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 {
461 Log(Form("No IntegralThr value found in Map from Config entry in CDB, using default value: IntegralThr = %f",integralThr));
462 }
463 TObjString *strThrPar = (TObjString*)configMap->GetValue("ThrPar");
464 if (strThrPar) {
465 TString tmpstr = strThrPar->GetString();
466 thrPar = tmpstr.Atof();
467 }
468 else {
469 Log(Form("No ThrPar value found in Map from Config entry in CDB, using default value: ThrPar = %f",thrPar));
470 }
471 }
472 }
473 if (compDelays == "kTRUE") fFDRFlag = kFALSE;
474 else fFDRFlag = kTRUE;
475
476 delete cdbEntry;
477 cdbEntry = 0x0;
478
479 Log(Form("ComputingDelays = %s, StartingRun = %i",compDelays.Data(),startingRun));
480
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
500
501 TH1::AddDirectory(0);
502
503 Bool_t resultDAQRef=kFALSE;
504 Bool_t resultTOFPP=kFALSE;
505 TH2S *h2 = 0x0;
506 // processing DAQ
507
508 TFile * daqFile=0x0;
509
510 if(fStoreRefData){
511 //retrieving data at Run level
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));
519 if (!str) {
520 AliError("dynamic_cast returned NULL");
521 return 4;
522 }
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");
529 h2 = (TH2S*) daqFile->Get("htof");
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");
535 resultDAQRef = StoreReferenceData("Calib","DAQData",h2, &metaDataHisto);
536 if (!resultDAQRef){
537 Log("some problems occurred::No Reference Data stored, TOF exiting from Shuttle");
538 delete h2;
539 delete list;
540 delete fCal;
541 fCal=0x0;
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 ");
550 delete list;
551 delete fCal;
552 fCal=0x0;
553 return 4;//return error code for failure in retrieving Ref Data
554 }
555 }
556 delete list;
557 }
558 else{
559 Log("The input data file list from DAQ (run-level) was not found, TOF exiting from Shuttle ");
560 delete fCal;
561 fCal=0x0;
562 return 4;//return error code for failure in retrieving Ref Data
563 }
564 }
565
566
567 //Total files, with cumulative histos
568
569 TList* listTot = GetFileSources(kDAQ, "DELAYS");
570 if (listTot !=0x0 && listTot->GetEntries()!=0)
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++){
575 TObjString * str = dynamic_cast<TObjString*> (listTot->At(jj));
576 if (!str) {
577 AliError("dynamic_cast returned NULL");
578 return 4;
579 }
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");
588 if (h2) delete h2;
589 h2 = (TH2S*) daqFile->Get("htoftot");
590 if (!h2){
591 Log("some problems occurred:: No histo retrieved, TOF exiting from Shuttle");
592 delete listTot;
593 delete daqFile;
594 delete fCal;
595 fCal=0x0;
596 return 7; //return error code for histograms not existing/junky
597 }
598 else {
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);
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");
604 delete listTot;
605 delete h2;
606 delete daqFile;
607 delete fCal;
608 fCal=0x0;
609 return 7; //return error code for histograms not existing/junky
610 }
611 Int_t nNotStatistics = 0; // number of channel with not enough statistics
612
613 /* FDR flag set. do not compute delays, use nominal cable delays */
614 if (fFDRFlag) {
615
616 Log(" Not computing delays according to flag set in Config entry in OCDB!");
617 FillWithCosmicCalibration(fCal);
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
631 }
632
633 else { // computing delays if not in FDR runs
634
635 updateOCDB = kTRUE; /* always update OCDB when computing delays */
636
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++){
648 h1->SetBinContent(ibin+1,h2->GetBinContent(ich+1,ibin+1));
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 }
697 delete h2;
698 daqFile->Close();
699 delete daqFile;
700 }
701 else{
702 Log("The Cumulative data file from DAQ does not exist, TOF exiting from Shuttle");
703 delete listTot;
704 delete fCal;
705 fCal=0x0;
706 return 6;//return error code for problems in retrieving DAQ data
707 }
708 }
709 delete listTot;
710 }
711 else{
712 Log("Problem: no list for Cumulative data file from DAQ was found, TOF exiting from Shuttle");
713 delete fCal;
714 fCal=0x0;
715 return 6; //return error code for problems in retrieving DAQ data
716 }
717
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
726 daqFile=0;
727 AliCDBMetaData metaData;
728 metaData.SetBeamPeriod(0);
729 metaData.SetResponsible("Chiara Zampolli");
730 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineArray object for online calibration - delays.");
731 AliInfo("Storing Calibration Data");
732 resultTOFPP = Store("Calib","ParOnlineDelay",fCal, &metaData,deltaStartingRun,kTRUE);
733 if(!resultTOFPP){
734 Log("Some problems occurred while storing online object resulting from DAQ data processing");
735 delete fCal;
736 fCal=0x0;
737 return 8;//return error code for problems in storing DAQ data
738 }
739
740 if (fCal){
741 delete fCal;
742 fCal = 0;
743 }
744
745 return 0;
746}
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
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
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!!");
792 return 21;
793 }
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();
888 latencyWindow = fLatencyWindow[index] * 1.e3;
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 */
894
895
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 */
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;
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();
921 Float_t maxBinContent = hT0Fill->GetBinContent(maxBin);
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
931 /* rough fit of the edge */
932 TF1 *gaus = (TF1 *)gROOT->GetFunction("gaus");
933 gaus->SetParameter(1, maxBinCenter);
934 Float_t fitMin = maxBinCenter - 1000.; /* fit from 1 ns before max */
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 }
946 /* print params */
947 mean = gaus->GetParameter(1);
948 sigma = gaus->GetParameter(2);
949 Float_t meane = gaus->GetParError(1);
950 Float_t sigmae = gaus->GetParError(2);
951 Log(Form("edge fit: mean = %f +- %f ps", mean, meane));
952 Log(Form("edge fit: sigma = %f +- %f ps", sigma, sigmae));
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.;
961 }
962
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
968 /* create RunParams object */
969 UInt_t timestamp[1] = {0};
970 Float_t t0[1] = {mean};
971 Float_t tofReso[1] = {sigma};
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);
978 runParamsObject->SetUseLHCClockPhase(kFALSE);
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;
990 delete runParamsObject;
991 return 21;
992 }
993 Log("reference data successfully stored");
994 }
995
996 AliCDBMetaData metaData;
997 metaData.SetBeamPeriod(0);
998 metaData.SetResponsible("Roberto Preghenella");
999 metaData.SetComment("online RunParams measurement");
1000 if (!Store("Calib", "RunParams", runParamsObject, &metaData, 0, kFALSE)) {
1001 Log("error while storing RunParams object");
1002 delete hT0Fill;
1003 delete hit;
1004 delete runParamsObject;
1005 return 21;
1006 }
1007 Log("RunParams object successfully stored");
1008
1009 delete hT0Fill;
1010 delete hit;
1011 delete runParamsObject;
1012 return 0;
1013
1014}
1015
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");
1034 if (!cdbEntry) Log(Form("No Configuration entry found in CDB, using default values: NoiseThr = %f",noiseThr));
1035 else {
1036 TMap *configMap = (TMap*)cdbEntry->GetObject();
1037 if (!configMap) Log(Form("No map found in Config entry in CDB, using default values: NoiseThr = %f", noiseThr));
1038 else {
1039 TObjString *strNoiseThr = (TObjString*)configMap->GetValue("NoiseThr");
1040 if (strNoiseThr) {
1041 TString tmpstr = strNoiseThr->GetString();
1042 noiseThr = tmpstr.Atoi();
1043 }
1044 else Log(Form("No NoiseThr value found in Map from ConfigNoise entry in CDB, using default value: NoiseThr = %f",noiseThr));
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);
1087 /* check error */
1088 if (rate_err == 0.) continue;
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 }
1099 else if ((rate + 3. * rate_err) < noiseThr) {
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}
1127
1128//_____________________________________________________________________________
1129
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
1258UInt_t AliTOFPreprocessor::ProcessPulserData()
1259{
1260 // Processing Pulser Run data for TOF channel status
1261
1262 Log("Processing Pulser");
1263
1264 if (fStatus==0x0){
1265 AliError("No valid fStatus found, some errors must have occurred!!");
1266 return 20;
1267 }
1268
1269 TH1::AddDirectory(0);
1270
1271 Bool_t resultPulserRef=kFALSE;
1272 Bool_t resultPulser=kFALSE;
1273
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++){
1277 htofPulser->SetBinContent(ibin,-1);
1278 }
1279
1280 // processing pulser
1281
1282 TFile * daqFile=0x0;
1283 TH1S *h1=0x0;
1284
1285 //retrieving Pulser data
1286 TList* listPulser = GetFileSources(kDAQ, "PULSER");
1287 if (listPulser !=0x0 && listPulser->GetEntries()!=0)
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));
1295 if (!str) {
1296 AliError("dynamic_cast returned NULL");
1297 return 4;
1298 }
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;
1373 }
1374
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
1385 }
1386 AliDebug(2,Form(" Number of channels processed during pulser run from source %i = %i",jj, nPulserSource));
1387 }
1388 AliDebug(2,Form(" Number of channels processed during pulser run = %i",nPulser));
1389 delete listPulser;
1390 }
1391
1392 else{
1393 Log("The input data file list from DAQ (pulser) was not found, TOF exiting from Shuttle ");
1394 delete htofPulser;
1395 htofPulser = 0x0;
1396 if (fStatus){
1397 delete fStatus;
1398 fStatus = 0;
1399 }
1400 return 10;//return error code for failure in retrieving Ref Data
1401 }
1402
1403 //storing in OCDB
1404
1405 AliCDBMetaData metaData;
1406 metaData.SetBeamPeriod(0);
1407 metaData.SetResponsible("Chiara Zampolli");
1408 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object after a Pulser run.");
1409 AliInfo("Storing Calibration Data from Pulser Run");
1410 resultPulser = Store("Calib","Status",fStatus, &metaData,0,kTRUE);
1411 if(!resultPulser){
1412 Log("Some problems occurred while storing online object resulting from Pulser data processing");
1413 delete htofPulser;
1414 htofPulser = 0x0;
1415 if (fStatus){
1416 delete fStatus;
1417 fStatus = 0;
1418 }
1419 return 11;//return error code for problems in storing Pulser data
1420 }
1421
1422 if(fStoreRefData){
1423
1424 AliCDBMetaData metaDataHisto;
1425 metaDataHisto.SetBeamPeriod(0);
1426 metaDataHisto.SetResponsible("Chiara Zampolli");
1427 metaDataHisto.SetComment("This preprocessor stores the Ref data from a pulser run.");
1428 AliInfo("Storing Reference Data");
1429 resultPulserRef = StoreReferenceData("Calib","PulserData",htofPulser, &metaDataHisto);
1430 if (!resultPulserRef){
1431 Log("some problems occurred::No Reference Data for pulser stored, TOF exiting from Shuttle");
1432 delete htofPulser;
1433 htofPulser = 0x0;
1434 if (fStatus){
1435 delete fStatus;
1436 fStatus = 0;
1437 }
1438 return 9;//return error code for failure in storing Ref Data
1439 }
1440 }
1441
1442 daqFile=0;
1443
1444 delete htofPulser;
1445 htofPulser = 0x0;
1446
1447 if (fStatus){
1448 delete fStatus;
1449 fStatus = 0;
1450 }
1451
1452 return 0;
1453}
1454//_____________________________________________________________________________
1455
1456UInt_t AliTOFPreprocessor::ProcessNoiseData()
1457{
1458
1459 // Processing Noise Run data for TOF channel status
1460
1461 Log("Processing Noise");
1462
1463 if (fStatus==0x0){
1464 AliError("No valid fStatus found, some errors must have occurred!!");
1465 return 20;
1466 }
1467
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) {
1472 Log(Form("No Configuration entry found in CDB, using default values: NoiseThr = %f",noiseThr));
1473 }
1474 else {
1475 TMap *configMap = (TMap*)cdbEntry->GetObject();
1476 if (!configMap){
1477 Log(Form("No map found in Config entry in CDB, using default values: NoiseThr = %f", noiseThr));
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 {
1486 Log(Form("No NoiseThr value found in Map from ConfigNoise entry in CDB, using default value: NoiseThr = %f",noiseThr));
1487 }
1488 }
1489 }
1490
1491 delete cdbEntry;
1492 cdbEntry = 0x0;
1493
1494 TH1::AddDirectory(0);
1495
1496 Bool_t resultNoiseRef=kFALSE;
1497 Bool_t resultNoise=kFALSE;
1498
1499 static const Int_t kSize = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
1500 TH1F * htofNoise = new TH1F("hTOFnoise","histo with signals on TOF during noise", kSize,-0.5,kSize-0.5);
1501 for (Int_t ibin =1;ibin<=kSize;ibin++){
1502 htofNoise->SetBinContent(ibin,-1);
1503 }
1504
1505 // processing noise
1506
1507 TFile * daqFile=0x0;
1508 TH1F * h1=0x0;
1509
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
1519 TList* listNoise = GetFileSources(kDAQ, "NOISE");
1520 if (listNoise !=0x0 && listNoise->GetEntries()!=0)
1521 {
1522 AliInfo("The following sources produced files with the id NOISE");
1523 listNoise->Print();
1524 for (Int_t jj=0;jj<listNoise->GetEntries();jj++){
1525 Int_t nNoiseSource = 0;
1526 TObjString * str = dynamic_cast<TObjString*> (listNoise->At(jj));
1527 if (!str) {
1528 AliError("dynamic_cast returned NULL");
1529 return 4;
1530 }
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){
1541 nNoiseSource++;
1542 // checking the matching window for current channel
1543 if (fMatchingWindow[ibin] == 0){
1544 Log(Form("Matching window for channel %i null, but the channel was read by the LDC! skipping channel, BUT Please check!",ibin));
1545 if ((h1->GetBinContent(ibin+1))!=0) nMatchingWindowNullNonZero++;
1546 if ((h1->GetBinContent(ibin+1))==0) nMatchingWindowNullEqualZero++;
1547 continue;
1548 }
1549 if ((htofNoise->GetBinContent(ibin+1))==-1){
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)));
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 }
1558
1559 Log(Form(" Number of channels processed during noise run from source %i = %i",jj, nNoiseSource));
1560 daqFile->Close();
1561 delete daqFile;
1562 delete h1;
1563 daqFile = 0x0;
1564 h1 = 0x0;
1565
1566 }
1567 else{
1568 Log("The input data file from DAQ (noise) was not found, TOF exiting from Shuttle ");
1569 delete listNoise;
1570 listNoise = 0x0;
1571 delete htofNoise;
1572 htofNoise = 0x0;
1573 if (fStatus){
1574 delete fStatus;
1575 fStatus = 0;
1576 }
1577 if (fMatchingWindow){
1578 delete [] fMatchingWindow;
1579 fMatchingWindow = 0;
1580 }
1581 return 13;//return error code for failure in retrieving Ref Data
1582 }
1583 }
1584 }
1585
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;
1593 }
1594 if (fMatchingWindow){
1595 delete [] fMatchingWindow;
1596 fMatchingWindow = 0;
1597 }
1598 return 13;//return error code for failure in retrieving Ref Data
1599 }
1600
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;
1641
1642 //storing in OCDB
1643
1644 AliCDBMetaData metaData;
1645 metaData.SetBeamPeriod(0);
1646 metaData.SetResponsible("Chiara Zampolli");
1647 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object after a Noise run.");
1648 AliInfo("Storing Calibration Data from Noise Run");
1649 resultNoise = Store("Calib","Status",fStatus, &metaData,0,kTRUE);
1650 if(!resultNoise){
1651 Log("Some problems occurred while storing online object resulting from Noise data processing");
1652 delete htofNoise;
1653 htofNoise = 0x0;
1654 if (fStatus){
1655 delete fStatus;
1656 fStatus = 0;
1657 }
1658 if (fMatchingWindow){
1659 delete [] fMatchingWindow;
1660 fMatchingWindow = 0;
1661 }
1662 return 14;//return error code for problems in storing Noise data
1663 }
1664
1665 if(fStoreRefData){
1666
1667 AliCDBMetaData metaDataHisto;
1668 metaDataHisto.SetBeamPeriod(0);
1669 metaDataHisto.SetResponsible("Chiara Zampolli");
1670 metaDataHisto.SetComment("This preprocessor stores the Ref data from a noise run. ");
1671 AliInfo("Storing Reference Data");
1672 resultNoiseRef = StoreReferenceData("Calib","NoiseData",htofNoise, &metaDataHisto);
1673 if (!resultNoiseRef){
1674 Log("some problems occurred::No Reference Data for noise stored");
1675 delete htofNoise;
1676 htofNoise = 0x0;
1677 if (fStatus){
1678 delete fStatus;
1679 fStatus = 0;
1680 }
1681 if (fMatchingWindow){
1682 delete [] fMatchingWindow;
1683 fMatchingWindow = 0;
1684 }
1685 return 12;//return error code for failure in storing Ref Data
1686 }
1687 }
1688
1689 delete htofNoise;
1690 htofNoise = 0x0;
1691
1692 if (fStatus){
1693 delete fStatus;
1694 fStatus = 0;
1695 }
1696
1697 if (fMatchingWindow){
1698 delete [] fMatchingWindow;
1699 fMatchingWindow = 0;
1700 }
1701
1702 return 0;
1703}
1704//_____________________________________________________________________________
1705
1706UInt_t AliTOFPreprocessor::ProcessFEEData()
1707{
1708 // Processing Pulser Run data for TOF channel status
1709 // dummy for the time being
1710
1711 Log("Processing FEE");
1712
1713 //Bool_t updateOCDB = kFALSE;
1714 AliTOFFEEReader feeReader;
1715
1716 TH1C hCurrentFEE("hCurrentFEE","histo with current FEE channel status", fNChannels, 0, fNChannels);
1717
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,
1730 * fill current FEE histogram and set FEE status */
1731
1732 const char * nameFile = GetFile(kDCS,"TofFeeLightMap","");
1733 AliInfo(Form("toffeeLight file name = %s",nameFile));
1734 if (nameFile == NULL) {
1735 return 15;
1736 }
1737 feeReader.LoadFEElightConfig(nameFile);
1738 Int_t parseFee = feeReader.ParseFEElightConfig();
1739 AliDebug(2,Form("%i enabled channels found in FEElight configuration",parseFee));
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
1744 fMatchingWindow = new Int_t[fNChannels];
1745 fLatencyWindow = new Int_t[fNChannels];
1746
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);
1754 //updateOCDB = kTRUE;
1755 fIsStatusMapChanged = kTRUE;
1756 }
1757 else {
1758 if (cdbEntry) cdbEntry->SetOwner(kFALSE);
1759 /* CDB entry OK. loop over channels */
1760 fStatus = (AliTOFChannelOnlineStatusArray*) cdbEntry->GetObject();
1761 delete cdbEntry;
1762 cdbEntry = 0x0;
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);
1771 //updateOCDB = kTRUE;
1772 fIsStatusMapChanged = kTRUE;
1773 }
1774 }
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)));
1780 fMatchingWindow[iChannel] = feeReader.GetMatchingWindow(iChannel);
1781 fLatencyWindow[iChannel] = feeReader.GetLatencyWindow(iChannel);
1782 if (feeReader.IsChannelEnabled(iChannel)) {
1783 hCurrentFEE.SetBinContent(iChannel + 1, 1);
1784 if (fStatus->GetHWStatus(iChannel)!=AliTOFChannelOnlineStatusArray::kTOFHWOk){
1785 //updateOCDB = kTRUE;
1786 fIsStatusMapChanged = kTRUE;
1787 fStatus->SetHWStatus(iChannel,AliTOFChannelOnlineStatusArray::kTOFHWOk);
1788 AliDebug(3,Form( " changed into enabled: channel %i status after FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
1789 }
1790 if (fStatus->GetLatencyWindow(iChannel)!=fLatencyWindow[iChannel]){
1791 //updateOCDB = kTRUE;
1792 fIsStatusMapChanged = kTRUE;
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 }
1796 }
1797 else {
1798 if (fStatus->GetHWStatus(iChannel)!=AliTOFChannelOnlineStatusArray::kTOFHWBad){
1799 //updateOCDB = kTRUE;
1800 fIsStatusMapChanged = kTRUE;
1801 fStatus->SetHWStatus(iChannel,AliTOFChannelOnlineStatusArray::kTOFHWBad);
1802 AliDebug(3,Form( " changed into disabled: channel %i status after FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
1803 }
1804 }
1805 }
1806
1807
1808 /* check whether we don't have to store reference data.
1809 * in this case we return without errors. */
1810 if (fStoreRefData) {
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 }
1840 }
1841
1842 return 0;
1843
1844}
1845
1846//_____________________________________________________________________________
1847
1848UInt_t AliTOFPreprocessor::Process(TMap *dcsAliasMap)
1849{
1850 //
1851 // Main AliTOFPreprocessor method called by SHUTTLE
1852 //
1853
1854 TString runType = GetRunType();
1855 Log(Form("RunType %s",runType.Data()));
1856
1857 // processing
1858
1859 /* always process FEE data */
1860 Int_t iresultFEE = ProcessFEEData();
1861 if (iresultFEE != 0)
1862 return iresultFEE;
1863
1864 if (runType == "PULSER") {
1865 Int_t iresultPulser = ProcessPulserData();
1866 return iresultPulser;
1867 }
1868
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 }
1873
1874 if (runType == "PHYSICS") {
1875 // Int_t iresultDAQ = ProcessOnlineDelays();
1876 Int_t iresultDAQ = ProcessT0Fill();
1877 Int_t iresultNoiseCalib = ProcessNoiseCalibTrg();
1878 Int_t iresultReadout = ProcessReadout();
1879 Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
1880 Int_t iResultHVandLVdps = ProcessHVandLVdps(dcsAliasMap);
1881 return iresultDAQ+iresultNoiseCalib+iresultDCS+iResultHVandLVdps+iresultReadout;
1882 }
1883
1884 // storing
1885 return 0;
1886}
1887
1888
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;
1901 calibHisto.SetFullCorrectionFlag(AliTOFcalibHisto::kTimeSlewingCorr, kFALSE);
1902 Log(Form(" loading calibration histograms from %s", calibHisto.GetCalibHistoFileName()));
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++) {
1908 cal->SetDelay(iIndex, calibHisto.GetFullCorrection(iIndex));
1909 }
1910
1911}
1912
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);
1956 if (index < 0) continue;
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