Loading [MathJax]/extensions/tex2jax.js
The Gaudi Framework  v38r0 (2143aa4c)
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
TupleDecorator.cpp
Go to the documentation of this file.
1 /***********************************************************************************\
2 * (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
3 * *
4 * This software is distributed under the terms of the Apache version 2 licence, *
5 * copied verbatim in the file "LICENSE". *
6 * *
7 * In applying this licence, CERN does not waive the privileges and immunities *
8 * granted to it by virtue of its status as an Intergovernmental Organization *
9 * or submit itself to any jurisdiction. *
10 \***********************************************************************************/
11 // ============================================================================
12 // Include files
13 // ============================================================================
14 // CLHEP
15 // ============================================================================/
16 #include "CLHEP/Matrix/GenMatrix.h"
17 #include "CLHEP/Matrix/Matrix.h"
18 #include "CLHEP/Matrix/Vector.h"
19 // Handle CLHEP 2.0.x move to CLHEP namespace
20 namespace CLHEP {}
21 using namespace CLHEP;
22 // CLHEP is just #()$)*#)*@#)$@ Not even the git master (as of Aug 2015) has HepVector::begin and HepVector::end
23 // defined!!!
24 // fortunately, ADL comes to the rescue...
25 namespace CLHEP {
26  class HepVector;
27  double* begin( CLHEP::HepVector& v ) { return &v[0]; }
28  const double* begin( const CLHEP::HepVector& v ) { return &v[0]; }
29 } // namespace CLHEP
30 
31 // ============================================================================/
32 // GaudiAlg
33 // ============================================================================
34 #include "GaudiAlg/Tuple.h"
35 #include "GaudiAlg/TupleObj.h"
36 // ============================================================================
37 // GaudiPython
38 // ============================================================================
39 #include "GaudiPython/TupleDecorator.h"
40 #include "GaudiPython/Vector.h"
41 // ===========================================================================
47 // ============================================================================
48 namespace {
49  // ==========================================================================
50  template <class TYPE>
51  inline StatusCode _fill( const Tuples::Tuple& tuple, const std::string& name, const TYPE& value ) {
52  return tuple.valid() ? tuple->column( name, value ) : StatusCode::FAILURE;
53  }
54  // ==========================================================================
55 } // namespace
56 // ============================================================================
57 INTuple* GaudiPython::TupleDecorator::nTuple( const Tuples::Tuple& tuple ) {
58  if ( !tuple.valid() ) { return 0; }
59  return tuple->tuple();
60 }
61 // ============================================================================
62 NTuple::Tuple* GaudiPython::TupleDecorator::ntuple( const Tuples::Tuple& tuple ) {
63  if ( !tuple.valid() ) { return 0; }
64  return tuple->tuple();
65 }
66 // ============================================================================
67 bool GaudiPython::TupleDecorator::valid( const Tuples::Tuple& tuple ) { return tuple.valid(); }
68 // ============================================================================
69 StatusCode GaudiPython::TupleDecorator::write( const Tuples::Tuple& tuple ) {
70  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
71  return tuple->write();
72 }
73 // ============================================================================
74 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const std::string& name, const int value ) {
75  return _fill( tuple, name, value );
76 }
77 // ============================================================================
78 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const std::string& name, const int value,
79  const int minv, const int maxv ) {
80  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
81  return tuple->column( name, value, minv, maxv );
82 }
83 // ============================================================================
84 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const std::string& name,
85  const double value ) {
86  return _fill( tuple, name, value );
87 }
88 // ============================================================================
89 StatusCode GaudiPython::TupleDecorator::column_ll( const Tuples::Tuple& tuple, const std::string& name,
90  const long long value ) {
91  return _fill( tuple, name, value );
92 }
93 // ============================================================================
94 StatusCode GaudiPython::TupleDecorator::column_ull( const Tuples::Tuple& tuple, const std::string& name,
95  const unsigned long long value ) {
96  return _fill( tuple, name, value );
97 }
98 // ============================================================================
99 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const std::string& name,
100  const bool value ) {
101  return _fill( tuple, name, value );
102 }
103 // ============================================================================
104 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const std::string& name,
105  IOpaqueAddress* value ) {
106  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
107  return tuple->column( name, value );
108 }
109 // ============================================================================
110 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, IOpaqueAddress* value ) {
111  return column( tuple, "Address", value );
112 }
113 // ============================================================================
114 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const std::string& name,
115  const Gaudi::LorentzVector& value ) {
116  return _fill( tuple, name, value );
117 }
118 // ============================================================================
119 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const std::string& name,
120  const Gaudi::XYZVector& value ) {
121  return _fill( tuple, name, value );
122 }
123 // ============================================================================
124 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const std::string& name,
125  const Gaudi::XYZPoint& value ) {
126  return _fill( tuple, name, value );
127 }
128 // ============================================================================
129 StatusCode GaudiPython::TupleDecorator::farray( const Tuples::Tuple& tuple, const std::string& name,
130  const std::vector<double>& data, const std::string& length,
131  const size_t maxv ) {
132  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
133  return tuple->farray( name, data.begin(), data.end(), length, maxv );
134 }
135 // ============================================================================
136 StatusCode GaudiPython::TupleDecorator::fmatrix( const Tuples::Tuple& tuple, const std::string& name,
137  const GaudiPython::Matrix& data,
138  const Tuples::TupleObj::MIndex cols, // fixed !!!
139  const std::string& length, const size_t maxv ) {
140  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
141  if ( !data.empty() && cols != data.front().size() ) {
142  return tuple->Error( "GP:fmatrix(1): mismatch in matrix dimensions!" );
143  }
144  return tuple->fmatrix( name, data, data.size(), cols, length, maxv );
145 }
146 // ============================================================================
147 StatusCode GaudiPython::TupleDecorator::fmatrix( const Tuples::Tuple& tuple, const std::string& name,
148  const GaudiUtils::VectorMap<int, double>& info,
149  const std::string& length, const size_t maxv ) {
150  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
151  return tuple->fmatrix( name, info, length, maxv );
152 }
153 // ============================================================================
154 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
155  const std::vector<double>& data ) {
156  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
157  return tuple->array( name, data.begin(), data.end() );
158 }
159 // ============================================================================
160 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
161  const Gaudi::Vector1& data ) {
162  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
163  return tuple->array( name, data );
164 }
165 // ============================================================================
166 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
167  const Gaudi::Vector2& data ) {
168  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
169  return tuple->array( name, data );
170 }
171 // ============================================================================
172 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
173  const Gaudi::Vector3& data ) {
174  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
175  return tuple->array( name, data.begin(), data.begin() + 3 );
176 }
177 // ============================================================================
178 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
179  const Gaudi::Vector4& data ) {
180  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
181  // return tuple->array( name , data ) ;
182  return tuple->array( name, data.begin(), data.begin() + 4 );
183 }
184 // ============================================================================
185 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
186  const Gaudi::Vector5& data ) {
187  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
188  return tuple->array( name, data );
189 }
190 // ============================================================================
191 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
192  const Gaudi::Vector6& data ) {
193  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
194  return tuple->array( name, data );
195 }
196 // ============================================================================
197 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
198  const Gaudi::Vector7& data ) {
199  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
200  return tuple->array( name, data );
201 }
202 // ============================================================================
203 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
204  const Gaudi::Vector8& data ) {
205  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
206  return tuple->array( name, data );
207 }
208 // ============================================================================
209 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
210  const Gaudi::Vector9& data ) {
211  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
212  return tuple->array( name, data );
213 }
214 // ============================================================================
215 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
216  const GaudiPython::Matrix& data,
217  const Tuples::TupleObj::MIndex cols ) // fixed !!!
218 {
219  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
220  if ( data.empty() ) { return tuple->Warning( "GP:matrix(1): empty fixed matrix, skip matrix " ); }
221  if ( cols != data.front().size() ) { return tuple->Error( "GP:matrix(1): mismatch in fixed matrix dimensions!" ); }
222  return tuple->matrix( name, data, data.size(), cols );
223 }
224 // ============================================================================
225 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
226  const Gaudi::Matrix1x1& data ) {
227  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
228  return tuple->matrix( name, data );
229 }
230 // ============================================================================
231 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
232  const Gaudi::Matrix2x2& data ) {
233  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
234  return tuple->matrix( name, data );
235 }
236 // ============================================================================
237 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
238  const Gaudi::Matrix3x3& data ) {
239  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
240  return tuple->matrix( name, data );
241 }
242 // ============================================================================
243 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
244  const Gaudi::Matrix4x4& data ) {
245  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
246  return tuple->matrix( name, data );
247 }
248 // ============================================================================
249 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
250  const Gaudi::Matrix5x5& data ) {
251  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
252  return tuple->matrix( name, data );
253 }
254 // ============================================================================
255 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
256  const Gaudi::Matrix6x6& data ) {
257  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
258  return tuple->matrix( name, data );
259 }
260 // ============================================================================
261 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
262  const Gaudi::Matrix7x7& data ) {
263  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
264  return tuple->matrix( name, data );
265 }
266 // ============================================================================
267 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
268  const Gaudi::Matrix8x8& data ) {
269  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
270  return tuple->matrix( name, data );
271 }
272 // ============================================================================
273 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
274  const Gaudi::Matrix9x9& data ) {
275  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
276  return tuple->matrix( name, data );
277 }
278 // ============================================================================
279 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
280  const Gaudi::Matrix1x3& data ) {
281  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
282  return tuple->matrix( name, data );
283 }
284 // ============================================================================
285 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
286  const Gaudi::Matrix1x5& data ) {
287  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
288  return tuple->matrix( name, data );
289 }
290 // ============================================================================
291 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
292  const Gaudi::Matrix1x6& data ) {
293  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
294  return tuple->matrix( name, data );
295 }
296 // ============================================================================
297 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
298  const Gaudi::Matrix4x3& data ) {
299  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
300  return tuple->matrix( name, data );
301 }
302 // ============================================================================
303 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
304  const Gaudi::Matrix3x4& data ) {
305  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
306  return tuple->matrix( name, data );
307 }
308 // ============================================================================
309 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
310  const Gaudi::Matrix3x5& data ) {
311  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
312  return tuple->matrix( name, data );
313 }
314 // ============================================================================
315 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
316  const Gaudi::Matrix3x6& data ) {
317  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
318  return tuple->matrix( name, data );
319 }
320 // ============================================================================
321 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
322  const Gaudi::Matrix2x3& data ) {
323  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
324  return tuple->matrix( name, data );
325 }
326 // ============================================================================
327 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
328  const Gaudi::Matrix3x2& data ) {
329  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
330  return tuple->matrix( name, data );
331 }
332 // ============================================================================
333 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
334  const Gaudi::SymMatrix1x1& data ) {
335  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
336  return tuple->matrix( name, data );
337 }
338 // ============================================================================
339 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
340  const Gaudi::SymMatrix2x2& data ) {
341  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
342  return tuple->matrix( name, data );
343 }
344 // ============================================================================
345 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
346  const Gaudi::SymMatrix3x3& data ) {
347  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
348  return tuple->matrix( name, data );
349 }
350 // ============================================================================
351 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
352  const Gaudi::SymMatrix4x4& data ) {
353  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
354  return tuple->matrix( name, data );
355 }
356 // ============================================================================
357 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
358  const Gaudi::SymMatrix5x5& data ) {
359  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
360  return tuple->matrix( name, data );
361 }
362 // ============================================================================
363 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
364  const Gaudi::SymMatrix6x6& data ) {
365  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
366  return tuple->matrix( name, data );
367 }
368 // ============================================================================
369 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
370  const Gaudi::SymMatrix7x7& data ) {
371  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
372  return tuple->matrix( name, data );
373 }
374 // ============================================================================
375 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
376  const Gaudi::SymMatrix8x8& data ) {
377  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
378  return tuple->matrix( name, data );
379 }
380 // ============================================================================
381 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
382  const Gaudi::SymMatrix9x9& data ) {
383  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
384  return tuple->matrix( name, data );
385 }
386 // ============================================================================
387 // advanced column: time
388 // ============================================================================
389 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const Gaudi::Time& value ) {
390  return column( tuple, "", value );
391 }
392 // ============================================================================
393 // advanced column: time
394 // ============================================================================
395 StatusCode GaudiPython::TupleDecorator::column( const Tuples::Tuple& tuple, const std::string& name,
396  const Gaudi::Time& value ) {
397  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
398  StatusCode sc = StatusCode::SUCCESS;
399  //
400  sc = tuple->column( name + "year", value.year( true ), 1970, 2070 );
401  if ( sc.isFailure() ) { return sc; }
402  sc = tuple->column( name + "month", value.month( true ) + 1, 1, 16 );
403  if ( sc.isFailure() ) { return sc; }
404  sc = tuple->column( name + "day", value.day( true ), 0, 32 );
405  if ( sc.isFailure() ) { return sc; }
406  sc = tuple->column( name + "hour", value.hour( true ), 0, 25 );
407  if ( sc.isFailure() ) { return sc; }
408  sc = tuple->column( name + "minute", value.minute( true ), 0, 61 );
409  if ( sc.isFailure() ) { return sc; }
410  sc = tuple->column( name + "second", value.second( true ), 0, 61 );
411  if ( sc.isFailure() ) { return sc; }
412  sc = tuple->column( name + "nsecond", value.nsecond() );
413  //
414  return sc;
415 }
416 // ============================================================================
417 
418 // ============================================================================
419 // Legacy:
420 // ============================================================================
421 StatusCode GaudiPython::TupleDecorator::array( const Tuples::Tuple& tuple, const std::string& name,
422  const CLHEP::HepVector& data ) {
423  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
424  return tuple->array( name, data, data.num_row() );
425 }
426 // ============================================================================
427 StatusCode GaudiPython::TupleDecorator::farray( const Tuples::Tuple& tuple, const std::string& name,
428  const CLHEP::HepVector& data, const std::string& length,
429  const size_t maxv ) {
430  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
431  // use the trick!
432  const double* begin = &( data[0] );
433  const double* end = begin + data.num_row();
434  return tuple->farray( name, begin, end, length, maxv );
435 }
436 // ============================================================================
437 StatusCode GaudiPython::TupleDecorator::matrix( const Tuples::Tuple& tuple, const std::string& name,
438  const CLHEP::HepGenMatrix& data ) {
439  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
440  if ( 1 > data.num_col() ) { return tuple->Error( "GP:matrix(2): illegal fixed matrix num_col" ); }
441  if ( 1 > data.num_row() ) { return tuple->Error( "GP:matrix(2): illegal fixed matrix num_row" ); }
442  return tuple->matrix( name, data, data.num_row(), data.num_col() );
443 }
444 // ============================================================================
445 StatusCode GaudiPython::TupleDecorator::fmatrix( const Tuples::Tuple& tuple, const std::string& name,
446  const CLHEP::HepGenMatrix& data,
447  const Tuples::TupleObj::MIndex cols, // fixed !!!
448  const std::string& length, const size_t maxv ) {
449  if ( !tuple.valid() ) { return StatusCode::FAILURE; }
450  if ( cols != data.num_col() ) { return tuple->Error( "GP:fmatrix(2): mismatch in matrix dimensions!" ); }
451  return tuple->fmatrix( name, data, data.num_row(), cols, length, maxv );
452 }
453 // ============================================================================
454 
455 // ============================================================================
456 // Tuple-Alg-decorator
457 // ============================================================================
458 Tuples::Tuple GaudiPython::TupleAlgDecorator::nTuple( const GaudiTupleAlg& algo, const std::string& title,
459  const CLID& clid ) {
460  return algo.nTuple( title, clid );
461 }
462 // ============================================================================
463 Tuples::Tuple GaudiPython::TupleAlgDecorator::nTuple( const GaudiTupleAlg& algo, const GaudiAlg::TupleID& ID,
464  const std::string& title, const CLID& clid ) {
465  return algo.nTuple( ID, title, clid );
466 }
467 // ============================================================================
468 Tuples::Tuple GaudiPython::TupleAlgDecorator::nTuple( const GaudiTupleAlg& algo, const int ID, const std::string& title,
469  const CLID& clid ) {
470  return algo.nTuple( ID, title, clid );
471 }
472 // ============================================================================
473 Tuples::Tuple GaudiPython::TupleAlgDecorator::nTuple( const GaudiTupleAlg& algo, const std::string& ID,
474  const std::string& title, const CLID& clid ) {
475  return algo.nTuple( ID, title, clid );
476 }
477 // ============================================================================
478 Tuples::Tuple GaudiPython::TupleAlgDecorator::evtCol( const GaudiTupleAlg& algo, const std::string& title,
479  const CLID& clid ) {
480  return algo.evtCol( title, clid );
481 }
482 // ============================================================================
483 Tuples::Tuple GaudiPython::TupleAlgDecorator::evtCol( const GaudiTupleAlg& algo, const GaudiAlg::TupleID& ID,
484  const std::string& title, const CLID& clid ) {
485  return algo.evtCol( ID, title, clid );
486 }
487 // ============================================================================
488 Tuples::Tuple GaudiPython::TupleAlgDecorator::evtCol( const GaudiTupleAlg& algo, const int ID, const std::string& title,
489  const CLID& clid ) {
490  return algo.evtCol( ID, title, clid );
491 }
492 // ============================================================================
493 Tuples::Tuple GaudiPython::TupleAlgDecorator::evtCol( const GaudiTupleAlg& algo, const std::string& ID,
494  const std::string& title, const CLID& clid ) {
495  return algo.evtCol( ID, title, clid );
496 }
497 // ============================================================================
498 // The END
499 // ============================================================================
Gaudi::Matrix4x3
ROOT::Math::SMatrix< double, 4, 3 > Matrix4x3
Generic 4x3 matrix (double)
Definition: GenericMatrixTypes.h:58
GaudiPython::TupleDecorator::nTuple
static INTuple * nTuple(const Tuples::Tuple &tuple)
accessors to internal
Definition: TupleDecorator.cpp:57
Tuple.h
Gaudi::Vector5
ROOT::Math::SVector< double, 5 > Vector5
5D Vector (double)
Definition: GenericVectorTypes.h:43
Gaudi::Matrix7x7
ROOT::Math::SMatrix< double, 7, 7 > Matrix7x7
Generic 7x7 matrix (double)
Definition: GenericMatrixTypes.h:45
std::string
STL class.
Gaudi::Matrix5x5
ROOT::Math::SMatrix< double, 5, 5 > Matrix5x5
Generic 5x5 matrix (double)
Definition: GenericMatrixTypes.h:43
GaudiAlg::ID
Definition: GaudiHistoID.h:53
Gaudi::Time::year
int year(bool local) const
Get the year.
Definition: Time.cpp:176
Tuples::TupleObj::column
StatusCode column(std::string_view name, float value)
Set the value for selected tuple column.
Definition: TupleObj.cpp:267
bug_34121.name
name
Definition: bug_34121.py:20
Tuples::TupleObj::tuple
const NTuple::Tuple * tuple() const
provide the access to underlying Gaudi N-tuple
Definition: TupleObj.h:1862
Tuples::TupleObj::matrix
StatusCode matrix(std::string_view name, const MATRIX &data, const MIndex &rows, const MIndex &cols)
fill N-Tuple with fixed-size matrix
Definition: TupleObj.h:1699
Gaudi::SymMatrix1x1
ROOT::Math::SMatrix< double, 1, 1, ROOT::Math::MatRepSym< double, 1 > > SymMatrix1x1
Symmetrix 1x1 matrix (double)
Definition: SymmetricMatrixTypes.h:37
Tuples::TupleObj::Error
virtual StatusCode Error(const std::string &msg, const StatusCode sc=StatusCode::FAILURE) const =0
Gaudi::Time::second
int second(bool local) const
Get the seconds, numbered [0,61] (allowing one or two leap seconds, years with leap seconds can have ...
Definition: Time.cpp:193
IOpaqueAddress
Definition: IOpaqueAddress.h:33
Gaudi::XYZVector
ROOT::Math::XYZVector XYZVector
Cartesian 3D vector (double)
Definition: Vector3DTypes.h:39
Gaudi::Matrix1x5
ROOT::Math::SMatrix< double, 1, 5 > Matrix1x5
Generic 1x5 matrix (double)
Definition: GenericMatrixTypes.h:50
std::vector< double >
GaudiPython::TupleDecorator::matrix
static StatusCode matrix(const Tuples::Tuple &tuple, const std::string &name, const GaudiPython::Matrix &data, const Tuples::TupleObj::MIndex cols)
Advanced columns: fixed size matrices.
Definition: TupleDecorator.cpp:215
std::vector::size
T size(T... args)
GaudiUtils::VectorMap
Definition: VectorMap.h:112
Gaudi::SymMatrix5x5
ROOT::Math::SMatrix< double, 5, 5, ROOT::Math::MatRepSym< double, 5 > > SymMatrix5x5
Symmetrix 5x5 matrix (double)
Definition: SymmetricMatrixTypes.h:45
GaudiTupleAlg
Definition: GaudiTupleAlg.h:51
Gaudi::Matrix3x2
ROOT::Math::SMatrix< double, 3, 2 > Matrix3x2
Generic 3x2 matrix (double)
Definition: GenericMatrixTypes.h:54
Gaudi::Matrix1x3
ROOT::Math::SMatrix< double, 1, 3 > Matrix1x3
Generic 1x3 matrix (double)
Definition: GenericMatrixTypes.h:49
Gaudi::Vector9
ROOT::Math::SVector< double, 9 > Vector9
9D Vector (double)
Definition: GenericVectorTypes.h:47
Tuples::TupleObj::array
StatusCode array(std::string_view name, DATA first, DATA last)
fill N-Tuple with fixed-size array
Definition: TupleObj.h:1544
GaudiAlg.Algs.column
column
Definition: Algs.py:1212
GaudiPython::TupleDecorator::farray
static StatusCode farray(const Tuples::Tuple &tuple, const std::string &name, const std::vector< double > &data, const std::string &length, const size_t maxv)
Advanced columns: floating-size arrays.
Definition: TupleDecorator.cpp:129
Gaudi::SymMatrix4x4
ROOT::Math::SMatrix< double, 4, 4, ROOT::Math::MatRepSym< double, 4 > > SymMatrix4x4
Symmetrix 4x4 matrix (double)
Definition: SymmetricMatrixTypes.h:43
std::vector::front
T front(T... args)
Gaudi::Matrix3x4
ROOT::Math::SMatrix< double, 3, 4 > Matrix3x4
Generic 3x4 matrix (double)
Definition: GenericMatrixTypes.h:55
Gaudi::Time
Definition: Time.h:241
GaudiPython::TupleDecorator::fmatrix
static StatusCode fmatrix(const Tuples::Tuple &tuple, const std::string &name, const GaudiPython::Matrix &data, const Tuples::TupleObj::MIndex cols, const std::string &length, const size_t maxv)
Advanced columns: floating-size matrices.
Definition: TupleDecorator.cpp:136
Gaudi::Matrix2x3
ROOT::Math::SMatrix< double, 2, 3 > Matrix2x3
Generic 2x3 matrix (double)
Definition: GenericMatrixTypes.h:52
Vector.h
Gaudi::Vector2
ROOT::Math::SVector< double, 2 > Vector2
2D Vector (double)
Definition: GenericVectorTypes.h:40
Gaudi::Time::minute
int minute(bool local) const
Get the minute, numbered [0, 59].
Definition: Time.cpp:188
StatusCode
Definition: StatusCode.h:65
Gaudi::Matrix8x8
ROOT::Math::SMatrix< double, 8, 8 > Matrix8x8
Generic 8x8 matrix (double)
Definition: GenericMatrixTypes.h:46
Gaudi::Vector1
ROOT::Math::SVector< double, 1 > Vector1
1D Vector (double)
Definition: GenericVectorTypes.h:39
CLHEP::begin
double * begin(CLHEP::HepVector &v)
Definition: TupleAlg.cpp:45
TupleObj.h
Gaudi::Matrix3x5
ROOT::Math::SMatrix< double, 3, 5 > Matrix3x5
Generic 3x5 matrix (double)
Definition: GenericMatrixTypes.h:56
GaudiPython::TupleDecorator::ntuple
static NTuple::Tuple * ntuple(const Tuples::Tuple &tuple)
accessors to internal
Definition: TupleDecorator.cpp:62
Tuples::TupleObj::fmatrix
StatusCode fmatrix(std::string_view name, const MATRIX &data, size_t rows, const MIndex &cols, std::string_view length, size_t maxv)
Fill N-Tuple with data from variable-size matrix.
Definition: TupleObj.h:1303
Gaudi::Time::hour
int hour(bool local) const
Get the hour, numbered [0, 23].
Definition: Time.cpp:185
Gaudi::Matrix4x4
ROOT::Math::SMatrix< double, 4, 4 > Matrix4x4
Generic 4x4 matrix (double)
Definition: GenericMatrixTypes.h:42
Tuples::Tuple
A simple wrapper class over standard Gaudi NTuple::Tuple facility.
Definition: Tuple.h:126
GaudiPython::TupleAlgDecorator::evtCol
static Tuples::Tuple evtCol(const GaudiTupleAlg &algo, const std::string &title, const CLID &clid=CLID_ColumnWiseTuple)
get n-tuple (book-on-demand)
Definition: TupleDecorator.cpp:478
INTuple
Definition: INTuple.h:91
Gaudi::Vector6
ROOT::Math::SVector< double, 6 > Vector6
6D Vector (double)
Definition: GenericVectorTypes.h:44
GaudiTuples::evtCol
Tuple evtCol(const std::string &title, const CLID &clid=CLID_ColumnWiseTuple) const
Access an Event Tag Collection object (book on-demand) with unique identifier.
Definition: GaudiTuples.icpp:134
Gaudi::Matrix1x6
ROOT::Math::SMatrix< double, 1, 6 > Matrix1x6
Generic 1x6 matrix (double)
Definition: GenericMatrixTypes.h:51
CLID
unsigned int CLID
Class ID definition.
Definition: ClassID.h:18
Gaudi::SymMatrix2x2
ROOT::Math::SMatrix< double, 2, 2, ROOT::Math::MatRepSym< double, 2 > > SymMatrix2x2
Symmetrix 2x2 matrix (double)
Definition: SymmetricMatrixTypes.h:39
GaudiPython::TupleDecorator::write
static StatusCode write(const Tuples::Tuple &tuple)
commit the row
Definition: TupleDecorator.cpp:69
Gaudi::SymMatrix8x8
ROOT::Math::SMatrix< double, 8, 8, ROOT::Math::MatRepSym< double, 8 > > SymMatrix8x8
Symmetrix 8x8 matrix (double)
Definition: SymmetricMatrixTypes.h:51
CLHEP
Definition: TupleDecorator.h:29
TupleDecorator.h
Gaudi::SymMatrix9x9
ROOT::Math::SMatrix< double, 9, 9, ROOT::Math::MatRepSym< double, 9 > > SymMatrix9x9
Symmetrix 9x9 matrix (double)
Definition: SymmetricMatrixTypes.h:53
StatusCode::isFailure
bool isFailure() const
Definition: StatusCode.h:129
GaudiPython::TupleDecorator::column_ll
static StatusCode column_ll(const Tuples::Tuple &tuple, const std::string &name, const long long value)
more or less simple columns: long long
Definition: TupleDecorator.cpp:89
Gaudi::Vector7
ROOT::Math::SVector< double, 7 > Vector7
7D Vector (double)
Definition: GenericVectorTypes.h:45
Tuples::TupleObj::Warning
virtual StatusCode Warning(const std::string &msg, const StatusCode sc=StatusCode::FAILURE) const =0
Tuples::Tuple::valid
bool valid() const
check the validity of the tuple object
Definition: Tuple.h:142
StatusCode::SUCCESS
constexpr static const auto SUCCESS
Definition: StatusCode.h:100
GaudiPython::TupleDecorator::column_ull
static StatusCode column_ull(const Tuples::Tuple &tuple, const std::string &name, const unsigned long long value)
more or less simple columns: unsigned long long
Definition: TupleDecorator.cpp:94
NTuple::Tuple
Abstract base class which allows the user to interact with the actual N tuple implementation.
Definition: NTuple.h:387
GaudiPython::TupleDecorator::valid
static bool valid(const Tuples::Tuple &tuple)
status of the tuple
Definition: TupleDecorator.cpp:67
std::vector::begin
T begin(T... args)
GaudiTuples::nTuple
Tuple nTuple(const std::string &title, const CLID &clid=CLID_ColumnWiseTuple) const
Access an N-Tuple object (book on-demand) with unique identifier.
Definition: GaudiTuples.icpp:101
Gaudi::Vector3
ROOT::Math::SVector< double, 3 > Vector3
3D Vector (double)
Definition: GenericVectorTypes.h:41
Tuples::TupleObj::MIndex
unsigned short MIndex
Definition: TupleObj.h:231
Gaudi::SymMatrix3x3
ROOT::Math::SMatrix< double, 3, 3, ROOT::Math::MatRepSym< double, 3 > > SymMatrix3x3
Symmetrix 3x3 matrix (double)
Definition: SymmetricMatrixTypes.h:41
Gaudi::Matrix2x2
ROOT::Math::SMatrix< double, 2, 2 > Matrix2x2
Generic 2x2 matrix (double)
Definition: GenericMatrixTypes.h:40
Gaudi::SymMatrix7x7
ROOT::Math::SMatrix< double, 7, 7, ROOT::Math::MatRepSym< double, 7 > > SymMatrix7x7
Symmetrix 7x7 matrix (double)
Definition: SymmetricMatrixTypes.h:49
Gaudi::Matrix9x9
ROOT::Math::SMatrix< double, 9, 9 > Matrix9x9
Generic 9x9 matrix (double)
Definition: GenericMatrixTypes.h:47
Gaudi::Vector4
ROOT::Math::SVector< double, 4 > Vector4
4D Vector (double)
Definition: GenericVectorTypes.h:42
Gaudi::Matrix3x3
ROOT::Math::SMatrix< double, 3, 3 > Matrix3x3
Generic 3x3 matrix (double)
Definition: GenericMatrixTypes.h:41
std::vector::empty
T empty(T... args)
Gaudi::Time::month
int month(bool local) const
Get the month, numbered [0,11].
Definition: Time.cpp:179
Tuples::TupleObj::write
StatusCode write()
write a record to NTuple
Definition: TupleObj.cpp:245
Properties.v
v
Definition: Properties.py:122
Gaudi::Matrix1x1
ROOT::Math::SMatrix< double, 1, 1 > Matrix1x1
Generic 1x1 matrix (double)
Definition: GenericMatrixTypes.h:39
Tuples::TupleObj::farray
StatusCode farray(std::string_view name, ITERATOR1 &&first, ITERATOR2 &&last, std::string_view length, size_t maxv)
Add an indexed array (of type float) to N-tuple.
Definition: TupleObj.h:886
std::vector::end
T end(T... args)
Gaudi::Time::nsecond
int nsecond() const
Get the nanoseconds.
Definition: Time.cpp:198
Gaudi::Time::day
int day(bool local) const
Get the day of month, numbered [1,31].
Definition: Time.cpp:182
IOTest.end
end
Definition: IOTest.py:123
Gaudi::Matrix3x6
ROOT::Math::SMatrix< double, 3, 6 > Matrix3x6
Generic 3x6 matrix (double)
Definition: GenericMatrixTypes.h:57
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:101
GaudiPython::TupleDecorator::column
static StatusCode column(const Tuples::Tuple &tuple, const std::string &name, const int value)
more or less simple columns: long
Definition: TupleDecorator.cpp:74
Gaudi::LorentzVector
ROOT::Math::PxPyPzEVector LorentzVector
Cartesian 4 Vector.
Definition: Vector4DTypes.h:40
GaudiPython::TupleAlgDecorator::nTuple
static Tuples::Tuple nTuple(const GaudiTupleAlg &algo, const std::string &title, const CLID &clid=CLID_ColumnWiseTuple)
get n-tuple (book-on-demand)
Definition: TupleDecorator.cpp:458
Gaudi::SymMatrix6x6
ROOT::Math::SMatrix< double, 6, 6, ROOT::Math::MatRepSym< double, 6 > > SymMatrix6x6
Symmetrix 6x6 matrix (double)
Definition: SymmetricMatrixTypes.h:47
Gaudi::Matrix6x6
ROOT::Math::SMatrix< double, 6, 6 > Matrix6x6
Generic 6x6 matrix (double)
Definition: GenericMatrixTypes.h:44
GaudiPython::TupleDecorator::array
static StatusCode array(const Tuples::Tuple &tuple, const std::string &name, const std::vector< double > &data)
Advanced columns: fixed size arrays.
Definition: TupleDecorator.cpp:154
Gaudi::Vector8
ROOT::Math::SVector< double, 8 > Vector8
8D Vector (double)
Definition: GenericVectorTypes.h:46
Gaudi::XYZPoint
ROOT::Math::XYZPoint XYZPoint
3D cartesian point (double)
Definition: Point3DTypes.h:39