prevent running if CDB snapshot setting failed
[u/mrichter/AliRoot.git] / 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         AliRawEventHeaderV3_14::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_14 - temporary fix 
1569         Log("Processing DAQ FXS");
1570         TList* list = GetFileSources(kDAQ);     
1571         if (!list) {
1572                 Log("No raw data tag list: connection problems with DAQ FXS logbook!");
1573                 return 1;
1574         }
1575         
1576         if (list->GetEntries() == 0) {
1577                 Log("no raw data tags in this run: nothing to merge!");
1578                 delete  list; list=0;
1579                 return 0;
1580         }
1581         
1582         TChain *fRawTagChain = new TChain("T");
1583         Int_t nFiles=0;
1584         Int_t nCorruptedFiles=0;
1585         TIterator* iter = list->MakeIterator();
1586         TObject* obj = 0;
1587         while ((obj = iter->Next())) {
1588                 TObjString* objStr = dynamic_cast<TObjString*> (obj);
1589                 if (objStr) {
1590                         Log(Form("Found source %s", objStr->String().Data()));
1591                         TList* list2 = GetFileIDs(kDAQ, objStr->String());
1592                         if (!list2) {
1593                                 Log("No list with ids from DAQ was found: connection problems with DAQ FXS logbook!");
1594                                 delete fRawTagChain; fRawTagChain=0;
1595                                 return 1;
1596                         }
1597                         Log(Form("Number of ids: %d",list2->GetEntries()));
1598                         for(Int_t i = 0; i < list2->GetEntries(); i++) {
1599                                 TObjString *idStr = (TObjString *)list2->At(i);
1600                                 if (idStr->String().CompareTo("QAThreshold") == 0 || idStr->String().CompareTo("TriggerClassesAndHistosToClone") == 0) {
1601                                         Log(Form("Skipping file with Id %s",idStr->String().Data()));
1602                                         continue; 
1603                                 }
1604                                 TString fileName = GetFile(kDAQ,idStr->String().Data(),objStr->String().Data());
1605                                 if (fileName.Length() > 0) {
1606                                         if(!CheckFileRecords(fileName.Data())){
1607                                                 Log(Form("The file records for \"%s\" are corrupted! The chain is skipping it.",fileName.Data()));
1608                                                 nCorruptedFiles++;
1609                                         }else{
1610                                                 Log(Form("Adding file in the chain: %s",fileName.Data()));
1611                                                 fRawTagChain->Add(fileName.Data());
1612                                                 nFiles++;
1613                                         }
1614                                 } else {
1615                                         Log(Form("Could not retrieve file with id %s from source %s: "
1616                                                  "connection problems with DAQ FXS!",
1617                                                  idStr->String().Data(), objStr->String().Data()));
1618                                         delete list; list=0;
1619                                         delete list2; list2=0;
1620                                         delete fRawTagChain; fRawTagChain=0;
1621                                         return 2;
1622                                 }
1623                         }
1624                         delete list2;
1625                 }
1626         }
1627
1628         if (nFiles == 0){
1629                 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!");
1630                 delete iter;
1631                 iter = 0;
1632                 delete list;
1633                 list = 0;
1634                 delete fRawTagChain; 
1635                 fRawTagChain=0;
1636                 return 0;
1637         }
1638         
1639         TString fRawDataFileName = "GRP_Merged.tag.root";
1640         if(nCorruptedFiles!=0)
1641                 Log(Form("Merging %d raw data tags into file: %s. %d corrupted files skipped", nFiles, fRawDataFileName.Data(), nCorruptedFiles));
1642         else
1643                 Log(Form("Merging %d raw data tags into file: %s", nFiles, fRawDataFileName.Data()));
1644         
1645         if (fRawTagChain->Merge(fRawDataFileName) < 1 ) {
1646                 Log(Form("Error merging %d raw data files!!!",nFiles));
1647                 delete iter;
1648                 iter = 0;
1649                 delete list;
1650                 list = 0;
1651                 delete fRawTagChain; 
1652                 fRawTagChain=0;
1653                 return 3;
1654         }
1655                 
1656         TString outputfile = Form("Run%d.Merged.RAW.tag.root", fRun);
1657         Bool_t result = StoreRunMetadataFile(fRawDataFileName.Data(),outputfile.Data());
1658         
1659         if (!result) {
1660                 Log("Problem storing raw data tags in local file!!!");
1661         } else {
1662                 Log("Raw data tags merged successfully!!");
1663         }
1664         
1665         delete iter;
1666         iter = 0;
1667         delete list;
1668         list = 0;
1669         delete fRawTagChain; fRawTagChain=0;
1670         
1671         if (result == kFALSE) {
1672                 return 4;
1673         }
1674         
1675         return 0;
1676         
1677 }
1678
1679 //_______________________________________________________________
1680 UInt_t AliGRPPreprocessor::ProcessDcsFxs(TString partition, TString detector)
1681 {
1682
1683         // processing the info
1684         // stored in the DCS FXS
1685         // coming from the trigger
1686
1687         // Get the CTP counters information
1688         //              +
1689         // Get the CTP aliases information
1690
1691         if (partition.IsNull() && !detector.IsNull()){ // standalone partition
1692                 Log("STANDALONE partition for current run, using Trigger Scalers and Trigger Aliases dummy values");
1693
1694                 AliCDBEntry *cdbEntryScalers = GetFromOCDB("CTP","DummyScalers");
1695                 if (!cdbEntryScalers) {
1696                         Log(Form("No dummy CTP scalers entry found, going into error..."));
1697                         return 1;
1698                 }
1699                 else{
1700                         AliTriggerRunScalers *scalers = (AliTriggerRunScalers*)cdbEntryScalers->GetObject();
1701                         if (!scalers){
1702                                 Log(Form("CTP dummy scalers not found in OCDB entry, going into error..."));
1703                                 return 1;
1704                         }
1705                         else {
1706                                 AliCDBMetaData metaData;
1707                                 metaData.SetResponsible("Roman Lietava");
1708                                 metaData.SetComment("CTP scalers from dummy entry in OCDB");
1709                                 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1710                                         Log("Unable to store the dummy CTP scalers object to OCDB!");
1711                                         delete scalers;
1712                                         return 1;
1713                                 }
1714                         }
1715                 }
1716
1717                 AliCDBEntry *cdbEntryAliases = GetFromOCDB("CTP","DummyAliases");
1718                 if (!cdbEntryAliases) {
1719                         Log(Form("No dummy CTP aliases entry found, going into error..."));
1720                         return 2;
1721                 }
1722                 else{
1723                         THashList *aliases = dynamic_cast<THashList*>(cdbEntryAliases->GetObject());
1724                         if (!aliases){
1725                                 Log(Form("CTP dummy aliases not found in OCDB entry, going into error..."));
1726                                 return 2;
1727                         }
1728                         else {
1729                                 AliCDBMetaData metaData;
1730                                 metaData.SetResponsible("Evgeny Kryshen");
1731                                 metaData.SetComment("CTP mapping of trigger classes to trigger aliases");
1732                                 if (!Store("CTP","Aliases", aliases, &metaData, 0, 0)) {
1733                                         Log("Unable to store the dummy CTP aliases object to OCDB!");
1734                                         delete aliases;                                 
1735                                         return 2;
1736                                 }
1737                         }
1738                 }
1739         }
1740
1741         else if (!partition.IsNull() && detector.IsNull()){ // global partition
1742                 Log("GLOBAL partition for current run, using CTP scalers from DCS FXS");
1743                 TString countersfile = GetFile(kDCS, "CTP_xcounters","");
1744                 if (countersfile.IsNull()) {
1745                         Log("No CTP counters files has been found: empty source!");
1746                         return 1;
1747                 }
1748                 else {
1749                         Log(Form("File with Id CTP_xcounters found in DCS FXS! Copied to %s",countersfile.Data()));
1750                         AliTriggerRunScalers *scalers = AliTriggerRunScalers::ReadScalers(countersfile);
1751                         if (!scalers) {
1752                                 Log("Bad CTP counters file! The corresponding CDB entry will not be filled!");
1753                                 return 1;
1754                         }
1755                         else {
1756                                 AliCDBMetaData metaData;
1757                                 metaData.SetBeamPeriod(0);
1758                                 metaData.SetResponsible("Roman Lietava");
1759                                 metaData.SetComment("CTP scalers");
1760                                 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1761                                         Log("Unable to store the CTP scalers object to OCDB!");
1762                                         delete scalers;                                 
1763                                         return 1;
1764                                 }
1765                         }
1766                         delete scalers;
1767                 }
1768
1769
1770
1771                 TString aliasesFile = GetFile(kDCS, "CTP_aliases","");
1772                 if (aliasesFile.IsNull()) {
1773                         Log("No CTP aliases files has been found: empty source!");
1774                         return 2;
1775                 }
1776                 else {
1777                         Log(Form("File with Id CTP_aliases found in DCS FXS! Copied to %s",aliasesFile.Data()));
1778                         // We build the THashList of TNamed("triggerclass","comma_separated_list_of_corresponding_aliases")
1779                         THashList* trClasses2Aliases = ProcessAliases(aliasesFile);
1780                         if (!trClasses2Aliases) {
1781                                 Log("Bad CTP aliases file! The corresponding CDB entry will not be filled!");
1782                                 return 2;
1783                         }
1784                         else {
1785                                 AliCDBMetaData metaData;
1786                                 metaData.SetBeamPeriod(0);
1787                                 metaData.SetResponsible("Evgeny Kryshen");
1788                                 metaData.SetComment("CTP mapping of trigger classes to trigger aliases");
1789                                 if (!Store("CTP","Aliases", trClasses2Aliases, &metaData, 0, 0)) {
1790                                         Log("Unable to store the CTP aliases object to OCDB!");
1791                                         delete trClasses2Aliases;                                       
1792                                         return 2;
1793                                 }
1794                         }
1795                         delete trClasses2Aliases;
1796                 }
1797         }
1798         
1799
1800         else{   
1801                 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error...",partition.Data(),detector.Data()));
1802                 return 3;
1803         }
1804
1805         return 0;
1806
1807 }
1808
1809 //_______________________________________________________________
1810 THashList* AliGRPPreprocessor::ProcessAliases(const char* aliasesFile)
1811 {
1812
1813         //
1814         // build the THashList of triggerclasses-to-triggeraliases from text file  
1815         // each line of the file is supposed to be a string composed by
1816         // triggerclass+spaces+commaseparatedlistofcorrespondingaliases\n
1817         // it will add a TNamed("triggerclass","commaseparatedlistofcorrespondingaliases")
1818         // to the hashlist
1819         //
1820
1821         if (gSystem->AccessPathName(aliasesFile)) {
1822                 Printf("file (%s) not found", aliasesFile);
1823                 return 0;
1824         }
1825
1826         ifstream *file = new ifstream(aliasesFile);
1827         if (!*file) {
1828                 Printf("Error opening file (%s) !",aliasesFile);
1829                 file->close();
1830                 delete file;
1831                 return 0;
1832         }
1833
1834         THashList *hList = new THashList(10);
1835         hList->SetName("List of trigger classes to trigger aliases strings");
1836
1837         TString strLine;
1838         while (strLine.ReadLine(*file)) {
1839
1840             // safety for null lines, tabs instead of whitespaces, trailing carriage return, leading or trailing spaces/tabs
1841                 if (strLine.IsNull()) continue;
1842                 strLine.ReplaceAll('\t',' ');
1843                 strLine.Remove(TString::kLeading,' ');
1844                 strLine.Remove(TString::kTrailing,'\r');
1845                 strLine.Remove(TString::kTrailing,' ');
1846
1847                 TObjArray* arr = strLine.Tokenize(' ');
1848                 if(arr->GetEntries() != 2){
1849                         Printf("The line:\n%s\nunexpectedly contains %d tokens, instead of two.",strLine.Data(),arr->GetEntries());
1850                         delete arr;
1851                         return 0;
1852                 }
1853                 TObjString *osTC = (TObjString*) arr->At(0);
1854                 TObjString *osTAlist = (TObjString*) arr->At(1);
1855                 TNamed *ctoa = new TNamed(osTC->GetName(),osTAlist->GetName());
1856                 hList->Add(ctoa);
1857                 delete arr;
1858         }
1859
1860         file->close();
1861         delete file;
1862
1863         return hList;
1864 }
1865
1866 //_______________________________________________________________
1867 Int_t AliGRPPreprocessor::ProcessDcsDPs(TMap* valueMap, AliGRPObject* grpObj)
1868 {
1869
1870         //
1871         // processing DCS DPs
1872         //
1873
1874         Int_t entries = 0;  // counting the entries that are in the DCS DB, not taking care whether they have values or not
1875         Int_t nL3Entries = 0;
1876         Int_t nDipoleEntries = 0;
1877         Int_t nEnvEntries = 0;
1878         Int_t nHallProbesEntries = 0;
1879         nL3Entries = ProcessL3DPs(valueMap, grpObj);
1880         nDipoleEntries = ProcessDipoleDPs(valueMap, grpObj);
1881         nEnvEntries = ProcessEnvDPs(valueMap, grpObj);
1882         nHallProbesEntries = ProcessHPDPs(valueMap, grpObj);
1883         grpObj->SetPolarityConventionLHC();  // after the dipole cables swap we comply with LHC convention
1884         Log(Form("L3Entries = %d, nDipoleEntries =%d, nEnvEntries = %d, nHallProbesEntries = %d", nL3Entries, nDipoleEntries, nEnvEntries, nHallProbesEntries));
1885         entries = nL3Entries + nDipoleEntries + nEnvEntries + nHallProbesEntries;
1886         return entries;
1887
1888 }
1889
1890 //_______________________________________________________________
1891
1892 Int_t AliGRPPreprocessor::ProcessL3DPs(const TMap* valueMap, AliGRPObject* grpObj)
1893 {
1894
1895         // processing DPs
1896         // related to 
1897         // L3 info
1898
1899         Int_t nL3Entries = 0;
1900
1901         TObjArray *array = 0x0;
1902         Int_t indexDP = -1;
1903         Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
1904
1905         AliInfo(Form("==========L3Current==========="));
1906         Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
1907         indexDP = kL3Current;
1908         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1909         if(!array) {
1910                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1911         } 
1912         else {
1913                 if (array->GetEntries() == 0){
1914                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1915                 }
1916                 else {
1917                         Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1918                         if (floatDCS != NULL){
1919                                 grpObj->SetL3Current(floatDCS);
1920                         }
1921                         else{
1922                                 outOfRange = kTRUE;
1923                         }       
1924                         if (floatDCS){
1925                                 delete[] floatDCS;
1926                                 floatDCS = 0x0;
1927                         }
1928                 }
1929                 if (!outOfRange) {
1930                         nL3Entries++;
1931                         ffailedDPs->RemoveAt(indexDP);
1932                 }
1933         }
1934
1935         if (array) array = 0x0;
1936
1937         AliInfo(Form("==========L3Polarity==========="));
1938         indexDP = kL3Polarity;
1939         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1940         if(!array) {
1941                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1942         } 
1943         else {
1944                 if (array->GetEntries() == 0){
1945                         AliError(Form("No entries found in array! setting %s Polarity to invalid...",fgkDCSDataPoints[indexDP]));
1946                 }
1947                 else {
1948                         Bool_t change = kFALSE;
1949                         Char_t charDCS = ProcessBool(array,change);
1950                         if (change == kFALSE){
1951                                 grpObj->SetL3Polarity(charDCS);
1952                                 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetL3Polarity())));
1953                                 ffailedDPs->RemoveAt(indexDP);
1954                                 nL3Entries++;
1955                         }
1956                         else if (isZero){
1957                                 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
1958                                 ffailedDPs->RemoveAt(indexDP);
1959                                 nL3Entries++;
1960                         }
1961                         else {
1962                                 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]));
1963                         }
1964                 }
1965         }
1966
1967         return nL3Entries;
1968
1969 }
1970 //_______________________________________________________________
1971
1972 Int_t AliGRPPreprocessor::ProcessDipoleDPs(const TMap* valueMap, AliGRPObject* grpObj)
1973 {
1974         // processing DPs
1975         // related to 
1976         // the Dipole info
1977
1978         Int_t nDipoleEntries = 0;
1979         TObjArray *array = 0x0;
1980         Int_t indexDP = -1;
1981         Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
1982
1983         AliInfo(Form("==========DipoleCurrent==========="));
1984         Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
1985         indexDP = kDipoleCurrent;
1986         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1987         if(!array) {
1988                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1989         } 
1990         else {
1991                 if (array->GetEntries() == 0){
1992                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1993                 }
1994                 else {
1995                         Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1996                         if (floatDCS != NULL){
1997                                 grpObj->SetDipoleCurrent(floatDCS);
1998                         } 
1999                         else{
2000                                 outOfRange=kTRUE;
2001                         }
2002                         if (floatDCS){
2003                                 delete[] floatDCS;
2004                                 floatDCS = 0x0;
2005                         }
2006                 }
2007                 if (!outOfRange) {
2008                         nDipoleEntries++;
2009                         ffailedDPs->RemoveAt(indexDP);
2010                 }
2011         }
2012
2013         if (array) array = 0x0;
2014
2015         AliInfo(Form("==========DipolePolarity==========="));
2016         indexDP = kDipolePolarity;
2017         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
2018         if(!array) {
2019                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
2020         } 
2021         else {
2022                 if (array->GetEntries() == 0){
2023                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
2024                 }
2025                 else {
2026                         Bool_t change = kFALSE;
2027                         Char_t charDCS = ProcessBool(array,change);
2028                         if (!change){
2029                                 grpObj->SetDipolePolarity(charDCS);
2030                                 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetDipolePolarity())));
2031                                 ffailedDPs->RemoveAt(indexDP);
2032                                 nDipoleEntries++;
2033                         }
2034                         else if (isZero){
2035                                 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
2036                                 ffailedDPs->RemoveAt(indexDP);
2037                                 nDipoleEntries++;
2038                         }
2039                         else{
2040                                 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]));
2041                         }
2042                 }
2043         }
2044
2045         return nDipoleEntries;
2046
2047 }
2048 //_______________________________________________________________
2049
2050 Int_t AliGRPPreprocessor::ProcessEnvDPs(TMap* valueMap, AliGRPObject* grpObj)
2051 {
2052         // processing DPs
2053         // related to 
2054         // evironment conditions (temperature, pressure) info
2055
2056         Int_t nEnvEntries = 0;
2057         TObjArray *array = 0x0;
2058         Int_t indexDP = -1;
2059
2060         AliInfo(Form("==========CavernTemperature==========="));
2061         Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
2062         indexDP = kCavernTemperature;
2063         array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
2064         if(!array) {
2065                 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
2066         } 
2067         else {
2068                 if (array->GetEntries() == 0){
2069                         AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
2070                 }
2071                 else {
2072                         Float_t *floatDCS = ProcessFloatAll(array);
2073                         if (floatDCS != NULL){
2074                                 grpObj->SetCavernTemperature(floatDCS);
2075                         }
2076                         else{
2077                                 outOfRange = kTRUE;
2078                         }
2079                         if (floatDCS){
2080                                 delete[] floatDCS;
2081                                 floatDCS = 0x0;
2082                         }
2083                 }
2084                 if (!outOfRange) {
2085                         ffailedDPs->RemoveAt(indexDP);
2086                         nEnvEntries++;
2087                 }
2088         }
2089
2090         if (array) array = 0x0;
2091
2092         AliInfo(Form("========== AtmosPressures (Cavern + Surface + Cavern2) ==========="));
2093         AliDCSSensorArray *dcsSensorArray = GetPressureMap(valueMap);
2094         //dcsSensorArray->Print();
2095         if( fPressure->NumFits()<kNumSensors ) {
2096                 Log(Form("Check the pressure sensor values! Not all the %d pressure sensors have been fit",kNumSensors));
2097         } 
2098         Log(Form("Number of fits performed = %d",fPressure->NumFits()));
2099
2100         AliInfo(Form("==========CavernAtmosPressure==========="));
2101         indexDP = kCavernAtmosPressure;
2102         AliDCSSensor* sensorCavernP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
2103         TGraph* graph = sensorCavernP2->GetGraph();
2104         AliDebug(3,Form("index = %d",indexDP));
2105         AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
2106         AliDebug(2,Form("graph = %p",graph));
2107         AliDebug(3,Form("sensorCavernP2 = %p", sensorCavernP2));
2108         if(sensorCavernP2->GetFit() || graph) {
2109                 if (sensorCavernP2->GetFit()){
2110                         Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
2111                 }
2112                 else {
2113                         Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
2114                 }
2115                 grpObj->SetCavernAtmosPressure(sensorCavernP2);
2116                 ffailedDPs->RemoveAt(indexDP);
2117                 nEnvEntries++;
2118         } 
2119         //if (sensorP2) delete sensorP2;
2120         else {
2121                 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] ));
2122         }
2123         
2124         AliInfo(Form("==========SurfaceAtmosPressure==========="));
2125         indexDP = kSurfaceAtmosPressure;
2126         AliDCSSensor* sensorP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
2127         graph = sensorP2->GetGraph();
2128         AliDebug(3,Form("index = %d",indexDP));
2129         AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
2130         AliDebug(2,Form("graph = %p",graph));   
2131         AliDebug(3,Form("sensorP2 = %p", sensorP2));
2132         if(sensorP2->GetFit() || graph) {
2133                 if (sensorP2->GetFit()){
2134                         Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
2135                 }
2136                 else {
2137                         Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
2138                 }
2139                 grpObj->SetSurfaceAtmosPressure(sensorP2);
2140                 ffailedDPs->RemoveAt(indexDP);
2141                 nEnvEntries++;
2142         } 
2143         //if (sensorP2) delete sensorP2;
2144         else {
2145                 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] ));
2146         }
2147
2148         AliInfo(Form("==========CavernAtmosPressure2==========="));
2149         indexDP = kCavernAtmosPressure2;
2150         AliDCSSensor* sensorCavernP22 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
2151         graph = sensorCavernP22->GetGraph();
2152         AliDebug(3,Form("index = %d",indexDP));
2153         AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
2154         AliDebug(2,Form("graph = %p",graph));   
2155         AliDebug(3,Form("sensorCavernP2_2 = %p", sensorCavernP22));
2156         if(sensorCavernP22->GetFit() || graph) {
2157                 if (sensorCavernP22->GetFit()){
2158                         Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
2159                 }
2160                 else {
2161                         Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
2162                 }
2163                 grpObj->SetCavernAtmosPressure2(sensorCavernP22);
2164                 ffailedDPs->RemoveAt(indexDP);
2165                 nEnvEntries++;
2166         } 
2167         //if (sensorP2) delete sensorP2;
2168         else {
2169                 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] ));
2170         }
2171         
2172         
2173         return nEnvEntries;
2174 }
2175 //_______________________________________________________________
2176
2177 Int_t AliGRPPreprocessor::ProcessHPDPs(const TMap* valueMap, AliGRPObject* grpObj)
2178 {
2179         // processing DPs
2180         // related to 
2181         // Hall Probes info
2182
2183         Int_t nHPEntries = 0;
2184         TObjArray *array = 0x0;
2185         Int_t indexDP = -1;
2186         Bool_t outOfRange; // flag to monitor if any value collected by DCS is out of range
2187
2188         if (fgknDCSDPHallProbes != AliGRPObject::GetNumberOfHP()){
2189                 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()));
2190         }
2191         for (indexDP = 0; indexDP < AliGRPObject::GetNumberOfHP(); indexDP++){
2192                 outOfRange = kFALSE; // resetting outOfRange flag at each HP
2193                 AliInfo(Form("==========%s===========",AliGRPObject::GetHPDP(indexDP)));
2194                 array = (TObjArray *)valueMap->GetValue(AliGRPObject::GetHPDP(indexDP));
2195                 if(!array) {
2196                         Log(Form("%s not found in the map!!!",AliGRPObject::GetHPDP(indexDP)));
2197                 } 
2198                 else {
2199                         if (array->GetEntries() == 0){
2200                                 AliError(Form("No entries found in array! setting %s to invalid...",AliGRPObject::GetHPDP(indexDP)));
2201                         }
2202                         else {
2203                                 Float_t *floatDCS = ProcessFloatAll(array);
2204                                 if (floatDCS != NULL){
2205                                         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])); 
2206                                         grpObj->SetHallProbes((AliGRPObject::DP_HallProbes)indexDP,floatDCS);
2207                                         for (Int_t kk = 0 ; kk< 5; kk++){
2208                                                 AliDebug(2,Form("HallProbe[%d][%d]=%f",indexDP,kk,grpObj->GetHallProbes((AliGRPObject::DP_HallProbes)indexDP,(AliGRPObject::Stats)kk)));
2209                                         }
2210                                 }
2211                                 else{
2212                                         outOfRange = kTRUE;
2213                                 }
2214                                 if (floatDCS){
2215                                         delete[] floatDCS;
2216                                         floatDCS = 0x0;
2217                                 }
2218                         }
2219                         if (!outOfRange) {
2220                                 ffailedDPs->RemoveAt(indexDP + fgkDCSDPHallTopShift);  // 7 = shift in the complete list of DPs to get to the Hall Probes
2221                                 nHPEntries++;
2222                         }
2223                 }
2224         }
2225                 
2226         Log(Form("Hall Probes = %d ", nHPEntries));
2227         return nHPEntries;
2228 }
2229
2230 //_________________________________________________________________________
2231
2232 AliSplineFit* AliGRPPreprocessor::GetSplineFit(const TObjArray *array, const TString& stringID){
2233
2234
2235         // 
2236         // returning Spline Fit 
2237         // 
2238
2239         Int_t entriesarray = array->GetEntries();
2240         Float_t* value = new Float_t[entriesarray];
2241         Float_t* time = new Float_t[entriesarray];
2242         AliDCSValue* v = 0x0;
2243         for (Int_t iarray = 0; iarray < entriesarray; iarray++){
2244                 v = (AliDCSValue*)array->At(iarray);
2245                 value[iarray] = v->GetFloat();
2246                 time[iarray] = v->GetTimeStamp();
2247                 AliDebug(2,Form("iarray = %d, value = %f, time = %f",iarray,value[iarray],time[iarray]));
2248         }
2249         TGraph* gr = new TGraph(entriesarray,value,time);
2250         if (!gr ) {
2251                 AliWarning(Form("%s: no input graph to compute SplineFit",stringID.Data()));
2252                 return NULL;
2253         }
2254         AliSplineFit *fit = new AliSplineFit();
2255         fit->SetMinPoints(10);
2256         fit->InitKnots(gr,10,10,0.0);
2257         fit->SplineFit(2);
2258         fit->Cleanup();
2259         return fit;
2260 }
2261
2262 //_________________________________________________________________________
2263
2264 TString AliGRPPreprocessor::ProcessChar(const TObjArray *array)
2265 {
2266
2267         // 
2268         // processing char
2269         //
2270
2271         TString aDCSString="";
2272         
2273         AliDCSValue *v = 0x0;
2274         for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
2275                 v = (AliDCSValue *)array->At(iCount);
2276                 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
2277                         AliError(Form("DCS values for the parameter outside the queried interval"));
2278                         continue;
2279                 }
2280                 if (iCount > 0) {
2281                         if (aDCSString != v->GetChar())
2282                         AliError(Form("DCS values for the parameter changed from %s to %c within the queried interval", aDCSString.Data(), (Char_t)v->GetChar()));
2283                 }
2284                 aDCSString = (TString)v->GetChar();  // keeping always last value in the array
2285         }
2286         return aDCSString;
2287 }
2288
2289 //__________________________________________________________________________________________________________________
2290
2291 Float_t* AliGRPPreprocessor::ProcessFloatAll(const TObjArray* array)
2292 {
2293         // 
2294         // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median 
2295         //
2296         // parameters[0] = mean
2297         // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
2298         // parameters[2] = median
2299         // parameters[3] = standard deviation wrt mean
2300         // parameters[4] = standard deviation wrt median
2301         //
2302
2303         TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2304         TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2305         if (timeStartString.IsNull() || timeStartString.IsNull()){
2306                 if (timeStartString.IsNull()){ 
2307                         AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2308                 }
2309                 else if (timeStartString.IsNull()){
2310                         AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2311                 }
2312                 fdaqStartEndTimeOk = kFALSE;
2313                 return 0;
2314         }  
2315
2316         Int_t timeStart = (Int_t)(timeStartString.Atoi());
2317         Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2318         Float_t* parameters = new Float_t[5];
2319         Int_t iCounts = 0;
2320         Int_t iCountsRun = 0;
2321         Int_t nCounts = array->GetEntries();
2322         Float_t valueBeforeSOR = 0;
2323         Float_t valueAfterEOR = 0;
2324         Int_t timestampBeforeSOR = -1;
2325         Int_t timestampAfterEOR = -1;
2326         Int_t ientrySOR = -1;
2327         Int_t ientryEOR = -1;
2328         Float_t* arrayValues = 0x0; 
2329         Double_t* arrayWeights = 0x0; 
2330         Bool_t truncMeanFlag = kTRUE;  // flag to indicate whether Truncated Mean should be calculated or not
2331         Bool_t sdFlag = kTRUE;  // flag to indicate whether SD (wrt Mean/Median) should be calculated or not
2332
2333         for(Int_t i = 0; i < nCounts; i++) {
2334                 AliDCSValue *v = (AliDCSValue *)array->At(i);
2335                 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
2336                         AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
2337                         if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
2338                         if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
2339                         delete [] parameters;
2340                         return NULL;
2341                 }
2342                 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2343                         AliDebug(2,Form("%d-th entry = %f at timestamp %i",i,v->GetFloat(),v->GetTimeStamp()));
2344                         iCounts += 1;
2345                         // look for the last value before SOR and the first value before EOR
2346                         if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
2347                                 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
2348                                 AliDebug(2,Form("timestamp of last value before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
2349                                 valueBeforeSOR = v->GetFloat();
2350                         }
2351                         else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
2352                                 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
2353                                 valueAfterEOR = v->GetFloat();
2354                                 AliDebug(2,Form("timestamp of first value after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
2355                         }
2356                         // check if there are DPs between DAQ_time_start and DAQ_time_end
2357                         if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
2358                                 if (ientrySOR == -1) ientrySOR = i;  // first entry after SOR
2359                                 if (ientryEOR < i) ientryEOR = i;  // last entry before EOR
2360                                 AliDebug(2,Form("entry between SOR and EOR"));
2361                                 iCountsRun += 1;
2362                         }
2363                 }
2364                 else {
2365                         AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
2366                 }
2367         }
2368
2369         if (timestampBeforeSOR == -1){
2370                 AliWarning("No value found before SOR");
2371         }
2372         if (timestampAfterEOR == -1){
2373                 AliWarning("No value found after EOR");
2374         }
2375
2376         AliDebug(2,Form("Number of valid entries (within DCS query interval) = %i, from a total amount of %i entries",iCounts,nCounts));
2377         AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2378         AliDebug(2,Form("First value after DAQ_time_end (EOR)   = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2379         AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2380         AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2381         AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2382
2383         Int_t nentriesUsed = 0;
2384         if (iCountsRun > 1){
2385                 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2386                 AliDebug(2,"Calculating (weighted) Mean and Median");
2387                 arrayValues = new Float_t[iCountsRun]; 
2388                 arrayWeights = new Double_t[iCountsRun]; 
2389                 nentriesUsed = iCountsRun;
2390                 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2391                         AliDCSValue *v = (AliDCSValue *)array->At(i);
2392                         Int_t timestamp2 = 0;
2393                         if (i < ientryEOR){
2394                                 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2395                                 timestamp2 = (Int_t)v1->GetTimeStamp();
2396                         }
2397                         else {
2398                                 timestamp2 = timeEnd+1;
2399                         }
2400                         arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2401                         arrayValues[i-ientrySOR] = v->GetFloat();
2402                 }
2403                 parameters[0] = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2404                 parameters[2] = TMath::Median(iCountsRun,arrayValues,arrayWeights);
2405         }
2406         else if (iCountsRun == 1){
2407                 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2408                 nentriesUsed = 2;
2409                 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2410                         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.");
2411                         arrayValues = new Float_t[2];
2412                         arrayWeights = new Double_t[2];
2413                         arrayValues[0] = valueBeforeSOR;
2414                         arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2415                         arrayValues[1] = v->GetFloat();
2416                         arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2417                         AliDebug(2, Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0])); 
2418                         AliDebug(2, Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1])); 
2419                         parameters[0] = TMath::Mean(2,arrayValues,arrayWeights);
2420                         parameters[2] = TMath::Median(2,arrayValues,arrayWeights);
2421                         truncMeanFlag = kFALSE;
2422                 }
2423                 else{
2424                         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");
2425                         parameters[0] = AliGRPObject::GetInvalidFloat();
2426                         parameters[1] = AliGRPObject::GetInvalidFloat();
2427                         parameters[2] = AliGRPObject::GetInvalidFloat();
2428                         parameters[3] = AliGRPObject::GetInvalidFloat();
2429                         parameters[4] = AliGRPObject::GetInvalidFloat();
2430                         return parameters;
2431                 }
2432         }
2433         else { // iCountsRun == 0, using only the point immediately before SOR
2434                 if (timestampBeforeSOR == -1){
2435                         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");
2436                         parameters[0] = AliGRPObject::GetInvalidFloat();
2437                         parameters[1] = AliGRPObject::GetInvalidFloat();
2438                         parameters[2] = AliGRPObject::GetInvalidFloat();
2439                         parameters[3] = AliGRPObject::GetInvalidFloat();
2440                         parameters[4] = AliGRPObject::GetInvalidFloat();
2441                         return parameters;
2442                 }
2443                 else {
2444                         AliWarning("Using only last entry before SOR. Truncated mean and Standard deviations (wrt mean/median) won't be calculated.");
2445                         AliDebug(2,Form("value = %f",valueBeforeSOR)); 
2446                         parameters[0] = valueBeforeSOR;
2447                         parameters[2] = valueBeforeSOR;
2448                         truncMeanFlag = kFALSE;
2449                         sdFlag = kFALSE;
2450                 }
2451         }
2452
2453         AliDebug(2, Form("nentriesUsed = %d", nentriesUsed));
2454         Float_t temp = 0;
2455         Float_t temp1 = 0;
2456         Float_t sumweights = 0; 
2457         Int_t entriesTruncMean = 0;
2458         Float_t* arrayValuesTruncMean = new Float_t[nentriesUsed]; 
2459         Double_t* arrayWeightsTruncMean = new Double_t[nentriesUsed]; 
2460
2461         // calculating SD wrt Mean and Median
2462         AliDebug(2,"Calculating SD wrt Mean and SD wrt Median");
2463         if (sdFlag){
2464                 for (Int_t i =0; i< nentriesUsed; i++){
2465                         AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
2466                         temp += (arrayValues[i]-parameters[2])*(arrayValues[i]-parameters[2]);
2467                         temp1 += arrayWeights[i]*(arrayValues[i]-parameters[0])*(arrayValues[i]-parameters[0]);
2468                         sumweights += arrayWeights[i];
2469                 }
2470                 // setting SD wrt Mean 
2471                 if (sumweights != 0 ){
2472                         parameters[3] = TMath::Sqrt(temp1/sumweights);
2473                 }
2474                 else {
2475                         AliError("Sum of weights to calculate Standard Deviation (wrt mean) <= 0, setting the SD to invalid");
2476                         parameters[3] = AliGRPObject::GetInvalidFloat();
2477                 }
2478                 // setting SD wrt Median
2479                 if (nentriesUsed != 0){
2480                         parameters[4] = TMath::Sqrt(temp/nentriesUsed);
2481                 }
2482                 else{
2483                         AliError("Number of entries used to calculate Standard Deviation (wrt median) <= 0, setting the SD to invalid");
2484                         parameters[4] = AliGRPObject::GetInvalidFloat();
2485                 }
2486         }
2487         else {
2488                 parameters[3] = AliGRPObject::GetInvalidFloat();
2489                 parameters[4] = AliGRPObject::GetInvalidFloat();
2490         }               
2491
2492         // calculating truncated mean (this comes afterwards since you need the SD wrt Mean)
2493         if (truncMeanFlag){
2494                 AliDebug(2,"Calculating Truncated Mean");
2495                 for (Int_t i =0; i< nentriesUsed; i++){
2496                         AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
2497                         if ((arrayValues[i]<=parameters[0]+3*parameters[3]) && (arrayValues[i]>=parameters[0]-3*parameters[3])){
2498                                 arrayValuesTruncMean[entriesTruncMean]=arrayValues[i];
2499                                 arrayWeightsTruncMean[entriesTruncMean]=arrayWeights[i];
2500                                 AliDebug(2,Form("For Truncated Mean: Entry %d: value = %f, weight = %f",entriesTruncMean,arrayValuesTruncMean[entriesTruncMean],arrayWeightsTruncMean[entriesTruncMean]));
2501                                 entriesTruncMean++;                     
2502                         }
2503                         else{
2504                                 AliDebug(2,"Discarding entry");
2505                         }
2506                 }
2507                 // setting truncated mean 
2508                 if (entriesTruncMean >1){
2509                         AliDebug(2,Form("%d entries used for truncated mean",entriesTruncMean));
2510                         parameters[1] = TMath::Mean(entriesTruncMean,arrayValuesTruncMean,arrayWeightsTruncMean);
2511                 }
2512                 else{   
2513                         AliDebug(2,Form("Too few entries (%d) to calculate truncated mean",entriesTruncMean));
2514                         parameters[1] = AliGRPObject::GetInvalidFloat();
2515                 }
2516         }
2517         else{
2518                         parameters[1] = AliGRPObject::GetInvalidFloat();
2519         }
2520
2521         if (arrayValues){
2522                 delete [] arrayValues;
2523         } 
2524         if (arrayWeights){
2525                 delete [] arrayWeights;
2526        &nb