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