dc/dad/_tuple_decorator_8h_source.html

 #ifndef GAUDIPYTHON_TUPLEDECORATOR_H
 #define GAUDIPYTHON_TUPLEDECORATOR_H 1
 // ============================================================================
 // Include files
 // ============================================================================
 #include "GaudiKernel/Point3DTypes.h"
 #include "GaudiKernel/Vector3DTypes.h"
 #include "GaudiKernel/Point4DTypes.h"
 #include "GaudiKernel/Vector4DTypes.h"
 #include "GaudiKernel/SymmetricMatrixTypes.h"
 #include "GaudiKernel/GenericMatrixTypes.h"
 #include "GaudiKernel/GenericVectorTypes.h"
 #include "GaudiKernel/Time.h"
 // ============================================================================
 // GaudiAlg
 // ============================================================================
 #include "GaudiAlg/TupleID.h"
 #include "GaudiAlg/TupleObj.h"
 #include "GaudiAlg/Tuple.h"
 #include "GaudiAlg/Tuples.h"
 #include "GaudiAlg/ITupleTool.h"
 #include "GaudiAlg/GaudiTupleAlg.h"
 // ============================================================================
 // GaudiPython
 // ============================================================================
 #include "GaudiPython/GaudiPython.h"
 #include "GaudiPython/Vector.h"
 // ============================================================================
 // Forward declarations
 // ============================================================================
 namespace CLHEP
 {
   class HepGenMatrix ;
   class HepVector    ;
 }
 // ============================================================================
 namespace GaudiPython
 {
   // ==========================================================================
   class GAUDI_API TupleDecorator
   {
   public:
     // ========================================================================
     static INTuple*         nTuple ( const Tuples::Tuple&  tuple ) ;
     // ========================================================================
     static NTuple::Tuple*   ntuple ( const Tuples::Tuple&  tuple ) ;
     // ========================================================================
     static bool             valid  ( const Tuples::Tuple&  tuple ) ;
     // ========================================================================
     static StatusCode       write  ( const Tuples::Tuple&  tuple ) ;
     // ========================================================================
   public: // primitives
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple& tuple ,
       const std::string&   name  ,
       const int            value ) ;
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple& tuple ,
       const std::string&   name  ,
       const int            value ,
       const int            minv  ,
       const int            maxv  ) ;
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple& tuple ,
       const std::string&   name  ,
       const double         value ) ;
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple& tuple ,
       const std::string&   name  ,
       const bool           value ) ;
     // ========================================================================
     static StatusCode column_ll
     ( const Tuples::Tuple&     tuple ,
       const std::string&       name  ,
       const long long          value ) ;
     // ========================================================================
     static StatusCode column_ull
     ( const Tuples::Tuple&     tuple ,
       const std::string&       name  ,
       const unsigned long long value ) ;
     // ========================================================================
   public:  // event tag collections
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple&  tuple ,
       const std::string&    name  ,
       IOpaqueAddress*       value ) ;
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple&  tuple ,
       IOpaqueAddress*       value ) ;
     // ========================================================================
   public: // 4D kinematics
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple&             tuple ,
       const std::string&               name  ,
       const Gaudi::LorentzVector&      value ) ;
     // ========================================================================
   public: // 3D geometry
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple&             tuple ,
       const std::string&               name  ,
       const Gaudi::XYZVector&          value ) ;
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::XYZPoint&          value ) ;
     // ========================================================================
   public:   // floating size arrays
     // ========================================================================
     static StatusCode farray
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const std::vector<double>&      data   ,
       const std::string&              length ,
       const size_t                    maxv   ) ;
     // ========================================================================
   public:   // floating-size matrices
     // ========================================================================
     static StatusCode fmatrix
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const GaudiPython::Matrix&      data   ,
       const Tuples::TupleObj::MIndex  cols   , // fixed !!!
       const std::string&              length ,
       const size_t                    maxv   ) ;
     // ========================================================================
     static StatusCode fmatrix
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const GaudiUtils::VectorMap<int,double>& info   ,
       const std::string&              length ,
       const size_t                    maxv   ) ;
     // ========================================================================
   public:   // fixed size arrays
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const std::vector<double>&      data   ) ;
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const Gaudi::Vector1&           data   ) ;
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const Gaudi::Vector2&           data   ) ;
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const Gaudi::Vector3&           data   ) ;
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const Gaudi::Vector4&           data   ) ;
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const Gaudi::Vector5&           data   ) ;
     // ========================================================================
   public:   // fixed size matrices
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const Gaudi::Vector6&           data   ) ;
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const Gaudi::Vector7&           data   ) ;
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const Gaudi::Vector8&           data   ) ;
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const Gaudi::Vector9&           data   ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const GaudiPython::Matrix&      data  ,
       const Tuples::TupleObj::MIndex  cols  ) ; // fixed !!!
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix2x2&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix3x3&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix4x4&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix5x5&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix6x6&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix7x7&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix8x8&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix9x9&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix1x1&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix1x3&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix1x5&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix1x6&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix4x3&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix3x4&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix3x5&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix3x6&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix2x3&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Matrix3x2&         value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::SymMatrix1x1&      value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::SymMatrix2x2&      value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::SymMatrix3x3&      value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::SymMatrix4x4&      value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::SymMatrix5x5&      value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::SymMatrix6x6&      value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::SymMatrix7x7&      value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::SymMatrix8x8&      value ) ;
     // ========================================================================
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::SymMatrix9x9&      value ) ;
     // ========================================================================
   public:   // some auxillary  objects
     // ========================================================================
     static StatusCode column
     ( const Tuples::Tuple&            tuple ,
       const std::string&              name  ,
       const Gaudi::Time&              value ) ;
     static StatusCode column
     ( const Tuples::Tuple&            tuple ,
       const Gaudi::Time&              value ) ;
     // ========================================================================
   public:   // CLHEP: should we keep it ?
     // ========================================================================
     static StatusCode array
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const CLHEP::HepVector&         data   ) ;
     static StatusCode farray
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const CLHEP::HepVector&         data   ,
       const std::string&              length ,
       const size_t                    maxv   ) ;
     static StatusCode matrix
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const CLHEP::HepGenMatrix&      data   ) ;
     static StatusCode fmatrix
     ( const Tuples::Tuple&            tuple  ,
       const std::string&              name   ,
       const CLHEP::HepGenMatrix&      data   ,
       const Tuples::TupleObj::MIndex  cols   , // fixed !!!
       const std::string&              length ,
       const size_t                    maxv   ) ;
     // ========================================================================
   } ;
   // ==========================================================================
   class GAUDI_API TupleAlgDecorator
   {
   public:
     // ========================================================================
     static Tuples::Tuple       nTuple
     ( const GaudiTupleAlg&     algo                         ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple ) ;
     // ========================================================================
     static Tuples::Tuple       nTuple
     ( const GaudiTupleAlg&     algo                         ,
       const GaudiAlg::TupleID& ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple ) ;
     // ========================================================================
     static Tuples::Tuple       nTuple
     ( const GaudiTupleAlg&     algo                         ,
       const int                ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple ) ;
     // ========================================================================
     static Tuples::Tuple       nTuple
     ( const GaudiTupleAlg&     algo                         ,
       const std::string&       ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple ) ;
     // ========================================================================
     static Tuples::Tuple       evtCol
     ( const GaudiTupleAlg&     algo                         ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple ) ;
     // ========================================================================
     static Tuples::Tuple       evtCol
     ( const GaudiTupleAlg&     algo                         ,
       const GaudiAlg::TupleID& ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple ) ;
     // ========================================================================
     static Tuples::Tuple       evtCol
     ( const GaudiTupleAlg&     algo                         ,
       const int                ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple ) ;
     // ========================================================================
     static Tuples::Tuple       evtCol
     ( const GaudiTupleAlg&     algo                         ,
       const std::string&       ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple ) ;
     // ========================================================================
   } ;
   // ==========================================================================
   class GAUDI_API TupleToolDecorator
   {
   public:
     // ========================================================================
     static Tuples::Tuple       nTuple
     ( const ITupleTool&        tool                         ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple )
     { return tool.nTuple ( title , clid ) ; }
     // ========================================================================
     static Tuples::Tuple       nTuple
     ( const ITupleTool&        tool                         ,
       const GaudiAlg::TupleID& ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple )
     { return tool.nTuple ( ID , title , clid ) ; }
     // ========================================================================
     static Tuples::Tuple       nTuple
     ( const ITupleTool&        tool                         ,
       const int                ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple )
     { return tool.nTuple ( ID , title , clid ) ; }
     // ========================================================================
     static Tuples::Tuple       nTuple
     ( const ITupleTool&        tool                         ,
       const std::string&       ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple )
     { return tool.nTuple ( ID , title , clid ) ; }
     // ========================================================================
     static Tuples::Tuple       evtCol
     ( const ITupleTool&        tool                         ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple )
     { return tool.evtCol ( title , clid ) ; }
     // ========================================================================
     static Tuples::Tuple       evtCol
     ( const ITupleTool&        tool                         ,
       const GaudiAlg::TupleID& ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple )
     { return tool.nTuple ( ID , title , clid ) ; }
     // ========================================================================
     static Tuples::Tuple       evtCol
     ( const ITupleTool&        tool                         ,
       const int                ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple )
     { return tool.nTuple ( ID , title , clid ) ; }
     // ========================================================================
     static Tuples::Tuple       evtCol
     ( const ITupleTool&        tool                         ,
       const std::string&       ID                           ,
       const std::string&       title                        ,
       const CLID&              clid  = CLID_ColumnWiseTuple )
     { return tool.nTuple ( ID , title , clid ) ; }
     // ========================================================================
   } ;
   // ==========================================================================
 } // end of namespace GaudiPython
 // ============================================================================
 // The END
 // ============================================================================
 #endif // GAUDIPYTHON_TUPLEDECORATOR_H
 // ============================================================================
Gaudi::Matrix8x8
ROOT::Math::SMatrix< double, 8, 8 > Matrix8x8
Generic 8x8 matrix (double)
Definition: GenericMatrixTypes.h:37

Gaudi::Matrix4x4
ROOT::Math::SMatrix< double, 4, 4 > Matrix4x4
Generic 4x4 matrix (double)
Definition: GenericMatrixTypes.h:33

GaudiUtils::VectorMap
A bit modified version of &#39;Loki::AssocVector&#39; associative vector from Loki library by Andrei Alexandr...
Definition: VectorMap.h:108

GaudiPython::TupleDecorator
Simple class which performs the decoration of the standard N-Tuple.
Definition: TupleDecorator.h:46

Gaudi::SymMatrix8x8
ROOT::Math::SMatrix< double, 8, 8, ROOT::Math::MatRepSym< double, 8 > > SymMatrix8x8
Symmetrix 8x8 matrix (double)
Definition: SymmetricMatrixTypes.h:43

GaudiPython.GaudiAlgs.ntuple
ntuple
Definition: GaudiAlgs.py:1142

Gaudi::Matrix3x5
ROOT::Math::SMatrix< double, 3, 5 > Matrix3x5
Generic 3x5 matrix (double)
Definition: GenericMatrixTypes.h:45

Gaudi::SymMatrix5x5
ROOT::Math::SMatrix< double, 5, 5, ROOT::Math::MatRepSym< double, 5 > > SymMatrix5x5
Symmetrix 5x5 matrix (double)
Definition: SymmetricMatrixTypes.h:37

GenericMatrixTypes.h
Generic matrix typedefs.

Vector.h

GaudiPython::TupleAlgDecorator
Simple class to perform the "decoration" of Tuples in Python/ROOT.
Definition: TupleDecorator.h:446

gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28

Gaudi::Vector7
ROOT::Math::SVector< double, 7 > Vector7
7D Vector (double)
Definition: GenericVectorTypes.h:36

GaudiTupleAlg
Simple class to extend the functionality of class GaudiHistoAlg.
Definition: GaudiTupleAlg.h:41

TupleObj.h
Header file for class TupleObj.

Vector4DTypes.h
4 vector typedefs

Gaudi::SymMatrix3x3
ROOT::Math::SMatrix< double, 3, 3, ROOT::Math::MatRepSym< double, 3 > > SymMatrix3x3
Symmetrix 3x3 matrix (double)
Definition: SymmetricMatrixTypes.h:33

GaudiPython.GaudiAlgs.fmatrix
fmatrix
Definition: GaudiAlgs.py:1151

GenericVectorTypes.h
General vectors.

Gaudi::SymMatrix2x2
ROOT::Math::SMatrix< double, 2, 2, ROOT::Math::MatRepSym< double, 2 > > SymMatrix2x2
Symmetrix 2x2 matrix (double)
Definition: SymmetricMatrixTypes.h:31

ITupleTool::nTuple
virtual Tuple nTuple(const std::string &title, const CLID &clid=CLID_ColumnWiseTuple) const  =0
get N-tuple object ( book on-demand ) with unique identifier

Gaudi::Matrix9x9
ROOT::Math::SMatrix< double, 9, 9 > Matrix9x9
Generic 9x9 matrix (double)
Definition: GenericMatrixTypes.h:38

Gaudi::Vector3
ROOT::Math::SVector< double, 3 > Vector3
3D Vector (double)
Definition: GenericVectorTypes.h:32

GaudiPython::TupleToolDecorator
Simple class to perform the "decoration" of Tuples in Python/ROOT.
Definition: TupleDecorator.h:511

Gaudi::Matrix3x3
ROOT::Math::SMatrix< double, 3, 3 > Matrix3x3
Generic 3x3 matrix (double)
Definition: GenericMatrixTypes.h:32

Tuples::TupleObj::MIndex
unsigned short MIndex
Definition: TupleObj.h:243

Gaudi::Matrix3x2
ROOT::Math::SMatrix< double, 3, 2 > Matrix3x2
Generic 3x2 matrix (double)
Definition: GenericMatrixTypes.h:48

ROOT::Math::PositionVector3D
Definition: IMagneticFieldSvc.h:16

Gaudi::Vector9
ROOT::Math::SVector< double, 9 > Vector9
9D Vector (double)
Definition: GenericVectorTypes.h:38

Gaudi::Vector2
ROOT::Math::SVector< double, 2 > Vector2
2D Vector (double)
Definition: GenericVectorTypes.h:31

Gaudi::Vector8
ROOT::Math::SVector< double, 8 > Vector8
8D Vector (double)
Definition: GenericVectorTypes.h:37

Gaudi::SymMatrix7x7
ROOT::Math::SMatrix< double, 7, 7, ROOT::Math::MatRepSym< double, 7 > > SymMatrix7x7
Symmetrix 7x7 matrix (double)
Definition: SymmetricMatrixTypes.h:41

std::string
STL class.

GaudiPython.GaudiAlgs.farray
farray
Definition: GaudiAlgs.py:1150

Gaudi::Matrix1x1
ROOT::Math::SMatrix< double, 1, 1 > Matrix1x1
Generic 1x1 matrix (double)
Definition: GenericMatrixTypes.h:30

INTuple
NTuple interface class definition.
Definition: INTuple.h:79

Tuples::Tuple
A simple wrapper class over standard Gaudi NTuple::Tuple facility.
Definition: Tuple.h:116

SymmetricMatrixTypes.h
Symmetric Matrix typedefs.

Gaudi::Matrix3x6
ROOT::Math::SMatrix< double, 3, 6 > Matrix3x6
Generic 3x6 matrix (double)
Definition: GenericMatrixTypes.h:46

Gaudi::SymMatrix1x1
ROOT::Math::SMatrix< double, 1, 1, ROOT::Math::MatRepSym< double, 1 > > SymMatrix1x1
Symmetrix 1x1 matrix (double)
Definition: SymmetricMatrixTypes.h:29

Gaudi::Matrix4x3
ROOT::Math::SMatrix< double, 4, 3 > Matrix4x3
Generic 4x3 matrix (double)
Definition: GenericMatrixTypes.h:43

Point3DTypes.h
3D point typedefs

Gaudi::Matrix2x3
ROOT::Math::SMatrix< double, 2, 3 > Matrix2x3
Generic 2x3 matrix (double)
Definition: GenericMatrixTypes.h:47

Gaudi::Matrix1x6
ROOT::Math::SMatrix< double, 1, 6 > Matrix1x6
Generic 1x6 matrix (double)
Definition: GenericMatrixTypes.h:42

Gaudi::Matrix6x6
ROOT::Math::SMatrix< double, 6, 6 > Matrix6x6
Generic 6x6 matrix (double)
Definition: GenericMatrixTypes.h:35

Gaudi::Time
Based on seal::Time.
Definition: Time.h:213

StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26

Gaudi::Matrix5x5
ROOT::Math::SMatrix< double, 5, 5 > Matrix5x5
Generic 5x5 matrix (double)
Definition: GenericMatrixTypes.h:34

ITupleTool
Definition: ITupleTool.h:31

Gaudi::Matrix7x7
ROOT::Math::SMatrix< double, 7, 7 > Matrix7x7
Generic 7x7 matrix (double)
Definition: GenericMatrixTypes.h:36

GaudiPython.GaudiAlgs.column_ll
column_ll
Definition: GaudiAlgs.py:1146

CLID
unsigned int CLID
Class ID definition.
Definition: ClassID.h:8

Time.h

Gaudi::SymMatrix6x6
ROOT::Math::SMatrix< double, 6, 6, ROOT::Math::MatRepSym< double, 6 > > SymMatrix6x6
Symmetrix 6x6 matrix (double)
Definition: SymmetricMatrixTypes.h:39

GaudiPython.GaudiAlgs.nTuple
nTuple
Definition: GaudiAlgs.py:1141

ROOT::Math::DisplacementVector3D
Definition: IMagneticFieldSvc.h:18

GaudiPython.h

Gaudi::Vector6
ROOT::Math::SVector< double, 6 > Vector6
6D Vector (double)
Definition: GenericVectorTypes.h:35

GaudiPython.GaudiAlgs.matrix
matrix
Definition: GaudiAlgs.py:1149

GaudiPython
GaudiPython.h GaudiPython/GaudiPython.h.
Definition: AlgDecorators.h:37

NTuple::Tuple
Abstract base class which allows the user to interact with the actual N tuple implementation.
Definition: NTuple.h:370

ITupleTool::evtCol
virtual Tuple evtCol(const std::string &title, const CLID &clid=CLID_RowWiseTuple) const  =0

TupleID.h

GaudiPython.GaudiAlgs.column_ull
column_ull
Definition: GaudiAlgs.py:1147

Gaudi::Matrix1x5
ROOT::Math::SMatrix< double, 1, 5 > Matrix1x5
Generic 1x5 matrix (double)
Definition: GenericMatrixTypes.h:41

Gaudi::Matrix2x2
ROOT::Math::SMatrix< double, 2, 2 > Matrix2x2
Generic 2x2 matrix (double)
Definition: GenericMatrixTypes.h:31

Containers::array
struct GAUDI_API array
Parametrisation class for redirection array - like implementation.
Definition: KeyedObjectManager.h:27

GaudiTupleAlg.h

std::vector< double >

Vector3DTypes.h
3D vector typedefs

Gaudi::Vector4
ROOT::Math::SVector< double, 4 > Vector4
4D Vector (double)
Definition: GenericVectorTypes.h:33

CLHEP
Definition: IFuncMinimum.h:16

Gaudi::Matrix1x3
ROOT::Math::SMatrix< double, 1, 3 > Matrix1x3
Generic 1x3 matrix (double)
Definition: GenericMatrixTypes.h:40

GaudiPython.GaudiAlgs.write
write
Definition: GaudiAlgs.py:1144

Gaudi::SymMatrix9x9
ROOT::Math::SMatrix< double, 9, 9, ROOT::Math::MatRepSym< double, 9 > > SymMatrix9x9
Symmetrix 9x9 matrix (double)
Definition: SymmetricMatrixTypes.h:45

Tuples.h

GaudiPython.GaudiAlgs.valid
valid
Definition: GaudiAlgs.py:1143

Gaudi::LorentzVector
ROOT::Math::PxPyPzEVector LorentzVector
Cartesian 4 Vector.
Definition: Vector4DTypes.h:31

Gaudi::Matrix3x4
ROOT::Math::SMatrix< double, 3, 4 > Matrix3x4
Generic 3x4 matrix (double)
Definition: GenericMatrixTypes.h:44

Point4DTypes.h
4D point typedefs

IOpaqueAddress
Opaque address interface definition.
Definition: IOpaqueAddress.h:23

GAUDI_API
#define GAUDI_API
Definition: Kernel.h:107

ITupleTool.h

Gaudi::Vector5
ROOT::Math::SVector< double, 5 > Vector5
5D Vector (double)
Definition: GenericVectorTypes.h:34

GaudiAlg::ID
ID class for Histogram and Ntuples.
Definition: GaudiHistoID.h:44

Tuple.h
Header file for class : Tuple.

Gaudi::Vector1
ROOT::Math::SVector< double, 1 > Vector1
1D Vector (double)
Definition: GenericVectorTypes.h:30

Gaudi::SymMatrix4x4
ROOT::Math::SMatrix< double, 4, 4, ROOT::Math::MatRepSym< double, 4 > > SymMatrix4x4
Symmetrix 4x4 matrix (double)
Definition: SymmetricMatrixTypes.h:35

GaudiPython.GaudiAlgs.column
column
Definition: GaudiAlgs.py:1071