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