db/d65/_install_area_2x86__64-slc6-gcc48-opt_2include_2_gaudi_alg_2_tuple_obj_8h_source.html

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

 #ifndef GAUDIALG_TUPLEOBJ_H

 #define GAUDIALG_TUPLEOBJ_H 1

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

 // Include files

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

 // STD&STL

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

 #include <cstddef>

 #include <set>

 #include <string>

 #include <limits>

 #include <array>

 #include <functional>

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

 // 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

 {

     namespace implementation_detail {

       template <typename T> struct to_ {

           template <typename Arg>

           T operator()(Arg&& i) const

           { return T(std::forward<Arg>(i)); }

       };

       constexpr struct to_<float> to_float {};

     }

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

   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

     ( 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   ,

                         float              value  );

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

   public:

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

     StatusCode column ( const std::string& name   ,

                         double             value  );

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

   public:

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

     StatusCode column ( const std::string&   name  ,

                         short                value );

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

     StatusCode column ( const std::string&  name  ,

                         short         value ,

                         short         minv  ,

                         short         maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         unsigned short     value );

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

     StatusCode column ( const std::string& name  ,

                         unsigned short     value ,

                         unsigned short     minv  ,

                         unsigned short     maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         char               value );

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

     StatusCode column ( const std::string& name  ,

                         char               value ,

                         char               minv  ,

                         char               maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         unsigned char      value );

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

     StatusCode column ( const std::string& name  ,

                         unsigned char      value ,

                         unsigned char      minv  ,

                         unsigned char      maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         int                value );

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

     StatusCode column ( const std::string& name  ,

                         int                value ,

                         int                minv  ,

                         int                maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         unsigned int       value );

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

     StatusCode column ( const std::string& name  ,

                         unsigned int       value ,

                         unsigned int       minv  ,

                         unsigned int       maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         long               value );

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

     StatusCode column ( const std::string& name  ,

                         long               value ,

                         long               minv  ,

                         long               maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         unsigned long      value );

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

     StatusCode column ( const std::string& name  ,

                         unsigned long      value ,

                         unsigned long      minv  ,

                         unsigned long      maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         long long          value );

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

     StatusCode column ( const std::string& name  ,

                         long long          value ,

                         long long          minv  ,

                         long long          maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         unsigned long long value );

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

     StatusCode column ( const std::string& name  ,

                         unsigned long long value ,

                         unsigned long long minv  ,

                         unsigned long long maxv  );

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

   public:

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

     StatusCode column ( const std::string& name  ,

                         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  ,

                         bool               value );

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

   public:

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

     StatusCode column ( const std::string& name    ,

                         IOpaqueAddress*    address ) ;

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

     StatusCode column ( IOpaqueAddress* address ) ;

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

   public:

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

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

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

   public:

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

     template <typename ITERATOR1,typename ITERATOR2>

     StatusCode farray ( const std::string& name          ,

                         ITERATOR1&&        first         ,

                         ITERATOR2&&        last          ,

                         const std::string& length        ,

                         size_t             maxv          )

     {

       return farray( name, implementation_detail::to_float,

                      std::forward<ITERATOR1>(first), std::forward<ITERATOR2>(last),

                      length, maxv );

     }

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

     template <class DATA>

     StatusCode farray ( const std::string& name          ,

                         const DATA&        data          ,

                         const std::string& length        ,

                         const size_t       maxv          )

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

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

     template <class FUNCTION, class ITERATOR>

     StatusCode farray ( const std::string& name          ,

                         const FUNCTION&    function      ,

                         ITERATOR           first         ,

                         ITERATOR           last          ,

                         const std::string& length        ,

                         size_t             maxv          )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if( std::distance(first,last) > static_cast<std::ptrdiff_t>(maxv) ) {

         Warning("farray('"

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

         last = std::next(first,maxv);

       }


       // get the length item

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

       if( !len  ) { return InvalidColumn ; }


       // adjust the length

       *len = std::distance(first,last);


       // get the array itself

       FArray*  var  = fArray ( name , len ) ;

       if( !var ) { return InvalidColumn ; }


       // fill the array

       std::transform( first, last, std::begin(*var), std::cref(function) );


       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        ,

                         size_t               maxv          )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the lenfth

       if( std::distance(first,last) > static_cast<std::ptrdiff_t>(maxv) )

       {

         Warning("farray('"

                 + name1 + ","

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

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

         last = std::next(first, maxv) ;

       }


       // get the length item

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

       if ( !len  ) { return InvalidColumn ; }


       // adjust the length

       *len = std::distance(first,last);


       // get the array itself

       FArray*  var1  = fArray ( name1 , len ) ;

       if ( !var1 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var2 = fArray ( name2 , len ) ;

       if ( !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        ,

                         size_t             maxv          )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if( (size_t)std::distance(first,last) > maxv )

       {

         Warning("farray('"

                 + name1 + ","

                 + name2 + ","

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

         last = std::next(first,  maxv) ;

       }


       // get the length item

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

       if( !len   ) { return InvalidColumn ; }


       // adjust the length

       *len = std::distance(first,last);


       // get the array itself

       FArray*  var1  = fArray ( name1 , len ) ;

       if( !var1 ) { return InvalidColumn  ; }


       // get the array itself

       FArray*  var2 = fArray ( name2 , len ) ;

       if( !var2 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var3 = fArray ( name3 , len ) ;

       if( !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        ,

                         size_t             maxv          )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if( std::distance(first,last) > static_cast<std::ptrdiff_t>(maxv) )

       {

         Warning("farray('"

                 + name1 + ","

                 + name2 + ","

                 + name3 + ","

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

         last = std::next(first, maxv);

       }


       // get the length item

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

       if( !len  ) { return InvalidColumn ; }


       // adjust the length

       *len = std::distance(first,last);


       // get the array itself

       FArray*  var1  = fArray ( name1 , len ) ;

       if( !var1 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var2 = fArray ( name2 , len ) ;

       if( !var2 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var3 = fArray ( name3 , len ) ;

       if( !var3 ) { return InvalidColumn ; }


       // get the array itself

       FArray*  var4 = fArray ( name4 , len ) ;

       if( !var4 ) { return InvalidColumn ; }


       // fill the array

       size_t index = 0 ;

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

       {

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

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

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

         ( *var4 ) [ index ] = 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  ,

                          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 ( !len  ) { return InvalidColumn; }


       // adjust the length item

       *len = rows ;


       // get the array itself

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

       if ( !var ) { return InvalidColumn ; }


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

       {

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

         { (*var)[ iRow ] [ iCol ] = 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 ,

                          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 ( !len  ) { return InvalidColumn; }


       // adjust the length item

       *len = last - first ;


       // get the array itself

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

       if ( !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 ,

                          size_t             maxv   )

     {

       if ( invalid () ) { return InvalidTuple     ; }

       if ( rowWise () ) { return InvalidOperation ; }


       // adjust the length

       if ( std::distance(first,last) > static_cast<std::ptrdiff_t>(maxv) )

       {

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

         last = std::next(first, maxv) ;

       }


       // get the length item

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

       if ( !len  ) { return InvalidColumn; }


       // adjust the length item

       *len = std::distance(first,last);


       // get the array itself

       auto cols = std::distance(funF,funL);

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

       if ( !var ) { return InvalidColumn ; }


       size_t iRow = 0 ;

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

       {

         //

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

         { (*var)[ iRow ] [ fun - funF ] = (*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!)

       auto length = std::distance(first,last);


       // get the array itself

       FArray* var  = fArray ( name , length ) ;

       if ( !var ) { return InvalidColumn ; }


       std::copy( first, last, std::begin(*var) );


       return StatusCode::SUCCESS ;

     }

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

     template <class ARRAY>

     StatusCode array ( const std::string& name   ,

                        const ARRAY&       data   ,

                        const MIndex&      length )

     {

       using std::begin; // allow data to be eg. CLHEP::HepVector (which does not define HepVector::begin()!,

                         // in which case ADL prefers CLHEP::begin (yah! at least they (now) use a namespace)

                         // so one just to insure  double* CLHEP::begin(CLHEP::HepVector& v) { return &v[0]; }

                         // is visible when this function gets instantiated for CLHEP::HepVector...

       auto first = begin(data);

       return array( name, first, std::next( first, length ) );

     }

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

     template <class ARRAY>

     StatusCode array ( const std::string& name  ,

                        const ARRAY&       data  )

     {

         using std::begin; using std::end;

         return array ( name , begin(data) , end(data) ) ;

     }

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

   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 ( !var ) { return InvalidColumn ; }


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

       {

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

         { (*var)[iRow][iCol] = 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 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 ( !var   ) { return InvalidColumn ; }


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

       {

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

         { (*var)[iRow][iCol] = 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 )

     {

       using Info = std::pair<KEY,VALUE>;

       static const std::array< std::function<float(const Info&)>, 2>

                     fns = { [](const Info& i) { return i.first;  } ,

                             [](const Info& i) { return i.second; } };

       return fmatrix( name,

                       std::begin(fns), std::end(fns),

                       std::begin(info), std::end(info),

                       length,maxv );

     }

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

   public:

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

     template <class TYPE>

     StatusCode put

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

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

   public:

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

     StatusCode write () ;

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

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

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

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

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

     NTuple::Tuple* tuple() { 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 ( std::string name ,

                    std::string type )

     { return m_items.emplace ( std::move(name) , std::move(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 ,

                         unsigned char       minv ,

                         unsigned char       maxv ) ;

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

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

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

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

                           short              minv ,

                           short              maxv ) ;

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

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

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

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

                           unsigned short     minv ,

                           unsigned short     maxv ) ;

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

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

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

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

                           int                minv ,

                           int                maxv ) ;

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

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

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

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

                           unsigned int       minv ,

                           unsigned int       maxv ) ;

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

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

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

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

                           long long          minv ,

                           long long          maxv ) ;

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

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

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

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

                             unsigned long long minv ,

                             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 () = delete;

     TupleObj            ( const TupleObj& ) = delete;

     TupleObj& operator= ( const TupleObj& ) = delete;

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

   private:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   private:

     template <typename T, NTuple::Item<T>* (TupleObj::*fun)(const std::string&), typename UT>

     StatusCode column_(const std::string& name, UT&& value) {

         if ( invalid() ) { return InvalidTuple  ; }

         auto item = (this->*fun)( name );

         if ( !item )     { return InvalidColumn ; }

         *item = std::forward<UT>(value);

         return StatusCode::SUCCESS ;

     }

     template <typename T, NTuple::Item<T>* (TupleObj::*fun)(const std::string&,T,T), typename UT>

     StatusCode column_(const std::string& name, UT&& value, UT&& minv, UT&& maxv) {

         if ( invalid() ) { return InvalidTuple  ; }

         auto item = (this->*fun)( name, std::forward<UT>(minv),std::forward<UT>(maxv) );

         if ( !item )     { return InvalidColumn ; }

         *item = std::forward<UT>(value);

         return StatusCode::SUCCESS ;

     }


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

     std::string            m_name       ;

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

     NTuple::Tuple*         m_tuple      ;

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

     CLID                   m_clid       ;

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

     Tuples::Type           m_type       ;

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

     size_t                 m_refCount   = 0;

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

     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::TruncateValue
Definition: TupleObj.h:93

Tuples::InvalidObject
Definition: TupleObj.h:91

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, size_t maxv)
Put two functions from one data array into LoKi-style N-Tuple simultaneously (effective!) ...
Definition: TupleObj.h:1079

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

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

Tuples::implementation_detail::to_float
Definition: TupleObj.h:65

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

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:36

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

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

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:1803

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, size_t maxv)
Put three functions from one data array into LoKi-style N-Tuple simultaneously (effective!) ...
Definition: TupleObj.h:1165

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

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

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

gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28

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

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

Tuples::implementation_detail::to_::operator()
T operator()(Arg &&i) const
Definition: TupleObj.h:62

GAUDI_API
#define GAUDI_API
Definition: Kernel.h:107

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

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

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

begin
auto begin(reverse_wrapper< T > &w)
Definition: reverse.h:45

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

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

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

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

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

Tuples::InvalidItem
Definition: TupleObj.h:92

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

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

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

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

merge_files.sc
int sc
Definition: merge_files.py:167

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

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

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

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

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

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

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

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

Tuples::InvalidOperation
Definition: TupleObj.h:90

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

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

Tuples::InvalidColumn
Definition: TupleObj.h:89

Tuples::NTUPLE
Definition: TupleObj.h:75

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

Tuples::EVTCOL
Definition: TupleObj.h:76

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

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

Tuples::InvalidTuple
Definition: TupleObj.h:88

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

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

Tuples::implementation_detail::to_
Definition: TupleObj.h:60

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

end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:47

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

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

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:944

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

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

Tuples::TupleObj::column_
StatusCode column_(const std::string &name, UT &&value)
Definition: TupleObj.h:2238

StatusCode::FAILURE
Definition: StatusCode.h:29

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:2319

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

implementation_detail
Definition: CommonMessaging.h:43

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

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

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

StatusCode::SUCCESS
Definition: StatusCode.h:30

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

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, size_t maxv)
Put four functions from one data array into LoKi-style N-Tuple simultaneously (effective!) ...
Definition: TupleObj.h:1260

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

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

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

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

GaudiUtils::HashMap
Common class providing an architecture-independent hash map.
Definition: HashMap.h:77

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

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

Tuples::TupleObj::column_
StatusCode column_(const std::string &name, UT &&value, UT &&minv, UT &&maxv)
Definition: TupleObj.h:2246

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

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

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

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

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

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

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

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

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

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

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

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:1702

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

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

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

ana.i
list i
Definition: ana.py:128

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

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

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

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

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

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

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

gaudirun.type
string type
Definition: gaudirun.py:151

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

Tuples
General namespace for Tuple properties.
Definition: Maps.h:34