STEER/AliGRPPreprocessor.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 //                          Class AliGRPPreprocessor
  20 //                  Global Run Parameters (GRP) preprocessor
  21 //    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
  22 //    Modified: Ernesto.Lopez.Torres@cern.ch  CEADEN-CERN
  23 //    Modified: Chiara.Zampolli@cern.ch  CERN
  24 //-------------------------------------------------------------------------
  25
  26 #include <TChain.h>
  27 #include <TList.h>
  28 #include <TMap.h>
  29 #include <TObjString.h>
  30 #include <TObjArray.h>
  31 #include <TGraph.h>
  32 #include <TString.h>
  33 #include <TFile.h>
  34
  35 #include <float.h>
  36
  37 #include "AliGRPPreprocessor.h"
  38 #include "AliGRPObject.h"
  39 #include "AliDCSSensor.h"
  40 #include "AliSplineFit.h"
  41 #include "AliDCSSensorArray.h"
  42 #include "AliRawEventHeaderVersions.h"
  43
  44 #include "AliTriggerConfiguration.h"
  45 #include "AliTriggerRunScalers.h"
  46 #include "AliTriggerInput.h"
  47
  48 #include "AliCDBMetaData.h"
  49 #include "AliESDVertex.h"
  50 #include "AliLHCReader.h"
  51 #include "AliLHCData.h"
  52 #include "AliDCSArray.h"
  53 #include "AliDAQ.h"
  54 #include "AliLTUConfig.h"
  55
  56 class AliLog;
  57 class AliDCSValue;
  58 class AliShuttleInterface;
  59
  60 // needed for ReceivePromptRecoParameters
  61
  62 #include <TSQLServer.h>
  63 #include <TSQLResult.h>
  64 #include <TSQLRow.h>
  65 #include <AliCDBManager.h>
  66 #include <AliCDBMetaData.h>
  67 #include <AliCDBId.h>
  68 #include <AliTriggerConfiguration.h>
  69 #include <AliCTPTimeParams.h>
  70 #include <AliLHCClockPhase.h>
  71
  72 const Double_t kFitFraction = -1.;                 // Fraction of DCS sensor fits required
  73
  74 ClassImp(AliGRPPreprocessor)
  75
  76 //_______________________________________________________________
  77
  78   const Int_t AliGRPPreprocessor::fgknDAQLbPar = 6; // num parameters in the logbook used to fill the GRP object
  79   const Int_t AliGRPPreprocessor::fgknDCSDP = 48;   // number of dcs dps
  80   const Int_t AliGRPPreprocessor::fgknDCSDPHallProbes = 40;   // number of dcs dps
  81   const Int_t AliGRPPreprocessor::fgknLHCDP = 6;   // number of dcs dps from LHC data
  82   const Int_t AliGRPPreprocessor::fgkDCSDPHallTopShift = 4;   // shift from the top to get tp the Hall Probes names in the list of DCS DPs
  83   const Int_t AliGRPPreprocessor::fgkDCSDPNonWorking = 5; // number of non working DCS DPs
  84   const char* AliGRPPreprocessor::fgkDCSDataPoints[AliGRPPreprocessor::fgknDCSDP] = {
  85                    "L3Polarity",
  86                    "DipolePolarity",
  87                    "L3Current",
  88                    "DipoleCurrent",
  89                    "L3_BSF17_H1",
  90                    "L3_BSF17_H2",
  91                    "L3_BSF17_H3",
  92                    "L3_BSF17_Temperature",
  93                    "L3_BSF4_H1",
  94                    "L3_BSF4_H2",
  95                    "L3_BSF4_H3",
  96                    "L3_BSF4_Temperature",
  97                    "L3_BKF17_H1",
  98                    "L3_BKF17_H2",
  99                    "L3_BKF17_H3",
 100                    "L3_BKF17_Temperature",
 101                    "L3_BKF4_H1",
 102                    "L3_BKF4_H2",
 103                    "L3_BKF4_H3",
 104                    "L3_BKF4_Temperature",
 105                    "L3_BSF13_H1",
 106                    "L3_BSF13_H2",
 107                    "L3_BSF13_H3",
 108                    "L3_BSF13_Temperature",
 109                    "L3_BSF8_H1",
 110                    "L3_BSF8_H2",
 111                    "L3_BSF8_H3",
 112                    "L3_BSF8_Temperature",
 113                    "L3_BKF13_H1",
 114                    "L3_BKF13_H2",
 115                    "L3_BKF13_H3",
 116                    "L3_BKF13_Temperature",
 117                    "L3_BKF8_H1",
 118                    "L3_BKF8_H2",
 119                    "L3_BKF8_H3",
 120                    "L3_BKF8_Temperature",
 121                    "Dipole_Inside_H1",
 122                    "Dipole_Inside_H2",
 123                    "Dipole_Inside_H3",
 124                    "Dipole_Inside_Temperature",
 125                    "Dipole_Outside_H1",
 126                    "Dipole_Outside_H2",
 127                    "Dipole_Outside_H3",
 128                    "Dipole_Outside_Temperature",
 129                    "CavernTemperature",
 130                    "CavernAtmosPressure",
 131                    "SurfaceAtmosPressure",
 132                    "CavernAtmosPressure2"
 133                  };
 134
 135   const char* AliGRPPreprocessor::fgkDCSDataPointsHallProbes[AliGRPPreprocessor::fgknDCSDPHallProbes] = {
 136                    "L3_BSF17_H1",
 137                    "L3_BSF17_H2",
 138                    "L3_BSF17_H3",
 139                    "L3_BSF17_Temperature",
 140                    "L3_BSF4_H1",
 141                    "L3_BSF4_H2",
 142                    "L3_BSF4_H3",
 143                    "L3_BSF4_Temperature",
 144                    "L3_BKF17_H1",
 145                    "L3_BKF17_H2",
 146                    "L3_BKF17_H3",
 147                    "L3_BKF17_Temperature",
 148                    "L3_BKF4_H1",
 149                    "L3_BKF4_H2",
 150                    "L3_BKF4_H3",
 151                    "L3_BKF4_Temperature",
 152                    "L3_BSF13_H1",
 153                    "L3_BSF13_H2",
 154                    "L3_BSF13_H3",
 155                    "L3_BSF13_Temperature",
 156                    "L3_BSF8_H1",
 157                    "L3_BSF8_H2",
 158                    "L3_BSF8_H3",
 159                    "L3_BSF8_Temperature",
 160                    "L3_BKF13_H1",
 161                    "L3_BKF13_H2",
 162                    "L3_BKF13_H3",
 163                    "L3_BKF13_Temperature",
 164                    "L3_BKF8_H1",
 165                    "L3_BKF8_H2",
 166                    "L3_BKF8_H3",
 167                    "L3_BKF8_Temperature",
 168                    "Dipole_Inside_H1",
 169                    "Dipole_Inside_H2",
 170                    "Dipole_Inside_H3",
 171                    "Dipole_Inside_Temperature",
 172                    "Dipole_Outside_H1",
 173                    "Dipole_Outside_H2",
 174                    "Dipole_Outside_H3",
 175                    "Dipole_Outside_Temperature"
 176                  };
 177
 178   const Short_t kSensors = 45; // start index position of sensor in DCS DPs
 179   const Short_t kNumSensors = 3; // Number of sensors in DCS DPs (CavernAtmosPressure, SurfaceAtmosPressure, CavernAtmosPressure2)
 180
 181
 182   const char* AliGRPPreprocessor::fgkLHCDataPoints[AliGRPPreprocessor::fgknLHCDP] = {
 183           "LHC_Beam_Energy",
 184           "LHC_MachineMode",
 185           "LHC_BeamMode",
 186           "LHC_Beams_Particle_Type",
 187           "BPTX_Phase_Shift_B1",
 188           "BPTX_Phase_Shift_B2"
 189   };
 190
 191   const char* kppError[] = {
 192                    "",
 193                    "(DAQ logbook ERROR)",
 194                    "(DAQ FXS ERROR)",
 195                    "(Trigger Scalers not found in DCS FXS - ERROR)",
 196                    "(DCS data points ERROR)",
 197                    "(Trigger Configuration ERROR)",
 198                    "(DAQ logbook ERROR determining partition of the run)",
 199                    "(CTP timing ERROR)",
 200                    "(SPD Mean Vertex ERROR)",
 201                    "(DCS FXS Error for LHC Data)",
 202                    "(LHC Data Error)",
 203                    "(LHC Clock Phase Error (from LHC Data))",
 204                    "(LTU Configuration Error)"
 205   };
 206
 207 //_______________________________________________________________
 208
 209 AliGRPPreprocessor::AliGRPPreprocessor(AliShuttleInterface* shuttle):
 210         AliPreprocessor("GRP",shuttle),  fPressure(0), fmaxFloat(0), fminFloat(0),fmaxDouble(0), fminDouble(0), fmaxInt(0), fminInt(0), fmaxUInt(0), fminUInt(0),fdaqStartEndTimeOk(kTRUE),ffailedDPs(new TObjArray(fgknDCSDP))
 211 {
 212         // constructor - shuttle must be instantiated!
 213
 214         AddRunType("COSMIC");
 215         AddRunType("LASER");
 216         AddRunType("PHYSICS");
 217         AddRunType("CALIBRATION_BC");
 218         AddRunType("CALIBRATION_CENTRAL");
 219         AddRunType("CALIBRATION_EMD");
 220         AddRunType("CALIBRATION_MB");
 221         AddRunType("CALIBRATION_SEMICENTRAL");
 222         AddRunType("CALIBRATION");
 223         AddRunType("PEDESTAL");
 224         AddRunType("STANDALONE");
 225         AddRunType("GAIN");
 226         AddRunType("NOISE");
 227         AddRunType("PULSER");
 228         AddRunType("STANDALONE_PULSER");
 229         AddRunType("STANDALONE_BC");
 230
 231         fmaxFloat = FLT_MAX;
 232         fminFloat = -FLT_MAX;
 233         fmaxDouble = DBL_MAX;
 234         fminDouble = -DBL_MAX;
 235         fmaxInt = kMaxInt;
 236         fminInt = kMinInt;
 237         fmaxUInt = kMaxUInt;
 238         fminUInt = 0;
 239
 240         AliInfo(Form("Max allowed float = %6.5e",fmaxFloat));
 241         AliInfo(Form("Min allowed float = %6.5e",fminFloat));
 242         AliInfo(Form("Max allowed double = %6.5e",fmaxDouble));
 243         AliInfo(Form("Min allowed double = %6.5e",fminDouble));
 244         AliInfo(Form("Max allowed integer = %d",fmaxInt));
 245         AliInfo(Form("Min allowed integer = %d",fminInt));
 246         AliInfo(Form("Max allowed unsigned integer = %u",(Int_t)fmaxUInt));
 247         AliInfo(Form("Min allowed unsigned integer = %u",(Int_t)fminUInt));
 248
 249         ffailedDPs->SetOwner(kTRUE);
 250 }
 251
 252 //_______________________________________________________________
 253
 254 AliGRPPreprocessor::~AliGRPPreprocessor()
 255 {
 256         //destructor
 257
 258         delete fPressure;
 259         delete ffailedDPs;
 260
 261 }
 262
 263 //_______________________________________________________________
 264
 265 void AliGRPPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
 266 {
 267         // Initialize preprocessor
 268
 269         AliPreprocessor::Initialize(run, startTime, endTime);
 270
 271         AliInfo("Initialization of the GRP preprocessor.");
 272         AliInfo(Form("Start Time DCS = %d",GetStartTimeDCSQuery()));
 273         AliInfo(Form("End Time DCS = %d",GetEndTimeDCSQuery()));
 274         TClonesArray * array = new TClonesArray("AliDCSSensor",kNumSensors);
 275         for(Int_t j = 0; j < kNumSensors; j++) {
 276                 AliDCSSensor * sens = new ((*array)[j])AliDCSSensor;
 277                 sens->SetStringID(fgkDCSDataPoints[j+kSensors]);
 278         }
 279         AliInfo(Form("Pressure Entries: %d",array->GetEntries()));
 280
 281         fPressure = new AliDCSSensorArray(GetStartTimeDCSQuery(), GetEndTimeDCSQuery(), array);
 282
 283         for (Int_t iDP=0; iDP < fgknDCSDP; iDP++){
 284                 TObjString* dp = new TObjString(fgkDCSDataPoints[iDP]);
 285                 ffailedDPs->AddAt(dp,iDP);
 286         }
 287
 288 }
 289
 290 //_______________________________________________________________
 291
 292 UInt_t AliGRPPreprocessor::Process(TMap* valueMap)
 293 {
 294         // process data retrieved by the Shuttle
 295
 296         // retrieving "partition" and "detector" fields from DAQ logbook to
 297         // determine the partition in which the run was taken
 298         // the partition is used to decide how to react in case of errors for CTP
 299
 300         TString partition = (TString)GetRunParameter("partition");
 301         TString detector = (TString)GetRunParameter("detector");
 302
 303         AliGRPObject *grpobj = new AliGRPObject();  // object to store data
 304         grpobj->SetBeamEnergyIsSqrtSHalfGeV(); // new format
 305
 306         //=================//
 307         // DAQ logbook     //
 308         //=================//
 309
 310         Log("*************** Processing DAQ logbook");
 311
 312         UInt_t error = 0;
 313
 314         Int_t iDaqLB = ProcessDaqLB(grpobj);
 315         TString runType = (TString)GetRunType();
 316         TString beamType = (TString)GetRunParameter("beamType");
 317         if(iDaqLB == fgknDAQLbPar) {
 318                 Log(Form("DAQ Logbook, successful! Retrieved %d/%d entries",iDaqLB,fgknDAQLbPar));
 319         } else {
 320                 Log(Form("DAQ Logbook, could not get all expected entries!!! Retrieved only %d/%d entries",iDaqLB,fgknDAQLbPar));
 321                 error |= 1;
 322         }
 323
 324         //=================//
 325         // DAQ FXS         //
 326         //=================//
 327
 328         Log("*************** Processing DAQ FXS");
 329
 330         UInt_t iDaqFxs = ProcessDaqFxs();
 331         if( iDaqFxs == 0 ) {
 332                 Log(Form("DAQ FXS, successful!"));
 333         } else {
 334                 Log(Form("DAQ FXS, could not store run raw tag file!!!"));
 335                 error |= 2;
 336         }
 337
 338         //=================//
 339         // DCS FXS         //
 340         //=================//
 341
 342         Log("*************** Processing DCS FXS");
 343
 344         UInt_t iDcsFxs = ProcessDcsFxs(partition, detector);
 345         if( iDcsFxs == 0 ) {
 346                 Log(Form("DCS FXS, successful!"));
 347         } else  if (iDcsFxs ==1) {
 348                 Log(Form("DCS FXS, Could not store CTP scalers!!!"));
 349                 error |= 4;
 350         } else{
 351                 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without CTP scalers...",partition.Data(),detector.Data()));
 352                 error |= 32;
 353         }
 354
 355         //=================//
 356         // DCS data points //
 357         //=================//
 358
 359         Log("*************** Processing DCS DPs");
 360
 361         Log(Form("Starting DCS Query at %d and finishing at %d",GetStartTimeDCSQuery(),GetEndTimeDCSQuery()));
 362         Int_t entries = ProcessDcsDPs( valueMap, grpobj );
 363         Log(Form("entries found = %d (should be %d)",entries, fgknDCSDP-fgkDCSDPNonWorking));
 364         if (fdaqStartEndTimeOk){
 365                 if( entries < fgknDCSDP - fgkDCSDPNonWorking ) { // L3_BSF4_H3, L3_BSF17_H1, L3_BSF17_H2, L3_BSF17_H3, L3_BSF17_Temperature are not working yet...
 366                         Log(Form("Possible problem with the DCS data points!!! Only %d/%d entries found - Please read further for more details",entries,fgknDCSDP-fgkDCSDPNonWorking));
 367                         Log(Form("The DPs giving problems were:"));
 368                         for (Int_t iDP = 0; iDP < fgknDCSDP; iDP++){
 369                                 TObjString *dpString = (TObjString*)ffailedDPs->At(iDP);
 370                                 if (dpString){
 371                                         TString name = dpString->String();
 372                                         if (name != "L3_BSF4_H3" && name != "L3_BSF17_H1" && name != "L3_BSF17_H2" && name != "L3_BSF17_H3" && name != "L3_BSF17_Temperature" ){
 373                                                 Log(Form("******** %s ******** not present, but foreseen --> causing an ERROR",name.Data()));
 374                                         }
 375                                         else {
 376                                                 Log(Form(" %s is not present, but was not generating any error since it is not ready in DCS - check the other DPs in this list!",name.Data()));
 377                                         }
 378                                 }
 379                         }
 380                         error |= 8;
 381                 }
 382                 else  Log(Form("DCS data points, successful!"));
 383         }
 384         else Log(Form("Statistical values for DCS DPs could not be computed due to missing DAQ_time_start and DAQ_time_end fields in DAQ logbook"));
 385
 386         //=======================//
 387         // Trigger Configuration //
 388         //=======================//
 389
 390         Log("*************** Processing Trigger Configuration");
 391
 392         const char * triggerConf = GetTriggerConfiguration();
 393
 394         if (partition.IsNull() && !detector.IsNull()){ // standalone partition
 395                 Log("STANDALONE partition for current run, using Trigger Configuration dummy value");
 396                 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyConfig");
 397                 if (!cdbEntry) {
 398                         Log(Form("No dummy CTP configuration entry found, going into error..."));
 399                         error |= 16;
 400                 }
 401                 else{
 402                         AliTriggerConfiguration *runcfg = (AliTriggerConfiguration*)cdbEntry->GetObject();
 403                         if (!runcfg){
 404                                 Log(Form("dummy CTP config not found in OCDB entry, going into error..."));
 405                                 error |= 16;
 406                         }
 407                         else {
 408                                 TString titleCTPcfg = Form("CTP cfg for run %i from Dummy entry in OCDB",fRun);
 409                                 runcfg->SetTitle(titleCTPcfg);
 410                                 AliCDBMetaData metaData;
 411                                 metaData.SetResponsible("Roman Lietava");
 412                                 metaData.SetComment("CTP run configuration from dummy entry in OCDB");
 413                                 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
 414                                         Log("Unable to store the dummy CTP run configuration object to OCDB!");
 415                                         error |= 16;
 416                                 }
 417                         }
 418                 }
 419         }
 420
 421         else if (!partition.IsNull() && detector.IsNull()){ // global partition
 422                 Log("GLOBAL partition for current run, using Trigger Configuration from DAQ Logbook");
 423                 if (triggerConf!= NULL) {
 424                         Log("Found trigger configuration in DAQ logbook");
 425                         AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConf);
 426                         if (!runcfg) {
 427                                 Log("Bad CTP run configuration file from DAQ logbook! The corresponding CDB entry will not be filled!");
 428                                 error |= 16;
 429                         }
 430                         else {
 431                                 TString titleCTPcfg = Form("CTP cfg for run %i from DAQ",fRun);
 432                                 runcfg->SetTitle(titleCTPcfg);
 433                                 AliCDBMetaData metaData;
 434                                 metaData.SetBeamPeriod(0);
 435                                 metaData.SetResponsible("Roman Lietava");
 436                                 metaData.SetComment("CTP run configuration from DAQ logbook");
 437                                 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
 438                                         Log("Unable to store the CTP run configuration object to OCDB!");
 439                                         error |= 16;
 440                                 }
 441                         }
 442                 }
 443
 444                 else {
 445                         Log("Trigger configuration NULL in DAQ logbook");
 446                         error |= 16;
 447                 }
 448         }
 449
 450         else {
 451                 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger configuration...",partition.Data(),detector.Data()));
 452                 error |= 32;
 453         }
 454
 455         //===========================//
 456         // Trigger Timing Parameters //
 457         //===========================//
 458
 459         Log("*************** Processing Trigger Time Params");
 460
 461         const char * triggerCTPtiming = GetCTPTimeParams();
 462
 463         if (partition.IsNull() && !detector.IsNull()){ // standalone partition
 464                 Log("STANDALONE partition for current run, using CTP timing params dummy value");
 465                 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyCTPtime");
 466                 if (!cdbEntry) {
 467                         Log(Form("No dummy CTP timing parameters entry found, going into error..."));
 468                         error |= 64;
 469                 }
 470                 else{
 471                         AliCTPTimeParams *runCTPtiming = (AliCTPTimeParams*)cdbEntry->GetObject();
 472                         if (!runCTPtiming){
 473                                 Log(Form("dummy CTP timing parameters not found in OCDB entry, going into error..."));
 474                                 error |= 64;
 475                         }
 476                         else {
 477                                 TString titleCTPtiming = Form("CTP timing params for run %i from Dummy entry in OCDB",fRun);
 478                                 runCTPtiming->SetTitle(titleCTPtiming);
 479                                 AliCDBMetaData metadata;
 480                                 metadata.SetResponsible("Roman Lietava");
 481                                 metadata.SetComment("CTP run timing parameters from dummy entry in OCDB");
 482                                 if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
 483                                         Log("Unable to store the dummy CTP timing params object to OCDB!");
 484                                         error |= 64;
 485                                 }
 486                         }
 487                 }
 488         }
 489
 490         else if (!partition.IsNull() && detector.IsNull()){ // global partition
 491                 Log("GLOBAL partition for current run, using Trigger Timing Parameters from DAQ Logbook");
 492                 if (triggerCTPtiming!= NULL) {
 493                         Log("Found trigger timing params in DAQ logbook");
 494                         AliDebug(2,Form("%s",triggerCTPtiming));
 495                         AliCTPTimeParams *runCTPtiming = AliCTPTimeParams::LoadCTPTimeParamsFromString(triggerCTPtiming);
 496                         if (!runCTPtiming) {
 497                                 Log("Bad CTP trigger timing params file from DAQ logbook! The corresponding CDB entry will not be filled!");
 498                                 error |= 64;
 499                         }
 500                         else {
 501                                 TString titleCTPtiming = Form("CTP timing params for run %i from DAQ",fRun);
 502                                 runCTPtiming->SetTitle(titleCTPtiming);
 503                                 AliCDBMetaData metadata;
 504                                 metadata.SetBeamPeriod(0);
 505                                 metadata.SetResponsible("Roman Lietava");
 506                                 metadata.SetComment("CTP timing params from DAQ logbook");
 507                                 if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
 508                                         Log("Unable to store the CTP timing params object to OCDB!");
 509                                         error |= 64;
 510                                 }
 511                         }
 512                 }
 513
 514                 else {
 515                         Log("Trigger timing params NULL in DAQ logbook");
 516                         error |= 64;
 517                 }
 518         }
 519
 520         else {
 521                 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger timing parameters...",partition.Data(),detector.Data()));
 522                 error |= 32;
 523         }
 524
 525         //===========================//
 526         // LTU Configuration         //
 527         //===========================//
 528
 529         Log("*************** Processing LTU Configuration");
 530
 531         if (partition.IsNull() && !detector.IsNull()){ // standalone partition
 532                 Log("STANDALONE partition for current run, not retrieving LTU configuration");
 533                 /*
 534                 Log("STANDALONE partition for current run, using LTU configuration dummy value");
 535                 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyLTUConfig");
 536                 if (!cdbEntry) {
 537                         Log(Form("No dummy LTU Config entry found, going into error..."));
 538                         error |= 2048;
 539                 }
 540                 else{
 541                         TObjArray *ltuConfig = (TObjArray*)cdbEntry->GetObject();
 542                         if (!ltuConfig){
 543                                 Log(Form("dummy LTU Config not found in OCDB entry, going into error..."));
 544                                 error |= 2048;
 545                         }
 546                         else {
 547                                 AliCDBMetaData metadata;
 548                                 metadata.SetResponsible("Roman Lietava");
 549                                 metadata.SetComment("LTU Config from dummy entry in OCDB");
 550                                 if (!Store("CTP","LTUConfig", ltuConfig, &metadata, 0, 0)) {
 551                                         Log("Unable to store the dummy LTU Config object to OCDB!");
 552                                         error |= 2048;
 553                                 }
 554                         }
 555                 }
 556                 */
 557         }
 558
 559         else if (!partition.IsNull() && detector.IsNull()){ // global partition
 560
 561                 Log("GLOBAL partition for current run, getting LTU Config from DAQ Logbook (logbook_detectors table)");
 562                 UInt_t  detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
 563                 Printf ("detectormask = %d",detectorMask);
 564                 TObjArray * ltuarray = new TObjArray();
 565                 ltuarray->SetOwner(1);
 566                 Bool_t isLTUok = kTRUE;
 567                 for(Int_t i = 0; i<AliDAQ::kNDetectors-2; i++){
 568                         if ((detectorMask >> i) & 0x1) {
 569                                 TString det = AliDAQ::OfflineModuleName(i);
 570                                 TString detCTPName = AliTriggerInput::fgkCTPDetectorName[i];
 571                                 if (detCTPName == "CTP") {
 572                                         detCTPName="TRG"; // converting according to what is found in DAQ logbook_detectors
 573                                         Printf("Processing CTP (CTP Detector name %s) --> SKIPPING, CTP does not have any LTU!!!!!!",detCTPName.Data());
 574                                         continue;
 575                                 }
 576                                 Printf("Processing detector %s (CTP Detector name %s)",det.Data(),detCTPName.Data());
 577                                 TString* ltu = GetLTUConfig(detCTPName.Data());
 578                                 if (!ltu){
 579                                         Log(Form("No LTU Configuration from DAQ logbook for detector %s (BUT it was expected)! The corresponding CDB entry will not be filled!",detCTPName.Data()));
 580                                         error |= 2048;
 581                                         isLTUok = kFALSE;
 582                                         break;
 583                                 }
 584                                 else{
 585                                         Float_t ltuFineDelay1 = ltu[0].Atof();
 586                                         Float_t ltuFineDelay2 = ltu[1].Atof();
 587                                         Float_t ltuBCDelayAdd = ltu[2].Atof();
 588                                         const char* name = AliDAQ::DetectorName(i);
 589                                         AliLTUConfig* ltuConfig = new AliLTUConfig((UChar_t)AliDAQ::DetectorID(name),ltuFineDelay1,ltuFineDelay2,ltuBCDelayAdd);
 590                                         ltuarray->AddAtAndExpand(ltuConfig,i);
 591                                 }
 592                         }
 593                 }
 594                 if (isLTUok){
 595                         AliCDBMetaData metadata;
 596                         metadata.SetBeamPeriod(0);
 597                         metadata.SetResponsible("Roman Lietava");
 598                         metadata.SetComment("LTU Configuration for current run");
 599                         if (!Store("CTP","LTUConfig", ltuarray, &metadata, 0, 0)) {
 600                                 Log("Unable to store the LTU Config object to OCDB!");
 601                                 error |= 2048;
 602                         }
 603                 }
 604                 if (ltuarray) delete ltuarray;
 605         }
 606
 607         else {
 608                 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger timing parameters...",partition.Data(),detector.Data()));
 609                 error |= 32;
 610         }
 611
 612
 613         //=================//
 614         // LHC Data        //
 615         //=================//
 616
 617         if (runType == "PHYSICS"){  // processing the LHC file only in PHYSICS runs
 618                 Log("*************** Processing LHC Data");
 619
 620                 UInt_t iLHCData = ProcessLHCData(grpobj);
 621
 622                 if( iLHCData == 0 ) {
 623                         Log(Form("LHC Data from DCS FXS, successful!"));
 624                 } else  if (iLHCData == 1) {
 625                         Log(Form("LHC Data, problems with DCS FXS!"));
 626                         error |= 256;
 627                 } else  if (iLHCData == 2) {
 628                         Log(Form("LHC Data, problems with DAQ_time_start/DAQ_time_end!"));
 629                         error |= 512;
 630                 } else if (iLHCData ==3){
 631                         Log(Form("Problems in storing LHC Phase - going into Error"));
 632                         error |= 1024;
 633                 } else if (iLHCData ==4){
 634                         Log(Form("Problems with LHC Phase - going into Error"));
 635                         error |= 1024;
 636                 } else{
 637                         Log(Form("LHC Data problems"));
 638                         error |= 512;
 639                 }
 640
 641         }
 642
 643         //==================//
 644         // SPD Mean Vertex  //
 645         //==================//
 646
 647         Log("*************** Processing SPD Mean Vertex");
 648
 649         if (runType == "PHYSICS"){
 650                 UInt_t iSPDMeanVertex = ProcessSPDMeanVertex();
 651                 if( iSPDMeanVertex == 1 ) {
 652                         Log(Form("SPD Mean Vertex, successful!"));
 653                 } else {
 654                         Log(Form("SPD Mean Vertex failed!!!"));
 655                         error |= 128;
 656                 }
 657         }
 658         else {
 659                 Log("SPD Mean Vertex not processed since runType != PHYSICS");
 660         }
 661
 662         // storing AliGRPObject in OCDB
 663
 664         AliCDBMetaData md;
 665         md.SetResponsible("Chiara Zampolli");
 666         md.SetComment("Output parameters from the GRP preprocessor.");
 667
 668         Bool_t result = kTRUE;
 669         result = Store("GRP", "Data", grpobj, &md);
 670         delete grpobj;
 671
 672         if (result && !error ) {
 673                 Log("GRP Preprocessor Success");
 674                 return 0;
 675         } else {
 676                 Log( Form("GRP Preprocessor FAILS!!! %s%s%s%s%s%s%s%s%s%s%s%s",
 677                           kppError[(error&1)?1:0],
 678                           kppError[(error&2)?2:0],
 679                           kppError[(error&4)?3:0],
 680                           kppError[(error&8)?4:0],
 681                           kppError[(error&16)?5:0],
 682                           kppError[(error&32)?6:0],
 683                           kppError[(error&64)?7:0],
 684                           kppError[(error&128)?8:0],
 685                           kppError[(error&256)?9:0],
 686                           kppError[(error&512)?10:0],
 687                           kppError[(error&1024)?11:0],
 688                           kppError[(error&2048)?12:0]
 689                           ));
 690                 return error;
 691         }
 692
 693
 694 }
 695
 696 //_______________________________________________________________
 697
 698 UInt_t AliGRPPreprocessor::ProcessLHCData(AliGRPObject *grpobj)
 699 {
 700         //
 701         //Getting the LHC Data from DCS FXS
 702         //
 703
 704         TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
 705         TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
 706         if (timeStartString.IsNull() || timeEndString.IsNull()){
 707                 if (timeStartString.IsNull()){
 708                         AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
 709                 }
 710                 else if (timeEndString.IsNull()){
 711                         AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
 712                 }
 713                 return 2;
 714         }
 715
 716         Double_t timeStart = timeStartString.Atof();
 717         Double_t timeEnd = timeEndString.Atof();
 718
 719         TString fileName = GetFile(kDCS, "LHCData","");
 720         if (fileName.Length()>0){
 721                 AliInfo("Got The LHC Data file");
 722                 AliLHCReader lhcReader;
 723
 724                 // Processing data to be put in AliGRPObject
 725
 726                 // Energy
 727                 Log("*************Energy ");
 728                 TObjArray* energyArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[0]);
 729                 if (energyArray){
 730                         Float_t energy = ProcessEnergy(energyArray,timeStart);
 731                         if (energy != -1.) {
 732                                 grpobj->SetBeamEnergy(energy);
 733                                 grpobj->SetBeamEnergyIsSqrtSHalfGeV(kTRUE);
 734                         }
 735                         delete energyArray;
 736                 }
 737                 else {
 738                         AliError("Energy not found in LHC Data file!!!");
 739                 }
 740
 741                 Double_t timeBeamModeEnd = timeEnd;        // max validity for Beam Mode
 742                 Double_t timeMachineModeEnd = timeEnd;     // max validity for Machine Mode
 743                 Double_t timeBeamEnd = timeEnd;            // max validity for Beam Type
 744                 Double_t timeBeamModeStart = -1;    // min validity for Beam Mode
 745                 Double_t timeMachineModeStart = -1; // min validity for Machine Mode
 746                 Double_t timeBeamStart = -1;        // min validity for Beam Type
 747                 Int_t indexBeamMode = -1;                  // index of measurement used to set Beam Mode
 748                 Int_t indexMachineMode = -1;               // index of measurement used to set Beam Mode
 749                 Int_t indexBeam = -1;                      // index of measurement used to set Beam Mode
 750                 Bool_t foundBeamModeStart = kFALSE;        // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
 751                 Bool_t foundMachineModeStart = kFALSE;     // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
 752                 Bool_t foundBeamStart = kFALSE;            // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
 753                 Bool_t flagBeamMode = kFALSE;  //flag set true if a changed occurred in BeamMode
 754                 Bool_t flagMachineMode = kFALSE;  //flag set true if a changed occurred in MachineMode
 755                 Bool_t flagBeam = kFALSE;  //flag set true if a changed occurred in BeamType
 756
 757                 // BeamMode
 758                 Log("*************BeamMode (LHCState) ");
 759                 TObjArray* beamModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[2]);
 760                 Int_t nBeamMode = -1;
 761                 if (beamModeArray){
 762                         nBeamMode = beamModeArray->GetEntries();
 763                         if (nBeamMode==0){
 764                                 AliInfo("Found zero entries for the Beam Mode, leaving it empty");
 765                         }
 766                         else{
 767                                 for (Int_t iBeamMode = 0; iBeamMode<nBeamMode; iBeamMode++){
 768                                         AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(iBeamMode);
 769                                         if (beamMode){
 770                                                 if (beamMode->GetTimeStamp()<=timeStart && beamMode->GetTimeStamp()>=timeBeamModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
 771                                                         timeBeamModeStart = beamMode->GetTimeStamp();
 772                                                         indexBeamMode = iBeamMode;
 773                                                         foundBeamModeStart = kTRUE;
 774                                                 }
 775                                                 else {
 776                                                         break;
 777
 778                                                 }
 779                                         }
 780                                 }
 781                                 if (!foundBeamModeStart){
 782                                         AliInfo("No value for the Beam Mode found before start of run, the Beam Mode will remain empty");
 783                                 }
 784                                 else {
 785                                         AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(indexBeamMode);
 786                                         TObjString* beamModeString = beamMode->GetStringArray(0);
 787                                         AliInfo(Form("LHC State (corresponding to BeamMode) = %s (set at %f)",(beamModeString->String()).Data(),beamMode->GetTimeStamp()));
 788                                         grpobj->SetLHCState(beamModeString->String());
 789                                         if (indexBeamMode < nBeamMode-1){
 790                                                 AliDCSArray* beamMode1 = (AliDCSArray*)beamModeArray->At(indexBeamMode+1);
 791                                                 if (beamMode1){
 792                                                         if (beamMode1->GetTimeStamp()<=timeStart){
 793                                                                 AliError("you did not choose the correct value! there is still something before (or at) SOR, but later than this!");
 794                                                         }
 795                                                         else if (beamMode1->GetTimeStamp()>timeStart && beamMode1->GetTimeStamp()<=timeEnd){
 796                                                                 timeBeamModeEnd = beamMode1->GetTimeStamp();
 797                                                                 TObjString* beamModeString1 = beamMode1->GetStringArray(0);
 798                                                                 TString bmString0 = beamModeString->String();
 799                                                                 TString bmString1 = beamModeString1->String();
 800                                                                 if (bmString0.CompareTo(bmString1.Data(),TString::kIgnoreCase) == -1){
 801                                                                         AliWarning(Form("The beam mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",bmString0.Data(), bmString1.Data(), timeBeamModeEnd, bmString0.Data()));
 802                                                                         flagBeamMode = kTRUE;
 803                                                                 }
 804                                                         }
 805                                                 }
 806                                                 else {
 807                                                         AliInfo("Invalid pointer for the first entry for Beam Mode after the first valid one, not considering anything after what has already been found");
 808                                                 }
 809                                         }
 810                                 }
 811                         }
 812                         delete beamModeArray;
 813                 }
 814                 else{
 815                         AliError("Beam mode array not found in LHC Data file!!!");
 816                 }
 817
 818                 // MachineMode
 819                 Log("*************MachineMode ");
 820                 TObjArray* machineModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[1]);
 821                 Int_t nMachineMode = -1;
 822                 if (machineModeArray){
 823                         nMachineMode = machineModeArray->GetEntries();
 824                         if (nMachineMode==0){
 825                                 AliInfo("No Machine Mode found, leaving it empty");
 826                         }
 827                         else{
 828                                 for (Int_t iMachineMode = 0; iMachineMode<nMachineMode; iMachineMode++){
 829                                         AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(iMachineMode);
 830                                         if (machineMode){
 831                                                 if (machineMode->GetTimeStamp()<=timeStart && machineMode->GetTimeStamp()>=timeMachineModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
 832                                                         timeMachineModeStart = machineMode->GetTimeStamp();
 833                                                         indexMachineMode = iMachineMode;
 834                                                         foundMachineModeStart = kTRUE;
 835                                                 }
 836                                                 else{
 837                                                         break;
 838                                                 }
 839                                         }
 840                                 }
 841                                 if (!foundMachineModeStart){
 842                                         AliInfo("No value for the Machine Mode found before start of run, the Machine Mode will remain empty");
 843                                 }
 844                                 else {
 845                                         AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(indexMachineMode);
 846                                         TObjString* machineModeString = machineMode->GetStringArray(0);
 847                                         AliInfo(Form("MachineMode = %s (set at %f)",(machineModeString->String()).Data(),machineMode->GetTimeStamp()));
 848                                         grpobj->SetMachineMode(machineModeString->String());
 849                                         if (indexMachineMode < nMachineMode-1){
 850                                                 AliDCSArray* machineMode1 = (AliDCSArray*)machineModeArray->At(indexMachineMode+1);
 851                                                 if (machineMode1){
 852                                                         if (machineMode1->GetTimeStamp()>timeStart && machineMode1->GetTimeStamp()<=timeEnd){
 853                                                                 timeMachineModeEnd = machineMode1->GetTimeStamp();
 854                                                                 TObjString* machineModeString1 = machineMode1->GetStringArray(0);
 855                                                                 TString mmString0 = machineModeString->String();
 856                                                                 TString mmString1 = machineModeString1->String();
 857                                                                 if (mmString0.CompareTo(mmString1.Data(),TString::kIgnoreCase) == -1){
 858                                                                         AliWarning(Form("The machine mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",mmString0.Data(),mmString1.Data(),timeMachineModeEnd,mmString0.Data()));
 859                                                                         flagMachineMode = kTRUE;
 860                                                                 }
 861                                                         }
 862                                                 }
 863                                                 else {
 864                                                         AliInfo("Invalid pointer for the first entry for Machine Mode after the first valid one, not considering anything after what has already been found");
 865                                                 }
 866                                         }
 867                                 }
 868                         }
 869                         delete machineModeArray;
 870                 }
 871                 else{
 872                         AliError("Machine mode array not found in LHC Data file!!!");
 873                 }
 874
 875                 // BeamType1 and BeamType2 - both put in the same string
 876                 Log("*************BeamType ");
 877                 TObjArray* beamArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[3]);
 878                 if (beamArray){
 879                         Int_t nBeam = beamArray->GetEntries();
 880                         if (nBeam==0){
 881                                 AliInfo("No Beam Type found, leaving it empty");
 882                         }
 883                         else{
 884                                 for (Int_t iBeam = 0; iBeam<nBeam; iBeam++){
 885                                         AliDCSArray* beam = (AliDCSArray*)beamArray->At(iBeam);
 886                                         if (beam){
 887                                                 if (beam->GetTimeStamp()<=timeStart && beam->GetTimeStamp()>=timeBeamStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
 888                                                         timeBeamStart = beam->GetTimeStamp();
 889                                                         indexBeam = iBeam;
 890                                                         foundBeamStart = kTRUE;
 891                                                 }
 892                                                 else{
 893                                                         break;
 894                                                 }
 895                                         }
 896                                 }
 897                                 if (!foundBeamStart){
 898                                         AliInfo("No value for the Beam Type found before start of run, the Machine Mode will remain empty");
 899                                 }
 900                                 else {
 901                                         AliDCSArray* beam = (AliDCSArray*)beamArray->At(indexBeam);
 902                                         TObjString* beamString = beam->GetStringArray(0);
 903                                         TString beamType = beamString->String();
 904                                         AliInfo(Form("Beam Type = %s",beamType.Data()));
 905                                         if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
 906                                                 AliInfo("Setting beam type to p-p");
 907                                                 grpobj->SetBeamType("p-p");
 908                                         }
 909                                         else { // if there is no PROTON beam, we suppose it is Pb, and we put A-A
 910                                                 AliInfo("Setting beam type to A-A");
 911                                                 grpobj->SetBeamType("A-A");
 912                                         }
 913                                         /*
 914                                           else if (beamType.CompareTo("LEAD82",TString::kIgnoreCase) == 0){
 915                                                 AliInfo("Setting beam type to Pb-Pb");
 916                                                 grpobj->SetBeamType("Pb-Pb");
 917                                         }
 918                                         else{
 919                                                 AliError("Beam Type not known, leaving it empty");
 920                                         }
 921                                         */
 922                                         if (indexBeam < nBeam-1){
 923                                                 AliDCSArray* beam1 = (AliDCSArray*)beamArray->At(indexBeam+1);
 924                                                 if (beam1){
 925                                                         if (beam1->GetTimeStamp()>timeStart && beam1->GetTimeStamp()<=timeEnd){
 926                                                                 timeBeamEnd = beam1->GetTimeStamp();
 927                                                                 TObjString* beamString1 = beam1->GetStringArray(0);
 928                                                                 TString beamType1 = beamString1->String();
 929                                                                 if (beamType.CompareTo(beamType1.Data(),TString::kIgnoreCase) == -1){
 930                                                                         AliWarning(Form("The Beam Type changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",beamType.Data(),(beamString1->String()).Data(),timeBeamEnd,beamType.Data()));
 931                                                                         flagBeam = kTRUE;
 932                                                                 }
 933                                                         }
 934                                                 }
 935                                                 else {
 936                                                         AliInfo("Invalid pointer for the first entry for Beam Type after the first valid one, not considering anything after what has already been found");
 937                                                 }
 938                                         }
 939                                 }
 940                         }
 941                         delete beamArray;
 942                 }
 943                 else{
 944                         AliError("Beam Type array not found in LHC Data file!!!");
 945                 }
 946
 947                 // Setting minTimeLHCValidity
 948                 if (timeBeamModeEnd!=0 || timeMachineModeEnd!=0 || timeBeamEnd !=0){
 949                         Double_t minTimeLHCValidity;
 950                         if (flagBeamMode == kFALSE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam only true
 951                                 minTimeLHCValidity = timeBeamEnd;
 952                         }
 953                         else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode only true
 954                                 minTimeLHCValidity = timeMachineModeEnd;
 955                         }
 956                         else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kFALSE){ // flagBeamMode only true
 957                                 minTimeLHCValidity = timeBeamModeEnd;
 958                         }
 959                         else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kTRUE){ // flagBeam and flagMachineMode only true
 960                                 minTimeLHCValidity= TMath::Min(timeBeamEnd,timeMachineModeEnd);
 961                         }
 962                         else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam and flagBeamMode only true
 963                                 minTimeLHCValidity= TMath::Min(timeBeamEnd,timeBeamModeEnd);
 964                         }
 965                         else if (flagBeamMode == kTRUE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode and flagBeamMode only true
 966                                 minTimeLHCValidity= TMath::Min(timeMachineModeEnd,timeBeamModeEnd);
 967                         }
 968                         else {
 969                                 Double_t arrayTimes[3] = {timeBeamModeEnd,timeMachineModeEnd,timeBeamEnd};// flagMachineMode and flagBeamMode and flagBeam
 970                                 minTimeLHCValidity= TMath::MinElement(3,arrayTimes);
 971                         }
 972                         AliWarning(Form("Setting MaxTimeLHCValidity to %f",minTimeLHCValidity));
 973                         grpobj->SetMaxTimeLHCValidity(minTimeLHCValidity);
 974                 }
 975
 976                 // Processing data to go to AliLHCData object
 977                 AliLHCData* dt = new AliLHCData(fileName.Data(),timeStart,timeEnd);
 978                 // storing AliLHCData in OCDB
 979                 if (dt){
 980                   AliInfo(Form("Filled %d records to AliLHCData object",dt->GetData().GetEntriesFast()));
 981                   AliCDBMetaData md;
 982                   md.SetResponsible("Ruben Shahoyan");
 983                   md.SetComment("LHC data from the GRP preprocessor.");
 984                   Bool_t result = kTRUE;
 985                   result = Store("GRP", "LHCData", dt, &md);
 986                   delete dt;
 987                   if (!result){
 988                         Log(Form("Problems in storing LHC Data - but not going into Error"));
 989                   }
 990                 }
 991
 992                 // processing LHC Phase
 993
 994                 TObjArray *beam1phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[4]);
 995                 TObjArray *beam2phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[5]);
 996                 if (beam1phase == 0x0 || beam2phase == 0x0){
 997                         Log(Form("Problems in retrieving LHC Clock data from LHC file"));
 998                         return 4;
 999                 }
1000                 AliLHCClockPhase *phaseObj = ProcessLHCClockPhase(beam1phase,beam2phase,timeEnd);
1001                 if (phaseObj){
1002                         AliInfo(Form("LHC Phase found"));
1003                         AliCDBMetaData mdPhase;
1004                         mdPhase.SetResponsible("Cvetan Cheshkov");
1005                         mdPhase.SetComment("LHC Clock Phase");
1006                         Bool_t result = kTRUE;
1007                         result = Store("Calib", "LHCClockPhase", phaseObj, &mdPhase);
1008                         delete phaseObj;
1009                         if (!result) return 3;
1010                 }
1011                 else return 4;
1012         }
1013
1014         else {
1015                 AliError("No LHCData file found in DCS FXS");
1016                 return 1;
1017         }
1018
1019         return 0;
1020 }
1021
1022 //_______________________________________________________________
1023
1024 UInt_t AliGRPPreprocessor::ProcessSPDMeanVertex()
1025 {
1026         //
1027         //Getting the SPD Mean Vertex
1028         //
1029
1030         TList* list = GetForeignFileSources("SPD", kDAQ, "VertexDiamond");
1031         Bool_t storeResult = kTRUE;
1032         if (list !=0x0 && list->GetEntries()!=0)
1033                 {
1034                         AliInfo("The following sources produced files with the id VertexDiamond from SPD");
1035                         list->Print();
1036                         for (Int_t jj=0;jj<list->GetEntries();jj++){
1037                                 TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
1038                                 AliInfo(Form("found source %s", str->String().Data()));
1039                                 TString fileNameRun = GetForeignFile("SPD", kDAQ, "VertexDiamond", str->GetName());
1040                                 if (fileNameRun.Length()>0){
1041                                         AliInfo(Form("Got the file %s", fileNameRun.Data()));
1042                                         TFile daqFile(fileNameRun.Data(),"READ");
1043                                         if (daqFile.IsOpen()) {
1044                                                 AliESDVertex* meanVtx = dynamic_cast<AliESDVertex*>(daqFile.Get("MeanVertexPos"));
1045                                                 if (meanVtx){
1046                                                         meanVtx->Print();
1047                                                         // storing in the OCDB
1048                                                         AliCDBMetaData md;
1049                                                         md.SetResponsible("Cvetan Cheshkov");
1050                                                         md.SetComment("SPD Mean Vertex");
1051                                                         storeResult = Store("Calib", "MeanVertexSPD", meanVtx, &md, 0, kTRUE);
1052                                                 }
1053                                                 else{
1054                                                         AliWarning("No SPD Mean Vertex object found in file");
1055                                                 }
1056                                         }
1057                                         else {
1058                                                 AliError("Can't open file");
1059                                                 storeResult = kFALSE;
1060                                         }
1061                                 }
1062                                 else{
1063                                         AliWarning("No file found for current source for SPD Mean Vertex");
1064                                 }
1065                         }
1066                 }
1067         else {
1068                 AliWarning("No list found for SPD Mean Vertex");
1069         }
1070
1071         if (list) delete list;
1072
1073         return storeResult;
1074 }
1075
1076
1077 //_______________________________________________________________
1078
1079 Int_t AliGRPPreprocessor::ProcessDaqLB(AliGRPObject* grpObj)
1080 {
1081         //Getting the DAQ lb information
1082
1083         time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
1084         time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
1085         Float_t beamEnergy = (Float_t)(((TString)GetRunParameter("beamEnergy")).Atof());
1086         TString beamType = (TString)GetRunParameter("beamType");
1087         Char_t numberOfDetectors = (Char_t)(((TString)GetRunParameter("numberOfDetectors")).Atoi());
1088         UInt_t  detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
1089         TString lhcPeriod = (TString)GetRunParameter("LHCperiod");
1090         TString runType = (TString)GetRunType();
1091
1092         UInt_t nparameter = 0;
1093         if (timeStart != 0){
1094                 grpObj->SetTimeStart(timeStart);
1095                 Log(Form("Start time for run %d: %d",fRun, (Int_t)timeStart));
1096                 nparameter++;
1097         }
1098         else {
1099                 Log(Form("Start time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1100         }
1101
1102         if (timeEnd != 0){
1103                 grpObj->SetTimeEnd(timeEnd);
1104                 Log(Form("End time for run %d: %i",fRun, (Int_t)timeEnd));
1105                 nparameter++;
1106         }
1107         else {
1108                 Log(Form("End time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1109         }
1110
1111         if (beamEnergy != 0){
1112                 Log(Form("Beam Energy for run %d: %f (NOT USING IT TO FILL THE GRP OBJECT, taking it from the LHC file)",fRun, beamEnergy));
1113         }
1114         else {
1115                 Log(Form("Beam Energy not put in logbook, but not using it anyway for the GRP object (taking it from the LHC file)"));
1116         }
1117
1118
1119         if (beamType.Length() != 0){
1120                 Log(Form("Beam Type for run %d: %s (NOT USING IT TO FILL THE GRP OBJECT, taking it from the LHC file)",fRun, beamType.Data()));
1121         }
1122         else {
1123                 Log(Form("Beam Type not put in logbook, but not using it anyway for the GRP entry (taking it from the LHC file)"));
1124         }
1125
1126         if (numberOfDetectors != 0){
1127                 grpObj->SetNumberOfDetectors(numberOfDetectors);
1128                 Log(Form("Number Of Detectors for run %d: %d",fRun, (Int_t)numberOfDetectors));
1129                 nparameter++;
1130         }
1131         else {
1132                 Log(Form("Number Of Detectors not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1133         }
1134
1135         if (detectorMask != 0){
1136                 grpObj->SetDetectorMask(detectorMask);
1137                 Log(Form("Detector Mask for run %d: %d",fRun, detectorMask));
1138                 nparameter++;
1139         }
1140         else {
1141                 Log(Form("Detector Mask not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1142         }
1143
1144         if (lhcPeriod.Length() != 0) {
1145                 grpObj->SetLHCPeriod(lhcPeriod);
1146                 Log(Form("LHC period (DAQ) for run %d: %s",fRun, lhcPeriod.Data()));
1147                 nparameter++;
1148         }
1149         else {
1150                 Log(Form("LHCperiod not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1151         }
1152         if (runType.Length() != 0) {
1153                 grpObj->SetRunType(runType);
1154                 Log(Form("Run Type (DAQ) for run %d: %s",fRun, runType.Data()));
1155                 nparameter++;
1156         }
1157         else {
1158                 Log(Form("Run Type not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1159         }
1160
1161         return nparameter;
1162 }
1163
1164 //_______________________________________________________________
1165
1166 UInt_t AliGRPPreprocessor::ProcessDaqFxs()
1167 {
1168         //======DAQ FXS======//
1169
1170         AliRawEventHeaderV3_9::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_9 - temporary fix
1171         TList* list = GetFileSources(kDAQ);
1172         if (!list) {
1173                 Log("No raw data tag list: connection problems with DAQ FXS logbook!");
1174                 return 1;
1175         }
1176
1177         if (list->GetEntries() == 0) {
1178                 Log("no raw data tags in this run: nothing to merge!");
1179                 delete  list; list=0;
1180                 return 0;
1181         }
1182
1183         TChain *fRawTagChain = new TChain("T");
1184         Int_t nFiles=0;
1185         TIterator* iter = list->MakeIterator();
1186         TObject* obj = 0;
1187         while ((obj = iter->Next())) {
1188                 TObjString* objStr = dynamic_cast<TObjString*> (obj);
1189                 if (objStr) {
1190                         Log(Form("Found source %s", objStr->String().Data()));
1191                         TList* list2 = GetFileIDs(kDAQ, objStr->String());
1192                         if (!list2) {
1193                                 Log("No list with ids from DAQ was found: connection problems with DAQ FXS logbook!");
1194                                 delete fRawTagChain; fRawTagChain=0;
1195                                 return 1;
1196                         }
1197                         Log(Form("Number of ids: %d",list2->GetEntries()));
1198                         for(Int_t i = 0; i < list2->GetEntries(); i++) {
1199                                 TObjString *idStr = (TObjString *)list2->At(i);
1200                                 TString fileName = GetFile(kDAQ,idStr->String().Data(),objStr->String().Data());
1201                                 if (fileName.Length() > 0) {
1202                                         Log(Form("Adding file in the chain: %s",fileName.Data()));
1203                                         fRawTagChain->Add(fileName.Data());
1204                                         nFiles++;
1205                                 } else {
1206                                         Log(Form("Could not retrieve file with id %s from source %s: "
1207                                                  "connection problems with DAQ FXS!",
1208                                                  idStr->String().Data(), objStr->String().Data()));
1209                                         delete list; list=0;
1210                                         delete list2; list2=0;
1211                                         delete fRawTagChain; fRawTagChain=0;
1212                                         return 2;
1213                                 }
1214                         }
1215                         delete list2;
1216                 }
1217         }
1218
1219         TString fRawDataFileName = "GRP_Merged.tag.root";
1220         Log(Form("Merging %d raw data tags into file: %s", nFiles, fRawDataFileName.Data()));
1221
1222         if( fRawTagChain->Merge(fRawDataFileName) < 1 ) {
1223                 Log("Error merging raw data files!!!");
1224                 return 3;
1225         }
1226
1227         TString outputfile = Form("Run%d.Merged.RAW.tag.root", fRun);
1228         Bool_t result = StoreRunMetadataFile(fRawDataFileName.Data(),outputfile.Data());
1229
1230         if (!result) {
1231                 Log("Problem storing raw data tags in local file!!!");
1232         } else {
1233                 Log("Raw data tags merged successfully!!");
1234         }
1235
1236         delete iter;
1237         delete list;
1238         delete fRawTagChain; fRawTagChain=0;
1239
1240         if (result == kFALSE) {
1241                 return 4;
1242         }
1243
1244         return 0;
1245
1246 }
1247
1248 //_______________________________________________________________
1249 UInt_t AliGRPPreprocessor::ProcessDcsFxs(TString partition, TString detector)
1250 {
1251
1252         // processing the info
1253         // stored in the DCS FXS
1254         // coming from the trigger
1255
1256         // Get the CTP counters information
1257
1258         if (partition.IsNull() && !detector.IsNull()){ // standalone partition
1259                 Log("STANDALONE partition for current run, using Trigger Scalers dummy value");
1260                 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyScalers");
1261                 if (!cdbEntry) {
1262                         Log(Form("No dummy CTP scalers entry found, going into error..."));
1263                         return 1;
1264                 }
1265                 else{
1266                         AliTriggerRunScalers *scalers = (AliTriggerRunScalers*)cdbEntry->GetObject();
1267                         if (!scalers){
1268                                 Log(Form("CTP dummy scalers not found in OCDB entry, going into error..."));
1269                                 return 1;
1270                         }
1271                         else {
1272                                 AliCDBMetaData metaData;
1273                                 metaData.SetResponsible("Roman Lietava");
1274                                 metaData.SetComment("CTP scalers from dummy entry in OCDB");
1275                                 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1276                                         Log("Unable to store the dummy CTP scalers object to OCDB!");
1277                                         return 1;
1278                                 }
1279                         }
1280                 }
1281         }
1282
1283         else if (!partition.IsNull() && detector.IsNull()){ // global partition
1284                 Log("GLOBAL partition for current run, using CTP scalers from DCS FXS");
1285                 TString countersfile = GetFile(kDCS, "CTP_xcounters","");
1286                 if (countersfile.IsNull()) {
1287                         Log("No CTP counters files has been found: empty source!");
1288                         return 1;
1289                 }
1290                 else {
1291                         Log(Form("File with Id CTP_xcounters found in DCS FXS! Copied to %s",countersfile.Data()));
1292                         AliTriggerRunScalers *scalers = AliTriggerRunScalers::ReadScalers(countersfile);
1293                         if (!scalers) {
1294                                 Log("Bad CTP counters file! The corresponding CDB entry will not be filled!");
1295                                 return 1;
1296                         }
1297                         else {
1298                                 AliCDBMetaData metaData;
1299                                 metaData.SetBeamPeriod(0);
1300                                 metaData.SetResponsible("Roman Lietava");
1301                                 metaData.SetComment("CTP scalers");
1302                                 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1303                                         Log("Unable to store the CTP scalers object to OCDB!");
1304                                         delete scalers;
1305                                         return 1;
1306                                 }
1307                         }
1308                         delete scalers;
1309                 }
1310         }
1311
1312
1313         else{
1314                 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error...",partition.Data(),detector.Data()));
1315                 return 2;
1316         }
1317
1318         return 0;
1319
1320 }
1321 //_______________________________________________________________
1322
1323 Int_t AliGRPPreprocessor::ProcessDcsDPs(TMap* valueMap, AliGRPObject* grpObj)
1324 {
1325
1326         //
1327         // processing DCS DPs
1328         //
1329
1330         Int_t entries = 0;  // counting the entries that are in the DCS DB, not taking care whether they have values or not
1331         Int_t nL3Entries = 0;
1332         Int_t nDipoleEntries = 0;
1333         Int_t nEnvEntries = 0;
1334         Int_t nHallProbesEntries = 0;
1335         nL3Entries = ProcessL3DPs(valueMap, grpObj);
1336         nDipoleEntries = ProcessDipoleDPs(valueMap, grpObj);
1337         nEnvEntries = ProcessEnvDPs(valueMap, grpObj);
1338         nHallProbesEntries = ProcessHPDPs(valueMap, grpObj);
1339         grpObj->SetPolarityConventionLHC();  // after the dipole cables swap we comply with LHC convention
1340         Log(Form("L3Entries = %d, nDipoleEntries =%d, nEnvEntries = %d, nHallProbesEntries = %d", nL3Entries, nDipoleEntries, nEnvEntries, nHallProbesEntries));
1341         entries = nL3Entries + nDipoleEntries + nEnvEntries + nHallProbesEntries;
1342         return entries;
1343
1344 }
1345
1346 //_______________________________________________________________
1347
1348 Int_t AliGRPPreprocessor::ProcessL3DPs(const TMap* valueMap, AliGRPObject* grpObj)
1349 {
1350
1351         // processing DPs
1352         // related to
1353         // L3 info
1354
1355         Int_t nL3Entries = 0;
1356
1357         TObjArray *array = 0x0;
1358         Int_t indexDP = -1;
1359         Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
1360
1361         AliInfo(Form("==========L3Current==========="));
1362         Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
1363         indexDP = kL3Current;
1364         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1365         if(!array) {
1366                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1367         }
1368         else {
1369                 if (array->GetEntries() == 0){
1370                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1371                 }
1372                 else {
1373                         Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1374                         if (floatDCS != NULL){
1375                                 grpObj->SetL3Current(floatDCS);
1376                         }
1377                         else{
1378                                 outOfRange = kTRUE;
1379                         }
1380                         if (floatDCS){
1381                                 delete[] floatDCS;
1382                                 floatDCS = 0x0;
1383                         }
1384                 }
1385                 if (!outOfRange) {
1386                         nL3Entries++;
1387                         ffailedDPs->RemoveAt(indexDP);
1388                 }
1389         }
1390
1391         if (array) array = 0x0;
1392
1393         AliInfo(Form("==========L3Polarity==========="));
1394         indexDP = kL3Polarity;
1395         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1396         if(!array) {
1397                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1398         }
1399         else {
1400                 if (array->GetEntries() == 0){
1401                         AliError(Form("No entries found in array! setting %s Polarity to invalid...",fgkDCSDataPoints[indexDP]));
1402                 }
1403                 else {
1404                         Bool_t change = kFALSE;
1405                         Char_t charDCS = ProcessBool(array,change);
1406                         if (change == kFALSE){
1407                                 grpObj->SetL3Polarity(charDCS);
1408                                 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetL3Polarity())));
1409                                 ffailedDPs->RemoveAt(indexDP);
1410                                 nL3Entries++;
1411                         }
1412                         else if (isZero){
1413                                 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
1414                                 ffailedDPs->RemoveAt(indexDP);
1415                                 nL3Entries++;
1416                         }
1417                         else {
1418                                 AliError(Form("%s value changed within the run, while the magnet was ON (according to the current), setting it to invalid and considering the DP as wrong",fgkDCSDataPoints[indexDP]));
1419                         }
1420                 }
1421         }
1422
1423         return nL3Entries;
1424
1425 }
1426 //_______________________________________________________________
1427
1428 Int_t AliGRPPreprocessor::ProcessDipoleDPs(const TMap* valueMap, AliGRPObject* grpObj)
1429 {
1430         // processing DPs
1431         // related to
1432         // the Dipole info
1433
1434         Int_t nDipoleEntries = 0;
1435         TObjArray *array = 0x0;
1436         Int_t indexDP = -1;
1437         Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
1438
1439         AliInfo(Form("==========DipoleCurrent==========="));
1440         Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
1441         indexDP = kDipoleCurrent;
1442         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1443         if(!array) {
1444                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1445         }
1446         else {
1447                 if (array->GetEntries() == 0){
1448                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1449                 }
1450                 else {
1451                         Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1452                         if (floatDCS != NULL){
1453                                 grpObj->SetDipoleCurrent(floatDCS);
1454                         }
1455                         else{
1456                                 outOfRange=kTRUE;
1457                         }
1458                         if (floatDCS){
1459                                 delete[] floatDCS;
1460                                 floatDCS = 0x0;
1461                         }
1462                 }
1463                 if (!outOfRange) {
1464                         nDipoleEntries++;
1465                         ffailedDPs->RemoveAt(indexDP);
1466                 }
1467         }
1468
1469         if (array) array = 0x0;
1470
1471         AliInfo(Form("==========DipolePolarity==========="));
1472         indexDP = kDipolePolarity;
1473         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1474         if(!array) {
1475                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1476         }
1477         else {
1478                 if (array->GetEntries() == 0){
1479                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1480                 }
1481                 else {
1482                         Bool_t change = kFALSE;
1483                         Char_t charDCS = ProcessBool(array,change);
1484                         if (!change){
1485                                 grpObj->SetDipolePolarity(charDCS);
1486                                 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetDipolePolarity())));
1487                                 ffailedDPs->RemoveAt(indexDP);
1488                                 nDipoleEntries++;
1489                         }
1490                         else if (isZero){
1491                                 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
1492                                 ffailedDPs->RemoveAt(indexDP);
1493                                 nDipoleEntries++;
1494                         }
1495                         else{
1496                                 AliError(Form("%s value changed within the run while the magnet was ON (according to the current), setting it to invalid and considering the DP as wrong", fgkDCSDataPoints[indexDP]));
1497                         }
1498                 }
1499         }
1500
1501         return nDipoleEntries;
1502
1503 }
1504 //_______________________________________________________________
1505
1506 Int_t AliGRPPreprocessor::ProcessEnvDPs(TMap* valueMap, AliGRPObject* grpObj)
1507 {
1508         // processing DPs
1509         // related to
1510         // evironment conditions (temperature, pressure) info
1511
1512         Int_t nEnvEntries = 0;
1513         TObjArray *array = 0x0;
1514         Int_t indexDP = -1;
1515
1516         AliInfo(Form("==========CavernTemperature==========="));
1517         Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
1518         indexDP = kCavernTemperature;
1519         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1520         if(!array) {
1521                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1522         }
1523         else {
1524                 if (array->GetEntries() == 0){
1525                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1526                 }
1527                 else {
1528                         Float_t *floatDCS = ProcessFloatAll(array);
1529                         if (floatDCS != NULL){
1530                                 grpObj->SetCavernTemperature(floatDCS);
1531                         }
1532                         else{
1533                                 outOfRange = kTRUE;
1534                         }
1535                         if (floatDCS){
1536                                 delete[] floatDCS;
1537                                 floatDCS = 0x0;
1538                         }
1539                 }
1540                 if (!outOfRange) {
1541                         ffailedDPs->RemoveAt(indexDP);
1542                         nEnvEntries++;
1543                 }
1544         }
1545
1546         if (array) array = 0x0;
1547
1548         AliInfo(Form("========== AtmosPressures (Cavern + Surface + Cavern2) ==========="));
1549         AliDCSSensorArray *dcsSensorArray = GetPressureMap(valueMap);
1550         //dcsSensorArray->Print();
1551         if( fPressure->NumFits()<kNumSensors ) {
1552                 Log(Form("Check the pressure sensor values! Not all the %d pressure sensors have been fit",kNumSensors));
1553         }
1554         Log(Form("Number of fits performed = %d",fPressure->NumFits()));
1555
1556         AliInfo(Form("==========CavernAtmosPressure==========="));
1557         indexDP = kCavernAtmosPressure;
1558         AliDCSSensor* sensorCavernP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
1559         TGraph* graph = sensorCavernP2->GetGraph();
1560         AliDebug(3,Form("index = %d",indexDP));
1561         AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
1562         AliDebug(2,Form("graph = %p",graph));
1563         AliDebug(3,Form("sensorCavernP2 = %p", sensorCavernP2));
1564         if(sensorCavernP2->GetFit() || graph) {
1565                 if (sensorCavernP2->GetFit()){
1566                         Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
1567                 }
1568                 else {
1569                         Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
1570                 }
1571                 grpObj->SetCavernAtmosPressure(sensorCavernP2);
1572                 ffailedDPs->RemoveAt(indexDP);
1573                 nEnvEntries++;
1574         }
1575         //if (sensorP2) delete sensorP2;
1576         else {
1577                 Log(Form("ERROR!!! Neither graph nor fit found for sensor %s - this will not increase the number of found DCS DPs and will cause an error", fgkDCSDataPoints[indexDP] ));
1578         }
1579
1580         AliInfo(Form("==========SurfaceAtmosPressure==========="));
1581         indexDP = kSurfaceAtmosPressure;
1582         AliDCSSensor* sensorP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
1583         graph = sensorP2->GetGraph();
1584         AliDebug(3,Form("index = %d",indexDP));
1585         AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
1586         AliDebug(2,Form("graph = %p",graph));
1587         AliDebug(3,Form("sensorP2 = %p", sensorP2));
1588         if(sensorP2->GetFit() || graph) {
1589                 if (sensorP2->GetFit()){
1590                         Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
1591                 }
1592                 else {
1593                         Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
1594                 }
1595                 grpObj->SetSurfaceAtmosPressure(sensorP2);
1596                 ffailedDPs->RemoveAt(indexDP);
1597                 nEnvEntries++;
1598         }
1599         //if (sensorP2) delete sensorP2;
1600         else {
1601                 Log(Form("ERROR!!! Neither graph nor fit found for sensor %s - this will not increase the number of found DCS DPs and will cause an error", fgkDCSDataPoints[indexDP] ));
1602         }
1603
1604         AliInfo(Form("==========CavernAtmosPressure2==========="));
1605         indexDP = kCavernAtmosPressure2;
1606         AliDCSSensor* sensorCavernP22 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
1607         graph = sensorCavernP22->GetGraph();
1608         AliDebug(3,Form("index = %d",indexDP));
1609         AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
1610         AliDebug(2,Form("graph = %p",graph));
1611         AliDebug(3,Form("sensorCavernP2_2 = %p", sensorCavernP22));
1612         if(sensorCavernP22->GetFit() || graph) {
1613                 if (sensorCavernP22->GetFit()){
1614                         Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
1615                 }
1616                 else {
1617                         Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
1618                 }
1619                 grpObj->SetCavernAtmosPressure2(sensorCavernP22);
1620                 ffailedDPs->RemoveAt(indexDP);
1621                 nEnvEntries++;
1622         }
1623         //if (sensorP2) delete sensorP2;
1624         else {
1625                 Log(Form("ERROR!!! Neither graph nor fit found for sensor %s - this will not increase the number of found DCS DPs and will cause an error", fgkDCSDataPoints[indexDP] ));
1626         }
1627
1628
1629         return nEnvEntries;
1630 }
1631 //_______________________________________________________________
1632
1633 Int_t AliGRPPreprocessor::ProcessHPDPs(const TMap* valueMap, AliGRPObject* grpObj)
1634 {
1635         // processing DPs
1636         // related to
1637         // Hall Probes info
1638
1639         Int_t nHPEntries = 0;
1640         TObjArray *array = 0x0;
1641         Int_t indexDP = -1;
1642         Bool_t outOfRange; // flag to monitor if any value collected by DCS is out of range
1643
1644         if (fgknDCSDPHallProbes != AliGRPObject::GetNumberOfHP()){
1645                 AliError(Form("Number of Hall probes expected in GRP Preprocessor (i.e. %d) different from number of Hall Probes foreseen in GRP object (i.e. %d). Looping on entries from GRP object anyway.", fgknDCSDPHallProbes, AliGRPObject::GetNumberOfHP()));
1646         }
1647         for (indexDP = 0; indexDP < AliGRPObject::GetNumberOfHP(); indexDP++){
1648                 outOfRange = kFALSE; // resetting outOfRange flag at each HP
1649                 AliInfo(Form("==========%s===========",AliGRPObject::GetHPDP(indexDP)));
1650                 array = (TObjArray *)valueMap->GetValue(AliGRPObject::GetHPDP(indexDP));
1651                 if(!array) {
1652                         Log(Form("%s not found in the map!!!",AliGRPObject::GetHPDP(indexDP)));
1653                 }
1654                 else {
1655                         if (array->GetEntries() == 0){
1656                                 AliError(Form("No entries found in array! setting %s to invalid...",AliGRPObject::GetHPDP(indexDP)));
1657                         }
1658                         else {
1659                                 Float_t *floatDCS = ProcessFloatAll(array);
1660                                 if (floatDCS != NULL){
1661                                         AliDebug(2,Form("value[0] = %f, value[1] = %f, value[2] = %f, value[3] = %f, value[4] = %f",floatDCS[0],floatDCS[1],floatDCS[2],floatDCS[3],floatDCS[4]));
1662                                         grpObj->SetHallProbes((AliGRPObject::DP_HallProbes)indexDP,floatDCS);
1663                                         for (Int_t kk = 0 ; kk< 5; kk++){
1664                                                 AliDebug(2,Form("HallProbe[%d][%d]=%f",indexDP,kk,grpObj->GetHallProbes((AliGRPObject::DP_HallProbes)indexDP,(AliGRPObject::Stats)kk)));
1665                                         }
1666                                 }
1667                                 else{
1668                                         outOfRange = kTRUE;
1669                                 }
1670                                 if (floatDCS){
1671                                         delete[] floatDCS;
1672                                         floatDCS = 0x0;
1673                                 }
1674                         }
1675                         if (!outOfRange) {
1676                                 ffailedDPs->RemoveAt(indexDP + fgkDCSDPHallTopShift);  // 7 = shift in the complete list of DPs to get to the Hall Probes
1677                                 nHPEntries++;
1678                         }
1679                 }
1680         }
1681
1682         Log(Form("Hall Probes = %d ", nHPEntries));
1683         return nHPEntries;
1684 }
1685
1686 //_________________________________________________________________________
1687
1688 AliSplineFit* AliGRPPreprocessor::GetSplineFit(const TObjArray *array, const TString& stringID){
1689
1690
1691         //
1692         // returning Spline Fit
1693         //
1694
1695         Int_t entriesarray = array->GetEntries();
1696         Float_t* value = new Float_t[entriesarray];
1697         Float_t* time = new Float_t[entriesarray];
1698         AliDCSValue* v = 0x0;
1699         for (Int_t iarray = 0; iarray < entriesarray; iarray++){
1700                 v = (AliDCSValue*)array->At(iarray);
1701                 value[iarray] = v->GetFloat();
1702                 time[iarray] = v->GetTimeStamp();
1703                 AliDebug(2,Form("iarray = %d, value = %f, time = %f",iarray,value[iarray],time[iarray]));
1704         }
1705         TGraph* gr = new TGraph(entriesarray,value,time);
1706         if (!gr ) {
1707                 AliWarning(Form("%s: no input graph to compute SplineFit",stringID.Data()));
1708                 return NULL;
1709         }
1710         AliSplineFit *fit = new AliSplineFit();
1711         fit->SetMinPoints(10);
1712         fit->InitKnots(gr,10,10,0.0);
1713         fit->SplineFit(2);
1714         fit->Cleanup();
1715         if (!fit) {
1716                 AliWarning(Form("%s: no fit performed",stringID.Data()));
1717                 return NULL;
1718         }
1719         return fit;
1720 }
1721
1722 //_________________________________________________________________________
1723
1724 TString AliGRPPreprocessor::ProcessChar(const TObjArray *array)
1725 {
1726
1727         //
1728         // processing char
1729         //
1730
1731         TString aDCSString="";
1732
1733         AliDCSValue *v = 0x0;
1734         for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1735                 v = (AliDCSValue *)array->At(iCount);
1736                 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
1737                         AliError(Form("DCS values for the parameter outside the queried interval"));
1738                         continue;
1739                 }
1740                 if (iCount > 0) {
1741                         if (aDCSString != v->GetChar())
1742                         AliError(Form("DCS values for the parameter changed from %s to %c within the queried interval", aDCSString.Data(), (Char_t)v->GetChar()));
1743                 }
1744                 aDCSString = (TString)v->GetChar();  // keeping always last value in the array
1745         }
1746         return aDCSString;
1747 }
1748
1749 //__________________________________________________________________________________________________________________
1750
1751 Float_t* AliGRPPreprocessor::ProcessFloatAll(const TObjArray* array)
1752 {
1753         //
1754         // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
1755         //
1756         // parameters[0] = mean
1757         // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
1758         // parameters[2] = median
1759         // parameters[3] = standard deviation wrt mean
1760         // parameters[4] = standard deviation wrt median
1761         //
1762
1763         TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
1764         TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
1765         if (timeStartString.IsNull() || timeStartString.IsNull()){
1766                 if (timeStartString.IsNull()){
1767                         AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
1768                 }
1769                 else if (timeStartString.IsNull()){
1770                         AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
1771                 }
1772                 fdaqStartEndTimeOk = kFALSE;
1773                 return 0;
1774         }
1775
1776         Int_t timeStart = (Int_t)(timeStartString.Atoi());
1777         Int_t timeEnd = (Int_t)(timeEndString.Atoi());
1778         Float_t* parameters = new Float_t[5];
1779         Int_t iCounts = 0;
1780         Int_t iCountsRun = 0;
1781         Int_t nCounts = array->GetEntries();
1782         Float_t valueBeforeSOR = 0;
1783         Float_t valueAfterEOR = 0;
1784         Int_t timestampBeforeSOR = -1;
1785         Int_t timestampAfterEOR = -1;
1786         Int_t ientrySOR = -1;
1787         Int_t ientryEOR = -1;
1788         Float_t* arrayValues = 0x0;
1789         Double_t* arrayWeights = 0x0;
1790         Bool_t truncMeanFlag = kTRUE;  // flag to indicate whether Truncated Mean should be calculated or not
1791         Bool_t sdFlag = kTRUE;  // flag to indicate whether SD (wrt Mean/Median) should be calculated or not
1792
1793         for(Int_t i = 0; i < nCounts; i++) {
1794                 AliDCSValue *v = (AliDCSValue *)array->At(i);
1795                 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
1796                         AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
1797                         if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
1798                         if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
1799                         return NULL;
1800                 }
1801                 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
1802                         AliDebug(2,Form("%d-th entry = %f at timestamp %i",i,v->GetFloat(),v->GetTimeStamp()));
1803                         iCounts += 1;
1804                         // look for the last value before SOR and the first value before EOR
1805                         if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
1806                                 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
1807                                 AliDebug(2,Form("timestamp of last value before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
1808                                 valueBeforeSOR = v->GetFloat();
1809                         }
1810                         else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
1811                                 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
1812                                 valueAfterEOR = v->GetFloat();
1813                                 AliDebug(2,Form("timestamp of first value after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
1814                         }
1815                         // check if there are DPs between DAQ_time_start and DAQ_time_end
1816                         if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
1817                                 if (ientrySOR == -1) ientrySOR = i;  // first entry after SOR
1818                                 if (ientryEOR < i) ientryEOR = i;  // last entry before EOR
1819                                 AliDebug(2,Form("entry between SOR and EOR"));
1820                                 iCountsRun += 1;
1821                         }
1822                 }
1823                 else {
1824                         AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
1825                 }
1826         }
1827
1828         if (timestampBeforeSOR == -1){
1829                 AliWarning("No value found before SOR");
1830         }
1831         if (timestampAfterEOR == -1){
1832                 AliWarning("No value found after EOR");
1833         }
1834
1835         AliDebug(2,Form("Number of valid entries (within DCS query interval) = %i, from a total amount of %i entries",iCounts,nCounts));
1836         AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
1837         AliDebug(2,Form("First value after DAQ_time_end (EOR)   = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
1838         AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
1839         AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
1840         AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
1841
1842         Int_t nentriesUsed = 0;
1843         if (iCountsRun > 1){
1844                 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
1845                 AliDebug(2,"Calculating (weighted) Mean and Median");
1846                 arrayValues = new Float_t[iCountsRun];
1847                 arrayWeights = new Double_t[iCountsRun];
1848                 nentriesUsed = iCountsRun;
1849                 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
1850                         AliDCSValue *v = (AliDCSValue *)array->At(i);
1851                         Int_t timestamp2 = 0;
1852                         if (i < ientryEOR){
1853                                 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
1854                                 timestamp2 = (Int_t)v1->GetTimeStamp();
1855                         }
1856                         else {
1857                                 timestamp2 = timeEnd+1;
1858                         }
1859                         arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
1860                         arrayValues[i-ientrySOR] = v->GetFloat();
1861                 }
1862                 parameters[0] = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
1863                 parameters[2] = TMath::Median(iCountsRun,arrayValues,arrayWeights);
1864         }
1865         else if (iCountsRun == 1){
1866                 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
1867                 nentriesUsed = 2;
1868                 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
1869                         AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR. Truncated mean won't be calculated.");
1870                         arrayValues = new Float_t[2];
1871                         arrayWeights = new Double_t[2];
1872                         arrayValues[0] = valueBeforeSOR;
1873                         arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
1874                         arrayValues[1] = v->GetFloat();
1875                         arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
1876                         AliDebug(2, Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
1877                         AliDebug(2, Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
1878                         parameters[0] = TMath::Mean(2,arrayValues,arrayWeights);
1879                         parameters[2] = TMath::Median(2,arrayValues,arrayWeights);
1880                         truncMeanFlag = kFALSE;
1881                 }
1882                 else{
1883                         AliError("Cannot calculate mean, truncated mean, median, SD wrt mean, SD wrt median for current DP - only one value collected during the run, but no value before with which to calculate the statistical quantities");
1884                         parameters[0] = AliGRPObject::GetInvalidFloat();
1885                         parameters[1] = AliGRPObject::GetInvalidFloat();
1886                         parameters[2] = AliGRPObject::GetInvalidFloat();
1887                         parameters[3] = AliGRPObject::GetInvalidFloat();
1888                         parameters[4] = AliGRPObject::GetInvalidFloat();
1889                         return parameters;
1890                 }
1891         }
1892         else { // iCountsRun == 0, using only the point immediately before SOR
1893                 if (timestampBeforeSOR == -1){
1894                         AliError("Cannot set mean, truncated mean, median, SD wrt mean, SD wrt median for current DP - no points during the run collected, and point before SOR missing");
1895                         parameters[0] = AliGRPObject::GetInvalidFloat();
1896                         parameters[1] = AliGRPObject::GetInvalidFloat();
1897                         parameters[2] = AliGRPObject::GetInvalidFloat();
1898                         parameters[3] = AliGRPObject::GetInvalidFloat();
1899                         parameters[4] = AliGRPObject::GetInvalidFloat();
1900                         return parameters;
1901                 }
1902                 else {
1903                         AliWarning("Using only last entry before SOR. Truncated mean and Standard deviations (wrt mean/median) won't be calculated.");
1904                         AliDebug(2,Form("value = %f",valueBeforeSOR));
1905                         parameters[0] = valueBeforeSOR;
1906                         parameters[2] = valueBeforeSOR;
1907                         truncMeanFlag = kFALSE;
1908                         sdFlag = kFALSE;
1909                 }
1910         }
1911
1912         Float_t temp = 0;
1913         Float_t temp1 = 0;
1914         Float_t sumweights = 0;
1915         Int_t entriesTruncMean = 0;
1916         Float_t* arrayValuesTruncMean = new Float_t[nentriesUsed];
1917         Double_t* arrayWeightsTruncMean = new Double_t[nentriesUsed];
1918
1919         // calculating SD wrt Mean and Median
1920         AliDebug(2,"Calculating SD wrt Mean and SD wrt Median");
1921         if (sdFlag){
1922                 for (Int_t i =0; i< nentriesUsed; i++){
1923                         AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
1924                         temp += (arrayValues[i]-parameters[2])*(arrayValues[i]-parameters[2]);
1925                         temp1 += arrayWeights[i]*(arrayValues[i]-parameters[0])*(arrayValues[i]-parameters[0]);
1926                         sumweights += arrayWeights[i];
1927                 }
1928                 // setting SD wrt Mean
1929                 if (sumweights != 0 ){
1930                         parameters[3] = TMath::Sqrt(temp1/sumweights);
1931                 }
1932                 else {
1933                         AliError("Sum of weights to calculate Standard Deviation (wrt mean) <= 0, setting the SD to invalid");
1934                         parameters[3] = AliGRPObject::GetInvalidFloat();
1935                 }
1936                 // setting SD wrt Median
1937                 if (nentriesUsed != 0){
1938                         parameters[4] = TMath::Sqrt(temp/nentriesUsed);
1939                 }
1940                 else{
1941                         AliError("Number of entries used to calculate Standard Deviation (wrt median) <= 0, setting the SD to invalid");
1942                         parameters[4] = AliGRPObject::GetInvalidFloat();
1943                 }
1944         }
1945         else {
1946                 parameters[3] = AliGRPObject::GetInvalidFloat();
1947                 parameters[4] = AliGRPObject::GetInvalidFloat();
1948         }
1949
1950         // calculating truncated mean (this comes afterwards since you need the SD wrt Mean)
1951         if (truncMeanFlag){
1952                 AliDebug(2,"Calculating Truncated Mean");
1953                 for (Int_t i =0; i< nentriesUsed; i++){
1954                         AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
1955                         if ((arrayValues[i]<=parameters[0]+3*parameters[3]) && (arrayValues[i]>=parameters[0]-3*parameters[3])){
1956                                 arrayValuesTruncMean[entriesTruncMean]=arrayValues[i];
1957                                 arrayWeightsTruncMean[entriesTruncMean]=arrayWeights[i];
1958                                 AliDebug(2,Form("For Truncated Mean: Entry %d: value = %f, weight = %f",entriesTruncMean,arrayValuesTruncMean[entriesTruncMean],arrayWeightsTruncMean[entriesTruncMean]));
1959                                 entriesTruncMean++;
1960                         }
1961                         else{
1962                                 AliDebug(2,"Discarding entry");
1963                         }
1964                 }
1965                 // setting truncated mean
1966                 if (entriesTruncMean >1){
1967                         AliDebug(2,Form("%d entries used for truncated mean",entriesTruncMean));
1968                         parameters[1] = TMath::Mean(entriesTruncMean,arrayValuesTruncMean,arrayWeightsTruncMean);
1969                 }
1970                 else{
1971                         AliDebug(2,Form("Too few entries (%d) to calculate truncated mean",entriesTruncMean));
1972                         parameters[1] = AliGRPObject::GetInvalidFloat();
1973                 }
1974         }
1975         else{
1976                         parameters[1] = AliGRPObject::GetInvalidFloat();
1977         }
1978
1979         AliInfo(Form("(weighted) mean = %f ",parameters[0]));
1980         AliInfo(Form("(weighted) truncated mean = %f ",parameters[1]));
1981         AliInfo(Form("median = %f ",parameters[2]));
1982         AliInfo(Form("(weighted) standard deviation with (weighted) mean = %f ",parameters[3]));
1983         AliInfo(Form("standard deviation with median = %f ",parameters[4]));
1984
1985         return parameters;
1986 }
1987
1988 //__________________________________________________________________________________________________________________
1989
1990 Float_t* AliGRPPreprocessor::ProcessFloatAllMagnet(const TObjArray* array, Int_t indexDP, Bool_t &isZero)
1991 {
1992         //
1993         // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
1994         // used for L3 and Dipole magnets, using isZero flag to decide whther the magnet was OFF/ON
1995         // the flag is set according to the L3/Dipole current value
1996         // current threshold for L3 = 350 A (value provided by DCS)
1997         // current threshold for Dipole = 450 A (value provided by DCS)
1998         //
1999         // parameters[0] = mean
2000         // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
2001         // parameters[2] = median
2002         // parameters[3] = standard deviation wrt mean
2003         // parameters[4] = standard deviation wrt median
2004         //
2005
2006         AliInfo(Form("indexDP = %d",indexDP));
2007
2008         Int_t nCounts = array->GetEntries();
2009         for(Int_t i = 0; i < nCounts; i++) {
2010                 AliDCSValue *v = (AliDCSValue *)array->At(i);
2011                 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
2012                         AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
2013                         if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
2014                         if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
2015                         return NULL;
2016                 }
2017                 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2018                         AliDebug(2,Form("%d-th entry = %f",i,v->GetFloat()));
2019                         if (indexDP == kL3Current && v->GetFloat() > 350 && isZero == kTRUE) isZero=kFALSE;
2020                         if (indexDP == kDipoleCurrent && v->GetFloat() > 450 && isZero == kTRUE) isZero=kFALSE;
2021                 }
2022                 else {
2023                         AliError(Form("DCS values for the parameter outside the queried interval"));
2024                 }
2025         }
2026
2027         return ProcessFloatAll(array);
2028 }
2029
2030
2031 //_______________________________________________________________
2032
2033 Char_t AliGRPPreprocessor::ProcessBool(const TObjArray* array, Bool_t &change)
2034 {
2035         //
2036         // processing Boolean values
2037         //
2038
2039         Bool_t aDCSBool = kTRUE;
2040
2041         AliDCSValue *v = 0x0;
2042
2043         for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
2044                 v = (AliDCSValue *)array->At(iCount);
2045                 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
2046                         AliError(Form("DCS values for the parameter outside the queried interval"));
2047                         continue;
2048                 }
2049                 if (iCount > 0) {
2050                         if (aDCSBool != v->GetBool()) {
2051                                 AliError(Form("DCS values for the parameter changed from %d to %d within the queried interval", (UInt_t)aDCSBool, (UInt_t)v->GetBool()));
2052                                 change = kTRUE;
2053                         }
2054                 }
2055                 aDCSBool = v->GetBool(); // always keeping last value
2056                 AliDebug(2,Form("Bool = %d",(Int_t)aDCSBool));
2057         }
2058
2059         Char_t caDCSBool = (Char_t) aDCSBool;
2060         return caDCSBool;
2061
2062 }
2063
2064 //_______________________________________________________________
2065
2066 Float_t AliGRPPreprocessor::ProcessInt(const TObjArray* array)
2067 {
2068         //
2069         // processing Int values, returning mean
2070         // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
2071         // are outside the queried time interval or their value is out of range
2072         //
2073
2074         TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2075         TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2076         if (timeStartString.IsNull() || timeStartString.IsNull()){
2077                 if (timeStartString.IsNull()){
2078                         AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2079                 }
2080                 else if (timeStartString.IsNull()){
2081                         AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2082                 }
2083                 return 0;
2084         }
2085
2086         Int_t timeStart = (Int_t)(timeStartString.Atoi());
2087         Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2088         Float_t aDCSArrayMean = 0.0;
2089         Int_t iCounts = 0;
2090         Float_t valueBeforeSOR = 0;
2091         Float_t valueAfterEOR = 0;
2092         Int_t timestampBeforeSOR = -1;
2093         Int_t timestampAfterEOR = -1;
2094         Int_t ientrySOR = -1;
2095         Int_t ientryEOR = -1;
2096         Float_t* arrayValues = 0x0;
2097         Double_t* arrayWeights = 0x0;
2098         Int_t iCountsRun = 0;
2099         Int_t nCounts = array->GetEntries();
2100
2101         for(Int_t i = 0; i < nCounts; i++) {
2102                 AliDCSValue* v = (AliDCSValue *)array->At(i);
2103                 if ((v->GetInt() < fminInt) || (v->GetInt() > fmaxInt)) {
2104                         AliError(Form("Error! Int value found in DCS map at %d-th entry is OUT OF RANGE: value = %d",i, v->GetInt()));
2105                         return AliGRPObject::GetInvalidFloat();
2106                 }
2107                 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2108                         AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetInt(),v->GetTimeStamp()));
2109                         iCounts += 1;
2110                         // look for the last value before SOR and the first value before EOR
2111                         if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
2112                                 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
2113                                 AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
2114                                 valueBeforeSOR = (Float_t) v->GetInt();
2115                         }
2116                         else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
2117                                 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
2118                                 valueAfterEOR = (Float_t) v->GetInt();
2119                                 AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
2120                         }
2121                         // check if there are DPs between DAQ_time_start and DAQ_time_end
2122                         if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
2123                                 if (ientrySOR == -1) ientrySOR = i;  // first entry after SOR
2124                                 if (ientryEOR < i) ientryEOR = i;  // last entry before EOR
2125                                 AliDebug(2,Form("entry between SOR and EOR"));
2126                                 iCountsRun += 1;
2127                         }
2128                 }
2129                 else {
2130                         AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
2131                 }
2132         }
2133
2134         if (timestampBeforeSOR == -1){
2135                 AliWarning("No value found before SOR!");
2136         }
2137         if (timestampAfterEOR == -1){
2138                 AliWarning("No value found after EOR!");
2139         }
2140
2141         AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
2142         AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2143         AliDebug(2,Form("First value after DAQ_time_end (EOR)   = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2144         AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2145         AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2146         AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2147
2148         Int_t nentriesUsed = 0;
2149         if (iCountsRun > 1){
2150                 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2151                 AliDebug(2,"Calculating (weighted) Mean");
2152                 arrayValues = new Float_t[iCountsRun];
2153                 arrayWeights = new Double_t[iCountsRun];
2154                 nentriesUsed = iCountsRun;
2155                 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2156                         AliDCSValue *v = (AliDCSValue *)array->At(i);
2157                         Int_t timestamp2 = 0;
2158                         if (i < ientryEOR){
2159                                 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2160                                 timestamp2 = (Int_t)v1->GetTimeStamp();
2161                         }
2162                         else {
2163                                 timestamp2 = timeEnd+1;
2164                         }
2165                         arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2166                         arrayValues[i-ientrySOR] = (Float_t)v->GetInt();
2167                 }
2168                 aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2169         }
2170         else if (iCountsRun == 1){
2171                 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2172                 nentriesUsed = 2;
2173                 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2174                         AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
2175                         arrayValues = new Float_t[2];
2176                         arrayWeights = new Double_t[2];
2177                         arrayValues[0] = valueBeforeSOR;
2178                         arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2179                         arrayValues[1] = (Float_t)v->GetInt();
2180                         arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2181                         AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2182                         AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2183                         aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
2184                 }
2185                 else{
2186                         AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
2187                         return AliGRPObject::GetInvalidFloat();
2188                 }
2189         }
2190         else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
2191                 if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
2192                         if (timestampBeforeSOR == -1){
2193                                 AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
2194                         }
2195                         if (timestampAfterEOR == -1){
2196                                 AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
2197                         }
2198                         return AliGRPObject::GetInvalidFloat();
2199                 }
2200                 else {
2201                         AliWarning("Using last entry before SOR and first entry after EOR.");
2202                         nentriesUsed = 2;
2203                         arrayValues = new Float_t[2];
2204                         arrayWeights = new Double_t[2];
2205                         arrayValues[0] = valueBeforeSOR;
2206                         arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
2207                         arrayValues[1] = valueAfterEOR;
2208                         arrayWeights[1] = 1.;
2209                         AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2210                         AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2211                         aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
2212                 }
2213         }
2214
2215         AliInfo(Form("mean = %f ", aDCSArrayMean));
2216         return aDCSArrayMean;
2217
2218 }
2219 //_______________________________________________________________
2220
2221 Float_t AliGRPPreprocessor::ProcessUInt(const TObjArray* array)
2222 {
2223         //
2224         // processing Int values, returning mean
2225         // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
2226         // are outside the queried time interval or their value is out of range
2227         //
2228
2229         TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2230         TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2231         if (timeStartString.IsNull() || timeStartString.IsNull()){
2232                 if (timeStartString.IsNull()){
2233                         AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2234                 }
2235                 else if (timeStartString.IsNull()){
2236                         AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2237                 }
2238                 return 0;
2239         }
2240
2241         Int_t timeStart = (Int_t)(timeStartString.Atoi());
2242         Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2243         Float_t aDCSArrayMean = 0.0;
2244         Int_t iCounts = 0;
2245         Float_t valueBeforeSOR = 0;
2246         Float_t valueAfterEOR = 0;
2247         Int_t timestampBeforeSOR = -1;
2248         Int_t timestampAfterEOR = -1;
2249         Int_t ientrySOR = -1;
2250         Int_t ientryEOR = -1;
2251         Float_t* arrayValues = 0x0;
2252         Double_t* arrayWeights = 0x0;
2253         Int_t iCountsRun = 0;
2254         Int_t nCounts = array->GetEntries();
2255
2256         for(Int_t i = 0; i < nCounts; i++) {
2257                 AliDCSValue* v = (AliDCSValue *)array->At(i);
2258                 if ((v->GetUInt() < fminUInt) || (v->GetUInt() > fmaxUInt)) {
2259                         AliError(Form("Error! UInt value found in DCS map at %d-th entry is OUT OF RANGE: value = %u",i,v->GetUInt()));
2260                         return AliGRPObject::GetInvalidFloat();
2261                 }
2262                 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2263                         AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetUInt(),v->GetTimeStamp()));
2264                         iCounts += 1;
2265                         // look for the last value before SOR and the first value before EOR
2266                         if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
2267                                 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
2268                                 AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
2269                                 valueBeforeSOR = (Float_t)v->GetUInt();
2270                         }
2271                         else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
2272                                 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
2273                                 valueAfterEOR = (Float_t)v->GetUInt();
2274                                 AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
2275                         }
2276                         // check if there are DPs between DAQ_time_start and DAQ_time_end
2277                         if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
2278                                 if (ientrySOR == -1) ientrySOR = i;  // first entry after SOR
2279                                 if (ientryEOR < i) ientryEOR = i;  // last entry before EOR
2280                                 AliDebug(2,Form("entry between SOR and EOR"));
2281                                 iCountsRun += 1;
2282                         }
2283                 }
2284                 else {
2285                         AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
2286                 }
2287         }
2288
2289         if (timestampBeforeSOR == -1){
2290                 AliWarning("No value found before SOR!");
2291         }
2292         if (timestampAfterEOR == -1){
2293                 AliWarning("No value found after EOR!");
2294         }
2295
2296         AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
2297         AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2298         AliDebug(2,Form("First value after DAQ_time_end (EOR)   = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2299         AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2300         AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2301         AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2302
2303         Int_t nentriesUsed = 0;
2304         if (iCountsRun > 1){
2305                 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2306                 AliDebug(2,"Calculating (weighted) Mean");
2307                 arrayValues = new Float_t[iCountsRun];
2308                 arrayWeights = new Double_t[iCountsRun];
2309                 nentriesUsed = iCountsRun;
2310                 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2311                         AliDCSValue *v = (AliDCSValue *)array->At(i);
2312                         Int_t timestamp2 = 0;
2313                         if (i < ientryEOR){
2314                                 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2315                                 timestamp2 = (Int_t)v1->GetTimeStamp();
2316                         }
2317                         else {
2318                                 timestamp2 = timeEnd+1;
2319                         }
2320                         arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2321                         arrayValues[i-ientrySOR] = (Float_t)v->GetUInt();
2322                 }
2323                 aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2324         }
2325         else if (iCountsRun == 1){
2326                 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2327                 nentriesUsed = 2;
2328                 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2329                         AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
2330                         arrayValues = new Float_t[2];
2331                         arrayWeights = new Double_t[2];
2332                         arrayValues[0] = valueBeforeSOR;
2333                         arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2334                         arrayValues[1] = (Float_t)v->GetUInt();
2335                         arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2336                         AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2337                         AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2338                         aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
2339                 }
2340                 else{
2341                         AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
2342                         return AliGRPObject::GetInvalidFloat();
2343                 }
2344         }
2345         else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
2346                 if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
2347                         if (timestampBeforeSOR == -1){
2348                                 AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
2349                         }
2350                         if (timestampAfterEOR == -1){
2351                                 AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
2352                         }
2353                         return AliGRPObject::GetInvalidFloat();
2354                 }
2355                 else {
2356                         AliWarning("Using last entry before SOR and first entry after EOR.");
2357                         nentriesUsed = 2;
2358                         arrayValues = new Float_t[2];
2359                         arrayWeights = new Double_t[2];
2360                         arrayValues[0] = valueBeforeSOR;
2361                         arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
2362                         arrayValues[1] = valueAfterEOR;
2363                         arrayWeights[1] = 1.;
2364                         AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2365                         AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2366                         aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
2367                 }
2368         }
2369
2370         AliInfo(Form("mean = %f ",aDCSArrayMean));
2371         return aDCSArrayMean;
2372
2373 }
2374
2375
2376 //_______________________________________________________________
2377
2378 AliDCSSensorArray *AliGRPPreprocessor::GetPressureMap(TMap* dcsAliasMap)
2379 {
2380         // extract DCS pressure maps. Perform fits to save space
2381
2382         TMap *map = fPressure->ExtractDCS(dcsAliasMap);
2383         if (map) {
2384                 AliDebug(2,Form("Map has %d entries",map->GetEntries()));
2385                 fPressure->MakeSplineFit(map);
2386                 Double_t fitFraction = fPressure->NumFits()/fPressure->NumSensors();
2387                 if (fitFraction > kFitFraction ) {
2388                         AliInfo(Form("Pressure values extracted, %d fits performed for %d sensors.", fPressure->NumFits(),fPressure->NumSensors()));
2389                 } else {
2390                         AliInfo("Too few pressure maps fitted!!!");
2391                 }
2392         } else {
2393                 AliInfo("no atmospheric pressure map extracted!!!");
2394         }
2395         delete map;
2396
2397         return fPressure;
2398 }
2399
2400
2401
2402 //_______________________________________________________________
2403 Int_t AliGRPPreprocessor::ReceivePromptRecoParameters(UInt_t run, const char* dbHost, Int_t dbPort, const char* dbName, const char* user, const char* password, const char *cdbRoot, TString &gdc)
2404 {
2405         //
2406         // Retrieves logbook and trigger information from the online logbook
2407         // This information is needed for prompt reconstruction
2408         //
2409         // Parameters are:
2410         // Run number
2411         // DAQ params: dbHost, dbPort, dbName, user, password, logbookTable, triggerTable
2412         // cdbRoot
2413         //
2414         // returns:
2415         //         positive on success: the return code is the run number of last run processed of the same run type already processed by the SHUTTLE
2416         //         0 on success and no run was found
2417         //         negative on error
2418         //
2419         // This function is NOT called during the preprocessor run in the Shuttle!
2420         //
2421
2422         // defaults
2423         if (dbPort == 0)
2424                 dbPort = 3306;
2425
2426         // CDB connection
2427         AliCDBManager* cdb = AliCDBManager::Instance();
2428         cdb->SetDefaultStorage(cdbRoot);
2429
2430         // SQL connection
2431         TSQLServer* server = TSQLServer::Connect(Form("mysql://%s:%d/%s", dbHost, dbPort, dbName), user, password);
2432
2433         if (!server)
2434                 {
2435                         Printf("ERROR: Could not connect to DAQ LB");
2436                         return -1;
2437                 }
2438
2439         // main logbook
2440         TString sqlQuery;
2441         sqlQuery.Form("SELECT DAQ_time_start, run_type, detectorMask, L3_magnetCurrent, Dipole_magnetCurrent,beamType FROM logbook WHERE run = %d", run);
2442         TSQLResult* result = server->Query(sqlQuery);
2443         if (!result)
2444                 {
2445                         Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2446                         return -2;
2447                 }
2448
2449         if (result->GetRowCount() == 0)
2450                 {
2451                         Printf("ERROR: Run %d not found", run);
2452                         delete result;
2453                         return -3;
2454                 }
2455
2456         TSQLRow* row = result->Next();
2457         if (!row)
2458                 {
2459                         Printf("ERROR: Could not receive data from run %d", run);
2460                         delete result;
2461                         return -4;
2462                 }
2463
2464         TString timeStartString(row->GetField(0));
2465         TString runType(row->GetField(1));
2466         TString detectorMaskString(row->GetField(2));
2467         TString l3CurrentString(row->GetField(3));
2468         TString dipoleCurrentString(row->GetField(4));
2469         TString beamTypeString(row->GetField(5));
2470         time_t timeStart = (time_t)(timeStartString.Atoi());
2471         UInt_t detectorMask = (UInt_t)(detectorMaskString.Atoi());
2472         Float_t l3Current = (Float_t)(TMath::Abs(l3CurrentString.Atof()));
2473         Float_t dipoleCurrent = (Float_t)(TMath::Abs(dipoleCurrentString.Atof()));
2474         Char_t l3Polarity = (l3CurrentString.Atof() < 0) ? 1 : 0;
2475         Char_t dipolePolarity = (dipoleCurrentString.Atof() < 0) ? 1 : 0;
2476         if (beamTypeString.CompareTo("Pb-Pb",TString::kIgnoreCase) == 0){
2477                 beamTypeString="A-A";
2478         }
2479
2480         AliGRPObject * grpObj = new AliGRPObject();
2481         grpObj->SetTimeStart(timeStart);
2482         grpObj->SetRunType((TString)(row->GetField(1)));
2483         grpObj->SetDetectorMask(detectorMask);
2484         grpObj->SetL3Current(l3Current,(AliGRPObject::Stats)0);
2485         grpObj->SetDipoleCurrent(dipoleCurrent,(AliGRPObject::Stats)0);
2486         grpObj->SetL3Polarity(l3Polarity);
2487         grpObj->SetDipolePolarity(dipolePolarity);
2488         grpObj->SetPolarityConventionLHC();  // after the dipole cables swap we comply with LHC convention
2489         grpObj->SetBeamType(beamTypeString);
2490
2491         delete row;
2492         row = 0;
2493
2494         delete result;
2495         result = 0;
2496
2497         Printf("Storing GRP/GRP/Data object with the following content");
2498         grpObj->Dump();
2499
2500         AliCDBMetaData metadata;
2501         metadata.SetResponsible("Jan Fiete Grosse-Oetringhaus & Chiara Zampolli");
2502         metadata.SetComment("GRP Output parameters received during online running");
2503
2504         AliCDBId id("GRP/GRP/Data", run, run);
2505         Bool_t success = cdb->Put(grpObj, id, &metadata);
2506
2507         delete grpObj;
2508
2509         if (!success)
2510                 {
2511                         Printf("ERROR: Could not store GRP/GRP/Data into OCDB");
2512                         return -5;
2513                 }
2514
2515         // Receive trigger information
2516         sqlQuery.Form("SELECT configFile FROM logbook_trigger_config WHERE run = %d", run);
2517         result = server->Query(sqlQuery);
2518         if (!result)
2519                 {
2520                         Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2521                         return -11;
2522                 }
2523
2524         if (result->GetRowCount() == 0)
2525                 {
2526                         Printf("ERROR: Run %d not found in logbook_trigger_config", run);
2527                         delete result;
2528                         return -12;
2529                 }
2530
2531         row = result->Next();
2532         if (!row)
2533                 {
2534                         Printf("ERROR: Could not receive logbook_trigger_config data from run %d", run);
2535                         delete result;
2536                         return -13;
2537                 }
2538
2539         TString triggerConfig(row->GetField(0));
2540
2541         delete row;
2542         row = 0;
2543
2544         delete result;
2545         result = 0;
2546
2547         Printf("Found trigger configuration: %s", triggerConfig.Data());
2548
2549         AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConfig);
2550         if (!runcfg)
2551                 {
2552                         Printf("ERROR: Could not create CTP configuration object");
2553                         return -14;
2554                 }
2555
2556         metadata.SetComment("CTP run configuration received during online running");
2557
2558         AliCDBId id2("GRP/CTP/Config", run, run);
2559         success = cdb->Put(runcfg, id2, &metadata);
2560
2561         delete runcfg;
2562         runcfg = 0;
2563
2564         if (!success)
2565                 {
2566                         Printf("ERROR: Could not store GRP/CTP/Config into OCDB");
2567                         return -15;
2568                 }
2569
2570
2571         // Receive list of GDCs for this run
2572         sqlQuery.Form("SELECT GDC FROM logbook_stats_GDC WHERE run = %d", run);
2573         result = server->Query(sqlQuery);
2574         if (!result)
2575                 {
2576                         Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2577                         return -24;
2578                 }
2579
2580         if (result->GetRowCount() == 0)
2581                 {
2582                         Printf("ERROR: Run %d not found in logbook_stats_GDC", run);
2583                         delete result;
2584                         return -25;
2585                 }
2586
2587         gdc = "";
2588         for (Int_t iGDC = 0; iGDC < result->GetRowCount(); iGDC++) {
2589           row = result->Next();
2590           if (!row)
2591             {
2592               Printf("ERROR: Could not receive logbook_stats_GDC data from run %d", run);
2593               delete result;
2594               return -26;
2595             }
2596           gdc += row->GetField(0);
2597           gdc += " ";
2598         }
2599
2600         delete row;
2601         row = 0;
2602
2603         delete result;
2604         result = 0;
2605
2606         Printf("Found GDC: %s", gdc.Data());
2607
2608         // get last run with same run type that was already processed by the SHUTTLE
2609
2610         sqlQuery.Form("SELECT max(logbook.run) FROM logbook LEFT JOIN logbook_shuttle ON logbook_shuttle.run = logbook.run WHERE run_type = '%s' AND shuttle_done = 1", runType.Data());
2611         result = server->Query(sqlQuery);
2612         if (!result)
2613                 {
2614                         Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2615                         return -21;
2616                 }
2617
2618         if (result->GetRowCount() == 0)
2619                 {
2620                         Printf("ERROR: No result with query <%s>", sqlQuery.Data());
2621                         delete result;
2622                         return -22;
2623                 }
2624
2625         row = result->Next();
2626         if (!row)
2627                 {
2628                         Printf("ERROR: Could not receive data for query <%s>", sqlQuery.Data());
2629                         delete result;
2630                         return -23;
2631                 }
2632
2633         TString lastRunStr(row->GetField(0));
2634         Int_t lastRun = lastRunStr.Atoi();
2635
2636         Printf("Last run with same run type %s is %d", runType.Data(), lastRun);
2637
2638         delete row;
2639         row = 0;
2640
2641         delete result;
2642         result = 0;
2643
2644         server->Close();
2645         delete server;
2646         server = 0;
2647
2648         return lastRun;
2649 }
2650 //-----------------------------------------------------------------
2651 Double_t AliGRPPreprocessor::CalculateMean(TObjArray* const array){
2652
2653         //
2654         // Calculating mean over TObjArray from LHC Data
2655         //
2656
2657         TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2658         TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2659         if (timeStartString.IsNull() || timeStartString.IsNull()){
2660                 if (timeStartString.IsNull()){
2661                         AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2662                 }
2663                 else if (timeStartString.IsNull()){
2664                         AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2665                 }
2666                 return 0;
2667         }
2668
2669         Int_t timeStart = (Int_t)(timeStartString.Atoi());
2670         Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2671         timeStart = 1260646960;
2672         timeEnd = 1260652740;
2673         Double_t* parameters = new Double_t[5];
2674         parameters[0] = -1.;
2675         parameters[1] = -1.;
2676         parameters[2] = -1.;
2677         parameters[3] = -1.;
2678         parameters[4] = -1.;
2679         Int_t iCounts = 0;
2680         Int_t iCountsRun = 0;
2681         Int_t nCounts = array->GetEntries();
2682         printf("ncounts = %d\n",nCounts);
2683         Double_t valueBeforeSOR = 0;
2684         Double_t valueAfterEOR = 0;
2685         Double_t timestampBeforeSOR = -1.;
2686         Double_t timestampAfterEOR = -1.;
2687         Int_t ientrySOR = -1;
2688         Int_t ientryEOR = -1;
2689         Double_t* arrayValues = 0x0;
2690         Double_t* arrayWeights = 0x0;
2691         Bool_t truncMeanFlag = kTRUE;  // flag to indicate whether Truncated Mean should be calculated or not
2692         Bool_t sdFlag = kTRUE;  // flag to indicate whether SD (wrt Mean/Median) should be calculated or not
2693
2694         for(Int_t i = 0; i < nCounts; i++) {
2695                 AliDCSArray *dcs = (AliDCSArray*)array->At(i);
2696                 if((dcs->GetTimeStamp() >= timeStart) &&(dcs->GetTimeStamp() <= timeEnd)) {
2697                         AliDebug(2,Form("%d-th entry = %f at timestamp %f\n",i,(Double_t)(dcs->GetInt(0)),dcs->GetTimeStamp()));
2698                         iCounts += 1;
2699                         // look for the last value before SOR and the first value before EOR
2700                         if ((dcs->GetTimeStamp() >= timeStart) && (dcs->GetTimeStamp() < timeStart)) {
2701                                 timestampBeforeSOR = dcs->GetTimeStamp();
2702                                 AliDebug(2,Form("timestamp of last value before SOR = %f, with DAQ_time_start = %d\n",timestampBeforeSOR,timeStart));
2703                                 valueBeforeSOR = (Double_t)(dcs->GetInt(0));
2704                         }
2705                         else if ((dcs->GetTimeStamp() <= timeEnd) && (dcs->GetTimeStamp() > timeEnd) && timestampAfterEOR == -1){
2706                                 timestampAfterEOR = dcs->GetTimeStamp();
2707                                 valueAfterEOR = (Double_t)(dcs->GetInt(0));
2708                                 AliDebug(2,Form("timestamp of first value after EOR = %f, with DAQ_time_end = %d\n",timestampAfterEOR,timeEnd));
2709                         }
2710                         // check if there are DPs between DAQ_time_start and DAQ_time_end
2711                         if((dcs->GetTimeStamp() >= timeStart) &&(dcs->GetTimeStamp() <= timeEnd)) {
2712                                 if (ientrySOR == -1) ientrySOR = i;  // first entry after SOR
2713                                 if (ientryEOR < i) ientryEOR = i;  // last entry before EOR
2714                                 AliDebug(2,Form("entry between SOR and EOR\n"));
2715                                 iCountsRun += 1;
2716                         }
2717                 }
2718                 else {
2719                         printf("DCS values for the parameter outside the queried interval: timestamp = %f\n",dcs->GetTimeStamp());
2720                 }
2721         }
2722
2723         if (timestampBeforeSOR == -1.){
2724                 printf("No value found before SOR\n");
2725         }
2726         if (timestampAfterEOR == -1.){
2727                 printf("No value found after EOR\n");
2728         }
2729
2730         printf("Number of valid entries (within DCS query interval) = %i, from a total amount of %i entries\n",iCounts,nCounts);
2731         printf("Last value before DAQ_time_start (SOR) = %f at timestamp = %f\n",valueBeforeSOR,timestampBeforeSOR);
2732         printf("First value after DAQ_time_end (EOR)   = %f at timestamp = %f\n",valueAfterEOR,timestampAfterEOR);
2733         printf("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)\n",iCountsRun);
2734         printf("Index of first entry after DAQ_time_start (SOR) = %d\n ",ientrySOR);
2735         printf("Index of first entry before DAQ_time_end (EOR) = %d\n ",ientryEOR);
2736
2737         Int_t nentriesUsed = 0;
2738         if (iCountsRun > 1){
2739                 printf("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)\n");
2740                 printf("Calculating (weighted) Mean and Median\n" );
2741                 arrayValues = new Double_t[iCountsRun];
2742                 arrayWeights = new Double_t[iCountsRun];
2743                 nentriesUsed = iCountsRun;
2744                 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2745                         AliDCSArray *dcs = (AliDCSArray *)array->At(i);
2746                         Double_t timestamp2 = 0;
2747                         if (i < ientryEOR){
2748                                 AliDCSArray *dcs1 = (AliDCSArray *)array->At(i+1);
2749                                 timestamp2 = dcs1->GetTimeStamp();
2750                         }
2751                         else {
2752                                 timestamp2 = (Double_t)timeEnd+1;
2753                         }
2754                         arrayWeights[i-ientrySOR] = (Double_t)((Double_t)timestamp2 - dcs->GetTimeStamp());
2755                         arrayValues[i-ientrySOR] = (Double_t)(dcs->GetInt(0));
2756                         printf("Entry %d: value = %f, weight = %f\n",i-ientrySOR,arrayValues[i-ientrySOR],arrayWeights[i-ientrySOR]);
2757                 }
2758                 parameters[0] = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2759                 parameters[2] = TMath::Median(iCountsRun,arrayValues,arrayWeights);
2760         }
2761         else if (iCountsRun == 1){
2762                 AliDCSArray* dcs = (AliDCSArray *)array->At(ientrySOR);
2763                 nentriesUsed = 2;
2764                 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)dcs->GetTimeStamp()){
2765                         printf("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR. Truncated mean won't be calculated.\n");
2766                         arrayValues = new Double_t[2];
2767                         arrayWeights = new Double_t[2];
2768                         arrayValues[0] = valueBeforeSOR;
2769                         arrayWeights[0] = (Double_t)(dcs->GetTimeStamp()-(Double_t)timestampBeforeSOR);
2770                         arrayValues[1] = (Double_t)(dcs->GetInt(0));
2771                         arrayWeights[1] = (Double_t)((Double_t)timeEnd+1-dcs->GetTimeStamp());
2772                         printf("value0 = %f, with weight = %f\n",arrayValues[0],arrayWeights[0]);
2773                         printf("value1 = %f, with weight = %f\n",arrayValues[1],arrayWeights[1]);
2774                         parameters[0] = TMath::Mean(2,arrayValues,arrayWeights);
2775                         parameters[2] = TMath::Median(2,arrayValues,arrayWeights);
2776                         truncMeanFlag = kFALSE;
2777                 }
2778                 else{
2779                         printf("Cannot calculate mean, truncated mean, median, SD wrt mean, SD wrt median for current DP - only one value collected during the run, but no value before with which to calculate the statistical quantities\n");
2780                         parameters[0] = -1;
2781                         parameters[1] = -1;
2782                         parameters[2] = -1;
2783                         parameters[3] = -1;
2784                         parameters[4] = -1;
2785                         return parameters[0];
2786                 }
2787         }
2788         else { // iCountsRun == 0, using only the point immediately before SOR
2789                 if (timestampBeforeSOR == -1.){
2790                         printf("Cannot set mean, truncated mean, median, SD wrt mean, SD wrt median for current DP - no points during the run collected, and point before SOR missing\n");
2791                         parameters[0] = -1;
2792                         parameters[1] = -1;
2793                         parameters[2] = -1;
2794                         parameters[3] = -1;
2795                         parameters[4] = -1;
2796                         return parameters[0];
2797                 }
2798                 else {
2799                         printf("Using only last entry before SOR. Truncated mean and Standard deviations (wrt mean/median) won't be calculated.\n");
2800                         printf("value = %f\n",valueBeforeSOR);
2801                         parameters[0] = valueBeforeSOR;
2802                         parameters[2] = valueBeforeSOR;
2803                         truncMeanFlag = kFALSE;
2804                         sdFlag = kFALSE;
2805                 }
2806         }
2807
2808         Double_t temp = 0;
2809         Double_t temp1 = 0;
2810         Double_t sumweights = 0;
2811         Int_t entriesTruncMean = 0;
2812         Double_t* arrayValuesTruncMean = new Double_t[nentriesUsed];
2813         Double_t* arrayWeightsTruncMean = new Double_t[nentriesUsed];
2814
2815         // calculating SD wrt Mean and Median
2816         printf("Calculating SD wrt Mean and SD wrt Median\n");
2817         if (sdFlag){
2818                 for (Int_t i =0; i< nentriesUsed; i++){
2819                         //printf("Entry %d: value = %f, weight = %f\n",i,arrayValues[i],arrayWeights[i]);
2820                         temp += (arrayValues[i]-parameters[2])*(arrayValues[i]-parameters[2]);
2821                         temp1 += arrayWeights[i]*(arrayValues[i]-parameters[0])*(arrayValues[i]-parameters[0]);
2822                         sumweights += arrayWeights[i];
2823                 }
2824                 // setting SD wrt Mean
2825                 if (sumweights != 0 ){
2826                         parameters[3] = TMath::Sqrt(temp1/sumweights);
2827                 }
2828                 else {
2829                         printf("Sum of weights to calculate Standard Deviation (wrt mean) <= 0, setting the SD to invalid\n");
2830                         parameters[3] = -1;
2831                 }
2832                 // setting SD wrt Median
2833                 if (nentriesUsed != 0){
2834                         parameters[4] = TMath::Sqrt(temp/nentriesUsed);
2835                 }
2836                 else{
2837                         printf("Number of entries used to calculate Standard Deviation (wrt median) <= 0, setting the SD to invalid\n");
2838                         parameters[4] = -1;
2839                 }
2840         }
2841         else {
2842                 parameters[3] = -1;
2843                 parameters[4] = -1;
2844         }
2845
2846         // calculating truncated mean (this comes afterwards since you need the SD wrt Mean)
2847         if (truncMeanFlag){
2848                 printf("Calculating Truncated Mean\n");
2849                 for (Int_t i =0; i< nentriesUsed; i++){
2850                         //printf("Entry %d: value = %f, weight = %f\n",i,arrayValues[i],arrayWeights[i]);
2851                         if ((arrayValues[i]<=parameters[0]+3*parameters[3]) && (arrayValues[i]>=parameters[0]-3*parameters[3])){
2852                                 arrayValuesTruncMean[entriesTruncMean]=arrayValues[i];
2853                                 arrayWeightsTruncMean[entriesTruncMean]=arrayWeights[i];
2854                                 printf("For Truncated Mean: Entry %d: value = %f, weight = %f\n",entriesTruncMean,arrayValuesTruncMean[entriesTruncMean],arrayWeightsTruncMean[entriesTruncMean]);
2855                                 entriesTruncMean++;
2856                         }
2857                         else{
2858                                 printf("Discarding entry\n");
2859                         }
2860                 }
2861                 // setting truncated mean
2862                 if (entriesTruncMean >1){
2863                         printf("%d entries used for truncated mean\n",entriesTruncMean);
2864                         parameters[1] = TMath::Mean(entriesTruncMean,arrayValuesTruncMean,arrayWeightsTruncMean);
2865                 }
2866                 else{
2867                         printf("Too few entries (%d) to calculate truncated mean\n",entriesTruncMean);
2868                         parameters[1] = -1;
2869                 }
2870         }
2871         else{
2872                         parameters[1] = -1;
2873         }
2874
2875         printf("(weighted) mean = %f \n",parameters[0]);
2876         printf("(weighted) truncated mean = %f \n",parameters[1]);
2877         printf("median = %f \n",parameters[2]);
2878         printf("(weighted) standard deviation with (weighted) mean = %f \n",parameters[3]);
2879         printf("standard deviation with median = %f \n",parameters[4]);
2880
2881         return (parameters[0]);
2882 }
2883 //------------------------------------------------------------------------------------------------------
2884 Float_t AliGRPPreprocessor::ProcessEnergy(TObjArray* const array, Double_t timeStart){
2885
2886         //
2887         // Method to processo LHC Energy information
2888         // Only the first value is returned, provided that it is withing DAQ_time_start and DAQ_time_end
2889         //
2890
2891         Int_t nCounts = array->GetEntries();
2892         Float_t energy = -1;
2893         Double_t timeEnergy = -1;
2894         Int_t indexEnergy = -1;
2895         Bool_t foundEnergy = kFALSE;
2896
2897         AliDebug(2,Form("Energy measurements = %d\n",nCounts));
2898         if (nCounts ==0){
2899                 AliWarning("No Energy values found! Beam Energy remaining invalid!");
2900         }
2901         else{
2902                 for (Int_t i = 0; i < nCounts; i++){
2903                         AliDCSArray *dcs = (AliDCSArray*)array->At(i);
2904                         if (dcs){
2905                                 if (dcs->GetTimeStamp()<=timeStart && dcs->GetTimeStamp()>=timeEnergy){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
2906                                         timeEnergy = dcs->GetTimeStamp();
2907                                         indexEnergy = i;
2908                                         foundEnergy = kTRUE;
2909                                 }
2910                                 else{
2911                                         break;
2912                                 }
2913                         }
2914                 }
2915                 if (!foundEnergy){
2916                         AliInfo("No value for the Energy found before start of run, the Energy will remain invalid");
2917                 }
2918                 else {
2919                         AliDCSArray* dcs = (AliDCSArray*)array->At(indexEnergy);
2920                         energy = (Float_t)(TMath::Nint(((Double_t)(dcs->GetInt(0)))*120/1000)); // sqrt(s)/2 energy in GeV
2921                         AliInfo(Form("Energy value found = %d (at %f), converting --> sqrt(s)/2 = %f (GeV)", dcs->GetInt(0),dcs->GetTimeStamp(),energy));
2922                 }
2923         }
2924
2925         return energy;
2926 }
2927 //------------------------------------------------------------------------------------------------------
2928 AliLHCClockPhase* AliGRPPreprocessor::ProcessLHCClockPhase(TObjArray *beam1phase,TObjArray *beam2phase, Double_t timeEnd)
2929 {
2930   //
2931   // Method to process LHC-Clock Phase data
2932   // Only the values between DAQ_time_start and DAQ_time_end are kept
2933   //
2934   AliLHCClockPhase *phaseObj = new AliLHCClockPhase;
2935
2936   Bool_t foundBeam1Phase = kFALSE, foundBeam2Phase = kFALSE;
2937   const Float_t threshold = 0.050; // we store the measurement only in case they differ with more 50ps from the previous one
2938
2939   TString timeCreatedStr = GetRunParameter("time_created");
2940   Double_t timeCreated = timeCreatedStr.Atof();
2941
2942   Int_t nCounts = beam1phase->GetEntries();
2943   AliDebug(2,Form("Beam1 phase measurements = %d\n",nCounts));
2944   if (nCounts ==0){
2945     AliWarning("No beam1 LHC clock phase values found!");
2946     delete phaseObj;
2947     return NULL;
2948   }
2949   else{
2950     Double_t prevPhase = 0;
2951     for (Int_t i = 0; i < nCounts; i++){
2952       AliDCSArray *dcs = (AliDCSArray*)beam1phase->At(i);
2953       if (dcs){
2954               //if (dcs->GetTimeStamp()>=timeStart && dcs->GetTimeStamp()<=timeEnd) {
2955               if (dcs->GetTimeStamp()>=timeCreated && dcs->GetTimeStamp()<=timeEnd) {
2956           if ((i == 0) || (i == (nCounts-1)) ||
2957               !foundBeam1Phase ||
2958               (TMath::Abs(dcs->GetDouble(0)-prevPhase) > threshold)) {
2959             prevPhase = dcs->GetDouble(0);
2960             foundBeam1Phase = kTRUE;
2961             AliInfo(Form("B1 Clk Phase = %f at TS = %f",
2962                          (Float_t)dcs->GetDouble(0),dcs->GetTimeStamp()));
2963             phaseObj->AddPhaseB1DP((UInt_t)dcs->GetTimeStamp(),(Float_t)dcs->GetDouble(0));
2964           }
2965         }
2966       }
2967     }
2968     if (!foundBeam1Phase){
2969       AliError("No beam1 LHC clock phase values found within the run!");
2970       delete phaseObj;
2971       return NULL;
2972     }
2973   }
2974
2975   nCounts = beam2phase->GetEntries();
2976   AliDebug(2,Form("Beam2 phase measurements = %d\n",nCounts));
2977   if (nCounts ==0){
2978     AliWarning("No beam2 LHC clock phase values found!");
2979     delete phaseObj;
2980     return NULL;
2981   }
2982   else{
2983     Double_t prevPhase = 0;
2984     for (Int_t i = 0; i < nCounts; i++){
2985       AliDCSArray *dcs = (AliDCSArray*)beam2phase->At(i);
2986       if (dcs){
2987         if (dcs->GetTimeStamp()>=timeCreated && dcs->GetTimeStamp()<=timeEnd) {
2988           if ((i == 0) || (i == (nCounts-1)) ||
2989               !foundBeam2Phase ||
2990               (TMath::Abs(dcs->GetDouble(0)-prevPhase) > threshold)) {
2991             prevPhase = dcs->GetDouble(0);
2992             foundBeam2Phase = kTRUE;
2993             AliInfo(Form("B2 Clk Phase = %f at TS = %f",
2994                          (Float_t)dcs->GetDouble(0),dcs->GetTimeStamp()));
2995             phaseObj->AddPhaseB2DP((UInt_t)dcs->GetTimeStamp(),(Float_t)dcs->GetDouble(0));
2996           }
2997         }
2998       }
2999     }
3000     if (!foundBeam2Phase){
3001       AliError("No beam2 LHC clock phase values found within the run!");
3002       delete phaseObj;
3003       return NULL;
3004     }
3005   }
3006
3007   return phaseObj;
3008 }