]>
Commit | Line | Data |
---|---|---|
9b0229cf | 1 | #ifndef ALILHCDIPVALT_H |
2 | #define ALILHCDIPVALT_H | |
3 | ||
4 | #include <typeinfo> | |
5 | #include <TString.h> | |
6 | #include <TObjString.h> | |
7 | #include <TObject.h> | |
9b0229cf | 8 | #include "AliLog.h" |
9b0229cf | 9 | |
10 | ||
11 | ///////////////////////////////////////////////////////////////////////////////// | |
12 | // // | |
13 | // AliLHCDipValT: templated class to store the array from processed // | |
14 | // LHC DIP data. Associated with the time stamp either of the value // | |
15 | // acquisition or the last sample timestamp if many samples were processed // | |
16 | // // | |
17 | // Author: ruben.shahoyan@cern.ch // | |
18 | // // | |
19 | ///////////////////////////////////////////////////////////////////////////////// | |
20 | ||
21 | //_______________________________________________________________________________________ | |
22 | template<class Element> class AliLHCDipValT : public TObject | |
23 | { | |
24 | public: | |
25 | // | |
799c6677 | 26 | enum { |
27 | kLastSpecial=BIT(14), // last element of array is special (e.g. assigned error etc) | |
28 | kProcessed1 =BIT(15), // last element of array is special (e.g. assigned error etc) | |
29 | kChar=BIT(22), | |
30 | kFloat=BIT(23) | |
31 | }; | |
32 | // | |
33 | AliLHCDipValT(Int_t size=0, Double_t t=0); | |
34 | AliLHCDipValT(const AliLHCDipValT<Element> &src); | |
9b0229cf | 35 | virtual ~AliLHCDipValT() {delete[] fArray;} |
36 | AliLHCDipValT& operator=(const AliLHCDipValT<Element> &src); | |
9b0229cf | 37 | Element& operator[](Int_t i); |
38 | Element operator[](Int_t i) const; | |
39 | // | |
40 | void SetSize(Int_t size); | |
41 | void SetValue(Int_t i,Element v); | |
42 | void SetValues(const Element *v, Int_t n); | |
43 | void SetTimeStamp(Double_t v) {fTimeStamp = v;} | |
9b0229cf | 44 | // |
94179526 | 45 | Int_t GetSizeTotal() const {return fSizeTot;} |
9b0229cf | 46 | Element GetValue(Int_t i=0) const; |
47 | Element* GetValues() const {return (Element*)fArray;} | |
48 | Double_t GetTimeStamp() const {return fTimeStamp;} | |
63bd40f4 | 49 | Char_t* GetTimeAsString(Bool_t utc=kTRUE) const {return TimeAsString(fTimeStamp,utc);} |
9b0229cf | 50 | // |
799c6677 | 51 | void SetProcessed1(Bool_t v=kTRUE) {SetBit(kProcessed1,v);} |
52 | void SetLastSpecial(Bool_t v=kTRUE) {SetBit(kLastSpecial,v);} | |
53 | Bool_t IsProcessed1() const {return TestBit(kProcessed1);} | |
54 | Bool_t IsLastSpecial() const {return TestBit(kLastSpecial);} | |
55 | Int_t GetSize() const {return IsLastSpecial() ? GetSizeTotal()-1:GetSizeTotal();} | |
56 | Bool_t IsTypeC() const {return TestBit(kChar);} | |
57 | Bool_t IsTypeF() const {return TestBit(kFloat);} | |
58 | Bool_t IsTypeI() const {return !TestBit(kFloat|kChar);} | |
59 | // | |
9b0229cf | 60 | virtual void Clear(const Option_t *opt=""); |
61 | virtual void Print(const Option_t *opt="") const; | |
62 | // | |
63bd40f4 | 63 | static Char_t* TimeAsString(double t,Bool_t utc=kTRUE); |
9b0229cf | 64 | // |
65 | protected: | |
66 | // | |
67 | Double_t fTimeStamp; // timestamp of the entry | |
94179526 | 68 | Int_t fSizeTot; // vector total size (including special slots, like for errors) |
69 | Element* fArray; //[fSizeTot] array of entries | |
9b0229cf | 70 | // |
71 | ClassDef(AliLHCDipValT,1) | |
72 | }; | |
73 | ||
74 | ||
75 | //__________________________________________________________________________ | |
76 | template<class Element> | |
799c6677 | 77 | AliLHCDipValT<Element>::AliLHCDipValT(Int_t size,Double_t t) |
94179526 | 78 | : fTimeStamp(t),fSizeTot(0),fArray(0) |
9b0229cf | 79 | { |
80 | //def. constructor | |
9b0229cf | 81 | SetSize(size); |
799c6677 | 82 | if (!strcmp(typeid(fArray).name(),typeid(Char_t*).name())) SetBit(kChar); |
83 | else if (!strcmp(typeid(fArray).name(),typeid(Double_t*).name()) || | |
84 | !strcmp(typeid(fArray).name(),typeid(Float_t*).name() )) SetBit(kFloat); | |
85 | // | |
9b0229cf | 86 | } |
87 | ||
88 | //__________________________________________________________________________ | |
89 | template<class Element> | |
799c6677 | 90 | AliLHCDipValT<Element>::AliLHCDipValT(const AliLHCDipValT<Element> &src) |
94179526 | 91 | : TObject(src),fTimeStamp(src.fTimeStamp),fSizeTot(0),fArray(0) |
9b0229cf | 92 | { |
93 | //copy constructor | |
799c6677 | 94 | SetSize(src.GetSizeTotal()); |
95 | memcpy(fArray,src.fArray,GetSizeTotal()*sizeof(Element)); | |
9b0229cf | 96 | } |
97 | ||
98 | //__________________________________________________________________________ | |
99 | template<class Element> | |
100 | AliLHCDipValT<Element>& AliLHCDipValT<Element>::operator=(const AliLHCDipValT<Element> &src) | |
101 | { | |
102 | //assingment | |
103 | if (this != &src) { | |
104 | ((TObject*)this)->operator=(src); | |
799c6677 | 105 | if (GetSizeTotal()!=src.GetSizeTotal()) SetSize(src.GetSizeTotal()); |
9b0229cf | 106 | SetTimeStamp(src.GetTimeStamp()); |
799c6677 | 107 | memcpy(fArray,src.fArray,GetSizeTotal()*sizeof(Element)); |
9b0229cf | 108 | } |
109 | return *this; | |
110 | } | |
111 | ||
9b0229cf | 112 | //__________________________________________________________________________ |
113 | template<class Element> | |
63bd40f4 | 114 | Char_t* AliLHCDipValT<Element>::TimeAsString(double t, Bool_t utc) |
9b0229cf | 115 | { |
63bd40f4 | 116 | // time as string in UTC or local format |
9b0229cf | 117 | time_t tt = (time_t) t; |
63bd40f4 | 118 | char* st = utc ? asctime(gmtime(&tt)) : ctime(&tt); |
9b0229cf | 119 | *(strchr(st,'\n')) = 0; |
120 | return st; | |
121 | } | |
122 | ||
123 | //__________________________________________________________________________ | |
124 | template<class Element> | |
125 | void AliLHCDipValT<Element>::SetValue(Int_t i,Element v) | |
126 | { | |
127 | //assign value | |
799c6677 | 128 | if (i>=GetSizeTotal() || i<0) { |
129 | AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1)); | |
9b0229cf | 130 | return; |
131 | } | |
132 | fArray[i] = v; | |
133 | } | |
134 | ||
135 | //__________________________________________________________________________ | |
136 | template<class Element> | |
137 | void AliLHCDipValT<Element>::SetValues(const Element* v, Int_t n) | |
138 | { | |
139 | //assign value | |
799c6677 | 140 | if (n!=GetSizeTotal()) SetSize(n); |
9b0229cf | 141 | memcpy(fArray,v,n*sizeof(Element)); |
142 | } | |
143 | ||
144 | //__________________________________________________________________________ | |
145 | template<class Element> | |
146 | Element& AliLHCDipValT<Element>::operator[](Int_t i) | |
147 | { | |
148 | //obtain value refeterence | |
799c6677 | 149 | if (i>=GetSizeTotal() || i<0) { |
150 | AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1)); | |
9b0229cf | 151 | return fArray[0]; |
152 | } | |
153 | return fArray[i]; | |
154 | } | |
155 | ||
156 | //__________________________________________________________________________ | |
157 | template<class Element> | |
158 | Element AliLHCDipValT<Element>::operator[](Int_t i) const | |
159 | { | |
160 | //obtain value | |
799c6677 | 161 | if (i>=GetSizeTotal() || i<0) { |
162 | AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1)); | |
9b0229cf | 163 | return 0; |
164 | } | |
165 | return fArray[i]; | |
166 | } | |
167 | ||
168 | //__________________________________________________________________________ | |
169 | template<class Element> | |
170 | Element AliLHCDipValT<Element>::GetValue(Int_t i) const | |
171 | { | |
172 | //obtain value | |
799c6677 | 173 | if (i>=GetSizeTotal() || i<0) { |
174 | AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1)); | |
9b0229cf | 175 | return 0; |
176 | } | |
177 | return fArray[i]; | |
178 | } | |
179 | ||
180 | //__________________________________________________________________________ | |
181 | template<class Element> | |
182 | void AliLHCDipValT<Element>::SetSize(Int_t sz) | |
183 | { | |
184 | //resize | |
185 | Element* arr = 0; | |
186 | if (sz>0) { | |
187 | arr = new Element[sz]; | |
799c6677 | 188 | int nc = GetSizeTotal() > sz ? sz:GetSizeTotal(); // n elems to copy |
9b0229cf | 189 | if (nc) memcpy(arr, fArray, nc*sizeof(Element)); |
190 | if (nc<sz) memset(arr+nc, 0, (sz-nc)*sizeof(Element)); | |
799c6677 | 191 | if (GetSizeTotal()) delete[] fArray; |
9b0229cf | 192 | fArray = arr; |
94179526 | 193 | fSizeTot = sz; |
9b0229cf | 194 | } |
195 | else { | |
196 | delete[] fArray; | |
94179526 | 197 | fArray = 0; |
198 | fSizeTot = 0; | |
9b0229cf | 199 | } |
200 | } | |
201 | ||
202 | //__________________________________________________________________________ | |
203 | template<class Element> | |
204 | void AliLHCDipValT<Element>::Print(const Option_t *opt) const | |
205 | { | |
206 | // print time and value | |
207 | TString str = opt; | |
208 | str.ToLower(); | |
799c6677 | 209 | if (str.Contains("raw")) printf("%.1f ",GetTimeStamp()); |
63bd40f4 | 210 | else printf("[%s] ",GetTimeAsString(!str.Contains("loc"))); |
9b0229cf | 211 | // |
212 | TString tp = typeid(fArray).name(); | |
799c6677 | 213 | if ( tp==typeid(Char_t*).name() ) printf(": %s\n",(Char_t*)fArray); |
9b0229cf | 214 | else { |
799c6677 | 215 | int sz = GetSize(); |
216 | if (sz>1) printf("\n"); | |
217 | Bool_t eolOK = kFALSE; | |
218 | for (int i=0;i<sz;i++) { | |
63bd40f4 | 219 | if (tp == typeid(Int_t*).name() || tp == typeid(UInt_t*).name() ) { |
220 | if (!str.Contains("bit")) printf(" %6d |" ,(Int_t)fArray[i]); | |
221 | else { | |
222 | printf(" "); | |
223 | int val = (int)fArray[i]; | |
224 | for (int j=sizeof(int)*8;j--;) printf("%d",(val>>j)&0x1); | |
225 | printf(" |"); | |
226 | } | |
227 | ||
228 | } | |
799c6677 | 229 | else if (tp == typeid(Double_t*).name() || tp == typeid(Float_t*).name()) printf(" %+.3e |",(Float_t)fArray[i]); |
9b0229cf | 230 | else printf(" "); |
799c6677 | 231 | eolOK = kFALSE; |
232 | if ( (i+1)%5 == 0) {printf("\n"); eolOK = kTRUE;} | |
233 | } | |
234 | if (IsLastSpecial()) { | |
235 | if (sz>1 && !eolOK) {printf("\n"); eolOK = kTRUE;} | |
236 | if (tp == typeid(Double_t*).name() || tp == typeid(Float_t*).name()) { | |
237 | printf(" Error: %+e\n",(Float_t)fArray[sz]); | |
238 | eolOK = kTRUE; | |
239 | } | |
9b0229cf | 240 | } |
799c6677 | 241 | if (!eolOK) printf("\n"); |
9b0229cf | 242 | } |
243 | // | |
244 | } | |
245 | ||
246 | //__________________________________________________________________________ | |
247 | template<class Element> | |
248 | void AliLHCDipValT<Element>::Clear(const Option_t *) | |
249 | { | |
250 | // reset to 0 everything | |
9b0229cf | 251 | SetTimeStamp(0); |
799c6677 | 252 | memset(fArray,0,GetSizeTotal()*sizeof(Element)); |
9b0229cf | 253 | } |
254 | ||
255 | ||
256 | typedef AliLHCDipValT<Double_t> AliLHCDipValD; | |
257 | typedef AliLHCDipValT<Float_t> AliLHCDipValF; | |
258 | typedef AliLHCDipValT<Int_t> AliLHCDipValI; | |
259 | typedef AliLHCDipValT<Char_t> AliLHCDipValC; | |
260 | ||
261 | ||
262 | ||
263 | #endif |