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