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