Heavy ion Analysis Libriares
Loading...
Searching...
No Matches
Parameter.cxx
1/*
2 * Parameter.cpp
3 *
4 * Created on: 21-06-2013
5 * Author: Daniel Wielanek
6 */
7
8#include "Cout.h"
9#include "Std.h"
10#include <TBrowser.h>
11#include <TCollection.h>
12#include <TNamed.h>
13#include <TPaveText.h>
14#include <TVirtualPad.h>
15
16#include "StdString.h"
17#include "Parameter.h"
18
19#if !defined(__CINT__)
20// templateClassImp(HalStringsPlus);
21#endif
22//---------------- BASE CLASS -----------------------------------------
23namespace Hal {
24 Parameter::Parameter() : fMergeMode(Parameter::EParameterMerge::kEqual) { fName = "NULL"; }
25
26 Parameter::Parameter(TString name, Char_t merge_mode) {
27 fName = name;
28 SetMergeMode(merge_mode);
29 }
30
31 void Parameter::SetMergeMode(Char_t mergemode) {
32 if (mergemode == '+') {
33 fMergeMode = EParameterMerge::kPlus;
34 } else if (mergemode == '=') {
35 fMergeMode = EParameterMerge::kEqual;
36 } else if (mergemode == '*') {
37 fMergeMode = EParameterMerge::kMultiply;
38 } else if (mergemode == 'f') {
39 fMergeMode = EParameterMerge::kFirst;
40 } else if (mergemode == 'l') {
41 fMergeMode = EParameterMerge::kLast;
42 } else if (mergemode == 'M') {
43 fMergeMode = EParameterMerge::kMaximum;
44 } else if (mergemode == 'm') {
45 fMergeMode = EParameterMerge::kMinimum;
46 } else if (mergemode == 'a') {
47 fMergeMode = EParameterMerge::kAverage;
48 } else {
49 Cout::PrintInfo("Wrong merge mode in Parameter", Hal::EInfo::kLowWarning);
50 }
51 }
52
53 Bool_t Parameter::CheckName(const TObject* obj) {
54 TString name_first = this->GetName();
55 TString name_sec = obj->GetName();
56 if (name_first.EqualTo(name_sec)) {
57 return kTRUE;
58 } else {
59 Cout::PrintInfo(
60 Form("Warning in merging name %s differ than %s in class %s", this->GetName(), obj->GetName(), this->ClassName()),
61 Hal::EInfo::kLowWarning);
62 return kTRUE;
63 }
64 }
65
66 void Parameter::Browse(TBrowser* /*b*/) {
67 gPad->Clear();
68 gPad->Range(0, 0, 1, 1);
69 TPaveText* pt = new TPaveText(0, 0, 1, 1);
70 pt->AddText(ClassName());
71 pt->AddLine(0.0, 0.33, 1.0, 0.33);
72 pt->AddText(GetName());
73 pt->AddLine(0.0, 0.66, 1.0, 0.66);
74 pt->AddText(HTMLExtract(0));
75 pt->Draw();
76 }
77
78 Parameter::~Parameter() {}
79 //------------------------------------------------------------- Double_t
80 ParameterDouble::ParameterDouble() : Parameter(), fValue(0.0) {}
81
82 ParameterDouble::ParameterDouble(TString name, Double_t value, Char_t merge_mode) : Parameter(name, merge_mode) {
83 fValue = value;
84 }
85
86 void ParameterDouble::Add(const Object* val) {
87 if (CheckName(val)) {
88 const ParameterDouble* val_typed = (ParameterDouble*) val;
89 switch (fMergeMode) {
90 case EParameterMerge::kPlus: {
91 fValue += val_typed->GetValue();
92 } break;
93 case EParameterMerge::kEqual: {
94 if (fValue != val_typed->GetValue()) {
95 Cout::PrintInfo(Form("Differ values during adding %s", this->GetName()), Hal::EInfo::kLowWarning);
96 }
97 } break;
98 case EParameterMerge::kMultiply: {
99 fValue = fValue * val_typed->GetValue();
100 } break;
101 case EParameterMerge::kFirst: {
102 // do nothing this->fValue = fValue;
103 } break;
104 case EParameterMerge::kLast: {
105 fValue = val_typed->GetValue();
106 } break;
107 case EParameterMerge::kMaximum: {
108 if (fValue < val_typed->GetValue()) { fValue = val_typed->GetValue(); }
109 } break;
110 case EParameterMerge::kMinimum: {
111 if (fValue > val_typed->GetValue()) { fValue = val_typed->GetValue(); }
112 } break;
113 case EParameterMerge::kAverage: {
114 fValue = fValue * 0.5 + val_typed->GetValue() * 0.5;
115 } break;
116 default:
117 Cout::PrintInfo(Form("Unknow merging flag druing merging %s", this->GetName()), Hal::EInfo::kError);
118 break;
119 }
120 }
121 }
122
123 TString ParameterDouble::HTMLExtract(Int_t /*counter*/, TString /*dir*/) const { return Form("%4.3f", fValue); }
124
125 ParameterDouble::~ParameterDouble() {}
126 //-------------------------------------------------------------Float_t
127 //------------------------------------------------------------- Double_t
128 ParameterFloat::ParameterFloat() : Parameter(), fValue(0.0) {}
129
130 ParameterFloat::ParameterFloat(TString name, Float_t value, Char_t merge_mode) : Parameter(name, merge_mode) { fValue = value; }
131
132 void ParameterFloat::Add(const Object* val) {
133 if (CheckName(val)) {
134 const ParameterFloat* val_typed = (ParameterFloat*) val;
135 switch (fMergeMode) {
136 case EParameterMerge::kPlus: {
137 fValue += val_typed->GetValue();
138 } break;
139 case EParameterMerge::kEqual: {
140 if (fValue != val_typed->GetValue()) {
141 Cout::PrintInfo(Form("Differ values during adding %s", this->GetName()), Hal::EInfo::kLowWarning);
142 }
143 } break;
144 case EParameterMerge::kMultiply: {
145 fValue = fValue * val_typed->GetValue();
146 } break;
147 case EParameterMerge::kFirst: {
148 // do nothing this->fValue = fValue;
149 } break;
150 case EParameterMerge::kLast: {
151 fValue = val_typed->GetValue();
152 } break;
153 case EParameterMerge::kAverage: {
154 fValue = fValue * 0.5 + val_typed->GetValue() * 0.5;
155 } break;
156 case EParameterMerge::kMaximum: {
157 if (fValue < val_typed->GetValue()) { fValue = val_typed->GetValue(); }
158 } break;
159 case EParameterMerge::kMinimum: {
160 if (fValue > val_typed->GetValue()) { fValue = val_typed->GetValue(); }
161 } break;
162 default:
163 Cout::PrintInfo(Form("Unknow merging flag druing merging %s", this->GetName()), Hal::EInfo::kError);
164 break;
165 }
166 }
167 }
168
169 TString ParameterFloat::HTMLExtract(Int_t /*counter*/, TString /*dir*/) const { return Form("%4.3f", fValue); }
170
171 ParameterFloat::~ParameterFloat() {}
172 //-------------------------------------------------------------TString
173 ParameterString::ParameterString() : Parameter() {}
174
175 ParameterString::ParameterString(TString name, TString value, Char_t merge_mode) : Parameter(name, merge_mode) {
176 fValue = value;
177 }
178
179 void ParameterString::Add(const Object* val) {
180 if (CheckName(val)) {
181 ParameterString* val_typed = (ParameterString*) val;
182 switch (fMergeMode) {
183 case EParameterMerge::kPlus: {
184 fValue = fValue + val_typed->GetValue();
185 } break;
186 case EParameterMerge::kEqual: {
187 if (fValue.EqualTo(val_typed->GetValue()) == kFALSE) {
188 Cout::PrintInfo(Form("Differ values during adding %s", this->GetName()), Hal::EInfo::kLowWarning);
189 }
190 } break;
191 case EParameterMerge::kMultiply: {
192 Cout::PrintInfo("Multiply flag in ParameterString", Hal::EInfo::kLowWarning);
193 } break;
194 case EParameterMerge::kFirst: {
195 // do nothing this->fValue = fValue;
196 } break;
197 case EParameterMerge::kLast: {
198 fValue = val_typed->GetValue();
199 } break;
200 case EParameterMerge::kMaximum: {
201 if (fValue.Length() < val_typed->GetValue().Length()) { fValue = val_typed->GetValue(); }
202 } break;
203 case EParameterMerge::kMinimum: {
204 if (fValue.Length() > val_typed->GetValue().Length()) { fValue = val_typed->GetValue(); }
205 } break;
206 default:
207 Cout::PrintInfo(Form("Unknow merging flag druing merging %s", this->GetName()), Hal::EInfo::kError);
208 break;
209 }
210 }
211 }
212
213 TString ParameterString::HTMLExtract(Int_t /*counter*/, TString /*dir*/) const { return fValue; }
214
215 ParameterString::~ParameterString() {}
216 //-------------------------------------------------------------Uint_t
217 ParameterUInt::ParameterUInt() : Parameter(), fValue(0) {}
218
219 ParameterUInt::ParameterUInt(TString name, UInt_t value, Char_t merge_mode) : Parameter(name, merge_mode) { fValue = value; }
220
221 void ParameterUInt::Add(const Object* val) {
222 if (CheckName(val)) {
223 ParameterUInt* val_typed = (ParameterUInt*) val;
224 switch (fMergeMode) {
225 case EParameterMerge::kPlus: {
226 fValue += val_typed->GetValue();
227 } break;
228 case EParameterMerge::kEqual: {
229 if (fValue != val_typed->GetValue()) {
230 Cout::PrintInfo(Form("Differ values during adding %s", this->GetName()), Hal::EInfo::kLowWarning);
231 }
232 } break;
233 case EParameterMerge::kMultiply: {
234 fValue = fValue * val_typed->GetValue();
235 } break;
236 case EParameterMerge::kFirst: {
237 // do nothing this->fValue = fValue;
238 } break;
239 case EParameterMerge::kLast: {
240 fValue = val_typed->GetValue();
241 } break;
242 case EParameterMerge::kMaximum: {
243 if (fValue < val_typed->GetValue()) { fValue = val_typed->GetValue(); }
244 } break;
245 case EParameterMerge::kMinimum: {
246 if (fValue > val_typed->GetValue()) { fValue = val_typed->GetValue(); }
247 } break;
248 default:
249 Cout::PrintInfo(Form("Unknow merging flag druing merging %s", this->GetName()), Hal::EInfo::kError);
250 break;
251 }
252 }
253 }
254
255 TString ParameterUInt::HTMLExtract(Int_t /*counter*/, TString /*dir*/) const {
256 return Hal::Std::RoundToString(fValue, 0, "separators");
257 }
258
259 ParameterUInt::~ParameterUInt() {}
260 //------------------------------------------------------------ULong_t
261 ParameterULong::ParameterULong() : Parameter(), fValue(0) {}
262
263 ParameterULong::ParameterULong(TString name, ULong_t value, Char_t merge_mode) : Parameter(name, merge_mode) { fValue = value; }
264
265 void ParameterULong::Add(const Object* val) {
266 if (CheckName(val)) {
267 ParameterULong* val_typed = (ParameterULong*) val;
268 switch (fMergeMode) {
269 case EParameterMerge::kPlus: {
270 fValue += val_typed->GetValue();
271 } break;
272 case EParameterMerge::kEqual: {
273 if (fValue != val_typed->GetValue()) {
274 Cout::PrintInfo(Form("Differ values during adding %s", this->GetName()), Hal::EInfo::kLowWarning);
275 }
276 } break;
277 case EParameterMerge::kMultiply: {
278 fValue = fValue * val_typed->GetValue();
279 } break;
280 case EParameterMerge::kFirst: {
281 // do nothing this->fValue = fValue;
282 } break;
283 case EParameterMerge::kLast: {
284 fValue = val_typed->GetValue();
285 } break;
286 case EParameterMerge::kAverage: {
287 fValue = fValue * 0.5 + val_typed->GetValue() * 0.5;
288 } break;
289 case EParameterMerge::kMaximum: {
290 if (fValue < val_typed->GetValue()) { fValue = val_typed->GetValue(); }
291 } break;
292 case EParameterMerge::kMinimum: {
293 if (fValue > val_typed->GetValue()) { fValue = val_typed->GetValue(); }
294 } break;
295 default:
296 Cout::PrintInfo(Form("Unknow merging flag druing merging %s", this->GetName()), Hal::EInfo::kError);
297 break;
298 }
299 }
300 }
301
302 TString ParameterULong::HTMLExtract(Int_t /*counter*/, TString /*dir*/) const {
303 return Hal::Std::RoundToString(fValue, 0, "separators");
304 }
305
306 ParameterULong::~ParameterULong() {}
307 //-------------------------------------------------------------ULong64_t
308 ParameterULong64::ParameterULong64() : Parameter(), fValue(0) {}
309
310 ParameterULong64::ParameterULong64(TString name, ULong64_t value, Char_t merge_mode) : Parameter(name, merge_mode) {
311 fValue = value;
312 }
313
314 void ParameterULong64::Add(const Object* val) {
315 if (CheckName(val)) {
316 ParameterULong64* val_typed = (ParameterULong64*) val;
317 switch (fMergeMode) {
318 case EParameterMerge::kPlus: {
319 fValue += val_typed->GetValue();
320 } break;
321 case EParameterMerge::kEqual: {
322 if (fValue != val_typed->GetValue()) {
323 Cout::PrintInfo(Form("Differ values during adding %s", this->GetName()), Hal::EInfo::kLowWarning);
324 }
325 } break;
326 case EParameterMerge::kMultiply: {
327 fValue = fValue * val_typed->GetValue();
328 } break;
329 case EParameterMerge::kAverage: {
330 fValue = fValue * 0.5 + val_typed->GetValue() * 0.5;
331 } break;
332 case EParameterMerge::kFirst: {
333 // do nothing this->fValue = fValue;
334 } break;
335 case EParameterMerge::kLast: {
336 fValue = val_typed->GetValue();
337 } break;
338 case EParameterMerge::kMaximum: {
339 if (fValue < val_typed->GetValue()) { fValue = val_typed->GetValue(); }
340 } break;
341 case EParameterMerge::kMinimum: {
342 if (fValue > val_typed->GetValue()) { fValue = val_typed->GetValue(); }
343 } break;
344 default:
345 Cout::PrintInfo(Form("Unknow merging flag druing merging %s", this->GetName()), Hal::EInfo::kError);
346 break;
347 }
348 }
349 }
350
351 TString ParameterULong64::HTMLExtract(Int_t /*counter*/, TString /*dir*/) const {
352 { return Hal::Std::RoundToString(fValue, 0, "separators"); }
353 }
354
355 ParameterULong64::~ParameterULong64() {}
356 //--------------------------------------------------------------Int_t
357
358 ParameterInt::ParameterInt() : Parameter(), fValue(0) {}
359
360 ParameterInt::ParameterInt(TString name, Int_t value, Char_t merge_mode) : Parameter(name, merge_mode) { fValue = value; }
361
362 void ParameterInt::Add(const Object* val) {
363 if (CheckName(val)) {
364 ParameterInt* val_typed = (ParameterInt*) val;
365 switch (fMergeMode) {
366 case EParameterMerge::kPlus: {
367 fValue += val_typed->GetValue();
368 } break;
369 case EParameterMerge::kEqual: {
370 if (fValue != val_typed->GetValue()) {
371 Cout::PrintInfo(Form("Differ values during adding %s", this->GetName()), Hal::EInfo::kLowWarning);
372 }
373 } break;
374 case EParameterMerge::kMultiply: {
375 fValue = fValue * val_typed->GetValue();
376 } break;
377 case EParameterMerge::kAverage: {
378 fValue = fValue * 0.5 + val_typed->GetValue() * 0.5;
379 } break;
380 case EParameterMerge::kFirst: {
381 // do nothing this->fValue = fValue;
382 } break;
383 case EParameterMerge::kLast: {
384 fValue = val_typed->GetValue();
385 } break;
386 case EParameterMerge::kMaximum: {
387 if (fValue < val_typed->GetValue()) { fValue = val_typed->GetValue(); }
388 } break;
389 case EParameterMerge::kMinimum: {
390 if (fValue > val_typed->GetValue()) { fValue = val_typed->GetValue(); }
391 } break;
392 default:
393 Cout::PrintInfo(Form("Unknow merging flag druing merging %s", this->GetName()), Hal::EInfo::kError);
394 break;
395 }
396 }
397 }
398
399 TString ParameterInt::HTMLExtract(Int_t /*counter*/, TString /*dir*/) const {
400 return Hal::Std::RoundToString(GetValue(), 0, "separators");
401 }
402
403 ParameterInt::~ParameterInt() {}
404
405 //------------------------------------------------------------- Bool_t
406 ParameterBool::ParameterBool() : Parameter(), fValue(kFALSE) {}
407
408 ParameterBool::ParameterBool(TString name, Bool_t value, Char_t merge_mode) : Parameter(name, merge_mode) { fValue = value; }
409
410 void ParameterBool::Add(const Object* val) {
411 if (CheckName(val)) {
412 ParameterBool* val_typed = (ParameterBool*) val;
413 switch (fMergeMode) {
414 case EParameterMerge::kPlus: {
415 fValue += val_typed->GetValue();
416 } break;
417 case EParameterMerge::kEqual: {
418 if (fValue != val_typed->GetValue()) {
419 Cout::PrintInfo(Form("Differ values during adding %s", this->GetName()), Hal::EInfo::kLowWarning);
420 }
421 } break;
422 case EParameterMerge::kMultiply: {
423 fValue = fValue && val_typed->GetValue();
424 } break;
425 case EParameterMerge::kLast: {
426 fValue = val_typed->GetValue();
427 } break;
428 case EParameterMerge::kMaximum: {
429 if (fValue < val_typed->GetValue()) { fValue = val_typed->GetValue(); }
430 } break;
431 case EParameterMerge::kMinimum: {
432 if (fValue > val_typed->GetValue()) { fValue = val_typed->GetValue(); }
433 } break;
434 default:
435 Cout::PrintInfo(Form("Unknow merging flag druing merging %s", this->GetName()), Hal::EInfo::kError);
436 break;
437 }
438 }
439 }
440
441 ParameterBool::~ParameterBool() {}
442
443 TString ParameterBool::HTMLExtract(Int_t /*counter*/, TString /*dir*/) const {
444 if (fValue) {
445 return "kTRUE";
446 } else {
447 return "kFALSE";
448 }
449 }
450
451 Long64_t Parameter::Merge(TCollection* collection) {
452 if (collection) {
453 Parameter* pack = NULL;
454 TIter iterator(collection);
455 while ((pack = (Parameter*) iterator())) {
456 Add(pack);
457 }
458 }
459 return 1;
460 }
461} // namespace Hal
Hal::Cout::PrintInfo
static void PrintInfo(TString text, Hal::EInfo status)
Definition Cout.cxx:370
Hal::Object::Add
virtual void Add(const Object *pack)
Definition Object.cxx:24
Hal::ParameterBool::Add
void Add(const Object *val)
Definition Parameter.cxx:410
Hal::ParameterBool::HTMLExtract
virtual TString HTMLExtract(Int_t counter=0, TString dir=" ") const
Definition Parameter.cxx:443
Hal::ParameterBool::GetValue
Bool_t GetValue() const
Definition Parameter.h:322
Hal::ParameterDouble::HTMLExtract
virtual TString HTMLExtract(Int_t counter=0, TString dir=" ") const
Definition Parameter.cxx:123
Hal::ParameterDouble::GetValue
Double_t GetValue() const
Definition Parameter.h:142
Hal::ParameterDouble::Add
void Add(const Object *val)
Definition Parameter.cxx:86
Hal::ParameterFloat::GetValue
Float_t GetValue() const
Definition Parameter.h:172
Hal::ParameterFloat::HTMLExtract
virtual TString HTMLExtract(Int_t counter=0, TString dir=" ") const
Definition Parameter.cxx:169
Hal::ParameterFloat::Add
void Add(const Object *val)
Definition Parameter.cxx:132
Hal::ParameterInt::Add
void Add(const Object *val)
Definition Parameter.cxx:362
Hal::ParameterInt::GetValue
Int_t GetValue() const
Definition Parameter.h:112
Hal::ParameterInt::HTMLExtract
virtual TString HTMLExtract(Int_t counter=0, TString dir=" ") const
Definition Parameter.cxx:399
Hal::ParameterString::GetValue
TString GetValue() const
Definition Parameter.h:202
Hal::ParameterString::Add
void Add(const Object *val)
Definition Parameter.cxx:179
Hal::ParameterString::HTMLExtract
virtual TString HTMLExtract(Int_t counter=0, TString dir=" ") const
Definition Parameter.cxx:213
Hal::ParameterUInt::Add
void Add(const Object *val)
Definition Parameter.cxx:221
Hal::ParameterUInt::HTMLExtract
virtual TString HTMLExtract(Int_t counter=0, TString dir=" ") const
Definition Parameter.cxx:255
Hal::ParameterUInt::GetValue
UInt_t GetValue() const
Definition Parameter.h:232
Hal::ParameterULong64::GetValue
ULong64_t GetValue() const
Definition Parameter.h:292
Hal::ParameterULong64::Add
void Add(const Object *val)
Definition Parameter.cxx:314
Hal::ParameterULong64::HTMLExtract
virtual TString HTMLExtract(Int_t counter=0, TString dir=" ") const
Definition Parameter.cxx:351
Hal::ParameterULong::GetValue
ULong_t GetValue() const
Definition Parameter.h:262
Hal::ParameterULong::HTMLExtract
TString HTMLExtract(Int_t counter=0, TString dir=" ") const
Definition Parameter.cxx:302
Hal::ParameterULong::Add
void Add(const Object *val)
Definition Parameter.cxx:265
Hal::Parameter::Merge
Long64_t Merge(TCollection *collection)
Definition Parameter.cxx:451
Hal::Parameter::fMergeMode
EParameterMerge fMergeMode
Definition Parameter.h:39
Hal::Parameter::Browse
void Browse(TBrowser *b)
Definition Parameter.cxx:66
Hal::Parameter::HTMLExtract
virtual TString HTMLExtract(Int_t=0, TString=" ") const
Definition Parameter.h:83
Hal::Parameter::SetMergeMode
void SetMergeMode(Char_t mergemode)
Definition Parameter.cxx:31
Hal::Parameter::CheckName
Bool_t CheckName(const TObject *object)
Definition Parameter.cxx:53