TupleObj.h

Go to the documentation of this file.

// $Id: TupleObj.h,v 1.23 2008/10/27 19:22:20 marcocle Exp $
// ============================================================================
// CVS tag $Name: v11r2 $, 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 TupleObj
  {
  public:
    // ========================================================================
    typedef NTuple::Item<int>                   Int       ;
    // ========================================================================
    typedef NTuple::Item<float>                 Float     ;
    // ========================================================================
    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 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 int            value )
    {
      if ( invalid() ) { return InvalidTuple  ; }
      Int* item = ints( name ) ;
      if ( 0 == item ) { return InvalidColumn ; }
      *item = value ;
      return StatusCode::SUCCESS ;
    }
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const int            value ,
                        const int            minv  ,
                        const int            maxv  )
    {
      if ( invalid() ) { return InvalidTuple  ; }
      Int* item = ints ( name , minv , maxv ) ;
      if ( 0 == item ) { return InvalidColumn ; }
      *item = value ;
      return StatusCode::SUCCESS ;
    }
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned int   value )
    {
      StatusCode sc1 = StatusCode::SUCCESS ;
      static const unsigned int s_max = std::numeric_limits<int>::max() ;
      if ( s_max < value )
      { sc1 = Warning
          (" column('" + name + "'): truncate unsigned int" , TruncateValue ) ; }
      const int val = (int) value ;
      StatusCode sc2 = column ( name , val ) ;
      return sc2.isFailure() ? sc2 : sc1 ;
    }
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const long           value )
    {
      StatusCode sc1 = StatusCode::SUCCESS ;
      if ( sizeof(int) != sizeof(long)
           && ( std::numeric_limits<int>::max() < value ||
                std::numeric_limits<int>::min() > value ) )
      { sc1 = Warning (" column('" + name + "'): truncate long value" ,
                       TruncateValue ) ; }
      const int val = (int) value ;
      StatusCode sc2 = column ( name , val ) ;
      return sc2.isFailure() ? sc2 : sc1 ;
    }
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned long  value )
    {
      StatusCode sc1 = StatusCode::SUCCESS ;
      static const unsigned long s_max = std::numeric_limits<int>::max()  ;
      if ( sizeof (int) != sizeof (unsigned long) && s_max < value )
      { sc1 = Warning (" column('" + name + "'): truncate unsigned long value" ,
                       TruncateValue ) ; }
      const int val = (int) value ;
      StatusCode sc2 = column ( name , val ) ;
      return sc2.isFailure() ? sc2 : sc1 ;
    }
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const short          value )
    {
      return column
        ( name  ,
          value ,
          std::numeric_limits<short>::min() ,
          std::numeric_limits<short>::max() ) ;
    }
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned short value )
    {
      return column
        ( name  ,
          value ,
          std::numeric_limits<unsigned short>::min() ,
          std::numeric_limits<unsigned short>::max() ) ;
    }
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const char           value )
    {
      return column
        ( name  ,
          value ,
          std::numeric_limits<char>::min() ,
          std::numeric_limits<char>::max() ) ;
    }
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned char  value )
    {
      return column
        ( name  ,
          value ,
          std::numeric_limits<unsigned char>::min() ,
          std::numeric_limits<unsigned char>::max() ) ;
    }
    // ========================================================================
    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 float        value  )
    {
      if ( invalid() ) { return InvalidTuple  ; }
      Float* item = floats ( name ) ;
      if ( 0 == item ) { return InvalidColumn ; }
      *item = value ;
      return StatusCode::SUCCESS ;
    }
    // ========================================================================
    StatusCode column ( const std::string& name   ,
                        const double       value  )
    {
      StatusCode sc1 = StatusCode::SUCCESS ;
      static const double s_max =      std::numeric_limits<float>::max() ;
      static const double s_min = -1 * std::numeric_limits<float>::max() ;
      if ( s_max < value || s_min > value  )
      { sc1 = Warning (" column('" + name + "'): truncate double value " ,
                       TruncateValue ) ; }
      const float val = (float) value ;
      StatusCode sc2 = column ( name , val ) ;
      return sc2.isFailure() ? sc2 : sc1 ;
    }
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        const bool         value )
    {
      const int val = value ;
      return column ( name , val , 0 , 1 ) ;
    }
    // ========================================================================
  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") ;
        Warning(" farray('"+name1+"'): 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
      *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 lenfth
      if( first + maxv < last )
      {
        Warning(" farray('"
                + name1 + ","
                + name2 + ","
                + name3 + "'): 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*  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 lenfth
      if( first + maxv < last )
      {
        Warning(" farray('"
                + name1 + ","
                + name2 + ","
                + name3 + ","
                + name4 + "'): 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*  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") ;
        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") ;
        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") ;
        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 , D1 , 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 0 == tuple() ; }
    // =======================================================================
  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:
    // =======================================================================
    Float*   floats     ( const std::string& name );
    // =======================================================================
    Int*     ints       ( const std::string& name );
    // =======================================================================
    Int*     ints       ( const std::string& name ,
                          const int          minv ,
                          const int          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,Int*>    Ints;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,Float*>   Floats;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,Address*> Addresses;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,FArray*>  FArrays;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,FMatrix*> FMatrices;
    // =======================================================================
  private:
    // =======================================================================
    // name
    std::string            m_name       ;  
    // =======================================================================
    // tuple itself
    NTuple::Tuple*         m_tuple      ; 
    // =======================================================================
    // tuple CLID
    CLID                   m_clid       ; 
    // =======================================================================
    // tuple 'type'
    Tuples::Type           m_type       ; 
    // =======================================================================
    // reference counter
    size_t                 m_refCount   ; 
    // =======================================================================
    // the actual storage of all 'Int'    columns
    mutable Ints           m_ints      ; 
    // =======================================================================
    // the actual storage of all 'Float'   columns
    mutable Floats         m_floats     ; 
    // =======================================================================
    // the actual storage of all 'Address' columns
    mutable Addresses      m_addresses  ; 
    // =======================================================================
    // the actual storage of all 'FArray'  columns
    mutable FArrays        m_farrays    ; 
    // =======================================================================
    // the actual storage of all 'FArray'  columns (fixed)
    mutable FArrays        m_arraysf    ; 
    // =======================================================================
    // the actual storage of all 'FArray'  columns
    mutable FMatrices      m_fmatrices  ; 
    // =======================================================================
    // the actual storage of all 'FMatrix' columns (fixed)
    mutable FMatrices      m_matricesf  ; 
    // =======================================================================
    // all booked types:
    ItemMap                m_items      ; 
    // =======================================================================
  } ;
  // ==========================================================================
} // end of namespace Tuples
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/TuplePut.h"
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_TUPLEOBJ_H
// ============================================================================