Cross library dependency removed
[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"
ea932f75 38#include "AliTOFLvHvDataPoints.h"
10056aa6 39#include "AliTOFGeometry.h"
9edefa04 40#include "AliTOFPreprocessor.h"
db83b789 41#include "AliTOFFEEReader.h"
3dda26a0 42#include "AliTOFRawStream.h"
43#include "AliTOFCableLengthMap.h"
b06d5296 44#include "AliTOFcalibHisto.h"
69355034 45#include "AliTOFFEEDump.h"
3dda26a0 46
c9fe8530 47
c9fe8530 48// TOF preprocessor class.
49// It takes data from DCS and passes them to the class AliTOFDataDCS, which
50// processes them. The result is then written to the CDB.
17149e6b 51// Analogously, it takes data form DAQ (both at Run level and inclusive -
c9fe8530 52// of all the runs - level, processes them, and stores both Reference Data
53// and Online Calibration files in the CDB.
17149e6b 54// Processing of Pulser/Noise Run data and of TOF FEE DCS map included also.
7fffa85b 55
56// return codes:
57// return=0 : all ok
58// return=1 : no DCS input data Map
59// return=2 : no DCS input data processing
60// return=3 : no DCS processed data was stored in Ref Data
61// return=4 : no DAQ input for Ref Data
62// return=5 : failed to store DAQ Ref Data
63// return=6 : failed to retrieve DAQ data for calibration
64// return=7 : problems in processing histos in the input DAQ file
65// return=8 : failed to store Online Delays
66// return=9 : failed to store Reference Data for Pulser
67// return=10: failed to retrieve Pulser data
68// return=11: failed to store Pulser map in OCDB
69// return=12: failed to store Reference Data for Noise
70// return=13: failed to retrieve Noise data
71// return=14: failed to store Noise map in OCDB
db83b789 72// return=15: failed to retrieve FEE data from FXS
73// return=16: failed to retrieve FEE data from OCDB
74// return=17: failed to store FEE data in OCDB
75// return=18: failed to store FEE reference data in OCDB
17149e6b 76// return=20: failed in retrieving status variable
c9fe8530 77
78ClassImp(AliTOFPreprocessor)
79
7fffa85b 80const Int_t AliTOFPreprocessor::fgkBinRangeAve = 13; // number of bins where to calculate the mean
81const Double_t AliTOFPreprocessor::fgkIntegralThr = 100; // min number of entries to perform computation of delay per channel
82const Double_t AliTOFPreprocessor::fgkThrPar = 0.013; // parameter used to trigger the calculation of the delay
c9fe8530 83
84//_____________________________________________________________________________
85
708db10b 86AliTOFPreprocessor::AliTOFPreprocessor(AliShuttleInterface* shuttle) :
87 AliPreprocessor("TOF", shuttle),
c9fe8530 88 fData(0),
ea932f75 89 fHVLVmaps(0),
c9fe8530 90 fCal(0),
10056aa6 91 fNChannels(0),
7fffa85b 92 fStoreRefData(kTRUE),
17149e6b 93 fFDRFlag(kFALSE),
013ac2dd 94 fStatus(0),
02ede0c4 95 fMatchingWindow(0),
ea932f75 96 fLatencyWindow(0),
97 fIsStatusMapChanged(0)
c9fe8530 98{
99 // constructor
370aeff7 100 AddRunType("PHYSICS");
101 AddRunType("PULSER");
102 AddRunType("NOISE");
10056aa6 103
c9fe8530 104}
105
106//_____________________________________________________________________________
107
108AliTOFPreprocessor::~AliTOFPreprocessor()
109{
110 // destructor
111}
112
113//______________________________________________________________________________
114void AliTOFPreprocessor::Initialize(Int_t run, UInt_t startTime,
115 UInt_t endTime)
116{
117 // Creates AliTOFDataDCS object
118
119 AliPreprocessor::Initialize(run, startTime, endTime);
120
ff326f84 121 AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", run,
c9fe8530 122 TTimeStamp(startTime).AsString(),
ff326f84 123 TTimeStamp(endTime).AsString(), ((TTimeStamp)GetStartTimeDCSQuery()).AsString(), ((TTimeStamp)GetEndTimeDCSQuery()).AsString()));
c9fe8530 124
ff326f84 125 fData = new AliTOFDataDCS(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
ea932f75 126 fHVLVmaps = new AliTOFLvHvDataPoints(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
10056aa6 127 fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
c9fe8530 128}
7fffa85b 129//_____________________________________________________________________________
130Bool_t AliTOFPreprocessor::ProcessDCS(){
131
132 // check whether DCS should be processed or not...
c9fe8530 133
7fffa85b 134 TString runType = GetRunType();
135 Log(Form("RunType %s",runType.Data()));
136
55454922 137 if (runType != "PHYSICS"){
7fffa85b 138 return kFALSE;
139 }
140
141 return kTRUE;
142}
c9fe8530 143//_____________________________________________________________________________
144
ea932f75 145UInt_t AliTOFPreprocessor::ProcessDCSDataPoints(TMap * const dcsAliasMap)
c9fe8530 146{
147 // Fills data into a AliTOFDataDCS object
148
7fffa85b 149
150 Log("Processing DCS DP");
708db10b 151 TH1::AddDirectory(0);
5936ab02 152
7885c291 153 Bool_t resultDCSMap=kFALSE;
154 Bool_t resultDCSStore=kFALSE;
c9fe8530 155
156 // processing DCS
157
4856f488 158 fData->SetFDRFlag(fFDRFlag);
159
c9fe8530 160 if (!dcsAliasMap){
5936ab02 161 Log("No DCS map found: TOF exiting from Shuttle");
e88f3330 162 if (fData){
163 delete fData;
164 fData = 0;
165 }
5936ab02 166 return 1;// return error Code for DCS input data not found
c9fe8530 167 }
168 else {
4856f488 169
c9fe8530 170 // The processing of the DCS input data is forwarded to AliTOFDataDCS
7885c291 171 resultDCSMap=fData->ProcessData(*dcsAliasMap);
172 if(!resultDCSMap){
173 Log("Some problems occurred while processing DCS data, TOF exiting from Shuttle");
e88f3330 174 if (fData){
175 delete fData;
176 fData = 0;
177 }
5936ab02 178 return 2;// return error Code for processed DCS data not stored
c9fe8530 179 }
7885c291 180 else{
181 AliCDBMetaData metaDataDCS;
182 metaDataDCS.SetBeamPeriod(0);
183 metaDataDCS.SetResponsible("Chiara Zampolli");
184 metaDataDCS.SetComment("This preprocessor fills an AliTOFDataDCS object.");
185 AliInfo("Storing DCS Data");
b0d8f3fc 186 resultDCSStore = StoreReferenceData("Calib","DCSData",fData, &metaDataDCS);
7885c291 187 if (!resultDCSStore){
b0d8f3fc 188 Log("Some problems occurred while storing DCS data results in Reference Data, TOF exiting from Shuttle");
e88f3330 189 if (fData){
190 delete fData;
191 fData = 0;
192 }
7885c291 193 return 3;// return error Code for processed DCS data not stored
b0d8f3fc 194 // in reference data
7885c291 195
196 }
197 }
c9fe8530 198 }
e88f3330 199 if (fData){
200 delete fData;
201 fData = 0;
202 }
203
ee3e792b 204 return 0;
205}
206//_____________________________________________________________________________
207
ea932f75 208UInt_t AliTOFPreprocessor::ProcessHVandLVdps(TMap * const dcsAliasMap)
209{
210 //
211 //Fills data into a AliTOFLvHvDataPoints object
212 // Merges fStatus object with LV and HV status at SOR
213 // Updates fStatus object with LV and HV status
214 // at EOR in case of correct end of run
215 // at last but two value in case of end-of-run caused by TOF detector.
216 //
217
218 Log("Processing HV and LV DCS DPs");
219 TH1::AddDirectory(0);
220
221 Bool_t resultDCSMap=kFALSE;
222
223 // processing DCS
224
225 fHVLVmaps->SetFDRFlag(fFDRFlag);
226
227 if (!dcsAliasMap){
228 Log("No DCS map found: TOF exiting from Shuttle");
229 if (fHVLVmaps){
230 delete fHVLVmaps;
231 fHVLVmaps = 0;
232 }
233 return 1;// return error Code for DCS input data not found
234 }
235 else {
236
237 // The processing of the DCS input data is forwarded to AliTOFDataDCS
238 resultDCSMap = fHVLVmaps->ProcessData(*dcsAliasMap);
239 if (!resultDCSMap) {
240 Log("Some problems occurred while processing DCS data, TOF exiting from Shuttle");
241 if (fHVLVmaps) {
242 delete fHVLVmaps;
243 fHVLVmaps = 0;
244 }
245 return 2;// return error Code for processed DCS data not stored
246 }
247 else {
248
249 // check with plots. Start...
250 /*
251 TH1F *hROsor = new TH1F("hROsor","RO status map at SOR",91*96*18,-0.5,91*96*18-0.5);
252 for (Int_t ii=1; ii<=91*96*18; ii++) hROsor->SetBinContent(ii,-1);
253 for (Int_t ii=0; ii<91*96*18; ii++) {
254 if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWBad)
255 hROsor->SetBinContent(ii+1,0);
256 else if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWOk)
257 hROsor->SetBinContent(ii+1,1);
258 }
259
260 TH1F *hROandHVandLVsor = new TH1F("hROandHVandLVsor","RO.and.HV.andLV status map at SOR",91*96*18,-0.5,91*96*18-0.5);
261 for (Int_t ii=1; ii<=91*96*18; ii++) hROandHVandLVsor->SetBinContent(ii,-1);
262 TH1F *hROandHVandLVeor = new TH1F("hROandHVandLVeor","RO.and.HV.andLV status map at EOR",91*96*18,-0.5,91*96*18-0.5);
263 for (Int_t ii=1; ii<=91*96*18; ii++) hROandHVandLVeor->SetBinContent(ii,-1);
264 */
265
266 AliTOFDCSmaps * lvANDhvMap = (AliTOFDCSmaps*)fHVLVmaps->GetHVandLVmapAtSOR(); // Get LV.and.HV status map at SOR
267 for (Int_t index=0; index<fNChannels; index++) {
268 if ( ( lvANDhvMap->GetCellValue(index)==0 &&
269 fStatus->GetHWStatus(index) != AliTOFChannelOnlineStatusArray::kTOFHWBad ) ||
270 ( lvANDhvMap->GetCellValue(index)==1 &&
271 fStatus->GetHWStatus(index) != AliTOFChannelOnlineStatusArray::kTOFHWOk ) ) {
272 fStatus->SetHWStatus(index, AliTOFChannelOnlineStatusArray::kTOFHWBad);
273 fIsStatusMapChanged=kTRUE;
274 }
275 }
276
277 // check with plots. Start...
278 /*
279 for (Int_t ii=0; ii<91*96*18; ii++) {
280 if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWBad)
281 hROandHVandLVsor->SetBinContent(ii+1,0);
282 else if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWOk)
283 hROandHVandLVsor->SetBinContent(ii+1,1);
284 }
285 */
286
287 lvANDhvMap = (AliTOFDCSmaps*)fHVLVmaps->GetHVandLVmapAtEOR(); // Get LV.and.HV status map at EOR
288 for (Int_t index=0; index<fNChannels; index++) {
289 if ( ( lvANDhvMap->GetCellValue(index)==0 &&
290 fStatus->GetHWStatus(index)!=AliTOFChannelOnlineStatusArray::kTOFHWBad ) ||
291 ( lvANDhvMap->GetCellValue(index)==1 &&
292 fStatus->GetHWStatus(index) != AliTOFChannelOnlineStatusArray::kTOFHWOk ) ) {
293 fStatus->SetHWStatus(index, AliTOFChannelOnlineStatusArray::kTOFHWBad);
294 fIsStatusMapChanged=kTRUE;
295 }
296 }
297
298 // check with plots. Start...
299 /*
300 for (Int_t ii=0; ii<91*96*18; ii++) {
301 if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWBad)
302 hROandHVandLVeor->SetBinContent(ii+1,0);
303 else if (fStatus->GetHWStatus(ii)==AliTOFChannelOnlineStatusArray::kTOFHWOk)
304 hROandHVandLVeor->SetBinContent(ii+1,1);
305 }
306
307 TCanvas *canvas = new TCanvas("canvas","",10,10,1000,1000);
308 canvas->SetFillColor(0);
309 canvas->Divide(2,2);
310 canvas->cd(1);
311 hROsor->SetLineWidth(2);
312 hROsor->Draw();
313 canvas->cd(2);
314 hROandHVandLVsor->SetLineWidth(2);
315 hROandHVandLVsor->Draw();
316 canvas->cd(3);
317 hROandHVandLVeor->SetLineWidth(2);
318 hROandHVandLVeor->Draw();
319 canvas->cd();
320 */
321
322 }
323 }
324
325
326 /* check whether we don't need to update OCDB.
327 * in this case we can return without errors. */
328
329 if (!fIsStatusMapChanged) {
330 AliInfo("TOF FEE config has not changed. Do not overwrite stored file.");
331 return 0; // return ok
332 }
333
334 TString runType = GetRunType();
335 if (runType != "PHYSICS") {
336 AliInfo(Form("Run Type = %s, waiting to store status map",GetRunType()));
337 return 0; // return ok
338 }
339
340 // update the OCDB with the current FEE.and.HV.and.LV
341 // since even a little difference has been detected.
342
343 AliCDBMetaData metaData;
344 metaData.SetBeamPeriod(0);
345 metaData.SetResponsible("Roberto Preghenella");
346 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object from FEE.and.HV.and.LV data.");
347 AliInfo("Storing Status data from current run. Collected RO.and.HV.and.LV infos @ EOR");
348 // store FEE data
349 if (!Store("Calib", "Status", fStatus, &metaData, 0, kTRUE)) {
350 // failed
351 Log("problems while storing RO.and.HV.and.LV Status data object");
352 if (fStatus){
353 delete fStatus;
354 fStatus = 0;
355 }
356 if (fHVLVmaps) {
357 delete fHVLVmaps;
358 fHVLVmaps = 0;
359 }
360 return 17; // return error code for problems while storing FEE data
361 }
362
363 // everything fine. return
364
365 if (fStatus){
366 delete fStatus;
367 fStatus = 0;
368 }
369
370 if (fHVLVmaps) {
371 delete fHVLVmaps;
372 fHVLVmaps = 0;
373 }
374
375 return 0;
376}
377//_____________________________________________________________________________
378
ee3e792b 379UInt_t AliTOFPreprocessor::ProcessOnlineDelays()
380{
7fffa85b 381 // Processing data from DAQ for online calibration
382
965fa008 383 Bool_t updateOCDB = kFALSE;
7fffa85b 384 Log("Processing DAQ delays");
ee3e792b 385
17149e6b 386 // reading configuration map
387 TString compDelays = "kFALSE";
388 Int_t deltaStartingRun = fRun;
389 Int_t startingRun = fRun-deltaStartingRun;
390 Int_t binRangeAve = fgkBinRangeAve;
391 Double_t integralThr = fgkIntegralThr;
392 Double_t thrPar = fgkThrPar;
393
394 AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Config");
395 if (!cdbEntry) {
396 Log(Form("No Configuration entry found in CDB, using default values: ComputingDelays = %s, StartingRun = %i",compDelays.Data(), startingRun));
397 }
398 else {
399 TMap *configMap = (TMap*)cdbEntry->GetObject();
400 if (!configMap){
401 Log(Form("No map found in Config entry in CDB, using default values: ComputingDelays = %s, StartingRun = %i",compDelays.Data(), startingRun));
402 }
403 else{
404 TObjString *strDelays = (TObjString*)configMap->GetValue("ComputingDelays");
405 if (strDelays) {
406 compDelays = (TString) strDelays->GetString();
407 }
408 else {
409 Log(Form("No ComputingDelays value found in Map from Config entry in CDB, using default value: ComputingDelays = %s",compDelays.Data()));
410 }
411 TObjString *strRun = (TObjString*)configMap->GetValue("StartingRun");
412 if (strRun) {
413 TString tmpstr = strRun->GetString();
414 startingRun = tmpstr.Atoi();
415 deltaStartingRun = fRun - startingRun;
416 }
417 else {
418 Log(Form("No StartingRun value found in Map from Config entry in CDB, using default value: StartingRun = %i",startingRun));
419 }
420 TObjString *strBinRangeAve = (TObjString*)configMap->GetValue("BinRangeAve");
421 if (strBinRangeAve) {
422 TString tmpstr = strBinRangeAve->GetString();
423 binRangeAve = tmpstr.Atoi();
424 }
425 else {
426 Log(Form("No BinRangeAve value found in Map from Config entry in CDB, using default value: BinRangeAve = %i",binRangeAve));
427 }
428 TObjString *strIntegralThr = (TObjString*)configMap->GetValue("IntegralThr");
429 if (strIntegralThr) {
430 TString tmpstr = strIntegralThr->GetString();
431 integralThr = tmpstr.Atof();
432 }
433 else {
434 Log(Form("No IntegralThr value found in Map from Config entry in CDB, using default value: IntegralThr = %i",integralThr));
435 }
436 TObjString *strThrPar = (TObjString*)configMap->GetValue("ThrPar");
437 if (strThrPar) {
438 TString tmpstr = strThrPar->GetString();
439 thrPar = tmpstr.Atof();
440 }
441 else {
442 Log(Form("No ThrPar value found in Map from Config entry in CDB, using default value: ThrPar = %i",thrPar));
443 }
444 }
445 }
446 if (compDelays == "kTRUE") fFDRFlag = kFALSE;
447 else fFDRFlag = kTRUE;
448
e88f3330 449 delete cdbEntry;
450 cdbEntry = 0x0;
451
17149e6b 452 Log(Form("ComputingDelays = %s, StartingRun = %i",compDelays.Data(),startingRun));
453
965fa008 454 /* init array with current calibration, if any */
455 fCal = new AliTOFChannelOnlineArray(fNChannels);
456 AliTOFChannelOnlineArray *curCal = NULL;
457
458 AliCDBEntry *cdbEntry2 = GetFromOCDB("Calib","ParOnlineDelay");
459 if (!cdbEntry2 || !cdbEntry2->GetObject()) {
460 /* no CDB entry found. set update flag */
461 Log(" ************ WARNING ************");
462 Log("No CDB ParOnlineDelay entry found, creating a new one!");
463 Log(" *********************************");
464 updateOCDB = kTRUE;
465 }
466 else {
467 Log("Found previous ParOnlineDelay entry. Using it to init calibration");
468 curCal = (AliTOFChannelOnlineArray *)cdbEntry2->GetObject();
469 for (Int_t i = 0; i < fNChannels; i++)
470 fCal->SetDelay(i, curCal->GetDelay(i));
471 }
472
17149e6b 473
ee3e792b 474 TH1::AddDirectory(0);
475
476 Bool_t resultDAQRef=kFALSE;
7fffa85b 477 Bool_t resultTOFPP=kFALSE;
e88f3330 478 TH2S *h2 = 0x0;
c9fe8530 479 // processing DAQ
7885c291 480
c9fe8530 481 TFile * daqFile=0x0;
7885c291 482
5936ab02 483 if(fStoreRefData){
484 //retrieving data at Run level
17149e6b 485 TList* list = GetFileSources(kDAQ, "RUNLevel");
486 if (list !=0x0 && list->GetEntries()!=0)
487 {
488 AliInfo("The following sources produced files with the id RUNLevel");
489 list->Print();
490 for (Int_t jj=0;jj<list->GetEntries();jj++){
491 TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
492 AliInfo(Form("found source %s", str->String().Data()));
493 // file to be stored run per run
494 TString fileNameRun = GetFile(kDAQ, "RUNLevel", str->GetName());
495 if (fileNameRun.Length()>0){
496 AliInfo(Form("Got the file %s, now we can store the Reference Data for the current Run.", fileNameRun.Data()));
497 daqFile = new TFile(fileNameRun.Data(),"READ");
e88f3330 498 h2 = (TH2S*) daqFile->Get("htof");
17149e6b 499 AliCDBMetaData metaDataHisto;
500 metaDataHisto.SetBeamPeriod(0);
501 metaDataHisto.SetResponsible("Chiara Zampolli");
502 metaDataHisto.SetComment("This preprocessor stores the array of histos object as Reference Data.");
503 AliInfo("Storing Reference Data");
e88f3330 504 resultDAQRef = StoreReferenceData("Calib","DAQData",h2, &metaDataHisto);
17149e6b 505 if (!resultDAQRef){
506 Log("some problems occurred::No Reference Data stored, TOF exiting from Shuttle");
e88f3330 507 delete h2;
508 delete list;
509 delete fCal;
510 fCal=0x0;
17149e6b 511 return 5;//return error code for failure in storing Ref Data
512 }
513 daqFile->Close();
514 delete daqFile;
515 }
516
517 else{
518 Log("The input data file from DAQ (run-level) was not found, TOF exiting from Shuttle ");
e88f3330 519 delete list;
520 delete fCal;
521 fCal=0x0;
17149e6b 522 return 4;//return error code for failure in retrieving Ref Data
523 }
524 }
525 delete list;
526 }
5936ab02 527 else{
17149e6b 528 Log("The input data file list from DAQ (run-level) was not found, TOF exiting from Shuttle ");
e88f3330 529 delete fCal;
530 fCal=0x0;
17149e6b 531 return 4;//return error code for failure in retrieving Ref Data
532 }
9bc469d1 533 }
534
9bc469d1 535
17149e6b 536 //Total files, with cumulative histos
5936ab02 537
9bc469d1 538 TList* listTot = GetFileSources(kDAQ, "DELAYS");
bf76be9c 539 if (listTot !=0x0 && listTot->GetEntries()!=0)
17149e6b 540 {
541 AliInfo("The following sources produced files with the id DELAYS");
542 listTot->Print();
543 for (Int_t jj=0;jj<listTot->GetEntries();jj++){
544 TObjString * str = dynamic_cast<TObjString*> (listTot->At(jj));
545 AliInfo(Form("found source %s", str->String().Data()));
546
547 // file with summed histos, to extract calib params
548 TString fileName = GetFile(kDAQ, "DELAYS", str->GetName());
549 if (fileName.Length()>0){
550 AliInfo(Form("Got the file %s, now we can extract some values.", fileName.Data()));
551
552 daqFile = new TFile(fileName.Data(),"READ");
e88f3330 553 if (h2) delete h2;
554 h2 = (TH2S*) daqFile->Get("htoftot");
555 if (!h2){
17149e6b 556 Log("some problems occurred:: No histo retrieved, TOF exiting from Shuttle");
e88f3330 557 delete listTot;
17149e6b 558 delete daqFile;
e88f3330 559 delete fCal;
560 fCal=0x0;
17149e6b 561 return 7; //return error code for histograms not existing/junky
562 }
563 else {
e88f3330 564 static const Int_t kSize=h2->GetNbinsX();
565 static const Int_t kNBins=h2->GetNbinsY();
566 static const Double_t kXBinmin=h2->GetYaxis()->GetBinLowEdge(1);
17149e6b 567 if (kSize != fNChannels){
568 Log(" number of bins along x different from number of pads, found only a subset of the histograms, TOF exiting from Shuttle");
e88f3330 569 delete listTot;
570 delete h2;
17149e6b 571 delete daqFile;
e88f3330 572 delete fCal;
573 fCal=0x0;
17149e6b 574 return 7; //return error code for histograms not existing/junky
575 }
576 Int_t nNotStatistics = 0; // number of channel with not enough statistics
3dda26a0 577
b06d5296 578 /* FDR flag set. do not compute delays, use nominal cable delays */
3dda26a0 579 if (fFDRFlag) {
580
581 Log(" Not computing delays according to flag set in Config entry in OCDB!");
b06d5296 582 FillWithCosmicCalibration(fCal);
965fa008 583
584 /* check whether the new calibration is different from the previous one */
585 if (curCal) { /* well, check also whether we have a previous calibration */
586 for (Int_t i = 0; i < fNChannels; i++) {
587 if (fCal->GetDelay(i) != curCal->GetDelay(i)) {
588 updateOCDB = kTRUE;
589 break;
590 }
591 }
592 }
593 else /* otherwise update OCDB */
594 updateOCDB = kTRUE;
595
3dda26a0 596 }
17149e6b 597
598 else { // computing delays if not in FDR runs
965fa008 599
600 updateOCDB = kTRUE; /* always update OCDB when computing delays */
601
17149e6b 602 for (Int_t ich=0;ich<kSize;ich++){
603 /* check whether channel has been read out during current run.
604 * if the status is bad it means it has not been read out.
605 * in this case skip channel in order to not affect the mean */
606 if (fStatus->GetHWStatus(ich) == AliTOFChannelOnlineStatusArray::kTOFHWBad){
607 AliDebug(2,Form(" Channel %i found bad according to FEEmap, (HW status = %i), skipping from delay computing",ich, (Int_t)fStatus->GetHWStatus(ich)));
608 continue;
609 }
610 AliDebug(2,Form(" Channel %i found ok according to FEEmap, starting delay computing",ich));
611 TH1S *h1 = new TH1S("h1","h1",kNBins,kXBinmin-0.5,kNBins*1.+kXBinmin-0.5);
612 for (Int_t ibin=0;ibin<kNBins;ibin++){
e88f3330 613 h1->SetBinContent(ibin+1,h2->GetBinContent(ich+1,ibin+1));
17149e6b 614 }
615 if(h1->Integral()<integralThr) {
616 nNotStatistics++;
617 Log(Form(" Not enough statistics for bin %i, skipping this channel",ich)); // printing message only if not in FDR runs
618 delete h1;
619 h1=0x0;
620 continue;
621 }
622 Bool_t found=kFALSE;
623 Float_t minContent=h1->Integral()*thrPar;
624 Int_t nbinsX = h1->GetNbinsX();
625 Int_t startBin=1;
626 for (Int_t j=1; j<=nbinsX; j++){
627 if ((
628 h1->GetBinContent(j) +
629 h1->GetBinContent(j+1)+
630 h1->GetBinContent(j+2)+
631 h1->GetBinContent(j+3))>minContent){
632 found=kTRUE;
633 startBin=j;
634 break;
635 }
636 }
637 if(!found) AliInfo(Form("WARNING!!! no start of fit found for histo # %i",ich));
638 // Now calculate the mean over the interval.
639 Double_t mean = 0;
640 Double_t sumw2 = 0;
641 Double_t nent = 0;
642 for(Int_t k=0;k<binRangeAve;k++){
643 mean=mean+h1->GetBinCenter(startBin+k)*h1->GetBinContent(startBin+k);
644 nent=nent+h1->GetBinContent(startBin+k);
645 sumw2=sumw2+(h1->GetBinCenter(startBin+k))*(h1->GetBinCenter(startBin+k))*(h1->GetBinContent(startBin+k));
646 }
647 mean= mean/nent; //<x>
648 sumw2=sumw2/nent; //<x^2>
649 Double_t rmsmean= 0;
650 rmsmean = TMath::Sqrt((sumw2-mean*mean)/nent);
651 if (ich<fNChannels) {
652 Float_t delay = mean*AliTOFGeometry::TdcBinWidth()*1.E-3; // delay in ns
653 fCal->SetDelay(ich,delay); // delay in ns
654 AliDebug(2,Form("Setting delay %f (ns) for channel %i",delay,ich));
655 }
656 delete h1;
657 h1=0x0;
658 }
659 }
660 if (nNotStatistics!=0) Log(Form("Too little statistics for %d channels!",nNotStatistics));
661 }
e88f3330 662 delete h2;
17149e6b 663 daqFile->Close();
664 delete daqFile;
665 }
666 else{
667 Log("The Cumulative data file from DAQ does not exist, TOF exiting from Shuttle");
e88f3330 668 delete listTot;
669 delete fCal;
670 fCal=0x0;
17149e6b 671 return 6;//return error code for problems in retrieving DAQ data
672 }
7fffa85b 673 }
17149e6b 674 delete listTot;
c9fe8530 675 }
c9fe8530 676 else{
9d883ed9 677 Log("Problem: no list for Cumulative data file from DAQ was found, TOF exiting from Shuttle");
e88f3330 678 delete fCal;
679 fCal=0x0;
7885c291 680 return 6; //return error code for problems in retrieving DAQ data
c9fe8530 681 }
682
965fa008 683 /* check whether we don't need to update OCDB.
684 * in this case we can return without errors and
685 * the current FEE is stored in the fStatus object. */
686 if (!updateOCDB) {
687 AliInfo("update OCDB flag not set. Do not overwrite stored file.");
688 return 0; /* return ok */
689 }
690
c9fe8530 691 daqFile=0;
7fffa85b 692 AliCDBMetaData metaData;
693 metaData.SetBeamPeriod(0);
694 metaData.SetResponsible("Chiara Zampolli");
17149e6b 695 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineArray object for online calibration - delays.");
7fffa85b 696 AliInfo("Storing Calibration Data");
17149e6b 697 resultTOFPP = Store("Calib","ParOnlineDelay",fCal, &metaData,deltaStartingRun,kTRUE);
7fffa85b 698 if(!resultTOFPP){
699 Log("Some problems occurred while storing online object resulting from DAQ data processing");
e88f3330 700 delete fCal;
701 fCal=0x0;
7fffa85b 702 return 8;//return error code for problems in storing DAQ data
703 }
9d883ed9 704
e88f3330 705 if (fCal){
706 delete fCal;
707 fCal = 0;
708 }
709
5936ab02 710 return 0;
c9fe8530 711}
ee3e792b 712//_____________________________________________________________________________
713
714UInt_t AliTOFPreprocessor::ProcessPulserData()
715{
7fffa85b 716 // Processing Pulser Run data for TOF channel status
717
718 Log("Processing Pulser");
ee3e792b 719
17149e6b 720 if (fStatus==0x0){
721 AliError("No valid fStatus found, some errors must have occurred!!");
722 return 20;
723 }
ee3e792b 724
17149e6b 725 TH1::AddDirectory(0);
726
ee3e792b 727 Bool_t resultPulserRef=kFALSE;
7fffa85b 728 Bool_t resultPulser=kFALSE;
17149e6b 729
a174d599 730 static const Int_t kSize = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
731 TH1S * htofPulser = new TH1S("hTOFpulser","histo with signals on TOF during pulser", kSize,-0.5,kSize-0.5);
732 for (Int_t ibin =1;ibin<=kSize;ibin++){
17149e6b 733 htofPulser->SetBinContent(ibin,-1);
7fffa85b 734 }
17149e6b 735
ee3e792b 736 // processing pulser
737
738 TFile * daqFile=0x0;
739 TH1S *h1=0x0;
740
741 //retrieving Pulser data
742 TList* listPulser = GetFileSources(kDAQ, "PULSER");
bf76be9c 743 if (listPulser !=0x0 && listPulser->GetEntries()!=0)
e88f3330 744 {
745 AliInfo("The following sources produced files with the id PULSER");
746 listPulser->Print();
747 Int_t nPulser = 0;
748 for (Int_t jj=0;jj<listPulser->GetEntries();jj++){
749 Int_t nPulserSource = 0;
750 TObjString * str = dynamic_cast<TObjString*> (listPulser->At(jj));
751 AliInfo(Form("found source %s", str->String().Data()));
752 // file to be stored run per run
753 TString fileNamePulser = GetFile(kDAQ, "PULSER", str->GetName());
754 if (fileNamePulser.Length()>0){
755 // storing refernce data
756 AliInfo(Form("Got the file %s, now we can process pulser data.", fileNamePulser.Data()));
757 daqFile = new TFile(fileNamePulser.Data(),"READ");
758 h1 = (TH1S*) daqFile->Get("hTOFpulser");
759 for (Int_t ibin=0;ibin<kSize;ibin++){
760 if ((h1->GetBinContent(ibin+1))!=-1){
761 if ((htofPulser->GetBinContent(ibin+1))==-1){
762 htofPulser->SetBinContent(ibin+1,h1->GetBinContent(ibin+1));
763 }
764 else {
765 Log(Form("Something strange occurred during Pulser run, channel %i already read by another LDC, please check!",ibin));
766 }
767 }
768 }
769
770 // elaborating infos
771 Double_t mean =0;
772 Int_t nread=0;
773 Int_t nreadNotEmpty=0;
774 for (Int_t ientry=1;ientry<=h1->GetNbinsX();ientry++){
775
776 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)));
777 /* check whether channel has been read out during current run.
778 * if the status is bad it means it has not been read out.
779 * in this case skip channel in order to not affect the mean */
780 if (fStatus->GetHWStatus(ientry-1) == AliTOFChannelOnlineStatusArray::kTOFHWBad)
781 continue;
782 nPulser++;
783 nPulserSource++;
784 if (h1->GetBinContent(ientry)==-1) continue;
785 else {
786 if (h1->GetBinContent(ientry)>0) {
787 nreadNotEmpty++;
788 AliDebug(2,Form(" channel %i is ok with entry = %f; so far %i channels added ",ientry-1,h1->GetBinContent(ientry),nreadNotEmpty));
789 }
790 mean+=h1->GetBinContent(ientry);
791 nread++;
792 }
793 }
794 if (nread!=0) {
795 mean/=nread;
796 AliDebug(2,Form(" nread = %i , nreadNotEmpty = %i, mean = %f",nread,nreadNotEmpty,mean));
797 for (Int_t ich =0;ich<fNChannels;ich++){
798 if (h1->GetBinContent(ich+1)==-1) continue;
799 AliDebug(3,Form(" channel %i pulser status before pulser = %i",ich,(Int_t)fStatus->GetPulserStatus(ich)));
800
801 /* check whether channel has been read out during current run.
802 * if the status is bad it means it has not been read out.
803 * in this case skip channel in order to leave its status
804 * unchanged */
805 if (fStatus->GetHWStatus(ich) == AliTOFChannelOnlineStatusArray::kTOFHWBad)
806 continue;
807
808 if (h1->GetBinContent(ich+1)<0.05*mean){
809 fStatus->SetPulserStatus(ich,AliTOFChannelOnlineStatusArray::kTOFPulserBad); // bad status for pulser
810 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)));
811 }
812 else {
813 fStatus->SetPulserStatus(ich,AliTOFChannelOnlineStatusArray::kTOFPulserOk); // good status for pulser
814 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)));
815 }
816 }
817 }
818 else {
819 Log("No channels read!! No action taken, keeping old status");
820 }
821
822 daqFile->Close();
823 delete daqFile;
824 delete h1;
17149e6b 825 }
1a1486e7 826
e88f3330 827 else{
828 Log("The input data file from DAQ (pulser) was not found, TOF exiting from Shuttle ");
829 delete listPulser;
830 delete htofPulser;
831 htofPulser = 0x0;
832 if (fStatus){
833 delete fStatus;
834 fStatus = 0;
835 }
836 return 10;//return error code for failure in retrieving Ref Data
1a1486e7 837 }
e88f3330 838 AliDebug(2,Form(" Number of channels processed during pulser run from source %i = %i",jj, nPulserSource));
1a1486e7 839 }
e88f3330 840 AliDebug(2,Form(" Number of channels processed during pulser run = %i",nPulser));
841 delete listPulser;
ee3e792b 842 }
7fffa85b 843
ee3e792b 844 else{
17149e6b 845 Log("The input data file list from DAQ (pulser) was not found, TOF exiting from Shuttle ");
e88f3330 846 delete htofPulser;
847 htofPulser = 0x0;
848 if (fStatus){
849 delete fStatus;
850 fStatus = 0;
851 }
17149e6b 852 return 10;//return error code for failure in retrieving Ref Data
ee3e792b 853 }
17149e6b 854
7fffa85b 855 //storing in OCDB
17149e6b 856
7fffa85b 857 AliCDBMetaData metaData;
858 metaData.SetBeamPeriod(0);
859 metaData.SetResponsible("Chiara Zampolli");
17149e6b 860 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object after a Pulser run.");
7fffa85b 861 AliInfo("Storing Calibration Data from Pulser Run");
17149e6b 862 resultPulser = Store("Calib","Status",fStatus, &metaData,0,kTRUE);
7fffa85b 863 if(!resultPulser){
864 Log("Some problems occurred while storing online object resulting from Pulser data processing");
e88f3330 865 delete htofPulser;
866 htofPulser = 0x0;
867 if (fStatus){
868 delete fStatus;
869 fStatus = 0;
870 }
7fffa85b 871 return 11;//return error code for problems in storing Pulser data
872 }
873
ee3e792b 874 if(fStoreRefData){
875
876 AliCDBMetaData metaDataHisto;
877 metaDataHisto.SetBeamPeriod(0);
878 metaDataHisto.SetResponsible("Chiara Zampolli");
879 char comment[200];
17149e6b 880 sprintf(comment,"This preprocessor stores the Ref data from a pulser run.");
ee3e792b 881 metaDataHisto.SetComment(comment);
882 AliInfo("Storing Reference Data");
db83b789 883 resultPulserRef = StoreReferenceData("Calib","PulserData",htofPulser, &metaDataHisto);
ee3e792b 884 if (!resultPulserRef){
7fffa85b 885 Log("some problems occurred::No Reference Data for pulser stored, TOF exiting from Shuttle");
e88f3330 886 delete htofPulser;
887 htofPulser = 0x0;
888 if (fStatus){
889 delete fStatus;
890 fStatus = 0;
891 }
7fffa85b 892 return 9;//return error code for failure in storing Ref Data
ee3e792b 893 }
894 }
895
896 daqFile=0;
897
e88f3330 898 delete htofPulser;
899 htofPulser = 0x0;
900
901 if (fStatus){
902 delete fStatus;
903 fStatus = 0;
904 }
905
ee3e792b 906 return 0;
907}
908//_____________________________________________________________________________
909
910UInt_t AliTOFPreprocessor::ProcessNoiseData()
911{
7fffa85b 912
913 // Processing Noise Run data for TOF channel status
914
915 Log("Processing Noise");
ee3e792b 916
17149e6b 917 if (fStatus==0x0){
918 AliError("No valid fStatus found, some errors must have occurred!!");
919 return 20;
920 }
921
013ac2dd 922 Float_t noiseThr = 1; // setting default threshold for noise to 1 Hz
923 // reading config map
924 AliCDBEntry *cdbEntry = GetFromOCDB("Calib","ConfigNoise");
925 if (!cdbEntry) {
926 Log(Form("No Configuration entry found in CDB, using default values: NoiseThr = %d",noiseThr));
927 }
928 else {
929 TMap *configMap = (TMap*)cdbEntry->GetObject();
930 if (!configMap){
931 Log(Form("No map found in Config entry in CDB, using default values: NoiseThr = %d", noiseThr));
932 }
933 else{
934 TObjString *strNoiseThr = (TObjString*)configMap->GetValue("NoiseThr");
935 if (strNoiseThr) {
936 TString tmpstr = strNoiseThr->GetString();
937 noiseThr = tmpstr.Atoi();
938 }
939 else {
940 Log(Form("No NoiseThr value found in Map from ConfigNoise entry in CDB, using default value: NoiseThr = %i",noiseThr));
941 }
942 }
943 }
944
945 delete cdbEntry;
946 cdbEntry = 0x0;
947
ee3e792b 948 TH1::AddDirectory(0);
949
950 Bool_t resultNoiseRef=kFALSE;
7fffa85b 951 Bool_t resultNoise=kFALSE;
ee3e792b 952
a174d599 953 static const Int_t kSize = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
17149e6b 954 TH1F * htofNoise = new TH1F("hTOFnoise","histo with signals on TOF during noise", kSize,-0.5,kSize-0.5);
a174d599 955 for (Int_t ibin =1;ibin<=kSize;ibin++){
17149e6b 956 htofNoise->SetBinContent(ibin,-1);
ee3e792b 957 }
17149e6b 958
ee3e792b 959 // processing noise
960
961 TFile * daqFile=0x0;
962 TH1F * h1=0x0;
963
013ac2dd 964 // useful counters
965 Int_t nNoise = 0;
966 Int_t nNoisyChannels = 0;
967 Int_t nNotNoisyChannels = 0;
968 Int_t nChannelsFromDA = 0;
969 Int_t nMatchingWindowNullNonZero = 0;
970 Int_t nMatchingWindowNullEqualZero = 0;
971
972 // retrieving Noise data
ee3e792b 973 TList* listNoise = GetFileSources(kDAQ, "NOISE");
bf76be9c 974 if (listNoise !=0x0 && listNoise->GetEntries()!=0)
e88f3330 975 {
976 AliInfo("The following sources produced files with the id NOISE");
977 listNoise->Print();
e88f3330 978 for (Int_t jj=0;jj<listNoise->GetEntries();jj++){
979 Int_t nNoiseSource = 0;
980 TObjString * str = dynamic_cast<TObjString*> (listNoise->At(jj));
981 AliInfo(Form("found source %s", str->String().Data()));
982 // file to be stored run per run
983 TString fileNameNoise = GetFile(kDAQ, "NOISE", str->GetName());
984 if (fileNameNoise.Length()>0){
985 // storing reference data
986 AliInfo(Form("Got the file %s, now we can process noise data.", fileNameNoise.Data()));
987 daqFile = new TFile(fileNameNoise.Data(),"READ");
988 h1 = (TH1F*) daqFile->Get("hTOFnoise");
989 for (Int_t ibin=0;ibin<kSize;ibin++){
990 if ((h1->GetBinContent(ibin+1))!=-1){
013ac2dd 991 nNoiseSource++;
992 // checking the matching window for current channel
993 if (fMatchingWindow[ibin] == 0){
fc143ab2 994 Log(Form("Matching window for channel %i null, but the channel was read by the LDC! skipping channel, BUT Please check!",ibin));
013ac2dd 995 if ((h1->GetBinContent(ibin+1))!=0) nMatchingWindowNullNonZero++;
996 if ((h1->GetBinContent(ibin+1))==0) nMatchingWindowNullEqualZero++;
997 continue;
998 }
e88f3330 999 if ((htofNoise->GetBinContent(ibin+1))==-1){
013ac2dd 1000 htofNoise->SetBinContent(ibin+1,h1->GetBinContent(ibin+1)/(fMatchingWindow[ibin]*1.E-9));
1001 if ((h1->GetBinContent(ibin+1))!= 0) AliDebug(2,Form("Channel = %i, Matching window = %i, Content = %f", ibin, fMatchingWindow[ibin], htofNoise->GetBinContent(ibin+1)));
e88f3330 1002 }
1003 else {
1004 Log(Form("Something strange occurred during Noise run, channel %i already read by another LDC, please check!",ibin));
1005 }
1006 }
1007 }
013ac2dd 1008
1009 Log(Form(" Number of channels processed during noise run from source %i = %i",jj, nNoiseSource));
e88f3330 1010 daqFile->Close();
1011 delete daqFile;
1012 delete h1;
013ac2dd 1013 daqFile = 0x0;
1014 h1 = 0x0;
1015
e88f3330 1016 }
e88f3330 1017 else{
1018 Log("The input data file from DAQ (noise) was not found, TOF exiting from Shuttle ");
1019 delete listNoise;
013ac2dd 1020 listNoise = 0x0;
e88f3330 1021 delete htofNoise;
1022 htofNoise = 0x0;
1023 if (fStatus){
1024 delete fStatus;
1025 fStatus = 0;
1026 }
013ac2dd 1027 if (fMatchingWindow){
1028 delete [] fMatchingWindow;
1029 fMatchingWindow = 0;
1030 }
e88f3330 1031 return 13;//return error code for failure in retrieving Ref Data
1032 }
013ac2dd 1033 }
ee3e792b 1034 }
013ac2dd 1035
e88f3330 1036 else{
1037 Log("The input data file list from DAQ (noise) was not found, TOF exiting from Shuttle ");
1038 delete htofNoise;
1039 htofNoise = 0x0;
1040 if (fStatus){
1041 delete fStatus;
1042 fStatus = 0;
ee3e792b 1043 }
013ac2dd 1044 if (fMatchingWindow){
1045 delete [] fMatchingWindow;
1046 fMatchingWindow = 0;
1047 }
7fffa85b 1048 return 13;//return error code for failure in retrieving Ref Data
ee3e792b 1049 }
1050
013ac2dd 1051 // elaborating infos to set NOISE status
1052 for (Int_t ich =0;ich<fNChannels;ich++){
1053 if (htofNoise->GetBinContent(ich+1)== -1) continue;
1054
1055 nChannelsFromDA++;
1056
1057 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)));
1058 //AliDebug(2,Form( " channel %i status before noise = %i",ich,(Int_t)fStatus->GetNoiseStatus(ich)));
1059
1060 /* check whether channel has been read out during current run.
1061 * if the status is bad it means it has not been read out.
1062 * in this case skip channel in order to leave its status
1063 * unchanged */
1064
1065 if ((fStatus->GetHWStatus(ich)) == AliTOFChannelOnlineStatusArray::kTOFHWBad)
1066 continue;
1067
1068 nNoise++;
1069 if (htofNoise->GetBinContent(ich+1) >= noiseThr){
1070 fStatus->SetNoiseStatus(ich,AliTOFChannelOnlineStatusArray::kTOFNoiseBad); // bad status for noise
1071 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)));
1072 nNoisyChannels++;
1073 }
1074 else {
1075 fStatus->SetNoiseStatus(ich,AliTOFChannelOnlineStatusArray::kTOFNoiseOk); // good status for noise
1076 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)));
1077 nNotNoisyChannels++;
1078 }
1079 }
1080
1081 Log(Form(" Number of channels processed by DA during noise run, independetly from TOFFEE = %i",nChannelsFromDA));
1082 Log(Form(" Number of channels processed during noise run (that were ON according to TOFFEE) = %i",nNoise));
1083 Log(Form(" Number of noisy channels found during noise run = %i",nNoisyChannels));
1084 Log(Form(" Number of not noisy channels found during noise run = %i",nNotNoisyChannels));
1085 Log(Form(" Number of channels with matching window NULL (so skipped), but Non Zero content = %i",nMatchingWindowNullNonZero));
1086 Log(Form(" Number of channels with matching window NULL (so skipped), and Zero content = %i",nMatchingWindowNullEqualZero));
1087
1088 delete listNoise;
1089
1090 //daqFile=0;
e88f3330 1091
7fffa85b 1092 //storing in OCDB
e88f3330 1093
7fffa85b 1094 AliCDBMetaData metaData;
1095 metaData.SetBeamPeriod(0);
1096 metaData.SetResponsible("Chiara Zampolli");
17149e6b 1097 metaData.SetComment("This preprocessor fills an AliTOFChannelOnlineStatusArray object after a Noise run.");
7fffa85b 1098 AliInfo("Storing Calibration Data from Noise Run");
17149e6b 1099 resultNoise = Store("Calib","Status",fStatus, &metaData,0,kTRUE);
7fffa85b 1100 if(!resultNoise){
1101 Log("Some problems occurred while storing online object resulting from Noise data processing");
e88f3330 1102 delete htofNoise;
1103 htofNoise = 0x0;
1104 if (fStatus){
1105 delete fStatus;
1106 fStatus = 0;
1107 }
013ac2dd 1108 if (fMatchingWindow){
1109 delete [] fMatchingWindow;
1110 fMatchingWindow = 0;
1111 }
7fffa85b 1112 return 14;//return error code for problems in storing Noise data
1113 }
1114
ee3e792b 1115 if(fStoreRefData){
1116
1117 AliCDBMetaData metaDataHisto;
1118 metaDataHisto.SetBeamPeriod(0);
1119 metaDataHisto.SetResponsible("Chiara Zampolli");
1120 char comment[200];
17149e6b 1121 sprintf(comment,"This preprocessor stores the Ref data from a noise run. ");
ee3e792b 1122 metaDataHisto.SetComment(comment);
1123 AliInfo("Storing Reference Data");
db83b789 1124 resultNoiseRef = StoreReferenceData("Calib","NoiseData",htofNoise, &metaDataHisto);
ee3e792b 1125 if (!resultNoiseRef){
1126 Log("some problems occurred::No Reference Data for noise stored");
e88f3330 1127 delete htofNoise;
1128 htofNoise = 0x0;
1129 if (fStatus){
1130 delete fStatus;
1131 fStatus = 0;
1132 }
013ac2dd 1133 if (fMatchingWindow){
1134 delete [] fMatchingWindow;
1135 fMatchingWindow = 0;
1136 }
7fffa85b 1137 return 12;//return error code for failure in storing Ref Data
ee3e792b 1138 }
1139 }
1140
e88f3330 1141 delete htofNoise;
1142 htofNoise = 0x0;
1143
1144 if (fStatus){
1145 delete fStatus;
1146 fStatus = 0;
1147 }
1148
013ac2dd 1149 if (fMatchingWindow){
1150 delete [] fMatchingWindow;
1151 fMatchingWindow = 0;
1152 }
1153
ee3e792b 1154 return 0;
1155}
1156//_____________________________________________________________________________
1157
db83b789 1158UInt_t AliTOFPreprocessor::ProcessFEEData()
ee3e792b 1159{
7fffa85b 1160 // Processing Pulser Run data for TOF channel status
1161 // dummy for the time being
ee3e792b 1162
db83b789 1163 Log("Processing FEE");
1164
ea932f75 1165 //Bool_t updateOCDB = kFALSE;
db83b789 1166 AliTOFFEEReader feeReader;
17149e6b 1167
db83b789 1168 TH1C hCurrentFEE("hCurrentFEE","histo with current FEE channel status", fNChannels, 0, fNChannels);
1169
69355034 1170 /* load current TOF FEE(dump) from DCS FXS,
1171 * setup TOFFEEdump object */
1172
1173 const char * toffeeFileName = GetFile(kDCS,"TofFeeMap","");
1174 AliInfo(Form("toffee file name = %s", toffeeFileName));
1175 if (toffeeFileName == NULL) {
1176 return 15;
1177 }
1178 AliTOFFEEDump feedump;
1179 feedump.ReadFromFile(toffeeFileName);
1180
1181 /* load current TOF FEE(light) config from DCS FXS, parse,
db83b789 1182 * fill current FEE histogram and set FEE status */
1183
fceb731d 1184 const char * nameFile = GetFile(kDCS,"TofFeeLightMap","");
69355034 1185 AliInfo(Form("toffeeLight file name = %s",nameFile));
db83b789 1186 if (nameFile == NULL) {
1187 return 15;
1188 }
fceb731d 1189 feeReader.LoadFEElightConfig(nameFile);
1190 Int_t parseFee = feeReader.ParseFEElightConfig();
1191 AliDebug(2,Form("%i enabled channels found in FEElight configuration",parseFee));
db83b789 1192 /* load stored TOF FEE from OCDB and compare it with current FEE.
1193 * if stored FEE is different from current FEE set update flag.
1194 * if there is no stored FEE in OCDB set update flag */
1195
013ac2dd 1196 fMatchingWindow = new Int_t[fNChannels];
02ede0c4 1197 fLatencyWindow = new Int_t[fNChannels];
1198
17149e6b 1199 AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Status");
1200 if (!cdbEntry) {
1201 /* no CDB entry found. set update flag */
1202 Log(" ************ WARNING ************");
1203 Log("No CDB Status entry found, creating a new one!");
1204 Log(" *********************************");
1205 fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
ea932f75 1206 //updateOCDB = kTRUE;
1207 fIsStatusMapChanged = kTRUE;
db83b789 1208 }
db83b789 1209 else {
e88f3330 1210 if (cdbEntry) cdbEntry->SetOwner(kFALSE);
17149e6b 1211 /* CDB entry OK. loop over channels */
1212 fStatus = (AliTOFChannelOnlineStatusArray*) cdbEntry->GetObject();
e88f3330 1213 delete cdbEntry;
1214 cdbEntry = 0x0;
134e5594 1215 /* cehck whether status object has latency window data */
1216 if (!fStatus->HasLatencyWindow()) {
1217 /* create new status object and update OCDB */
1218 Log(" ************ WARNING ************");
1219 Log("CDB Status entry found but has no latency window data, creating a new one!");
1220 Log(" *********************************");
1221 delete fStatus;
1222 fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
ea932f75 1223 //updateOCDB = kTRUE;
1224 fIsStatusMapChanged = kTRUE;
134e5594 1225 }
db83b789 1226 }
17149e6b 1227 for (Int_t iChannel = 0; iChannel < fNChannels; iChannel++){
1228 //AliDebug(2,Form("********** channel %i",iChannel));
1229 /* compare current FEE channel status with stored one
1230 * if different set update flag and break loop */
1231 //AliDebug(2,Form( " channel %i status before FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
013ac2dd 1232 fMatchingWindow[iChannel] = feeReader.GetMatchingWindow(iChannel);
02ede0c4 1233 fLatencyWindow[iChannel] = feeReader.GetLatencyWindow(iChannel);
17149e6b 1234 if (feeReader.IsChannelEnabled(iChannel)) {
1235 hCurrentFEE.SetBinContent(iChannel + 1, 1);
1236 if (fStatus->GetHWStatus(iChannel)!=AliTOFChannelOnlineStatusArray::kTOFHWOk){
ea932f75 1237 //updateOCDB = kTRUE;
1238 fIsStatusMapChanged = kTRUE;
17149e6b 1239 fStatus->SetHWStatus(iChannel,AliTOFChannelOnlineStatusArray::kTOFHWOk);
013ac2dd 1240 AliDebug(3,Form( " changed into enabled: channel %i status after FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
17149e6b 1241 }
02ede0c4 1242 if (fStatus->GetLatencyWindow(iChannel)!=fLatencyWindow[iChannel]){
ea932f75 1243 //updateOCDB = kTRUE;
1244 fIsStatusMapChanged = kTRUE;
02ede0c4 1245 fStatus->SetLatencyWindow(iChannel,fLatencyWindow[iChannel]);
1246 AliDebug(3,Form( " changed latency window: channel %i latency window after FEE = %i",iChannel,fStatus->GetLatencyWindow(iChannel)));
1247 }
17149e6b 1248 }
1249 else {
1250 if (fStatus->GetHWStatus(iChannel)!=AliTOFChannelOnlineStatusArray::kTOFHWBad){
ea932f75 1251 //updateOCDB = kTRUE;
1252 fIsStatusMapChanged = kTRUE;
17149e6b 1253 fStatus->SetHWStatus(iChannel,AliTOFChannelOnlineStatusArray::kTOFHWBad);
013ac2dd 1254 AliDebug(3,Form( " changed into disabled: channel %i status after FEE = %i",iChannel,(Int_t)fStatus->GetHWStatus(iChannel)));
17149e6b 1255 }
1256 }
1257 }
1258
db83b789 1259
1260 /* check whether we don't have to store reference data.
1261 * in this case we return without errors. */
1262 if (fStoreRefData) {
69355034 1263 /* store reference data */
1264 AliCDBMetaData metaDataHisto;
1265 metaDataHisto.SetBeamPeriod(0);
1266 metaDataHisto.SetResponsible("Roberto Preghenella");
1267 metaDataHisto.SetComment("This preprocessor stores the FEE Ref data of the current run.");
1268 AliInfo("Storing FEE reference data");
1269 /* store FEE reference data */
1270 if (!StoreReferenceData("Calib", "FEEData", &hCurrentFEE, &metaDataHisto)) {
1271 /* failed */
1272 Log("problems while storing FEE reference data");
1273 if (fStatus){
1274 delete fStatus;
1275 fStatus = 0;
1276 }
1277 return 18; /* error return code for problems while storing FEE reference data */
1278 }
1279
1280 /* store TOF FEE dump reference data */
1281 AliCDBMetaData metaDatadump;
1282 metaDatadump.SetBeamPeriod(0);
1283 metaDatadump.SetResponsible("Roberto Preghenella");
1284 metaDatadump.SetComment("This preprocessor stores the TOF FEE dump Ref data of the current run.");
1285 AliInfo("Storing TOF FEE dump reference data");
1286 /* store FEE reference data */
1287 if (!StoreReferenceData("Calib", "FEEDump", &feedump, &metaDatadump)) {
1288 /* failed */
1289 Log("problems while storing TOF FEE dump reference data");
1290 return 18; /* error return code for problems while storing FEE reference data */
1291 }
db83b789 1292 }
1293
7fffa85b 1294 return 0;
1295
1296}
1297
1298//_____________________________________________________________________________
1299
ea932f75 1300UInt_t AliTOFPreprocessor::Process(TMap * const dcsAliasMap)
7fffa85b 1301{
a174d599 1302 //
ea932f75 1303 // Main AliTOFPreprocessor method called by SHUTTLE
a174d599 1304 //
7fffa85b 1305
1306 TString runType = GetRunType();
1307 Log(Form("RunType %s",runType.Data()));
bf76be9c 1308
ee3e792b 1309 // processing
1310
db83b789 1311 /* always process FEE data */
1312 Int_t iresultFEE = ProcessFEEData();
1313 if (iresultFEE != 0)
1314 return iresultFEE;
1315
7fffa85b 1316 if (runType == "PULSER") {
1317 Int_t iresultPulser = ProcessPulserData();
1318 return iresultPulser;
1319 }
17149e6b 1320
7fffa85b 1321 if (runType == "NOISE") { // for the time being associating noise runs with pedestal runs; proper run type to be defined
1322 Int_t iresultNoise = ProcessNoiseData();
1323 return iresultNoise;
1324 }
1325
1326 if (runType == "PHYSICS") {
4856f488 1327 Int_t iresultDAQ = ProcessOnlineDelays();
1328 if (iresultDAQ != 0) {
7fffa85b 1329 return iresultDAQ;
1330 }
4856f488 1331 else {
1332 Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
ea932f75 1333 Int_t iResultHVandLVdps = ProcessHVandLVdps(dcsAliasMap);
1334 return iresultDCS+iResultHVandLVdps;
4856f488 1335 }
ee3e792b 1336 }
1337
7fffa85b 1338 // storing
ee3e792b 1339 return 0;
1340}
c9fe8530 1341
1342
b06d5296 1343//_____________________________________________________________________________
1344
1345void
1346AliTOFPreprocessor::FillWithCosmicCalibration(AliTOFChannelOnlineArray *cal)
1347{
1348 /*
1349 * fill with cosmic calibration
1350 */
1351
1352 Log(" Using cosmic-ray calibration.");
1353
1354 AliTOFcalibHisto calibHisto;
97a29b32 1355 calibHisto.SetFullCorrectionFlag(AliTOFcalibHisto::kTimeSlewingCorr, kFALSE);
1356 Log(Form(" loading calibration histograms from %s", calibHisto.GetCalibHistoFileName()));
b06d5296 1357 Log(Form(" loading calibration parameters from %s", calibHisto.GetCalibParFileName()));
1358 calibHisto.LoadCalibPar();
1359
1360 /* loop over channel index */
1361 for (Int_t iIndex = 0; iIndex < fNChannels; iIndex++) {
9155334b 1362 cal->SetDelay(iIndex, calibHisto.GetFullCorrection(iIndex));
b06d5296 1363 }
1364
1365}
1366
b06d5296 1367//_____________________________________________________________________________
1368
1369void
1370AliTOFPreprocessor::FillWithCableLengthMap(AliTOFChannelOnlineArray *cal)
1371{
1372 /*
1373 * fill with cosmic calibration
1374 */
1375
1376 Log(" Using cable-length map.");
1377 AliTOFRawStream tofrs;
1378 Int_t det[5], dummy, index;
1379 Float_t cableTimeShift;
1380
1381 /* temporarly disable warnings */
1382 AliLog::EType_t logLevel = (AliLog::EType_t)AliLog::GetGlobalLogLevel();
1383 AliLog::SetGlobalLogLevel(AliLog::kError);
1384
1385 /* loop over EO indeces */
1386 for (Int_t iddl = 0; iddl < 72; iddl++)
1387 for (Int_t islot = 3; islot <= 12; islot++)
1388 for (Int_t ichain = 0; ichain < 2; ichain++)
1389 for (Int_t itdc = 0; itdc < 15; itdc++)
1390 for (Int_t ichannel = 0; ichannel < 8; ichannel++) {
1391
1392 /* get DO index */
1393 tofrs.EquipmentId2VolumeId(iddl, islot, ichain, itdc, ichannel, det);
1394
1395 /* swap det[3] and det[4] indeces (needed to obtain correct channel index) */
1396 dummy = det[3];
1397 det[3] = det[4];
1398 det[4] = dummy;
1399
1400 /* check DO index */
1401 if (det[0] < 0 || det[0] > 17 ||
1402 det[1] < 0 || det[1] > 4 ||
1403 det[2] < 0 || det[2] > 18 ||
1404 det[3] < 0 || det[3] > 1 ||
1405 det[4] < 0 || det[4] > 47)
1406 continue;
1407
1408 /* get channel index */
1409 index = AliTOFGeometry::GetIndex(det);
1410
1411 /* get cable time shift */
1412 cableTimeShift = AliTOFCableLengthMap::GetCableTimeShift(iddl, islot, ichain, itdc);
1413
1414 /* set delay */
1415 if (index<fNChannels) {
1416 cal->SetDelay(index,cableTimeShift); // delay in ns
1417 AliDebug(2,Form("Setting delay %f (ns) for channel %i",cableTimeShift,index));
1418 }
1419
1420 } /* loop over EO indeces */
1421
1422 /* re-enable warnings */
1423 AliLog::SetGlobalLogLevel(logLevel);
1424
1425}
1426
1427