added prediction processor framework and implementations; moved MUON preprocessors
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 30 Jul 2008 14:35:44 +0000 (14:35 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 30 Jul 2008 14:35:44 +0000 (14:35 +0000)
14 files changed:
HLT/libHLTpendolino.pkg [new file with mode: 0644]
HLT/pendolino/HLT/AliHLTPredicProcTempMonitor.cxx [new file with mode: 0644]
HLT/pendolino/HLT/AliHLTPredicProcTempMonitor.h [new file with mode: 0644]
HLT/pendolino/HLT/AliHLTPredictionProcessorHLT.cxx [new file with mode: 0644]
HLT/pendolino/HLT/AliHLTPredictionProcessorHLT.h [new file with mode: 0644]
HLT/pendolino/MUON/AliHLTPredictionProcessorMCH.cxx [new file with mode: 0644]
HLT/pendolino/MUON/AliHLTPredictionProcessorMCH.h [new file with mode: 0644]
HLT/pendolino/MUON/AliHLTPredictionProcessorMTR.cxx [new file with mode: 0644]
HLT/pendolino/MUON/AliHLTPredictionProcessorMTR.h [new file with mode: 0644]
HLT/pendolino/Makefile.am
HLT/pendolino/TPC/AliHLTDCSArray.cxx [new file with mode: 0644]
HLT/pendolino/TPC/AliHLTDCSArray.h [new file with mode: 0644]
HLT/pendolino/TPC/AliHLTPredictionProcessorTPC.cxx [new file with mode: 0644]
HLT/pendolino/TPC/AliHLTPredictionProcessorTPC.h [new file with mode: 0644]

diff --git a/HLT/libHLTpendolino.pkg b/HLT/libHLTpendolino.pkg
new file mode 100644 (file)
index 0000000..2b5f7a1
--- /dev/null
@@ -0,0 +1,38 @@
+#-*- Mode: Makefile -*-
+# $Id$
+
+CLASS_HDRS:=   AliHLTPredictionProcessorInterface.h \
+               AliHLTPendolino.h \
+               AliHLTPendolinoLoggerOStream.h \
+               AliHLTPredictionProcessorDummy.h \
+               AliHLTPendolinoLoggerDump.h \
+               HLT/AliHLTPredicProcTempMonitor.h \
+               HLT/AliHLTPredictionProcessorHLT.h \
+               MUON/AliHLTPredictionProcessorMCH.h \
+               MUON/AliHLTPredictionProcessorMTR.h \
+               TPC/AliHLTDCSArray.h \
+               TPC/AliHLTPredictionProcessorTPC.h
+
+MODULE_SRCS:=  $(CLASS_HDRS:.h=.cxx)
+
+MODULE_HDRS:=  $(CLASS_HDRS)
+
+MODULE_DHDR:=          
+
+EINCLUDE := HLT/pendolino HLT/BASE STEER
+
+LIBRARY_DEP := -lHLTbase
+
+include $(MODDIR)/hlt.conf
+
+SRCS:=$(patsubst %,pendolino/%,$(MODULE_SRCS))
+CINTHDRS:=$(patsubst %,pendolino/%,$(CLASS_HDRS))
+HDRS:=$(patsubst %,pendolino/%,$(MODULE_HDRS))
+DHDR:=$(patsubst %,pendolino/%,$(MODULE_DHDR))
+CINTAUTOLINK:= $(shell test "x$(MODULE_DHDR)" = "x" && echo 1)
+
+EDEFINE      := ${HLTDEFS}
+PACKCXXFLAGS := ${HLTCXXFLAGS} -DLIBHLTREC_VERSION=$(LIBHLTPENDOLINO_VERSION)
+PACKCFLAGS   := ${HLTCLFAGS}
+PACKDCXXFLAGS:= ${HLTDCXXFLAGS}
+PACKSOFLAGS  := $(HLTSOFLAGS)
diff --git a/HLT/pendolino/HLT/AliHLTPredicProcTempMonitor.cxx b/HLT/pendolino/HLT/AliHLTPredicProcTempMonitor.cxx
new file mode 100644 (file)
index 0000000..ac0152f
--- /dev/null
@@ -0,0 +1,237 @@
+// $Id$
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Sebastian Bablok <Sebastian.Bablok@ift.uib.no>        *
+//*                  for The ALICE HLT Project.                            *
+//*                                                                        *
+//* Permission to use, copy, modify and distribute this software and its   *
+//* documentation strictly for non-commercial purposes is hereby granted   *
+//* without fee, provided that the above copyright notice appears in all   *
+//* copies and that both the copyright notice and this permission notice   *
+//* appear in the supporting documentation. The authors make no claims     *
+//* about the suitability of this software for any purpose. It is          *
+//* provided "as is" without express or implied warranty.                  *
+//**************************************************************************
+
+/** @file   AliHLTPredicProcTempMonitor.cxx
+    @author Sebastian Bablok
+    @date   
+    @brief  
+*/
+
+#include "AliHLTPredicProcTempMonitor.h"
+
+#include <AliCDBMetaData.h>
+#include <AliCDBEntry.h>
+#include <AliDCSValue.h>
+
+#include <TMap.h>
+#include <TObjString.h>
+#include <TObjArray.h>
+
+#include <TTimeStamp.h>
+
+
+ClassImp(AliHLTPredicProcTempMonitor)
+
+
+const TString AliHLTPredicProcTempMonitor::kPath2("CalibMonitor");
+
+const TString AliHLTPredicProcTempMonitor::kPath3("DCSTempMon");
+
+const TString AliHLTPredicProcTempMonitor::kCreator("S. Bablok (HLT)");
+
+const TString AliHLTPredicProcTempMonitor::kComment("Calib Object for monitoring DCS temperature values in HLT.");
+
+const TString AliHLTPredicProcTempMonitor::kAliRootVersion("");
+
+const UInt_t AliHLTPredicProcTempMonitor::kUnableToStoreObject = 7;
+
+//const TString AliHLTPredicProcTempMonitor::kAmandaTempSensor = "TPC_PT_%d_TEMPERATURE";
+
+               
+AliHLTPredicProcTempMonitor::AliHLTPredicProcTempMonitor(
+                       const char* detector, AliHLTPendolino* pendolino) :
+                               AliHLTPredictionProcessorInterface(detector, pendolino) {
+       // C-tor for AliHLTPredicProcTempMonitor
+       mPredict = true;
+       mRun = 0;
+       mStartTime = 0;
+       mEndTime = 0;
+}
+
+
+AliHLTPredicProcTempMonitor::~AliHLTPredicProcTempMonitor() {
+       // D-tor for AliHLTPredicProcTempMonitor
+
+}
+
+
+UInt_t AliHLTPredicProcTempMonitor::makePrediction(Bool_t doPrediction) {
+       // switch for prediction making in AliHLTPredicProcTempMonitor
+       Log("AliHLTPredicProcTempMonitor + B-Field extractor: prediction switched on");
+       mPredict = doPrediction;
+       return 0;
+}
+
+
+void AliHLTPredicProcTempMonitor::Initialize(Int_t run, UInt_t startTime, 
+                       UInt_t endTime) {
+       // initializes AliHLTPredicProcTempMonitor
+       mRun = run;
+       mStartTime = startTime;
+       mEndTime = endTime;
+
+       TString msg("Initialized HLT PredictionProcessor; Run: ");
+       msg += mRun;
+       msg += ", start time: ";
+       msg += mStartTime;
+       msg += ", end time: ";
+       msg += mEndTime;
+       msg += ".";     
+       Log(msg.Data());
+}
+
+
+UInt_t AliHLTPredicProcTempMonitor::Process(TMap* dcsAliasMap) {
+       // processes the DCS value map in AliHLTPredicProcTempMonitor
+       UInt_t beamPeriod = 0;
+       
+       UInt_t retVal = 0;
+       UInt_t tempRet = 0;
+       Int_t start = 0;
+       TMap* tempMap = 0;
+       Bool_t infiniteValid = kFALSE;
+       
+               
+       //test GetFromOCDB() calls
+       AliCDBEntry* entry = GetFromOCDB(kPath2.Data(), kPath3.Data());
+       if (entry == 0) {
+               // No object in HCDB -> discarding old values
+               TString msg("No '" + kPath2 + "/" + kPath3 + 
+                               "' in HCDB, most likely first round, filling object now...");
+               Log(msg.Data());
+               tempMap = dcsAliasMap;
+               
+       } else {
+               Log("Old data is already stored in HCDB, but now discarding that...");
+               tempMap = dcsAliasMap; 
+       
+// If old data shall be included use lines below and uncomment lines above
+/*
+               Log("Adding new DCS value to old Temperature map...");
+               // Adding new DCS values to old Temperature map 
+               tempMap = (TMap*) entry->GetObject();
+
+               TMapIter iter(dcsAliasMap);        // iterator for values in TMap
+               TObject* aKey;
+                          
+               while ((aKey = iter.Next())) {
+                       tempMap->Add(aKey, dcsAliasMap->GetValue(aKey));
+               }
+*/
+       }
+
+       AliCDBMetaData meta(kCreator.Data(), beamPeriod, kAliRootVersion.Data(), 
+                       kComment.Data());
+
+       if (Store(kPath2.Data(), kPath3.Data(), (TObject*) tempMap, &meta, start, 
+                       infiniteValid)) {
+               TString msg(" +++ Successfully stored object '" + kPath2 + "/" + kPath3 + 
+                               "' in HCDB.");
+               Log(msg.Data());
+       } else {
+               TString msg(" *** Storing of object '" + kPath2 + "/" + kPath3 + 
+                               "' in HCDB failed.");
+               Log(msg.Data());
+               retVal = kUnableToStoreObject;
+       }
+
+       // extract B-Field
+       tempRet = ExtractBField(dcsAliasMap);
+       retVal = tempRet & retVal; // combine retvals
+       
+       return retVal;
+}
+
+UInt_t AliHLTPredicProcTempMonitor::ExtractBField(TMap* dcsAliasMap) {
+       // extracts the B-field value from DCS value map
+  
+       TString stringId = "dcs_magnet:Magnet/ALICESolenoid.Current";
+  
+       Float_t BField = 0; 
+       Bool_t bRet = GetSensorValue(dcsAliasMap,stringId.Data(),&BField);
+
+       if (bRet) {
+               BField = BField / 60000; // If we get field, take this away and change SensorValue
+               TString dummy("-bfield ");
+               dummy += BField;
+               TObjString dummy2(dummy.Data());
+               mBField = dummy2; 
+               Log(Form("BField set to %s", mBField.String().Data())); 
+       } else {
+               return 1;
+       }
+
+       TString path2("Config");
+       TString path3("BField");
+       Int_t start = 0;
+
+       TString comment("BField");
+       AliCDBMetaData meta(this->GetName(), 0, "unknownAliRoot", comment.Data());
+  
+       if (Store(path2.Data(), path3.Data(), (TObject*) (&mBField), &meta, start, 
+                       kTRUE)) {
+               Log(" +++ Successfully stored object ;-)");
+       } else {
+               Log(" *** Storing of OBJECT failed!!");
+               return 7;
+       }
+
+       return 0;
+}
+
+Bool_t AliHLTPredicProcTempMonitor::GetSensorValue(TMap* dcsAliasMap,
+                       const char* stringId, Float_t *value) {
+       // retreives the sensor value
+  // return last value read from sensor specified by stringId
+  
+       TObjArray* valueSet;
+       TPair* pair = (TPair*) (dcsAliasMap->FindObject(stringId));
+       if (pair) {
+               valueSet = (TObjArray*) (pair->Value());
+               if (valueSet) {
+                       Int_t nentriesDCS = (valueSet->GetEntriesFast()) - 1;
+                       if (nentriesDCS >= 0) {
+                               AliDCSValue* val = (AliDCSValue*) (valueSet->At(nentriesDCS));
+                               if (val) {
+                                       *value = val->GetFloat();
+                                       return kTRUE;
+                               }
+                       }
+               }
+       }
+       return kFALSE;
+}
+
+TMap* AliHLTPredicProcTempMonitor::produceTestData(TString aliasName) {
+       // produces test data for AliHLTPredicProcTempMonitor
+    TMap* resultMap = 0;
+
+    // here has to come real dummy data :-)
+    resultMap = new TMap();
+    TTimeStamp tt;
+       Float_t fval = 33.3;
+    TObjString* name = new TObjString("DummyData");
+    AliDCSValue* val = new AliDCSValue(fval, tt.GetTime());
+    TObjArray* arr = new TObjArray();
+    arr->Add(val);
+    resultMap->Add(name, arr);
+
+    return resultMap;
+}
+
+
diff --git a/HLT/pendolino/HLT/AliHLTPredicProcTempMonitor.h b/HLT/pendolino/HLT/AliHLTPredicProcTempMonitor.h
new file mode 100644 (file)
index 0000000..11ceb41
--- /dev/null
@@ -0,0 +1,224 @@
+//-*- Mode: C++ -*-
+// $Id$
+
+#ifndef ALI_HLT_PREDICT_PROC_TEMP_MONITOR_H
+#define ALI_HLT_PREDICT_PROC_TEMP_MONITOR_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+/** @file   AliHLTPredicProcTempMonitor.h
+    @author Sebastian Bablok
+    @date   
+    @brief  
+*/
+
+#include "AliHLTPredictionProcessorInterface.h"
+
+#include <TObjString.h>
+
+
+/**
+ * Implementation of an AliHLTPredictionProcessor for monitoring DCS 
+ * Temperatur values inside the HLT. 
+ *
+ * @author Sebastian Bablok
+ * @author Gaute Oevrebekk (extention for B-Field)
+ *
+ * @date 2007-12-03
+ * @date 2008-03-04
+ */
+class AliHLTPredicProcTempMonitor : public AliHLTPredictionProcessorInterface {
+    public:
+
+               /** Static const defining path part 2 */
+               static const TString kPath2; // defining path part 2
+               /** Static const defining path part 3 */
+               static const TString kPath3; //defining path part 3
+               /** Static const defining creator of HCDB object */
+               static const TString kCreator; // defining creator of HCDB object
+               /** Static const defining comment for HCDB object */
+               static const TString kComment; // defining comment for HCDB object
+               /** Static const defining aliroot version */
+               static const TString kAliRootVersion; // defining aliroot version
+               /** Static const defining error ret val for storage error */
+               static const UInt_t kUnableToStoreObject; // defining error ret val for storage error
+//             static const TString kAmandaTempSensor;
+       
+               /**
+                * Constructor for AliHLTPredictionProcessorDummy
+                *
+                * @param detector string defining the detector to which the 
+                *                      PredictionProcessor belongs to
+                * @param pendolino pointer to the hosting pendolino (derived from 
+                *                      AliShuttleInterface)
+                */
+               AliHLTPredicProcTempMonitor(const char* detector, 
+                                               AliHLTPendolino* pendolino);
+
+               /**
+                * Destructor for AliHLTPredictionProcessorDummy
+                */
+               virtual ~AliHLTPredicProcTempMonitor();
+               
+               /**
+                * Pure virtual function to force the Prediction Processor to implement
+                * a function to flag that prediction making is required.
+                * This function is called by the Pendolino before the fetched DCS data
+                * is handed in for (prediction) processing.
+                *
+                * @param doPrediction if true, prediction making shall be switched on,
+                *                      if false, switched off.
+                * 
+                * @return 0 on success; a value greater than 0 refers to an error
+                */
+               virtual UInt_t makePrediction(Bool_t doPrediction = true);
+
+               /**
+                * Pure Virtual function, implemented in the detector specific 
+                * PredictionProcessors to initialize them.
+                *
+                * @param run run number
+                * @param startTime start time of data
+                * @param endTime end time of data
+                */
+               virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
+
+               /**
+                * Function called by the Pendolino for each participating subdetector
+                * producing the required condition settings. This includes the 
+                * encoding of a prediction to the values due to the fact, that only 
+                * data up to now can be fetched from DCS (the latest data can also be 
+                * up to 2 min old until it is received on HLT side). To write the data
+                * to the HCDB, the detector specific implementation of this class has 
+                * to call the appropriated storing function provided by the interface.
+                *
+                * @param dcsAliasMap the map containing aliases and corresponding DCS
+                *                      values and timestamps
+                *
+                * @return 0 on success; a value greater than 0 refers to an error
+                */
+               virtual UInt_t Process(TMap* dcsAliasMap);
+
+               /**
+                * Indicates if DCS data shall be processed.
+                * NOTE: should always return true, since it is used as prediction 
+                * processor, which will only process DCS data
+                *
+                * @return true if DCS data can be processed, else false. Note: if false
+                *                              the Pendolino would stop, so make sure that it is true.
+                */
+               virtual Bool_t ProcessDCS();
+
+        /**
+         * Function to let the PredictionProcessor produce dummy input data,
+         * that can be used in Pendolino tests, where no DCS Archieve DB is
+         * contacted. This function is called by the Pendolino, the result is
+         * given back to the PredictionProcessor via the Process(...) call.
+         * Since the DCSMaps requested from DCS are detector specific, the
+         * PredictionProcessor should know, how the maps look like, that it
+         * expects.
+         * NOTE: The clean - up (delete) of the TMap will be performed by the
+         * Pendolino after the usage. The PredictionProcessor has never to
+         * call delete on the returned TMap pointer.
+         *
+         * @param aliasName optional parameter, that can be given in order to
+         *          create a DCSMap for dedicated aliases. For a general test
+         *          this paramter should be empty. If more than one alias name
+         *          shall be specified, they are separated by blanks " ".
+         *
+         * @return DCSMap containing dummy data for testing the Pendolino.
+         */
+        virtual TMap* produceTestData(TString aliasName = "");
+
+
+       protected:
+               
+               /**
+                * Function to extract the B-Field from the DCS map.
+                *
+                * @param dcsAliasMap the DCS map, containing the AliDCSValues
+                *
+                * @return 0 in case of success, else an error code
+                */
+               UInt_t ExtractBField(TMap* dcsAliasMap);
+
+               /**
+                * Function to extract a float AliDCSValue by its name from the DCS map
+                *
+                * @param dcsAliasMap the DCS value map
+                * @param stringId the name of the desired AliDCSValue - float
+                * @param value pointer to a float, where the extratced value shall be stored
+                *                              (out parameter)
+                * 
+                * @return true in case of success, else false
+                */
+               Bool_t GetSensorValue(TMap* dcsAliasMap, const char* stringId, 
+                                               Float_t* value);
+               
+       private:
+               /**
+                * Disabled Copy constructor 
+                * (parent class is disabled so derived class does the same)
+                */
+               AliHLTPredicProcTempMonitor(
+                                               const AliHLTPredicProcTempMonitor& predictPro);
+
+               /**
+                * Disabled Assignment operator
+                * (parent class is disabled so derived class does the same)
+                */
+               AliHLTPredicProcTempMonitor& operator=(
+                                               const AliHLTPredicProcTempMonitor& rhs);
+
+
+               /**
+                * Function to extract the actual values from the DCSMap
+                *
+                * @param inputMap pointer to the DCSMap as input
+                * @param outputMap pointer to the Map where to store the extracted 
+                *                      values
+                *
+                * @return true in case of success, else false
+                */
+//             Bool_t extractTempvalues(TMap* inputMap, TMap* outputMap);
+
+               /**
+                * Stores if prediction shall be made
+                */
+               Bool_t mPredict;  // flag for prediction making
+
+               /**
+                * Stores the run number
+                */
+               Int_t mRun;  //  Stores the run number
+       
+               /**
+                * Stores the start time of the to process DCS data
+                */     
+               UInt_t mStartTime; // Stores the start time of the to process DCS data
+       
+               /**
+                * Stores the end time of the to process DCS data
+                */     
+               UInt_t mEndTime;  // Stores the end time of the to process DCS data
+
+               /**
+                * Stores the extracted B-Field in a TObjString
+                */
+               TObjString mBField;  // Stores the extracted B-Field in a TObjString
+
+               /** ClassDef of AliHLTPredicProcTempMonitor for AliRoot */
+               ClassDef(AliHLTPredicProcTempMonitor, 2);
+       
+};
+
+
+inline Bool_t AliHLTPredicProcTempMonitor::ProcessDCS() {
+       // indicates if DCS values are processed; always true
+       return true;
+}
+
+#endif
+
+
diff --git a/HLT/pendolino/HLT/AliHLTPredictionProcessorHLT.cxx b/HLT/pendolino/HLT/AliHLTPredictionProcessorHLT.cxx
new file mode 100644 (file)
index 0000000..1807ffc
--- /dev/null
@@ -0,0 +1,184 @@
+// $Id$
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Gaute Ovrebekk                                        *
+//*                  for The ALICE HLT Project.                            *
+//*                                                                        *
+//* Permission to use, copy, modify and distribute this software and its   *
+//* documentation strictly for non-commercial purposes is hereby granted   *
+//* without fee, provided that the above copyright notice appears in all   *
+//* copies and that both the copyright notice and this permission notice   *
+//* appear in the supporting documentation. The authors make no claims     *
+//* about the suitability of this software for any purpose. It is          *
+//* provided "as is" without express or implied warranty.                  *
+//**************************************************************************
+
+/** @file   AliHLTPredictionProcessorHLT.cxx
+    @author Gaute Ovrebekk
+    @date   
+    @brief  
+*/
+
+#include "AliHLTPredictionProcessorHLT.h"
+
+#include <AliCDBMetaData.h>
+#include <AliCDBEntry.h>
+
+// new
+#include <TObjArray.h>
+#include <AliDCSValue.h>
+
+#include <TTimeStamp.h>
+#include <TObjString.h>
+
+
+ClassImp(AliHLTPredictionProcessorHLT)
+
+AliHLTPredictionProcessorHLT::AliHLTPredictionProcessorHLT(
+                       const char* detector, AliHLTPendolino* pendolino) :
+                               AliHLTPredictionProcessorInterface(detector, pendolino) {
+       // C-tor for AliHLTPredictionProcessorHLT
+       mPredict = false;
+       mRun = 0;
+       mStartTime = 0;
+       mEndTime = 0;
+       mBField = 0;
+}
+
+
+AliHLTPredictionProcessorHLT::~AliHLTPredictionProcessorHLT() {
+       // D-tor for AliHLTPredictionProcessorHLT
+}
+
+
+UInt_t AliHLTPredictionProcessorHLT::makePrediction(Bool_t doPrediction) {
+       // switch for prediction making
+       Log("Prediction switched on");
+       mPredict = doPrediction;
+       return 0;
+}
+
+
+void AliHLTPredictionProcessorHLT::Initialize(Int_t run, UInt_t startTime, 
+                       UInt_t endTime) {
+       // initializes AliHLTPredictionProcessorHLT
+       mRun = run;
+       mStartTime = startTime;
+       mEndTime = endTime;
+
+       TString msg("Initialized HLT PredictProc. Run: ");
+       msg += mRun;
+       msg += ", start time: ";
+       msg += mStartTime;
+       msg += ", end time: ";
+       msg += mEndTime;
+       msg += ".";     
+       Log(msg.Data());
+
+       if (mPredict) {
+               Log("HLT PredictProc has prediction switched ON.");
+       } else {
+               Log("Prediction is switched OFF.");
+       }
+}
+
+
+UInt_t AliHLTPredictionProcessorHLT::Process(TMap* dcsAliasMap) {
+       // processes the DCS value map
+  
+  if (!dcsAliasMap) return 9;
+  if (dcsAliasMap->GetEntries() == 0 ) return 9;
+
+  UInt_t retVal = 0;
+  Int_t start = 0;
+  TString path2("ConfigHLT"); // "Config" 
+  TString path3("SolenoidBz"); // "BField"
+  
+  UInt_t BFieldResult = ExtractBField(dcsAliasMap);
+
+  if (BFieldResult != 0) {
+       Log(" *** Extraction of BField failed - no entry for HCDB!!");
+       return 8;
+  }
+
+
+  //transform dcsAliasMap to ROOT object 
+  TString comment("BField");
+  AliCDBMetaData meta(this->GetName(), 0, "unknownAliRoot",comment.Data());
+  
+  if (Store(path2.Data(),path3.Data(),(TObject*) &mBField,&meta,start,kTRUE)) {
+    Log(" +++ Successfully stored object ;-)");
+  } else {
+    Log(" *** Storing of OBJECT failed!!");
+    retVal = 7;
+  }
+  
+  return retVal;
+}
+
+UInt_t AliHLTPredictionProcessorHLT::ExtractBField(TMap* dcsAliasMap){
+  // extracts the b-field from DCS value map
+//  TString stringId = "dcs_magnet:Magnet/ALICESolenoid.Current"; // old name
+       TString stringId = "L3Current";
+  
+  Float_t BField = 0; 
+  Bool_t bRet = GetSensorValue(dcsAliasMap,stringId.Data(),&BField);
+
+  if(bRet){
+       // new   
+    BField = BField/60000; // If we get field, take this away and change SensorValue
+    TString dummy("-solenoidBz");
+    dummy += BField;
+    TObjString dummy2(dummy.Data());
+    mBField = dummy2;
+       
+    Log(Form("BField set to %s",mBField.String().Data()));
+    return 0; 
+  }
+  
+  return 1;
+
+}
+
+Bool_t AliHLTPredictionProcessorHLT::GetSensorValue(TMap* dcsAliasMap,
+                                                         const char* stringId, Float_t *value)
+{
+       // extracts the sensor value
+  // return last value read from sensor specified by stringId
+  
+  TObjArray* valueSet;
+  TPair* pair = (TPair*)dcsAliasMap->FindObject(stringId);
+  if (pair) {
+    valueSet = (TObjArray*)pair->Value();
+    Int_t nentriesDCS = valueSet->GetEntriesFast() - 1;
+    if(nentriesDCS>=0){
+       AliDCSValue *val = (AliDCSValue *)valueSet->At(nentriesDCS);
+       //new
+       *value=val->GetFloat();
+       return kTRUE;
+    }
+  }
+  return kFALSE;
+}
+
+TMap* AliHLTPredictionProcessorHLT::produceTestData(TString aliasName) {
+       // produces test data for AliHLTPredictionProcessorHLT
+    TMap* resultMap = 0;
+
+    // here has to come real dummy data :-)
+    resultMap = new TMap();
+    TTimeStamp tt;
+       Float_t fval = 33.3;
+    TObjString* name = new TObjString("DummyData");
+    AliDCSValue* val = new AliDCSValue(fval, tt.GetTime());
+    TObjArray* arr = new TObjArray();
+    arr->Add(val);
+    resultMap->Add(name, arr);
+
+    return resultMap;
+}
+
+
diff --git a/HLT/pendolino/HLT/AliHLTPredictionProcessorHLT.h b/HLT/pendolino/HLT/AliHLTPredictionProcessorHLT.h
new file mode 100644 (file)
index 0000000..2ce6c2f
--- /dev/null
@@ -0,0 +1,194 @@
+//-*- Mode: C++ -*-
+// $Id$
+
+#ifndef ALI_HLT_PREDICTION_PROCESSOR_HLT_H
+#define ALI_HLT_PREDICTION_PROCESSOR_HLT_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+/** @file   AliHLTPredictionProcessorHLT.h
+    @author Gaute Ovrebekk
+    @date   
+    @brief  
+*/
+
+#include "AliHLTPredictionProcessorInterface.h"
+
+//new
+#include <TObjString.h>
+
+
+/**
+ * Predition Processor for prepering b-field values for general HLT components. 
+ *
+ * @author Sebastian Bablok, Gaute Ovrebekk
+ *
+ * @date 2007-10-24
+ */
+class AliHLTPredictionProcessorHLT : public AliHLTPredictionProcessorInterface {
+    public:
+       
+               /**
+                * Constructor for AliHLTPredictionProcessorHLT
+                *
+                * @param detector string defining the detector to which the 
+                *                      PredictionProcessor belongs to
+                * @param pendolino pointer to the hosting pendolino (derived from 
+                *                      AliShuttleInterface)
+                */
+               AliHLTPredictionProcessorHLT(const char* detector, 
+                                               AliHLTPendolino* pendolino);
+
+               /**
+                * Destructor for AliHLTPredictionProcessorHLT
+                */
+               virtual ~AliHLTPredictionProcessorHLT();
+               
+               /**
+                * Virtual function to force the Prediction Processor to implement
+                * a function to flag that prediction making is required.
+                * This function is called by the Pendolino before the fetched DCS data
+                * is handed in for (prediction) processing.
+                *
+                * @param doPrediction if true, prediction making shall be switched on,
+                *                      if false, switched off.
+                * 
+                * @return 0 on success; a value greater than 0 refers to an error
+                */
+               virtual UInt_t makePrediction(Bool_t doPrediction = true);
+
+               /**
+                * Virtual function, implemented in the detector specific 
+                * PredictionProcessors to initialize them.
+                *
+                * @param run run number
+                * @param startTime start time of data
+                * @param endTime end time of data
+                */
+               virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
+
+               /**
+                * Function called by the Pendolino for each participating subdetector
+                * producing the required condition settings. This includes the 
+                * encoding of a prediction to the values due to the fact, that only 
+                * data up to now can be fetched from DCS (the latest data can also be 
+                * up to 2 min old until it is received on HLT side). To write the data
+                * to the HCDB, the detector specific implementation of this class has 
+                * to call the appropriated storing function provided by the interface.
+                *
+                * @param dcsAliasMap the map containing aliases and corresponding DCS
+                *                      values and timestamps
+                *
+                * @return 0 on success; a value greater than 0 refers to an error
+                */
+               virtual UInt_t Process(TMap* dcsAliasMap);
+
+               /**
+                * Indicates if DCS data shall be processed.
+                * NOTE: should always return true, since it is used as prediction 
+                * processor, which will only process DCS data
+                *
+                * @return true if DCS data can be processed, else false. Note: if false
+                *                              the Pendolino would stop, so make sure that it is true.
+                */
+               virtual Bool_t ProcessDCS();
+
+        /**
+         * Function to let the PredictionProcessor produce dummy input data,
+         * that can be used in Pendolino tests, where no DCS Archieve DB is
+         * contacted. This function is called by the Pendolino, the result is
+         * given back to the PredictionProcessor via the Process(...) call.
+         * Since the DCSMaps requested from DCS are detector specific, the
+         * PredictionProcessor should know, how the maps look like, that it
+         * expects.
+         * NOTE: The clean - up (delete) of the TMap will be performed by the
+         * Pendolino after the usage. The PredictionProcessor has never to
+         * call delete on the returned TMap pointer.
+         *
+         * @param aliasName optional parameter, that can be given in order to
+         *          create a DCSMap for dedicated aliases. For a general test
+         *          this paramter should be empty. If more than one alias name
+         *          shall be specified, they are separated by blanks " ".
+         *
+         * @return DCSMap containing dummy data for testing the Pendolino.
+         */
+        virtual TMap* produceTestData(TString aliasName = "");
+
+
+        protected:
+
+       private:
+               /**
+                * Disabled Copy constructor 
+                * (parent class is disabled so derived class does the same)
+                */
+               AliHLTPredictionProcessorHLT(
+                                               const AliHLTPredictionProcessorHLT& predictPro);
+
+               /**
+                * Disabled Assignment operator
+                * (parent class is disabled so derived class does the same)
+                */
+               AliHLTPredictionProcessorHLT& operator=(
+                                               const AliHLTPredictionProcessorHLT& rhs);
+
+
+               /**
+                * TObjstring which stores the B-field value
+                */
+               TObjString mBField;  // TObjstring which stores the B-field value
+
+               /**
+                * Stores if prediction shall be made
+                */
+               Bool_t mPredict;  // flag for prediction making
+
+               /**
+                * Stores the run number
+                */
+               Int_t mRun;  // Stores the run number
+       
+               /**
+                * Stores the start time of the to process DCS data
+                */     
+               UInt_t mStartTime;  // Stores the start time of the to process DCS data
+       
+               /**
+                * Stores the end time of the to process DCS data
+                */     
+               UInt_t mEndTime;  // Stores the end time of the to process DCS data
+
+               /**
+                * Function to extract the B-field from the DCS value map
+                *
+                * @param dcsAliasMap the retrieved DCS value map
+                *
+                * @return 0 on sucess else an error code
+                */
+               UInt_t ExtractBField(TMap* dcsAliasMap);
+
+               /**
+                * Function to rertieve a sensor value from the DCS value map
+                *
+                * @param dcsAliasMap the retrieved DCS value map
+                * @param stringId the alias name of the desired sensor value
+                * @param value [return parameter] - the extracted sensor value
+                *
+                * @return true if sucessful, else false
+                */
+               Bool_t GetSensorValue(TMap* dcsAliasMap,const char* stringId, Float_t * value);
+               
+               ClassDef(AliHLTPredictionProcessorHLT, 0);
+       
+};
+
+
+inline Bool_t AliHLTPredictionProcessorHLT::ProcessDCS() {
+       // indicates if DCS values are processed; always true
+       return true;
+}
+
+#endif
+
+
diff --git a/HLT/pendolino/MUON/AliHLTPredictionProcessorMCH.cxx b/HLT/pendolino/MUON/AliHLTPredictionProcessorMCH.cxx
new file mode 100644 (file)
index 0000000..0108524
--- /dev/null
@@ -0,0 +1,133 @@
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Authors:                                                       *
+ *   Artur Szostak <artursz@iafrica.com>                                  *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          * 
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+///
+///  @file   AliHLTPredictionProcessorMCH.cxx
+///  @author Artur Szostak <artursz@iafrica.com>
+///  @date   
+///  @brief  Implementation of the AliHLTPredictionProcessorMCH class.
+///
+
+#include "AliHLTPredictionProcessorMCH.h"
+#include "AliCDBMetaData.h"
+#include "AliCDBEntry.h"
+#include <cstdlib>
+
+#include <TTimeStamp.h>
+#include <TObjString.h>
+#include <TObjArray.h>
+#include <AliDCSValue.h>
+
+ClassImp(AliHLTPredictionProcessorMCH);
+
+
+AliHLTPredictionProcessorMCH::AliHLTPredictionProcessorMCH(
+               const char* detector, AliHLTPendolino* pendolino
+       ) :
+       AliHLTPredictionProcessorInterface(detector, pendolino),
+       fPredict(kTRUE)
+{
+       /// The class constructor for the preprocessor.
+       /// @param detector  The detector name, which must be "MCH".
+       /// @param pendolino A valid pointer to the pendolino instance.
+       
+       if (strcmp(detector, "MCH") != 0)
+       {
+               Log(Form("Warning: Setting the detector name to an incorrect value = '%s'."
+                   " It must be set to 'MCH'.", detector)
+               );
+       }
+}
+
+
+AliHLTPredictionProcessorMCH::~AliHLTPredictionProcessorMCH()
+{
+       /// Default destructor.
+}
+
+
+UInt_t AliHLTPredictionProcessorMCH::makePrediction(Bool_t doPrediction)
+{
+       /// This function is called by the Pendolino before the fetched DCS data
+       /// is handed in for (prediction) processing.
+       ///
+       /// @param doPrediction If true then preprocessed data will be extrapolated
+       ///           to the current time. Otherwise no extrapolation will be
+       ///           performed if false. The default is to perform extrapolations.
+       ///
+       /// @return Currently always returns 0 for success.
+
+       fPredict = doPrediction;
+       return 0;
+}
+
+
+void AliHLTPredictionProcessorMCH::Initialize(
+               Int_t run, UInt_t startTime, UInt_t endTime
+       )
+{
+       /// Performs initialisation of the preprocessor.
+       /// At the moment just basic sanity checks are performed.
+       ///
+       /// @param run The current run number.
+       /// @param startTime The start time (earliest timestamp) of the data.
+       /// @param endTime The end time (latest timestamp) of the data.
+       
+       if (startTime > endTime)
+               Log("Error: start time is greater than end time.");
+       
+       AliPreprocessor::Initialize(run, startTime, endTime);
+
+       if (fPredict)
+               Log("Prediction is switched ON.");
+       else
+               Log("Prediction is switched OFF.");
+}
+
+
+UInt_t AliHLTPredictionProcessorMCH::Process(TMap* dcsAliasMap)
+{
+       /// Process the DCS values.
+       /// At the moment nothing is done here.
+       ///
+       /// @param dcsAliasMap The map containing aliases and corresponding DCS
+       ///                    values and timestamps
+       ///
+       /// @return At the moment 0 is always returned for success.
+       
+       Log("Processing MCH");
+       return 0;
+}
+
+TMap* AliHLTPredictionProcessorMCH::produceTestData(TString aliasName) {
+    TMap* resultMap = 0;
+
+    // here has to come real dummy data :-)
+    resultMap = new TMap();
+    TTimeStamp tt;
+       Float_t fval = 33.3;
+    TObjString* name = new TObjString("DummyData");
+    AliDCSValue* val = new AliDCSValue(fval, tt.GetTime());
+    TObjArray* arr = new TObjArray();
+    arr->Add(val);
+    resultMap->Add(name, arr);
+
+    return resultMap;
+}
+
+
diff --git a/HLT/pendolino/MUON/AliHLTPredictionProcessorMCH.h b/HLT/pendolino/MUON/AliHLTPredictionProcessorMCH.h
new file mode 100644 (file)
index 0000000..64db04e
--- /dev/null
@@ -0,0 +1,120 @@
+#ifndef ALIHLTPREDICTIONPROCESSORMCH_H
+#define ALIHLTPREDICTIONPROCESSORMCH_H
+/* This file is property of and copyright by the ALICE HLT Project        *
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+///
+/// @file   AliHLTPredictionProcessorMCH.h
+/// @author Artur Szostak <artursz@iafrica.com>
+/// @date   2007-11-24
+/// @brief  Declaration of the muon tracking chamber prediction processor.
+///
+
+#include "AliHLTPredictionProcessorInterface.h"
+
+/**
+ * This is the prediction processor for the muon tracking chambers.
+ * It is required as part of the Pendolino interface so that data fetched from
+ * DCS can be transformed and extrapolated into a format suitable for the HCDB.
+ *
+ * At the moment this class does not really do anything, but will fill the
+ * HCDB with data in the future.
+ *
+ * Refer to:
+ * http://wiki.kip.uni-heidelberg.de/ti/HLT/index.php/Pendolino-PredictionProcessor-Interface
+ * for more details about the Pendolino and preprocessor interfaces.
+ */
+class AliHLTPredictionProcessorMCH : public AliHLTPredictionProcessorInterface
+{
+public:
+
+       /**
+        * The class constructor for the preprocessor.
+        * @param detector  The detector name, which must be "MCH".
+        * @param pendolino A valid pointer to the pendolino instance.
+        */
+       AliHLTPredictionProcessorMCH(const char* detector, AliHLTPendolino* pendolino);
+       
+       virtual ~AliHLTPredictionProcessorMCH();
+       
+       // The following methods are inherited from AliHLTPredictionProcessorInterface.
+       
+       /**
+        * This function is called by the Pendolino before the fetched DCS data
+        * is handed in for (prediction) processing.
+        *
+        * @param doPrediction If true then preprocessed data will be extrapolated
+        *           to the current time. Otherwise no extrapolation will be
+        *           performed if false. The default is to perform extrapolations.
+        *
+        * @return Currently always returns 0 for success.
+        */
+       virtual UInt_t makePrediction(Bool_t doPrediction = true);
+
+       /**
+        * Performs initialisation of the preprocessor.
+        * At the moment just basic sanity checks are performed.
+        *
+        * @param run The current run number.
+        * @param startTime The start time (earliest timestamp) of the data.
+        * @param endTime The end time (latest timestamp) of the data.
+        */
+       virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
+
+       /**
+        * Process the DCS values.
+        * At the moment nothing is done here.
+        *
+        * @param dcsAliasMap The map containing aliases and corresponding DCS
+        *                    values and timestamps
+        *
+        * @return At the moment 0 is always returned for success.
+        */
+       virtual UInt_t Process(TMap* dcsAliasMap);
+
+       /**
+        * Indicates that the DCS data shall be processed.
+        * NOTE: should always return true, since it is used as prediction
+        * processor, which will only process DCS data
+        *
+        * @return Always returns the value kTRUE.
+        */
+       virtual Bool_t ProcessDCS() { return kTRUE; };
+
+        /**
+         * Function to let the PredictionProcessor produce dummy input data,
+         * that can be used in Pendolino tests, where no DCS Archieve DB is
+         * contacted. This function is called by the Pendolino, the result is
+         * given back to the PredictionProcessor via the Process(...) call.
+         * Since the DCSMaps requested from DCS are detector specific, the
+         * PredictionProcessor should know, how the maps look like, that it
+         * expects.
+         * NOTE: The clean - up (delete) of the TMap will be performed by the
+         * Pendolino after the usage. The PredictionProcessor has never to
+         * call delete on the returned TMap pointer.
+         *
+         * @param aliasName optional parameter, that can be given in order to
+         *          create a DCSMap for dedicated aliases. For a general test
+         *          this paramter should be empty. If more than one alias name
+         *          shall be specified, they are separated by blanks " ".
+         *
+         * @return DCSMap containing dummy data for testing the Pendolino.
+         */
+        virtual TMap* produceTestData(TString aliasName = "");
+
+       
+private:
+
+       // Do not allow copying of this class.
+       AliHLTPredictionProcessorMCH(const AliHLTPredictionProcessorMCH& /*obj*/);
+       AliHLTPredictionProcessorMCH& operator = (const AliHLTPredictionProcessorMCH& /*obj*/);
+
+       Bool_t fPredict;  //! Flag indicating if the processed values should be extrapolated to current time.
+       
+       ClassDef(AliHLTPredictionProcessorMCH, 0);  // The prediction processor for the muon tracking chambers.
+};
+
+#endif // ALIHLTPREDICTIONPROCESSORMCH_H
diff --git a/HLT/pendolino/MUON/AliHLTPredictionProcessorMTR.cxx b/HLT/pendolino/MUON/AliHLTPredictionProcessorMTR.cxx
new file mode 100644 (file)
index 0000000..b59a43c
--- /dev/null
@@ -0,0 +1,133 @@
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Authors:                                                       *
+ *   Artur Szostak <artursz@iafrica.com>                                  *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          * 
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+///
+///  @file   AliHLTPredictionProcessorMTR.cxx
+///  @author Artur Szostak <artursz@iafrica.com>
+///  @date   
+///  @brief  Implementation of the AliHLTPredictionProcessorMTR class.
+///
+
+#include "AliHLTPredictionProcessorMTR.h"
+#include "AliCDBMetaData.h"
+#include "AliCDBEntry.h"
+#include <cstdlib>
+
+#include <TTimeStamp.h>
+#include <TObjString.h>
+#include <TObjArray.h>
+#include <AliDCSValue.h>
+
+ClassImp(AliHLTPredictionProcessorMTR);
+
+
+AliHLTPredictionProcessorMTR::AliHLTPredictionProcessorMTR(
+               const char* detector, AliHLTPendolino* pendolino
+       ) :
+       AliHLTPredictionProcessorInterface(detector, pendolino),
+       fPredict(kTRUE)
+{
+       /// The class constructor for the preprocessor.
+       /// @param detector  The detector name, which must be "MTR".
+       /// @param pendolino A valid pointer to the pendolino instance.
+       
+       if (strcmp(detector, "MTR") != 0)
+       {
+               Log(Form("Warning: Setting the detector name to an incorrect value = '%s'."
+                   " It must be set to 'MTR'.", detector)
+               );
+       }
+}
+
+
+AliHLTPredictionProcessorMTR::~AliHLTPredictionProcessorMTR()
+{
+       /// Default destructor.
+}
+
+
+UInt_t AliHLTPredictionProcessorMTR::makePrediction(Bool_t doPrediction)
+{
+       /// This function is called by the Pendolino before the fetched DCS data
+       /// is handed in for (prediction) processing.
+       ///
+       /// @param doPrediction If true then preprocessed data will be extrapolated
+       ///           to the current time. Otherwise no extrapolation will be
+       ///           performed if false. The default is to perform extrapolations.
+       ///
+       /// @return Currently always returns 0 for success.
+
+       fPredict = doPrediction;
+       return 0;
+}
+
+
+void AliHLTPredictionProcessorMTR::Initialize(
+               Int_t run, UInt_t startTime, UInt_t endTime
+       )
+{
+       /// Performs initialisation of the preprocessor.
+       /// At the moment just basic sanity checks are performed.
+       ///
+       /// @param run The current run number.
+       /// @param startTime The start time (earliest timestamp) of the data.
+       /// @param endTime The end time (latest timestamp) of the data.
+       
+       if (startTime > endTime)
+               Log("Error: start time is greater than end time.");
+       
+       AliPreprocessor::Initialize(run, startTime, endTime);
+
+       if (fPredict)
+               Log("Prediction is switched ON.");
+       else
+               Log("Prediction is switched OFF.");
+}
+
+
+UInt_t AliHLTPredictionProcessorMTR::Process(TMap* dcsAliasMap)
+{
+       /// Process the DCS values.
+       /// At the moment nothing is done here.
+       ///
+       /// @param dcsAliasMap The map containing aliases and corresponding DCS
+       ///                    values and timestamps
+       ///
+       /// @return At the moment 0 is always returned for success.
+       
+       Log("Processing MTR");
+       return 0;
+}
+
+TMap* AliHLTPredictionProcessorMTR::produceTestData(TString aliasName) {
+    TMap* resultMap = 0;
+
+    // here has to come real dummy data :-)
+    resultMap = new TMap();
+    TTimeStamp tt;
+       Float_t fval = 33.3;
+    TObjString* name = new TObjString("DummyData");
+    AliDCSValue* val = new AliDCSValue(fval, tt.GetTime());
+    TObjArray* arr = new TObjArray();
+    arr->Add(val);
+    resultMap->Add(name, arr);
+
+    return resultMap;
+}
+
+
diff --git a/HLT/pendolino/MUON/AliHLTPredictionProcessorMTR.h b/HLT/pendolino/MUON/AliHLTPredictionProcessorMTR.h
new file mode 100644 (file)
index 0000000..430fbfa
--- /dev/null
@@ -0,0 +1,119 @@
+#ifndef ALIHLTPREDICTIONPROCESSORMTR_H
+#define ALIHLTPREDICTIONPROCESSORMTR_H
+/* This file is property of and copyright by the ALICE HLT Project        *
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+///
+/// @file   AliHLTPredictionProcessorMTR.h
+/// @author Artur Szostak <artursz@iafrica.com>
+/// @date   2007-11-24
+/// @brief  Declaration of the muon trigger prediction processor.
+///
+
+#include "AliHLTPredictionProcessorInterface.h"
+
+/**
+ * This is the prediction processor for the muon trigger detector.
+ * It is required as part of the Pendolino interface so that data fetched from
+ * DCS can be transformed and extrapolated into a format suitable for the HCDB.
+ *
+ * At the moment this class does not really do anything, but will fill the
+ * HCDB with data in the future.
+ *
+ * Refer to:
+ * http://wiki.kip.uni-heidelberg.de/ti/HLT/index.php/Pendolino-PredictionProcessor-Interface
+ * for more details about the Pendolino and preprocessor interfaces.
+ */
+class AliHLTPredictionProcessorMTR : public AliHLTPredictionProcessorInterface
+{
+public:
+
+       /**
+        * The class constructor for the preprocessor.
+        * @param detector  The detector name, which must be "MTR".
+        * @param pendolino A valid pointer to the pendolino instance.
+        */
+       AliHLTPredictionProcessorMTR(const char* detector, AliHLTPendolino* pendolino);
+       
+       virtual ~AliHLTPredictionProcessorMTR();
+       
+       // The following methods are inherited from AliHLTPredictionProcessorInterface.
+       
+       /**
+        * This function is called by the Pendolino before the fetched DCS data
+        * is handed in for (prediction) processing.
+        *
+        * @param doPrediction If true then preprocessed data will be extrapolated
+        *           to the current time. Otherwise no extrapolation will be
+        *           performed if false. The default is to perform extrapolations.
+        *
+        * @return Currently always returns 0 for success.
+        */
+       virtual UInt_t makePrediction(Bool_t doPrediction = true);
+
+       /**
+        * Performs initialisation of the preprocessor.
+        * At the moment just basic sanity checks are performed.
+        *
+        * @param run The current run number.
+        * @param startTime The start time (earliest timestamp) of the data.
+        * @param endTime The end time (latest timestamp) of the data.
+        */
+       virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
+
+       /**
+        * Process the DCS values.
+        * At the moment nothing is done here.
+        *
+        * @param dcsAliasMap The map containing aliases and corresponding DCS
+        *                    values and timestamps
+        *
+        * @return At the moment 0 is always returned for success.
+        */
+       virtual UInt_t Process(TMap* dcsAliasMap);
+
+       /**
+        * Indicates that the DCS data shall be processed.
+        * NOTE: should always return true, since it is used as prediction
+        * processor, which will only process DCS data
+        *
+        * @return Always returns the value kTRUE.
+        */
+       virtual Bool_t ProcessDCS() { return kTRUE; };
+
+        /**
+         * Function to let the PredictionProcessor produce dummy input data,
+         * that can be used in Pendolino tests, where no DCS Archieve DB is
+         * contacted. This function is called by the Pendolino, the result is
+         * given back to the PredictionProcessor via the Process(...) call.
+         * Since the DCSMaps requested from DCS are detector specific, the
+         * PredictionProcessor should know, how the maps look like, that it
+         * expects.
+         * NOTE: The clean - up (delete) of the TMap will be performed by the
+         * Pendolino after the usage. The PredictionProcessor has never to
+         * call delete on the returned TMap pointer.
+         *
+         * @param aliasName optional parameter, that can be given in order to
+         *          create a DCSMap for dedicated aliases. For a general test
+         *          this paramter should be empty. If more than one alias name
+         *          shall be specified, they are separated by blanks " ".
+         *
+         * @return DCSMap containing dummy data for testing the Pendolino.
+         */
+        virtual TMap* produceTestData(TString aliasName = "");
+       
+private:
+
+       // Do not allow copying of this class.
+       AliHLTPredictionProcessorMTR(const AliHLTPredictionProcessorMTR& /*obj*/);
+       AliHLTPredictionProcessorMTR& operator = (const AliHLTPredictionProcessorMTR& /*obj*/);
+
+       Bool_t fPredict;  //! Flag indicating if the processed values should be extrapolated to current time.
+       
+       ClassDef(AliHLTPredictionProcessorMTR, 0);  // The prediction processor for the muon trigger detector.
+};
+
+#endif // ALIHLTPREDICTIONPROCESSORMTR_H
index ddd843a..fe25b80 100644 (file)
@@ -11,7 +11,7 @@ EXTRA_DIST                    =
 lib_LTLIBRARIES                        =  libHLTpendolino.la
 
 # version info for the library
-LIBRARY_VERSION                        = "$(LIBHLTPENDOLINO_VERSION):0:0"
+LIBRARY_VERSION                        = "4:0:0"
 
 # MODDIR is set by the AliRoot build system and denotes the topdir
 # of the module, we must set it since the package definition libHLTpendolino.pkg
diff --git a/HLT/pendolino/TPC/AliHLTDCSArray.cxx b/HLT/pendolino/TPC/AliHLTDCSArray.cxx
new file mode 100644 (file)
index 0000000..793f79a
--- /dev/null
@@ -0,0 +1,47 @@
+// $Id$
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Haavard Helstrup                                      *
+//*                  for The ALICE HLT Project.                            *
+//*                                                                        *
+//* Permission to use, copy, modify and distribute this software and its   *
+//* documentation strictly for non-commercial purposes is hereby granted   *
+//* without fee, provided that the above copyright notice appears in all   *
+//* copies and that both the copyright notice and this permission notice   *
+//* appear in the supporting documentation. The authors make no claims     *
+//* about the suitability of this software for any purpose. It is          *
+//* provided "as is" without express or implied warranty.                  *
+//**************************************************************************
+
+/** @file   AliHLTDCSArray.cxx
+    @author Haavard Helstrup
+    @date   
+    @brief  
+*/
+
+#include "TROOT.h"
+#include "TArrayF.h"
+#include "AliHLTDCSArray.h"
+
+
+//______________________________________________________________________________________________
+
+AliHLTDCSArray::AliHLTDCSArray(Int_t entries): TObject(),
+   fTimeStamp(0),
+   fValues(0)
+{
+ // constructor
+    fValues.Set(entries);
+}
+
+//______________________________________________________________________________________________
+
+AliHLTDCSArray::~AliHLTDCSArray()
+{
+ // destructor
+} 
+
diff --git a/HLT/pendolino/TPC/AliHLTDCSArray.h b/HLT/pendolino/TPC/AliHLTDCSArray.h
new file mode 100644 (file)
index 0000000..9e1034d
--- /dev/null
@@ -0,0 +1,37 @@
+//-*- Mode: C++ -*-
+// $Id$
+
+#ifndef ALIHLTDCSARRAY_H
+#define ALIHLTDCSARRAY_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+/** @file   AliHLTDCSArray.h
+    @author Haavard Helstrup
+    @date   
+    @brief  
+*/
+
+#include "TArrayF.h"
+
+class AliHLTDCSArray : public TObject {
+
+ public:
+   AliHLTDCSArray(Int_t entries=0);
+   virtual ~AliHLTDCSArray();
+   void SetTime(UInt_t time) {fTimeStamp=time;}
+   const UInt_t GetTime() const {return fTimeStamp;}
+   void SetValue(Int_t i, Float_t val) {fValues[i]=val;}
+   Float_t GetValue(Int_t i) const {return fValues[i];}
+   
+ protected:  
+   UInt_t      fTimeStamp;    // time of DCS reading
+   TArrayF     fValues;       // array holding DCS readings
+   
+ ClassDef(AliHLTDCSArray,1)
+};
+
+#endif   
+
diff --git a/HLT/pendolino/TPC/AliHLTPredictionProcessorTPC.cxx b/HLT/pendolino/TPC/AliHLTPredictionProcessorTPC.cxx
new file mode 100644 (file)
index 0000000..6ddc19e
--- /dev/null
@@ -0,0 +1,258 @@
+// $Id$
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Haavard Helstrup                                      *
+//*                  for The ALICE HLT Project.                            *
+//*                                                                        *
+//* Permission to use, copy, modify and distribute this software and its   *
+//* documentation strictly for non-commercial purposes is hereby granted   *
+//* without fee, provided that the above copyright notice appears in all   *
+//* copies and that both the copyright notice and this permission notice   *
+//* appear in the supporting documentation. The authors make no claims     *
+//* about the suitability of this software for any purpose. It is          *
+//* provided "as is" without express or implied warranty.                  *
+//**************************************************************************
+
+/** @file   AliHLTPredictionProcessorTPC.cxx
+    @author Haavard Helstrup
+    @date   
+    @brief  
+*/
+
+#include "AliHLTPredictionProcessorTPC.h"
+
+#include "AliHLTDCSArray.h"
+#include "TROOT.h"
+#include "TArrayF.h"
+#include "TObjArray.h"
+#include "TTree.h"
+#include "TString.h"
+#include "AliCDBEntry.h"
+#include "AliCDBMetaData.h"
+#include "AliDCSValue.h"
+
+#include <TTimeStamp.h>
+#include <TObjString.h>
+
+
+ClassImp(AliHLTPredictionProcessorTPC)
+
+const TString kAmandaString = "TPC_PT_%d_TEMPERATURE";
+
+//______________________________________________________________________________________________
+
+AliHLTPredictionProcessorTPC::AliHLTPredictionProcessorTPC(
+           const char* detector, AliHLTPendolino* pendolino) :
+               AliHLTPredictionProcessorInterface(detector, pendolino),
+               fConfigOK(kTRUE),
+              fConfTreeTemp(0),
+               fTemp(0),
+              fPredict(kFALSE),
+              fRun(0),
+              fStartTime(0),
+              fEndTime(0)
+{
+ // constructor
+}
+
+//______________________________________________________________________________________________
+
+AliHLTPredictionProcessorTPC::~AliHLTPredictionProcessorTPC()
+{
+
+  // destructor
+       if (fConfTreeTemp) {
+               delete fConfTreeTemp;
+       }
+       if (fTemp) {
+               fTemp->Delete();
+               delete fTemp;
+       }
+
+}
+
+//______________________________________________________________________________________________
+
+UInt_t AliHLTPredictionProcessorTPC::makePrediction(Bool_t doPrediction) {
+//
+// Signal whether prediction making is required
+//
+   fPredict = doPrediction; // own member indicating that prediction making is required
+   return 0;
+}
+
+//______________________________________________________________________________________________
+
+void AliHLTPredictionProcessorTPC::Initialize(Int_t run, UInt_t startTime,
+           UInt_t endTime) {
+//
+//  Initialise TPC prediction processor. Read config entry from HCDB
+//
+   fRun = run;               // storing locally the run number
+   fStartTime = startTime;   // storing locally the start time
+   fEndTime = endTime;       // storing locally the end time
+
+
+   AliCDBEntry* entry = GetFromOCDB("Config", "HLTTemperature");
+   if (entry) fConfTreeTemp = (TTree*) entry->GetObject();
+   if ( fConfTreeTemp==0 ) {
+     Log("AliHLTPredictionProcessorTPC: Temperature Config HCDB entry missing.\n");
+     fConfigOK = kFALSE;
+     return;
+   }
+}
+
+//______________________________________________________________________________________________
+
+UInt_t AliHLTPredictionProcessorTPC::Process(TMap* dcsAliasMap) {
+//
+// Event-by-event processing of the PredictionProcessorTPC
+//
+
+// test if configuration available and DCS map valid
+
+  if (!dcsAliasMap) return 91;
+  if (dcsAliasMap->GetEntries() == 0 ) return 92;
+  if (!fConfigOK) return 93;
+
+//
+// Extract values from DCS maps. Store updated entry to HCDB
+//
+   UInt_t retVal = 0;
+   Int_t start = 0;
+   TString path2("Calib");        // for the storage path in HCDB
+   TString path3("Temperature");    // for the storage path in HCDB
+
+   //get data from the HCDB
+   AliCDBEntry* entry = GetFromOCDB(path2.Data(), path3.Data());
+   if (entry != 0) {
+       entry->PrintMetaData();  // use the AliCDBEntry
+       fTemp = (TObjArray*)entry->GetObject();
+   } else {
+       Log("Cannot retrieve HCDB entry. New TObjArray generated");
+       fTemp = new TObjArray();
+   }
+
+   // process temperatures
+   
+   UInt_t tempResult = ExtractTemperature(dcsAliasMap); 
+
+   //process dcsAliasMap to ROOT object
+   // and create AliCDBEntry 
+
+   if (tempResult == 0) {
+               // create meta data entry for HCDB
+       TString comment("HLT temperatures");
+       AliCDBMetaData meta(this->GetName(), 0, "unknownAliRoot", comment.Data());
+
+       // store AliCDBEntry in HCDB
+       if (Store(path2.Data(), path3.Data(), fTemp, &meta, start, kTRUE)) {
+               Log(" +++ Successfully stored object ;-)");
+       } else {
+               Log(" *** Storing of OBJECT failed!!");
+               retVal = 7;
+       }
+    } else {
+       retVal = 94;
+    }
+   
+   return retVal;
+}
+
+//______________________________________________________________________________________________
+
+UInt_t AliHLTPredictionProcessorTPC::ExtractTemperature(TMap* dcsAliasMap)
+{
+// Extract temperature values from DCS maps, according to infoamtion from configuration tree
+
+  const Int_t error = 9; 
+  Int_t nentries = fConfTreeTemp->GetEntries();
+  if (nentries<1) return error;
+    
+  TString stringId;
+  Int_t echa=0;
+  fConfTreeTemp->SetBranchAddress("ECha",&echa);
+  fConfTreeTemp->GetEntry(0);
+  stringId = Form(kAmandaString.Data(),echa);
+  UInt_t time = GetCurrentTime(dcsAliasMap,stringId.Data());   
+  AliHLTDCSArray* temperatures = new AliHLTDCSArray(nentries);
+  temperatures->SetTime(time);
+  
+  for (Int_t isensor=0; isensor<nentries; isensor++ ){
+     fConfTreeTemp->GetEntry(isensor);
+     stringId = Form(kAmandaString.Data(),echa);
+     Float_t temp = GetSensorValue(dcsAliasMap,stringId.Data());
+     temperatures->SetValue(isensor,temp);
+  }
+  
+  fTemp->Add(temperatures);
+  return 0;  
+}
+
+  
+//______________________________________________________________________________________________
+
+Float_t AliHLTPredictionProcessorTPC::GetSensorValue(TMap* dcsAliasMap,
+                                     const char* stringId)
+{
+  // return last value read from sensor specified by stringId
+  Float_t sensorValue=0;
+  TObjArray* valueSet;
+  TPair* pair = (TPair*)dcsAliasMap->FindObject(stringId);
+  if (pair) {
+     valueSet = (TObjArray*)pair->Value();
+        if (valueSet) {
+       Int_t nentriesDCS = valueSet->GetEntriesFast();
+       AliDCSValue *val = (AliDCSValue *)valueSet->At(nentriesDCS - 1);
+       if (val) {
+                       sensorValue=val->GetFloat();
+               }
+        }
+  }
+  return sensorValue;
+}
+       
+//______________________________________________________________________________________________
+
+UInt_t AliHLTPredictionProcessorTPC::GetCurrentTime(TMap* dcsAliasMap,
+                                     const char* stringId)
+{
+  // return last time value read from sensor specified by stringId
+  
+  UInt_t time=0;
+  TObjArray* valueSet;
+  TPair* pair = (TPair*) (dcsAliasMap->FindObject(stringId));
+  if (pair) {
+     valueSet = (TObjArray*) (pair->Value());
+        if (valueSet) {
+       Int_t nentriesDCS = valueSet->GetEntriesFast();
+       AliDCSValue *val = (AliDCSValue *) (valueSet->At(nentriesDCS - 1));
+               if (val) {
+               time = val->GetTimeStamp();
+               }
+        }
+  }
+  return time;
+}
+
+TMap* AliHLTPredictionProcessorTPC::produceTestData(TString aliasName) {
+    TMap* resultMap = 0;
+
+    // here has to come real dummy data :-)
+    resultMap = new TMap();
+    TTimeStamp tt;
+    TObjString* name = new TObjString("DummyData");
+       Float_t fval = 33.3;
+    AliDCSValue* val = new AliDCSValue(fval, tt.GetTime());
+    TObjArray* arr = new TObjArray();
+    arr->Add(val);
+    resultMap->Add(name, arr);
+
+    return resultMap;
+}
+
+                            
+
diff --git a/HLT/pendolino/TPC/AliHLTPredictionProcessorTPC.h b/HLT/pendolino/TPC/AliHLTPredictionProcessorTPC.h
new file mode 100644 (file)
index 0000000..a45c2b9
--- /dev/null
@@ -0,0 +1,63 @@
+//-*- Mode: C++ -*-
+// $Id$
+
+#ifndef ALIHLTPREDICTIONPROCESSORTPC_H
+#define ALIHLTPREDICTIONPROCESSORTPC_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+/** @file   AliHLTPredictionProcessorTPC.h
+    @author Haavard Helstrup
+    @date   
+    @brief  
+*/
+
+#include "AliHLTPredictionProcessorInterface.h"
+#include "TTree.h"
+class TMap;
+class AliHLTDCSArray;
+
+class TObjArray;
+
+class AliHLTPredictionProcessorTPC : public AliHLTPredictionProcessorInterface
+{
+ public:
+   AliHLTPredictionProcessorTPC(const char* detector, 
+                                AliHLTPendolino* pendolino);
+   virtual ~AliHLTPredictionProcessorTPC();
+   
+   UInt_t makePrediction (Bool_t doPrediction);
+   void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
+   UInt_t Process (TMap* dcsAliasMap);
+   UInt_t ExtractTemperature(TMap* dcsAliasMap);
+   UInt_t GetCurrentTime(TMap* dcsAliasMap, const char* stringId);
+   Float_t GetSensorValue(TMap* dcsAliasMap, const char* stringId);
+   virtual Bool_t ProcessDCS();
+   virtual TMap* produceTestData(TString aliasName = "");
+   
+  private: 
+    Bool_t                 fConfigOK;     // Identify succesful reading of OCDB Config
+    TTree*                 fConfTreeTemp; // TTree holding temperature configuration  
+    TObjArray*             fTemp;         // Array holding temperature readings
+    Bool_t                 fPredict;      // Indicates whether predictions should be made
+    Int_t                  fRun;          // run number
+    UInt_t                 fStartTime;    // start time
+    UInt_t                 fEndTime;      // end time
+
+    AliHLTPredictionProcessorTPC
+             (const AliHLTPredictionProcessorTPC& predictPro); // Disabled Copy Constructor
+
+    AliHLTPredictionProcessorTPC& 
+             operator=(const AliHLTPredictionProcessorTPC& rhs); // Disabled Assignment Operator
+
+
+  ClassDef(AliHLTPredictionProcessorTPC,2)
+};
+
+inline Bool_t AliHLTPredictionProcessorTPC::ProcessDCS() {
+       return true;
+}
+
+#endif
+