added prediction processor framework and implementations; moved MUON preprocessors
[u/mrichter/AliRoot.git] / HLT / pendolino / HLT / AliHLTPredictionProcessorHLT.h
1 //-*- Mode: C++ -*-
2 // $Id$
3
4 #ifndef ALI_HLT_PREDICTION_PROCESSOR_HLT_H
5 #define ALI_HLT_PREDICTION_PROCESSOR_HLT_H
6 //* This file is property of and copyright by the ALICE HLT Project        * 
7 //* ALICE Experiment at CERN, All rights reserved.                         *
8 //* See cxx source for full Copyright notice                               *
9
10 /** @file   AliHLTPredictionProcessorHLT.h
11     @author Gaute Ovrebekk
12     @date   
13     @brief  
14 */
15
16 #include "AliHLTPredictionProcessorInterface.h"
17
18 //new
19 #include <TObjString.h>
20
21
22 /**
23  * Predition Processor for prepering b-field values for general HLT components. 
24  *
25  * @author Sebastian Bablok, Gaute Ovrebekk
26  *
27  * @date 2007-10-24
28  */
29 class AliHLTPredictionProcessorHLT : public AliHLTPredictionProcessorInterface {
30     public:
31         
32                 /**
33                  * Constructor for AliHLTPredictionProcessorHLT
34                  *
35                  * @param detector string defining the detector to which the 
36                  *                      PredictionProcessor belongs to
37                  * @param pendolino pointer to the hosting pendolino (derived from 
38                  *                      AliShuttleInterface)
39                  */
40                 AliHLTPredictionProcessorHLT(const char* detector, 
41                                                 AliHLTPendolino* pendolino);
42
43                 /**
44                  * Destructor for AliHLTPredictionProcessorHLT
45                  */
46                 virtual ~AliHLTPredictionProcessorHLT();
47                 
48                 /**
49                  * Virtual function to force the Prediction Processor to implement
50                  * a function to flag that prediction making is required.
51                  * This function is called by the Pendolino before the fetched DCS data
52                  * is handed in for (prediction) processing.
53                  *
54                  * @param doPrediction if true, prediction making shall be switched on,
55                  *                      if false, switched off.
56                  * 
57                  * @return 0 on success; a value greater than 0 refers to an error
58                  */
59                 virtual UInt_t makePrediction(Bool_t doPrediction = true);
60
61                 /**
62                  * Virtual function, implemented in the detector specific 
63                  * PredictionProcessors to initialize them.
64                  *
65                  * @param run run number
66                  * @param startTime start time of data
67                  * @param endTime end time of data
68                  */
69                 virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
70
71                 /**
72                  * Function called by the Pendolino for each participating subdetector
73                  * producing the required condition settings. This includes the 
74                  * encoding of a prediction to the values due to the fact, that only 
75                  * data up to now can be fetched from DCS (the latest data can also be 
76                  * up to 2 min old until it is received on HLT side). To write the data
77                  * to the HCDB, the detector specific implementation of this class has 
78                  * to call the appropriated storing function provided by the interface.
79                  *
80                  * @param dcsAliasMap the map containing aliases and corresponding DCS
81                  *                      values and timestamps
82                  *
83                  * @return 0 on success; a value greater than 0 refers to an error
84                  */
85                 virtual UInt_t Process(TMap* dcsAliasMap);
86
87                 /**
88                  * Indicates if DCS data shall be processed.
89                  * NOTE: should always return true, since it is used as prediction 
90                  * processor, which will only process DCS data
91                  *
92                  * @return true if DCS data can be processed, else false. Note: if false
93                  *                              the Pendolino would stop, so make sure that it is true.
94                  */
95                 virtual Bool_t ProcessDCS();
96
97         /**
98          * Function to let the PredictionProcessor produce dummy input data,
99          * that can be used in Pendolino tests, where no DCS Archieve DB is
100          * contacted. This function is called by the Pendolino, the result is
101          * given back to the PredictionProcessor via the Process(...) call.
102          * Since the DCSMaps requested from DCS are detector specific, the
103          * PredictionProcessor should know, how the maps look like, that it
104          * expects.
105          * NOTE: The clean - up (delete) of the TMap will be performed by the
106          * Pendolino after the usage. The PredictionProcessor has never to
107          * call delete on the returned TMap pointer.
108          *
109          * @param aliasName optional parameter, that can be given in order to
110          *          create a DCSMap for dedicated aliases. For a general test
111          *          this paramter should be empty. If more than one alias name
112          *          shall be specified, they are separated by blanks " ".
113          *
114          * @return DCSMap containing dummy data for testing the Pendolino.
115          */
116         virtual TMap* produceTestData(TString aliasName = "");
117
118
119         protected:
120
121         private:
122                 /**
123                  * Disabled Copy constructor 
124                  * (parent class is disabled so derived class does the same)
125                  */
126                 AliHLTPredictionProcessorHLT(
127                                                 const AliHLTPredictionProcessorHLT& predictPro);
128
129                 /**
130                  * Disabled Assignment operator
131                  * (parent class is disabled so derived class does the same)
132                  */
133                 AliHLTPredictionProcessorHLT& operator=(
134                                                 const AliHLTPredictionProcessorHLT& rhs);
135
136
137                 /**
138                  * TObjstring which stores the B-field value
139                  */
140                 TObjString mBField;  // TObjstring which stores the B-field value
141
142                 /**
143                  * Stores if prediction shall be made
144                  */
145                 Bool_t mPredict;  // flag for prediction making
146
147                 /**
148                  * Stores the run number
149                  */
150                 Int_t mRun;  // Stores the run number
151         
152                 /**
153                  * Stores the start time of the to process DCS data
154                  */     
155                 UInt_t mStartTime;  // Stores the start time of the to process DCS data
156         
157                 /**
158                  * Stores the end time of the to process DCS data
159                  */     
160                 UInt_t mEndTime;  // Stores the end time of the to process DCS data
161
162                 /**
163                  * Function to extract the B-field from the DCS value map
164                  *
165                  * @param dcsAliasMap the retrieved DCS value map
166                  *
167                  * @return 0 on sucess else an error code
168                  */
169                 UInt_t ExtractBField(TMap* dcsAliasMap);
170
171                 /**
172                  * Function to rertieve a sensor value from the DCS value map
173                  *
174                  * @param dcsAliasMap the retrieved DCS value map
175                  * @param stringId the alias name of the desired sensor value
176                  * @param value [return parameter] - the extracted sensor value
177                  *
178                  * @return true if sucessful, else false
179                  */
180                 Bool_t GetSensorValue(TMap* dcsAliasMap,const char* stringId, Float_t * value);
181                 
182                 ClassDef(AliHLTPredictionProcessorHLT, 0);
183         
184 };
185
186
187 inline Bool_t AliHLTPredictionProcessorHLT::ProcessDCS() {
188         // indicates if DCS values are processed; always true
189         return true;
190 }
191
192 #endif
193
194