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