STEER/AliGRPPreprocessor.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //-------------------------------------------------------------------------
  19 //                          Class AliGRPPreprocessor
  20 //                  Global Run Parameters (GRP) preprocessor
  21 //    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
  22 //    Modified: Ernesto.Lopez.Torres@cern.ch  CEADEN-CERN
  23 //    Modified: Chiara.Zampolli@cern.ch  CERN
  24 //-------------------------------------------------------------------------
  25
  26 #include <TChain.h>
  27 #include <TList.h>
  28 #include <TMap.h>
  29 #include <TObjString.h>
  30 #include <TGraph.h>
  31
  32 #include <float.h>
  33
  34 #include "AliGRPPreprocessor.h"
  35 #include "AliGRPObject.h"
  36 #include "AliDCSSensor.h"
  37 #include "AliSplineFit.h"
  38 #include "AliDCSSensorArray.h"
  39 //#include "AliRawEventHeaderVersions.h"
  40
  41 #include "AliTriggerConfiguration.h"
  42 #include "AliTriggerRunScalers.h"
  43
  44 #include "AliCDBMetaData.h"
  45 #include "AliLog.h"
  46
  47 class AliDCSValue;
  48 class AliShuttleInterface;
  49
  50 // needed for ReceivePromptRecoParameters
  51
  52 #include <TSQLServer.h>
  53 #include <TSQLResult.h>
  54 #include <TSQLRow.h>
  55 #include <AliCDBManager.h>
  56 #include <AliCDBMetaData.h>
  57 #include <AliCDBId.h>
  58 #include <AliTriggerConfiguration.h>
  59
  60 const Double_t kFitFraction = 0.7;                 // Fraction of DCS sensor fits required
  61
  62 ClassImp(AliGRPPreprocessor)
  63
  64 //_______________________________________________________________
  65
  66   const Int_t AliGRPPreprocessor::fgknDAQLbPar = 8; // num parameters in the logbook for PHYSICS runs, when beamType from DAQ logbook != Cosmics
  67   const Int_t AliGRPPreprocessor::fgknDAQLbParReduced = 7; // num parameters in the logbook for the other cases
  68   const Int_t AliGRPPreprocessor::fgknDCSDP = 50;   // number of dcs dps
  69   const Int_t AliGRPPreprocessor::fgknDCSDPHallProbes = 40;   // number of dcs dps
  70   const char* AliGRPPreprocessor::fgkDCSDataPoints[AliGRPPreprocessor::fgknDCSDP] = {
  71                    "LHCState",              // missing in DCS
  72                    "L3Polarity",
  73                    "DipolePolarity",
  74                    "LHCLuminosity",         // missing in DCS
  75                    "BeamIntensity",         // missing in DCS
  76                    "L3Current",
  77                    "DipoleCurrent",
  78                    "L3_BSF17_H1",
  79                    "L3_BSF17_H2",
  80                    "L3_BSF17_H3",
  81                    "L3_BSF17_Temperature",
  82                    "L3_BSF4_H1",
  83                    "L3_BSF4_H2",
  84                    "L3_BSF4_H3",
  85                    "L3_BSF4_Temperature",
  86                    "L3_BKF17_H1",
  87                    "L3_BKF17_H2",
  88                    "L3_BKF17_H3",
  89                    "L3_BKF17_Temperature",
  90                    "L3_BKF4_H1",
  91                    "L3_BKF4_H2",
  92                    "L3_BKF4_H3",
  93                    "L3_BKF4_Temperature",
  94                    "L3_BSF13_H1",
  95                    "L3_BSF13_H2",
  96                    "L3_BSF13_H3",
  97                    "L3_BSF13_Temperature",
  98                    "L3_BSF8_H1",
  99                    "L3_BSF8_H2",
 100                    "L3_BSF8_H3",
 101                    "L3_BSF8_Temperature",
 102                    "L3_BKF13_H1",
 103                    "L3_BKF13_H2",
 104                    "L3_BKF13_H3",
 105                    "L3_BKF13_Temperature",
 106                    "L3_BKF8_H1",
 107                    "L3_BKF8_H2",
 108                    "L3_BKF8_H3",
 109                    "L3_BKF8_Temperature",
 110                    "Dipole_Inside_H1",
 111                    "Dipole_Inside_H2",
 112                    "Dipole_Inside_H3",
 113                    "Dipole_Inside_Temperature",
 114                    "Dipole_Outside_H1",
 115                    "Dipole_Outside_H2",
 116                    "Dipole_Outside_H3",
 117                    "Dipole_Outside_Temperature",
 118                    "CavernTemperature",
 119                    "CavernAtmosPressure",
 120                    "SurfaceAtmosPressure"
 121                  };
 122
 123   const char* AliGRPPreprocessor::fgkDCSDataPointsHallProbes[AliGRPPreprocessor::fgknDCSDPHallProbes] = {
 124                    "L3_BSF17_H1",
 125                    "L3_BSF17_H2",
 126                    "L3_BSF17_H3",
 127                    "L3_BSF17_Temperature",
 128                    "L3_BSF4_H1",
 129                    "L3_BSF4_H2",
 130                    "L3_BSF4_H3",
 131                    "L3_BSF4_Temperature",
 132                    "L3_BKF17_H1",
 133                    "L3_BKF17_H2",
 134                    "L3_BKF17_H3",
 135                    "L3_BKF17_Temperature",
 136                    "L3_BKF4_H1",
 137                    "L3_BKF4_H2",
 138                    "L3_BKF4_H3",
 139                    "L3_BKF4_Temperature",
 140                    "L3_BSF13_H1",
 141                    "L3_BSF13_H2",
 142                    "L3_BSF13_H3",
 143                    "L3_BSF13_Temperature",
 144                    "L3_BSF8_H1",
 145                    "L3_BSF8_H2",
 146                    "L3_BSF8_H3",
 147                    "L3_BSF8_Temperature",
 148                    "L3_BKF13_H1",
 149                    "L3_BKF13_H2",
 150                    "L3_BKF13_H3",
 151                    "L3_BKF13_Temperature",
 152                    "L3_BKF8_H1",
 153                    "L3_BKF8_H2",
 154                    "L3_BKF8_H3",
 155                    "L3_BKF8_Temperature",
 156                    "Dipole_Inside_H1",
 157                    "Dipole_Inside_H2",
 158                    "Dipole_Inside_H3",
 159                    "Dipole_Inside_Temperature",
 160                    "Dipole_Outside_H1",
 161                    "Dipole_Outside_H2",
 162                    "Dipole_Outside_H3",
 163                    "Dipole_Outside_Temperature",
 164                  };
 165
 166   const Short_t kSensors = 48; // start index position of sensor in DCS DPs
 167   const Short_t kNumSensors = 2; // Number of sensors in DCS DPs
 168
 169   const char* AliGRPPreprocessor::fgkLHCState[20] = {
 170                    "P", "PREPARE",
 171                    "J", "PREINJECTION",
 172                    "I", "INJECTION",
 173                    "F", "FILLING",
 174                    "A", "ADJUST",
 175                    "U", "UNSTABLE BEAMS",
 176                    "S", "STABLE BEAMS",
 177                    "D", "BEAM DUMP",
 178                    "R", "RECOVER",
 179                    "C", "PRECYCLE"
 180                  };
 181
 182   const char* kppError[] = {
 183                    "",
 184                    "(DAQ logbook ERROR)",
 185                    "(DAQ FXS ERROR)",
 186                    "(DCS FXS ERROR)",
 187                    "(DCS data points ERROR)",
 188                    "(Trigger Configuration ERROR)",
 189                    "(DAQ logbook ERROR determining partition of the run)"
 190   };
 191
 192 //_______________________________________________________________
 193
 194 AliGRPPreprocessor::AliGRPPreprocessor(AliShuttleInterface* shuttle):
 195         AliPreprocessor("GRP",shuttle),  fPressure(0), fmaxFloat(0), fminFloat(0),fmaxDouble(0), fminDouble(0), fmaxInt(0), fminInt(0), fmaxUInt(0), fminUInt(0)
 196 {
 197         // constructor - shuttle must be instantiated!
 198
 199         AddRunType("COSMIC");
 200         AddRunType("LASER");
 201         AddRunType("PHYSICS");
 202         AddRunType("CALIBRATION_BC");
 203         AddRunType("CALIBRATION_CENTRAL");
 204         AddRunType("CALIBRATION_EMD");
 205         AddRunType("CALIBRATION_MB");
 206         AddRunType("CALIBRATION_SEMICENTRAL");
 207         AddRunType("CALIBRATION");
 208         AddRunType("PEDESTAL");
 209         AddRunType("STANDALONE");
 210         AddRunType("GAIN");
 211         AddRunType("NOISE");
 212         AddRunType("PULSER");
 213         AddRunType("STANDALONE_PULSER");
 214
 215         fmaxFloat = FLT_MAX;
 216         fminFloat = -FLT_MAX;
 217         fmaxDouble = DBL_MAX;
 218         fminDouble = -DBL_MAX;
 219         fmaxInt = kMaxInt;
 220         fminInt = kMinInt;
 221         fmaxUInt = kMaxUInt;
 222         fminUInt = 0;
 223
 224         AliInfo(Form("Max allowed float = %6.5e",fmaxFloat));
 225         AliInfo(Form("Min allowed float = %6.5e",fminFloat));
 226         AliInfo(Form("Max allowed double = %6.5e",fmaxDouble));
 227         AliInfo(Form("Min allowed double = %6.5e",fminDouble));
 228         AliInfo(Form("Max allowed integer = %d",fmaxInt));
 229         AliInfo(Form("Min allowed integer = %d",fminInt));
 230         AliInfo(Form("Max allowed unsigned integer = %u",(Int_t)fmaxUInt));
 231         AliInfo(Form("Min allowed unsigned integer = %u",(Int_t)fminUInt));
 232
 233 }
 234
 235 //_______________________________________________________________
 236
 237 AliGRPPreprocessor::~AliGRPPreprocessor()
 238 {
 239         //destructor
 240
 241         delete fPressure;
 242 }
 243
 244 //_______________________________________________________________
 245
 246 void AliGRPPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
 247 {
 248   // Initialize preprocessor
 249
 250   AliPreprocessor::Initialize(run, startTime, endTime);
 251
 252   AliInfo("Initialization of the GRP preprocessor.");
 253   AliInfo(Form("Start Time DCS = %d",GetStartTimeDCSQuery()));
 254   AliInfo(Form("End Time DCS = %d",GetEndTimeDCSQuery()));
 255   TClonesArray * array = new TClonesArray("AliDCSSensor",kNumSensors);
 256   for(Int_t j = 0; j < kNumSensors; j++) {
 257     AliDCSSensor * sens = new ((*array)[j])AliDCSSensor;
 258     sens->SetStringID(fgkDCSDataPoints[j+kSensors]);
 259   }
 260   AliInfo(Form("Pressure Entries: %d",array->GetEntries()));
 261
 262   fPressure = new AliDCSSensorArray(GetStartTimeDCSQuery(), GetEndTimeDCSQuery(), array);
 263 }
 264
 265 //_______________________________________________________________
 266
 267 UInt_t AliGRPPreprocessor::Process(TMap* valueMap)
 268 {
 269         // process data retrieved by the Shuttle
 270
 271         // retrieving "partition" and "detector" fields from DAQ logbook to
 272         // determine the partition in which the run was taken
 273         // the partition is used to decide how to react in case of errors for CTP
 274
 275         TString partition = (TString)GetRunParameter("partition");
 276         TString detector = (TString)GetRunParameter("detector");
 277
 278         AliGRPObject *grpobj = new AliGRPObject();  // object to store data
 279
 280         //=================//
 281         // DAQ logbook     //
 282         //=================//
 283         UInt_t error = 0;
 284
 285         Int_t iDaqLB = ProcessDaqLB(grpobj);
 286         TString runType = (TString)GetRunType();
 287         TString beamType = (TString)GetRunParameter("beamType");
 288         if((runType == "PHYSICS" && iDaqLB == fgknDAQLbPar && beamType!="Cosmics") ||  (runType == "PHYSICS" && iDaqLB == fgknDAQLbParReduced && beamType=="Cosmics") || (runType != "PHYSICS" && iDaqLB == fgknDAQLbParReduced)) {
 289                 Log(Form("DAQ Logbook, successful!"));
 290         } else {
 291                 Log(Form("DAQ Logbook, could not get all expected entries!!!"));
 292                 error |= 1;
 293         }
 294
 295         //=================//
 296         // DAQ FXS         //
 297         //=================//
 298         UInt_t iDaqFxs = ProcessDaqFxs();
 299         if( iDaqFxs == 0 ) {
 300                 Log(Form("DAQ FXS, successful!"));
 301         } else {
 302                 Log(Form("DAQ FXS, could not store run raw tag file!!!"));
 303                 error |= 2;
 304         }
 305
 306         //=================//
 307         // DCS FXS         //
 308         //=================//
 309         UInt_t iDcsFxs = ProcessDcsFxs(partition, detector);
 310         if( iDcsFxs == 0 ) {
 311                 Log(Form("DCS FXS, successful!"));
 312         } else  if (iDcsFxs ==1) {
 313                 Log(Form("DCS FXS, Could not store CTP scalers!!!"));
 314                 error |= 4;
 315         } else{
 316                 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without CTP scalers...",partition.Data(),detector.Data()));
 317                 error |= 32;
 318         }
 319
 320         //=================//
 321         // DCS data points //
 322         //=================//
 323         Log(Form("Starting DCS Query at %d and finishing at %d",GetStartTimeDCSQuery(),GetEndTimeDCSQuery()));
 324         Int_t entries = ProcessDcsDPs( valueMap, grpobj );
 325         Log(Form("entries found = %d (should be %d)",entries, fgknDCSDP-4));
 326         if( entries < fgknDCSDP-4 ) { // FIXME (!= ) LHState, LHCLuminosity, BeamIntensity, LH3_BSF4_H3 are not working yet...
 327                 Log(Form("Problem with the DCS data points!!! Only %d/%d entries found",entries,fgknDCSDP-4));
 328                 error |= 8;
 329         } else  Log(Form("DCS data points, successful!"));
 330
 331         //=======================//
 332         // Trigger Configuration //
 333         //=======================//
 334
 335         const char * triggerConf = GetTriggerConfiguration();
 336
 337         if (partition.IsNull() && !detector.IsNull()){ // standalone partition
 338                 Log("STANDALONE partition for current run, using Trigger Configuration dummy value");
 339                 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyConfig");
 340                 if (!cdbEntry) {
 341                         Log(Form("No dummy CTP configuration entry found, going into error..."));
 342                         error |= 16;
 343                 }
 344                 else{
 345                         AliTriggerConfiguration *runcfg = (AliTriggerConfiguration*)cdbEntry->GetObject();
 346                         if (!runcfg){
 347                                 Log(Form("dummy CTP config not found in OCDB entry, going into error..."));
 348                                 error |= 16;
 349                         }
 350                         else {
 351                                 TString titleCTPcfg = Form("CTP cfg for run %i from Dummy entry in OCDB",fRun);
 352                                 runcfg->SetTitle(titleCTPcfg);
 353                                 AliCDBMetaData metaData;
 354                                 metaData.SetResponsible("Roman Lietava");
 355                                 metaData.SetComment("CTP run configuration from dummy entry in OCDB");
 356                                 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
 357                                         Log("Unable to store the dummy CTP run configuration object to OCDB!");
 358                                         error |= 16;
 359                                 }
 360                         }
 361                 }
 362         }
 363
 364         else if (!partition.IsNull() && detector.IsNull()){ // global partition
 365                 Log("GLOBAL partition for current run, using Trigger Configuration from DAQ Logbook");
 366                 if (triggerConf!= NULL) {
 367                         Log("Found trigger configuration in DAQ logbook");
 368                         AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConf);
 369                         if (!runcfg) {
 370                                 Log("Bad CTP run configuration file from DAQ logbook! The corresponding CDB entry will not be filled!");
 371                                 error |= 16;
 372                         }
 373                         else {
 374                                 TString titleCTPcfg = Form("CTP cfg for run %i from DAQ",fRun);
 375                                 runcfg->SetTitle(titleCTPcfg);
 376                                 AliCDBMetaData metaData;
 377                                 metaData.SetBeamPeriod(0);
 378                                 metaData.SetResponsible("Roman Lietava");
 379                                 metaData.SetComment("CTP run configuration from DAQ logbook");
 380                                 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
 381                                         Log("Unable to store the CTP run configuration object to OCDB!");
 382                                         error |= 16;
 383                                 }
 384                         }
 385                 }
 386
 387                 else {
 388                         Log("Trigger configuration NULL in DAQ logbook");
 389                         error |= 16;
 390                 }
 391         }
 392
 393         else {
 394                 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger configuration...",partition.Data(),detector.Data()));
 395                 error |= 32;
 396         }
 397
 398         // storing AliGRPObject in OCDB
 399
 400         AliCDBMetaData md;
 401         md.SetResponsible("Chiara Zampolli");
 402         md.SetComment("Output parameters from the GRP preprocessor.");
 403
 404         Bool_t result = kTRUE;
 405         result = Store("GRP", "Data", grpobj, &md);
 406         delete grpobj;
 407
 408         if (result && !error ) {
 409                 Log("GRP Preprocessor Success");
 410                 return 0;
 411         } else {
 412                 Log( Form("GRP Preprocessor FAILS!!! %s%s%s%s%s%s",
 413                           kppError[(error&1)?1:0],
 414                           kppError[(error&2)?2:0],
 415                           kppError[(error&4)?3:0],
 416                           kppError[(error&8)?4:0],
 417                           kppError[(error&16)?5:0],
 418                           kppError[(error&32)?6:0]
 419                           ));
 420                 return error;
 421         }
 422 }
 423
 424 //_______________________________________________________________
 425
 426 Int_t AliGRPPreprocessor::ProcessDaqLB(AliGRPObject* grpObj)
 427 {
 428         //Getting the DAQ lb information
 429
 430         time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
 431         time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
 432         Float_t beamEnergy = (Float_t)(((TString)GetRunParameter("beamEnergy")).Atof());
 433         TString beamType = (TString)GetRunParameter("beamType");
 434         Char_t numberOfDetectors = (Char_t)(((TString)GetRunParameter("numberOfDetectors")).Atoi());
 435         UInt_t  detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
 436         TString lhcPeriod = (TString)GetRunParameter("LHCperiod");
 437         TString runType = (TString)GetRunType();
 438
 439         UInt_t nparameter = 0;
 440         if (timeStart != 0){
 441                 grpObj->SetTimeStart(timeStart);
 442                 Log(Form("Start time for run %d: %d",fRun, (Int_t)timeStart));
 443                 nparameter++;
 444         }
 445         else {
 446                 Log(Form("Start time not put in logbook, setting to invalid in GRP entry!"));
 447         }
 448
 449         if (timeEnd != 0){
 450                 grpObj->SetTimeEnd(timeEnd);
 451                 Log(Form("End time for run %d: %i",fRun, (Int_t)timeEnd));
 452                 nparameter++;
 453         }
 454         else {
 455                 Log(Form("End time not put in logbook, setting to invalid in GRP entry!"));
 456         }
 457
 458         if (beamEnergy != 0){
 459                 grpObj->SetBeamEnergy(beamEnergy);
 460                 Log(Form("Beam Energy for run %d: %f",fRun, beamEnergy));
 461                 if ((runType == "PHYSICS" && beamType!="Cosmics")){
 462                         nparameter++; // increasing nparameters only in case we're in PHYSICS runs with beamType != Cosmics
 463                 }
 464         }
 465         else {
 466                 if ((runType == "PHYSICS" && beamType!="Cosmics")){
 467                         Log(Form("Beam Energy not put in logbook, setting to invalid in GRP entry, and producing an error (beamType = %s, runType = %s)",beamType.Data(), runType.Data()));
 468                 }
 469                 else{
 470                         Log(Form("Beam Energy not put in logbook, setting to invalid in GRP entry, but not producing any error (beamType = %s, runType = %s)",beamType.Data(), runType.Data()));
 471                 }
 472         }
 473
 474
 475         if (beamType.Length() != 0){
 476                 grpObj->SetBeamType(beamType);
 477                 Log(Form("Beam Type for run %d: %s",fRun, beamType.Data()));
 478                 nparameter++;
 479         }
 480         else {
 481                 Log(Form("Beam Type not put in logbook, setting to invalid in GRP entry!"));
 482         }
 483
 484         if (numberOfDetectors != 0){
 485                 grpObj->SetNumberOfDetectors(numberOfDetectors);
 486                 Log(Form("Number Of Detectors for run %d: %d",fRun, (Int_t)numberOfDetectors));
 487                 nparameter++;
 488         }
 489         else {
 490                 Log(Form("Number Of Detectors not put in logbook, setting to invalid in GRP entry!"));
 491         }
 492
 493         if (detectorMask != 0){
 494                 grpObj->SetDetectorMask(detectorMask);
 495                 Log(Form("Detector Mask for run %d: %d",fRun, detectorMask));
 496                 nparameter++;
 497         }
 498         else {
 499                 Log(Form("Detector Mask not put in logbook, setting to invalid in GRP entry!"));
 500         }
 501
 502         if (lhcPeriod.Length() != 0) {
 503                 grpObj->SetLHCPeriod(lhcPeriod);
 504                 Log(Form("LHC period (DAQ) for run %d: %s",fRun, lhcPeriod.Data()));
 505                 nparameter++;
 506         }
 507         else {
 508                 Log(Form("LHCperiod not put in logbook, setting to invalid in GRP entry!"));
 509         }
 510         if (runType.Length() != 0) {
 511                 grpObj->SetRunType(runType);
 512                 Log(Form("Run Type (DAQ) for run %d: %s",fRun, runType.Data()));
 513                 nparameter++;
 514         }
 515         else {
 516                 Log(Form("Run Type not put in logbook, setting to invalid in GRP entry!"));
 517         }
 518
 519         return nparameter;
 520 }
 521
 522 //_______________________________________________________________
 523
 524 UInt_t AliGRPPreprocessor::ProcessDaqFxs()
 525 {
 526         //======DAQ FXS======//
 527
 528         //      AliRawEventHeaderV3_9::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_9 - temporary fix
 529         TList* list = GetFileSources(kDAQ);
 530         if (!list) {
 531                 Log("No raw data tag list: connection problems with DAQ FXS logbook!");
 532                 return 1;
 533         }
 534
 535         if (list->GetEntries() == 0) {
 536                 Log("no raw data tags in this run: nothing to merge!");
 537                 delete  list; list=0;
 538                 return 0;
 539         }
 540
 541         TChain *fRawTagChain = new TChain("T");
 542         Int_t nFiles=0;
 543         TIterator* iter = list->MakeIterator();
 544         TObject* obj = 0;
 545         while ((obj = iter->Next())) {
 546                 TObjString* objStr = dynamic_cast<TObjString*> (obj);
 547                 if (objStr) {
 548                         Log(Form("Found source %s", objStr->String().Data()));
 549                         TList* list2 = GetFileIDs(kDAQ, objStr->String());
 550                         if (!list2) {
 551                                 Log("No list with ids from DAQ was found: connection problems with DAQ FXS logbook!");
 552                                 delete fRawTagChain; fRawTagChain=0;
 553                                 return 1;
 554                         }
 555                         Log(Form("Number of ids: %d",list2->GetEntries()));
 556                         for(Int_t i = 0; i < list2->GetEntries(); i++) {
 557                                 TObjString *idStr = (TObjString *)list2->At(i);
 558                                 TString fileName = GetFile(kDAQ,idStr->String().Data(),objStr->String().Data());
 559                                 if (fileName.Length() > 0) {
 560                                         Log(Form("Adding file in the chain: %s",fileName.Data()));
 561                                         fRawTagChain->Add(fileName.Data());
 562                                         nFiles++;
 563                                 } else {
 564                                         Log(Form("Could not retrieve file with id %s from source %s: "
 565                                                  "connection problems with DAQ FXS!",
 566                                                  idStr->String().Data(), objStr->String().Data()));
 567                                         delete list; list=0;
 568                                         delete list2; list2=0;
 569                                         delete fRawTagChain; fRawTagChain=0;
 570                                         return 2;
 571                                 }
 572                         }
 573                         delete list2;
 574                 }
 575         }
 576
 577         TString fRawDataFileName = "GRP_Merged.tag.root";
 578         Log(Form("Merging %d raw data tags into file: %s", nFiles, fRawDataFileName.Data()));
 579
 580         if( fRawTagChain->Merge(fRawDataFileName) < 1 ) {
 581                 Log("Error merging raw data files!!!");
 582                 return 3;
 583         }
 584
 585         TString outputfile = Form("Run%d.Merged.RAW.tag.root", fRun);
 586         Bool_t result = StoreRunMetadataFile(fRawDataFileName.Data(),outputfile.Data());
 587
 588         if (!result) {
 589                 Log("Problem storing raw data tags in local file!!!");
 590         } else {
 591                 Log("Raw data tags merged successfully!!");
 592         }
 593
 594         delete iter;
 595         delete list;
 596         delete fRawTagChain; fRawTagChain=0;
 597
 598         if (result == kFALSE) {
 599                 return 4;
 600         }
 601
 602         return 0;
 603
 604 }
 605
 606 //_______________________________________________________________
 607 UInt_t AliGRPPreprocessor::ProcessDcsFxs(TString partition, TString detector)
 608 {
 609
 610         // processing the info
 611         // stored in the DCS FXS
 612         // coming from the trigger
 613
 614         // Get the CTP counters information
 615
 616         if (partition.IsNull() && !detector.IsNull()){ // standalone partition
 617                 Log("STANDALONE partition for current run, using Trigger Configuration dummy value");
 618                 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyScalers");
 619                 if (!cdbEntry) {
 620                         Log(Form("No dummy CTP scalers entry found, going into error..."));
 621                         return 1;
 622                 }
 623                 else{
 624                         AliTriggerRunScalers *scalers = (AliTriggerRunScalers*)cdbEntry->GetObject();
 625                         if (!scalers){
 626                                 Log(Form("CTP dummy scalers not found in OCDB entry, going into error..."));
 627                                 return 1;
 628                         }
 629                         else {
 630                                 AliCDBMetaData metaData;
 631                                 metaData.SetResponsible("Roman Lietava");
 632                                 metaData.SetComment("CTP scalers from dummy entry in OCDB");
 633                                 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
 634                                         Log("Unable to store the dummy CTP scalers object to OCDB!");
 635                                         return 1;
 636                                 }
 637                         }
 638                 }
 639         }
 640
 641         else if (!partition.IsNull() && detector.IsNull()){ // global partition
 642                 Log("GLOBAL partition for current run, using CTP scalers from DCS FXS");
 643                 TString countersfile = GetFile(kDCS, "CTP_xcounters","");
 644                 if (countersfile.IsNull()) {
 645                         Log("No CTP counters files has been found: empty source!");
 646                         return 1;
 647                 }
 648                 else {
 649                         Log(Form("File with Id CTP_xcounters found in DCS FXS! Copied to %s",countersfile.Data()));
 650                         AliTriggerRunScalers *scalers = AliTriggerRunScalers::ReadScalers(countersfile);
 651                         if (!scalers) {
 652                                 Log("Bad CTP counters file! The corresponding CDB entry will not be filled!");
 653                                 return 1;
 654                         }
 655                         else {
 656                                 AliCDBMetaData metaData;
 657                                 metaData.SetBeamPeriod(0);
 658                                 metaData.SetResponsible("Roman Lietava");
 659                                 metaData.SetComment("CTP scalers");
 660                                 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
 661                                         Log("Unable to store the CTP scalers object to OCDB!");
 662                                         return 1;
 663                                 }
 664                         }
 665                 }
 666         }
 667
 668
 669         else{
 670                 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error...",partition.Data(),detector.Data()));
 671                 return 2;
 672         }
 673
 674         return 0;
 675
 676 }
 677 //_______________________________________________________________
 678
 679 Int_t AliGRPPreprocessor::ProcessDcsDPs(TMap* valueMap, AliGRPObject* grpObj)
 680 {
 681
 682         //
 683         // processing DCS DPs
 684         //
 685
 686         Int_t entries = 0;  // counting the entries that are in the DCS DB, not taking care whether they have values or not
 687         Int_t nLHCEntries = 0;
 688         Int_t nL3Entries = 0;
 689         Int_t nDipoleEntries = 0;
 690         Int_t nEnvEntries = 0;
 691         Int_t nHallProbesEntries = 0;
 692         nLHCEntries = ProcessLHCDPs(valueMap, grpObj);
 693         nL3Entries = ProcessL3DPs(valueMap, grpObj);
 694         nDipoleEntries = ProcessDipoleDPs(valueMap, grpObj);
 695         nEnvEntries = ProcessEnvDPs(valueMap, grpObj);
 696         nHallProbesEntries = ProcessHPDPs(valueMap, grpObj);
 697
 698         entries = nLHCEntries + nL3Entries + nDipoleEntries + nEnvEntries + nHallProbesEntries;
 699         return entries;
 700
 701 }
 702
 703 //_______________________________________________________________
 704
 705 Int_t AliGRPPreprocessor::ProcessL3DPs(const TMap* valueMap, AliGRPObject* grpObj)
 706 {
 707
 708         // processing DPs
 709         // related to
 710         // L3 info
 711
 712         Int_t nL3Entries = 0;
 713         TObjArray *array = 0x0;
 714         Int_t indexDP = -1;
 715         Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
 716
 717         AliInfo(Form("==========L3Current==========="));
 718         Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
 719         indexDP = kL3Current;
 720         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
 721         if(!array) {
 722                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
 723         }
 724         else {
 725                 if (array->GetEntries() == 0){
 726                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
 727                 }
 728                 else {
 729                         Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
 730                         if (floatDCS != NULL){
 731                                 grpObj->SetL3Current(floatDCS);
 732                         }
 733                         else{
 734                                 outOfRange = kTRUE;
 735                         }
 736                         if (floatDCS){
 737                                 delete[] floatDCS;
 738                                 floatDCS = 0x0;
 739                         }
 740                 }
 741                 if (!outOfRange) nL3Entries++;
 742         }
 743
 744         if (array) array = 0x0;
 745
 746         AliInfo(Form("==========L3Polarity==========="));
 747         indexDP = kL3Polarity;
 748         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
 749         if(!array) {
 750                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
 751         }
 752         else {
 753                 if (array->GetEntries() == 0){
 754                         AliError(Form("No entries found in array! setting %s Polarity to invalid...",fgkDCSDataPoints[indexDP]));
 755                 }
 756                 else {
 757                         Bool_t change = kFALSE;
 758                         Char_t charDCS = ProcessBool(array,change);
 759                         if (!change){
 760                                 grpObj->SetL3Polarity(charDCS);
 761                                 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetL3Polarity())));
 762                                 nL3Entries++;
 763                         }
 764                         else if (isZero){
 765                                 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
 766                                 nL3Entries++;
 767                         }
 768                         else {
 769                                 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]));
 770                         }
 771                 }
 772         }
 773
 774         return nL3Entries;
 775
 776 }
 777 //_______________________________________________________________
 778
 779 Int_t AliGRPPreprocessor::ProcessDipoleDPs(const TMap* valueMap, AliGRPObject* grpObj)
 780 {
 781         // processing DPs
 782         // related to
 783         // the Dipole info
 784
 785         Int_t nDipoleEntries = 0;
 786         TObjArray *array = 0x0;
 787         Int_t indexDP = -1;
 788         Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
 789
 790         AliInfo(Form("==========DipoleCurrent==========="));
 791         Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
 792         indexDP = kDipoleCurrent;
 793         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
 794         if(!array) {
 795                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
 796         }
 797         else {
 798                 if (array->GetEntries() == 0){
 799                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
 800                 }
 801                 else {
 802                         Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
 803                         if (floatDCS != NULL){
 804                                 grpObj->SetDipoleCurrent(floatDCS);
 805                         }
 806                         else{
 807                                 outOfRange=kTRUE;
 808                         }
 809                         if (floatDCS){
 810                                 delete[] floatDCS;
 811                                 floatDCS = 0x0;
 812                         }
 813                 }
 814                 if (!outOfRange) nDipoleEntries++;
 815         }
 816
 817         if (array) array = 0x0;
 818
 819         AliInfo(Form("==========DipolePolarity==========="));
 820         indexDP = kDipolePolarity;
 821         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
 822         if(!array) {
 823                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
 824         }
 825         else {
 826                 if (array->GetEntries() == 0){
 827                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
 828                 }
 829                 else {
 830                         Bool_t change = kFALSE;
 831                         Char_t charDCS = ProcessBool(array,change);
 832                         if (!change){
 833                                 grpObj->SetDipolePolarity(charDCS);
 834                                 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetDipolePolarity())));
 835                                 nDipoleEntries++;
 836                         }
 837                         else if (isZero){
 838                                 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
 839                                 nDipoleEntries++;
 840                         }
 841                         else{
 842                                 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]));
 843                         }
 844                 }
 845         }
 846
 847         return nDipoleEntries;
 848
 849 }
 850 //_______________________________________________________________
 851
 852 Int_t AliGRPPreprocessor::ProcessEnvDPs(TMap* valueMap, AliGRPObject* grpObj)
 853 {
 854         // processing DPs
 855         // related to
 856         // evironment conditions (temperature, pressure) info
 857
 858         Int_t nEnvEntries = 0;
 859         TObjArray *array = 0x0;
 860         Int_t indexDP = -1;
 861
 862         AliInfo(Form("==========CavernTemperature==========="));
 863         Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
 864         indexDP = kCavernTemperature;
 865         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
 866         if(!array) {
 867                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
 868         }
 869         else {
 870                 if (array->GetEntries() == 0){
 871                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
 872                 }
 873                 else {
 874                         Float_t *floatDCS = ProcessFloatAll(array);
 875                         if (floatDCS != NULL){
 876                                 grpObj->SetCavernTemperature(floatDCS);
 877                         }
 878                         else{
 879                                 outOfRange = kTRUE;
 880                         }
 881                         if (floatDCS){
 882                                 delete[] floatDCS;
 883                                 floatDCS = 0x0;
 884                         }
 885                 }
 886                 if (!outOfRange) nEnvEntries++;
 887         }
 888
 889         if (array) array = 0x0;
 890
 891         AliInfo(Form("==========AtmosPressures (Cavern + Surface)==========="));
 892         AliDCSSensorArray *dcsSensorArray = GetPressureMap(valueMap);
 893         dcsSensorArray->Print();
 894         if( fPressure->NumFits()==0 ) {
 895                 Log("Problem with the pressure sensor values!!!");
 896         }
 897         else {
 898                 AliInfo(Form("==========CavernAtmosPressure==========="));
 899                 indexDP = kCavernAtmosPressure;
 900                 AliDCSSensor* sensorCavernP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
 901                 AliDebug(2,Form("sensorCavernP2 = %p", sensorCavernP2));
 902                 if( sensorCavernP2->GetFit() ) {
 903                         Log(Form("<%s> for run %d: Sensor Fit found",fgkDCSDataPoints[indexDP], fRun));
 904                         grpObj->SetCavernAtmosPressure(sensorCavernP2);
 905                         nEnvEntries++;
 906                 }
 907                 //if (sensorP2) delete sensorP2;
 908                 else {
 909                         Log(Form("ERROR Sensor Fit for %s not found ", fgkDCSDataPoints[indexDP] ));
 910                 }
 911                 AliInfo(Form("==========SurfaceAtmosPressure==========="));
 912                 indexDP = kSurfaceAtmosPressure;
 913                 AliDCSSensor* sensorP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
 914                 AliDebug(2,Form("sensorP2 = %p", sensorP2));
 915                 if( sensorP2->GetFit() ) {
 916                         Log(Form("<%s> for run %d: Sensor Fit found",fgkDCSDataPoints[indexDP], fRun));
 917                         grpObj->SetSurfaceAtmosPressure(sensorP2);
 918                         nEnvEntries++;
 919                 }
 920                 //if (sensorP2) delete sensorP2;
 921                 else {
 922                         Log(Form("ERROR Sensor Fit for %s not found ", fgkDCSDataPoints[indexDP] ));
 923                 }
 924
 925         }
 926
 927         return nEnvEntries;
 928 }
 929 //_______________________________________________________________
 930
 931 Int_t AliGRPPreprocessor::ProcessHPDPs(const TMap* valueMap, AliGRPObject* grpObj)
 932 {
 933         // processing DPs
 934         // related to
 935         // Hall Probes info
 936
 937         Int_t nHPEntries = 0;
 938         TObjArray *array = 0x0;
 939         Int_t indexDP = -1;
 940         Bool_t outOfRange; // flag to monitor if any value collected by DCS is out of range
 941
 942         if (fgknDCSDPHallProbes != AliGRPObject::GetNumberOfHP()){
 943                 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()));
 944         }
 945         for (indexDP = 0; indexDP < AliGRPObject::GetNumberOfHP(); indexDP++){
 946                 outOfRange = kFALSE; // resetting outOfRange flag at each HP
 947                 AliInfo(Form("==========%s===========",AliGRPObject::GetHPDP(indexDP)));
 948                 array = (TObjArray *)valueMap->GetValue(AliGRPObject::GetHPDP(indexDP));
 949                 if(!array) {
 950                         Log(Form("%s not found in the map!!!",AliGRPObject::GetHPDP(indexDP)));
 951                 }
 952                 else {
 953                         if (array->GetEntries() == 0){
 954                                 AliError(Form("No entries found in array! setting %s to invalid...",AliGRPObject::GetHPDP(indexDP)));
 955                         }
 956                         else {
 957                                 Float_t *floatDCS = ProcessFloatAll(array);
 958                                 if (floatDCS != NULL){
 959                                         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]));
 960                                         grpObj->SetHallProbes((AliGRPObject::DP_HallProbes)indexDP,floatDCS);
 961                                         for (Int_t kk = 0 ; kk< 5; kk++){
 962                                                 AliDebug(2,Form("HallProbe[%d][%d]=%f",indexDP,kk,grpObj->GetHallProbes((AliGRPObject::DP_HallProbes)indexDP,(AliGRPObject::Stats)kk)));
 963                                         }
 964                                 }
 965                                 else{
 966                                         outOfRange = kTRUE;
 967                                 }
 968                                 if (floatDCS){
 969                                         delete[] floatDCS;
 970                                         floatDCS = 0x0;
 971                                 }
 972                         }
 973                         if (!outOfRange) nHPEntries++;
 974                 }
 975         }
 976
 977         Log(Form("Hall Probes = %d ", nHPEntries));
 978         return nHPEntries;
 979 }
 980
 981 //_______________________________________________________________
 982
 983 Int_t AliGRPPreprocessor::ProcessLHCDPs(const TMap* valueMap, AliGRPObject* grpObj)
 984 {
 985
 986         //
 987         // processing of LHC related DCS DPs, i.e.:
 988         // LHCState
 989         // LHCLuminosity
 990         // BeamIntensity
 991         //
 992
 993         Int_t nLHCEntries = 0;
 994         TObjArray *array = 0x0;
 995         Int_t indexDP = -1;
 996
 997         AliInfo(Form("==========LHCState==========="));
 998         indexDP = kLHCState;
 999         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1000         if(!array) {
1001                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1002         }
1003         else {
1004                 if (array->GetEntries() == 0){
1005                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1006                 }
1007                 else {
1008                         TString stringDCS = ProcessChar(array);
1009                         if (stringDCS.Length()!=0) {
1010                                 Bool_t found = kFALSE;
1011                                 for( Int_t i=0; i<20; i+=2 ) {
1012                                         if( stringDCS.CompareTo(fgkLHCState[i]) == 0 ) {
1013                                                 stringDCS = fgkLHCState[i+1];
1014                                                 found = kTRUE;
1015                                                 break;
1016                                         }
1017                                 }
1018                                 if (found){
1019                                         Log(Form("<%s> for run %d: %s",fgkDCSDataPoints[indexDP],fRun, stringDCS.Data()));
1020                                         grpObj->SetLHCState(stringDCS);
1021                                 }
1022                                 else{
1023                                         Log(Form("%s values found not valid!",fgkDCSDataPoints[indexDP]));
1024                                         grpObj->SetLHCState(AliGRPObject::GetInvalidString());
1025                                 }
1026                         }
1027                         else {
1028                                 Log(Form("%s not valid (null length), string set as invalid!",fgkDCSDataPoints[indexDP]));
1029                                 grpObj->SetLHCState(AliGRPObject::GetInvalidString());
1030                         }
1031                 }
1032                 nLHCEntries++;
1033         }
1034
1035         if (array) array = 0x0;
1036
1037         AliInfo(Form("==========LHCLuminosity==========="));
1038         Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
1039         indexDP = kLHCLuminosity;
1040         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1041         if(!array) {
1042                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1043         }
1044         else {
1045                 if (array->GetEntries() == 0){
1046                         AliError(Form("No entries found in array! setting %s and its Spline Fit to invalid...",fgkDCSDataPoints[indexDP]));
1047                 }
1048                 else {
1049                         Float_t *floatDCS = ProcessFloatAll(array);
1050                         if (floatDCS != NULL){
1051                                 grpObj->SetLHCLuminosity(floatDCS);
1052                                 AliSplineFit* splfit = GetSplineFit(array,fgkDCSDataPoints[indexDP]);
1053                                 grpObj->SetLHCLuminositySplineFit(splfit);
1054                         //              delete splfit;
1055                         }
1056                         else {
1057                                 outOfRange = kTRUE;
1058                         }
1059                         if (floatDCS){
1060                                 delete[] floatDCS;
1061                                 floatDCS = 0x0;
1062                         }
1063                 }
1064                 if (!outOfRange) nLHCEntries++;
1065         }
1066
1067         if (array) array = 0x0;
1068
1069         AliInfo(Form("==========BeamIntensity==========="));
1070         if (outOfRange) outOfRange = kFALSE;  // resetting outOfRange if needed
1071         indexDP = kBeamIntensity;
1072         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1073         if(!array) {
1074                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1075         }
1076         else {
1077                 if (array->GetEntries() == 0){
1078                         AliError(Form("No entries found in array! setting %s and its Spline Fit to invalid...",fgkDCSDataPoints[indexDP]));
1079                 }
1080                 else {
1081                         Float_t *floatDCS = ProcessFloatAll(array);
1082                         if (floatDCS != NULL){
1083                                 grpObj->SetBeamIntensity(floatDCS);
1084                                 AliSplineFit* splfit1 = GetSplineFit(array,fgkDCSDataPoints[indexDP]);
1085                                 grpObj->SetBeamIntensitySplineFit(splfit1);
1086                                 //delete splfit;
1087                         }
1088                         else{
1089                                 outOfRange = kTRUE;
1090                         }
1091                         if (floatDCS){
1092                                 delete[] floatDCS;
1093                                 floatDCS = 0x0;
1094                         }
1095                 }
1096                 if (!outOfRange) nLHCEntries++;
1097         }
1098
1099         return nLHCEntries;
1100 }
1101 //_________________________________________________________________________
1102
1103 AliSplineFit* AliGRPPreprocessor::GetSplineFit(const TObjArray *array, const TString& stringID){
1104
1105
1106         //
1107         // returning Spline Fit
1108         //
1109
1110         Int_t entriesarray = array->GetEntries();
1111         Float_t* value = new Float_t[entriesarray];
1112         Float_t* time = new Float_t[entriesarray];
1113         AliDCSValue* v = 0x0;
1114         for (Int_t iarray = 0; iarray < entriesarray; iarray++){
1115                 v = (AliDCSValue*)array->At(iarray);
1116                 value[iarray] = v->GetFloat();
1117                 time[iarray] = v->GetTimeStamp();
1118                 AliDebug(2,Form("iarray = %d, value = %f, time = %f",iarray,value[iarray],time[iarray]));
1119         }
1120         TGraph* gr = new TGraph(entriesarray,value,time);
1121         if (!gr ) {
1122                 AliWarning(Form("%s: no input graph to compute SplineFit",stringID.Data()));
1123                 return NULL;
1124         }
1125         AliSplineFit *fit = new AliSplineFit();
1126         fit->SetMinPoints(10);
1127         fit->InitKnots(gr,10,10,0.0);
1128         fit->SplineFit(2);
1129         fit->Cleanup();
1130         if (!fit) {
1131                 AliWarning(Form("%s: no fit performed",stringID.Data()));
1132                 return NULL;
1133         }
1134         return fit;
1135 }
1136
1137 //_________________________________________________________________________
1138
1139 TString AliGRPPreprocessor::ProcessChar(const TObjArray *array)
1140 {
1141
1142         //
1143         // processing char
1144         //
1145
1146         TString aDCSString="";
1147
1148         AliDCSValue *v = 0x0;
1149         for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1150                 v = (AliDCSValue *)array->At(iCount);
1151                 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
1152                         AliError(Form("DCS values for the parameter outside the queried interval"));
1153                         continue;
1154                 }
1155                 if (iCount > 0) {
1156                         if (aDCSString != v->GetChar())
1157                         AliError(Form("DCS values for the parameter changed from %s to %c within the queried interval", aDCSString.Data(), (Char_t)v->GetChar()));
1158                 }
1159                 aDCSString = (TString)v->GetChar();  // keeping always last value in the array
1160         }
1161         return aDCSString;
1162 }
1163
1164 //__________________________________________________________________________________________________________________
1165
1166 Float_t* AliGRPPreprocessor::ProcessFloatAll(const TObjArray* array)
1167 {
1168         //
1169         // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
1170         //
1171         // parameters[0] = mean
1172         // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
1173         // parameters[2] = median
1174         // parameters[3] = standard deviation wrt mean
1175         // parameters[4] = standard deviation wrt median
1176         //
1177
1178         Float_t* parameters = new Float_t[5];
1179         Double_t aDCSArrayMean = 0;     // Mean
1180         Double_t aDCSArrayTruncMean = 0;// Truncated Mean
1181         Double_t aDCSArrayMedian = 0;   // Median
1182         Double_t aDCSArraySDMean = 0;   // Standard Deviation wrt Mean
1183         Double_t aDCSArraySDMedian = 0; // Standard Deviation wrt Median
1184         Float_t aDCSArraySum = 0.0;
1185         Int_t iCounts = 0;
1186         Int_t iCounts1 = 0;
1187         Float_t temp = 0;
1188         Float_t temp1 = 0;
1189         Int_t nCounts = array->GetEntries();
1190         Float_t *tempArray = new Float_t[nCounts];
1191         for(Int_t i = 0; i < nCounts; i++) {
1192                 AliDCSValue *v = (AliDCSValue *)array->At(i);
1193                 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
1194                         AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
1195                         if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
1196                         if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
1197                         return NULL;
1198                 }
1199                 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
1200                         aDCSArraySum += v->GetFloat();
1201                         tempArray[i] = v->GetFloat();
1202                         AliDebug(2,Form("%d-th entry = %f",i,tempArray[i]));
1203                         iCounts += 1;
1204                 }
1205                 else {
1206                         AliError(Form("DCS values for the parameter outside the queried interval"));
1207                 }
1208         }
1209
1210         AliDebug(2,Form("Using %i entries, starting from %i entries",iCounts,nCounts));
1211         if(iCounts != 0) {
1212                 aDCSArrayMean = TMath::Mean(iCounts,tempArray);
1213                 aDCSArrayMedian = TMath::Median(iCounts,tempArray);
1214                 aDCSArraySDMean = TMath::RMS(iCounts,tempArray);
1215                 AliDebug(2,Form("SD = %f",aDCSArraySDMean));
1216                 // computing standard deviation wrt median
1217                 AliDebug(2,Form("maximum = %f, minimum = %f", aDCSArrayMean+3*aDCSArraySDMean, aDCSArrayMean-3*aDCSArraySDMean));
1218                 for (Int_t i = 0; i < iCounts; i++){
1219                         AliDCSValue *v = (AliDCSValue *)array->At(i);
1220                         AliDebug(3,Form("maximum = %f, minimum = %f", aDCSArrayMean+3*aDCSArraySDMean, aDCSArrayMean-3*aDCSArraySDMean));
1221                         AliDebug(3,Form("%i-th entry = %f",i, v->GetFloat()));
1222                         if ((v->GetFloat()<=aDCSArrayMean+3*aDCSArraySDMean) && (v->GetFloat()>=aDCSArrayMean-3*aDCSArraySDMean)){
1223                                 temp1+=v->GetFloat();
1224                                 iCounts1++;
1225                                 AliDebug(3,Form("temp1 = %f, iCounts1 = %i",temp1,iCounts1));
1226                         }
1227                         temp += (v->GetFloat()-aDCSArrayMedian)*(v->GetFloat()-aDCSArrayMedian);
1228                 }
1229                 AliDebug(3,Form("temp before the ratio = %f, with %d counts", temp, iCounts));
1230                 temp/=iCounts;
1231                 AliDebug(3,Form("temp after the ratio = %f", temp));
1232                 if (temp>0) {
1233                         aDCSArraySDMedian = TMath::Sqrt(temp);
1234                 }
1235                 else if (temp==0) {
1236                         AliInfo(Form("Radical = 0 in computing standard deviation wrt median! Setting it to zero...."));
1237                         aDCSArraySDMedian = 0;
1238                 }
1239                 else{
1240                         AliError(Form("Radical < 0 in computing standard deviation! Setting it to invalid...."));
1241                         aDCSArraySDMedian = AliGRPObject::GetInvalidFloat();
1242                 }
1243         }
1244         else {
1245                 aDCSArrayMean = AliGRPObject::GetInvalidFloat();
1246                 aDCSArrayMedian = AliGRPObject::GetInvalidFloat();
1247                 aDCSArraySDMean = AliGRPObject::GetInvalidFloat();
1248         }
1249         AliDebug(3,Form("iCounts1 = %d and temp1 = %f",iCounts1, temp1));
1250         if (iCounts1 > 0) {
1251                 aDCSArrayTruncMean = temp1/iCounts1;
1252         }
1253         else{
1254                 aDCSArrayTruncMean = AliGRPObject::GetInvalidFloat();
1255         }
1256
1257
1258
1259         AliDebug(2,Form("mean within %d counts = %f ",iCounts,aDCSArrayMean));
1260         AliDebug(2,Form("truncated mean within %d counts = %f (%i values used)",iCounts,aDCSArrayTruncMean,iCounts1));
1261         AliDebug(2,Form("median within %d counts = %f ",iCounts,aDCSArrayMedian));
1262         AliDebug(2,Form("standard deviation with mean within %d counts = %f ",iCounts,aDCSArraySDMean));
1263         AliDebug(2,Form("standard deviation with median within %d counts = %f ",iCounts,aDCSArraySDMedian));
1264
1265         parameters[0] = aDCSArrayMean;
1266         parameters[1] = aDCSArrayTruncMean;
1267         parameters[2] = aDCSArrayMedian;
1268         parameters[3] = aDCSArraySDMean;
1269         parameters[4] = aDCSArraySDMedian;
1270
1271         AliDebug(2,Form("mean = %f, truncated mean = %f, median = %f, SD wrt mean = %f, SD wrt median = %f ",parameters[0],parameters[1],parameters[2],parameters[3],parameters[4]));
1272         //AliInfo(Form("mean = %f, truncated mean = %f, median = %f, SD wrt mean = %f, SD wrt median = %f ",parameters[0],parameters[1],parameters[2],parameters[3],parameters[4]));
1273
1274         return parameters;
1275 }
1276
1277
1278
1279 //__________________________________________________________________________________________________________________
1280
1281 Float_t* AliGRPPreprocessor::ProcessFloatAllMagnet(const TObjArray* array, Int_t indexDP, Bool_t &isZero)
1282 {
1283         //
1284         // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
1285         // used for L3 and Dipole magnets, using isZero flag to decide whther the magnet was OFF/ON
1286         // the flag is set according to the L3/Dipole current value
1287         // current threshold for L3 = 350 A (value provided by DCS)
1288         // current threshold for Dipole = 450 A (value provided by DCS)
1289         //
1290         // parameters[0] = mean
1291         // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
1292         // parameters[2] = median
1293         // parameters[3] = standard deviation wrt mean
1294         // parameters[4] = standard deviation wrt median
1295         //
1296
1297         AliInfo(Form("indexDP = %d",indexDP));
1298         Float_t* parameters = new Float_t[5];
1299         Double_t aDCSArrayMean = 0;     // Mean
1300         Double_t aDCSArrayTruncMean = 0;// Truncated Mean
1301         Double_t aDCSArrayMedian = 0;   // Median
1302         Double_t aDCSArraySDMean = 0;   // Standard Deviation wrt Mean
1303         Double_t aDCSArraySDMedian = 0; // Standard Deviation wrt Median
1304         Float_t aDCSArraySum = 0.0;
1305         Int_t iCounts = 0;
1306         Int_t iCounts1 = 0;
1307         Float_t temp = 0;
1308         Float_t temp1 = 0;
1309         Int_t nCounts = array->GetEntries();
1310         Float_t *tempArray = new Float_t[nCounts];
1311         for(Int_t i = 0; i < nCounts; i++) {
1312                 AliDCSValue *v = (AliDCSValue *)array->At(i);
1313                 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
1314                         AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
1315 if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
1316 if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
1317                         return NULL;
1318                 }
1319                 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
1320                         aDCSArraySum += v->GetFloat();
1321                         tempArray[i] = v->GetFloat();
1322                         AliDebug(2,Form("%d-th entry = %f",i,tempArray[i]));
1323                         iCounts += 1;
1324                         if (indexDP == kL3Current && v->GetFloat() > 350 && isZero == kTRUE) isZero=kFALSE;
1325                         if (indexDP == kDipoleCurrent && v->GetFloat() > 450 && isZero == kTRUE) isZero=kFALSE;
1326                 }
1327                 else {
1328                         AliError(Form("DCS values for the parameter outside the queried interval"));
1329                 }
1330         }
1331
1332         AliDebug(2,Form("Using %i entries, starting from %i entries",iCounts,nCounts));
1333         if(iCounts != 0) {
1334                 aDCSArrayMean = TMath::Mean(iCounts,tempArray);
1335                 aDCSArrayMedian = TMath::Median(iCounts,tempArray);
1336                 aDCSArraySDMean = TMath::RMS(iCounts,tempArray);
1337                 AliDebug(2,Form("SD = %f",aDCSArraySDMean));
1338                 // computing standard deviation wrt median
1339                 AliDebug(2,Form("maximum = %f, minimum = %f", aDCSArrayMean+3*aDCSArraySDMean, aDCSArrayMean-3*aDCSArraySDMean));
1340                 for (Int_t i = 0; i < iCounts; i++){
1341                         AliDCSValue *v = (AliDCSValue *)array->At(i);
1342                         AliDebug(3,Form("maximum = %f, minimum = %f", aDCSArrayMean+3*aDCSArraySDMean, aDCSArrayMean-3*aDCSArraySDMean));
1343                         AliDebug(3,Form("%i-th entry = %f",i, v->GetFloat()));
1344                         if ((v->GetFloat()<=aDCSArrayMean+3*aDCSArraySDMean) && (v->GetFloat()>=aDCSArrayMean-3*aDCSArraySDMean)){
1345                                 temp1+=v->GetFloat();
1346                                 iCounts1++;
1347                                 AliDebug(3,Form("temp1 = %f, iCounts1 = %i",temp1,iCounts1));
1348                         }
1349                         temp += (v->GetFloat()-aDCSArrayMedian)*(v->GetFloat()-aDCSArrayMedian);
1350                 }
1351                 AliDebug(3,Form("temp before the ratio = %f, with %d counts", temp, iCounts));
1352                 temp/=iCounts;
1353                 AliDebug(3,Form("temp after the ratio = %f", temp));
1354                 if (temp>0) {
1355                         aDCSArraySDMedian = TMath::Sqrt(temp);
1356                 }
1357                 else if (temp==0) {
1358                         AliInfo(Form("Radical = 0 in computing standard deviation wrt median! Setting it to zero...."));
1359                         aDCSArraySDMedian = 0;
1360                 }
1361                 else{
1362                         AliError(Form("Radical < 0 in computing standard deviation! Setting it to invalid...."));
1363                         aDCSArraySDMedian = AliGRPObject::GetInvalidFloat();
1364                 }
1365         }
1366         else {
1367                 aDCSArrayMean = AliGRPObject::GetInvalidFloat();
1368                 aDCSArrayMedian = AliGRPObject::GetInvalidFloat();
1369                 aDCSArraySDMean = AliGRPObject::GetInvalidFloat();
1370         }
1371         AliDebug(3,Form("iCounts1 = %d and temp1 = %f",iCounts1, temp1));
1372         if (iCounts1 > 0) {
1373                 aDCSArrayTruncMean = temp1/iCounts1;
1374         }
1375         else{
1376                 aDCSArrayTruncMean = AliGRPObject::GetInvalidFloat();
1377         }
1378
1379
1380
1381         AliDebug(2,Form("mean within %d counts = %f ",iCounts,aDCSArrayMean));
1382         AliDebug(2,Form("truncated mean within %d counts = %f (%i values used)",iCounts,aDCSArrayTruncMean,iCounts1));
1383         AliDebug(2,Form("median within %d counts = %f ",iCounts,aDCSArrayMedian));
1384         AliDebug(2,Form("standard deviation with mean within %d counts = %f ",iCounts,aDCSArraySDMean));
1385         AliDebug(2,Form("standard deviation with median within %d counts = %f ",iCounts,aDCSArraySDMedian));
1386
1387         parameters[0] = aDCSArrayMean;
1388         parameters[1] = aDCSArrayTruncMean;
1389         parameters[2] = aDCSArrayMedian;
1390         parameters[3] = aDCSArraySDMean;
1391         parameters[4] = aDCSArraySDMedian;
1392
1393         AliDebug(2,Form("mean = %f, truncated mean = %f, median = %f, SD wrt mean = %f, SD wrt median = %f ",parameters[0],parameters[1],parameters[2],parameters[3],parameters[4]));
1394         //AliInfo(Form("mean = %f, truncated mean = %f, median = %f, SD wrt mean = %f, SD wrt median = %f ",parameters[0],parameters[1],parameters[2],parameters[3],parameters[4]));
1395
1396         return parameters;
1397 }
1398
1399
1400 //_______________________________________________________________
1401
1402 Char_t AliGRPPreprocessor::ProcessBool(const TObjArray* array, Bool_t &change)
1403 {
1404         //
1405         // processing Boolean values
1406         //
1407
1408         Bool_t aDCSBool = kTRUE;
1409
1410         AliDCSValue *v = 0x0;
1411
1412         for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1413                 v = (AliDCSValue *)array->At(iCount);
1414                 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
1415                         AliError(Form("DCS values for the parameter outside the queried interval"));
1416                         continue;
1417                 }
1418                 if (iCount > 0) {
1419                         if (aDCSBool != v->GetBool())
1420                         AliError(Form("DCS values for the parameter changed from %d to %d within the queried interval", (UInt_t)aDCSBool, (UInt_t)v->GetBool()));
1421                         change = kTRUE;
1422                 }
1423                 aDCSBool = v->GetBool(); // always keeping last value
1424                 AliDebug(2,Form("Bool = %d",(Int_t)aDCSBool));
1425         }
1426
1427         Char_t caDCSBool = (Char_t) aDCSBool;
1428         return caDCSBool;
1429
1430 }
1431
1432 //_______________________________________________________________
1433
1434 Float_t AliGRPPreprocessor::ProcessInt(const TObjArray* array)
1435 {
1436         //
1437         // processing Int values, returning mean
1438         // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
1439         // are outside the queried time interval or their value is out of range
1440         //
1441
1442         Float_t aDCSArraySum = 0.0;
1443         Float_t aDCSArrayMean = 0.0;
1444         Int_t iCounts = 0;
1445         AliDCSValue* v = 0x0;
1446
1447         for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1448                 v = (AliDCSValue *)array->At(iCount);
1449                 if ((v->GetInt() < fminInt) || (v->GetInt() > fmaxInt)) {
1450                         AliError(Form("Error! Int value found in DCS map at %d-th entry is OUT OF RANGE: value = %d",iCount, v->GetInt()));
1451                         return AliGRPObject::GetInvalidFloat();
1452                 }
1453                 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
1454                         aDCSArraySum += v->GetInt();
1455                         iCounts += 1;
1456                 }
1457         }
1458
1459         if(iCounts != 0) aDCSArrayMean = aDCSArraySum/iCounts;
1460         else aDCSArrayMean = AliGRPObject::GetInvalidFloat();
1461
1462         return aDCSArrayMean;
1463
1464 }
1465 //_______________________________________________________________
1466
1467 Float_t AliGRPPreprocessor::ProcessUInt(const TObjArray* array)
1468 {
1469         //
1470         // processing Int values, returning mean
1471         // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
1472         // are outside the queried time interval or their value is out of range
1473         //
1474
1475         Float_t aDCSArraySum = 0.0;
1476         Float_t aDCSArrayMean = 0.0;
1477         Int_t iCounts = 0;
1478         AliDCSValue* v = 0x0;
1479
1480         for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1481                 v = (AliDCSValue *)array->At(iCount);
1482                 if ((v->GetUInt() < fminUInt) || (v->GetUInt() > fmaxUInt)) {
1483                         AliError(Form("Error! UInt value found in DCS map at %d-th entry is OUT OF RANGE: value = %u",iCount,v->GetUInt()));
1484                         return AliGRPObject::GetInvalidFloat();
1485                 }
1486                 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
1487                         aDCSArraySum += v->GetUInt();
1488                         iCounts += 1;
1489                 }
1490         }
1491
1492         if(iCounts != 0) aDCSArrayMean = aDCSArraySum/iCounts;
1493         else aDCSArrayMean = AliGRPObject::GetInvalidFloat();
1494
1495         return aDCSArrayMean;
1496
1497 }
1498
1499
1500 //_______________________________________________________________
1501
1502 AliDCSSensorArray *AliGRPPreprocessor::GetPressureMap(TMap* dcsAliasMap)
1503 {
1504         // extract DCS pressure maps. Perform fits to save space
1505
1506         TMap *map = fPressure->ExtractDCS(dcsAliasMap);
1507         if (map) {
1508                 fPressure->MakeSplineFit(map);
1509                 Double_t fitFraction = fPressure->NumFits()/fPressure->NumSensors();
1510                 if (fitFraction > kFitFraction ) {
1511                         AliInfo(Form("Pressure values extracted, %d fits performed.", fPressure->NumFits()));
1512                 } else {
1513                         AliInfo("Too few pressure maps fitted!!!");
1514                 }
1515         } else {
1516                 AliInfo("no atmospheric pressure map extracted!!!");
1517         }
1518         delete map;
1519
1520         return fPressure;
1521 }
1522
1523
1524
1525 //_______________________________________________________________
1526 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)
1527 {
1528         //
1529         // Retrieves logbook and trigger information from the online logbook
1530         // This information is needed for prompt reconstruction
1531         //
1532         // Parameters are:
1533         // Run number
1534         // DAQ params: dbHost, dbPort, dbName, user, password, logbookTable, triggerTable
1535         // cdbRoot
1536         //
1537         // returns:
1538         //         positive on success: the return code is the run number of last run processed of the same run type already processed by the SHUTTLE
1539         //         0 on success and no run was found
1540         //         negative on error
1541         //
1542         // This function is NOT called during the preprocessor run in the Shuttle!
1543         //
1544
1545         // defaults
1546         if (dbPort == 0)
1547                 dbPort = 3306;
1548
1549         // CDB connection
1550         AliCDBManager* cdb = AliCDBManager::Instance();
1551         cdb->SetDefaultStorage(cdbRoot);
1552
1553         // SQL connection
1554         TSQLServer* server = TSQLServer::Connect(Form("mysql://%s:%d/%s", dbHost, dbPort, dbName), user, password);
1555
1556         if (!server)
1557                 {
1558                         Printf("ERROR: Could not connect to DAQ LB");
1559                         return -1;
1560                 }
1561
1562         // main logbook
1563         TString sqlQuery;
1564         sqlQuery.Form("SELECT DAQ_time_start, run_type, detectorMask, L3_magnetCurrent, Dipole_magnetCurrent FROM logbook WHERE run = %d", run);
1565         TSQLResult* result = server->Query(sqlQuery);
1566         if (!result)
1567                 {
1568                         Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
1569                         return -2;
1570                 }
1571
1572         if (result->GetRowCount() == 0)
1573                 {
1574                         Printf("ERROR: Run %d not found", run);
1575                         delete result;
1576                         return -3;
1577                 }
1578
1579         TSQLRow* row = result->Next();
1580         if (!row)
1581                 {
1582                         Printf("ERROR: Could not receive data from run %d", run);
1583                         delete result;
1584                         return -4;
1585                 }
1586
1587         TString timeStartString(row->GetField(0));
1588         TString runType(row->GetField(1));
1589         TString detectorMaskString(row->GetField(2));
1590         TString l3CurrentString(row->GetField(3));
1591         TString dipoleCurrentString(row->GetField(4));
1592         time_t timeStart = (time_t)(timeStartString.Atoi());
1593         UInt_t detectorMask = (UInt_t)(detectorMaskString.Atoi());
1594         Float_t l3Current = (Float_t)(TMath::Abs(l3CurrentString.Atof()));
1595         Float_t dipoleCurrent = (Float_t)(TMath::Abs(dipoleCurrentString.Atof()));
1596
1597         AliGRPObject * grpObj = new AliGRPObject();
1598         grpObj->SetTimeStart(timeStart);
1599         grpObj->SetRunType((TString)(row->GetField(1)));
1600         grpObj->SetDetectorMask(detectorMask);
1601         grpObj->SetL3Current(l3Current,(AliGRPObject::Stats)0);
1602         grpObj->SetDipoleCurrent(dipoleCurrent,(AliGRPObject::Stats)0);
1603
1604         delete row;
1605         row = 0;
1606
1607         delete result;
1608         result = 0;
1609
1610         Printf("Storing GRP/GRP/Data object with the following content");
1611         grpObj->Dump();
1612
1613         AliCDBMetaData metadata;
1614         metadata.SetResponsible("Jan Fiete Grosse-Oetringhaus & Chiara Zampolli");
1615         metadata.SetComment("GRP Output parameters received during online running");
1616
1617         AliCDBId id("GRP/GRP/Data", run, run);
1618         Bool_t success = cdb->Put(grpObj, id, &metadata);
1619
1620         delete grpObj;
1621
1622         if (!success)
1623                 {
1624                         Printf("ERROR: Could not store GRP/GRP/Data into OCDB");
1625                         return -5;
1626                 }
1627
1628         // Receive trigger information
1629         sqlQuery.Form("SELECT configFile FROM logbook_trigger_config WHERE run = %d", run);
1630         result = server->Query(sqlQuery);
1631         if (!result)
1632                 {
1633                         Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
1634                         return -11;
1635                 }
1636
1637         if (result->GetRowCount() == 0)
1638                 {
1639                         Printf("ERROR: Run %d not found in logbook_trigger_config", run);
1640                         delete result;
1641                         return -12;
1642                 }
1643
1644         row = result->Next();
1645         if (!row)
1646                 {
1647                         Printf("ERROR: Could not receive logbook_trigger_config data from run %d", run);
1648                         delete result;
1649                         return -13;
1650                 }
1651
1652         TString triggerConfig(row->GetField(0));
1653
1654         delete row;
1655         row = 0;
1656
1657         delete result;
1658         result = 0;
1659
1660         Printf("Found trigger configuration: %s", triggerConfig.Data());
1661
1662         AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConfig);
1663         if (!runcfg)
1664                 {
1665                         Printf("ERROR: Could not create CTP configuration object");
1666                         return -14;
1667                 }
1668
1669         metadata.SetComment("CTP run configuration received during online running");
1670
1671         AliCDBId id2("GRP/CTP/Config", run, run);
1672         success = cdb->Put(runcfg, id2, &metadata);
1673
1674         delete runcfg;
1675         runcfg = 0;
1676
1677         if (!success)
1678                 {
1679                         Printf("ERROR: Could not store GRP/CTP/Config into OCDB");
1680                         return -15;
1681                 }
1682
1683         // get last run with same run type that was already processed by the SHUTTLE
1684
1685         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());
1686         result = server->Query(sqlQuery);
1687         if (!result)
1688                 {
1689                         Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
1690                         return -21;
1691                 }
1692
1693         if (result->GetRowCount() == 0)
1694                 {
1695                         Printf("ERROR: No result with query <%s>", sqlQuery.Data());
1696                         delete result;
1697                         return -22;
1698                 }
1699
1700         row = result->Next();
1701         if (!row)
1702                 {
1703                         Printf("ERROR: Could not receive data for query <%s>", sqlQuery.Data());
1704                         delete result;
1705                         return -23;
1706                 }
1707
1708         TString lastRunStr(row->GetField(0));
1709         Int_t lastRun = lastRunStr.Atoi();
1710
1711         Printf("Last run with same run type %s is %d", runType.Data(), lastRun);
1712
1713         delete row;
1714         row = 0;
1715
1716         delete result;
1717         result = 0;
1718
1719         server->Close();
1720         delete server;
1721         server = 0;
1722
1723         return lastRun;
1724 }