| 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_wroot_ntuple 4 #ifndef tools_wroot_ntuple
5 #define tools_wroot_ntuple 5 #define tools_wroot_ntuple
6 6
7 // An ntuple class to write at the CERN-ROOT f 7 // An ntuple class to write at the CERN-ROOT format.
8 // It inherits wroot::tree and each column is 8 // It inherits wroot::tree and each column is mapped
9 // on a (wroot::branch,wroot::leaf). Each add_ 9 // on a (wroot::branch,wroot::leaf). Each add_row() does a tree::fill().
10 10
11 #include "tree" 11 #include "tree"
12 #include "icol" 12 #include "icol"
13 13
14 #include "../vfind" 14 #include "../vfind"
15 #include "../vmanip" 15 #include "../vmanip"
16 #include "../ntuple_booking" 16 #include "../ntuple_booking"
17 #include "../sout" 17 #include "../sout"
18 #include "../scast" 18 #include "../scast"
19 #include "../forit" 19 #include "../forit"
20 20
21 // for mpi : 21 // for mpi :
22 #include "mpi_create_basket" 22 #include "mpi_create_basket"
23 23
24 #ifdef TOOLS_MEM 24 #ifdef TOOLS_MEM
25 #include "../mem" 25 #include "../mem"
26 #endif 26 #endif
27 27
28 namespace tools { 28 namespace tools {
29 namespace wroot { 29 namespace wroot {
30 30
31 class ntuple : public tree { 31 class ntuple : public tree {
32 public: 32 public:
33 //typedef wroot::icol icol; //for backward com 33 //typedef wroot::icol icol; //for backward compatibility.
34 public: 34 public:
35 35
36 #include "columns.icc" 36 #include "columns.icc"
37 37
38 public: 38 public:
39 ntuple(idir& a_dir,const std::string& a_name 39 ntuple(idir& a_dir,const std::string& a_name,const std::string& a_title,bool a_row_wise = false)
40 :tree(a_dir,a_name,a_title),m_row_wise(a_row 40 :tree(a_dir,a_name,a_title),m_row_wise(a_row_wise),m_row_wise_branch(0)
41 { 41 {
42 if(m_row_wise) m_row_wise_branch = create_ 42 if(m_row_wise) m_row_wise_branch = create_branch("row_wise_branch");
43 } 43 }
44 44
45 ntuple(idir& a_dir,const ntuple_booking& a_b 45 ntuple(idir& a_dir,const ntuple_booking& a_bkg,bool a_row_wise = false)
46 :tree(a_dir,a_bkg.name(),a_bkg.title()),m_ro 46 :tree(a_dir,a_bkg.name(),a_bkg.title()),m_row_wise(a_row_wise),m_row_wise_branch(0)
47 { 47 {
48 if(m_row_wise) m_row_wise_branch = create_ 48 if(m_row_wise) m_row_wise_branch = create_branch("row_wise_branch");
49 49
50 const std::vector<column_booking>& cols = 50 const std::vector<column_booking>& cols = a_bkg.columns();
51 tools_vforcit(column_booking,cols,it){ 51 tools_vforcit(column_booking,cols,it){
52 52
53 #define TOOLS_WROOT_NTUPLE_CREATE_COL(a__type) 53 #define TOOLS_WROOT_NTUPLE_CREATE_COL(a__type) \
54 if((*it).cls_id()==_cid(a__type())) {\ 54 if((*it).cls_id()==_cid(a__type())) {\
55 a__type* user = (a__type*)(*it).user_o 55 a__type* user = (a__type*)(*it).user_obj();\
56 if(user) {\ 56 if(user) {\
57 if(!create_column_ref<a__type>((*it) 57 if(!create_column_ref<a__type>((*it).name(),*user)) {\
58 m_out << "tools::wroot::ntuple : create_ 58 m_out << "tools::wroot::ntuple : create_column_ref(" << (*it).name() << ") failed." << std::endl;\
59 safe_clear<icol>(m_cols);\ 59 safe_clear<icol>(m_cols);\
60 safe_clear<branch>(m_branches);\ 60 safe_clear<branch>(m_branches);\
61 return;\ 61 return;\
62 }\ 62 }\
63 } else {\ 63 } else {\
64 if(!create_column<a__type>((*it).nam 64 if(!create_column<a__type>((*it).name())) {\
65 m_out << "tools::wroot::ntuple : create_ 65 m_out << "tools::wroot::ntuple : create_column(" << (*it).name() << ") failed." << std::endl;\
66 safe_clear<icol>(m_cols);\ 66 safe_clear<icol>(m_cols);\
67 safe_clear<branch>(m_branches);\ 67 safe_clear<branch>(m_branches);\
68 return;\ 68 return;\
69 }\ 69 }\
70 }\ 70 }\
71 } 71 }
72 72
73 #define TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(a__t 73 #define TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(a__type) \
74 if((*it).cls_id()==_cid_std_vector<a__ty 74 if((*it).cls_id()==_cid_std_vector<a__type>()) {\
75 std::vector<a__type>* vec = (std::vect 75 std::vector<a__type>* vec = (std::vector<a__type>*)(*it).user_obj();\
76 if(vec) {\ 76 if(vec) {\
77 if(!create_column_vector_ref<a__type 77 if(!create_column_vector_ref<a__type>((*it).name(),*vec)) {\
78 m_out << "tools::wroot::ntuple : c 78 m_out << "tools::wroot::ntuple : create_column_vector_ref(" << (*it).name() << ") failed." << std::endl;\
79 safe_clear<icol>(m_cols);\ 79 safe_clear<icol>(m_cols);\
80 safe_clear<branch>(m_branches);\ 80 safe_clear<branch>(m_branches);\
81 return;\ 81 return;\
82 }\ 82 }\
83 } else {\ 83 } else {\
84 if(!create_column_vector<a__type>((* 84 if(!create_column_vector<a__type>((*it).name())) {\
85 m_out << "tools::wroot::ntuple : c 85 m_out << "tools::wroot::ntuple : create_column_vector(" << (*it).name() << ") failed." << std::endl;\
86 safe_clear<icol>(m_cols);\ 86 safe_clear<icol>(m_cols);\
87 safe_clear<branch>(m_branches);\ 87 safe_clear<branch>(m_branches);\
88 return;\ 88 return;\
89 }\ 89 }\
90 }\ 90 }\
91 } 91 }
92 92
93 //below types are in sync with rroot/ntu 93 //below types are in sync with rroot/ntuple.
94 94
95 TOOLS_WROOT_NTUPLE_CREATE_COL(char) 95 TOOLS_WROOT_NTUPLE_CREATE_COL(char)
96 else TOOLS_WROOT_NTUPLE_CREATE_COL(short 96 else TOOLS_WROOT_NTUPLE_CREATE_COL(short)
97 else TOOLS_WROOT_NTUPLE_CREATE_COL(int) 97 else TOOLS_WROOT_NTUPLE_CREATE_COL(int)
98 else TOOLS_WROOT_NTUPLE_CREATE_COL(float 98 else TOOLS_WROOT_NTUPLE_CREATE_COL(float)
99 else TOOLS_WROOT_NTUPLE_CREATE_COL(doubl 99 else TOOLS_WROOT_NTUPLE_CREATE_COL(double)
100 100
101 else if((*it).cls_id()==_cid(std::string 101 else if((*it).cls_id()==_cid(std::string())) {
102 std::string* user = (std::string*)(*it 102 std::string* user = (std::string*)(*it).user_obj();
103 if(user) { 103 if(user) {
104 if(!create_column_string_ref((*it).n 104 if(!create_column_string_ref((*it).name(),*user)) {
105 m_out << "tools::wroot::ntuple : create_ 105 m_out << "tools::wroot::ntuple : create_column_string_ref(" << (*it).name() << ") failed." << std::endl;
106 safe_clear<icol>(m_cols); 106 safe_clear<icol>(m_cols);
107 safe_clear<branch>(m_branches); 107 safe_clear<branch>(m_branches);
108 return; 108 return;
109 } 109 }
110 } else { 110 } else {
111 if(!create_column_string((*it).name( 111 if(!create_column_string((*it).name())) {
112 m_out << "tools::wroot::ntuple : create_ 112 m_out << "tools::wroot::ntuple : create_column_string(" << (*it).name() << ") failed." << std::endl;
113 safe_clear<icol>(m_cols); 113 safe_clear<icol>(m_cols);
114 safe_clear<branch>(m_branches); 114 safe_clear<branch>(m_branches);
115 return; 115 return;
116 } 116 }
117 } 117 }
118 } 118 }
119 119
120 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(c 120 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(char)
121 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(s 121 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(short)
122 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(i 122 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(int)
123 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(f 123 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(float)
124 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(d 124 else TOOLS_WROOT_NTUPLE_CREATE_VEC_COL(double)
125 125
126 else if((*it).cls_id()==_cid_std_vector< 126 else if((*it).cls_id()==_cid_std_vector<std::string>()) {\
127 std::vector<std::string>* user = (std: 127 std::vector<std::string>* user = (std::vector<std::string>*)(*it).user_obj();
128 char sep = '\n'; 128 char sep = '\n';
129 if(user) { 129 if(user) {
130 if(!create_column_vector_string_ref( 130 if(!create_column_vector_string_ref((*it).name(),*user,sep)) {
131 m_out << "tools::wroot::ntuple : create_ 131 m_out << "tools::wroot::ntuple : create_column_vector_string_ref(" << (*it).name() << ") failed." << std::endl;
132 safe_clear<icol>(m_cols); 132 safe_clear<icol>(m_cols);
133 safe_clear<branch>(m_branches); 133 safe_clear<branch>(m_branches);
134 return; 134 return;
135 } 135 }
136 } else { 136 } else {
137 if(!create_column_vector_string((*it 137 if(!create_column_vector_string((*it).name(),std::vector<std::string>(),sep)) {
138 m_out << "tools::wroot::ntuple : create_ 138 m_out << "tools::wroot::ntuple : create_column_vector_string(" << (*it).name() << ") failed." << std::endl;
139 safe_clear<icol>(m_cols); 139 safe_clear<icol>(m_cols);
140 safe_clear<branch>(m_branches); 140 safe_clear<branch>(m_branches);
141 return; 141 return;
142 } 142 }
143 } 143 }
144 } 144 }
145 145
146 // no leaf_store_class() defined for the 146 // no leaf_store_class() defined for the other types.
147 147
148 else { 148 else {
149 m_out << "tools::wroot::ntuple :" 149 m_out << "tools::wroot::ntuple :"
150 << " for column " << sout((*it). 150 << " for column " << sout((*it).name())
151 << ", type with cid " << (*it).c 151 << ", type with cid " << (*it).cls_id() << " not yet handled."
152 << std::endl; 152 << std::endl;
153 //throw 153 //throw
154 safe_clear<icol>(m_cols); 154 safe_clear<icol>(m_cols);
155 safe_clear<branch>(m_branches); 155 safe_clear<branch>(m_branches);
156 return; 156 return;
157 } 157 }
158 } 158 }
159 #undef TOOLS_WROOT_NTUPLE_CREATE_VEC_COL 159 #undef TOOLS_WROOT_NTUPLE_CREATE_VEC_COL
160 #undef TOOLS_WROOT_NTUPLE_CREATE_COL 160 #undef TOOLS_WROOT_NTUPLE_CREATE_COL
161 161
162 } 162 }
163 163
164 virtual ~ntuple() { 164 virtual ~ntuple() {
165 safe_clear<icol>(m_cols); 165 safe_clear<icol>(m_cols);
166 } 166 }
167 protected: 167 protected:
168 ntuple(const ntuple& a_from):iobject(a_from) 168 ntuple(const ntuple& a_from):iobject(a_from),itree(a_from),tree(a_from),m_row_wise(a_from.m_row_wise){}
169 ntuple& operator=(const ntuple&){return *thi 169 ntuple& operator=(const ntuple&){return *this;}
170 public: 170 public:
171 const std::vector<icol*>& columns() const {r 171 const std::vector<icol*>& columns() const {return m_cols;}
172 std::vector<icol*>& columns() {return m_cols 172 std::vector<icol*>& columns() {return m_cols;}
173 173
174 template <class T> 174 template <class T>
175 column_ref<T>* create_column_ref(const std:: 175 column_ref<T>* create_column_ref(const std::string& a_name,const T& a_ref) {
176 if(find_named<icol>(m_cols,a_name)) return 176 if(find_named<icol>(m_cols,a_name)) return 0;
177 branch* _branch = m_row_wise?m_row_wise_br 177 branch* _branch = m_row_wise?m_row_wise_branch:create_branch(a_name);
178 if(!_branch) return 0; 178 if(!_branch) return 0;
179 column_ref<T>* col = new column_ref<T>(*_b 179 column_ref<T>* col = new column_ref<T>(*_branch,a_name,a_ref);
180 if(!col) return 0; 180 if(!col) return 0;
181 m_cols.push_back(col); 181 m_cols.push_back(col);
182 return col; 182 return col;
183 } 183 }
184 184
185 template <class T> 185 template <class T>
186 column<T>* create_column(const std::string& 186 column<T>* create_column(const std::string& a_name,const T& a_def = T()) {
187 if(find_named<icol>(m_cols,a_name)) return 187 if(find_named<icol>(m_cols,a_name)) return 0;
188 branch* _branch = m_row_wise?m_row_wise_br 188 branch* _branch = m_row_wise?m_row_wise_branch:create_branch(a_name);
189 if(!_branch) return 0; 189 if(!_branch) return 0;
190 column<T>* col = new column<T>(*_branch,a_ 190 column<T>* col = new column<T>(*_branch,a_name,a_def);
191 if(!col) return 0; 191 if(!col) return 0;
192 m_cols.push_back(col); 192 m_cols.push_back(col);
193 return col; 193 return col;
194 } 194 }
195 195
196 column_string_ref* create_column_string_ref( 196 column_string_ref* create_column_string_ref(const std::string& a_name,const std::string& a_ref) {
197 if(find_named<icol>(m_cols,a_name)) return 197 if(find_named<icol>(m_cols,a_name)) return 0;
198 branch* _branch = m_row_wise?m_row_wise_br 198 branch* _branch = m_row_wise?m_row_wise_branch:create_branch(a_name);
199 if(!_branch) return 0; 199 if(!_branch) return 0;
200 column_string_ref* col = new column_string 200 column_string_ref* col = new column_string_ref(*_branch,a_name,a_ref);
201 if(!col) return 0; 201 if(!col) return 0;
202 m_cols.push_back(col); 202 m_cols.push_back(col);
203 return col; 203 return col;
204 } 204 }
205 205
206 column_string* create_column_string(const st 206 column_string* create_column_string(const std::string& a_name,const std::string& a_def = std::string()) {
207 if(find_named<icol>(m_cols,a_name)) return 207 if(find_named<icol>(m_cols,a_name)) return 0;
208 branch* _branch = m_row_wise?m_row_wise_br 208 branch* _branch = m_row_wise?m_row_wise_branch:create_branch(a_name);
209 if(!_branch) return 0; 209 if(!_branch) return 0;
210 column_string* col = new column_string(*_b 210 column_string* col = new column_string(*_branch,a_name,a_def);
211 if(!col) return 0; 211 if(!col) return 0;
212 m_cols.push_back(col); 212 m_cols.push_back(col);
213 return col; 213 return col;
214 } 214 }
215 215
216 column_vector_string_ref* create_column_vect 216 column_vector_string_ref* create_column_vector_string_ref(const std::string& a_name,
217 217 const std::vector<std::string>& a_ref,char a_sep) {
218 if(find_named<icol>(m_cols,a_name)) return 218 if(find_named<icol>(m_cols,a_name)) return 0;
219 branch* _branch = m_row_wise?m_row_wise_br 219 branch* _branch = m_row_wise?m_row_wise_branch:create_branch(a_name);
220 if(!_branch) return 0; 220 if(!_branch) return 0;
221 column_vector_string_ref* col = new column 221 column_vector_string_ref* col = new column_vector_string_ref(*_branch,a_name,a_ref,a_sep);
222 if(!col) return 0; 222 if(!col) return 0;
223 m_cols.push_back(col); 223 m_cols.push_back(col);
224 return col; 224 return col;
225 } 225 }
226 226
227 column_vector_string* create_column_vector_s 227 column_vector_string* create_column_vector_string(const std::string& a_name,
228 228 const std::vector<std::string>& a_def,char a_sep) {
229 if(find_named<icol>(m_cols,a_name)) return 229 if(find_named<icol>(m_cols,a_name)) return 0;
230 branch* _branch = m_row_wise?m_row_wise_br 230 branch* _branch = m_row_wise?m_row_wise_branch:create_branch(a_name);
231 if(!_branch) return 0; 231 if(!_branch) return 0;
232 column_vector_string* col = new column_vec 232 column_vector_string* col = new column_vector_string(*_branch,a_name,a_def,a_sep);
233 if(!col) return 0; 233 if(!col) return 0;
234 m_cols.push_back(col); 234 m_cols.push_back(col);
235 return col; 235 return col;
236 } 236 }
237 237
238 template <class T> 238 template <class T>
239 std_vector_column_ref<T>* create_column_vect 239 std_vector_column_ref<T>* create_column_vector_ref(const std::string& a_name,const std::vector<T>& a_ref) {
240 if(find_named<icol>(m_cols,a_name)) return 240 if(find_named<icol>(m_cols,a_name)) return 0;
241 branch* _branch = m_row_wise?m_row_wise_br 241 branch* _branch = m_row_wise?m_row_wise_branch:create_std_vector_be_ref<T>(a_name,a_ref);
242 if(!_branch) return 0; 242 if(!_branch) return 0;
243 std_vector_column_ref<T>* col = new std_ve 243 std_vector_column_ref<T>* col = new std_vector_column_ref<T>(*_branch,a_name,a_ref);
244 if(!col) return 0; 244 if(!col) return 0;
245 m_cols.push_back(col); 245 m_cols.push_back(col);
246 return col; 246 return col;
247 } 247 }
248 248
249 template <class T> 249 template <class T>
250 std_vector_column<T>* create_column_vector(c 250 std_vector_column<T>* create_column_vector(const std::string& a_name,const std::vector<T>& a_def = std::vector<T>()) {
251 if(find_named<icol>(m_cols,a_name)) return 251 if(find_named<icol>(m_cols,a_name)) return 0;
252 if(m_row_wise) { 252 if(m_row_wise) {
253 branch* _branch = m_row_wise_branch; 253 branch* _branch = m_row_wise_branch;
254 std_vector_column<T>* col = new std_vect 254 std_vector_column<T>* col = new std_vector_column<T>(*_branch,a_name,a_def);
255 if(!col) return 0; 255 if(!col) return 0;
256 m_cols.push_back(col); 256 m_cols.push_back(col);
257 return col; 257 return col;
258 } else { 258 } else {
259 std_vector_be_pointer<T>* _branch = crea 259 std_vector_be_pointer<T>* _branch = create_std_vector_be_pointer<T>(a_name,0);
260 if(!_branch) return 0; 260 if(!_branch) return 0;
261 std_vector_column<T>* col = new std_vect 261 std_vector_column<T>* col = new std_vector_column<T>(*_branch,a_name,a_def);
262 if(!col) return 0; 262 if(!col) return 0;
263 _branch->set_pointer(&(col->variable())) 263 _branch->set_pointer(&(col->variable()));
264 m_cols.push_back(col); 264 m_cols.push_back(col);
265 return col; 265 return col;
266 } 266 }
267 } 267 }
268 268
269 template <class T> 269 template <class T>
270 column_ref<T>* find_column_ref(const std::st 270 column_ref<T>* find_column_ref(const std::string& a_name) {
271 icol* col = find_named<icol>(m_cols,a_name 271 icol* col = find_named<icol>(m_cols,a_name);
272 if(!col) return 0; 272 if(!col) return 0;
273 return id_cast<icol, column_ref<T> >(*col) 273 return id_cast<icol, column_ref<T> >(*col);
274 } 274 }
275 275
276 template <class T> 276 template <class T>
277 column<T>* find_column(const std::string& a_ 277 column<T>* find_column(const std::string& a_name) {
278 icol* col = find_named<icol>(m_cols,a_name 278 icol* col = find_named<icol>(m_cols,a_name);
279 if(!col) return 0; 279 if(!col) return 0;
280 return id_cast<icol, column<T> >(*col); 280 return id_cast<icol, column<T> >(*col);
281 } 281 }
282 282
283 column_string_ref* find_column_string_ref(co 283 column_string_ref* find_column_string_ref(const std::string& a_name) {
284 icol* col = find_named<icol>(m_cols,a_name 284 icol* col = find_named<icol>(m_cols,a_name);
285 if(!col) return 0; 285 if(!col) return 0;
286 return id_cast<icol, column_string_ref >(* 286 return id_cast<icol, column_string_ref >(*col);
287 } 287 }
288 288
289 column_string* find_column_string(const std: 289 column_string* find_column_string(const std::string& a_name) {
290 icol* col = find_named<icol>(m_cols,a_name 290 icol* col = find_named<icol>(m_cols,a_name);
291 if(!col) return 0; 291 if(!col) return 0;
292 return id_cast<icol, column_string >(*col) 292 return id_cast<icol, column_string >(*col);
293 } 293 }
294 294
295 template <class T> 295 template <class T>
296 std_vector_column_ref<T>* find_column_vector 296 std_vector_column_ref<T>* find_column_vector_ref(const std::string& a_name) {
297 icol* col = find_named<icol>(m_cols,a_name 297 icol* col = find_named<icol>(m_cols,a_name);
298 if(!col) return 0; 298 if(!col) return 0;
299 return id_cast<icol, std_vector_column_ref 299 return id_cast<icol, std_vector_column_ref<T> >(*col);
300 } 300 }
301 301
302 template <class T> 302 template <class T>
303 std_vector_column<T>* find_column_vector(con 303 std_vector_column<T>* find_column_vector(const std::string& a_name) {
304 icol* col = find_named<icol>(m_cols,a_name 304 icol* col = find_named<icol>(m_cols,a_name);
305 if(!col) return 0; 305 if(!col) return 0;
306 return id_cast<icol, std_vector_column<T> 306 return id_cast<icol, std_vector_column<T> >(*col);
307 } 307 }
308 308
309 column_vector_string_ref* find_column_vector 309 column_vector_string_ref* find_column_vector_string_ref(const std::string& a_name) {
310 icol* col = find_named<icol>(m_cols,a_name 310 icol* col = find_named<icol>(m_cols,a_name);
311 if(!col) return 0; 311 if(!col) return 0;
312 return id_cast<icol, column_vector_string_ 312 return id_cast<icol, column_vector_string_ref >(*col);
313 } 313 }
314 314
315 column_vector_string* find_column_vector_str 315 column_vector_string* find_column_vector_string(const std::string& a_name) {
316 icol* col = find_named<icol>(m_cols,a_name 316 icol* col = find_named<icol>(m_cols,a_name);
317 if(!col) return 0; 317 if(!col) return 0;
318 return id_cast<icol, column_vector_string 318 return id_cast<icol, column_vector_string >(*col);
319 } 319 }
320 320
321 void print_columns(std::ostream& a_out) { 321 void print_columns(std::ostream& a_out) {
322 a_out << "for ntuple named " << sout(m_nam 322 a_out << "for ntuple named " << sout(m_name) << ", number of columns " << m_cols.size() << " :" << std::endl;
323 tools_vforit(icol*,m_cols,it) { 323 tools_vforit(icol*,m_cols,it) {
324 a_out << " " << (*it)->name() << std::en 324 a_out << " " << (*it)->name() << std::endl;
325 } 325 }
326 } 326 }
327 327
328 bool add_row() { 328 bool add_row() {
329 if(m_cols.empty()) return false; 329 if(m_cols.empty()) return false;
330 tools_vforit(icol*,m_cols,it) (*it)->add() 330 tools_vforit(icol*,m_cols,it) (*it)->add();
331 uint32 n; 331 uint32 n;
332 bool status = tree::fill(n); 332 bool status = tree::fill(n);
333 tools_vforit(icol*,m_cols,it) (*it)->set_d 333 tools_vforit(icol*,m_cols,it) (*it)->set_def();
334 return status; 334 return status;
335 } 335 }
336 336
337 void set_basket_size(uint32 a_size) { 337 void set_basket_size(uint32 a_size) {
338 if(m_row_wise) { 338 if(m_row_wise) {
339 if(m_row_wise_branch) m_row_wise_branch- 339 if(m_row_wise_branch) m_row_wise_branch->set_basket_size(a_size);
340 } else { 340 } else {
341 tools_vforit(icol*,m_cols,it) (*it)->set 341 tools_vforit(icol*,m_cols,it) (*it)->set_basket_size(a_size);
342 } 342 }
343 } 343 }
344 344
345 //////////////////////////////////////////// 345 ///////////////////////////////////////////////////////////////////////////
346 /// for parallelization : ////////////////// 346 /// for parallelization : /////////////////////////////////////////////////
347 //////////////////////////////////////////// 347 ///////////////////////////////////////////////////////////////////////////
348 branch* get_row_wise_branch() const {return 348 branch* get_row_wise_branch() const {return m_row_wise_branch;}
349 void get_branches(std::vector<branch*>& a_ve 349 void get_branches(std::vector<branch*>& a_vec) const {
350 a_vec.clear(); 350 a_vec.clear();
351 tools_vforcit(icol*,m_cols,it) a_vec.push_ 351 tools_vforcit(icol*,m_cols,it) a_vec.push_back(&((*it)->get_branch()));
352 } 352 }
353 353
354 bool merge_number_of_entries() { 354 bool merge_number_of_entries() {
355 m_entries = 0; //it should be zero! 355 m_entries = 0; //it should be zero!
356 m_tot_bytes = 0; 356 m_tot_bytes = 0;
357 m_zip_bytes = 0; 357 m_zip_bytes = 0;
358 bool status = true; 358 bool status = true;
359 tools_vforit(icol*,m_cols,it) { 359 tools_vforit(icol*,m_cols,it) {
360 if(it==m_cols.begin()) { 360 if(it==m_cols.begin()) {
361 m_entries = (*it)->get_branch().entrie 361 m_entries = (*it)->get_branch().entries();
362 } else if(m_entries!=(*it)->get_branch() 362 } else if(m_entries!=(*it)->get_branch().entries()) {
363 m_out << "tools::wroot::ntuple::merge_ 363 m_out << "tools::wroot::ntuple::merge_number_of_entries :"
364 << " branches do not have same n 364 << " branches do not have same number of entries."
365 << std::endl; 365 << std::endl;
366 status = false; 366 status = false;
367 } 367 }
368 m_tot_bytes += (*it)->get_branch().tot_b 368 m_tot_bytes += (*it)->get_branch().tot_bytes();
369 m_zip_bytes += (*it)->get_branch().zip_b 369 m_zip_bytes += (*it)->get_branch().zip_bytes();
370 } 370 }
371 return status; 371 return status;
372 } 372 }
373 373
374 bool mpi_add_basket(impi& a_impi) { 374 bool mpi_add_basket(impi& a_impi) {
375 uint32 icol; //not used if row_wise. 375 uint32 icol; //not used if row_wise.
376 if(!a_impi.unpack(icol)) { 376 if(!a_impi.unpack(icol)) {
377 m_out << "tools::wroot::ntuple::mpi_add_ 377 m_out << "tools::wroot::ntuple::mpi_add_basket : unpack(icol) failed."<< std::endl;
378 return false; 378 return false;
379 } 379 }
380 380
381 if(m_row_wise) { 381 if(m_row_wise) {
382 if(!m_row_wise_branch) return false; 382 if(!m_row_wise_branch) return false;
383 383
384 basket* basket = mpi_create_basket(m_out 384 basket* basket = mpi_create_basket(m_out,a_impi,
385 m_dir 385 m_dir.file().byte_swap(),m_dir.seek_directory(),
386 m_row 386 m_row_wise_branch->basket_size());
387 if(!basket) { 387 if(!basket) {
388 m_out << "tools::wroot::ntuple::mpi_ad 388 m_out << "tools::wroot::ntuple::mpi_add_basket : mpi_create_basket() failed."<< std::endl;
389 return false; 389 return false;
390 } 390 }
391 391
392 uint32 add_bytes,nout; 392 uint32 add_bytes,nout;
393 if(!m_row_wise_branch->add_basket(m_dir. 393 if(!m_row_wise_branch->add_basket(m_dir.file(),*basket,add_bytes,nout)) {
394 m_out << "tools::wroot::ntuple::mpi_ad 394 m_out << "tools::wroot::ntuple::mpi_add_basket : row wise : branch.add_basket() failed."<< std::endl;
395 delete basket; 395 delete basket;
396 return false; 396 return false;
397 } 397 }
398 398
399 delete basket; 399 delete basket;
400 m_row_wise_branch->set_tot_bytes(m_row_w 400 m_row_wise_branch->set_tot_bytes(m_row_wise_branch->tot_bytes()+add_bytes);
401 m_row_wise_branch->set_zip_bytes(m_row_w 401 m_row_wise_branch->set_zip_bytes(m_row_wise_branch->zip_bytes()+nout);
402 402
403 } else { 403 } else {
404 if(icol>=m_cols.size()) { 404 if(icol>=m_cols.size()) {
405 m_out << "tools::wroot::ntuple::mpi_ad 405 m_out << "tools::wroot::ntuple::mpi_add_basket : column index " << icol << " >= " << m_cols.size() << std::endl;
406 return false; 406 return false;
407 } 407 }
408 408
409 branch& _branch = m_cols[icol]->get_bran 409 branch& _branch = m_cols[icol]->get_branch();
410 410
411 basket* basket = mpi_create_basket(m_out 411 basket* basket = mpi_create_basket(m_out,a_impi,
412 m_dir 412 m_dir.file().byte_swap(),m_dir.seek_directory(),
413 _bran 413 _branch.basket_size());
414 if(!basket) { 414 if(!basket) {
415 m_out << "tools::wroot::ntuple::mpi_ad 415 m_out << "tools::wroot::ntuple::mpi_add_basket : mpi_create_basket() failed."<< std::endl;
416 return false; 416 return false;
417 } 417 }
418 418
419 uint32 add_bytes,nout; 419 uint32 add_bytes,nout;
420 if(!_branch.add_basket(m_dir.file(),*bas 420 if(!_branch.add_basket(m_dir.file(),*basket,add_bytes,nout)) {
421 m_out << "tools::wroot::ntuple::mpi_ad 421 m_out << "tools::wroot::ntuple::mpi_add_basket : column wise : branch.add_basket() failed."<< std::endl;
422 delete basket; 422 delete basket;
423 return false; 423 return false;
424 } 424 }
425 425
426 delete basket; 426 delete basket;
427 _branch.set_tot_bytes(_branch.tot_bytes( 427 _branch.set_tot_bytes(_branch.tot_bytes()+add_bytes);
428 _branch.set_zip_bytes(_branch.zip_bytes( 428 _branch.set_zip_bytes(_branch.zip_bytes()+nout);
429 } 429 }
430 return true; 430 return true;
431 } 431 }
432 432
433 bool mpi_add_baskets(impi& a_impi) { //colum 433 bool mpi_add_baskets(impi& a_impi) { //column_wise && row_mode only.
434 uint32 _icol = 0; 434 uint32 _icol = 0;
435 tools_vforcit(icol*,m_cols,it) { 435 tools_vforcit(icol*,m_cols,it) {
436 uint32 icol; 436 uint32 icol;
437 if(!a_impi.unpack(icol)) { 437 if(!a_impi.unpack(icol)) {
438 m_out << "tools::wroot::ntuple::mpi_ad 438 m_out << "tools::wroot::ntuple::mpi_add_baskets : unpack(icol) failed."<< std::endl;
439 return false; 439 return false;
440 } 440 }
441 if(icol!=_icol) { 441 if(icol!=_icol) {
442 m_out << "tools::wroot::ntuple::mpi_ad 442 m_out << "tools::wroot::ntuple::mpi_add_basket : received column index " << icol << ", whilst " << _icol << " expected." << std::endl;
443 return false; 443 return false;
444 } 444 }
445 branch& _branch = m_cols[icol]->get_bran 445 branch& _branch = m_cols[icol]->get_branch();
446 basket* basket = mpi_create_basket(m_out 446 basket* basket = mpi_create_basket(m_out,a_impi,
447 m_dir 447 m_dir.file().byte_swap(),m_dir.seek_directory(),
448 _bran 448 _branch.basket_size());
449 if(!basket) { 449 if(!basket) {
450 m_out << "tools::wroot::ntuple::mpi_ad 450 m_out << "tools::wroot::ntuple::mpi_add_basket : mpi_create_basket() failed."<< std::endl;
451 return false; 451 return false;
452 } 452 }
453 453
454 uint32 add_bytes,nout; 454 uint32 add_bytes,nout;
455 if(!_branch.add_basket(m_dir.file(),*bas 455 if(!_branch.add_basket(m_dir.file(),*basket,add_bytes,nout)) {
456 m_out << "tools::wroot::ntuple::mpi_ad 456 m_out << "tools::wroot::ntuple::mpi_add_basket : column wise : branch.add_basket() failed."<< std::endl;
457 delete basket; 457 delete basket;
458 return false; 458 return false;
459 } 459 }
460 460
461 delete basket; 461 delete basket;
462 _branch.set_tot_bytes(_branch.tot_bytes( 462 _branch.set_tot_bytes(_branch.tot_bytes()+add_bytes);
463 _branch.set_zip_bytes(_branch.zip_bytes( 463 _branch.set_zip_bytes(_branch.zip_bytes()+nout);
464 464
465 _icol++; 465 _icol++;
466 } 466 }
467 return true; 467 return true;
468 } 468 }
469 469
470 bool mpi_end_fill(impi& a_impi) { 470 bool mpi_end_fill(impi& a_impi) {
471 471
472 #define TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX 472 #define TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX(a__type) \
473 {leaf_ref<a__type>* _mleaf_ = _mleaf 473 {leaf_ref<a__type>* _mleaf_ = _mleaf?id_cast<base_leaf, leaf_ref<a__type> >(*_mleaf):0;\
474 if(_mleaf_) {\ 474 if(_mleaf_) {\
475 uint32 _len;\ 475 uint32 _len;\
476 if(!a_impi.unpack(_len)) return 476 if(!a_impi.unpack(_len)) return false;\
477 a__type _mx;\ 477 a__type _mx;\
478 if(!a_impi.unpack(_mx)) return f 478 if(!a_impi.unpack(_mx)) return false;\
479 _mleaf_->set_length(mx(_len,_mle 479 _mleaf_->set_length(mx(_len,_mleaf_->length()));\
480 _mleaf_->set_max(mx(_mx,_mleaf_- 480 _mleaf_->set_max(mx(_mx,_mleaf_->get_max()));\
481 set_done = true;\ 481 set_done = true;\
482 }} 482 }}
483 483
484 #define TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR 484 #define TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR_LENGTH_MAX(a__type) \
485 {leaf_std_vector_ref<a__type>* _mlea 485 {leaf_std_vector_ref<a__type>* _mleaf_ = _mleaf?id_cast<base_leaf, leaf_std_vector_ref<a__type> >(*_mleaf):0;\
486 if(_mleaf_) {\ 486 if(_mleaf_) {\
487 uint32 _len;\ 487 uint32 _len;\
488 if(!a_impi.unpack(_len)) return 488 if(!a_impi.unpack(_len)) return false;\
489 a__type _mx;\ 489 a__type _mx;\
490 if(!a_impi.unpack(_mx)) return f 490 if(!a_impi.unpack(_mx)) return false;\
491 _mleaf_->set_length(mx(_len,_mle 491 _mleaf_->set_length(mx(_len,_mleaf_->length()));\
492 _mleaf_->set_max(mx(_mx,_mleaf_- 492 _mleaf_->set_max(mx(_mx,_mleaf_->get_max()));\
493 set_done = true;\ 493 set_done = true;\
494 }} 494 }}
495 495
496 #define TOOLS_WROOT_NTUPLE_SET_LEAF_STRING_LEN 496 #define TOOLS_WROOT_NTUPLE_SET_LEAF_STRING_LENGTH_MAX \
497 {leaf_string_ref* _mleaf_ = _mleaf? 497 {leaf_string_ref* _mleaf_ = _mleaf?id_cast<base_leaf,leaf_string_ref>(*_mleaf):0;\
498 if(_mleaf_) {\ 498 if(_mleaf_) {\
499 uint32 _len;\ 499 uint32 _len;\
500 if(!a_impi.unpack(_len)) return 500 if(!a_impi.unpack(_len)) return false;\
501 int _mx;\ 501 int _mx;\
502 if(!a_impi.unpack(_mx)) return f 502 if(!a_impi.unpack(_mx)) return false;\
503 _mleaf_->set_length(mx(_len,_mle 503 _mleaf_->set_length(mx(_len,_mleaf_->length()));\
504 _mleaf_->set_max(mx(_mx,_mleaf_- 504 _mleaf_->set_max(mx(_mx,_mleaf_->get_max()));\
505 set_done = true;\ 505 set_done = true;\
506 }} 506 }}
507 507
508 if(m_row_wise) { 508 if(m_row_wise) {
509 if(!m_row_wise_branch) return false; 509 if(!m_row_wise_branch) return false;
510 510
511 tools_vforcit(base_leaf*,m_row_wise_bran 511 tools_vforcit(base_leaf*,m_row_wise_branch->leaves(),mit) {
512 base_leaf* _mleaf = *mit; 512 base_leaf* _mleaf = *mit;
513 513
514 bool set_done = false; 514 bool set_done = false;
515 515
516 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX 516 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX(char)
517 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX 517 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX(short)
518 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX 518 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX(int)
519 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX 519 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX(float)
520 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX 520 TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX(double)
521 521
522 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR 522 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR_LENGTH_MAX(char)
523 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR 523 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR_LENGTH_MAX(short)
524 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR 524 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR_LENGTH_MAX(int)
525 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR 525 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR_LENGTH_MAX(float)
526 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR 526 TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR_LENGTH_MAX(double)
527 527
528 TOOLS_WROOT_NTUPLE_SET_LEAF_STRING_LEN 528 TOOLS_WROOT_NTUPLE_SET_LEAF_STRING_LENGTH_MAX
529 529
530 if(!set_done) { 530 if(!set_done) {
531 m_out << "tools::wroot::ntuple::mpi_ 531 m_out << "tools::wroot::ntuple::mpi_end_fill :"
532 << " leaf " << _mleaf->name() 532 << " leaf " << _mleaf->name() << " with cid " << _mleaf->id_cls() << " not treated." << std::endl;
533 return false; 533 return false;
534 } 534 }
535 } 535 }
536 536
537 } else { // column wise : 537 } else { // column wise :
538 tools_vforcit(wroot::icol*,m_cols,it) { 538 tools_vforcit(wroot::icol*,m_cols,it) {
539 base_leaf* _mleaf = (*it)->get_leaf(); 539 base_leaf* _mleaf = (*it)->get_leaf();
540 540
541 bool set_done = false; 541 bool set_done = false;
542 TOOLS_WROOT_NTUPLE_SET_LEAF_STRING_LEN 542 TOOLS_WROOT_NTUPLE_SET_LEAF_STRING_LENGTH_MAX
543 543
544 if(!set_done) { 544 if(!set_done) {
545 uint32 _len; 545 uint32 _len;
546 if(!a_impi.unpack(_len)) return fals 546 if(!a_impi.unpack(_len)) return false;
547 int _mx; 547 int _mx;
548 if(!a_impi.unpack(_mx)) return false 548 if(!a_impi.unpack(_mx)) return false;
549 } 549 }
550 } 550 }
551 } 551 }
552 552
553 #undef TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX 553 #undef TOOLS_WROOT_NTUPLE_SET_LEAF_LENGTH_MAX
554 #undef TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR_ 554 #undef TOOLS_WROOT_NTUPLE_SET_LEAF_STD_VECTOR_LENGTH_MAX
555 #undef TOOLS_WROOT_NTUPLE_SET_LEAF_STRING_LENG 555 #undef TOOLS_WROOT_NTUPLE_SET_LEAF_STRING_LENGTH_MAX
556 556
557 return true; 557 return true;
558 } 558 }
559 559
560 protected: 560 protected:
561 std::vector<icol*> m_cols; 561 std::vector<icol*> m_cols;
562 bool m_row_wise; 562 bool m_row_wise;
563 branch* m_row_wise_branch; //used if row_wis 563 branch* m_row_wise_branch; //used if row_wise.
564 }; 564 };
565 565
566 }} 566 }}
567 567
568 #endif 568 #endif