| Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 1 // Copyright (C) 2010, Guy Barrand. All rights reserved.
2 // See the file tools.license for terms. 2 // See the file tools.license for terms.
3 3
4 #ifndef tools_aida_ntuple 4 #ifndef tools_aida_ntuple
5 #define tools_aida_ntuple 5 #define tools_aida_ntuple
6 6
7 // An in memory ntuple able to have "sub ntupl 7 // An in memory ntuple able to have "sub ntuple" on a column.
8 // It is used in ioda to read ntuples in XML/A 8 // It is used in ioda to read ntuples in XML/AIDA files.
9 9
10 #ifdef TOOLS_MEM 10 #ifdef TOOLS_MEM
11 #include "mem" 11 #include "mem"
12 #endif 12 #endif
13 13
14 #include "vmanip" 14 #include "vmanip"
15 #include "vfind" 15 #include "vfind"
16 #include "typedefs" 16 #include "typedefs"
17 #include "scast" 17 #include "scast"
18 #include "forit" 18 #include "forit"
19 #include "ntuple_binding" 19 #include "ntuple_binding"
20 #include "mnmx" 20 #include "mnmx"
21 21
22 #include <string> 22 #include <string>
23 #include <vector> 23 #include <vector>
24 #include <ostream> 24 #include <ostream>
25 25
26 namespace tools { 26 namespace tools {
27 namespace aida { 27 namespace aida {
28 28
29 class base_col { 29 class base_col {
30 public: 30 public:
31 static const std::string& s_class() { 31 static const std::string& s_class() {
32 static const std::string s_v("tools::aida: 32 static const std::string s_v("tools::aida::base_col");
33 return s_v; 33 return s_v;
34 } 34 }
35 virtual void* cast(const std::string& a_clas 35 virtual void* cast(const std::string& a_class) const {
36 if(void* p = cmp_cast<base_col>(this,a_cla 36 if(void* p = cmp_cast<base_col>(this,a_class)) {return p;}
37 return 0; 37 return 0;
38 } 38 }
39 public: 39 public:
40 virtual base_col* copy() const = 0; 40 virtual base_col* copy() const = 0;
41 virtual uint64 num_elems() const = 0; 41 virtual uint64 num_elems() const = 0;
42 virtual bool add() = 0; 42 virtual bool add() = 0;
43 virtual bool reset() = 0; 43 virtual bool reset() = 0;
44 //binded column reading API : 44 //binded column reading API :
45 virtual bool fetch_entry() const = 0; 45 virtual bool fetch_entry() const = 0;
46 virtual void set_user_variable(void*) = 0; 46 virtual void set_user_variable(void*) = 0;
47 protected: 47 protected:
48 base_col(std::ostream& a_out,const std::stri 48 base_col(std::ostream& a_out,const std::string& a_name)
49 :m_out(a_out) 49 :m_out(a_out)
50 ,m_name(a_name),m_index(0){ 50 ,m_name(a_name),m_index(0){
51 #ifdef TOOLS_MEM 51 #ifdef TOOLS_MEM
52 mem::increment(s_class().c_str()); 52 mem::increment(s_class().c_str());
53 #endif 53 #endif
54 } 54 }
55 public: 55 public:
56 virtual ~base_col(){ 56 virtual ~base_col(){
57 #ifdef TOOLS_MEM 57 #ifdef TOOLS_MEM
58 mem::decrement(s_class().c_str()); 58 mem::decrement(s_class().c_str());
59 #endif 59 #endif
60 } 60 }
61 protected: 61 protected:
62 base_col(const base_col& a_from) 62 base_col(const base_col& a_from)
63 :m_out(a_from.m_out) 63 :m_out(a_from.m_out)
64 ,m_name(a_from.m_name) 64 ,m_name(a_from.m_name)
65 ,m_index(a_from.m_index){ 65 ,m_index(a_from.m_index){
66 #ifdef TOOLS_MEM 66 #ifdef TOOLS_MEM
67 mem::increment(s_class().c_str()); 67 mem::increment(s_class().c_str());
68 #endif 68 #endif
69 } 69 }
70 base_col& operator=(const base_col& a_from){ 70 base_col& operator=(const base_col& a_from){
71 m_name = a_from.m_name; 71 m_name = a_from.m_name;
72 m_index = a_from.m_index; 72 m_index = a_from.m_index;
73 return *this; 73 return *this;
74 } 74 }
75 public: 75 public:
76 const std::string& name() const {return m_na 76 const std::string& name() const {return m_name;}
77 77
78 void set_index(uint64 a_index){m_index = a_i 78 void set_index(uint64 a_index){m_index = a_index;}
79 protected: 79 protected:
80 std::ostream& m_out; 80 std::ostream& m_out;
81 std::string m_name; 81 std::string m_name;
82 uint64 m_index; 82 uint64 m_index;
83 }; 83 };
84 84
85 class base_ntu { 85 class base_ntu {
86 public: 86 public:
87 static const std::string& s_class() { 87 static const std::string& s_class() {
88 static const std::string s_v("tools::aida: 88 static const std::string s_v("tools::aida::base_ntu");
89 return s_v; 89 return s_v;
90 } 90 }
91 virtual void* cast(const std::string& a_clas 91 virtual void* cast(const std::string& a_class) const {
92 if(void* p = cmp_cast<base_ntu>(this,a_cla 92 if(void* p = cmp_cast<base_ntu>(this,a_class)) {return p;}
93 return 0; 93 return 0;
94 } 94 }
95 protected: 95 protected:
96 base_ntu(std::ostream& a_out,const std::stri 96 base_ntu(std::ostream& a_out,const std::string& a_title)
97 :m_out(a_out),m_title(a_title),m_index(-1){ 97 :m_out(a_out),m_title(a_title),m_index(-1){
98 #ifdef TOOLS_MEM 98 #ifdef TOOLS_MEM
99 mem::increment(s_class().c_str()); 99 mem::increment(s_class().c_str());
100 #endif 100 #endif
101 } 101 }
102 virtual ~base_ntu() { 102 virtual ~base_ntu() {
103 clear(); 103 clear();
104 #ifdef TOOLS_MEM 104 #ifdef TOOLS_MEM
105 mem::decrement(s_class().c_str()); 105 mem::decrement(s_class().c_str());
106 #endif 106 #endif
107 } 107 }
108 protected: 108 protected:
109 base_ntu(const base_ntu& a_from) 109 base_ntu(const base_ntu& a_from)
110 :m_out(a_from.m_out) 110 :m_out(a_from.m_out)
111 ,m_title(a_from.m_title),m_index(a_from.m_in 111 ,m_title(a_from.m_title),m_index(a_from.m_index)
112 { 112 {
113 #ifdef TOOLS_MEM 113 #ifdef TOOLS_MEM
114 mem::increment(s_class().c_str()); 114 mem::increment(s_class().c_str());
115 #endif 115 #endif
116 tools_vforcit(base_col*,a_from.m_cols,it) 116 tools_vforcit(base_col*,a_from.m_cols,it) {
117 base_col* column = (*it)->copy(); 117 base_col* column = (*it)->copy();
118 if(!column) { 118 if(!column) {
119 m_out << s_class() << "::cstor :" 119 m_out << s_class() << "::cstor :"
120 << " can't copy column." 120 << " can't copy column."
121 << std::endl; 121 << std::endl;
122 safe_clear<base_col>(m_cols); 122 safe_clear<base_col>(m_cols);
123 m_index = -1; 123 m_index = -1;
124 return; //throw 124 return; //throw
125 } 125 }
126 m_cols.push_back(column); 126 m_cols.push_back(column);
127 } 127 }
128 } 128 }
129 base_ntu& operator=(const base_ntu& a_from){ 129 base_ntu& operator=(const base_ntu& a_from){
130 if(&a_from==this) return *this; 130 if(&a_from==this) return *this;
131 131
132 safe_clear<base_col>(m_cols); 132 safe_clear<base_col>(m_cols);
133 m_index = a_from.m_index; 133 m_index = a_from.m_index;
134 134
135 m_title = a_from.m_title; 135 m_title = a_from.m_title;
136 tools_vforcit(base_col*,a_from.m_cols,it) 136 tools_vforcit(base_col*,a_from.m_cols,it) {
137 base_col* column = (*it)->copy(); 137 base_col* column = (*it)->copy();
138 if(!column) { 138 if(!column) {
139 m_out << s_class() << "::operator=() : 139 m_out << s_class() << "::operator=() :"
140 << " can't copy column." 140 << " can't copy column."
141 << std::endl; 141 << std::endl;
142 safe_clear<base_col>(m_cols); 142 safe_clear<base_col>(m_cols);
143 m_index = -1; 143 m_index = -1;
144 return *this; 144 return *this;
145 } 145 }
146 m_cols.push_back(column); 146 m_cols.push_back(column);
147 } 147 }
148 148
149 return *this; 149 return *this;
150 } 150 }
151 public: 151 public:
152 std::ostream& out() const {return m_out;} 152 std::ostream& out() const {return m_out;}
153 const std::vector<base_col*>& columns() cons 153 const std::vector<base_col*>& columns() const {return m_cols;}
154 size_t number_of_columns() const {return m_c 154 size_t number_of_columns() const {return m_cols.size();}
155 155
156 #ifdef tools_aida_ntuple 156 #ifdef tools_aida_ntuple
157 const std::vector<base_col*>& cols() const { 157 const std::vector<base_col*>& cols() const {return m_cols;} //deprecated : use columns().
158 #endif 158 #endif
159 159
160 void column_names(std::vector<std::string>& 160 void column_names(std::vector<std::string>& a_names) const {
161 a_names.clear(); 161 a_names.clear();
162 tools_vforcit(base_col*,m_cols,it) a_names 162 tools_vforcit(base_col*,m_cols,it) a_names.push_back((*it)->name());
163 } 163 }
164 164
165 const std::string& title() const {return m_t 165 const std::string& title() const {return m_title;}
166 void set_title(const std::string& a_title) { 166 void set_title(const std::string& a_title) {m_title = a_title;}
167 167
168 uint64 rows() const { 168 uint64 rows() const {
169 if(m_cols.empty()) return 0; 169 if(m_cols.empty()) return 0;
170 return m_cols.front()->num_elems(); 170 return m_cols.front()->num_elems();
171 } 171 }
172 bool number_of_entries(uint64& a_value) cons 172 bool number_of_entries(uint64& a_value) const {
173 if(m_cols.empty()) {a_value = 0;return fal 173 if(m_cols.empty()) {a_value = 0;return false;}
174 a_value = m_cols.front()->num_elems(); 174 a_value = m_cols.front()->num_elems();
175 return true; 175 return true;
176 } 176 }
177 177
178 void clear() { //must not be confused with r 178 void clear() { //must not be confused with reset().
179 safe_clear<base_col>(m_cols); 179 safe_clear<base_col>(m_cols);
180 m_index = -1; 180 m_index = -1;
181 } 181 }
182 182
183 bool reset() { //clear data in columns (but 183 bool reset() { //clear data in columns (but not the column set)
184 bool status = true; 184 bool status = true;
185 tools_vforit(base_col*,m_cols,it) { 185 tools_vforit(base_col*,m_cols,it) {
186 if(!(*it)->reset()) status = false; 186 if(!(*it)->reset()) status = false;
187 } 187 }
188 m_index = -1; 188 m_index = -1;
189 return status; 189 return status;
190 } 190 }
191 191
192 // reading : 192 // reading :
193 void start() {m_index = -1;set_columns_index 193 void start() {m_index = -1;set_columns_index(0);}
194 bool next() { 194 bool next() {
195 // a tuple loop is of the form : 195 // a tuple loop is of the form :
196 // tuple.start(); 196 // tuple.start();
197 // while(tuple.next()) { 197 // while(tuple.next()) {
198 // ... 198 // ...
199 // double v; 199 // double v;
200 // if(!col->get_entry(v)) {} 200 // if(!col->get_entry(v)) {}
201 // ... 201 // ...
202 // } 202 // }
203 if((m_index+1)>=(int64)rows()) return fals 203 if((m_index+1)>=(int64)rows()) return false;
204 m_index++; 204 m_index++;
205 set_columns_index(m_index); 205 set_columns_index(m_index);
206 return true; 206 return true;
207 } 207 }
208 int64 row_index() const {return m_index;} 208 int64 row_index() const {return m_index;}
209 209
210 // filling : 210 // filling :
211 bool add_row() { 211 bool add_row() {
212 bool status = true; 212 bool status = true;
213 tools_vforit(base_col*,m_cols,it) { 213 tools_vforit(base_col*,m_cols,it) {
214 if(!(*it)->add()) status = false; 214 if(!(*it)->add()) status = false;
215 } 215 }
216 return status; 216 return status;
217 } 217 }
218 public: 218 public:
219 base_col* find_column(const std::string& a_n 219 base_col* find_column(const std::string& a_name){
220 return find_named<base_col>(m_cols,a_name) 220 return find_named<base_col>(m_cols,a_name);
221 } 221 }
222 222
223 void add_column(base_col* a_col) { //we take 223 void add_column(base_col* a_col) { //we take ownership.
224 m_cols.push_back(a_col); 224 m_cols.push_back(a_col);
225 } 225 }
226 226
227 protected: 227 protected:
228 void set_columns_index(uint64 a_index) { 228 void set_columns_index(uint64 a_index) {
229 tools_vforit(base_col*,m_cols,it) { 229 tools_vforit(base_col*,m_cols,it) {
230 (*it)->set_index(a_index); 230 (*it)->set_index(a_index);
231 } 231 }
232 } 232 }
233 protected: 233 protected:
234 std::ostream& m_out; 234 std::ostream& m_out;
235 std::string m_title; 235 std::string m_title;
236 int64 m_index; 236 int64 m_index;
237 std::vector<base_col*> m_cols; 237 std::vector<base_col*> m_cols;
238 }; 238 };
239 239
240 }} 240 }}
241 241
242 #include "tos" 242 #include "tos"
243 #include "sto" 243 #include "sto"
244 #include "columns" 244 #include "columns"
245 #include "stype" 245 #include "stype"
246 246
247 namespace tools { 247 namespace tools {
248 namespace aida { 248 namespace aida {
249 249
250 //inline const std::string& s_aida_type(char) 250 //inline const std::string& s_aida_type(char) {
251 // static const std::string s_v("char"); 251 // static const std::string s_v("char");
252 // return s_v; 252 // return s_v;
253 //} 253 //}
254 inline const std::string& s_aida_type(short) { 254 inline const std::string& s_aida_type(short) {
255 static const std::string s_v("short"); 255 static const std::string s_v("short");
256 return s_v; 256 return s_v;
257 } 257 }
258 inline const std::string& s_aida_type(int) { 258 inline const std::string& s_aida_type(int) {
259 static const std::string s_v("int"); 259 static const std::string s_v("int");
260 return s_v; 260 return s_v;
261 } 261 }
262 inline const std::string& s_aida_type(float) { 262 inline const std::string& s_aida_type(float) {
263 static const std::string s_v("float"); 263 static const std::string s_v("float");
264 return s_v; 264 return s_v;
265 } 265 }
266 inline const std::string& s_aida_type(double) 266 inline const std::string& s_aida_type(double) {
267 static const std::string s_v("double"); 267 static const std::string s_v("double");
268 return s_v; 268 return s_v;
269 } 269 }
270 270
271 ///////////////////////////////////////// 271 /////////////////////////////////////////
272 ///////////////////////////////////////// 272 /////////////////////////////////////////
273 //inline const std::string& s_aida_type(unsign 273 //inline const std::string& s_aida_type(unsigned char) {
274 // static const std::string s_v("byte"); 274 // static const std::string s_v("byte");
275 // return s_v; 275 // return s_v;
276 //} 276 //}
277 277
278 inline const std::string& s_aida_type(bool) { 278 inline const std::string& s_aida_type(bool) {
279 static const std::string s_v("boolean"); 279 static const std::string s_v("boolean");
280 return s_v; 280 return s_v;
281 } 281 }
282 inline const std::string& s_aida_type(const st 282 inline const std::string& s_aida_type(const std::string&) {
283 static const std::string s_v("string"); 283 static const std::string s_v("string");
284 return s_v; 284 return s_v;
285 } 285 }
286 inline const std::string& s_aida_type(int64) { 286 inline const std::string& s_aida_type(int64) {
287 static const std::string s_v("long"); 287 static const std::string s_v("long");
288 return s_v; 288 return s_v;
289 } 289 }
290 /* 290 /*
291 inline const std::string& s_aida_type(const st 291 inline const std::string& s_aida_type(const std::vector<double>&) {
292 static const std::string s_v("double[]"); 292 static const std::string s_v("double[]");
293 return s_v; 293 return s_v;
294 } 294 }
295 */ 295 */
296 inline const std::string& s_aida_type_ituple() 296 inline const std::string& s_aida_type_ituple() {
297 static const std::string s_v("ITuple"); 297 static const std::string s_v("ITuple");
298 return s_v; 298 return s_v;
299 } 299 }
300 300
301 ///////////////////////////////////////// 301 /////////////////////////////////////////
302 /// not AIDA ! ////////////////////////// 302 /// not AIDA ! //////////////////////////
303 ///////////////////////////////////////// 303 /////////////////////////////////////////
304 inline const std::string& s_aida_type(unsigned 304 inline const std::string& s_aida_type(unsigned short) {
305 static const std::string s_v("ushort"); 305 static const std::string s_v("ushort");
306 return s_v; 306 return s_v;
307 } 307 }
308 inline const std::string& s_aida_type(unsigned 308 inline const std::string& s_aida_type(unsigned int) {
309 static const std::string s_v("uint"); 309 static const std::string s_v("uint");
310 return s_v; 310 return s_v;
311 } 311 }
312 inline const std::string& s_aida_type(uint64) 312 inline const std::string& s_aida_type(uint64) {
313 static const std::string s_v("ulong"); 313 static const std::string s_v("ulong");
314 return s_v; 314 return s_v;
315 } 315 }
316 316
317 class aida_base_col : public base_col { 317 class aida_base_col : public base_col {
318 public: 318 public:
319 static const std::string& s_class() { 319 static const std::string& s_class() {
320 static const std::string s_v("tools::aida: 320 static const std::string s_v("tools::aida::aida_base_col");
321 return s_v; 321 return s_v;
322 } 322 }
323 virtual void* cast(const std::string& a_clas 323 virtual void* cast(const std::string& a_class) const {
324 if(void* p = cmp_cast<aida_base_col>(this, 324 if(void* p = cmp_cast<aida_base_col>(this,a_class)) {return p;}
325 return base_col::cast(a_class); 325 return base_col::cast(a_class);
326 } 326 }
327 public: 327 public:
328 virtual const std::string& aida_type() const 328 virtual const std::string& aida_type() const = 0;
329 virtual bool s_default_value(std::string&) c 329 virtual bool s_default_value(std::string&) const = 0;
330 virtual bool s_value(std::string&) const = 0 330 virtual bool s_value(std::string&) const = 0;
331 virtual bool s_fill(const std::string&) = 0; 331 virtual bool s_fill(const std::string&) = 0;
332 public: 332 public:
333 aida_base_col(std::ostream& a_out,const std: 333 aida_base_col(std::ostream& a_out,const std::string& a_name)
334 :base_col(a_out,a_name){} 334 :base_col(a_out,a_name){}
335 public: 335 public:
336 virtual ~aida_base_col(){} 336 virtual ~aida_base_col(){}
337 public: 337 public:
338 aida_base_col(const aida_base_col& a_from) 338 aida_base_col(const aida_base_col& a_from)
339 :base_col(a_from) 339 :base_col(a_from)
340 {} 340 {}
341 aida_base_col& operator=(const aida_base_col 341 aida_base_col& operator=(const aida_base_col& a_from){
342 base_col::operator=(a_from); 342 base_col::operator=(a_from);
343 return *this; 343 return *this;
344 } 344 }
345 }; 345 };
346 346
347 inline bool s__fill(const std::string& a_s,std 347 inline bool s__fill(const std::string& a_s,std::string& a_v) {
348 a_v = a_s; 348 a_v = a_s;
349 return true; 349 return true;
350 } 350 }
351 inline bool s__fill(const std::string& a_s,cha 351 inline bool s__fill(const std::string& a_s,char& a_v) {
352 //for exlib/cbk/aida_ntu 352 //for exlib/cbk/aida_ntu
353 if(a_s.empty()) return false; 353 if(a_s.empty()) return false;
354 a_v = a_s[0]; 354 a_v = a_s[0];
355 return true; 355 return true;
356 } 356 }
357 inline bool s__fill(const std::string& a_s,uns 357 inline bool s__fill(const std::string& a_s,unsigned char& a_v) {
358 //for exlib/cbk/aida_ntu 358 //for exlib/cbk/aida_ntu
359 if(a_s.empty()) return false; 359 if(a_s.empty()) return false;
360 a_v = a_s[0]; 360 a_v = a_s[0];
361 return true; 361 return true;
362 } 362 }
363 inline bool s__fill(const std::string& a_s,boo 363 inline bool s__fill(const std::string& a_s,bool& a_v) {
364 return to(a_s,a_v); 364 return to(a_s,a_v);
365 } 365 }
366 inline bool s__fill(const std::string& a_s,sho 366 inline bool s__fill(const std::string& a_s,short& a_v) {
367 return to<short>(a_s,a_v); 367 return to<short>(a_s,a_v);
368 } 368 }
369 inline bool s__fill(const std::string& a_s,uns 369 inline bool s__fill(const std::string& a_s,unsigned short& a_v) {
370 return to<unsigned short>(a_s,a_v); 370 return to<unsigned short>(a_s,a_v);
371 } 371 }
372 inline bool s__fill(const std::string& a_s,int 372 inline bool s__fill(const std::string& a_s,int& a_v) {
373 return to<int>(a_s,a_v); 373 return to<int>(a_s,a_v);
374 } 374 }
375 inline bool s__fill(const std::string& a_s,uns 375 inline bool s__fill(const std::string& a_s,unsigned int& a_v) {
376 return to<unsigned int>(a_s,a_v); 376 return to<unsigned int>(a_s,a_v);
377 } 377 }
378 inline bool s__fill(const std::string& a_s,int 378 inline bool s__fill(const std::string& a_s,int64& a_v) {
379 return to<int64>(a_s,a_v); 379 return to<int64>(a_s,a_v);
380 } 380 }
381 inline bool s__fill(const std::string& a_s,uin 381 inline bool s__fill(const std::string& a_s,uint64& a_v) {
382 return to<uint64>(a_s,a_v); 382 return to<uint64>(a_s,a_v);
383 } 383 }
384 inline bool s__fill(const std::string& a_s,flo 384 inline bool s__fill(const std::string& a_s,float& a_v) {
385 return to<float>(a_s,a_v); 385 return to<float>(a_s,a_v);
386 } 386 }
387 inline bool s__fill(const std::string& a_s,dou 387 inline bool s__fill(const std::string& a_s,double& a_v) {
388 return to<double>(a_s,a_v); 388 return to<double>(a_s,a_v);
389 } 389 }
390 390
391 template <class T> 391 template <class T>
392 class aida_col : public aida_base_col { 392 class aida_col : public aida_base_col {
393 public: 393 public:
394 typedef T entry_t; 394 typedef T entry_t;
395 public: 395 public:
396 static const std::string& s_class() { 396 static const std::string& s_class() {
397 static const std::string s_v("tools::aida: 397 static const std::string s_v("tools::aida::aida_col<"+stype(T())+">");
398 return s_v; 398 return s_v;
399 } 399 }
400 virtual void* cast(const std::string& a_clas 400 virtual void* cast(const std::string& a_class) const {
401 if(void* p = cmp_cast< aida_col<T> >(this, 401 if(void* p = cmp_cast< aida_col<T> >(this,a_class)) {return p;}
402 return aida_base_col::cast(a_class); 402 return aida_base_col::cast(a_class);
403 } 403 }
404 public: 404 public:
405 virtual base_col* copy() const {return new a 405 virtual base_col* copy() const {return new aida_col(*this);}
406 virtual bool add() {m_data.push_back(m_tmp); 406 virtual bool add() {m_data.push_back(m_tmp);m_tmp = m_default;return true;}
407 virtual bool reset() { 407 virtual bool reset() {
408 m_data.clear(); 408 m_data.clear();
409 m_index = 0; 409 m_index = 0;
410 m_tmp = m_default; 410 m_tmp = m_default;
411 return true; 411 return true;
412 } 412 }
413 virtual uint64 num_elems() const {return m_d 413 virtual uint64 num_elems() const {return m_data.size();}
414 public: 414 public:
415 virtual const std::string& aida_type() const 415 virtual const std::string& aida_type() const {return s_aida_type(T());}
416 virtual bool s_default_value(std::string& a_ 416 virtual bool s_default_value(std::string& a_s) const {
417 a_s = tos(m_default); 417 a_s = tos(m_default);
418 return true; 418 return true;
419 } 419 }
420 virtual bool s_value(std::string& a_s) const 420 virtual bool s_value(std::string& a_s) const {
421 typedef typename std::vector<T>::size_type 421 typedef typename std::vector<T>::size_type sz_t;
422 a_s = tos(m_data[sz_t(m_index)]); 422 a_s = tos(m_data[sz_t(m_index)]);
423 return true; 423 return true;
424 } 424 }
425 425
426 // for exlib/raxml/tuple : 426 // for exlib/raxml/tuple :
427 virtual bool s_fill(const std::string& a_s) 427 virtual bool s_fill(const std::string& a_s) {
428 //if(!to<T>(a_s,m_tmp)) { 428 //if(!to<T>(a_s,m_tmp)) {
429 if(!s__fill(a_s,m_tmp)) { 429 if(!s__fill(a_s,m_tmp)) {
430 m_out << s_class() << "::fill :" 430 m_out << s_class() << "::fill :"
431 << " can't convert " << sout(a_s) 431 << " can't convert " << sout(a_s) << "."
432 << std::endl; 432 << std::endl;
433 return false; 433 return false;
434 } 434 }
435 return true; 435 return true;
436 } 436 }
437 437
438 virtual void set_user_variable(void* a_user_ 438 virtual void set_user_variable(void* a_user_var) {m_user_var = (T*)a_user_var;} //not owner.
439 public: 439 public:
440 aida_col(std::ostream& a_out,const std::stri 440 aida_col(std::ostream& a_out,const std::string& a_name,const T& a_def)
441 :aida_base_col(a_out,a_name) 441 :aida_base_col(a_out,a_name)
442 ,m_default(a_def) 442 ,m_default(a_def)
443 ,m_tmp(a_def) 443 ,m_tmp(a_def)
444 ,m_user_var(0) //not owner 444 ,m_user_var(0) //not owner
445 {} 445 {}
446 public: 446 public:
447 virtual ~aida_col(){} 447 virtual ~aida_col(){}
448 public: 448 public:
449 aida_col(const aida_col& a_from) 449 aida_col(const aida_col& a_from)
450 :aida_base_col(a_from) 450 :aida_base_col(a_from)
451 ,m_data(a_from.m_data) 451 ,m_data(a_from.m_data)
452 ,m_default(a_from.m_default) 452 ,m_default(a_from.m_default)
453 ,m_tmp(a_from.m_tmp) 453 ,m_tmp(a_from.m_tmp)
454 ,m_user_var(a_from.m_user_var) 454 ,m_user_var(a_from.m_user_var)
455 {} 455 {}
456 aida_col& operator=(const aida_col& a_from){ 456 aida_col& operator=(const aida_col& a_from){
457 aida_base_col::operator=(a_from); 457 aida_base_col::operator=(a_from);
458 if(&a_from==this) return *this; 458 if(&a_from==this) return *this;
459 m_data = a_from.m_data; 459 m_data = a_from.m_data;
460 m_default = a_from.m_default; 460 m_default = a_from.m_default;
461 m_tmp = a_from.m_tmp; 461 m_tmp = a_from.m_tmp;
462 m_user_var = a_from.m_user_var; 462 m_user_var = a_from.m_user_var;
463 return *this; 463 return *this;
464 } 464 }
465 public: 465 public:
466 bool fill(const T& a_value) {m_tmp = a_value 466 bool fill(const T& a_value) {m_tmp = a_value;return true;}
467 bool get_entry(T& a_v) const { 467 bool get_entry(T& a_v) const {
468 if(m_index>=m_data.size()) { 468 if(m_index>=m_data.size()) {
469 m_out << s_class() << "::get_entry :" 469 m_out << s_class() << "::get_entry :"
470 << " bad index " << m_index 470 << " bad index " << m_index
471 << ". Vec size is " << m_data.size 471 << ". Vec size is " << m_data.size() << "."
472 << "." 472 << "."
473 << std::endl; 473 << std::endl;
474 a_v = T(); 474 a_v = T();
475 return false; 475 return false;
476 } 476 }
477 typedef typename std::vector<T>::size_type 477 typedef typename std::vector<T>::size_type sz_t;
478 a_v = m_data[sz_t(m_index)]; 478 a_v = m_data[sz_t(m_index)];
479 return true; 479 return true;
480 } 480 }
481 virtual bool fetch_entry() const { 481 virtual bool fetch_entry() const {
482 //NOTE : it is ok to have a NULL m_user_va 482 //NOTE : it is ok to have a NULL m_user_var.
483 if(m_index>=m_data.size()) { 483 if(m_index>=m_data.size()) {
484 m_out << s_class() << "::get_entry :" 484 m_out << s_class() << "::get_entry :"
485 << " bad index " << m_index 485 << " bad index " << m_index
486 << ". Vec size is " << m_data.size 486 << ". Vec size is " << m_data.size() << "."
487 << "." 487 << "."
488 << std::endl; 488 << std::endl;
489 if(m_user_var) *m_user_var = T(); 489 if(m_user_var) *m_user_var = T();
490 return false; 490 return false;
491 } 491 }
492 typedef typename std::vector<T>::size_type 492 typedef typename std::vector<T>::size_type sz_t;
493 if(m_user_var) *m_user_var = m_data[sz_t(m 493 if(m_user_var) *m_user_var = m_data[sz_t(m_index)];
494 return true; 494 return true;
495 } 495 }
496 protected: 496 protected:
497 std::vector<T> m_data; 497 std::vector<T> m_data;
498 T m_default; 498 T m_default;
499 T m_tmp; 499 T m_tmp;
500 T* m_user_var; 500 T* m_user_var;
501 }; 501 };
502 502
503 class ntuple : public base_ntu { 503 class ntuple : public base_ntu {
504 public: 504 public:
505 static cid id_class() {return 2000;} //for n 505 static cid id_class() {return 2000;} //for ntuple_binding.
506 public: 506 public:
507 static const std::string& s_class() { 507 static const std::string& s_class() {
508 static const std::string s_v("tools::aida: 508 static const std::string s_v("tools::aida::ntuple");
509 return s_v; 509 return s_v;
510 } 510 }
511 virtual void* cast(const std::string& a_clas 511 virtual void* cast(const std::string& a_class) const {
512 if(void* p = cmp_cast<ntuple>(this,a_class 512 if(void* p = cmp_cast<ntuple>(this,a_class)) {return p;}
513 return base_ntu::cast(a_class); 513 return base_ntu::cast(a_class);
514 } 514 }
515 virtual const std::string& s_cls() const {re 515 virtual const std::string& s_cls() const {return s_class();}
516 public: 516 public:
517 ntuple(std::ostream& a_out,const std::string 517 ntuple(std::ostream& a_out,const std::string& a_title)
518 :base_ntu(a_out,a_title) 518 :base_ntu(a_out,a_title)
519 {} 519 {}
520 virtual ~ntuple() {} 520 virtual ~ntuple() {}
521 public: 521 public:
522 ntuple(const ntuple& a_from): base_ntu(a_fro 522 ntuple(const ntuple& a_from): base_ntu(a_from){}
523 ntuple& operator=(const ntuple& a_from){ 523 ntuple& operator=(const ntuple& a_from){
524 base_ntu::operator=(a_from); 524 base_ntu::operator=(a_from);
525 return *this; 525 return *this;
526 } 526 }
527 public: 527 public:
528 template <class T> 528 template <class T>
529 aida_col<T>* create_col(const std::string& a 529 aida_col<T>* create_col(const std::string& a_name,const T& a_def = T()) {
530 if(find_named<base_col>(m_cols,a_name)) { 530 if(find_named<base_col>(m_cols,a_name)) {
531 m_out << s_class() << "::create_col :" 531 m_out << s_class() << "::create_col :"
532 << " a column with name " << sout( 532 << " a column with name " << sout(a_name) << " already exists."
533 << std::endl; 533 << std::endl;
534 return 0; 534 return 0;
535 } 535 }
536 aida_col<T>* col = new aida_col<T>(m_out,a 536 aida_col<T>* col = new aida_col<T>(m_out,a_name,a_def);
537 if(!col) { 537 if(!col) {
538 m_out << s_class() << "::create_col :" 538 m_out << s_class() << "::create_col :"
539 << " can't create aida_col<T> " << 539 << " can't create aida_col<T> " << sout(a_name) << "."
540 << std::endl; 540 << std::endl;
541 return 0; 541 return 0;
542 } 542 }
543 m_cols.push_back(col); 543 m_cols.push_back(col);
544 return col; 544 return col;
545 } 545 }
546 546
547 template <class T> 547 template <class T>
548 aida_col<T>* find_column(const std::string& 548 aida_col<T>* find_column(const std::string& a_name){
549 base_col* col = find_named<base_col>(m_col 549 base_col* col = find_named<base_col>(m_cols,a_name);
550 if(!col) return 0; 550 if(!col) return 0;
551 return safe_cast<base_col, aida_col<T> >(* 551 return safe_cast<base_col, aida_col<T> >(*col);
552 } 552 }
553 553
554 template <class T> 554 template <class T>
555 bool find_column(const std::string& a_name,a 555 bool find_column(const std::string& a_name,aida_col<T>*& a_col,bool a_case_sensitive = true) { //for exlib::evaluator.
556 base_col* col = a_case_sensitive ? find_na 556 base_col* col = a_case_sensitive ? find_named<base_col>(m_cols,a_name) : find_named_case_insensitive<base_col>(m_cols,a_name);
557 if(!col) {a_col = 0;return false;} 557 if(!col) {a_col = 0;return false;}
558 a_col = safe_cast<base_col, aida_col<T> >( 558 a_col = safe_cast<base_col, aida_col<T> >(*col);
559 return a_col?true:false; 559 return a_col?true:false;
560 } 560 }
561 561
562 aida_base_col* find_aida_base_column(const s 562 aida_base_col* find_aida_base_column(const std::string& a_name,bool a_case_sensitive = true){ //for opaw/panntu.
563 base_col* col = a_case_sensitive ? find_na 563 base_col* col = a_case_sensitive ? find_named<base_col>(m_cols,a_name) : find_named_case_insensitive<base_col>(m_cols,a_name);
564 if(!col) return 0; 564 if(!col) return 0;
565 return safe_cast<base_col,aida_base_col>(* 565 return safe_cast<base_col,aida_base_col>(*col);
566 } 566 }
567 567
568 bool get_row() const { 568 bool get_row() const {
569 bool status = true; 569 bool status = true;
570 tools_vforcit(base_col*,m_cols,it) { 570 tools_vforcit(base_col*,m_cols,it) {
571 if(!(*it)->fetch_entry()) status = false 571 if(!(*it)->fetch_entry()) status = false;
572 } 572 }
573 return status; 573 return status;
574 } 574 }
575 575
576 bool set_binding(std::ostream& a_out,const n 576 bool set_binding(std::ostream& a_out,const ntuple_binding& a_bd = ntuple_binding()) {
577 tools_vforcit(column_binding,a_bd.columns( 577 tools_vforcit(column_binding,a_bd.columns(),itb) {
578 bool found = false; 578 bool found = false;
579 tools_vforcit(base_col*,m_cols,itc) { 579 tools_vforcit(base_col*,m_cols,itc) {
580 if((*itc)->name()==(*itb).name()) { 580 if((*itc)->name()==(*itb).name()) {
581 (*itc)->set_user_variable((*itb).use 581 (*itc)->set_user_variable((*itb).user_obj());
582 found = true; 582 found = true;
583 } 583 }
584 } 584 }
585 if(!found) { 585 if(!found) {
586 a_out << "tools::aida::ntuple :" 586 a_out << "tools::aida::ntuple :"
587 << " binding name " << sout((*it 587 << " binding name " << sout((*itb).name()) << " does not match any ntuple column."
588 << std::endl; 588 << std::endl;
589 return false; 589 return false;
590 } 590 }
591 } 591 }
592 return true; 592 return true;
593 } 593 }
594 594
595 template <class T> 595 template <class T>
596 bool column_min(unsigned int a_col,T& a_valu 596 bool column_min(unsigned int a_col,T& a_value) {
597 a_value = T(); 597 a_value = T();
598 if(m_cols.empty()) return false; 598 if(m_cols.empty()) return false;
599 if(a_col>=m_cols.size()) return false; 599 if(a_col>=m_cols.size()) return false;
600 base_col* _base_col = m_cols[a_col]; 600 base_col* _base_col = m_cols[a_col];
601 aida_col<T>* _col = safe_cast<base_col, ai 601 aida_col<T>* _col = safe_cast<base_col, aida_col<T> >(*_base_col);
602 if(!_col) return false; 602 if(!_col) return false;
603 start(); 603 start();
604 uint64 _rows = rows(); 604 uint64 _rows = rows();
605 T v; 605 T v;
606 {for(uint64 row=0;row<_rows;row++) { 606 {for(uint64 row=0;row<_rows;row++) {
607 if(!next()) {a_value = T();return false; 607 if(!next()) {a_value = T();return false;}
608 if(!_col->get_entry(v)) {} 608 if(!_col->get_entry(v)) {}
609 if(!row) { 609 if(!row) {
610 a_value = v; 610 a_value = v;
611 } else { 611 } else {
612 a_value = mn<T>(a_value,v); 612 a_value = mn<T>(a_value,v);
613 } 613 }
614 }} 614 }}
615 return true; 615 return true;
616 } 616 }
617 617
618 template <class T> 618 template <class T>
619 bool column_max(unsigned int a_col,T& a_valu 619 bool column_max(unsigned int a_col,T& a_value) {
620 a_value = T(); 620 a_value = T();
621 if(m_cols.empty()) return false; 621 if(m_cols.empty()) return false;
622 if(a_col>=m_cols.size()) return false; 622 if(a_col>=m_cols.size()) return false;
623 base_col* _base_col = m_cols[a_col]; 623 base_col* _base_col = m_cols[a_col];
624 aida_col<T>* _col = safe_cast<base_col, ai 624 aida_col<T>* _col = safe_cast<base_col, aida_col<T> >(*_base_col);
625 if(!_col) return false; 625 if(!_col) return false;
626 start(); 626 start();
627 uint64 _rows = rows(); 627 uint64 _rows = rows();
628 T v; 628 T v;
629 {for(uint64 row=0;row<_rows;row++) { 629 {for(uint64 row=0;row<_rows;row++) {
630 if(!next()) {a_value = T();return false; 630 if(!next()) {a_value = T();return false;}
631 if(!_col->get_entry(v)) {} 631 if(!_col->get_entry(v)) {}
632 if(!row) { 632 if(!row) {
633 a_value = v; 633 a_value = v;
634 } else { 634 } else {
635 a_value = mx<T>(a_value,v); 635 a_value = mx<T>(a_value,v);
636 } 636 }
637 }} 637 }}
638 return true; 638 return true;
639 } 639 }
640 640
641 }; 641 };
642 642
643 ////////////////////////////////////////////// 643 ////////////////////////////////////////////////////////////
644 /// some special column that can't be done wit 644 /// some special column that can't be done with aida_col<T> ////
645 ////////////////////////////////////////////// 645 ////////////////////////////////////////////////////////////
646 646
647 class aida_col_ntu : public base_col { 647 class aida_col_ntu : public base_col {
648 public: 648 public:
649 static const std::string& s_class() { 649 static const std::string& s_class() {
650 static const std::string s_v("tools::aida: 650 static const std::string s_v("tools::aida::aida_col_ntu");
651 return s_v; 651 return s_v;
652 } 652 }
653 virtual void* cast(const std::string& a_clas 653 virtual void* cast(const std::string& a_class) const {
654 if(void* p = cmp_cast<aida_col_ntu>(this,a 654 if(void* p = cmp_cast<aida_col_ntu>(this,a_class)) {return p;}
655 return base_col::cast(a_class); 655 return base_col::cast(a_class);
656 } 656 }
657 public: 657 public:
658 virtual base_col* copy() const {return new a 658 virtual base_col* copy() const {return new aida_col_ntu(*this);}
659 virtual bool add() {m_data.push_back(m_tmp); 659 virtual bool add() {m_data.push_back(m_tmp);m_tmp.reset();return true;}
660 virtual bool reset() {m_data.clear();m_index 660 virtual bool reset() {m_data.clear();m_index = 0;return true;}
661 virtual uint64 num_elems() const {return m_d 661 virtual uint64 num_elems() const {return m_data.size();}
662 public: 662 public:
663 base_ntu* get_entry() { 663 base_ntu* get_entry() {
664 if(m_index>=m_data.size()) { 664 if(m_index>=m_data.size()) {
665 m_out << s_class() << "::get_entry :" 665 m_out << s_class() << "::get_entry :"
666 << " bad index " << m_index 666 << " bad index " << m_index
667 << ". Vec size is " << m_data.size 667 << ". Vec size is " << m_data.size() << "."
668 << "." 668 << "."
669 << std::endl; 669 << std::endl;
670 return 0; 670 return 0;
671 } 671 }
672 typedef std::vector<ntuple>::size_type sz_ 672 typedef std::vector<ntuple>::size_type sz_t;
673 return &(m_data[sz_t(m_index)]); 673 return &(m_data[sz_t(m_index)]);
674 } 674 }
675 675
676 virtual void set_user_variable(void* a_user_ 676 virtual void set_user_variable(void* a_user_var) {m_user_var = (ntuple*)a_user_var;} //not owner.
677 virtual bool fetch_entry() const { 677 virtual bool fetch_entry() const {
678 if(m_index>=m_data.size()) { 678 if(m_index>=m_data.size()) {
679 m_out << s_class() << "::fetch_entry :" 679 m_out << s_class() << "::fetch_entry :"
680 << " bad index " << m_index 680 << " bad index " << m_index
681 << ". Vec size is " << m_data.size 681 << ". Vec size is " << m_data.size() << "."
682 << "." 682 << "."
683 << std::endl; 683 << std::endl;
684 if(m_user_var) *m_user_var = ntuple(m_ou 684 if(m_user_var) *m_user_var = ntuple(m_out,"");
685 return false; 685 return false;
686 } 686 }
687 typedef std::vector<ntuple>::size_type sz_ 687 typedef std::vector<ntuple>::size_type sz_t;
688 if(m_user_var) *m_user_var = m_data[sz_t(m 688 if(m_user_var) *m_user_var = m_data[sz_t(m_index)];
689 return true; 689 return true;
690 } 690 }
691 691
692 virtual base_ntu* get_to_fill() {return &m_t 692 virtual base_ntu* get_to_fill() {return &m_tmp;}
693 public: 693 public:
694 aida_col_ntu(std::ostream& a_out,const std:: 694 aida_col_ntu(std::ostream& a_out,const std::string& a_name)
695 :base_col(a_out,a_name) 695 :base_col(a_out,a_name)
696 ,m_tmp(a_out,"tmp") 696 ,m_tmp(a_out,"tmp")
697 ,m_user_var(0) //not owner 697 ,m_user_var(0) //not owner
698 {} 698 {}
699 public: 699 public:
700 virtual ~aida_col_ntu(){} 700 virtual ~aida_col_ntu(){}
701 public: 701 public:
702 aida_col_ntu(const aida_col_ntu& a_from) 702 aida_col_ntu(const aida_col_ntu& a_from)
703 :base_col(a_from) 703 :base_col(a_from)
704 ,m_data(a_from.m_data) 704 ,m_data(a_from.m_data)
705 705
706 ,m_tmp(a_from.m_tmp) 706 ,m_tmp(a_from.m_tmp)
707 ,m_user_var(a_from.m_user_var) 707 ,m_user_var(a_from.m_user_var)
708 {} 708 {}
709 aida_col_ntu& operator=(const aida_col_ntu& 709 aida_col_ntu& operator=(const aida_col_ntu& a_from){
710 base_col::operator=(a_from); 710 base_col::operator=(a_from);
711 if(&a_from==this) return *this; 711 if(&a_from==this) return *this;
712 m_data = a_from.m_data; 712 m_data = a_from.m_data;
713 713
714 m_tmp = a_from.m_tmp; 714 m_tmp = a_from.m_tmp;
715 m_user_var = a_from.m_user_var; 715 m_user_var = a_from.m_user_var;
716 return *this; 716 return *this;
717 } 717 }
718 protected: 718 protected:
719 std::vector<ntuple> m_data; 719 std::vector<ntuple> m_data;
720 ntuple m_tmp; 720 ntuple m_tmp;
721 ntuple* m_user_var; 721 ntuple* m_user_var;
722 }; 722 };
723 723
724 inline bool create_cols_from_vals(ntuple& a_nt 724 inline bool create_cols_from_vals(ntuple& a_ntu,
725 const std::v 725 const std::vector<value>& a_vars,
726 bool a_verbo 726 bool a_verbose = false){
727 tools_vforcit(value,a_vars,it) { 727 tools_vforcit(value,a_vars,it) {
728 if((*it).type()==value::VOID_STAR) { 728 if((*it).type()==value::VOID_STAR) {
729 if(a_verbose){ 729 if(a_verbose){
730 a_ntu.out() << "tools::aida::create_ 730 a_ntu.out() << "tools::aida::create_cols_from_vals :"
731 << " ITuple : " << (*it) 731 << " ITuple : " << (*it).label() << " : begin "
732 << std::endl; 732 << std::endl;
733 } 733 }
734 std::vector<value>* vars = (std::vecto 734 std::vector<value>* vars = (std::vector<value>*)(*it).get_void_star();
735 735
736 aida_col_ntu* col_ntu = new aida_col_n 736 aida_col_ntu* col_ntu = new aida_col_ntu(a_ntu.out(),(*it).label());
737 // create sub columns on the "fillable 737 // create sub columns on the "fillable" of col_ntu :
738 base_ntu* sub_base_ntu = col_ntu->get_ 738 base_ntu* sub_base_ntu = col_ntu->get_to_fill();
739 if(!sub_base_ntu) { 739 if(!sub_base_ntu) {
740 delete col_ntu; 740 delete col_ntu;
741 return false; 741 return false;
742 } 742 }
743 ntuple* sub_aida = safe_cast<base_ntu, 743 ntuple* sub_aida = safe_cast<base_ntu,ntuple>(*sub_base_ntu);
744 if(!sub_aida) { 744 if(!sub_aida) {
745 delete col_ntu; 745 delete col_ntu;
746 return false; 746 return false;
747 } 747 }
748 748
749 if(!create_cols_from_vals(*sub_aida,*v 749 if(!create_cols_from_vals(*sub_aida,*vars,a_verbose)) {
750 delete col_ntu; 750 delete col_ntu;
751 return false; 751 return false;
752 } 752 }
753 753
754 a_ntu.add_column(col_ntu); 754 a_ntu.add_column(col_ntu);
755 755
756 } else { 756 } else {
757 if(a_verbose){ 757 if(a_verbose){
758 std::string stype; 758 std::string stype;
759 (*it).s_type(stype); 759 (*it).s_type(stype);
760 std::string sval; 760 std::string sval;
761 (*it).tos(sval); 761 (*it).tos(sval);
762 a_ntu.out() << "tools::aida::create_ 762 a_ntu.out() << "tools::aida::create_cols_from_vals :"
763 << " " << stype << " : " 763 << " " << stype << " : "
764 << (*it).label() << " : 764 << (*it).label() << " : "
765 << sval 765 << sval
766 << std::endl; 766 << std::endl;
767 } 767 }
768 768
769 // char,short,int,float,double 769 // char,short,int,float,double
770 // byte,boolean,string,long(for int6 770 // byte,boolean,string,long(for int64)
771 // double[] 771 // double[]
772 772
773 base_col* col = 0; 773 base_col* col = 0;
774 /*if((*it).type()==value::CHAR) { 774 /*if((*it).type()==value::CHAR) {
775 col = a_ntu.create_col<char>((*it).l 775 col = a_ntu.create_col<char>((*it).label(),(*it).get_char());
776 } else*/ if((*it).type()==value::SHORT 776 } else*/ if((*it).type()==value::SHORT) {
777 col = a_ntu.create_col<short>((*it). 777 col = a_ntu.create_col<short>((*it).label(),(*it).get_short());
778 } else if((*it).type()==value::INT) { 778 } else if((*it).type()==value::INT) {
779 col = a_ntu.create_col<int>((*it).la 779 col = a_ntu.create_col<int>((*it).label(),(*it).get_int());
780 } else if((*it).type()==value::INT64) 780 } else if((*it).type()==value::INT64) {
781 col = a_ntu.create_col<int64>((*it). 781 col = a_ntu.create_col<int64>((*it).label(),(*it).get_int64());
782 } else if((*it).type()==value::FLOAT) 782 } else if((*it).type()==value::FLOAT) {
783 col = a_ntu.create_col<float>((*it). 783 col = a_ntu.create_col<float>((*it).label(),(*it).get_float());
784 } else if((*it).type()==value::DOUBLE) 784 } else if((*it).type()==value::DOUBLE) {
785 col = a_ntu.create_col<double>((*it) 785 col = a_ntu.create_col<double>((*it).label(),(*it).get_double());
786 786
787 //} else if((*it).type()==value::UNSIG 787 //} else if((*it).type()==value::UNSIGNED_CHAR) {
788 // col = a_ntu.create_col<unsigned ch 788 // col = a_ntu.create_col<unsigned char>((*it).label(),(*it).get_unsigned_char());
789 } else if((*it).type()==value::UNSIGNE 789 } else if((*it).type()==value::UNSIGNED_SHORT) {
790 col = a_ntu.create_col<unsigned shor 790 col = a_ntu.create_col<unsigned short>((*it).label(),(*it).get_unsigned_short());
791 } else if((*it).type()==value::UNSIGNE 791 } else if((*it).type()==value::UNSIGNED_INT) {
792 col = a_ntu.create_col<unsigned int> 792 col = a_ntu.create_col<unsigned int>((*it).label(),(*it).get_unsigned_int());
793 } else if((*it).type()==value::UNSIGNE 793 } else if((*it).type()==value::UNSIGNED_INT64) {
794 col = a_ntu.create_col<uint64>((*it) 794 col = a_ntu.create_col<uint64>((*it).label(),(*it).get_unsigned_int64());
795 795
796 } else if((*it).type()==value::BOOL) { 796 } else if((*it).type()==value::BOOL) {
797 col = a_ntu.create_col<bool>((*it).l 797 col = a_ntu.create_col<bool>((*it).label(),(*it).get_bool());
798 } else if((*it).type()==value::STRING) 798 } else if((*it).type()==value::STRING) {
799 col = a_ntu.create_col<std::string>( 799 col = a_ntu.create_col<std::string>((*it).label(),(*it).get_string());
800 } else if((*it).type()==value::INT64) 800 } else if((*it).type()==value::INT64) {
801 col = a_ntu.create_col<int64>((*it). 801 col = a_ntu.create_col<int64>((*it).label(),(*it).get_int64());
802 } 802 }
803 803
804 if(!col) { 804 if(!col) {
805 std::string stype; 805 std::string stype;
806 (*it).s_type(stype); 806 (*it).s_type(stype);
807 std::string sval; 807 std::string sval;
808 (*it).tos(sval); 808 (*it).tos(sval);
809 a_ntu.out() << "tools::aida::create_ 809 a_ntu.out() << "tools::aida::create_cols_from_vals :"
810 << " failed for " << sty 810 << " failed for " << stype << " : "
811 << (*it).label() << " : 811 << (*it).label() << " : "
812 << sval 812 << sval
813 << std::endl; 813 << std::endl;
814 return false; 814 return false;
815 } 815 }
816 } 816 }
817 } 817 }
818 return true; 818 return true;
819 } 819 }
820 820
821 // for raxml : 821 // for raxml :
822 inline bool create_col(ntuple& a_ntu, 822 inline bool create_col(ntuple& a_ntu,
823 const std::string& a_ty 823 const std::string& a_type,
824 const std::string& a_na 824 const std::string& a_name,
825 const std::string& a_s, 825 const std::string& a_s, //def or booking.
826 bool a_is_ntu){ 826 bool a_is_ntu){
827 /* 827 /*
828 if(a_type==s_aida_type((char)0)) { 828 if(a_type==s_aida_type((char)0)) {
829 char v = 0; 829 char v = 0;
830 if(a_s.size()&&!to<char>(a_s,v)) { 830 if(a_s.size()&&!to<char>(a_s,v)) {
831 a_ntu.out() << "tools::aida::create_col 831 a_ntu.out() << "tools::aida::create_col :"
832 << " can't convert def " << 832 << " can't convert def " << sout(a_s)
833 << " to a " << a_type 833 << " to a " << a_type
834 << std::endl; 834 << std::endl;
835 return false; 835 return false;
836 } 836 }
837 if(!a_ntu.create_col<char>(a_name,v)) { 837 if(!a_ntu.create_col<char>(a_name,v)) {
838 a_ntu.out() << "tools::aida::create_col 838 a_ntu.out() << "tools::aida::create_col :"
839 << " can't create column of 839 << " can't create column of type " << sout(a_type)
840 << std::endl; 840 << std::endl;
841 return false; 841 return false;
842 } 842 }
843 843
844 } else*/ if(a_type==s_aida_type((short)0)) { 844 } else*/ if(a_type==s_aida_type((short)0)) {
845 short v = 0; 845 short v = 0;
846 if(a_s.size()&&!to<short>(a_s,v)) { 846 if(a_s.size()&&!to<short>(a_s,v)) {
847 a_ntu.out() << "tools::aida::create_col 847 a_ntu.out() << "tools::aida::create_col :"
848 << " can't convert def " << 848 << " can't convert def " << sout(a_s)
849 << " to a " << a_type 849 << " to a " << a_type
850 << std::endl; 850 << std::endl;
851 return false; 851 return false;
852 } 852 }
853 if(!a_ntu.create_col<short>(a_name,v)) { 853 if(!a_ntu.create_col<short>(a_name,v)) {
854 a_ntu.out() << "tools::aida::create_col 854 a_ntu.out() << "tools::aida::create_col :"
855 << " can't create column of 855 << " can't create column of type " << sout(a_type)
856 << std::endl; 856 << std::endl;
857 return false; 857 return false;
858 } 858 }
859 859
860 } else if(a_type==s_aida_type((int)0)) { 860 } else if(a_type==s_aida_type((int)0)) {
861 int v = 0; 861 int v = 0;
862 if(a_s.size()&&!to<int>(a_s,v)) { 862 if(a_s.size()&&!to<int>(a_s,v)) {
863 a_ntu.out() << "tools::aida::create_col 863 a_ntu.out() << "tools::aida::create_col :"
864 << " can't convert def " << 864 << " can't convert def " << sout(a_s)
865 << " to a " << a_type 865 << " to a " << a_type
866 << std::endl; 866 << std::endl;
867 return false; 867 return false;
868 } 868 }
869 if(!a_ntu.create_col<int>(a_name,v)) { 869 if(!a_ntu.create_col<int>(a_name,v)) {
870 a_ntu.out() << "tools::aida::create_col 870 a_ntu.out() << "tools::aida::create_col :"
871 << " can't create column of 871 << " can't create column of type " << sout(a_type)
872 << std::endl; 872 << std::endl;
873 return false; 873 return false;
874 } 874 }
875 875
876 } else if(a_type==s_aida_type((int64)0)) { 876 } else if(a_type==s_aida_type((int64)0)) {
877 int64 v = 0; 877 int64 v = 0;
878 if(a_s.size()&&!to<int64>(a_s,v)) { 878 if(a_s.size()&&!to<int64>(a_s,v)) {
879 a_ntu.out() << "tools::aida::create_col 879 a_ntu.out() << "tools::aida::create_col :"
880 << " can't convert def " << 880 << " can't convert def " << sout(a_s)
881 << " to a " << a_type 881 << " to a " << a_type
882 << std::endl; 882 << std::endl;
883 return false; 883 return false;
884 } 884 }
885 if(!a_ntu.create_col<int64>(a_name,v)) { 885 if(!a_ntu.create_col<int64>(a_name,v)) {
886 a_ntu.out() << "tools::aida::create_col 886 a_ntu.out() << "tools::aida::create_col :"
887 << " can't create column of 887 << " can't create column of type " << sout(a_type)
888 << std::endl; 888 << std::endl;
889 return false; 889 return false;
890 } 890 }
891 891
892 } else if(a_type==s_aida_type((float)0)) { 892 } else if(a_type==s_aida_type((float)0)) {
893 float v = 0; 893 float v = 0;
894 if(a_s.size()&&!to<float>(a_s,v)) { 894 if(a_s.size()&&!to<float>(a_s,v)) {
895 a_ntu.out() << "tools::aida::create_col 895 a_ntu.out() << "tools::aida::create_col :"
896 << " can't convert def " << 896 << " can't convert def " << sout(a_s)
897 << " to a " << a_type 897 << " to a " << a_type
898 << std::endl; 898 << std::endl;
899 return false; 899 return false;
900 } 900 }
901 if(!a_ntu.create_col<float>(a_name,v)) { 901 if(!a_ntu.create_col<float>(a_name,v)) {
902 a_ntu.out() << "tools::aida::create_col 902 a_ntu.out() << "tools::aida::create_col :"
903 << " can't create column of 903 << " can't create column of type " << sout(a_type)
904 << std::endl; 904 << std::endl;
905 return false; 905 return false;
906 } 906 }
907 907
908 908
909 } else if(a_type==s_aida_type((double)0)) { 909 } else if(a_type==s_aida_type((double)0)) {
910 double v = 0; 910 double v = 0;
911 if(a_s.size()&&!to<double>(a_s,v)) { 911 if(a_s.size()&&!to<double>(a_s,v)) {
912 a_ntu.out() << "tools::aida::create_col 912 a_ntu.out() << "tools::aida::create_col :"
913 << " can't convert def " << 913 << " can't convert def " << sout(a_s)
914 << " to a " << a_type 914 << " to a " << a_type
915 << std::endl; 915 << std::endl;
916 return false; 916 return false;
917 } 917 }
918 if(!a_ntu.create_col<double>(a_name,v)) { 918 if(!a_ntu.create_col<double>(a_name,v)) {
919 a_ntu.out() << "tools::aida::create_col 919 a_ntu.out() << "tools::aida::create_col :"
920 << " can't create column of 920 << " can't create column of type " << sout(a_type)
921 << std::endl; 921 << std::endl;
922 return false; 922 return false;
923 } 923 }
924 924
925 /* } else if(a_type==s_aida_type((unsigned ch 925 /* } else if(a_type==s_aida_type((unsigned char)0)) { //byte
926 unsigned int v = 0; 926 unsigned int v = 0;
927 if(a_s.size()&&!to<unsigned int>(a_s,v)) { 927 if(a_s.size()&&!to<unsigned int>(a_s,v)) {
928 a_ntu.out() << "tools::aida::create_col 928 a_ntu.out() << "tools::aida::create_col :"
929 << " can't convert def " << 929 << " can't convert def " << sout(a_s)
930 << " to a " << a_type 930 << " to a " << a_type
931 << std::endl; 931 << std::endl;
932 return false; 932 return false;
933 } 933 }
934 if(v>=256) { 934 if(v>=256) {
935 a_ntu.out() << "tools::aida::create_col 935 a_ntu.out() << "tools::aida::create_col :"
936 << " can't convert def " << 936 << " can't convert def " << sout(a_s)
937 << " to byte." 937 << " to byte."
938 << std::endl; 938 << std::endl;
939 return false; 939 return false;
940 } 940 }
941 if(!a_ntu.create_col<unsigned char>(a_name 941 if(!a_ntu.create_col<unsigned char>(a_name,v)) {
942 a_ntu.out() << "tools::aida::create_col 942 a_ntu.out() << "tools::aida::create_col :"
943 << " can't create column of 943 << " can't create column of type " << sout(a_type)
944 << std::endl; 944 << std::endl;
945 return false; 945 return false;
946 } 946 }
947 */ 947 */
948 } else if(a_type==s_aida_type((unsigned shor 948 } else if(a_type==s_aida_type((unsigned short)0)) {
949 unsigned short v = 0; 949 unsigned short v = 0;
950 if(a_s.size()&&!to<unsigned short>(a_s,v)) 950 if(a_s.size()&&!to<unsigned short>(a_s,v)) {
951 a_ntu.out() << "tools::aida::create_col 951 a_ntu.out() << "tools::aida::create_col :"
952 << " can't convert def " << 952 << " can't convert def " << sout(a_s)
953 << " to a " << a_type 953 << " to a " << a_type
954 << std::endl; 954 << std::endl;
955 return false; 955 return false;
956 } 956 }
957 if(!a_ntu.create_col<unsigned short>(a_nam 957 if(!a_ntu.create_col<unsigned short>(a_name,v)) {
958 a_ntu.out() << "tools::aida::create_col 958 a_ntu.out() << "tools::aida::create_col :"
959 << " can't create column of 959 << " can't create column of type " << sout(a_type)
960 << std::endl; 960 << std::endl;
961 return false; 961 return false;
962 } 962 }
963 963
964 } else if(a_type==s_aida_type((unsigned int) 964 } else if(a_type==s_aida_type((unsigned int)0)) {
965 unsigned int v = 0; 965 unsigned int v = 0;
966 if(a_s.size()&&!to<unsigned int>(a_s,v)) { 966 if(a_s.size()&&!to<unsigned int>(a_s,v)) {
967 a_ntu.out() << "tools::aida::create_col 967 a_ntu.out() << "tools::aida::create_col :"
968 << " can't convert def " << 968 << " can't convert def " << sout(a_s)
969 << " to a " << a_type 969 << " to a " << a_type
970 << std::endl; 970 << std::endl;
971 return false; 971 return false;
972 } 972 }
973 if(!a_ntu.create_col<unsigned int>(a_name, 973 if(!a_ntu.create_col<unsigned int>(a_name,v)) {
974 a_ntu.out() << "tools::aida::create_col 974 a_ntu.out() << "tools::aida::create_col :"
975 << " can't create column of 975 << " can't create column of type " << sout(a_type)
976 << std::endl; 976 << std::endl;
977 return false; 977 return false;
978 } 978 }
979 979
980 } else if(a_type==s_aida_type((uint64)0)) { 980 } else if(a_type==s_aida_type((uint64)0)) {
981 uint64 v = 0; 981 uint64 v = 0;
982 if(a_s.size()&&!to<uint64>(a_s,v)) { 982 if(a_s.size()&&!to<uint64>(a_s,v)) {
983 a_ntu.out() << "tools::aida::create_col 983 a_ntu.out() << "tools::aida::create_col :"
984 << " can't convert def " << 984 << " can't convert def " << sout(a_s)
985 << " to a " << a_type 985 << " to a " << a_type
986 << std::endl; 986 << std::endl;
987 return false; 987 return false;
988 } 988 }
989 if(!a_ntu.create_col<uint64>(a_name,v)) { 989 if(!a_ntu.create_col<uint64>(a_name,v)) {
990 a_ntu.out() << "tools::aida::create_col 990 a_ntu.out() << "tools::aida::create_col :"
991 << " can't create column of 991 << " can't create column of type " << sout(a_type)
992 << std::endl; 992 << std::endl;
993 return false; 993 return false;
994 } 994 }
995 995
996 ///////////////////////////////////////// 996 /////////////////////////////////////////
997 ///////////////////////////////////////// 997 /////////////////////////////////////////
998 } else if(a_type==s_aida_type((bool)true)) { 998 } else if(a_type==s_aida_type((bool)true)) {
999 bool v = false; 999 bool v = false;
1000 if(a_s.size()&&!to(a_s,v)) { 1000 if(a_s.size()&&!to(a_s,v)) {
1001 a_ntu.out() << "tools::aida::create_col 1001 a_ntu.out() << "tools::aida::create_col :"
1002 << " can't convert def " << 1002 << " can't convert def " << sout(a_s)
1003 << " to a " << a_type 1003 << " to a " << a_type
1004 << std::endl; 1004 << std::endl;
1005 return false; 1005 return false;
1006 } 1006 }
1007 if(!a_ntu.create_col<bool>(a_name,v)) { 1007 if(!a_ntu.create_col<bool>(a_name,v)) {
1008 a_ntu.out() << "tools::aida::create_col 1008 a_ntu.out() << "tools::aida::create_col :"
1009 << " can't create column of 1009 << " can't create column of type " << sout(a_type)
1010 << std::endl; 1010 << std::endl;
1011 return false; 1011 return false;
1012 } 1012 }
1013 1013
1014 } else if(a_type==s_aida_type(std::string() 1014 } else if(a_type==s_aida_type(std::string())) {
1015 if(!a_ntu.create_col<std::string>(a_name, 1015 if(!a_ntu.create_col<std::string>(a_name,a_s)) {
1016 a_ntu.out() << "tools::aida::create_col 1016 a_ntu.out() << "tools::aida::create_col :"
1017 << " can't create column of 1017 << " can't create column of type " << sout(a_type)
1018 << std::endl; 1018 << std::endl;
1019 return false; 1019 return false;
1020 } 1020 }
1021 1021
1022 } else if(a_type==s_aida_type((int64)0)) { 1022 } else if(a_type==s_aida_type((int64)0)) {
1023 int64 v = 0; 1023 int64 v = 0;
1024 if(a_s.size()&&!to<int64>(a_s,v)) { 1024 if(a_s.size()&&!to<int64>(a_s,v)) {
1025 a_ntu.out() << "tools::aida::create_col 1025 a_ntu.out() << "tools::aida::create_col :"
1026 << " can't convert def " << 1026 << " can't convert def " << sout(a_s)
1027 << " to a " << a_type 1027 << " to a " << a_type
1028 << std::endl; 1028 << std::endl;
1029 return false; 1029 return false;
1030 } 1030 }
1031 if(!a_ntu.create_col<int64>(a_name,v)) { 1031 if(!a_ntu.create_col<int64>(a_name,v)) {
1032 a_ntu.out() << "tools::aida::create_col 1032 a_ntu.out() << "tools::aida::create_col :"
1033 << " can't create column of 1033 << " can't create column of type " << sout(a_type)
1034 << std::endl; 1034 << std::endl;
1035 return false; 1035 return false;
1036 } 1036 }
1037 1037
1038 } else if(a_type==s_aida_type_ituple()) { 1038 } else if(a_type==s_aida_type_ituple()) {
1039 // we expect a booking string on a_s. 1039 // we expect a booking string on a_s.
1040 1040
1041 if(!a_is_ntu) { 1041 if(!a_is_ntu) {
1042 a_ntu.out() << "tools::aida::create_col 1042 a_ntu.out() << "tools::aida::create_col :"
1043 << " mismatch a_is_ntu/a_ty 1043 << " mismatch a_is_ntu/a_type."
1044 << std::endl; 1044 << std::endl;
1045 return false; 1045 return false;
1046 } 1046 }
1047 if(a_s.empty()) { 1047 if(a_s.empty()) {
1048 a_ntu.out() << "tools::aida::create_col 1048 a_ntu.out() << "tools::aida::create_col :"
1049 << " empty booking string." 1049 << " empty booking string."
1050 << std::endl; 1050 << std::endl;
1051 return false; 1051 return false;
1052 } 1052 }
1053 1053
1054 columns::finder f(a_ntu.out(),a_s); 1054 columns::finder f(a_ntu.out(),a_s);
1055 if(!f.find_variables()) { 1055 if(!f.find_variables()) {
1056 a_ntu.out() << "tools::aida::create_col 1056 a_ntu.out() << "tools::aida::create_col :"
1057 << " find_variables() failed for 1057 << " find_variables() failed for " << sout(a_s) << "."
1058 << std::endl; 1058 << std::endl;
1059 return false; 1059 return false;
1060 } 1060 }
1061 1061
1062 aida_col_ntu* col_ntu = new aida_col_ntu( 1062 aida_col_ntu* col_ntu = new aida_col_ntu(a_ntu.out(),a_name);
1063 //create columns on the fillable. 1063 //create columns on the fillable.
1064 base_ntu* sub_base_ntu = col_ntu->get_to_ 1064 base_ntu* sub_base_ntu = col_ntu->get_to_fill();
1065 if(!sub_base_ntu) {delete col_ntu;return 1065 if(!sub_base_ntu) {delete col_ntu;return false;}
1066 ntuple* sub_aida = safe_cast<base_ntu,ntu 1066 ntuple* sub_aida = safe_cast<base_ntu,ntuple>(*sub_base_ntu);
1067 if(!sub_aida) {delete col_ntu;return fals 1067 if(!sub_aida) {delete col_ntu;return false;}
1068 1068
1069 std::vector<value> vars;f.result(vars); 1069 std::vector<value> vars;f.result(vars);
1070 if(!create_cols_from_vals(*sub_aida,vars) 1070 if(!create_cols_from_vals(*sub_aida,vars)) {
1071 columns::delete_columns(vars); 1071 columns::delete_columns(vars);
1072 delete col_ntu; 1072 delete col_ntu;
1073 return false; 1073 return false;
1074 } 1074 }
1075 columns::delete_columns(vars); 1075 columns::delete_columns(vars);
1076 a_ntu.add_column(col_ntu); 1076 a_ntu.add_column(col_ntu);
1077 1077
1078 //FIXME : double[] 1078 //FIXME : double[]
1079 1079
1080 } else { 1080 } else {
1081 a_ntu.out() << "tools::aida::create_col : 1081 a_ntu.out() << "tools::aida::create_col :"
1082 << " col type " << sout(a_typ 1082 << " col type " << sout(a_type)
1083 << " not yet handled." 1083 << " not yet handled."
1084 << std::endl; 1084 << std::endl;
1085 return false; 1085 return false;
1086 } 1086 }
1087 1087
1088 return true; 1088 return true;
1089 } 1089 }
1090 1090
1091 // for waxml : 1091 // for waxml :
1092 inline bool create_cols_from_string(ntuple& a 1092 inline bool create_cols_from_string(ntuple& a_ntu,
1093 const std 1093 const std::string& a_booking,
1094 bool a_ve 1094 bool a_verbose = false){
1095 a_ntu.clear(); 1095 a_ntu.clear();
1096 if(a_booking.empty()) { 1096 if(a_booking.empty()) {
1097 a_ntu.out() << "tools::aida::create_cols_ 1097 a_ntu.out() << "tools::aida::create_cols_from_string :"
1098 << " empty booking string." 1098 << " empty booking string."
1099 << std::endl; 1099 << std::endl;
1100 return false; 1100 return false;
1101 } 1101 }
1102 1102
1103 columns::finder f(a_ntu.out(),a_booking); 1103 columns::finder f(a_ntu.out(),a_booking);
1104 if(!f.find_variables()) { 1104 if(!f.find_variables()) {
1105 a_ntu.out() << "tools::aida::create_cols_ 1105 a_ntu.out() << "tools::aida::create_cols_from_string :"
1106 << " find_variables() failed." 1106 << " find_variables() failed."
1107 << std::endl; 1107 << std::endl;
1108 return false; 1108 return false;
1109 } 1109 }
1110 std::vector<value> vars;f.result(vars); 1110 std::vector<value> vars;f.result(vars);
1111 if(a_verbose) columns::dump_columns(a_ntu.o 1111 if(a_verbose) columns::dump_columns(a_ntu.out(),vars);
1112 1112
1113 if(!create_cols_from_vals(a_ntu,vars)) { 1113 if(!create_cols_from_vals(a_ntu,vars)) {
1114 columns::delete_columns(vars); 1114 columns::delete_columns(vars);
1115 a_ntu.clear(); 1115 a_ntu.clear();
1116 return false; 1116 return false;
1117 } 1117 }
1118 columns::delete_columns(vars); 1118 columns::delete_columns(vars);
1119 return true; 1119 return true;
1120 } 1120 }
1121 1121
1122 inline aida_col_ntu* find_col_ntu(ntuple& a_n 1122 inline aida_col_ntu* find_col_ntu(ntuple& a_ntu,const std::string& a_name){
1123 base_col* col = find_named<base_col>(a_ntu. 1123 base_col* col = find_named<base_col>(a_ntu.columns(),a_name);
1124 if(!col) return 0; 1124 if(!col) return 0;
1125 return safe_cast<base_col, aida_col_ntu >(* 1125 return safe_cast<base_col, aida_col_ntu >(*col);
1126 } 1126 }
1127 1127
1128 template <class T> 1128 template <class T>
1129 class base_looper { 1129 class base_looper {
1130 public: 1130 public:
1131 static const std::string& s_class() { 1131 static const std::string& s_class() {
1132 static const std::string s_v("tools::aida 1132 static const std::string s_v("tools::aida::base_looper<"+stype(T())+">");
1133 return s_v; 1133 return s_v;
1134 } 1134 }
1135 protected: 1135 protected:
1136 virtual bool action(const T& a_value) = 0; 1136 virtual bool action(const T& a_value) = 0; //return false to stop processing.
1137 public: 1137 public:
1138 base_looper(base_ntu& a_ntu,const base_col& 1138 base_looper(base_ntu& a_ntu,const base_col& a_col)
1139 :m_ntu(a_ntu),m_col(a_col){ 1139 :m_ntu(a_ntu),m_col(a_col){
1140 #ifdef TOOLS_MEM 1140 #ifdef TOOLS_MEM
1141 mem::increment(s_class().c_str()); 1141 mem::increment(s_class().c_str());
1142 #endif 1142 #endif
1143 } 1143 }
1144 virtual ~base_looper(){ 1144 virtual ~base_looper(){
1145 #ifdef TOOLS_MEM 1145 #ifdef TOOLS_MEM
1146 mem::decrement(s_class().c_str()); 1146 mem::decrement(s_class().c_str());
1147 #endif 1147 #endif
1148 } 1148 }
1149 public: 1149 public:
1150 base_looper(const base_looper& a_from) 1150 base_looper(const base_looper& a_from)
1151 :m_ntu(a_from.m_ntu),m_col(a_from.m_col){ 1151 :m_ntu(a_from.m_ntu),m_col(a_from.m_col){
1152 #ifdef TOOLS_MEM 1152 #ifdef TOOLS_MEM
1153 mem::increment(s_class().c_str()); 1153 mem::increment(s_class().c_str());
1154 #endif 1154 #endif
1155 } 1155 }
1156 base_looper& operator=(const base_looper&){ 1156 base_looper& operator=(const base_looper&){return *this;}
1157 public: 1157 public:
1158 bool process() { 1158 bool process() {
1159 std::vector<unsigned int> is; 1159 std::vector<unsigned int> is;
1160 bool found = false; 1160 bool found = false;
1161 if(!find_is(m_ntu,&m_col,is,found)) { 1161 if(!find_is(m_ntu,&m_col,is,found)) {
1162 m_ntu.out() << s_class() << "::process 1162 m_ntu.out() << s_class() << "::process :"
1163 << " find_is failed." 1163 << " find_is failed."
1164 << std::endl; 1164 << std::endl;
1165 return false; 1165 return false;
1166 } 1166 }
1167 if(!found) { 1167 if(!found) {
1168 m_ntu.out() << s_class() << "::process 1168 m_ntu.out() << s_class() << "::process :"
1169 << " find_is : col not foun 1169 << " find_is : col not found."
1170 << std::endl; 1170 << std::endl;
1171 return false; 1171 return false;
1172 } 1172 }
1173 if(is.empty()) { 1173 if(is.empty()) {
1174 m_ntu.out() << s_class() << "::process 1174 m_ntu.out() << s_class() << "::process :"
1175 << " is vec empty." 1175 << " is vec empty."
1176 << std::endl; 1176 << std::endl;
1177 return false; 1177 return false;
1178 } 1178 }
1179 1179
1180 bool stop = false; 1180 bool stop = false;
1181 if(!_looper(m_ntu,is,0,stop)) { 1181 if(!_looper(m_ntu,is,0,stop)) {
1182 m_ntu.out() << s_class() << "::process 1182 m_ntu.out() << s_class() << "::process :"
1183 << " _looper failed." 1183 << " _looper failed."
1184 << std::endl; 1184 << std::endl;
1185 return false; 1185 return false;
1186 } 1186 }
1187 return true; 1187 return true;
1188 } 1188 }
1189 protected: 1189 protected:
1190 static bool find_is(const base_ntu& a_ntu,c 1190 static bool find_is(const base_ntu& a_ntu,const base_col* a_col,
1191 std::vector<unsi 1191 std::vector<unsigned int>& a_is,
1192 bool& a_found){ 1192 bool& a_found){
1193 // search the indices to reach the sub le 1193 // search the indices to reach the sub leaf a_col from the main a_ntu.
1194 // Note : it is assumed that a_is is empt 1194 // Note : it is assumed that a_is is empty and a_found = false before
1195 // calling with function. 1195 // calling with function.
1196 1196
1197 const std::vector<base_col*>& cols = a_nt 1197 const std::vector<base_col*>& cols = a_ntu.columns();
1198 1198
1199 // look if a_col is a leaf col of a_ntu : 1199 // look if a_col is a leaf col of a_ntu :
1200 {unsigned int index = 0; 1200 {unsigned int index = 0;
1201 tools_vforcit(base_col*,cols,it) { 1201 tools_vforcit(base_col*,cols,it) {
1202 if(*it==a_col) { 1202 if(*it==a_col) {
1203 a_is.push_back(index); //leaf index i 1203 a_is.push_back(index); //leaf index is the last one in a_is.
1204 a_found = true; 1204 a_found = true;
1205 return true; 1205 return true;
1206 } 1206 }
1207 index++; 1207 index++;
1208 }} 1208 }}
1209 1209
1210 // go down sub ntu : 1210 // go down sub ntu :
1211 {unsigned int index = 0; 1211 {unsigned int index = 0;
1212 tools_vforcit(base_col*,cols,it) { 1212 tools_vforcit(base_col*,cols,it) {
1213 aida_col_ntu* col = safe_cast<base_col, 1213 aida_col_ntu* col = safe_cast<base_col,aida_col_ntu>(*(*it));
1214 if(col) { 1214 if(col) {
1215 base_ntu* sub = col->get_to_fill(); / 1215 base_ntu* sub = col->get_to_fill(); //it holds the "sub" cols schema.
1216 if(!sub) {a_is.clear();return false;} 1216 if(!sub) {a_is.clear();return false;}
1217 a_is.push_back(index); 1217 a_is.push_back(index);
1218 if(!find_is(*sub,a_col,a_is,a_found)) 1218 if(!find_is(*sub,a_col,a_is,a_found)) {a_is.clear();return false;}
1219 if(a_found) return true; 1219 if(a_found) return true;
1220 a_is.pop_back(); 1220 a_is.pop_back();
1221 } 1221 }
1222 index++; 1222 index++;
1223 }} 1223 }}
1224 return true; 1224 return true;
1225 } 1225 }
1226 protected: 1226 protected:
1227 bool _looper(base_ntu& a_sub, 1227 bool _looper(base_ntu& a_sub,
1228 const std::vector<unsig 1228 const std::vector<unsigned int>& a_is,
1229 unsigned int a_depth, 1229 unsigned int a_depth,
1230 bool& a_stop) { 1230 bool& a_stop) {
1231 if(a_depth>=a_is.size()) return false; 1231 if(a_depth>=a_is.size()) return false;
1232 1232
1233 unsigned int coli = a_is[a_depth]; 1233 unsigned int coli = a_is[a_depth];
1234 const std::vector<base_col*>& cols = a_su 1234 const std::vector<base_col*>& cols = a_sub.columns();
1235 if(coli>=cols.size()) return false; 1235 if(coli>=cols.size()) return false;
1236 1236
1237 if(a_depth==(a_is.size()-1)) { //we reach 1237 if(a_depth==(a_is.size()-1)) { //we reach the leaf.
1238 aida_col<T>* col = safe_cast<base_col, 1238 aida_col<T>* col = safe_cast<base_col, aida_col<T> >(*(cols[coli]));
1239 if(!col) return false; 1239 if(!col) return false;
1240 a_sub.start(); 1240 a_sub.start();
1241 while(a_sub.next()) { 1241 while(a_sub.next()) {
1242 T v; 1242 T v;
1243 if(!col->get_entry(v)) return false; 1243 if(!col->get_entry(v)) return false;
1244 if(!action(v)) {a_stop = true;break;} 1244 if(!action(v)) {a_stop = true;break;}
1245 } 1245 }
1246 } else { 1246 } else {
1247 aida_col_ntu* col = safe_cast<base_col, 1247 aida_col_ntu* col = safe_cast<base_col,aida_col_ntu>(*(cols[coli]));
1248 if(!col) return false; 1248 if(!col) return false;
1249 a_sub.start(); 1249 a_sub.start();
1250 while(a_sub.next()) { 1250 while(a_sub.next()) {
1251 base_ntu* ntu = col->get_entry(); //n 1251 base_ntu* ntu = col->get_entry(); //not const.
1252 if(!ntu) return false; 1252 if(!ntu) return false;
1253 ntu->start(); 1253 ntu->start();
1254 while(ntu->next()) { 1254 while(ntu->next()) {
1255 if(!_looper(*ntu,a_is,a_depth+1,a_s 1255 if(!_looper(*ntu,a_is,a_depth+1,a_stop)) return false;
1256 if(a_stop) break; 1256 if(a_stop) break;
1257 } 1257 }
1258 } 1258 }
1259 } 1259 }
1260 return true; 1260 return true;
1261 } 1261 }
1262 protected: 1262 protected:
1263 base_ntu& m_ntu; 1263 base_ntu& m_ntu;
1264 const base_col& m_col; 1264 const base_col& m_col;
1265 }; 1265 };
1266 1266
1267 }} 1267 }}
1268 1268
1269 #include "mnmx" 1269 #include "mnmx"
1270 1270
1271 namespace tools { 1271 namespace tools {
1272 namespace aida { 1272 namespace aida {
1273 1273
1274 template <class T> 1274 template <class T>
1275 class stat_looper : public base_looper<T> { 1275 class stat_looper : public base_looper<T> {
1276 protected: 1276 protected:
1277 virtual bool action(const T& a_v) { 1277 virtual bool action(const T& a_v) {
1278 if(m_first) { 1278 if(m_first) {
1279 m_mn = a_v; 1279 m_mn = a_v;
1280 m_mx = a_v; 1280 m_mx = a_v;
1281 m_S = a_v; 1281 m_S = a_v;
1282 m_S2 = a_v*a_v; 1282 m_S2 = a_v*a_v;
1283 1283
1284 m_first = false; 1284 m_first = false;
1285 } else { 1285 } else {
1286 m_mn = min_of<T>(m_mn,a_v); 1286 m_mn = min_of<T>(m_mn,a_v);
1287 m_mx = max_of<T>(m_mx,a_v); 1287 m_mx = max_of<T>(m_mx,a_v);
1288 m_S += a_v; 1288 m_S += a_v;
1289 m_S2 += a_v*a_v; 1289 m_S2 += a_v*a_v;
1290 } 1290 }
1291 m_counter++; 1291 m_counter++;
1292 return true; //continue looping. 1292 return true; //continue looping.
1293 } 1293 }
1294 public: 1294 public:
1295 stat_looper(base_ntu& a_ntu,const base_col& 1295 stat_looper(base_ntu& a_ntu,const base_col& a_col)
1296 :base_looper<T>(a_ntu,a_col) 1296 :base_looper<T>(a_ntu,a_col)
1297 ,m_first(true) 1297 ,m_first(true)
1298 ,m_mn(T()) 1298 ,m_mn(T())
1299 ,m_mx(T()) 1299 ,m_mx(T())
1300 ,m_S(T()) 1300 ,m_S(T())
1301 ,m_S2(T()) 1301 ,m_S2(T())
1302 ,m_counter(0) 1302 ,m_counter(0)
1303 {} 1303 {}
1304 virtual ~stat_looper(){} 1304 virtual ~stat_looper(){}
1305 public: 1305 public:
1306 stat_looper(const stat_looper& a_from) 1306 stat_looper(const stat_looper& a_from)
1307 :base_looper<T>(a_from) 1307 :base_looper<T>(a_from)
1308 ,m_first(true) 1308 ,m_first(true)
1309 ,m_mn(T()) 1309 ,m_mn(T())
1310 ,m_mx(T()) 1310 ,m_mx(T())
1311 ,m_S(T()) 1311 ,m_S(T())
1312 ,m_S2(T()) 1312 ,m_S2(T())
1313 ,m_counter(0) 1313 ,m_counter(0)
1314 {} 1314 {}
1315 stat_looper& operator=(const stat_looper& a 1315 stat_looper& operator=(const stat_looper& a_from){
1316 base_looper<T>::operator=(a_from); 1316 base_looper<T>::operator=(a_from);
1317 if(&a_from==this) return *this; 1317 if(&a_from==this) return *this;
1318 m_first = true; 1318 m_first = true;
1319 m_mn = T(); 1319 m_mn = T();
1320 m_mx = T(); 1320 m_mx = T();
1321 m_S = T(); 1321 m_S = T();
1322 m_S2 = T(); 1322 m_S2 = T();
1323 m_counter = 0; 1323 m_counter = 0;
1324 return *this; 1324 return *this;
1325 } 1325 }
1326 public: 1326 public:
1327 bool process() { 1327 bool process() {
1328 m_counter = 0; 1328 m_counter = 0;
1329 if(!base_looper<T>::process()) { 1329 if(!base_looper<T>::process()) {
1330 m_mn = T(); 1330 m_mn = T();
1331 m_mx = T(); 1331 m_mx = T();
1332 m_S = T(); 1332 m_S = T();
1333 m_S2 = T(); 1333 m_S2 = T();
1334 m_counter = 0; 1334 m_counter = 0;
1335 return false; 1335 return false;
1336 } 1336 }
1337 return true; 1337 return true;
1338 } 1338 }
1339 T mn() const {return m_mn;} 1339 T mn() const {return m_mn;}
1340 T mx() const {return m_mx;} 1340 T mx() const {return m_mx;}
1341 T S() const {return m_S;} 1341 T S() const {return m_S;}
1342 T S2() const {return m_S2;} 1342 T S2() const {return m_S2;}
1343 uint64 counter() const {return m_counter;} 1343 uint64 counter() const {return m_counter;}
1344 protected: 1344 protected:
1345 bool m_first; 1345 bool m_first;
1346 T m_mn; 1346 T m_mn;
1347 T m_mx; 1347 T m_mx;
1348 T m_S; 1348 T m_S;
1349 T m_S2; 1349 T m_S2;
1350 uint64 m_counter; 1350 uint64 m_counter;
1351 }; 1351 };
1352 1352
1353 template <class T> 1353 template <class T>
1354 inline bool column_infos(base_ntu& a_ntu, 1354 inline bool column_infos(base_ntu& a_ntu,
1355 base_col& a_col, 1355 base_col& a_col,
1356 T& a_mn,T& a_mx,T& a 1356 T& a_mn,T& a_mx,T& a_S,T& a_S2,
1357 uint64& a_count){ 1357 uint64& a_count){
1358 stat_looper<T> lpr(a_ntu,a_col); 1358 stat_looper<T> lpr(a_ntu,a_col);
1359 bool status = lpr.process(); 1359 bool status = lpr.process();
1360 a_mn = lpr.mn(); 1360 a_mn = lpr.mn();
1361 a_mx = lpr.mx(); 1361 a_mx = lpr.mx();
1362 a_S = lpr.S(); 1362 a_S = lpr.S();
1363 a_S2 = lpr.S2(); 1363 a_S2 = lpr.S2();
1364 a_count = lpr.counter(); 1364 a_count = lpr.counter();
1365 if(!status) return false; 1365 if(!status) return false;
1366 if(!a_count) return false; 1366 if(!a_count) return false;
1367 return true; 1367 return true;
1368 } 1368 }
1369 1369
1370 inline base_col* find_leaf_column(const base_ 1370 inline base_col* find_leaf_column(const base_ntu& a_ntu,const std::string& a_name){
1371 const std::vector<base_col*>& cols = a_ntu. 1371 const std::vector<base_col*>& cols = a_ntu.columns();
1372 tools_vforcit(base_col*,cols,it) { 1372 tools_vforcit(base_col*,cols,it) {
1373 aida_col_ntu* col = safe_cast<base_col,ai 1373 aida_col_ntu* col = safe_cast<base_col,aida_col_ntu>(*(*it));
1374 if(col) { 1374 if(col) {
1375 base_ntu* sub = col->get_to_fill(); //i 1375 base_ntu* sub = col->get_to_fill(); //it holds the "sub" cols schema.
1376 if(!sub) return 0; 1376 if(!sub) return 0;
1377 base_col* fcol = find_leaf_column(*sub, 1377 base_col* fcol = find_leaf_column(*sub,a_name);
1378 if(fcol) return fcol; 1378 if(fcol) return fcol;
1379 } else { 1379 } else {
1380 if((*it)->name()==a_name) return *it; 1380 if((*it)->name()==a_name) return *it;
1381 } 1381 }
1382 } 1382 }
1383 return 0; 1383 return 0;
1384 } 1384 }
1385 1385
1386 template <class T> 1386 template <class T>
1387 inline bool to_vector(base_ntu& a_ntu,std::ve 1387 inline bool to_vector(base_ntu& a_ntu,std::vector<double>& a_vec,unsigned int a_col = 0) {
1388 a_vec.clear(); 1388 a_vec.clear();
1389 const std::vector<base_col*>& cols = a_ntu. 1389 const std::vector<base_col*>& cols = a_ntu.columns();
1390 if(cols.empty()) return false; 1390 if(cols.empty()) return false;
1391 if(a_col>=cols.size()) return false; 1391 if(a_col>=cols.size()) return false;
1392 base_col* _base_col = cols[a_col]; 1392 base_col* _base_col = cols[a_col];
1393 aida_col<T>* _col = safe_cast<base_col, aid 1393 aida_col<T>* _col = safe_cast<base_col, aida_col<T> >(*_base_col);
1394 if(!_col) return false; 1394 if(!_col) return false;
1395 a_ntu.start(); 1395 a_ntu.start();
1396 uint64 _rows = a_ntu.rows(); 1396 uint64 _rows = a_ntu.rows();
1397 a_vec.resize(_rows); 1397 a_vec.resize(_rows);
1398 T v; 1398 T v;
1399 {for(uint64 row=0;row<_rows;row++) { 1399 {for(uint64 row=0;row<_rows;row++) {
1400 if(!a_ntu.next()) {a_vec.clear();return f 1400 if(!a_ntu.next()) {a_vec.clear();return false;}
1401 if(!_col->get_entry(v)) {} 1401 if(!_col->get_entry(v)) {}
1402 a_vec[row] = v; 1402 a_vec[row] = v;
1403 }} 1403 }}
1404 return true; 1404 return true;
1405 } 1405 }
1406 1406
1407 template <class T> 1407 template <class T>
1408 inline bool column_min(ntuple& a_ntu,unsigned 1408 inline bool column_min(ntuple& a_ntu,unsigned int a_col,T& a_value) {
1409 return a_ntu.column_min(a_col,a_value); 1409 return a_ntu.column_min(a_col,a_value);
1410 } 1410 }
1411 1411
1412 template <class T> 1412 template <class T>
1413 inline bool column_max(ntuple& a_ntu,unsigned 1413 inline bool column_max(ntuple& a_ntu,unsigned int a_col,T& a_value) {
1414 return a_ntu.column_max(a_col,a_value); 1414 return a_ntu.column_max(a_col,a_value);
1415 } 1415 }
1416 1416
1417 }} 1417 }}
1418 1418
1419 #endif 1419 #endif