d0/d7c/_tuple_obj_8h_source.html

 // $Id: TupleObj.h,v 1.23 2008/10/27 19:22:20 marcocle Exp $

 // ============================================================================

 // CVS tag $Name:  $, version $Revision: 1.23 $

 // ============================================================================

 #ifndef GAUDIALG_TUPLEOBJ_H

 #define GAUDIALG_TUPLEOBJ_H 1

 // ============================================================================

 // Include files

 // ============================================================================

 // STD&STL

 // ============================================================================

 #include <set>

 #include <string>

 #include <limits>

 // ============================================================================

 // GaudiKernel

 // ============================================================================

 #include "GaudiKernel/NTuple.h"

 #include "GaudiKernel/VectorMap.h"

 // ============================================================================

 // GaudiAlg

 // ============================================================================

 #include "GaudiAlg/Tuples.h"

 #include "GaudiAlg/Maps.h"

 // ============================================================================

 // ROOT

 // ============================================================================

 #include "Math/Point3D.h"

 #include "Math/Vector3D.h"

 #include "Math/Vector4D.h"

 #include "Math/SVector.h"

 #include "Math/SMatrix.h"

 // ============================================================================

 // forward declaration

 // ============================================================================

 // GaudiKernel

 // ============================================================================

 class IOpaqueAddress   ;

 // ============================================================================

 // ============================================================================

 namespace Tuples

 {

   // ==========================================================================

   enum Type

     {

       NTUPLE  , // Analysis nTuple

       EVTCOL    // Event Collection

     };

   // ==========================================================================

   enum ErrorCodes

     {

       InvalidTuple      = 100 ,

       InvalidColumn           ,

       InvalidOperation        ,

       InvalidObject           ,

       InvalidItem             ,

       TruncateValue     = 200

     };

   // ==========================================================================

   class GAUDI_API TupleObj

   {

   public:

     // ========================================================================

     typedef NTuple::Item<bool>                  Bool      ;

     // ========================================================================

     typedef NTuple::Item<char>                  Char      ;

     // ========================================================================

     typedef NTuple::Item<unsigned char>         UChar     ;

     // ========================================================================

     typedef NTuple::Item<short>                 Short     ;

     // ========================================================================

     typedef NTuple::Item<unsigned short>        UShort    ;

     // ========================================================================

     typedef NTuple::Item<int>                   Int       ;

     // ========================================================================

     typedef NTuple::Item<unsigned int>          UInt      ;

     // ========================================================================

     typedef NTuple::Item<long long>             LongLong  ;

     // ========================================================================

     typedef NTuple::Item<unsigned long long>    ULongLong ;

     // ========================================================================

     typedef NTuple::Item<float>                 Float     ;

     // ========================================================================

     typedef NTuple::Item<double>                Double    ;

     // ========================================================================

     typedef NTuple::Item<IOpaqueAddress*>       Address   ;

     // ========================================================================

     typedef NTuple::Array<float>                FArray    ;

     // ========================================================================

     typedef NTuple::Matrix<float>               FMatrix   ;

     // ========================================================================

     // the actual type for variable size matrix indices

     typedef unsigned short                      MIndex    ;

     // ========================================================================

     // the map of all items

     typedef std::map<std::string,std::string>   ItemMap   ;

     // ========================================================================

   protected:

     // ========================================================================

     TupleObj

     ( const std::string&    name                          ,

       NTuple::Tuple*        tuple                         ,

       const CLID&           clid = CLID_ColumnWiseTuple   ,

       const Tuples::Type    type = Tuples::NTUPLE         ) ;

     // ========================================================================

   protected:

     // ========================================================================

     virtual ~TupleObj();

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string& name   ,

                         const float        value  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string& name   ,

                         const double       value  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const short          value );

     // ========================================================================

     StatusCode column ( const std::string&  name  ,

                         const short         value ,

                         const short         minv  ,

                         const short         maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const unsigned short value );

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const unsigned short value ,

                         const unsigned short minv  ,

                         const unsigned short maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const char           value );

     // ========================================================================

     StatusCode column ( const std::string&  name  ,

                         const char          value ,

                         const char          minv  ,

                         const char          maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const unsigned char  value );

     // ========================================================================

     StatusCode column ( const std::string&  name  ,

                         const unsigned char value ,

                         const unsigned char minv  ,

                         const unsigned char maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const int            value );

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const int            value ,

                         const int            minv  ,

                         const int            maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const unsigned int   value );

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const unsigned int   value ,

                         const unsigned int   minv  ,

                         const unsigned int   maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const long           value );

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const long           value ,

                         const long           minv  ,

                         const long           maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const unsigned long  value );

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const unsigned long  value ,

                         const unsigned long  minv  ,

                         const unsigned long  maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const long long      value );

     // ========================================================================

     StatusCode column ( const std::string&   name  ,

                         const long long      value ,

                         const long long      minv  ,

                         const long long      maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&       name  ,

                         const unsigned long long value );

     // ========================================================================

     StatusCode column ( const std::string&       name  ,

                         const unsigned long long value ,

                         const unsigned long long minv  ,

                         const unsigned long long maxv  );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string& name  ,

                         const signed char  value )

     {

       return column

         ( name  ,

           value ,

           std::numeric_limits<signed char>::min() ,

           std::numeric_limits<signed char>::max() ) ;

     }

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string& name  ,

                         const bool         value );

     // ========================================================================

   public:

     // ========================================================================

     StatusCode column ( const std::string&    name    ,

                         IOpaqueAddress*       address ) ;

     // ========================================================================

     StatusCode column ( IOpaqueAddress*       address ) ;

     // ========================================================================

   public:

     // ========================================================================

     StatusCode fill( const char* format ... ) ;

     // =======================================================================

   public:

     // =======================================================================

     template <class DATA>

     StatusCode farray ( const std::string& name          ,

                         DATA               first         ,

                         DATA               last          ,

                         const std::string& length        ,

                         const size_t       maxv          )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if( first + maxv < last )

       {

         Warning( "farray('"+name+"'): array is overflow, skip extra items") ;

         last = first + maxv ;

       }


       // get the length item

       Int* len  = ints( length , 0 , maxv ) ;

       if( 0 == len  ) { return InvalidColumn; }


       // adjust the length item

       *len = last - first ;


       // get the array itself

       FArray* var  = fArray ( name , len ) ;

       if( 0 == var ) { return InvalidColumn ; }


       size_t index = 0 ;

       for( ; first != last ; ++first )

       { (*var)[ index ] = (float)(*first) ; ++index ; }


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

     template <class DATA>

     StatusCode farray ( const std::string& name          ,

                         const DATA&        data          ,

                         const std::string& length        ,

                         const size_t       maxv          )

     { return farray ( name , data.begin() , data.end() , length , maxv  ) ; }

     // =======================================================================

     template <class FUNCTION, class DATA>

     StatusCode farray ( const std::string& name          ,

                         const FUNCTION&    function      ,

                         DATA               first         ,

                         DATA               last          ,

                         const std::string& length        ,

                         const size_t       maxv          )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if( first + maxv < last )

       {

         Warning("farray('"

                 + name  + "'): array is overflow, skip extra entries") ;

         last = first + maxv ;

       }


       // get the length item

       Int* len  = ints( length , 0 , maxv ) ;

       if( 0 == len  ) { return InvalidColumn ; }


       // adjust the length

       *len = last - first ;


       // get the array itself

       FArray*  var  = fArray ( name , len ) ;

       if( 0 == var ) { return InvalidColumn ; }


       // fill the array

       size_t index = 0 ;

       for( ; first != last ; ++first )

       { (*var)[ index ] = function( *first )  ; ++index ; }


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

     template <class FUNC1, class FUNC2, class DATA>

     StatusCode farray ( const std::string& name1         ,

                         const FUNC1&       func1         ,

                         const std::string& name2         ,

                         const FUNC2&       func2         ,

                         DATA               first         ,

                         DATA               last          ,

                         const std::string& length        ,

                         const size_t       maxv          )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the lenfth

       if( first + maxv < last )

       {

         Warning("farray('"

                 + name1 + ","

                 + name2 + "'): array is overflow, skip extra entries").ignore() ;

         Warning("farray('"+name1+"'): array is overflow, skip extra items").ignore() ;

         last = first + maxv ;

       }


       // get the length item

       Int* len  = ints ( length , 0 , maxv ) ;

       if ( 0 == len  ) { return InvalidColumn ; }


       // adjust the length

       *len = last - first ;


       // get the array itself

       FArray*  var1  = fArray ( name1 , len ) ;

       if ( 0 == var1 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var2 = fArray ( name2 , len ) ;

       if ( 0 == var2 ) { return InvalidColumn ; }


       // fill the array

       size_t index = 0 ;

       for( ; first != last ; ++first )

       {

         ( *var1 ) [ index ] = func1 ( *first )  ;

         ( *var2 ) [ index ] = func2 ( *first )  ;

         ++index ;

       }


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

     template <class FUNC1, class FUNC2, class FUNC3, class DATA>

     StatusCode farray ( const std::string& name1         ,

                         const FUNC1&       func1         ,

                         const std::string& name2         ,

                         const FUNC2&       func2         ,

                         const std::string& name3         ,

                         const FUNC3&       func3         ,

                         DATA               first         ,

                         DATA               last          ,

                         const std::string& length        ,

                         const size_t       maxv          )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if( first + maxv < last )

       {

         Warning("farray('"

                 + name1 + ","

                 + name2 + ","

                 + name3 + "'): array is overflow, skip extra entries").ignore() ;

         last = first + maxv ;

       }


       // get the length item

       Int* len  = ints ( length , 0 , maxv ) ;

       if( 0 == len   ) { return InvalidColumn ; }


       // adjust the length

       *len = last - first ;


       // get the array itself

       FArray*  var1  = fArray ( name1 , len ) ;

       if( 0 == var1 ) { return InvalidColumn  ; }


       // get the array itself

       FArray*  var2 = fArray ( name2 , len ) ;

       if( 0 == var2 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var3 = fArray ( name3 , len ) ;

       if( 0 == var3 ) { return InvalidColumn ; }


       // fill the array

       size_t index = 0 ;

       for( ; first != last ; ++first )

       {

         ( *var1 ) [ index ] = (float)func1 ( *first )  ;

         ( *var2 ) [ index ] = (float)func2 ( *first )  ;

         ( *var3 ) [ index ] = (float)func3 ( *first )  ;

         ++index ;

       }

       return StatusCode::SUCCESS ;

     }

     // =======================================================================

     template <class FUNC1, class FUNC2, class FUNC3, class FUNC4, class DATA>

     StatusCode farray ( const std::string& name1         ,

                         const FUNC1&       func1         ,

                         const std::string& name2         ,

                         const FUNC2&       func2         ,

                         const std::string& name3         ,

                         const FUNC3&       func3         ,

                         const std::string& name4         ,

                         const FUNC4&       func4         ,

                         DATA               first         ,

                         DATA               last          ,

                         const std::string& length        ,

                         const size_t       maxv          )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if( first + maxv < last )

       {

         Warning("farray('"

                 + name1 + ","

                 + name2 + ","

                 + name3 + ","

                 + name4 + "'): array is overflow, skip extra entries").ignore() ;

         last = first + maxv ;

       }


       // get the length item

       Int* len  = ints ( length , 0 , maxv ) ;

       if( 0 == len  ) { return InvalidColumn ; }


       // adjust the length

       *len = last - first ;


       // get the array itself

       FArray*  var1  = fArray ( name1 , len ) ;

       if( 0 == var1 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var2 = fArray ( name2 , len ) ;

       if( 0 == var2 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var3 = fArray ( name3 , len ) ;

       if( 0 == var3 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var4 = fArray ( name4 , len ) ;

       if( 0 == var4 ) { return InvalidColumn ; }


       // fill the array

       size_t index = 0 ;

       for( ; first != last ; ++first )

       {

         ( *var1 ) [ index ] = static_cast<float> ( func1 ( *first ) );

         ( *var2 ) [ index ] = static_cast<float> ( func2 ( *first ) );

         ( *var3 ) [ index ] = static_cast<float> ( func3 ( *first ) );

         ( *var4 ) [ index ] = static_cast<float> ( func4 ( *first ) );

         ++index ;

       }


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

   public:

     // =======================================================================

     template <class MATRIX>

     StatusCode fmatrix ( const std::string& name    ,

                          const MATRIX&      data    ,

                          size_t             rows    ,

                          const MIndex&      cols    ,

                          const std::string& length  ,

                          const size_t       maxv    )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if ( rows >= maxv )

       {

         Warning ( "fmatrix('"+name+"'): matrix is overflow, skip extra items").ignore() ;

         rows = ( 0 < maxv ) ? ( maxv - 1 ) : 0 ;

       }


       // get the length item

       Int* len  = ints( length , 0 , maxv ) ;

       if ( 0 == len  ) { return InvalidColumn; }


       // adjust the length item

       *len = rows ;


       // get the array itself

       FMatrix* var  = fMatrix ( name , len  , cols ) ;

       if ( 0 == var ) { return InvalidColumn ; }


       for ( size_t iCol = 0 ; iCol < cols ; ++iCol )

       {

         for ( MIndex iRow = 0 ; iRow < rows ; ++iRow )

         { (*var)[ iRow ] [ iCol ] = (float)(data[ iRow ][ iCol ]) ; }

       }


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

     template <class DATA>

     StatusCode fmatrix ( const std::string& name   ,

                          DATA               first  ,

                          DATA               last   ,

                          const MIndex&      cols   ,

                          const std::string& length ,

                          const size_t       maxv   )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if ( first + maxv < last )

       {

         Warning("fmatrix('"+name+"'): matrix is overflow, skip extra items").ignore() ;

         last = first + maxv ;

       }


       // get the length item

       Int* len  = ints( length , 0 , maxv ) ;

       if ( 0 == len  ) { return InvalidColumn; }


       // adjust the length item

       *len = last - first ;


       // get the array itself

       FMatrix* var  = fMatrix ( name , len , cols ) ;

       if ( 0 == var ) { return InvalidColumn ; }


       size_t iRow = 0 ;

       for ( ; first != last ; ++first )

       {

         //

         for ( MIndex iCol = 0 ; iCol < cols ; ++iCol )

         { (*var)[ iRow ] [ iCol ] = (float)((*first)[ iCol ]) ; }

         //

         ++iRow ;

       }


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

     template <class FUN,class DATA>

     StatusCode fmatrix ( const std::string& name   ,

                          FUN                funF   ,

                          FUN                funL   ,

                          DATA               first  ,

                          DATA               last   ,

                          const std::string& length ,

                          const size_t       maxv   )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if ( first + maxv < last )

       {

         Warning("fmatrix('"+name+"'): matrix is overflow, skip extra items").ignore() ;

         last = first + maxv ;

       }


       // get the length item

       Int* len  = ints( length , 0 , maxv ) ;

       if ( 0 == len  ) { return InvalidColumn; }


       // adjust the length item

       *len = last - first ;


       // get the array itself

       const size_t cols = funL - funF ;

       FMatrix* var  = fMatrix ( name , len , cols ) ;

       if ( 0 == var ) { return InvalidColumn ; }


       size_t iRow = 0 ;

       for ( ; first != last ; ++first )

       {

         //

         for ( FUN fun = funF ; fun < funL ; ++fun )

         { (*var)[ iRow ] [ fun - funF ] = (float)((*fun) ( *first )) ; }

         //

         ++iRow;

       }


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

   public:

     // =======================================================================

     template <class DATA>

     StatusCode array ( const std::string& name          ,

                        DATA               first         ,

                        DATA               last          )


     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // get the length (fixed!)

       const size_t length = last - first ;


       // get the array itself

       FArray* var  = fArray ( name , length ) ;

       if ( 0 == var ) { return InvalidColumn ; }


       size_t iCol = 0 ;

       for ( ; first != last ; ++first )

       { (*var)[ iCol ] = (float)(*first) ; ++iCol ; }


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

     template <class ARRAY>

     StatusCode array ( const std::string& name   ,

                        const ARRAY&       data   ,

                        const MIndex&      length )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // get the array itself

       FArray* var  = fArray ( name , length ) ;

       if ( 0 == var ) { return InvalidColumn ; }


       for ( size_t index = 0 ; index < length ; ++index )

       { (*var)[ index ] = (float) data[index] ; }


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

     template <class ARRAY>

     StatusCode array ( const std::string& name  ,

                        const ARRAY&       data  )

     { return array ( name , data.begin() , data.end() ) ; }

     // =======================================================================

   public:

     // =======================================================================

     template <class MATRIX>

     StatusCode matrix ( const std::string& name  ,

                         const MATRIX&      data  ,

                         const MIndex&      rows  ,

                         const MIndex&      cols  )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // get the matrix itself

       FMatrix* var  = fMatrix ( name , rows , cols ) ;

       if ( 0 == var ) { return InvalidColumn ; }


       for ( size_t iCol = 0 ; iCol < cols ; ++iCol )

       {

         for ( size_t iRow = 0 ; iRow < rows ; ++iRow )

         { (*var)[iRow][iCol] = (float)(data[iRow][iCol]) ; }

       };

       return StatusCode::SUCCESS ;

     }

     // =======================================================================

   public:

     // =======================================================================

     template <class TYPE>

     StatusCode column

     ( const std::string& name ,

       const ROOT::Math::LorentzVector<TYPE>& v )

     {

       if ( invalid() ) { return InvalidTuple ; }

       // fill all separate columns:

       StatusCode sc1 = this -> column ( name + "E" , v.E  () ) ;

       StatusCode sc2 = this -> column ( name + "X" , v.Px () ) ;

       StatusCode sc3 = this -> column ( name + "Y" , v.Py () ) ;

       StatusCode sc4 = this -> column ( name + "Z" , v.Pz () ) ;

       return

         sc1.isFailure () ? sc1 :

         sc2.isFailure () ? sc2 :

         sc3.isFailure () ? sc3 :

         sc4.isFailure () ? sc4 : StatusCode(StatusCode::SUCCESS) ;

     }

     // =======================================================================

     template <class TYPE,class TAG>

     StatusCode column

     ( const std::string& name ,

       const ROOT::Math::DisplacementVector3D<TYPE,TAG>& v )

     {

       if ( invalid() ) { return InvalidTuple ; }

       StatusCode sc1 = this -> column ( name + "X" , v.X () ) ;

       StatusCode sc2 = this -> column ( name + "Y" , v.Y () ) ;

       StatusCode sc3 = this -> column ( name + "Z" , v.Z () ) ;

       return

         sc1.isFailure () ? sc1 :

         sc2.isFailure () ? sc2 :

         sc3.isFailure () ? sc3 : StatusCode(StatusCode::SUCCESS) ;

     }

     // =======================================================================

     template <class TYPE,class TAG>

     StatusCode column

     ( const std::string& name ,

       const ROOT::Math::PositionVector3D<TYPE,TAG>& v )

     {

       if ( invalid() ) { return InvalidTuple ; }

       StatusCode sc1 = this -> column ( name + "X" , v.X () ) ;

       StatusCode sc2 = this -> column ( name + "Y" , v.Y () ) ;

       StatusCode sc3 = this -> column ( name + "Z" , v.Z () ) ;

       return

         sc1.isFailure () ? sc1 :

         sc2.isFailure () ? sc2 :

         sc3.isFailure () ? sc3 : StatusCode(StatusCode::SUCCESS) ;

     }

     // =======================================================================

     template <class TYPE,unsigned int DIM>

     StatusCode array

     ( const std::string&                   name ,

       const ROOT::Math::SVector<TYPE,DIM>& vect )

     {

       return this->array( name , vect.begin() , vect.end() ) ;

     }

     // =======================================================================

     template <class TYPE,unsigned int D1,unsigned int D2,class REP>

     StatusCode matrix

     ( const std::string&                         name ,

       const ROOT::Math::SMatrix<TYPE,D1,D2,REP>& mtrx )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // get the matrix itself

       FMatrix* var  = fMatrix ( name , (MIndex)D1 , (MIndex)D2 ) ;

       if ( 0 == var   ) { return InvalidColumn ; }


       for ( size_t iCol = 0 ; iCol < D2 ; ++iCol )

       {

         for ( size_t iRow = 0 ; iRow < D1 ; ++iRow )

         { (*var)[iRow][iCol] = (float) mtrx(iRow,iCol) ; }

       };


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

     template <class KEY, class VALUE>

     StatusCode fmatrix

     ( const std::string&                      name       ,

       const GaudiUtils::VectorMap<KEY,VALUE>& info       ,

       const std::string&                      length     ,

       const size_t                            maxv = 100 )

     {


       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       typename GaudiUtils::VectorMap<KEY,VALUE>::const_iterator begin = info.begin () ;

       typename GaudiUtils::VectorMap<KEY,VALUE>::const_iterator end   = info.end   () ;


       // adjust the length

       if ( maxv < info.size() )

       {

         Warning("fmatrix('"+name+"'): matrix is overflow, skip extra items") ;

         end = begin + maxv ;

       } ;


       // get the length item

       Int* len  = ints( length , 0 , maxv ) ;

       if ( 0 == len  ) { return InvalidColumn; }


       // adjust the length item

       *len = end - begin ;


       // get the array itself

       FMatrix* var  = fMatrix ( name , len , 2 ) ;

       if ( 0 == var ) { return InvalidColumn ; }


       size_t iRow = 0 ;

       for ( ; begin != end ; ++begin)

       {

         //

         (*var)[iRow][0] = (float) begin->first   ;

         (*var)[iRow][1] = (float) begin->second  ;

         //

         ++iRow ;

       } ;


       return StatusCode::SUCCESS ;

     }

     // =======================================================================

   public:

     // =======================================================================

     template <class TYPE>

     StatusCode put

     ( const std::string& name , const TYPE*  obj ) ;

     // =======================================================================

   public:

     // =======================================================================

     StatusCode write () ;

     // =======================================================================

     const std::string&  name() const { return m_name ; }

     // =======================================================================

     NTuple::Tuple* tuple() const  { return m_tuple ; }

     // =======================================================================

     unsigned long refCount() const { return   m_refCount ; }

     // =======================================================================

     unsigned long addRef  ()       { return ++m_refCount ; }

     // =======================================================================

     void          release () ;

     // =======================================================================

     const CLID&        clid() const { return m_clid ; }

     // =======================================================================

     Tuples::Type       type() const { return m_type ; }

     // =======================================================================

     bool columnWise() const { return CLID_ColumnWiseTuple == clid() ; }

     // =======================================================================

     bool rowWise   () const { return CLID_RowWiseTuple    == clid() ; }

     // =======================================================================

     bool evtColType() const { return Tuples::EVTCOL       == type()  ; }

     // =======================================================================

     bool valid     () const { return 0 != tuple() ; }

     // =======================================================================

     bool invalid   () const { return ! valid()    ; }

     // =======================================================================

   public:

     // =======================================================================

     bool addItem ( const std::string& name ,

                    const std::string& type )

     { return m_items.insert ( std::make_pair ( name , type ) ).second ; }

     // =======================================================================

     bool goodItem  ( const std::string& name ) const

     { return m_items.end() == m_items.find ( name ) ; }

     // =======================================================================

     const ItemMap& items() const { return m_items ; }

     // =======================================================================

   public:

     // =======================================================================

     virtual StatusCode Error

     ( const std::string& msg ,

       const StatusCode   sc  = StatusCode::FAILURE ) const = 0 ;

     // =======================================================================

     virtual StatusCode Warning

     ( const std::string& msg ,

       const StatusCode   sc  = StatusCode::FAILURE ) const = 0 ;

     // =======================================================================

   private:

     // =======================================================================

     Bool*    bools      ( const std::string& name ) ;

     // =======================================================================

     Float*   floats     ( const std::string& name ) ;

     // =======================================================================

     Double*  doubles    ( const std::string& name ) ;

     // =======================================================================

     Char*   chars     ( const std::string& name ) ;

     // =======================================================================

     Char*   chars     ( const std::string& name ,

                         const char         minv ,

                         const char         maxv ) ;

     // =======================================================================

     UChar*  uchars    ( const std::string& name ) ;

     // =======================================================================

     UChar*  uchars    ( const std::string&  name ,

                         const unsigned char minv ,

                         const unsigned char maxv ) ;

     // =======================================================================

     Short*   shorts     ( const std::string& name ) ;

     // =======================================================================

     Short*   shorts     ( const std::string& name ,

                           const short        minv ,

                           const short        maxv ) ;

     // =======================================================================

     UShort*   ushorts   ( const std::string& name ) ;

     // =======================================================================

     UShort*   ushorts   ( const std::string& name ,

                           const unsigned short minv ,

                           const unsigned short maxv ) ;

     // =======================================================================

     Int*     ints       ( const std::string& name ) ;

     // =======================================================================

     Int*     ints       ( const std::string& name ,

                           const int          minv ,

                           const int          maxv ) ;

     // =======================================================================

     UInt*     uints     ( const std::string& name ) ;

     // =======================================================================

     UInt*     uints     ( const std::string& name ,

                           const unsigned int minv ,

                           const unsigned int maxv ) ;

     // =======================================================================

     LongLong* longlongs ( const std::string& name );

     // =======================================================================

     LongLong* longlongs ( const std::string& name ,

                           const long long    minv ,

                           const long long    maxv ) ;

     // =======================================================================

     ULongLong* ulonglongs ( const std::string& name ) ;

     // =======================================================================

     ULongLong* ulonglongs ( const std::string&       name ,

                             const unsigned long long minv ,

                             const unsigned long long maxv ) ;

     // =======================================================================

     FArray*  fArray     ( const std::string& name ,

                           Int*               item ) ;

     // =======================================================================

     FArray*  fArray     ( const std::string& name ,

                           const MIndex&      rows ) ;

     // =======================================================================

     Address* addresses  ( const std::string& name ) ;

     // =======================================================================

     FMatrix* fMatrix    ( const std::string& name ,

                           Int*               item ,

                           const MIndex&      cols ) ;

     // =======================================================================

     FMatrix* fMatrix    ( const std::string& name ,

                           const MIndex&      rows ,

                           const MIndex&      cols ) ;

     // =======================================================================

   private:

     // =======================================================================

     TupleObj () ;

     // =======================================================================

     TupleObj            ( const TupleObj& ) ;

     // =======================================================================

     TupleObj& operator= ( const TupleObj& ) ;

     // =======================================================================

   private:

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,Bool*>   Bools;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,Char*>   Chars;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,UChar*>  UChars;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,Short*>  Shorts;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,UShort*> UShorts;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,Int*>    Ints;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,UInt*>   UInts;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,LongLong*> LongLongs;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,ULongLong*> ULongLongs;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,Float*>   Floats;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,Double*>  Doubles;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,Address*> Addresses;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,FArray*>  FArrays;

     // =======================================================================

     typedef GaudiUtils::HashMap<std::string,FMatrix*> FMatrices;

     // =======================================================================

   private:

     // =======================================================================

     std::string            m_name       ;

     // =======================================================================

     NTuple::Tuple*         m_tuple      ;

     // =======================================================================

     CLID                   m_clid       ;

     // =======================================================================

     Tuples::Type           m_type       ;

     // =======================================================================

     size_t                 m_refCount   ;

     // =======================================================================

     mutable Bools          m_bools      ;

     // =======================================================================

     mutable Chars          m_chars      ;

     // =======================================================================

     mutable UChars         m_uchars     ;

     // =======================================================================

     mutable Shorts         m_shorts     ;

     // =======================================================================

     mutable UShorts        m_ushorts    ;

     // =======================================================================

     mutable Ints           m_ints       ;

     // =======================================================================

     mutable UInts          m_uints      ;

     // =======================================================================

     mutable LongLongs      m_longlongs  ;

     // =======================================================================

     mutable ULongLongs     m_ulonglongs ;

     // =======================================================================

     mutable Floats         m_floats     ;

     // =======================================================================

     mutable Doubles        m_doubles    ;

     // =======================================================================

     mutable Addresses      m_addresses  ;

     // =======================================================================

     mutable FArrays        m_farrays    ;

     // =======================================================================

     mutable FArrays        m_arraysf    ;

     // =======================================================================

     mutable FMatrices      m_fmatrices  ;

     // =======================================================================

     mutable FMatrices      m_matricesf  ;

     // =======================================================================

     ItemMap                m_items      ;

     // =======================================================================

   } ;

   // ==========================================================================

 } // end of namespace Tuples

 // ============================================================================

 // GaudiAlg

 // ============================================================================

 #include "GaudiAlg/TuplePut.h"

 // ============================================================================

 // The END

 // ============================================================================

 #endif // GAUDIALG_TUPLEOBJ_H

 // ============================================================================

Tuples::TupleObj::Addresses
GaudiUtils::HashMap< std::string, Address * > Addresses
the actual storage type for address columns
Definition: TupleObj.h:2301

Tuples::TupleObj::UChars
GaudiUtils::HashMap< std::string, UChar * > UChars
the actual storage type for unsigned short columns
Definition: TupleObj.h:2274

Tuples::TupleObj::m_ushorts
UShorts m_ushorts
the actual storage of all 'unsigned int' columns
Definition: TupleObj.h:2339

Tuples::TupleObj::m_fmatrices
FMatrices m_fmatrices
the actual storage of all 'FArray' columns
Definition: TupleObj.h:2369

GaudiUtils::VectorMap
A bit modified version of 'Loki::AssocVector' associative vector from Loki library by Andrei Alexandr...
Definition: VectorMap.h:110

Tuples::TupleObj::m_clid
CLID m_clid
tuple CLID
Definition: TupleObj.h:2318

Tuples::TupleObj::matrix
StatusCode matrix(const std::string &name, const MATRIX &data, const MIndex &rows, const MIndex &cols)
fill N-Tuple with fixed-size matrix
Definition: TupleObj.h:1824

format
GAUDI_API std::string format(const char *,...)
MsgStream format utility "a la sprintf(...)".
Definition: MsgStream.cpp:133

Tuples::TupleObj::Float
NTuple::Item< float > Float
basic type for float items
Definition: TupleObj.h:212

Tuples::TupleObj::goodItem
bool goodItem(const std::string &name) const
check the uniqueness of the name
Definition: TupleObj.h:2142

Tuples::TupleObj::evtColType
bool evtColType() const
Event collection ?
Definition: TupleObj.h:2119

GaudiMP.FdsRegistry.msg
tuple msg
Definition: FdsRegistry.py:8

Tuples::InvalidTuple
Definition: TupleObj.h:78

Tuples::TupleObj::farray
StatusCode farray(const std::string &name1, const FUNC1 &func1, const std::string &name2, const FUNC2 &func2, const std::string &name3, const FUNC3 &func3, DATA first, DATA last, const std::string &length, const size_t maxv)
Put three functions from one data array into LoKi-style N-Tuple simultaneously (effective!) ...
Definition: TupleObj.h:1182

Tuples::TupleObj::m_doubles
Doubles m_doubles
the actual storage of all 'Double' columns
Definition: TupleObj.h:2357

Tuples::TupleObj::m_type
Tuples::Type m_type
tuple 'type'
Definition: TupleObj.h:2321

NTuple::Matrix
Class acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:45

Tuples::TupleObj::Chars
GaudiUtils::HashMap< std::string, Char * > Chars
the actual storage type for short columns
Definition: TupleObj.h:2271

Tuples::TupleObj::fmatrix
StatusCode fmatrix(const std::string &name, DATA first, DATA last, const MIndex &cols, const std::string &length, const size_t maxv)
Fill N-Tuple with data from variable-size matrix.
Definition: TupleObj.h:1469

Tuples::TupleObj::Bools
GaudiUtils::HashMap< std::string, Bool * > Bools
the actual storage type for short columns
Definition: TupleObj.h:2268

Tuples::TupleObj::Address
NTuple::Item< IOpaqueAddress * > Address
basic type for address items
Definition: TupleObj.h:218

NTuple.h

Tuples::TupleObj::m_matricesf
FMatrices m_matricesf
the actual storage of all 'FMatrix' columns (fixed)
Definition: TupleObj.h:2372

Tuples::TupleObj::m_floats
Floats m_floats
the actual storage of all 'Float' columns
Definition: TupleObj.h:2354

Gaudi::Utils::Histos::fill
GAUDI_API void fill(AIDA::IHistogram1D *histo, const double value, const double weight=1.0)
simple function to fill AIDA::IHistogram1D objects
Definition: Fill.cpp:37

Tuples::TupleObj::ULongLong
NTuple::Item< unsigned long long > ULongLong
basic type for unsigned long long items
Definition: TupleObj.h:209

Tuples::TupleObj::m_farrays
FArrays m_farrays
the actual storage of all 'FArray' columns
Definition: TupleObj.h:2363

Tuples::TupleObj::UShort
NTuple::Item< unsigned short > UShort
basic type for unsigned int items
Definition: TupleObj.h:197

Tuples::TupleObj::LongLongs
GaudiUtils::HashMap< std::string, LongLong * > LongLongs
the actual storage type for longlong columns
Definition: TupleObj.h:2289

Tuples::TupleObj::m_refCount
size_t m_refCount
reference counter
Definition: TupleObj.h:2324

Tuples::InvalidItem
Definition: TupleObj.h:82

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

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

merge_files.sc
int sc
Definition: merge_files.py:153

Tuples::TupleObj::m_name
std::string m_name
name
Definition: TupleObj.h:2312

StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:85

Tuples::TruncateValue
Definition: TupleObj.h:83

Tuples::TupleObj::m_arraysf
FArrays m_arraysf
the actual storage of all 'FArray' columns (fixed)
Definition: TupleObj.h:2366

Tuples::InvalidOperation
Definition: TupleObj.h:80

Tuples::TupleObj::UChar
NTuple::Item< unsigned char > UChar
basic type for unsigned int items
Definition: TupleObj.h:191

Tuples::TupleObj::m_bools
Bools m_bools
the actual storage of all 'bool' columns
Definition: TupleObj.h:2327

Tuples::TupleObj::farray
StatusCode farray(const std::string &name1, const FUNC1 &func1, const std::string &name2, const FUNC2 &func2, const std::string &name3, const FUNC3 &func3, const std::string &name4, const FUNC4 &func4, DATA first, DATA last, const std::string &length, const size_t maxv)
Put four functions from one data array into LoKi-style N-Tuple simultaneously (effective!) ...
Definition: TupleObj.h:1277

Tuples::TupleObj::columnWise
bool columnWise() const
column wise NTuple ?
Definition: TupleObj.h:2113

Tuples::TupleObj::tuple
NTuple::Tuple * tuple() const
provide the access to underlying Gaudi N-tuple
Definition: TupleObj.h:2088

Tuples::TupleObj::farray
StatusCode farray(const std::string &name, const FUNCTION &function, DATA first, DATA last, const std::string &length, const size_t maxv)
Put an indexed array into LoKi-style N-Tuple.
Definition: TupleObj.h:1027

Tuples::TupleObj::Short
NTuple::Item< short > Short
basic type for int items
Definition: TupleObj.h:194

Tuples::TupleObj::m_chars
Chars m_chars
the actual storage of all 'Int' columns
Definition: TupleObj.h:2330

GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:200

Tuples::TupleObj::m_ulonglongs
ULongLongs m_ulonglongs
the actual storage of all 'ulonglong' columns
Definition: TupleObj.h:2351

gaudirun.type
string type
Definition: gaudirun.py:126

VectorMap.h

StatusCode::FAILURE
Definition: StatusCode.h:33

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

StatusCode::SUCCESS
Definition: StatusCode.h:34

Tuples::TupleObj::array
StatusCode array(const std::string &name, const ARRAY &data)
fill N-Tuple with fixed-size array
Definition: TupleObj.h:1769

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

Tuples::TupleObj::farray
StatusCode farray(const std::string &name, const DATA &data, const std::string &length, const size_t maxv)
Add an indexed array (of type float) to N-tuple.
Definition: TupleObj.h:958

Tuples::TupleObj::FMatrix
NTuple::Matrix< float > FMatrix
basic type for matrix of floats
Definition: TupleObj.h:224

GaudiUtils::VectorMap::begin
iterator begin() const
"begin" iterator for sequential access (const-only version!)
Definition: VectorMap.h:198

Tuples::TupleObj::m_uints
UInts m_uints
the actual storage of all 'unsigned int' columns
Definition: TupleObj.h:2345

Tuples::TupleObj::FMatrices
GaudiUtils::HashMap< std::string, FMatrix * > FMatrices
the actual storage type for matrix columns
Definition: TupleObj.h:2307

dump_component_properties.value
list value
Definition: dump_component_properties.py:12

Tuples::TupleObj::m_items
ItemMap m_items
all booked types:
Definition: TupleObj.h:2375

Tuples::TupleObj::Bool
NTuple::Item< bool > Bool
basic type for int items
Definition: TupleObj.h:185

Tuples::TupleObj::Double
NTuple::Item< double > Double
basic type for double items
Definition: TupleObj.h:215

Tuples::TupleObj::FArrays
GaudiUtils::HashMap< std::string, FArray * > FArrays
the actual storage type for array columns
Definition: TupleObj.h:2304

NTuple::Item< bool >
Specialization acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:299

Tuples::TupleObj::m_ints
Ints m_ints
the actual storage of all 'Int' columns
Definition: TupleObj.h:2342

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

Tuples::TupleObj::m_longlongs
LongLongs m_longlongs
the actual storage of all 'longlong' columns
Definition: TupleObj.h:2348

Tuples::TupleObj::valid
bool valid() const
valid pointer to tuple ?
Definition: TupleObj.h:2122

Tuples::InvalidColumn
Definition: TupleObj.h:79

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

Tuples::TupleObj::addRef
unsigned long addRef()
add the reference to TupleObj
Definition: TupleObj.h:2098

Tuples::TupleObj::refCount
unsigned long refCount() const
return the reference counter
Definition: TupleObj.h:2093

Tuples::TupleObj::rowWise
bool rowWise() const
row wise NTuple ?
Definition: TupleObj.h:2116

Tuples::TupleObj::column
StatusCode column(const std::string &name, const signed char value)
Set the value for the selected tuple column.
Definition: TupleObj.h:732

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

IOTest.end
tuple end
Definition: IOTest.py:101

Tuples::ErrorCodes
ErrorCodes
Tuple error codes.
Definition: TupleObj.h:76

Tuples::TupleObj::LongLong
NTuple::Item< long long > LongLong
basic type for unsigned long long items
Definition: TupleObj.h:206

Tuples::TupleObj::m_addresses
Addresses m_addresses
the actual storage of all 'Address' columns
Definition: TupleObj.h:2360

min
#define min(a, b)
Definition: CallbackStreamBuf.cpp:12

Tuples::EVTCOL
Definition: TupleObj.h:66

Maps.h

Tuples::TupleObj::array
StatusCode array(const std::string &name, DATA first, DATA last)
fill N-Tuple with fixed-size array
Definition: TupleObj.h:1659

Tuples::TupleObj::addItem
bool addItem(const std::string &name, const std::string &type)
add the item name into the list of known items
Definition: TupleObj.h:2134

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

Tuples::TupleObj::m_tuple
NTuple::Tuple * m_tuple
tuple itself
Definition: TupleObj.h:2315

Tuples::TupleObj::Shorts
GaudiUtils::HashMap< std::string, Short * > Shorts
the actual storage type for short columns
Definition: TupleObj.h:2277

GaudiUtils::VectorMap::const_iterator
_vector::const_iterator const_iterator
visible const_iterator (exported)
Definition: VectorMap.h:151

Tuples::TupleObj::ULongLongs
GaudiUtils::HashMap< std::string, ULongLong * > ULongLongs
the actual storage type for ulonglong columns
Definition: TupleObj.h:2292

Tuples::TupleObj::type
Tuples::Type type() const
accessor to the N-Tuple type
Definition: TupleObj.h:2110

Tuples::TupleObj::Doubles
GaudiUtils::HashMap< std::string, Double * > Doubles
the actual storage type for float columns
Definition: TupleObj.h:2298

fun
double fun(const std::vector< double > &x)
Definition: PFuncTest.cpp:27

Tuples::TupleObj::Char
NTuple::Item< char > Char
basic type for int items
Definition: TupleObj.h:188

Tuples::TupleObj::UInts
GaudiUtils::HashMap< std::string, UInt * > UInts
the actual storage type for unsigned integer columns
Definition: TupleObj.h:2286

GaudiUtils::HashMap< std::string, Bool * >

Tuples::TupleObj::Int
NTuple::Item< int > Int
basic type for int items
Definition: TupleObj.h:200

ana.item
tuple item
print s1,s2
Definition: ana.py:146

Tuples.h

Tuples::TupleObj::farray
StatusCode farray(const std::string &name1, const FUNC1 &func1, const std::string &name2, const FUNC2 &func2, DATA first, DATA last, const std::string &length, const size_t maxv)
Put two functions from one data array into LoKi-style N-Tuple simultaneously (effective!) ...
Definition: TupleObj.h:1096

Tuples::TupleObj::m_shorts
Shorts m_shorts
the actual storage of all 'Int' columns
Definition: TupleObj.h:2336

Tuples::TupleObj::invalid
bool invalid() const
invalid pointer to tuple ?
Definition: TupleObj.h:2125

Tuples::NTUPLE
Definition: TupleObj.h:65

Tuples::TupleObj::items
const ItemMap & items() const
get the full list of booked items
Definition: TupleObj.h:2146

Tuples::TupleObj::FArray
NTuple::Array< float > FArray
basic type for array of floats
Definition: TupleObj.h:221

TuplePut.h
Implementation file for Tuple::TupleObj::put method.

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

Tuples::InvalidObject
Definition: TupleObj.h:81

NTuple::Item
Class acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:43

Tuples::TupleObj::clid
const CLID & clid() const
accessor to the N-Tuple CLID
Definition: TupleObj.h:2107

Tuples::TupleObj::array
StatusCode array(const std::string &name, const ARRAY &data, const MIndex &length)
fill N-Tuple with fixed-size array
Definition: TupleObj.h:1721

NTuple::Array
Class acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:44

Tuples::TupleObj::ItemMap
std::map< std::string, std::string > ItemMap
Definition: TupleObj.h:230

GAUDI_API
#define GAUDI_API
Definition: Kernel.h:108

Tuples::Type
Type
the list of available types for ntuples
Definition: TupleObj.h:63

Tuples::TupleObj::name
const std::string & name() const
get the name
Definition: TupleObj.h:2083

Tuples::TupleObj::UInt
NTuple::Item< unsigned int > UInt
basic type for unsigned int items
Definition: TupleObj.h:203

Tuples::TupleObj::farray
StatusCode farray(const std::string &name, DATA first, DATA last, const std::string &length, const size_t maxv)
Add an indexed array (of type float) to N-tuple.
Definition: TupleObj.h:880

Tuples::TupleObj::fmatrix
StatusCode fmatrix(const std::string &name, FUN funF, FUN funL, DATA first, DATA last, const std::string &length, const size_t maxv)
fill N-Tuple with matrix of "direct-product" of "data-vector" [first,last) and "function-vector" [fun...
Definition: TupleObj.h:1590

Tuples::TupleObj::fmatrix
StatusCode fmatrix(const std::string &name, const MATRIX &data, size_t rows, const MIndex &cols, const std::string &length, const size_t maxv)
Fill N-Tuple with data from variable-size matrix.
Definition: TupleObj.h:1394

Tuples::TupleObj::UShorts
GaudiUtils::HashMap< std::string, UShort * > UShorts
the actual storage type for unsigned short columns
Definition: TupleObj.h:2280

Tuples::TupleObj::m_uchars
UChars m_uchars
the actual storage of all 'unsigned int' columns
Definition: TupleObj.h:2333

Tuples::TupleObj::Ints
GaudiUtils::HashMap< std::string, Int * > Ints
the actual storage type for integer columns
Definition: TupleObj.h:2283

GaudiUtils::VectorMap::size
size_type size() const
number of elements
Definition: VectorMap.h:495

Tuples::TupleObj::Floats
GaudiUtils::HashMap< std::string, Float * > Floats
the actual storage type for float columns
Definition: TupleObj.h:2295