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