1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
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 //-------------------------------------------------------------------------
29 #include <TObjString.h>
30 #include <TObjArray.h>
37 #include "AliGRPPreprocessor.h"
38 #include "AliGRPObject.h"
39 #include "AliDCSSensor.h"
40 #include "AliSplineFit.h"
41 #include "AliDCSSensorArray.h"
42 #include "AliRawEventHeaderVersions.h"
44 #include "AliTriggerConfiguration.h"
45 #include "AliTriggerRunScalers.h"
46 #include "AliTriggerInput.h"
48 #include "AliCDBMetaData.h"
49 #include "AliESDVertex.h"
50 #include "AliLHCReader.h"
51 #include "AliLHCData.h"
52 #include "AliDCSArray.h"
54 #include "AliLTUConfig.h"
58 class AliShuttleInterface;
60 // needed for ReceivePromptRecoParameters
62 #include <TSQLServer.h>
63 #include <TSQLResult.h>
65 #include <AliCDBManager.h>
66 #include <AliCDBMetaData.h>
68 #include <AliTriggerConfiguration.h>
69 #include <AliCTPTimeParams.h>
70 #include <AliLHCClockPhase.h>
72 const Double_t kFitFraction = -1.; // Fraction of DCS sensor fits required
74 ClassImp(AliGRPPreprocessor)
76 //_______________________________________________________________
78 const Int_t AliGRPPreprocessor::fgknDAQLbPar = 6; // num parameters in the logbook used to fill the GRP object
79 const Int_t AliGRPPreprocessor::fgknDCSDP = 48; // number of dcs dps
80 const Int_t AliGRPPreprocessor::fgknDCSDPHallProbes = 40; // number of dcs dps
81 const Int_t AliGRPPreprocessor::fgknLHCDP = 6; // number of dcs dps from LHC data
82 const Int_t AliGRPPreprocessor::fgkDCSDPHallTopShift = 4; // shift from the top to get tp the Hall Probes names in the list of DCS DPs
83 const Int_t AliGRPPreprocessor::fgkDCSDPNonWorking = 5; // number of non working DCS DPs
84 const char* AliGRPPreprocessor::fgkDCSDataPoints[AliGRPPreprocessor::fgknDCSDP] = {
92 "L3_BSF17_Temperature",
96 "L3_BSF4_Temperature",
100 "L3_BKF17_Temperature",
104 "L3_BKF4_Temperature",
108 "L3_BSF13_Temperature",
112 "L3_BSF8_Temperature",
116 "L3_BKF13_Temperature",
120 "L3_BKF8_Temperature",
124 "Dipole_Inside_Temperature",
128 "Dipole_Outside_Temperature",
130 "CavernAtmosPressure",
131 "SurfaceAtmosPressure",
132 "CavernAtmosPressure2"
135 const char* AliGRPPreprocessor::fgkDCSDataPointsHallProbes[AliGRPPreprocessor::fgknDCSDPHallProbes] = {
139 "L3_BSF17_Temperature",
143 "L3_BSF4_Temperature",
147 "L3_BKF17_Temperature",
151 "L3_BKF4_Temperature",
155 "L3_BSF13_Temperature",
159 "L3_BSF8_Temperature",
163 "L3_BKF13_Temperature",
167 "L3_BKF8_Temperature",
171 "Dipole_Inside_Temperature",
175 "Dipole_Outside_Temperature"
178 const Short_t kSensors = 45; // start index position of sensor in DCS DPs
179 const Short_t kNumSensors = 3; // Number of sensors in DCS DPs (CavernAtmosPressure, SurfaceAtmosPressure, CavernAtmosPressure2)
182 const char* AliGRPPreprocessor::fgkLHCDataPoints[AliGRPPreprocessor::fgknLHCDP] = {
186 "LHC_Beams_Particle_Type",
187 "BPTX_Phase_Shift_B1",
188 "BPTX_Phase_Shift_B2"
191 const char* kppError[] = {
193 "(DAQ logbook ERROR)",
195 "(Trigger Scalers not found in DCS FXS - ERROR)",
196 "(DCS data points ERROR)",
197 "(Trigger Configuration ERROR)",
198 "(DAQ logbook ERROR determining partition of the run)",
199 "(CTP timing ERROR)",
200 "(SPD Mean Vertex ERROR)",
201 "(DCS FXS Error for LHC Data)",
203 "(LHC Clock Phase Error (from LHC Data))",
204 "(LTU Configuration Error)"
207 //_______________________________________________________________
209 AliGRPPreprocessor::AliGRPPreprocessor(AliShuttleInterface* shuttle):
210 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))
212 // constructor - shuttle must be instantiated!
214 AddRunType("COSMIC");
216 AddRunType("PHYSICS");
217 AddRunType("CALIBRATION_BC");
218 AddRunType("CALIBRATION_CENTRAL");
219 AddRunType("CALIBRATION_EMD");
220 AddRunType("CALIBRATION_MB");
221 AddRunType("CALIBRATION_SEMICENTRAL");
222 AddRunType("CALIBRATION");
223 AddRunType("PEDESTAL");
224 AddRunType("STANDALONE");
227 AddRunType("PULSER");
228 AddRunType("STANDALONE_PULSER");
229 AddRunType("STANDALONE_BC");
232 fminFloat = -FLT_MAX;
233 fmaxDouble = DBL_MAX;
234 fminDouble = -DBL_MAX;
240 AliInfo(Form("Max allowed float = %6.5e",fmaxFloat));
241 AliInfo(Form("Min allowed float = %6.5e",fminFloat));
242 AliInfo(Form("Max allowed double = %6.5e",fmaxDouble));
243 AliInfo(Form("Min allowed double = %6.5e",fminDouble));
244 AliInfo(Form("Max allowed integer = %d",fmaxInt));
245 AliInfo(Form("Min allowed integer = %d",fminInt));
246 AliInfo(Form("Max allowed unsigned integer = %u",(Int_t)fmaxUInt));
247 AliInfo(Form("Min allowed unsigned integer = %u",(Int_t)fminUInt));
249 ffailedDPs->SetOwner(kTRUE);
252 //_______________________________________________________________
254 AliGRPPreprocessor::~AliGRPPreprocessor()
263 //_______________________________________________________________
265 void AliGRPPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
267 // Initialize preprocessor
269 AliPreprocessor::Initialize(run, startTime, endTime);
271 AliInfo("Initialization of the GRP preprocessor.");
272 AliInfo(Form("Start Time DCS = %d",GetStartTimeDCSQuery()));
273 AliInfo(Form("End Time DCS = %d",GetEndTimeDCSQuery()));
274 TClonesArray * array = new TClonesArray("AliDCSSensor",kNumSensors);
275 for(Int_t j = 0; j < kNumSensors; j++) {
276 AliDCSSensor * sens = new ((*array)[j])AliDCSSensor;
277 sens->SetStringID(fgkDCSDataPoints[j+kSensors]);
279 AliInfo(Form("Pressure Entries: %d",array->GetEntries()));
281 fPressure = new AliDCSSensorArray(GetStartTimeDCSQuery(), GetEndTimeDCSQuery(), array);
283 for (Int_t iDP=0; iDP < fgknDCSDP; iDP++){
284 TObjString* dp = new TObjString(fgkDCSDataPoints[iDP]);
285 ffailedDPs->AddAt(dp,iDP);
290 //_______________________________________________________________
292 UInt_t AliGRPPreprocessor::Process(TMap* valueMap)
294 // process data retrieved by the Shuttle
296 // retrieving "partition" and "detector" fields from DAQ logbook to
297 // determine the partition in which the run was taken
298 // the partition is used to decide how to react in case of errors for CTP
300 TString partition = (TString)GetRunParameter("partition");
301 TString detector = (TString)GetRunParameter("detector");
303 AliGRPObject *grpobj = new AliGRPObject(); // object to store data
304 grpobj->SetBeamEnergyIsSqrtSHalfGeV(); // new format
306 //=================//
308 //=================//
310 Log("*************** Processing DAQ logbook");
314 Int_t iDaqLB = ProcessDaqLB(grpobj);
315 TString runType = (TString)GetRunType();
316 TString beamType = (TString)GetRunParameter("beamType");
317 if(iDaqLB == fgknDAQLbPar) {
318 Log(Form("DAQ Logbook, successful! Retrieved %d/%d entries",iDaqLB,fgknDAQLbPar));
320 Log(Form("DAQ Logbook, could not get all expected entries!!! Retrieved only %d/%d entries",iDaqLB,fgknDAQLbPar));
324 //=================//
326 //=================//
328 Log("*************** Processing DAQ FXS");
330 UInt_t iDaqFxs = ProcessDaqFxs();
332 Log(Form("DAQ FXS, successful!"));
334 Log(Form("DAQ FXS, could not store run raw tag file!!!"));
338 //=================//
340 //=================//
342 Log("*************** Processing DCS FXS");
344 UInt_t iDcsFxs = ProcessDcsFxs(partition, detector);
346 Log(Form("DCS FXS, successful!"));
347 } else if (iDcsFxs ==1) {
348 Log(Form("DCS FXS, Could not store CTP scalers!!!"));
351 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without CTP scalers...",partition.Data(),detector.Data()));
355 //=================//
356 // DCS data points //
357 //=================//
359 Log("*************** Processing DCS DPs");
361 Log(Form("Starting DCS Query at %d and finishing at %d",GetStartTimeDCSQuery(),GetEndTimeDCSQuery()));
362 Int_t entries = ProcessDcsDPs( valueMap, grpobj );
363 Log(Form("entries found = %d (should be %d)",entries, fgknDCSDP-fgkDCSDPNonWorking));
364 if (fdaqStartEndTimeOk){
365 if( entries < fgknDCSDP - fgkDCSDPNonWorking ) { // L3_BSF4_H3, L3_BSF17_H1, L3_BSF17_H2, L3_BSF17_H3, L3_BSF17_Temperature are not working yet...
366 Log(Form("Possible problem with the DCS data points!!! Only %d/%d entries found - Please read further for more details",entries,fgknDCSDP-fgkDCSDPNonWorking));
367 Log(Form("The DPs giving problems were:"));
368 for (Int_t iDP = 0; iDP < fgknDCSDP; iDP++){
369 TObjString *dpString = (TObjString*)ffailedDPs->At(iDP);
371 TString name = dpString->String();
372 if (name != "L3_BSF4_H3" && name != "L3_BSF17_H1" && name != "L3_BSF17_H2" && name != "L3_BSF17_H3" && name != "L3_BSF17_Temperature" ){
373 Log(Form("******** %s ******** not present, but foreseen --> causing an ERROR",name.Data()));
376 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()));
382 else Log(Form("DCS data points, successful!"));
384 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"));
386 //=======================//
387 // Trigger Configuration //
388 //=======================//
390 Log("*************** Processing Trigger Configuration");
392 const char * triggerConf = GetTriggerConfiguration();
394 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
395 Log("STANDALONE partition for current run, using Trigger Configuration dummy value");
396 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyConfig");
398 Log(Form("No dummy CTP configuration entry found, going into error..."));
402 AliTriggerConfiguration *runcfg = (AliTriggerConfiguration*)cdbEntry->GetObject();
404 Log(Form("dummy CTP config not found in OCDB entry, going into error..."));
408 TString titleCTPcfg = Form("CTP cfg for run %i from Dummy entry in OCDB",fRun);
409 runcfg->SetTitle(titleCTPcfg);
410 AliCDBMetaData metaData;
411 metaData.SetResponsible("Roman Lietava");
412 metaData.SetComment("CTP run configuration from dummy entry in OCDB");
413 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
414 Log("Unable to store the dummy CTP run configuration object to OCDB!");
421 else if (!partition.IsNull() && detector.IsNull()){ // global partition
422 Log("GLOBAL partition for current run, using Trigger Configuration from DAQ Logbook");
423 if (triggerConf!= NULL) {
424 Log("Found trigger configuration in DAQ logbook");
425 AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConf);
427 Log("Bad CTP run configuration file from DAQ logbook! The corresponding CDB entry will not be filled!");
431 TString titleCTPcfg = Form("CTP cfg for run %i from DAQ",fRun);
432 runcfg->SetTitle(titleCTPcfg);
433 AliCDBMetaData metaData;
434 metaData.SetBeamPeriod(0);
435 metaData.SetResponsible("Roman Lietava");
436 metaData.SetComment("CTP run configuration from DAQ logbook");
437 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
438 Log("Unable to store the CTP run configuration object to OCDB!");
445 Log("Trigger configuration NULL in DAQ logbook");
451 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger configuration...",partition.Data(),detector.Data()));
455 //===========================//
456 // Trigger Timing Parameters //
457 //===========================//
459 Log("*************** Processing Trigger Time Params");
461 const char * triggerCTPtiming = GetCTPTimeParams();
463 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
464 Log("STANDALONE partition for current run, using CTP timing params dummy value");
465 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyCTPtime");
467 Log(Form("No dummy CTP timing parameters entry found, going into error..."));
471 AliCTPTimeParams *runCTPtiming = (AliCTPTimeParams*)cdbEntry->GetObject();
473 Log(Form("dummy CTP timing parameters not found in OCDB entry, going into error..."));
477 TString titleCTPtiming = Form("CTP timing params for run %i from Dummy entry in OCDB",fRun);
478 runCTPtiming->SetTitle(titleCTPtiming);
479 AliCDBMetaData metadata;
480 metadata.SetResponsible("Roman Lietava");
481 metadata.SetComment("CTP run timing parameters from dummy entry in OCDB");
482 if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
483 Log("Unable to store the dummy CTP timing params object to OCDB!");
490 else if (!partition.IsNull() && detector.IsNull()){ // global partition
491 Log("GLOBAL partition for current run, using Trigger Timing Parameters from DAQ Logbook");
492 if (triggerCTPtiming!= NULL) {
493 Log("Found trigger timing params in DAQ logbook");
494 AliDebug(2,Form("%s",triggerCTPtiming));
495 AliCTPTimeParams *runCTPtiming = AliCTPTimeParams::LoadCTPTimeParamsFromString(triggerCTPtiming);
497 Log("Bad CTP trigger timing params file from DAQ logbook! The corresponding CDB entry will not be filled!");
501 TString titleCTPtiming = Form("CTP timing params for run %i from DAQ",fRun);
502 runCTPtiming->SetTitle(titleCTPtiming);
503 AliCDBMetaData metadata;
504 metadata.SetBeamPeriod(0);
505 metadata.SetResponsible("Roman Lietava");
506 metadata.SetComment("CTP timing params from DAQ logbook");
507 if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
508 Log("Unable to store the CTP timing params object to OCDB!");
515 Log("Trigger timing params NULL in DAQ logbook");
521 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger timing parameters...",partition.Data(),detector.Data()));
525 //===========================//
526 // LTU Configuration //
527 //===========================//
529 Log("*************** Processing LTU Configuration");
531 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
532 Log("STANDALONE partition for current run, using LTU configuration dummy value");
533 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyLTUConfig");
535 Log(Form("No dummy LTU Config entry found, going into error..."));
539 TObjArray *ltuConfig = (TObjArray*)cdbEntry->GetObject();
541 Log(Form("dummy LTU Config not found in OCDB entry, going into error..."));
545 AliCDBMetaData metadata;
546 metadata.SetResponsible("Roman Lietava");
547 metadata.SetComment("LTU Config from dummy entry in OCDB");
548 if (!Store("CTP","LTUConfig", ltuConfig, &metadata, 0, 0)) {
549 Log("Unable to store the dummy LTU Config object to OCDB!");
556 else if (!partition.IsNull() && detector.IsNull()){ // global partition
558 Log("GLOBAL partition for current run, getting LTU Config from DAQ Logbook (logbook_detectors table)");
559 UInt_t detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
560 Printf ("detectormask = %d",detectorMask);
561 TObjArray * ltuarray = new TObjArray();
562 ltuarray->SetOwner(1);
563 Bool_t isLTUok = kTRUE;
564 for(Int_t i = 0; i<AliDAQ::kNDetectors-2; i++){
565 if ((detectorMask >> i) & 0x1) {
566 TString det = AliDAQ::OfflineModuleName(i);
567 TString detCTPName = AliTriggerInput::fgkCTPDetectorName[i];
568 if (detCTPName == "CTP") {
569 detCTPName="TRG"; // converting according to what is found in DAQ logbook_detectors
570 Printf("Processing CTP (CTP Detector name %s) --> SKIPPING, CTP does not have any LTU!!!!!!",detCTPName.Data());
573 Printf("Processing detector %s (CTP Detector name %s)",det.Data(),detCTPName.Data());
574 TString* ltu = GetLTUConfig(detCTPName.Data());
576 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()));
582 Float_t ltuFineDelay1 = ltu[0].Atof();
583 Float_t ltuFineDelay2 = ltu[1].Atof();
584 Float_t ltuBCDelayAdd = ltu[2].Atof();
585 const char* name = AliDAQ::DetectorName(i);
586 AliLTUConfig* ltuConfig = new AliLTUConfig((UChar_t)AliDAQ::DetectorID(name),ltuFineDelay1,ltuFineDelay2,ltuBCDelayAdd);
587 ltuarray->AddAtAndExpand(ltuConfig,i);
592 AliCDBMetaData metadata;
593 metadata.SetBeamPeriod(0);
594 metadata.SetResponsible("Roman Lietava");
595 metadata.SetComment("LTU Configuration for current run");
596 if (!Store("CTP","LTUConfig", ltuarray, &metadata, 0, 0)) {
597 Log("Unable to store the LTU Config object to OCDB!");
605 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger timing parameters...",partition.Data(),detector.Data()));
610 //=================//
612 //=================//
614 if (runType == "PHYSICS"){ // processing the LHC file only in PHYSICS runs
615 Log("*************** Processing LHC Data");
617 UInt_t iLHCData = ProcessLHCData(grpobj);
619 if( iLHCData == 0 ) {
620 Log(Form("LHC Data from DCS FXS, successful!"));
621 } else if (iLHCData == 1) {
622 Log(Form("LHC Data, problems with DCS FXS!"));
624 } else if (iLHCData == 2) {
625 Log(Form("LHC Data, problems with DAQ_time_start/DAQ_time_end!"));
627 } else if (iLHCData ==3){
628 Log(Form("Problems in storing LHC Phase - going into Error"));
630 } else if (iLHCData ==4){
631 Log(Form("Problems with LHC Phase - going into Error"));
634 Log(Form("LHC Data problems"));
640 //==================//
641 // SPD Mean Vertex //
642 //==================//
644 Log("*************** Processing SPD Mean Vertex");
646 if (runType == "PHYSICS"){
647 UInt_t iSPDMeanVertex = ProcessSPDMeanVertex();
648 if( iSPDMeanVertex == 1 ) {
649 Log(Form("SPD Mean Vertex, successful!"));
651 Log(Form("SPD Mean Vertex failed!!!"));
656 Log("SPD Mean Vertex not processed since runType != PHYSICS");
659 // storing AliGRPObject in OCDB
662 md.SetResponsible("Chiara Zampolli");
663 md.SetComment("Output parameters from the GRP preprocessor.");
665 Bool_t result = kTRUE;
666 result = Store("GRP", "Data", grpobj, &md);
669 if (result && !error ) {
670 Log("GRP Preprocessor Success");
673 Log( Form("GRP Preprocessor FAILS!!! %s%s%s%s%s%s%s%s%s%s%s%s",
674 kppError[(error&1)?1:0],
675 kppError[(error&2)?2:0],
676 kppError[(error&4)?3:0],
677 kppError[(error&8)?4:0],
678 kppError[(error&16)?5:0],
679 kppError[(error&32)?6:0],
680 kppError[(error&64)?7:0],
681 kppError[(error&128)?8:0],
682 kppError[(error&256)?9:0],
683 kppError[(error&512)?10:0],
684 kppError[(error&1024)?11:0],
685 kppError[(error&2048)?12:0]
693 //_______________________________________________________________
695 UInt_t AliGRPPreprocessor::ProcessLHCData(AliGRPObject *grpobj)
698 //Getting the LHC Data from DCS FXS
701 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
702 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
703 if (timeStartString.IsNull() || timeEndString.IsNull()){
704 if (timeStartString.IsNull()){
705 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
707 else if (timeEndString.IsNull()){
708 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
713 Double_t timeStart = timeStartString.Atof();
714 Double_t timeEnd = timeEndString.Atof();
716 TString fileName = GetFile(kDCS, "LHCData","");
717 if (fileName.Length()>0){
718 AliInfo("Got The LHC Data file");
719 AliLHCReader lhcReader;
721 // Processing data to be put in AliGRPObject
724 Log("*************Energy ");
725 TObjArray* energyArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[0]);
727 Float_t energy = ProcessEnergy(energyArray,timeStart);
729 grpobj->SetBeamEnergy(energy);
730 grpobj->SetBeamEnergyIsSqrtSHalfGeV(kTRUE);
735 AliError("Energy not found in LHC Data file!!!");
738 Double_t timeBeamModeEnd = timeEnd; // max validity for Beam Mode
739 Double_t timeMachineModeEnd = timeEnd; // max validity for Machine Mode
740 Double_t timeBeamEnd = timeEnd; // max validity for Beam Type
741 Double_t timeBeamModeStart = -1; // min validity for Beam Mode
742 Double_t timeMachineModeStart = -1; // min validity for Machine Mode
743 Double_t timeBeamStart = -1; // min validity for Beam Type
744 Int_t indexBeamMode = -1; // index of measurement used to set Beam Mode
745 Int_t indexMachineMode = -1; // index of measurement used to set Beam Mode
746 Int_t indexBeam = -1; // index of measurement used to set Beam Mode
747 Bool_t foundBeamModeStart = kFALSE; // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
748 Bool_t foundMachineModeStart = kFALSE; // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
749 Bool_t foundBeamStart = kFALSE; // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
750 Bool_t flagBeamMode = kFALSE; //flag set true if a changed occurred in BeamMode
751 Bool_t flagMachineMode = kFALSE; //flag set true if a changed occurred in MachineMode
752 Bool_t flagBeam = kFALSE; //flag set true if a changed occurred in BeamType
755 Log("*************BeamMode (LHCState) ");
756 TObjArray* beamModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[2]);
757 Int_t nBeamMode = -1;
759 nBeamMode = beamModeArray->GetEntries();
761 AliInfo("Found zero entries for the Beam Mode, leaving it empty");
764 for (Int_t iBeamMode = 0; iBeamMode<nBeamMode; iBeamMode++){
765 AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(iBeamMode);
767 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
768 timeBeamModeStart = beamMode->GetTimeStamp();
769 indexBeamMode = iBeamMode;
770 foundBeamModeStart = kTRUE;
778 if (!foundBeamModeStart){
779 AliInfo("No value for the Beam Mode found before start of run, the Beam Mode will remain empty");
782 AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(indexBeamMode);
783 TObjString* beamModeString = beamMode->GetStringArray(0);
784 AliInfo(Form("LHC State (corresponding to BeamMode) = %s (set at %f)",(beamModeString->String()).Data(),beamMode->GetTimeStamp()));
785 grpobj->SetLHCState(beamModeString->String());
786 if (indexBeamMode < nBeamMode-1){
787 AliDCSArray* beamMode1 = (AliDCSArray*)beamModeArray->At(indexBeamMode+1);
789 if (beamMode1->GetTimeStamp()<=timeStart){
790 AliError("you did not choose the correct value! there is still something before (or at) SOR, but later than this!");
792 else if (beamMode1->GetTimeStamp()>timeStart && beamMode1->GetTimeStamp()<=timeEnd){
793 timeBeamModeEnd = beamMode1->GetTimeStamp();
794 TObjString* beamModeString1 = beamMode1->GetStringArray(0);
795 TString bmString0 = beamModeString->String();
796 TString bmString1 = beamModeString1->String();
797 if (bmString0.CompareTo(bmString1.Data(),TString::kIgnoreCase) == -1){
798 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()));
799 flagBeamMode = kTRUE;
804 AliInfo("Invalid pointer for the first entry for Beam Mode after the first valid one, not considering anything after what has already been found");
809 delete beamModeArray;
812 AliError("Beam mode array not found in LHC Data file!!!");
816 Log("*************MachineMode ");
817 TObjArray* machineModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[1]);
818 Int_t nMachineMode = -1;
819 if (machineModeArray){
820 nMachineMode = machineModeArray->GetEntries();
821 if (nMachineMode==0){
822 AliInfo("No Machine Mode found, leaving it empty");
825 for (Int_t iMachineMode = 0; iMachineMode<nMachineMode; iMachineMode++){
826 AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(iMachineMode);
828 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
829 timeMachineModeStart = machineMode->GetTimeStamp();
830 indexMachineMode = iMachineMode;
831 foundMachineModeStart = kTRUE;
838 if (!foundMachineModeStart){
839 AliInfo("No value for the Machine Mode found before start of run, the Machine Mode will remain empty");
842 AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(indexMachineMode);
843 TObjString* machineModeString = machineMode->GetStringArray(0);
844 AliInfo(Form("MachineMode = %s (set at %f)",(machineModeString->String()).Data(),machineMode->GetTimeStamp()));
845 grpobj->SetMachineMode(machineModeString->String());
846 if (indexMachineMode < nMachineMode-1){
847 AliDCSArray* machineMode1 = (AliDCSArray*)machineModeArray->At(indexMachineMode+1);
849 if (machineMode1->GetTimeStamp()>timeStart && machineMode1->GetTimeStamp()<=timeEnd){
850 timeMachineModeEnd = machineMode1->GetTimeStamp();
851 TObjString* machineModeString1 = machineMode1->GetStringArray(0);
852 TString mmString0 = machineModeString->String();
853 TString mmString1 = machineModeString1->String();
854 if (mmString0.CompareTo(mmString1.Data(),TString::kIgnoreCase) == -1){
855 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()));
856 flagMachineMode = kTRUE;
861 AliInfo("Invalid pointer for the first entry for Machine Mode after the first valid one, not considering anything after what has already been found");
866 delete machineModeArray;
869 AliError("Machine mode array not found in LHC Data file!!!");
872 // BeamType1 and BeamType2 - both put in the same string
873 Log("*************BeamType ");
874 TObjArray* beamArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[3]);
876 Int_t nBeam = beamArray->GetEntries();
878 AliInfo("No Beam Type found, leaving it empty");
881 for (Int_t iBeam = 0; iBeam<nBeam; iBeam++){
882 AliDCSArray* beam = (AliDCSArray*)beamArray->At(iBeam);
884 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
885 timeBeamStart = beam->GetTimeStamp();
887 foundBeamStart = kTRUE;
894 if (!foundBeamStart){
895 AliInfo("No value for the Beam Type found before start of run, the Machine Mode will remain empty");
898 AliDCSArray* beam = (AliDCSArray*)beamArray->At(indexBeam);
899 TObjString* beamString = beam->GetStringArray(0);
900 TString beamType = beamString->String();
901 AliInfo(Form("Beam Type = %s",beamType.Data()));
902 if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
903 AliInfo("Setting beam type to p-p");
904 grpobj->SetBeamType("p-p");
906 else { // if there is no PROTON beam, we suppose it is Pb, and we put A-A
907 AliInfo("Setting beam type to A-A");
908 grpobj->SetBeamType("A-A");
911 else if (beamType.CompareTo("LEAD82",TString::kIgnoreCase) == 0){
912 AliInfo("Setting beam type to Pb-Pb");
913 grpobj->SetBeamType("Pb-Pb");
916 AliError("Beam Type not known, leaving it empty");
919 if (indexBeam < nBeam-1){
920 AliDCSArray* beam1 = (AliDCSArray*)beamArray->At(indexBeam+1);
922 if (beam1->GetTimeStamp()>timeStart && beam1->GetTimeStamp()<=timeEnd){
923 timeBeamEnd = beam1->GetTimeStamp();
924 TObjString* beamString1 = beam1->GetStringArray(0);
925 TString beamType1 = beamString1->String();
926 if (beamType.CompareTo(beamType1.Data(),TString::kIgnoreCase) == -1){
927 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()));
933 AliInfo("Invalid pointer for the first entry for Beam Type after the first valid one, not considering anything after what has already been found");
941 AliError("Beam Type array not found in LHC Data file!!!");
944 // Setting minTimeLHCValidity
945 if (timeBeamModeEnd!=0 || timeMachineModeEnd!=0 || timeBeamEnd !=0){
946 Double_t minTimeLHCValidity;
947 if (flagBeamMode == kFALSE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam only true
948 minTimeLHCValidity = timeBeamEnd;
950 else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode only true
951 minTimeLHCValidity = timeMachineModeEnd;
953 else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kFALSE){ // flagBeamMode only true
954 minTimeLHCValidity = timeBeamModeEnd;
956 else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kTRUE){ // flagBeam and flagMachineMode only true
957 minTimeLHCValidity= TMath::Min(timeBeamEnd,timeMachineModeEnd);
959 else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam and flagBeamMode only true
960 minTimeLHCValidity= TMath::Min(timeBeamEnd,timeBeamModeEnd);
962 else if (flagBeamMode == kTRUE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode and flagBeamMode only true
963 minTimeLHCValidity= TMath::Min(timeMachineModeEnd,timeBeamModeEnd);
966 Double_t arrayTimes[3] = {timeBeamModeEnd,timeMachineModeEnd,timeBeamEnd};// flagMachineMode and flagBeamMode and flagBeam
967 minTimeLHCValidity= TMath::MinElement(3,arrayTimes);
969 AliWarning(Form("Setting MaxTimeLHCValidity to %f",minTimeLHCValidity));
970 grpobj->SetMaxTimeLHCValidity(minTimeLHCValidity);
973 // Processing data to go to AliLHCData object
974 AliLHCData* dt = new AliLHCData(fileName.Data(),timeStart,timeEnd);
975 // storing AliLHCData in OCDB
977 AliInfo(Form("Filled %d records to AliLHCData object",dt->GetData().GetEntriesFast()));
979 md.SetResponsible("Ruben Shahoyan");
980 md.SetComment("LHC data from the GRP preprocessor.");
981 Bool_t result = kTRUE;
982 result = Store("GRP", "LHCData", dt, &md);
985 Log(Form("Problems in storing LHC Data - but not going into Error"));
989 // processing LHC Phase
991 TObjArray *beam1phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[4]);
992 TObjArray *beam2phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[5]);
993 if (beam1phase == 0x0 || beam2phase == 0x0){
994 Log(Form("Problems in retrieving LHC Clock data from LHC file"));
997 AliLHCClockPhase *phaseObj = ProcessLHCClockPhase(beam1phase,beam2phase,timeEnd);
999 AliInfo(Form("LHC Phase found"));
1000 AliCDBMetaData mdPhase;
1001 mdPhase.SetResponsible("Cvetan Cheshkov");
1002 mdPhase.SetComment("LHC Clock Phase");
1003 Bool_t result = kTRUE;
1004 result = Store("Calib", "LHCClockPhase", phaseObj, &mdPhase);
1006 if (!result) return 3;
1012 AliError("No LHCData file found in DCS FXS");
1019 //_______________________________________________________________
1021 UInt_t AliGRPPreprocessor::ProcessSPDMeanVertex()
1024 //Getting the SPD Mean Vertex
1027 TList* list = GetForeignFileSources("SPD", kDAQ, "VertexDiamond");
1028 Bool_t storeResult = kTRUE;
1029 if (list !=0x0 && list->GetEntries()!=0)
1031 AliInfo("The following sources produced files with the id VertexDiamond from SPD");
1033 for (Int_t jj=0;jj<list->GetEntries();jj++){
1034 TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
1036 AliError(Form("Expecting a TObjString in the list for the %d-th source, but something else was found.",jj));
1039 AliInfo(Form("found source %s", str->String().Data()));
1040 TString fileNameRun = GetForeignFile("SPD", kDAQ, "VertexDiamond", str->GetName());
1041 if (fileNameRun.Length()>0){
1042 AliInfo(Form("Got the file %s", fileNameRun.Data()));
1043 TFile daqFile(fileNameRun.Data(),"READ");
1044 if (daqFile.IsOpen()) {
1045 AliESDVertex* meanVtx = dynamic_cast<AliESDVertex*>(daqFile.Get("MeanVertexPos"));
1048 // storing in the OCDB
1050 md.SetResponsible("Cvetan Cheshkov");
1051 md.SetComment("SPD Mean Vertex");
1052 storeResult = Store("Calib", "MeanVertexSPD", meanVtx, &md, 0, kTRUE);
1055 AliWarning("No SPD Mean Vertex object found in file");
1059 AliError("Can't open file");
1060 storeResult = kFALSE;
1064 AliWarning("No file found for current source for SPD Mean Vertex");
1069 AliWarning("No list found for SPD Mean Vertex");
1072 if (list) delete list;
1078 //_______________________________________________________________
1080 Int_t AliGRPPreprocessor::ProcessDaqLB(AliGRPObject* grpObj)
1082 //Getting the DAQ lb information
1084 time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
1085 time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
1086 Float_t beamEnergy = (Float_t)(((TString)GetRunParameter("beamEnergy")).Atof());
1087 TString beamType = (TString)GetRunParameter("beamType");
1088 Char_t numberOfDetectors = (Char_t)(((TString)GetRunParameter("numberOfDetectors")).Atoi());
1089 UInt_t detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
1090 TString lhcPeriod = (TString)GetRunParameter("LHCperiod");
1091 TString runType = (TString)GetRunType();
1093 UInt_t nparameter = 0;
1094 if (timeStart != 0){
1095 grpObj->SetTimeStart(timeStart);
1096 Log(Form("Start time for run %d: %d",fRun, (Int_t)timeStart));
1100 Log(Form("Start time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1104 grpObj->SetTimeEnd(timeEnd);
1105 Log(Form("End time for run %d: %i",fRun, (Int_t)timeEnd));
1109 Log(Form("End time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1112 if (beamEnergy != 0){
1113 Log(Form("Beam Energy for run %d: %f (NOT USING IT TO FILL THE GRP OBJECT, taking it from the LHC file)",fRun, beamEnergy));
1116 Log(Form("Beam Energy not put in logbook, but not using it anyway for the GRP object (taking it from the LHC file)"));
1120 if (beamType.Length() != 0){
1121 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()));
1124 Log(Form("Beam Type not put in logbook, but not using it anyway for the GRP entry (taking it from the LHC file)"));
1127 if (numberOfDetectors != 0){
1128 grpObj->SetNumberOfDetectors(numberOfDetectors);
1129 Log(Form("Number Of Detectors for run %d: %d",fRun, (Int_t)numberOfDetectors));
1133 Log(Form("Number Of Detectors not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1136 if (detectorMask != 0){
1137 grpObj->SetDetectorMask(detectorMask);
1138 Log(Form("Detector Mask for run %d: %d",fRun, detectorMask));
1142 Log(Form("Detector Mask not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1145 if (lhcPeriod.Length() != 0) {
1146 grpObj->SetLHCPeriod(lhcPeriod);
1147 Log(Form("LHC period (DAQ) for run %d: %s",fRun, lhcPeriod.Data()));
1151 Log(Form("LHCperiod not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1153 if (runType.Length() != 0) {
1154 grpObj->SetRunType(runType);
1155 Log(Form("Run Type (DAQ) for run %d: %s",fRun, runType.Data()));
1159 Log(Form("Run Type not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1165 //_______________________________________________________________
1167 UInt_t AliGRPPreprocessor::ProcessDaqFxs()
1169 //======DAQ FXS======//
1171 AliRawEventHeaderV3_9::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_9 - temporary fix
1172 AliRawEventHeaderV3_11::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_11 - temporary fix
1173 TList* list = GetFileSources(kDAQ);
1175 Log("No raw data tag list: connection problems with DAQ FXS logbook!");
1179 if (list->GetEntries() == 0) {
1180 Log("no raw data tags in this run: nothing to merge!");
1181 delete list; list=0;
1185 TChain *fRawTagChain = new TChain("T");
1187 TIterator* iter = list->MakeIterator();
1189 while ((obj = iter->Next())) {
1190 TObjString* objStr = dynamic_cast<TObjString*> (obj);
1192 Log(Form("Found source %s", objStr->String().Data()));
1193 TList* list2 = GetFileIDs(kDAQ, objStr->String());
1195 Log("No list with ids from DAQ was found: connection problems with DAQ FXS logbook!");
1196 delete fRawTagChain; fRawTagChain=0;
1199 Log(Form("Number of ids: %d",list2->GetEntries()));
1200 for(Int_t i = 0; i < list2->GetEntries(); i++) {
1201 TObjString *idStr = (TObjString *)list2->At(i);
1202 TString fileName = GetFile(kDAQ,idStr->String().Data(),objStr->String().Data());
1203 if (fileName.Length() > 0) {
1204 Log(Form("Adding file in the chain: %s",fileName.Data()));
1205 fRawTagChain->Add(fileName.Data());
1208 Log(Form("Could not retrieve file with id %s from source %s: "
1209 "connection problems with DAQ FXS!",
1210 idStr->String().Data(), objStr->String().Data()));
1211 delete list; list=0;
1212 delete list2; list2=0;
1213 delete fRawTagChain; fRawTagChain=0;
1221 TString fRawDataFileName = "GRP_Merged.tag.root";
1222 Log(Form("Merging %d raw data tags into file: %s", nFiles, fRawDataFileName.Data()));
1224 if( fRawTagChain->Merge(fRawDataFileName) < 1 ) {
1225 Log("Error merging raw data files!!!");
1229 TString outputfile = Form("Run%d.Merged.RAW.tag.root", fRun);
1230 Bool_t result = StoreRunMetadataFile(fRawDataFileName.Data(),outputfile.Data());
1233 Log("Problem storing raw data tags in local file!!!");
1235 Log("Raw data tags merged successfully!!");
1240 delete fRawTagChain; fRawTagChain=0;
1242 if (result == kFALSE) {
1250 //_______________________________________________________________
1251 UInt_t AliGRPPreprocessor::ProcessDcsFxs(TString partition, TString detector)
1254 // processing the info
1255 // stored in the DCS FXS
1256 // coming from the trigger
1258 // Get the CTP counters information
1260 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
1261 Log("STANDALONE partition for current run, using Trigger Scalers dummy value");
1262 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyScalers");
1264 Log(Form("No dummy CTP scalers entry found, going into error..."));
1268 AliTriggerRunScalers *scalers = (AliTriggerRunScalers*)cdbEntry->GetObject();
1270 Log(Form("CTP dummy scalers not found in OCDB entry, going into error..."));
1274 AliCDBMetaData metaData;
1275 metaData.SetResponsible("Roman Lietava");
1276 metaData.SetComment("CTP scalers from dummy entry in OCDB");
1277 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1278 Log("Unable to store the dummy CTP scalers object to OCDB!");
1285 else if (!partition.IsNull() && detector.IsNull()){ // global partition
1286 Log("GLOBAL partition for current run, using CTP scalers from DCS FXS");
1287 TString countersfile = GetFile(kDCS, "CTP_xcounters","");
1288 if (countersfile.IsNull()) {
1289 Log("No CTP counters files has been found: empty source!");
1293 Log(Form("File with Id CTP_xcounters found in DCS FXS! Copied to %s",countersfile.Data()));
1294 AliTriggerRunScalers *scalers = AliTriggerRunScalers::ReadScalers(countersfile);
1296 Log("Bad CTP counters file! The corresponding CDB entry will not be filled!");
1300 AliCDBMetaData metaData;
1301 metaData.SetBeamPeriod(0);
1302 metaData.SetResponsible("Roman Lietava");
1303 metaData.SetComment("CTP scalers");
1304 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1305 Log("Unable to store the CTP scalers object to OCDB!");
1316 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error...",partition.Data(),detector.Data()));
1323 //_______________________________________________________________
1325 Int_t AliGRPPreprocessor::ProcessDcsDPs(TMap* valueMap, AliGRPObject* grpObj)
1329 // processing DCS DPs
1332 Int_t entries = 0; // counting the entries that are in the DCS DB, not taking care whether they have values or not
1333 Int_t nL3Entries = 0;
1334 Int_t nDipoleEntries = 0;
1335 Int_t nEnvEntries = 0;
1336 Int_t nHallProbesEntries = 0;
1337 nL3Entries = ProcessL3DPs(valueMap, grpObj);
1338 nDipoleEntries = ProcessDipoleDPs(valueMap, grpObj);
1339 nEnvEntries = ProcessEnvDPs(valueMap, grpObj);
1340 nHallProbesEntries = ProcessHPDPs(valueMap, grpObj);
1341 grpObj->SetPolarityConventionLHC(); // after the dipole cables swap we comply with LHC convention
1342 Log(Form("L3Entries = %d, nDipoleEntries =%d, nEnvEntries = %d, nHallProbesEntries = %d", nL3Entries, nDipoleEntries, nEnvEntries, nHallProbesEntries));
1343 entries = nL3Entries + nDipoleEntries + nEnvEntries + nHallProbesEntries;
1348 //_______________________________________________________________
1350 Int_t AliGRPPreprocessor::ProcessL3DPs(const TMap* valueMap, AliGRPObject* grpObj)
1357 Int_t nL3Entries = 0;
1359 TObjArray *array = 0x0;
1361 Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
1363 AliInfo(Form("==========L3Current==========="));
1364 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
1365 indexDP = kL3Current;
1366 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1368 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1371 if (array->GetEntries() == 0){
1372 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1375 Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1376 if (floatDCS != NULL){
1377 grpObj->SetL3Current(floatDCS);
1389 ffailedDPs->RemoveAt(indexDP);
1393 if (array) array = 0x0;
1395 AliInfo(Form("==========L3Polarity==========="));
1396 indexDP = kL3Polarity;
1397 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1399 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1402 if (array->GetEntries() == 0){
1403 AliError(Form("No entries found in array! setting %s Polarity to invalid...",fgkDCSDataPoints[indexDP]));
1406 Bool_t change = kFALSE;
1407 Char_t charDCS = ProcessBool(array,change);
1408 if (change == kFALSE){
1409 grpObj->SetL3Polarity(charDCS);
1410 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetL3Polarity())));
1411 ffailedDPs->RemoveAt(indexDP);
1415 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
1416 ffailedDPs->RemoveAt(indexDP);
1420 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]));
1428 //_______________________________________________________________
1430 Int_t AliGRPPreprocessor::ProcessDipoleDPs(const TMap* valueMap, AliGRPObject* grpObj)
1436 Int_t nDipoleEntries = 0;
1437 TObjArray *array = 0x0;
1439 Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
1441 AliInfo(Form("==========DipoleCurrent==========="));
1442 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
1443 indexDP = kDipoleCurrent;
1444 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1446 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1449 if (array->GetEntries() == 0){
1450 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1453 Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1454 if (floatDCS != NULL){
1455 grpObj->SetDipoleCurrent(floatDCS);
1467 ffailedDPs->RemoveAt(indexDP);
1471 if (array) array = 0x0;
1473 AliInfo(Form("==========DipolePolarity==========="));
1474 indexDP = kDipolePolarity;
1475 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1477 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1480 if (array->GetEntries() == 0){
1481 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1484 Bool_t change = kFALSE;
1485 Char_t charDCS = ProcessBool(array,change);
1487 grpObj->SetDipolePolarity(charDCS);
1488 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetDipolePolarity())));
1489 ffailedDPs->RemoveAt(indexDP);
1493 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
1494 ffailedDPs->RemoveAt(indexDP);
1498 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]));
1503 return nDipoleEntries;
1506 //_______________________________________________________________
1508 Int_t AliGRPPreprocessor::ProcessEnvDPs(TMap* valueMap, AliGRPObject* grpObj)
1512 // evironment conditions (temperature, pressure) info
1514 Int_t nEnvEntries = 0;
1515 TObjArray *array = 0x0;
1518 AliInfo(Form("==========CavernTemperature==========="));
1519 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
1520 indexDP = kCavernTemperature;
1521 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1523 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1526 if (array->GetEntries() == 0){
1527 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1530 Float_t *floatDCS = ProcessFloatAll(array);
1531 if (floatDCS != NULL){
1532 grpObj->SetCavernTemperature(floatDCS);
1543 ffailedDPs->RemoveAt(indexDP);
1548 if (array) array = 0x0;
1550 AliInfo(Form("========== AtmosPressures (Cavern + Surface + Cavern2) ==========="));
1551 AliDCSSensorArray *dcsSensorArray = GetPressureMap(valueMap);
1552 //dcsSensorArray->Print();
1553 if( fPressure->NumFits()<kNumSensors ) {
1554 Log(Form("Check the pressure sensor values! Not all the %d pressure sensors have been fit",kNumSensors));
1556 Log(Form("Number of fits performed = %d",fPressure->NumFits()));
1558 AliInfo(Form("==========CavernAtmosPressure==========="));
1559 indexDP = kCavernAtmosPressure;
1560 AliDCSSensor* sensorCavernP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
1561 TGraph* graph = sensorCavernP2->GetGraph();
1562 AliDebug(3,Form("index = %d",indexDP));
1563 AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
1564 AliDebug(2,Form("graph = %p",graph));
1565 AliDebug(3,Form("sensorCavernP2 = %p", sensorCavernP2));
1566 if(sensorCavernP2->GetFit() || graph) {
1567 if (sensorCavernP2->GetFit()){
1568 Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
1571 Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
1573 grpObj->SetCavernAtmosPressure(sensorCavernP2);
1574 ffailedDPs->RemoveAt(indexDP);
1577 //if (sensorP2) delete sensorP2;
1579 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] ));
1582 AliInfo(Form("==========SurfaceAtmosPressure==========="));
1583 indexDP = kSurfaceAtmosPressure;
1584 AliDCSSensor* sensorP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
1585 graph = sensorP2->GetGraph();
1586 AliDebug(3,Form("index = %d",indexDP));
1587 AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
1588 AliDebug(2,Form("graph = %p",graph));
1589 AliDebug(3,Form("sensorP2 = %p", sensorP2));
1590 if(sensorP2->GetFit() || graph) {
1591 if (sensorP2->GetFit()){
1592 Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
1595 Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
1597 grpObj->SetSurfaceAtmosPressure(sensorP2);
1598 ffailedDPs->RemoveAt(indexDP);
1601 //if (sensorP2) delete sensorP2;
1603 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] ));
1606 AliInfo(Form("==========CavernAtmosPressure2==========="));
1607 indexDP = kCavernAtmosPressure2;
1608 AliDCSSensor* sensorCavernP22 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
1609 graph = sensorCavernP22->GetGraph();
1610 AliDebug(3,Form("index = %d",indexDP));
1611 AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
1612 AliDebug(2,Form("graph = %p",graph));
1613 AliDebug(3,Form("sensorCavernP2_2 = %p", sensorCavernP22));
1614 if(sensorCavernP22->GetFit() || graph) {
1615 if (sensorCavernP22->GetFit()){
1616 Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
1619 Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
1621 grpObj->SetCavernAtmosPressure2(sensorCavernP22);
1622 ffailedDPs->RemoveAt(indexDP);
1625 //if (sensorP2) delete sensorP2;
1627 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] ));
1633 //_______________________________________________________________
1635 Int_t AliGRPPreprocessor::ProcessHPDPs(const TMap* valueMap, AliGRPObject* grpObj)
1641 Int_t nHPEntries = 0;
1642 TObjArray *array = 0x0;
1644 Bool_t outOfRange; // flag to monitor if any value collected by DCS is out of range
1646 if (fgknDCSDPHallProbes != AliGRPObject::GetNumberOfHP()){
1647 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()));
1649 for (indexDP = 0; indexDP < AliGRPObject::GetNumberOfHP(); indexDP++){
1650 outOfRange = kFALSE; // resetting outOfRange flag at each HP
1651 AliInfo(Form("==========%s===========",AliGRPObject::GetHPDP(indexDP)));
1652 array = (TObjArray *)valueMap->GetValue(AliGRPObject::GetHPDP(indexDP));
1654 Log(Form("%s not found in the map!!!",AliGRPObject::GetHPDP(indexDP)));
1657 if (array->GetEntries() == 0){
1658 AliError(Form("No entries found in array! setting %s to invalid...",AliGRPObject::GetHPDP(indexDP)));
1661 Float_t *floatDCS = ProcessFloatAll(array);
1662 if (floatDCS != NULL){
1663 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]));
1664 grpObj->SetHallProbes((AliGRPObject::DP_HallProbes)indexDP,floatDCS);
1665 for (Int_t kk = 0 ; kk< 5; kk++){
1666 AliDebug(2,Form("HallProbe[%d][%d]=%f",indexDP,kk,grpObj->GetHallProbes((AliGRPObject::DP_HallProbes)indexDP,(AliGRPObject::Stats)kk)));
1678 ffailedDPs->RemoveAt(indexDP + fgkDCSDPHallTopShift); // 7 = shift in the complete list of DPs to get to the Hall Probes
1684 Log(Form("Hall Probes = %d ", nHPEntries));
1688 //_________________________________________________________________________
1690 AliSplineFit* AliGRPPreprocessor::GetSplineFit(const TObjArray *array, const TString& stringID){
1694 // returning Spline Fit
1697 Int_t entriesarray = array->GetEntries();
1698 Float_t* value = new Float_t[entriesarray];
1699 Float_t* time = new Float_t[entriesarray];
1700 AliDCSValue* v = 0x0;
1701 for (Int_t iarray = 0; iarray < entriesarray; iarray++){
1702 v = (AliDCSValue*)array->At(iarray);
1703 value[iarray] = v->GetFloat();
1704 time[iarray] = v->GetTimeStamp();
1705 AliDebug(2,Form("iarray = %d, value = %f, time = %f",iarray,value[iarray],time[iarray]));
1707 TGraph* gr = new TGraph(entriesarray,value,time);
1709 AliWarning(Form("%s: no input graph to compute SplineFit",stringID.Data()));
1712 AliSplineFit *fit = new AliSplineFit();
1713 fit->SetMinPoints(10);
1714 fit->InitKnots(gr,10,10,0.0);
1720 //_________________________________________________________________________
1722 TString AliGRPPreprocessor::ProcessChar(const TObjArray *array)
1729 TString aDCSString="";
1731 AliDCSValue *v = 0x0;
1732 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1733 v = (AliDCSValue *)array->At(iCount);
1734 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
1735 AliError(Form("DCS values for the parameter outside the queried interval"));
1739 if (aDCSString != v->GetChar())
1740 AliError(Form("DCS values for the parameter changed from %s to %c within the queried interval", aDCSString.Data(), (Char_t)v->GetChar()));
1742 aDCSString = (TString)v->GetChar(); // keeping always last value in the array
1747 //__________________________________________________________________________________________________________________
1749 Float_t* AliGRPPreprocessor::ProcessFloatAll(const TObjArray* array)
1752 // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
1754 // parameters[0] = mean
1755 // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
1756 // parameters[2] = median
1757 // parameters[3] = standard deviation wrt mean
1758 // parameters[4] = standard deviation wrt median
1761 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
1762 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
1763 if (timeStartString.IsNull() || timeStartString.IsNull()){
1764 if (timeStartString.IsNull()){
1765 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
1767 else if (timeStartString.IsNull()){
1768 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
1770 fdaqStartEndTimeOk = kFALSE;
1774 Int_t timeStart = (Int_t)(timeStartString.Atoi());
1775 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
1776 Float_t* parameters = new Float_t[5];
1778 Int_t iCountsRun = 0;
1779 Int_t nCounts = array->GetEntries();
1780 Float_t valueBeforeSOR = 0;
1781 Float_t valueAfterEOR = 0;
1782 Int_t timestampBeforeSOR = -1;
1783 Int_t timestampAfterEOR = -1;
1784 Int_t ientrySOR = -1;
1785 Int_t ientryEOR = -1;
1786 Float_t* arrayValues = 0x0;
1787 Double_t* arrayWeights = 0x0;
1788 Bool_t truncMeanFlag = kTRUE; // flag to indicate whether Truncated Mean should be calculated or not
1789 Bool_t sdFlag = kTRUE; // flag to indicate whether SD (wrt Mean/Median) should be calculated or not
1791 for(Int_t i = 0; i < nCounts; i++) {
1792 AliDCSValue *v = (AliDCSValue *)array->At(i);
1793 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
1794 AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
1795 if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
1796 if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
1797 delete [] parameters;
1800 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
1801 AliDebug(2,Form("%d-th entry = %f at timestamp %i",i,v->GetFloat(),v->GetTimeStamp()));
1803 // look for the last value before SOR and the first value before EOR
1804 if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
1805 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
1806 AliDebug(2,Form("timestamp of last value before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
1807 valueBeforeSOR = v->GetFloat();
1809 else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
1810 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
1811 valueAfterEOR = v->GetFloat();
1812 AliDebug(2,Form("timestamp of first value after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
1814 // check if there are DPs between DAQ_time_start and DAQ_time_end
1815 if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
1816 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
1817 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
1818 AliDebug(2,Form("entry between SOR and EOR"));
1823 AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
1827 if (timestampBeforeSOR == -1){
1828 AliWarning("No value found before SOR");
1830 if (timestampAfterEOR == -1){
1831 AliWarning("No value found after EOR");
1834 AliDebug(2,Form("Number of valid entries (within DCS query interval) = %i, from a total amount of %i entries",iCounts,nCounts));
1835 AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
1836 AliDebug(2,Form("First value after DAQ_time_end (EOR) = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
1837 AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
1838 AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
1839 AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
1841 Int_t nentriesUsed = 0;
1842 if (iCountsRun > 1){
1843 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
1844 AliDebug(2,"Calculating (weighted) Mean and Median");
1845 arrayValues = new Float_t[iCountsRun];
1846 arrayWeights = new Double_t[iCountsRun];
1847 nentriesUsed = iCountsRun;
1848 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
1849 AliDCSValue *v = (AliDCSValue *)array->At(i);
1850 Int_t timestamp2 = 0;
1852 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
1853 timestamp2 = (Int_t)v1->GetTimeStamp();
1856 timestamp2 = timeEnd+1;
1858 arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
1859 arrayValues[i-ientrySOR] = v->GetFloat();
1861 parameters[0] = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
1862 parameters[2] = TMath::Median(iCountsRun,arrayValues,arrayWeights);
1864 else if (iCountsRun == 1){
1865 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
1867 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
1868 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.");
1869 arrayValues = new Float_t[2];
1870 arrayWeights = new Double_t[2];
1871 arrayValues[0] = valueBeforeSOR;
1872 arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
1873 arrayValues[1] = v->GetFloat();
1874 arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
1875 AliDebug(2, Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
1876 AliDebug(2, Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
1877 parameters[0] = TMath::Mean(2,arrayValues,arrayWeights);
1878 parameters[2] = TMath::Median(2,arrayValues,arrayWeights);
1879 truncMeanFlag = kFALSE;
1882 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");
1883 parameters[0] = AliGRPObject::GetInvalidFloat();
1884 parameters[1] = AliGRPObject::GetInvalidFloat();
1885 parameters[2] = AliGRPObject::GetInvalidFloat();
1886 parameters[3] = AliGRPObject::GetInvalidFloat();
1887 parameters[4] = AliGRPObject::GetInvalidFloat();
1891 else { // iCountsRun == 0, using only the point immediately before SOR
1892 if (timestampBeforeSOR == -1){
1893 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");
1894 parameters[0] = AliGRPObject::GetInvalidFloat();
1895 parameters[1] = AliGRPObject::GetInvalidFloat();
1896 parameters[2] = AliGRPObject::GetInvalidFloat();
1897 parameters[3] = AliGRPObject::GetInvalidFloat();
1898 parameters[4] = AliGRPObject::GetInvalidFloat();
1902 AliWarning("Using only last entry before SOR. Truncated mean and Standard deviations (wrt mean/median) won't be calculated.");
1903 AliDebug(2,Form("value = %f",valueBeforeSOR));
1904 parameters[0] = valueBeforeSOR;
1905 parameters[2] = valueBeforeSOR;
1906 truncMeanFlag = kFALSE;
1913 Float_t sumweights = 0;
1914 Int_t entriesTruncMean = 0;
1915 Float_t* arrayValuesTruncMean = new Float_t[nentriesUsed];
1916 Double_t* arrayWeightsTruncMean = new Double_t[nentriesUsed];
1918 // calculating SD wrt Mean and Median
1919 AliDebug(2,"Calculating SD wrt Mean and SD wrt Median");
1921 for (Int_t i =0; i< nentriesUsed; i++){
1922 AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
1923 temp += (arrayValues[i]-parameters[2])*(arrayValues[i]-parameters[2]);
1924 temp1 += arrayWeights[i]*(arrayValues[i]-parameters[0])*(arrayValues[i]-parameters[0]);
1925 sumweights += arrayWeights[i];
1927 // setting SD wrt Mean
1928 if (sumweights != 0 ){
1929 parameters[3] = TMath::Sqrt(temp1/sumweights);
1932 AliError("Sum of weights to calculate Standard Deviation (wrt mean) <= 0, setting the SD to invalid");
1933 parameters[3] = AliGRPObject::GetInvalidFloat();
1935 // setting SD wrt Median
1936 if (nentriesUsed != 0){
1937 parameters[4] = TMath::Sqrt(temp/nentriesUsed);
1940 AliError("Number of entries used to calculate Standard Deviation (wrt median) <= 0, setting the SD to invalid");
1941 parameters[4] = AliGRPObject::GetInvalidFloat();
1945 parameters[3] = AliGRPObject::GetInvalidFloat();
1946 parameters[4] = AliGRPObject::GetInvalidFloat();
1949 // calculating truncated mean (this comes afterwards since you need the SD wrt Mean)
1951 AliDebug(2,"Calculating Truncated Mean");
1952 for (Int_t i =0; i< nentriesUsed; i++){
1953 AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
1954 if ((arrayValues[i]<=parameters[0]+3*parameters[3]) && (arrayValues[i]>=parameters[0]-3*parameters[3])){
1955 arrayValuesTruncMean[entriesTruncMean]=arrayValues[i];
1956 arrayWeightsTruncMean[entriesTruncMean]=arrayWeights[i];
1957 AliDebug(2,Form("For Truncated Mean: Entry %d: value = %f, weight = %f",entriesTruncMean,arrayValuesTruncMean[entriesTruncMean],arrayWeightsTruncMean[entriesTruncMean]));
1961 AliDebug(2,"Discarding entry");
1964 // setting truncated mean
1965 if (entriesTruncMean >1){
1966 AliDebug(2,Form("%d entries used for truncated mean",entriesTruncMean));
1967 parameters[1] = TMath::Mean(entriesTruncMean,arrayValuesTruncMean,arrayWeightsTruncMean);
1970 AliDebug(2,Form("Too few entries (%d) to calculate truncated mean",entriesTruncMean));
1971 parameters[1] = AliGRPObject::GetInvalidFloat();
1975 parameters[1] = AliGRPObject::GetInvalidFloat();
1979 delete [] arrayValues;
1982 delete [] arrayWeights;
1984 delete [] arrayValuesTruncMean;
1985 delete [] arrayWeightsTruncMean;
1987 AliInfo(Form("(weighted) mean = %f ",parameters[0]));
1988 AliInfo(Form("(weighted) truncated mean = %f ",parameters[1]));
1989 AliInfo(Form("median = %f ",parameters[2]));
1990 AliInfo(Form("(weighted) standard deviation with (weighted) mean = %f ",parameters[3]));
1991 AliInfo(Form("standard deviation with median = %f ",parameters[4]));
1996 //__________________________________________________________________________________________________________________
1998 Float_t* AliGRPPreprocessor::ProcessFloatAllMagnet(const TObjArray* array, Int_t indexDP, Bool_t &isZero)
2001 // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
2002 // used for L3 and Dipole magnets, using isZero flag to decide whther the magnet was OFF/ON
2003 // the flag is set according to the L3/Dipole current value
2004 // current threshold for L3 = 350 A (value provided by DCS)
2005 // current threshold for Dipole = 450 A (value provided by DCS)
2007 // parameters[0] = mean
2008 // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
2009 // parameters[2] = median
2010 // parameters[3] = standard deviation wrt mean
2011 // parameters[4] = standard deviation wrt median
2014 AliInfo(Form("indexDP = %d",indexDP));
2016 Int_t nCounts = array->GetEntries();
2017 for(Int_t i = 0; i < nCounts; i++) {
2018 AliDCSValue *v = (AliDCSValue *)array->At(i);
2019 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
2020 AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
2021 if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
2022 if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
2025 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2026 AliDebug(2,Form("%d-th entry = %f",i,v->GetFloat()));
2027 if (indexDP == kL3Current && v->GetFloat() > 350 && isZero == kTRUE) isZero=kFALSE;
2028 if (indexDP == kDipoleCurrent && v->GetFloat() > 450 && isZero == kTRUE) isZero=kFALSE;
2031 AliError(Form("DCS values for the parameter outside the queried interval"));
2035 return ProcessFloatAll(array);
2039 //_______________________________________________________________
2041 Char_t AliGRPPreprocessor::ProcessBool(const TObjArray* array, Bool_t &change)
2044 // processing Boolean values
2047 Bool_t aDCSBool = kTRUE;
2049 AliDCSValue *v = 0x0;
2051 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
2052 v = (AliDCSValue *)array->At(iCount);
2053 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
2054 AliError(Form("DCS values for the parameter outside the queried interval"));
2058 if (aDCSBool != v->GetBool()) {
2059 AliError(Form("DCS values for the parameter changed from %d to %d within the queried interval", (UInt_t)aDCSBool, (UInt_t)v->GetBool()));
2063 aDCSBool = v->GetBool(); // always keeping last value
2064 AliDebug(2,Form("Bool = %d",(Int_t)aDCSBool));
2067 Char_t caDCSBool = (Char_t) aDCSBool;
2072 //_______________________________________________________________
2074 Float_t AliGRPPreprocessor::ProcessInt(const TObjArray* array)
2077 // processing Int values, returning mean
2078 // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
2079 // are outside the queried time interval or their value is out of range
2082 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2083 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2084 if (timeStartString.IsNull() || timeStartString.IsNull()){
2085 if (timeStartString.IsNull()){
2086 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2088 else if (timeStartString.IsNull()){
2089 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2094 Int_t timeStart = (Int_t)(timeStartString.Atoi());
2095 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2096 Float_t aDCSArrayMean = 0.0;
2098 Float_t valueBeforeSOR = 0;
2099 Float_t valueAfterEOR = 0;
2100 Int_t timestampBeforeSOR = -1;
2101 Int_t timestampAfterEOR = -1;
2102 Int_t ientrySOR = -1;
2103 Int_t ientryEOR = -1;
2104 Float_t* arrayValues = 0x0;
2105 Double_t* arrayWeights = 0x0;
2106 Int_t iCountsRun = 0;
2107 Int_t nCounts = array->GetEntries();
2109 for(Int_t i = 0; i < nCounts; i++) {
2110 AliDCSValue* v = (AliDCSValue *)array->At(i);
2111 if ((v->GetInt() < fminInt) || (v->GetInt() > fmaxInt)) {
2112 AliError(Form("Error! Int value found in DCS map at %d-th entry is OUT OF RANGE: value = %d",i, v->GetInt()));
2113 return AliGRPObject::GetInvalidFloat();
2115 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2116 AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetInt(),v->GetTimeStamp()));
2118 // look for the last value before SOR and the first value before EOR
2119 if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
2120 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
2121 AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
2122 valueBeforeSOR = (Float_t) v->GetInt();
2124 else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
2125 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
2126 valueAfterEOR = (Float_t) v->GetInt();
2127 AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
2129 // check if there are DPs between DAQ_time_start and DAQ_time_end
2130 if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
2131 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
2132 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
2133 AliDebug(2,Form("entry between SOR and EOR"));
2138 AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
2142 if (timestampBeforeSOR == -1){
2143 AliWarning("No value found before SOR!");
2145 if (timestampAfterEOR == -1){
2146 AliWarning("No value found after EOR!");
2149 AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
2150 AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2151 AliDebug(2,Form("First value after DAQ_time_end (EOR) = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2152 AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2153 AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2154 AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2156 Int_t nentriesUsed = 0;
2157 if (iCountsRun > 1){
2158 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2159 AliDebug(2,"Calculating (weighted) Mean");
2160 arrayValues = new Float_t[iCountsRun];
2161 arrayWeights = new Double_t[iCountsRun];
2162 nentriesUsed = iCountsRun;
2163 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2164 AliDCSValue *v = (AliDCSValue *)array->At(i);
2165 Int_t timestamp2 = 0;
2167 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2168 timestamp2 = (Int_t)v1->GetTimeStamp();
2171 timestamp2 = timeEnd+1;
2173 arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2174 arrayValues[i-ientrySOR] = (Float_t)v->GetInt();
2176 aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2177 delete [] arrayValues;
2178 delete [] arrayWeights;
2180 else if (iCountsRun == 1){
2181 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2183 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2184 AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
2185 arrayValues = new Float_t[2];
2186 arrayWeights = new Double_t[2];
2187 arrayValues[0] = valueBeforeSOR;
2188 arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2189 arrayValues[1] = (Float_t)v->GetInt();
2190 arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2191 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2192 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2193 aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
2194 delete [] arrayValues;
2195 delete [] arrayWeights;
2198 AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
2199 return AliGRPObject::GetInvalidFloat();
2202 else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
2203 if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
2204 if (timestampBeforeSOR == -1){
2205 AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
2207 if (timestampAfterEOR == -1){
2208 AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
2210 return AliGRPObject::GetInvalidFloat();
2213 AliWarning("Using last entry before SOR and first entry after EOR.");
2215 arrayValues = new Float_t[2];
2216 arrayWeights = new Double_t[2];
2217 arrayValues[0] = valueBeforeSOR;
2218 arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
2219 arrayValues[1] = valueAfterEOR;
2220 arrayWeights[1] = 1.;
2221 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2222 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2223 aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
2224 delete [] arrayValues;
2225 delete [] arrayWeights;
2229 AliInfo(Form("mean = %f ", aDCSArrayMean));
2230 return aDCSArrayMean;
2233 //_______________________________________________________________
2235 Float_t AliGRPPreprocessor::ProcessUInt(const TObjArray* array)
2238 // processing Int values, returning mean
2239 // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
2240 // are outside the queried time interval or their value is out of range
2243 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2244 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2245 if (timeStartString.IsNull() || timeStartString.IsNull()){
2246 if (timeStartString.IsNull()){
2247 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2249 else if (timeStartString.IsNull()){
2250 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2255 Int_t timeStart = (Int_t)(timeStartString.Atoi());
2256 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2257 Float_t aDCSArrayMean = 0.0;
2259 Float_t valueBeforeSOR = 0;
2260 Float_t valueAfterEOR = 0;
2261 Int_t timestampBeforeSOR = -1;
2262 Int_t timestampAfterEOR = -1;
2263 Int_t ientrySOR = -1;
2264 Int_t ientryEOR = -1;
2265 Float_t* arrayValues = 0x0;
2266 Double_t* arrayWeights = 0x0;
2267 Int_t iCountsRun = 0;
2268 Int_t nCounts = array->GetEntries();
2270 for(Int_t i = 0; i < nCounts; i++) {
2271 AliDCSValue* v = (AliDCSValue *)array->At(i);
2272 if ((v->GetUInt() < fminUInt) || (v->GetUInt() > fmaxUInt)) {
2273 AliError(Form("Error! UInt value found in DCS map at %d-th entry is OUT OF RANGE: value = %u",i,v->GetUInt()));
2274 return AliGRPObject::GetInvalidFloat();
2276 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2277 AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetUInt(),v->GetTimeStamp()));
2279 // look for the last value before SOR and the first value before EOR
2280 if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
2281 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
2282 AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
2283 valueBeforeSOR = (Float_t)v->GetUInt();
2285 else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
2286 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
2287 valueAfterEOR = (Float_t)v->GetUInt();
2288 AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
2290 // check if there are DPs between DAQ_time_start and DAQ_time_end
2291 if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
2292 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
2293 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
2294 AliDebug(2,Form("entry between SOR and EOR"));
2299 AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
2303 if (timestampBeforeSOR == -1){
2304 AliWarning("No value found before SOR!");
2306 if (timestampAfterEOR == -1){
2307 AliWarning("No value found after EOR!");
2310 AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
2311 AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2312 AliDebug(2,Form("First value after DAQ_time_end (EOR) = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2313 AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2314 AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2315 AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2317 Int_t nentriesUsed = 0;
2318 if (iCountsRun > 1){
2319 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2320 AliDebug(2,"Calculating (weighted) Mean");
2321 arrayValues = new Float_t[iCountsRun];
2322 arrayWeights = new Double_t[iCountsRun];
2323 nentriesUsed = iCountsRun;
2324 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2325 AliDCSValue *v = (AliDCSValue *)array->At(i);
2326 Int_t timestamp2 = 0;
2328 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2329 timestamp2 = (Int_t)v1->GetTimeStamp();
2332 timestamp2 = timeEnd+1;
2334 arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2335 arrayValues[i-ientrySOR] = (Float_t)v->GetUInt();
2337 aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2338 delete [] arrayValues;
2339 delete [] arrayWeights;
2341 else if (iCountsRun == 1){
2342 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2344 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2345 AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
2346 arrayValues = new Float_t[2];
2347 arrayWeights = new Double_t[2];
2348 arrayValues[0] = valueBeforeSOR;
2349 arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2350 arrayValues[1] = (Float_t)v->GetUInt();
2351 arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2352 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2353 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2354 aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
2355 delete [] arrayValues;
2356 delete [] arrayWeights;
2359 AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
2360 return AliGRPObject::GetInvalidFloat();
2363 else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
2364 if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
2365 if (timestampBeforeSOR == -1){
2366 AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
2368 if (timestampAfterEOR == -1){
2369 AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
2371 return AliGRPObject::GetInvalidFloat();
2374 AliWarning("Using last entry before SOR and first entry after EOR.");
2376 arrayValues = new Float_t[2];
2377 arrayWeights = new Double_t[2];
2378 arrayValues[0] = valueBeforeSOR;
2379 arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
2380 arrayValues[1] = valueAfterEOR;
2381 arrayWeights[1] = 1.;
2382 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2383 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2384 aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
2385 delete [] arrayValues;
2386 delete [] arrayWeights;
2390 AliInfo(Form("mean = %f ",aDCSArrayMean));
2391 return aDCSArrayMean;
2396 //_______________________________________________________________
2398 AliDCSSensorArray *AliGRPPreprocessor::GetPressureMap(TMap* dcsAliasMap)
2400 // extract DCS pressure maps. Perform fits to save space
2402 TMap *map = fPressure->ExtractDCS(dcsAliasMap);
2404 AliDebug(2,Form("Map has %d entries",map->GetEntries()));
2405 fPressure->MakeSplineFit(map);
2406 Double_t fitFraction = fPressure->NumFits()/fPressure->NumSensors();
2407 if (fitFraction > kFitFraction ) {
2408 AliInfo(Form("Pressure values extracted, %d fits performed for %d sensors.", fPressure->NumFits(),fPressure->NumSensors()));
2410 AliInfo("Too few pressure maps fitted!!!");
2413 AliInfo("no atmospheric pressure map extracted!!!");
2422 //_______________________________________________________________
2423 Int_t AliGRPPreprocessor::ReceivePromptRecoParameters(UInt_t run, const char* dbHost, Int_t dbPort, const char* dbName, const char* user, const char* password, const char *cdbRoot, TString &gdc)
2426 // Retrieves logbook and trigger information from the online logbook
2427 // This information is needed for prompt reconstruction
2431 // DAQ params: dbHost, dbPort, dbName, user, password, logbookTable, triggerTable
2435 // positive on success: the return code is the run number of last run processed of the same run type already processed by the SHUTTLE
2436 // 0 on success and no run was found
2437 // negative on error
2439 // This function is NOT called during the preprocessor run in the Shuttle!
2447 AliCDBManager* cdb = AliCDBManager::Instance();
2448 cdb->SetDefaultStorage(cdbRoot);
2451 TSQLServer* server = TSQLServer::Connect(Form("mysql://%s:%d/%s", dbHost, dbPort, dbName), user, password);
2455 Printf("ERROR: Could not connect to DAQ LB");
2461 sqlQuery.Form("SELECT DAQ_time_start, run_type, detectorMask, L3_magnetCurrent, Dipole_magnetCurrent,beamType FROM logbook WHERE run = %d", run);
2462 TSQLResult* result = server->Query(sqlQuery);
2465 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2469 if (result->GetRowCount() == 0)
2471 Printf("ERROR: Run %d not found", run);
2476 TSQLRow* row = result->Next();
2479 Printf("ERROR: Could not receive data from run %d", run);
2484 TString timeStartString(row->GetField(0));
2485 TString runType(row->GetField(1));
2486 TString detectorMaskString(row->GetField(2));
2487 TString l3CurrentString(row->GetField(3));
2488 TString dipoleCurrentString(row->GetField(4));
2489 TString beamTypeString(row->GetField(5));
2490 time_t timeStart = (time_t)(timeStartString.Atoi());
2491 UInt_t detectorMask = (UInt_t)(detectorMaskString.Atoi());
2492 Float_t l3Current = (Float_t)(TMath::Abs(l3CurrentString.Atof()));
2493 Float_t dipoleCurrent = (Float_t)(TMath::Abs(dipoleCurrentString.Atof()));
2494 Char_t l3Polarity = (l3CurrentString.Atof() < 0) ? 1 : 0;
2495 Char_t dipolePolarity = (dipoleCurrentString.Atof() < 0) ? 1 : 0;
2496 if (beamTypeString.CompareTo("Pb-Pb",TString::kIgnoreCase) == 0){
2497 beamTypeString="A-A";
2500 AliGRPObject * grpObj = new AliGRPObject();
2501 grpObj->SetTimeStart(timeStart);
2502 grpObj->SetRunType((TString)(row->GetField(1)));
2503 grpObj->SetDetectorMask(detectorMask);
2504 grpObj->SetL3Current(l3Current,(AliGRPObject::Stats)0);
2505 grpObj->SetDipoleCurrent(dipoleCurrent,(AliGRPObject::Stats)0);
2506 grpObj->SetL3Polarity(l3Polarity);
2507 grpObj->SetDipolePolarity(dipolePolarity);
2508 grpObj->SetPolarityConventionLHC(); // after the dipole cables swap we comply with LHC convention
2509 grpObj->SetBeamType(beamTypeString);
2517 Printf("Storing GRP/GRP/Data object with the following content");
2520 AliCDBMetaData metadata;
2521 metadata.SetResponsible("Jan Fiete Grosse-Oetringhaus & Chiara Zampolli");
2522 metadata.SetComment("GRP Output parameters received during online running");
2524 AliCDBId id("GRP/GRP/Data", run, run);
2525 Bool_t success = cdb->Put(grpObj, id, &metadata);
2531 Printf("ERROR: Could not store GRP/GRP/Data into OCDB");
2535 // Receive trigger information
2536 sqlQuery.Form("SELECT configFile FROM logbook_trigger_config WHERE run = %d", run);
2537 result = server->Query(sqlQuery);
2540 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2544 if (result->GetRowCount() == 0)
2546 Printf("ERROR: Run %d not found in logbook_trigger_config", run);
2551 row = result->Next();
2554 Printf("ERROR: Could not receive logbook_trigger_config data from run %d", run);
2559 TString triggerConfig(row->GetField(0));
2567 Printf("Found trigger configuration: %s", triggerConfig.Data());
2569 AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConfig);
2572 Printf("ERROR: Could not create CTP configuration object");
2576 metadata.SetComment("CTP run configuration received during online running");
2578 AliCDBId id2("GRP/CTP/Config", run, run);
2579 success = cdb->Put(runcfg, id2, &metadata);
2586 Printf("ERROR: Could not store GRP/CTP/Config into OCDB");
2591 // Receive list of GDCs for this run
2592 sqlQuery.Form("SELECT GDC FROM logbook_stats_GDC WHERE run = %d", run);
2593 result = server->Query(sqlQuery);
2596 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2600 if (result->GetRowCount() == 0)
2602 Printf("ERROR: Run %d not found in logbook_stats_GDC", run);
2608 for (Int_t iGDC = 0; iGDC < result->GetRowCount(); iGDC++) {
2609 row = result->Next();
2612 Printf("ERROR: Could not receive logbook_stats_GDC data from run %d", run);
2616 gdc += row->GetField(0);
2626 Printf("Found GDC: %s", gdc.Data());
2628 // get last run with same run type that was already processed by the SHUTTLE
2630 sqlQuery.Form("SELECT max(logbook.run) FROM logbook LEFT JOIN logbook_shuttle ON logbook_shuttle.run = logbook.run WHERE run_type = '%s' AND shuttle_done = 1", runType.Data());
2631 result = server->Query(sqlQuery);
2634 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2638 if (result->GetRowCount() == 0)
2640 Printf("ERROR: No result with query <%s>", sqlQuery.Data());
2645 row = result->Next();
2648 Printf("ERROR: Could not receive data for query <%s>", sqlQuery.Data());
2653 TString lastRunStr(row->GetField(0));
2654 Int_t lastRun = lastRunStr.Atoi();
2656 Printf("Last run with same run type %s is %d", runType.Data(), lastRun);
2670 //------------------------------------------------------------------------------------------------------
2671 Float_t AliGRPPreprocessor::ProcessEnergy(TObjArray* const array, Double_t timeStart){
2674 // Method to processo LHC Energy information
2675 // Only the first value is returned, provided that it is withing DAQ_time_start and DAQ_time_end
2678 Int_t nCounts = array->GetEntries();
2679 Float_t energy = -1;
2680 Double_t timeEnergy = -1;
2681 Int_t indexEnergy = -1;
2682 Bool_t foundEnergy = kFALSE;
2684 AliDebug(2,Form("Energy measurements = %d\n",nCounts));
2686 AliWarning("No Energy values found! Beam Energy remaining invalid!");
2689 for (Int_t i = 0; i < nCounts; i++){
2690 AliDCSArray *dcs = (AliDCSArray*)array->At(i);
2692 if (dcs->GetTimeStamp()<=timeStart && dcs->GetTimeStamp()>=timeEnergy){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
2693 timeEnergy = dcs->GetTimeStamp();
2695 foundEnergy = kTRUE;
2703 AliInfo("No value for the Energy found before start of run, the Energy will remain invalid");
2706 AliDCSArray* dcs = (AliDCSArray*)array->At(indexEnergy);
2707 energy = (Float_t)(TMath::Nint(((Double_t)(dcs->GetInt(0)))*120/1000)); // sqrt(s)/2 energy in GeV
2708 AliInfo(Form("Energy value found = %d (at %f), converting --> sqrt(s)/2 = %f (GeV)", dcs->GetInt(0),dcs->GetTimeStamp(),energy));
2714 //------------------------------------------------------------------------------------------------------
2715 AliLHCClockPhase* AliGRPPreprocessor::ProcessLHCClockPhase(TObjArray *beam1phase,TObjArray *beam2phase, Double_t timeEnd)
2718 // Method to process LHC-Clock Phase data
2719 // Only the values between DAQ_time_start and DAQ_time_end are kept
2721 AliLHCClockPhase *phaseObj = new AliLHCClockPhase;
2723 Bool_t foundBeam1Phase = kFALSE, foundBeam2Phase = kFALSE;
2724 const Float_t threshold = 0.050; // we store the measurement only in case they differ with more 50ps from the previous one
2726 TString timeCreatedStr = GetRunParameter("time_created");
2727 Double_t timeCreated = timeCreatedStr.Atof();
2729 Int_t nCounts = beam1phase->GetEntries();
2730 AliDebug(2,Form("Beam1 phase measurements = %d\n",nCounts));
2732 AliWarning("No beam1 LHC clock phase values found!");
2737 Double_t prevPhase = 0;
2738 for (Int_t i = 0; i < nCounts; i++){
2739 AliDCSArray *dcs = (AliDCSArray*)beam1phase->At(i);
2741 //if (dcs->GetTimeStamp()>=timeStart && dcs->GetTimeStamp()<=timeEnd) {
2742 if (dcs->GetTimeStamp()>=timeCreated && dcs->GetTimeStamp()<=timeEnd) {
2743 if ((i == 0) || (i == (nCounts-1)) ||
2745 (TMath::Abs(dcs->GetDouble(0)-prevPhase) > threshold)) {
2746 prevPhase = dcs->GetDouble(0);
2747 foundBeam1Phase = kTRUE;
2748 AliInfo(Form("B1 Clk Phase = %f at TS = %f",
2749 (Float_t)dcs->GetDouble(0),dcs->GetTimeStamp()));
2750 phaseObj->AddPhaseB1DP((UInt_t)dcs->GetTimeStamp(),(Float_t)dcs->GetDouble(0));
2755 if (!foundBeam1Phase){
2756 AliError("No beam1 LHC clock phase values found within the run!");
2762 nCounts = beam2phase->GetEntries();
2763 AliDebug(2,Form("Beam2 phase measurements = %d\n",nCounts));
2765 AliWarning("No beam2 LHC clock phase values found!");
2770 Double_t prevPhase = 0;
2771 for (Int_t i = 0; i < nCounts; i++){
2772 AliDCSArray *dcs = (AliDCSArray*)beam2phase->At(i);
2774 if (dcs->GetTimeStamp()>=timeCreated && dcs->GetTimeStamp()<=timeEnd) {
2775 if ((i == 0) || (i == (nCounts-1)) ||
2777 (TMath::Abs(dcs->GetDouble(0)-prevPhase) > threshold)) {
2778 prevPhase = dcs->GetDouble(0);
2779 foundBeam2Phase = kTRUE;
2780 AliInfo(Form("B2 Clk Phase = %f at TS = %f",
2781 (Float_t)dcs->GetDouble(0),dcs->GetTimeStamp()));
2782 phaseObj->AddPhaseB2DP((UInt_t)dcs->GetTimeStamp(),(Float_t)dcs->GetDouble(0));
2787 if (!foundBeam2Phase){
2788 AliError("No beam2 LHC clock phase values found within the run!");