A simple wrapper class over standard Gaudi NTuple::Tuple facility. More...

#include <GaudiAlg/TupleObj.h>

Inheritance diagram for Tuples::TupleObj:

Collaboration diagram for Tuples::TupleObj:

[legend]

Public Types
typedef NTuple::Item< bool >	Bool
	basic type for int items More...

typedef NTuple::Item< char >	Char
	basic type for int items More...

typedef NTuple::Item< unsigned char >	UChar
	basic type for unsigned int items More...

typedef NTuple::Item< short >	Short
	basic type for int items More...

typedef NTuple::Item< unsigned short >	UShort
	basic type for unsigned int items More...

typedef NTuple::Item< int >	Int
	basic type for int items More...

typedef NTuple::Item< unsigned int >	UInt
	basic type for unsigned int items More...

typedef NTuple::Item< long long >	LongLong
	basic type for unsigned long long items More...

typedef NTuple::Item< unsigned long long >	ULongLong
	basic type for unsigned long long items More...

typedef NTuple::Item< float >	Float
	basic type for float items More...

typedef NTuple::Item< double >	Double
	basic type for double items More...

typedef NTuple::Item< IOpaqueAddress * >	Address
	basic type for address items More...

typedef NTuple::Array< float >	FArray
	basic type for array of floats More...

typedef NTuple::Matrix< float >	FMatrix
	basic type for matrix of floats More...

typedef unsigned short	MIndex

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

Public Member Functions
virtual	~TupleObj ()

StatusCode	column (const std::string &name, float value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, double value)
	Set the value for the selected tuple column If the column does not exist, it will be automatically created and appended to the tuple. More...

StatusCode	column (const std::string &name, short value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, short value, short minv, short maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned short value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned short value, unsigned short minv, unsigned short maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, char value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, char value, char minv, char maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned char value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned char value, unsigned char minv, unsigned char maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, int value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, int value, int minv, int maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned int value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned int value, unsigned int minv, unsigned int maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, long value)
	Set the value for the selected tuple column. More...

StatusCode	column (const std::string &name, long value, long minv, long maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned long value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned long value, unsigned long minv, unsigned long maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, long long value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, long long value, long long minv, long long maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned long long value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, unsigned long long value, unsigned long long minv, unsigned long long maxv)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, signed char value)
	Set the value for the selected tuple column. More...

StatusCode	column (const std::string &name, bool value)
	Set the value for selected tuple column. More...

StatusCode	column (const std::string &name, IOpaqueAddress *address)
	Put IOpaqueAddress in POOL-based NTuple. More...

StatusCode	column (IOpaqueAddress *address)
	Put IOpaqueAddress in NTuple. More...

template<typename Value , typename... Args>
StatusCode	columns (Value &&value, Args &&...args)
	Set the values for several columns simultaneously, for the same object Non-existing columns will be automatically created and appended to the ntuple. More...

StatusCode	fill (const char *format...)
	Set the values for several columns simultaneously. More...

template<typename ITERATOR1 , typename ITERATOR2 >
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. More...

template<class DATA >
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. More...

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)
	Put an indexed array into LoKi-style N-Tuple. More...

template<typename FunIterator , typename DataIterator >
StatusCode	farray_impl (FunIterator first_item, FunIterator last_item, DataIterator first, DataIterator last, const std::string &length, size_t maxv)
	Put arbitrary number of functions from one data array into LoKi-style N-Tuple simultaneously (effective!) More...

template<typename DataIterator , template< typename, typename... > class Container = std::initializer_list, typename NamedFunction = std::pair<std::string, std::function<float( detail::const_ref_t<DataIterator> )>>, typename = std::enable_if_t<!std::is_convertible<Container<NamedFunction>, std::string>::value>>
StatusCode	farray (const Container< NamedFunction > &funs, DataIterator first, DataIterator last, const std::string &length, size_t maxv)

template<typename NamedFunctions , typename DataIterator , typename = std::enable_if_t<!std::is_convertible<NamedFunctions, std::string>::value>>
StatusCode	farray (const NamedFunctions &funs, DataIterator first, DataIterator last, const std::string &length, size_t maxv)

template<class FUNC1 , class FUNC2 , class Iterator >
StatusCode	farray (const std::string &name1, const FUNC1 &func1, const std::string &name2, const FUNC2 &func2, Iterator &&first, Iterator &&last, const std::string &length, size_t maxv)
	Put two functions from one data array into LoKi-style N-Tuple simultaneously (effective!) More...

template<class FUNC1 , class FUNC2 , class FUNC3 , class Iterator >
StatusCode	farray (const std::string &name1, const FUNC1 &func1, const std::string &name2, const FUNC2 &func2, const std::string &name3, const FUNC3 &func3, Iterator &&first, Iterator &&last, const std::string &length, size_t maxv)
	Put three functions from one data array into LoKi-style N-Tuple simultaneously (effective!) More...

template<class FUNC1 , class FUNC2 , class FUNC3 , class FUNC4 , class Iterator >
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, Iterator &&first, Iterator &&last, const std::string &length, size_t maxv)
	Put four functions from one data array into LoKi-style N-Tuple simultaneously (effective!) More...

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)
	Fill N-Tuple with data from variable-size matrix. More...

template<class DATA >
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. More...

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)
	fill N-Tuple with matrix of "direct-product" of "data-vector" [first,last) and "function-vector" [funF, funL) More...

template<class DATA >
StatusCode	array (const std::string &name, DATA first, DATA last)
	fill N-Tuple with fixed-size array More...

template<class ARRAY >
StatusCode	array (const std::string &name, const ARRAY &data, const MIndex &length)
	fill N-Tuple with fixed-size array More...

template<class ARRAY >
StatusCode	array (const std::string &name, const ARRAY &data)
	fill N-Tuple with fixed-size array More...

template<class MATRIX >
StatusCode	matrix (const std::string &name, const MATRIX &data, const MIndex &rows, const MIndex &cols)
	fill N-Tuple with fixed-size matrix More...

template<class TYPE >
StatusCode	column (const std::string &name, const ROOT::Math::LorentzVector< TYPE > &v)
	Useful shortcut to put LorentzVector directly into N-Tuple: More...

template<class TYPE , class TAG >
StatusCode	column (const std::string &name, const ROOT::Math::DisplacementVector3D< TYPE, TAG > &v)
	Useful shortcut to put 3D-Vector directly into N-Tuple: More...

template<class TYPE , class TAG >
StatusCode	column (const std::string &name, const ROOT::Math::PositionVector3D< TYPE, TAG > &v)
	Useful shortcut to put 3D-Vector directly into N-Tuple: More...

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)
	shortcut to put Smatrix into N-tuple: More...

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)
	shortcut to put "ExtraInfo" fields of major into N-Tuple More...

template<class TYPE >
StatusCode	put (const std::string &name, const TYPE *obj)
	The function allows to add almost arbitrary object into N-tuple. More...

StatusCode	write ()
	write a record to NTuple More...

const std::string &	name () const
	get the name More...

const NTuple::Tuple *	tuple () const
	provide the access to underlying Gaudi N-tuple More...

NTuple::Tuple *	tuple ()
	provide the access to underlying Gaudi N-tuple More...

const CLID &	clid () const
	accessor to the N-Tuple CLID More...

Tuples::Type	type () const
	accessor to the N-Tuple type More...

bool	columnWise () const
	column wise NTuple ? More...

bool	rowWise () const
	row wise NTuple ? More...

bool	evtColType () const
	Event collection ? More...

bool	valid () const
	valid pointer to tuple ? More...

bool	invalid () const
	invalid pointer to tuple ? More...

bool	addItem (std::string name, std::string type)
	add the item name into the list of known items More...

bool	goodItem (const std::string &name) const
	check the uniqueness of the name More...

const ItemMap &	items () const
	get the full list of booked items More...

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

Protected Member Functions
	TupleObj (std::string name, NTuple::Tuple *tuple, const CLID &clid=CLID_ColumnWiseTuple, const Tuples::Type type=Tuples::NTUPLE)
	Standard constructor. More...

Private Types
template<typename T >
using	ColumnStorage = GaudiUtils::HashMap< std::string, std::unique_ptr< T >>

Private Member Functions
Int *	ints (const std::string &name, int minv, int maxv)
	get the column More...

FArray *	fArray (const std::string &name, Int *item)
	get the column More...

FArray *	fArray (const std::string &name, const MIndex &rows)
	get the column More...

Address *	addresses (const std::string &name)
	get the column More...

FMatrix *	fMatrix (const std::string &name, Int *item, const MIndex &cols)
	get the column More...

FMatrix *	fMatrix (const std::string &name, const MIndex &rows, const MIndex &cols)
	get the column More...

	TupleObj (const TupleObj &)=delete
	delete the copy constructor and assignment More...

TupleObj &	operator= (const TupleObj &)=delete

Private Attributes
std::string	m_name
	name More...

NTuple::Tuple *	m_tuple
	tuple itself More...

CLID	m_clid
	tuple CLID More...

Tuples::Type	m_type
	tuple 'type' More...

size_t	m_refCount = 0
	reference counter More...

ColumnStorage< Bool >	m_bools
	the actual storage of all 'bool' columns More...

ColumnStorage< Char >	m_chars
	the actual storage of all 'Int' columns More...

ColumnStorage< UChar >	m_uchars
	the actual storage of all 'unsigned int' columns More...

ColumnStorage< Short >	m_shorts
	the actual storage of all 'Int' columns More...

ColumnStorage< UShort >	m_ushorts
	the actual storage of all 'unsigned int' columns More...

ColumnStorage< Int >	m_ints
	the actual storage of all 'Int' columns More...

ColumnStorage< UInt >	m_uints
	the actual storage of all 'unsigned int' columns More...

ColumnStorage< LongLong >	m_longlongs
	the actual storage of all 'long long' columns More...

ColumnStorage< ULongLong >	m_ulonglongs
	the actual storage of all 'unsigned long long' columns More...

ColumnStorage< Float >	m_floats
	the actual storage of all 'Float' columns More...

ColumnStorage< Double >	m_doubles
	the actual storage of all 'Double' columns More...

ColumnStorage< Address >	m_addresses
	the actual storage of all 'Address' columns More...

ColumnStorage< FArray >	m_farrays
	the actual storage of all 'FArray' columns More...

ColumnStorage< FArray >	m_arraysf
	the actual storage of all 'FArray' columns (fixed) More...

ColumnStorage< FMatrix >	m_fmatrices
	the actual storage of all 'FArray' columns More...

ColumnStorage< FMatrix >	m_matricesf
	the actual storage of all 'FMatrix' columns (fixed) More...

ItemMap	m_items
	all booked types: More...

Detailed Description

A simple wrapper class over standard Gaudi NTuple::Tuple facility.

The design and implementation are imported from LoKi package

One should not use lass TupleObj directly. The special handler Tuples::Tuple should be used instead, which is simultaneously 'proxy' an d'smart pointer' for real (and heavy!) TupleObj class.

The main advantages of local ntuples with respect to 'standard' Gaudi NTuples ( NTuple::Tuple ) is their "locality". For 'standard' ntuples one need

Define all ntuple columns/items as data members of the algorithm
Book the NTuple::Tuple object using INTupleSvc
Add all defined columns/items to the booked ntuple
Fill ntuple records

Usually the first step is done in the header file (separate file!) of the algorithm, the second and the third steps are done in initialize() method of the algorithm and the fourth step is done somewhere in execute() method of the same algorithm. Such approach requires to keep track of the tuple structure through different method and event through different files. And even minor modification of the structure of the ntuple will require the modification of at least 2 methods and 2 files.

The Tuples::Tuple wrapper over standard Gaudi NTuple::Tuple class solves all above listed problems with "non-local" nature of Gaudi NTuple::Tuple objects.

Tuples::Tuple object is booked and used 'locally'. One does not need to pre-book the ntuple or its columns/items somewhere in different compilation units or other methods different from the actual point of using the ntuple.

The simplest example of usage Tuples::Tuple object:

Tuple tuple = nTuple( "some more or less unique tuple title ");
for( Loop D0 = loop( "K- pi+", "D0" ) , D0 , ++D0 )
{
   tuple -> column ( "mass" , M  ( D0 ) / GeV ) ;
   tuple -> column ( "pt"   , PT ( D0 ) / GeV ) ;
   tuple -> column ( "p"    , P  ( D0 ) / GeV ) ;
   tuple -> write  () ;
}

One could fill some Tuple variables in one go

Tuple tuple = nTuple( "some more or less unique tuple title ");
for( Loop D0 = loop( "K- pi+", "D0" ) , D0 , ++D0 )
{
   tuple -> column ( "mass"      , M  ( D0 ) / GeV ) ;
   tuple -> fill   ( "pt , p "   , PT ( D0 ) / GeV , P(D0) / GeV ) ;
   tuple -> write  () ;
}

Even ALL variables could be filled in one go:

Tuple tuple = nTuple( "some more or less unique tuple title ");
for( Loop D0 = loop( "K- pi+", "D0" ) , D0 , ++D0 )
{
   tuple -> fill   ( "mass pt , p ", M(D0)/GeV,PT(D0)/GeV,P(D0)/GeV ) ;
   tuple -> write  () ;
}

The 'array-like' columns are also supported ( see methods 'farray')

All these techniques could be easily combined in arbitrary ways

class TupleObj is an abstract class with 3 pure abstract functions Error and Warning , which need to be reimplemented in any 'concrete class. Helper classes TupleObjImp, ErrorHandler and functions createTupleObj and make_handler allows to create concrete objects 'on-flight'

Attention: long long and unsigned long long types are not supported. One needs to convert the data into some other representation (e.g. as 2 separate fields, or perform the explicitly cast to long)

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2004-01-23

Definition at line 200 of file TupleObj.h.

Member Typedef Documentation

typedef NTuple::Item<IOpaqueAddress*> Tuples::TupleObj::Address

basic type for address items

Definition at line 237 of file TupleObj.h.

typedef NTuple::Item<bool> Tuples::TupleObj::Bool

basic type for int items

Definition at line 204 of file TupleObj.h.

typedef NTuple::Item<char> Tuples::TupleObj::Char

basic type for int items

Definition at line 207 of file TupleObj.h.

template<typename T >

using Tuples::TupleObj::ColumnStorage = GaudiUtils::HashMap<std::string, std::unique_ptr<T>>

private

Definition at line 1949 of file TupleObj.h.

typedef NTuple::Item<double> Tuples::TupleObj::Double

basic type for double items

Definition at line 234 of file TupleObj.h.

typedef NTuple::Array<float> Tuples::TupleObj::FArray

basic type for array of floats

Definition at line 240 of file TupleObj.h.

typedef NTuple::Item<float> Tuples::TupleObj::Float

basic type for float items

Definition at line 231 of file TupleObj.h.

typedef NTuple::Matrix<float> Tuples::TupleObj::FMatrix

basic type for matrix of floats

Definition at line 243 of file TupleObj.h.

typedef NTuple::Item<int> Tuples::TupleObj::Int

basic type for int items

Definition at line 219 of file TupleObj.h.

typedef std::map<std::string, std::string> Tuples::TupleObj::ItemMap

Definition at line 249 of file TupleObj.h.

typedef NTuple::Item<long long> Tuples::TupleObj::LongLong

basic type for unsigned long long items

Definition at line 225 of file TupleObj.h.

typedef unsigned short Tuples::TupleObj::MIndex

Definition at line 246 of file TupleObj.h.

typedef NTuple::Item<short> Tuples::TupleObj::Short

basic type for int items

Definition at line 213 of file TupleObj.h.

typedef NTuple::Item<unsigned char> Tuples::TupleObj::UChar

basic type for unsigned int items

Definition at line 210 of file TupleObj.h.

typedef NTuple::Item<unsigned int> Tuples::TupleObj::UInt

basic type for unsigned int items

Definition at line 222 of file TupleObj.h.

typedef NTuple::Item<unsigned long long> Tuples::TupleObj::ULongLong

basic type for unsigned long long items

Definition at line 228 of file TupleObj.h.

typedef NTuple::Item<unsigned short> Tuples::TupleObj::UShort

basic type for unsigned int items

Definition at line 216 of file TupleObj.h.

Constructor & Destructor Documentation

Tuples::TupleObj::TupleObj	(	std::string	name,
		NTuple::Tuple *	tuple,
		const CLID &	clid = `CLID_ColumnWiseTuple`,
		const Tuples::Type	type = `Tuples::NTUPLE`
	)

protected

Standard constructor.

See also: NTuple:Tuple

Parameters

name	name of the object
tuple	pointer to standard Gaudi NTuple::Tuple object
clid	CLID_ColumnWiseTuple or CLID_RowWiseTuple
type	the type of the tuple

Definition at line 213 of file TupleObj.cpp.

     : m_name( std::move( name ) ), m_tuple( tuple ), m_clid( clid ), m_type( type ) {
   // make counts
   Tuples::Local::s_InstanceCounter.increment( m_name );
 }

Tuples::TupleObj::~TupleObj ( )

virtual

Definition at line 222 of file TupleObj.cpp.

                           {
   // make counts
   Tuples::Local::s_InstanceCounter.decrement( m_name );
 }

Tuples::TupleObj::TupleObj ( const TupleObj & )

privatedelete

delete the copy constructor and assignment

Member Function Documentation

bool Tuples::TupleObj::addItem	(	std::string	name,
		std::string	type
	)

inline

add the item name into the list of known items

Parameters

name	the name of the item
type	the type of the item

Returns: true if the name is indeed added

Definition at line 1887 of file TupleObj.h.

                                                    {
       return m_items.emplace( std::move( name ), std::move( type ) ).second;
     }

Address* Tuples::TupleObj::addresses ( const std::string & name )

private

get the column

template<class DATA >

StatusCode Tuples::TupleObj::array	(	const std::string &	name,
		DATA	first,
		DATA	last
	)

inline

fill N-Tuple with fixed-size array

SEQUENCE  data( 10 ) ;
...
tuple -> array("data"         ,
                data.begin () ,
                data.end   () ) ;

Sequence may be of any objects, implicitly convertible into "float"

Parameters

name	N-Tuple entry name
first	begin-iterator for data sequence
last	end-iterator for data sequence

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@l.nosp@m.app..nosp@m.in2p3.nosp@m..fr

Date: 2005-05-01

fill the array

Definition at line 1534 of file TupleObj.h.

     {
       if ( invalid() ) return ErrorCodes::InvalidTuple;
       if ( rowWise() ) return ErrorCodes::InvalidOperation;
 
       // get the length (fixed!)
       auto length = std::distance( first, last );
 
       // get the array itself
       FArray* var = fArray( name, length );
       if ( !var ) return ErrorCodes::InvalidColumn;
 
       std::copy( first, last, std::begin( *var ) );
 
       return StatusCode::SUCCESS;
     }

template<class ARRAY >

StatusCode Tuples::TupleObj::array	(	const std::string &	name,
		const ARRAY &	data,
		const MIndex &	length
	)

inline

fill N-Tuple with fixed-size array

"ARRAY" must support indexing operations: e.g it coudl be of type:

std::vector<TYPE>
CLHEP::HepVector, ...
"TYPE"[n]

The content of array should be implicitly convertible to "float"

CLHEP::HepVector vct1(10) ;
...
tuple -> array ( "vct1" , vct1 , 10 ) ;
double vct2[40];
...
tuple -> array ( "vct2" , vct2 , 40 ) ;
long   vct3[4];
...
tuple -> array ( "vct3" , vct4 ,  4 ) ;
std::vector<long double> vct4(15) ;
...
tuple -> array ( "vct4" , vct4 , 15 ) ;

Parameters

name	N-Tuple entry name
data	data sequence
length	data length (fixed!)

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@l.nosp@m.app..nosp@m.in2p3.nosp@m..fr

Date: 2005-05-01

Definition at line 1592 of file TupleObj.h.

                                                                                        {
       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 Tuples::TupleObj::array	(	const std::string &	name,
		const ARRAY &	data
	)

inline

fill N-Tuple with fixed-size array

"ARRAY" is any sequence, which supports ARRAY::begin() and ARRAY::end() protocol, e.g.

std::vector<TYPE>
ROOT::Math::SVector<double,15>

The content of array should be implicitly convertible to "float"

 typedef std::vector<double> Seq ;
 Seq data( 10 ) ;
 for ( int i = 0 ; i < 10 ; ++i )
  {
    data[i] = ... ;
  }
tuple -> array( "data" , data ) ;

Parameters

name	N-Tupel entry name
data	data sequence

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@l.nosp@m.app..nosp@m.in2p3.nosp@m..fr

Date: 2005-05-01

Definition at line 1632 of file TupleObj.h.

                                                                  {
       using std::begin;
       using std::end;
       return array( name, begin( data ), end( data ) );
     }

const CLID& Tuples::TupleObj::clid ( ) const

inline

accessor to the N-Tuple CLID

Definition at line 1860 of file TupleObj.h.

1860 { return m_clid; }

Tuples::TupleObj::m_clid

CLID m_clid

tuple CLID

Definition: TupleObj.h:1939

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		float	value
	)

Set the value for selected tuple column.

If column does not exist, it will be automatically created and appended to the tuple

//
const float mass = ... ;
tuple->column( "m", mass );
//

Parameters

name	the name of the column
value	the value of the variable

Returns: status code

Definition at line 292 of file TupleObj.cpp.

                                                                       {
   return column_( this, m_floats, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		double	value
	)

Set the value for the selected tuple column If the column does not exist, it will be automatically created and appended to the tuple.

//
const double mass = ... ;
tuple->column( "m", mass );
//

Warning: the value is truncated to float

Parameters

name	the name of the column
value	the value of the variable

Returns: status code

Definition at line 296 of file TupleObj.cpp.

                                                                        {
   return column_( this, m_doubles, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		short	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

short number = ... ;

tuple -> column ( "num" , number );

Parameters

name	the name of the column
value	the value of the variable

Returns: status code

Definition at line 317 of file TupleObj.cpp.

                                                                       {
   return column_( this, m_shorts, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		short	value,
		short	minv,
		short	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

short number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 321 of file TupleObj.cpp.

                                                                                                                 {
   return column_( this, m_shorts, name, value, minv, maxv );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned short	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned short number = ... ;

tuple -> column ( "num" , number );

Parameters

name	the name of the column
value	the value of the variable

Returns: status code

Definition at line 325 of file TupleObj.cpp.

                                                                                      {
   return column_( this, m_ushorts, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned short	value,
		unsigned short	minv,
		unsigned short	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned short number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 329 of file TupleObj.cpp.

                                                            {
   return column_( this, m_ushorts, name, value, minv, maxv );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		char	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

char number = ... ;

tuple -> column ( "num" , number );

Parameters

name	the name of the column
value	the value of the variable

Returns: status code

Definition at line 300 of file TupleObj.cpp.

                                                                      {
   return column_( this, m_chars, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		char	value,
		char	minv,
		char	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

char number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 304 of file TupleObj.cpp.

                                                                                            {
   return column_( this, m_chars, name, value, minv, maxv );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned char	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned char number = ... ;

tuple -> column ( "num" , number );

Parameters

name	the name of the column
value	the value of the variable

Returns: status code

Definition at line 308 of file TupleObj.cpp.

                                                                               {
   return column_( this, m_uchars, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned char	value,
		unsigned char	minv,
		unsigned char	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned char number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 312 of file TupleObj.cpp.

                                                           {
   return column_( this, m_uchars, name, value, minv, maxv );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		int	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

int number = ... ;

tuple->column("num", number );

Parameters

name	name of the column
value	value of the variable

Returns: status code

Definition at line 334 of file TupleObj.cpp.

                                                                     {
   return column_( this, m_ints, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		int	value,
		int	minv,
		int	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

int number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 338 of file TupleObj.cpp.

                                                                                         {
   return column_( this, m_ints, name, value, minv, maxv );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned int	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned int number = ... ;

tuple->column("num", number );

Parameters

name	name of the column
value	value of the variable

Returns: status code

Definition at line 346 of file TupleObj.cpp.

                                                                              {
   return column_( this, m_uints, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned int	value,
		unsigned int	minv,
		unsigned int	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned int number = ... ;

tuple->column("num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 350 of file TupleObj.cpp.

                                                          {
   return column_( this, m_uints, name, value, minv, maxv );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		long	value
	)

Set the value for the selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

long number = ... ;

tuple -> column ( "num", number );

Warning: the value could be truncated to int

Parameters

name	the name of the column
value	the value of the variable

Returns: status code

Definition at line 355 of file TupleObj.cpp.

                                                                            {
   Warning( "'long' has different sizes on 32/64 bit systems. Casting '" + name + "' to 'long long'",
            StatusCode::SUCCESS )
       .ignore();
   return column( name, static_cast<long long>( value ) );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		long	value,
		long	minv,
		long	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

long number = ... ;

tuple->column("num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 362 of file TupleObj.cpp.

                                                                                                              {
   Warning( "'long' has different sizes on 32/64 bit systems. Casting '" + name + "' to 'long long'",
            StatusCode::SUCCESS )
       .ignore();
   return column( name, static_cast<long long>( value ), static_cast<long long>( minv ),
                  static_cast<long long>( maxv ) );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned long	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned long number = ... ;

tuple -> column ( "num" , number );

Warning: the value could be truncated to int

Parameters

name	the name of the column
value	the value of the variable

Returns: status code

Definition at line 370 of file TupleObj.cpp.

                                                                                     {
   Warning( "'unsigned long' has different sizes on 32/64 bit systems. Casting '" + name + "' to 'unsigned long long'",
            StatusCode::SUCCESS )
       .ignore();
   return column( name, static_cast<unsigned long long>( value ) );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned long	value,
		unsigned long	minv,
		unsigned long	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned long number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 377 of file TupleObj.cpp.

                                                                 {
   Warning( "'unsigned long' has different sizes on 32/64 bit systems. Casting '" + name + "' to 'unsigned long long'",
            StatusCode::SUCCESS )
       .ignore();
   return column( name, static_cast<unsigned long long>( value ), static_cast<unsigned long long>( minv ),
                  static_cast<unsigned long long>( maxv ) );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		long long	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

long long number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable

Returns: status code

Definition at line 386 of file TupleObj.cpp.

                                                                                 {
   return column_( this, m_longlongs, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		long long	value,
		long long	minv,
		long long	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

long long number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 390 of file TupleObj.cpp.

                                                                                                           {
   return column_( this, m_longlongs, name, value, minv, maxv );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned long long	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned long long number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable

Returns: status code

Definition at line 394 of file TupleObj.cpp.

                                                                                    {
   return column_( this, m_ulonglongs, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		unsigned long long	value,
		unsigned long long	minv,
		unsigned long long	maxv
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

unsigned long long number = ... ;

tuple->column( "num", number );

Parameters

name	name of the column
value	value of the variable
minv	minimum value of the variable
maxv	maximum value of the variable

Returns: status code

Definition at line 398 of file TupleObj.cpp.

                                                                {
   return column_( this, m_ulonglongs, name, value, minv, maxv );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		signed char	value
	)

inline

Set the value for the selected tuple column.

If the column does not exist yet, it will be automatically created and appended to the tuple

signed char number = ... ;

tuple->column("num", number );

Parameters

name	the name of the column
value	the value of tve variable

Returns: status code

Definition at line 704 of file TupleObj.h.

                                                                   {
       return column( name, value, std::numeric_limits<signed char>::min(), std::numeric_limits<signed char>::max() );
     }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		bool	value
	)

Set the value for selected tuple column.

If the column does not exist yet, it will be automatically create and appended to the tuple

tuple->column( "empty" , v.empty() );

Parameters

name	the name of the column
value	the value of the variable

Returns: status code

Definition at line 403 of file TupleObj.cpp.

                                                                      {
   return column_( this, m_bools, name, value );
 }

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		IOpaqueAddress *	address
	)

Put IOpaqueAddress in POOL-based NTuple.

If the column does not exist, it will be automatically created and appended to the tuple.

IOpaqueAddress* address = ... ;

tuple->column( "Address", address );

Warning: It has sense only for Event tag collection N-Tuples

Parameters

name	name of the column ("Address" is a recommended convention!)
address	IOpaqueAddress

Returns: status code

Definition at line 280 of file TupleObj.cpp.

                                                                                   {
   if ( !evtColType() ) return ErrorCodes::InvalidOperation;
   if ( !address ) return Error( "column('" + name + "') IOpaqueAddress* is NULL!", ErrorCodes::InvalidObject );
   return column_( this, m_addresses, name, address );
 }

StatusCode Tuples::TupleObj::column ( IOpaqueAddress * address )

Put IOpaqueAddress in NTuple.

If the column does not exist, it will be automatically created and appended to the tuple. The column name is set to be "Address"

IOpaqueAddress* address = ... ;

tuple->column ( address );

Warning: It has sense only for Event tag collection N-Tuples

Parameters

address IOpaqueAddress

Returns: status code

Definition at line 289 of file TupleObj.cpp.

289 { return column( "Address", address ); }

Tuples::TupleObj::column

StatusCode column(const std::string &name, float value)

Set the value for selected tuple column.

Definition: TupleObj.cpp:292

template<class TYPE >

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		const ROOT::Math::LorentzVector< TYPE > &	v
	)

inline

Useful shortcut to put LorentzVector directly into N-Tuple:

const LHCb::Particle* B = ...
Tuple tuple = nTuple("My N-Tuple") ;
// put 4-vector of B-candidate into N-tuple:
tuple -> column ("B" , B->momentum() ) ;

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-11-26

Definition at line 1723 of file TupleObj.h.

                                                                                      {
       return columns( v, std::make_pair( name + "E", &ROOT::Math::LorentzVector<TYPE>::E ),
                       std::make_pair( name + "X", &ROOT::Math::LorentzVector<TYPE>::Px ),
                       std::make_pair( name + "Y", &ROOT::Math::LorentzVector<TYPE>::Py ),
                       std::make_pair( name + "Z", &ROOT::Math::LorentzVector<TYPE>::Pz ) );
     }

template<class TYPE , class TAG >

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		const ROOT::Math::DisplacementVector3D< TYPE, TAG > &	v
	)

inline

Useful shortcut to put 3D-Vector directly into N-Tuple:

const LHCb::Vertex* V = ...
Tuple tuple = nTuple("My N-Tuple") ;
// put vertex position into N-tuple:
tuple -> column ("B" , B->position() ) ;

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-11-26

Definition at line 1747 of file TupleObj.h.

                                                                                                  {
       return this->columns( v, std::make_pair( name + "X", &ROOT::Math::DisplacementVector3D<TYPE, TAG>::X ),
                             std::make_pair( name + "Y", &ROOT::Math::DisplacementVector3D<TYPE, TAG>::Y ),
                             std::make_pair( name + "Z", &ROOT::Math::DisplacementVector3D<TYPE, TAG>::Z ) );
     }

template<class TYPE , class TAG >

StatusCode Tuples::TupleObj::column	(	const std::string &	name,
		const ROOT::Math::PositionVector3D< TYPE, TAG > &	v
	)

inline

Useful shortcut to put 3D-Vector directly into N-Tuple:

const LHCb::Vertex* V = ...
Tuple tuple = nTuple("My N-Tuple") ;
// put vertex position into N-tuple:
tuple -> column ("B" , B->position() ) ;

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-11-26

Definition at line 1770 of file TupleObj.h.

                                                                                              {
       return this->columns( v, std::make_pair( name + "X", &ROOT::Math::PositionVector3D<TYPE, TAG>::X ),
                             std::make_pair( name + "Y", &ROOT::Math::PositionVector3D<TYPE, TAG>::Y ),
                             std::make_pair( name + "Z", &ROOT::Math::PositionVector3D<TYPE, TAG>::Z ) );
     }

template<typename Value , typename... Args>

StatusCode Tuples::TupleObj::columns	(	Value &&	value,
		Args &&...	args
	)

inline

Set the values for several columns simultaneously, for the same object Non-existing columns will be automatically created and appended to the ntuple.

Gaudi::XYZPoint p;
tuple->columns( p, std::make_pair( "X", &Gaudi::XYZPoint::X),
                   std::make_pair( "Y", &Gaudi::XYZPoint::Y),
                   std::make_pair( "Z", &Gaudi::XYZPoint::Z) );

Warning: the type of column is set (implicitly) by the type returned by the 'callable' for that column, i.e. in the above the return type of eg. Gaudi::XYZPoint::X()

Author: Gerhard Raven

Definition at line 788 of file TupleObj.h.

                                                         {
       if ( sizeof...( Args ) == 0 ) return StatusCode::SUCCESS;
       std::initializer_list<StatusCode> scs{
           this->column( std::get<0>( args ), Gaudi::invoke( std::get<1>( args ), value ) )...};
       return std::accumulate( std::next( begin( scs ) ), end( scs ), *begin( scs ),
                               []( StatusCode sc, const StatusCode& i ) {
                                 i.ignore();                     // make sure there are no unchecked StatusCodes...
                                 return sc.isFailure() ? sc : i; // latch to the first non-success case
                               } );
     }

bool Tuples::TupleObj::columnWise ( ) const

inline

column wise NTuple ?

Definition at line 1866 of file TupleObj.h.

1866 { return CLID_ColumnWiseTuple == clid(); }

Tuples::TupleObj::clid

const CLID & clid() const

accessor to the N-Tuple CLID

Definition: TupleObj.h:1860

virtual StatusCode Tuples::TupleObj::Error	(	const std::string &	msg,
		const StatusCode	sc = `StatusCode::FAILURE`
	)		const

pure virtual

Implemented in Tuples::detail::TupleObjImp< HANDLER1, HANDLER2 >.

bool Tuples::TupleObj::evtColType ( ) const

inline

Event collection ?

Definition at line 1872 of file TupleObj.h.

1872 { return Tuples::EVTCOL == type(); }

Tuples::EVTCOL

Definition: TupleObj.h:82

Tuples::TupleObj::type

Tuples::Type type() const

accessor to the N-Tuple type

Definition: TupleObj.h:1863

template<typename ITERATOR1 , typename ITERATOR2 >

StatusCode Tuples::TupleObj::farray	(	const std::string &	name,
		ITERATOR1 &&	first,
		ITERATOR2 &&	last,
		const std::string &	length,
		size_t	maxv
	)

inline

Add an indexed array (of type float) to N-tuple.

The method is not VERY efficient since it copies the data.

std::vector<double> values  = ... ;
tuple->farray( "Values"        ,  // item name
               values.begin () ,  // begin of sequence
               values.end   () ,  // end of sequence
               "Length"        ,  // name of "length" item
               10000           ) ;

The name of "length" item can be reused for several arrays. The last assignement "wins"

std::vector<double> val1 = ... ;
std::vector<double> val2 = ... ;
tuple->farray( "Val1"          ,   // item name
                val1.begin  () ,   // begin of sequence
                val1.end    () ,   // end of sequence
               "Length"        ,   // name of "length" item
               10000           ) ; // maximal length
tuple->farray( "Val2"          ,   // item name
                val2.begin  () ,   // begin of sequence
                val2.end    () ,   // end of sequence
               "Length"        ,   // name of "length" item
               10000           ) ; // maximal length

Any sequence [first:last[ of objects which can be converted to type float can be used as input data, e.g. std::vector<double>, std::vector<float>, plain C-array, or whatever else

Parameters

name	name of N-tuple item
first	begin of data sequence
last	end of data sequence
length	name of "length" item
maxv	maximal length of array

Definition at line 877 of file TupleObj.h.

                                      {
       return farray( name, detail::to_float, std::forward<ITERATOR1>( first ), std::forward<ITERATOR2>( last ), length,
                      maxv );
     }

template<class DATA >

StatusCode Tuples::TupleObj::farray	(	const std::string &	name,
		const DATA &	data,
		const std::string &	length,
		const size_t	maxv
	)

inline

Add an indexed array (of type float) to N-tuple.

it is just a small adaptor for the previous method

std::vector<double> values  = ... ;
tuple->farray( "Values"        ,  // item name
               values          ,  // sequence
               "Length"        ,  // name of "length" item
               10000           ) ;

The name of "length" item can be reused for several arrays. The last assignment "wins"

std::vector<double> val1 = ... ;
std::vector<double> val2 = ... ;
tuple->farray( "Val1"          ,   // item name
                val1           ,   // begin of sequence
               "Length"        ,   // name of "length" item
               10000           ) ; // maximal length
tuple->farray( "Val2"          ,   // item name
                val2           ,   // begin of sequence
               "Length"        ,   // name of "length" item
               10000           ) ; // maximal length

Any sequence which provides begin() and end() methods can be used.

Parameters

name	name of N-tuple item
data	data sequence
length	name of "length" item
maxv	maximal length of array

Definition at line 926 of file TupleObj.h.

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

template<class FUNCTION , class ITERATOR >

StatusCode Tuples::TupleObj::farray	(	const std::string &	name,
		const FUNCTION &	function,
		ITERATOR	first,
		ITERATOR	last,
		const std::string &	length,
		size_t	maxv
	)

inline

Put an indexed array into LoKi-style N-Tuple.

std::vector<double> data = ... ;
Tuple tuple = ntuple( "My Ntuple" );
tuple->farray( "data"         ,   // data item name
                sqrt          ,   // "function" to be applied
                data.begin () ,   // begin of data sequence
                data.end   () ,   // end of data sequence
                "length"      ,   // name of "length" tuple item
                10000         ) ; // maximal array length

Since the method is templated, one can use arbitrary combinations of "sequences" and "functions", e.g. one can directly manipulate with complex objects. The only one thing is required - the result of FUNCTION(*DATA) formal operation MUST be convertible to type float

// some container of particles.
ParticleVector particles = ... ;
Tuple tuple = ntuple( "My Ntuple" );
// put the transverse momentum of all particles into N-Tuple
tuple->farray( "pt"                , // data item name
                PT                 , // function object
                particles.begin () , // begin of data sequence
                particles.end   () , // end of data sequence
                "num"              ,   // name of "length" tuple item
                10000              ) ; // maximal array length
// create the appropriate function object
Fun fun =  Q / P ;
// put Q/P of all particles into N-Tuple
tuple->farray( "qp"                , // data item name
                fun                , // function object
                particles.begin () , // begin of data sequence
                particles.end   () , // end of data sequence
                "num"              ,   // name of "length" tuple item
                10000              ) ; // maximal array length

Parameters

name	tuple item name
function	function to be applied
first	begin of data sequence
last	end of data sequence
length	name of "length" tuple name
maxv	maximal length of the array

Returns: status code

Definition at line 993 of file TupleObj.h.

                                                               {
       if ( invalid() ) return ErrorCodes::InvalidTuple;
       if ( rowWise() ) return ErrorCodes::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 ErrorCodes::InvalidColumn;
 
       // adjust the length
       *len = std::distance( first, last );
 
       // get the array itself
       FArray* var = fArray( name, len );
       if ( !var ) return ErrorCodes::InvalidColumn;
 
       // fill the array
       std::transform( first, last, std::begin( *var ),
                       [&]( auto&& i ) { return Gaudi::invoke( function, std::forward<decltype( i )>( i ) ); } );
 
       return StatusCode::SUCCESS;
     }

template<typename DataIterator , template< typename, typename... > class Container = std::initializer_list, typename NamedFunction = std::pair<std::string, std::function<float( detail::const_ref_t<DataIterator> )>>, typename = std::enable_if_t<!std::is_convertible<Container<NamedFunction>, std::string>::value>>

StatusCode Tuples::TupleObj::farray	(	const Container< NamedFunction > &	funs,
		DataIterator	first,
		DataIterator	last,
		const std::string &	length,
		size_t	maxv
	)

inline

Definition at line 1094 of file TupleObj.h.

                                                               {
       return farray_impl( funs.begin(), funs.end(), std::forward<DataIterator>( first ),
                           std::forward<DataIterator>( last ), length, maxv );
     }

template<typename NamedFunctions , typename DataIterator , typename = std::enable_if_t<!std::is_convertible<NamedFunctions, std::string>::value>>

StatusCode Tuples::TupleObj::farray	(	const NamedFunctions &	funs,
		DataIterator	first,
		DataIterator	last,
		const std::string &	length,
		size_t	maxv
	)

inline

Definition at line 1102 of file TupleObj.h.

                                      {
       return farray_impl( funs.begin(), funs.end(), std::forward<DataIterator>( first ),
                           std::forward<DataIterator>( last ), length, maxv );
     }

template<class FUNC1 , class FUNC2 , class Iterator >

StatusCode Tuples::TupleObj::farray	(	const std::string &	name1,
		const FUNC1 &	func1,
		const std::string &	name2,
		const FUNC2 &	func2,
		Iterator &&	first,
		Iterator &&	last,
		const std::string &	length,
		size_t	maxv
	)

inline

Put two functions from one data array into LoKi-style N-Tuple simultaneously (effective!)

std::vector<double> data = ... ;
Tuple tuple = ntuple( "My Ntuple" );
tuple->farray( "square_root"  ,   // the first data item name
                sqrt          ,   // "func1" to be used
               "sinus"        ,   // the second data item name
                sin           ,   // "func2" to be used
                data.begin () ,   // begin of data sequence
                data.end   () ,   // end of data sequence
                "length"      ,   // name of "length" tuple item
                10000         ) ; // maximal array length

Parameters

name1	the first tuple item name
func1	the first function to be applied
name2	the second tuple item name
func2	the second function to be applied
first	begin of data sequence
last	end of data sequence
length	name of "length" tuple name
maxv	maximal length of the array

Returns: status code

Definition at line 1140 of file TupleObj.h.

                                                                                                  {
       return farray( {{name1, std::cref( func1 )}, {name2, std::cref( func2 )}}, std::forward<Iterator>( first ),
                      std::forward<Iterator>( last ), length, maxv );
     }

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

StatusCode Tuples::TupleObj::farray	(	const std::string &	name1,
		const FUNC1 &	func1,
		const std::string &	name2,
		const FUNC2 &	func2,
		const std::string &	name3,
		const FUNC3 &	func3,
		Iterator &&	first,
		Iterator &&	last,
		const std::string &	length,
		size_t	maxv
	)

inline

Put three functions from one data array into LoKi-style N-Tuple simultaneously (effective!)

std::vector<double> data = ... ;
Tuple tuple = ntuple( "My Ntuple" );
tuple->farray( "square_root"    ,   // the first data item name
                sqrt          ,   // "func1" to be used
               "sinus"        ,   // the second data item name
                sin           ,   // "func2" to be used
               "tan"          ,   // the third data item name
                tan           ,   // "func3" to be used
                data.begin () ,   // begin of data sequence
                data.end   () ,   // end of data sequence
                "length"      ,   // name of "length" tuple item
                10000         ) ; // maximal array length

Parameters

name1	the first tuple item name
func1	the first function to be applied
name2	the second tuple item name
func2	the second function to be applied
name3	the third tuple item name
func3	the third function to be applied
first	begin of data sequence
last	end of data sequence
length	name of "length" tuple name
maxv	maximal length of the array

Returns: status code

Definition at line 1183 of file TupleObj.h.

                                                               {
       return farray( {{name1, std::cref( func1 )}, {name2, std::cref( func2 )}, {name3, std::cref( func3 )}},
                      std::forward<Iterator>( first ), std::forward<Iterator>( last ), length, maxv );
     }

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

StatusCode Tuples::TupleObj::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,
		Iterator &&	first,
		Iterator &&	last,
		const std::string &	length,
		size_t	maxv
	)

inline

Put four functions from one data array into LoKi-style N-Tuple simultaneously (effective!)

std::vector<double>   data = ... ;
Tuple tuple = ntuple( "My Ntuple" );
tuple->farray( "square_root"    ,   // the first data item name
                sqrt          ,   // "func1" to be used
               "sinus"        ,   // the second data item name
                sin           ,   // "func2" to be used
               "tan"          ,   // the third data item name
                tan           ,   // "func3" to be used
               "tanh"         ,   //
                tanh          ,   //
                data.begin () ,   // begin of data sequence
                data.end   () ,   // end of data sequence
                "length"      ,   // name of "length" tuple item
                10000         ) ; // maximal array length

Parameters

name1	the first tuple item name
func1	the first function to be applied
name2	the second tuple item name
func2	the second function to be applied
name3	the third tuple item name
func3	the third function to be applied
name4	the fourth tuple item name
func4	the fourth function to be applied
first	begin of data sequence
last	end of data sequence
length	name of "length" tuple name
maxv	maximal length of the array

Returns: status code

Definition at line 1230 of file TupleObj.h.

                                                                                                  {
       return farray( {{name1, std::cref( func1 )},
                       {name2, std::cref( func2 )},
                       {name3, std::cref( func3 )},
                       {name4, std::cref( func4 )}},
                      std::forward<Iterator>( first ), std::forward<Iterator>( last ), length, maxv );
     }

Tuples::TupleObj::FArray * Tuples::TupleObj::fArray	(	const std::string &	name,
		Int *	item
	)

private

get the column

Definition at line 409 of file TupleObj.cpp.

                                                                                                {
   // existing array ?
   auto found = m_farrays.find( name );
   if ( m_farrays.end() != found ) return found->second.get();
   return create_( this, m_farrays, name,
                   [&]( const std::string& n, FArray& i ) { return this->tuple()->addIndexedItem( n, *length, i ); } );
 }

Tuples::TupleObj::FArray * Tuples::TupleObj::fArray	(	const std::string &	name,
		const MIndex &	rows
	)

private

get the column

Definition at line 419 of file TupleObj.cpp.

                                                                                                       {
   // existing array ?
   auto found = m_arraysf.find( name );
   if ( m_arraysf.end() != found ) return found->second.get();
   return create_( this, m_arraysf, name,
                   [&]( const std::string& n, FArray& i ) { return this->tuple()->addItem( n, rows, i ); } );
 }

template<typename FunIterator , typename DataIterator >

StatusCode Tuples::TupleObj::farray_impl	(	FunIterator	first_item,
		FunIterator	last_item,
		DataIterator	first,
		DataIterator	last,
		const std::string &	length,
		size_t	maxv
	)

inline

Put arbitrary number of functions from one data array into LoKi-style N-Tuple simultaneously (effective!)

std::vector<double> data = ... ;
Tuple tuple = ntuple( "My Ntuple" );
tuple->farray( { { "sqrt", sqrt },     // name of 1st column, and function to use for it
                 { "sinus", sin } },   // name of the 2nd column, and corresponding function
                data.begin () ,   // begin of data sequence
                data.end   () ,   // end of data sequence
                "length"      ,   // name of "length" tuple item
                10000         ) ; // maximal array length

Parameters

items	vector of pairs { name, callable }
first	begin of data sequence
last	end of data sequence
length	name of "length" tuple name
maxv	maximal length of the array

Returns: status code

Definition at line 1050 of file TupleObj.h.

                                                                    {
       if ( invalid() ) return ErrorCodes::InvalidTuple;
       if ( rowWise() ) return ErrorCodes::InvalidOperation;
 
       // adjust the length
       if ( std::distance( first, last ) > static_cast<std::ptrdiff_t>( maxv ) ) {
         using GaudiUtils::details::ostream_joiner;
         std::ostringstream os;
         ostream_joiner( os, first_item, last_item, ",",
                         []( std::ostream& os, const auto& i ) -> decltype( auto ) { return os << i.first; } );
         Warning( "farray('" + os.str() + "'): array overflow, skipping extra entries" ).ignore();
         last = std::next( first, maxv );
       }
 
       // get the length item
       Int* len = ints( length, 0, maxv );
       if ( !len ) return ErrorCodes::InvalidColumn;
 
       // adjust the length
       *len = std::distance( first, last );
 
       // get the arrays themselves
       std::vector<FArray*> vars;
       vars.reserve( std::distance( first_item, last_item ) );
       std::transform( first_item, last_item, std::back_inserter( vars ),
                       [&]( const auto& item ) { return this->fArray( item.first, len ); } );
       if ( std::any_of( vars.begin(), vars.end(), []( const FArray* f ) { return !f; } ) ) {
         return ErrorCodes::InvalidColumn;
       }
 
       // fill the array
       for ( size_t index = 0; first != last; ++first, ++index ) {
         auto item = first_item;
         for ( auto& var : vars ) { ( *var )[index] = Gaudi::invoke( ( item++ )->second, *first ); }
       }
 
       return StatusCode::SUCCESS;
     }

StatusCode Tuples::TupleObj::fill ( const char * format... )

Set the values for several columns simultaneously.

Number of columns is arbitrary, but it should not be less than number of blank or comma separated tags in format string. Non-existing columns will be automatically created and appended to the ntuple.

double r1 , r2 , r3 , r4 , mass , length ;
tuple->fill( "var1 var2, radius  rad4 mass  len" ,
              r1,  r2,   r3,     r4,  mass, length);

Warning: ALL columns are assumed to be of type double

Parameters

format blank-separated list of variables, followed by variable number of arguments.

Attention: All variables are assumed to be double numbers

Author: Vanya Belyaev Ivan..nosp@m.Bely.nosp@m.aev@i.nosp@m.tep..nosp@m.ru

Date: 2002-10-30

decode arguments

Definition at line 256 of file TupleObj.cpp.

                                                        {
   // check the underlying tuple
   if ( invalid() ) return ErrorCodes::InvalidTuple;
   // decode format string into tokens
   auto tokens = tokenize( format, " ,;" );
   va_list valist;
   va_start( valist, format );
   // loop over all tokens
   StatusCode status = StatusCode::SUCCESS;
   for ( auto token = tokens.cbegin(); tokens.cend() != token && status.isSuccess(); ++token ) {
     double val = va_arg( valist, double );
     status     = column( *token, val );
     if ( status.isFailure() ) Error( "fill(): Can not add column '" + *token + "' " );
   }
   // mandatory !!!
   va_end( valist );
   //
   return status;
 }

template<class MATRIX >

StatusCode Tuples::TupleObj::fmatrix	(	const std::string &	name,
		const MATRIX &	data,
		size_t	rows,
		const MIndex &	cols,
		const std::string &	length,
		size_t	maxv
	)

inline

Fill N-Tuple with data from variable-size matrix.

"Matrix" could be of any type, which supports data[iRow][iCol] indexing, e.g.

std::vector<std::vector<TYPE> >
CLHEP::HepMatrix, etc...

typedef std::vector<double> Row  ;
typedef std::vector<Row>    Mtrx ;
// number of columns (fixed!)
const size_t numCols = 5 ;
// maximal number of rows
const size_t maxRows = 300 ;
// number of rows (variable)
size_t numRows =  .... ;
...
tuple -> fMatrix ( "mtrx"        , // "column" name
                   mtrx          , // matrix
                   numRows       , // number of rows (variable!)
                   numCols       , // number of columns (fixed)
                   "Length"      , // name for "length" column
                   maxRows       ) ; // maximal number of columns

CLHEP::HepMatrix mtrx = ... ;
...
tuple -> fMatrix ( "mtrx"         , // "column" name
                   mtrx           , // matrix
                   mtrx.num_row() , // number of rows (variable!)
                   mtrx.num_col() , // number of columns (fixed)
                   "Length"       , // name for "length" column
                   maxRows        ) ; // maximal number of columns

Parameters

name	entry name in N-Tuple
data	matrix itself
rows	number of rows of matrix (variable)
cols	number of columns of matrix (fixed)
length	entry name in NTuple for number of matrix column
maxv	maximal number of rows in matrix

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@l.nosp@m.app..nosp@m.in2p3.nosp@m..fr

Date: 2005-05-01

fill the matrix

Definition at line 1293 of file TupleObj.h.

                                                                {
       if ( invalid() ) return ErrorCodes::InvalidTuple;
       if ( rowWise() ) return ErrorCodes::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 ErrorCodes::InvalidColumn;
 
       // adjust the length item
       *len = rows;
 
       // get the array itself
       FMatrix* var = fMatrix( name, len, cols );
       if ( !var ) return ErrorCodes::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 Tuples::TupleObj::fmatrix	(	const std::string &	name,
		DATA	first,
		DATA	last,
		const MIndex &	cols,
		const std::string &	length,
		size_t	maxv
	)

inline

Fill N-Tuple with data from variable-size matrix.

"Matrix" could be of any type, which supports iteration from the first column to the last column and for each iterating column supports the indexing: (*first)[iCol]

typedef std::vector<double> Row  ;
typedef std::vector<Row>    Mtrx ;
// number of rows (fixed!)
const size_t numRows = 5 ;
// maximal number of columns
const size_t maxCols = 300 ;
// number of columns (variable)
size_t numCols =  .... ;
...
tuple -> fMatrix ( "mtrx"         , // entry name
                    mtrx.begin()  , // first row of matrix
                    mtrx.end  ()  , // last  row of matrix
                    numCols       , // number of columns (fixed!)
                    "Length"      , // name for "length" column
                    maxRows       ) ; // maximal number of rows

Parameters

name	entry name in N-Tuple
first	iterator for the first row of matrix
last	iterator for the last row of matrix
cols	number of columns for matrix (fixed!)
length	entry name in NTuple for number of matrix column
maxv	maximal number of rows in matrix

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@l.nosp@m.app..nosp@m.in2p3.nosp@m..fr

Date: 2005-05-01

fill the matrix

Definition at line 1360 of file TupleObj.h.

                                       {
       if ( invalid() ) return ErrorCodes::InvalidTuple;
       if ( rowWise() ) return ErrorCodes::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 ErrorCodes::InvalidColumn;
 
       // adjust the length item
       *len = last - first;
 
       // get the array itself
       FMatrix* var = fMatrix( name, len, cols );
       if ( !var ) return ErrorCodes::InvalidColumn;
 
       size_t iRow = 0;
       for ( ; first != last; ++first ) {
         //
         for ( MIndex iCol = 0; iCol < cols; ++iCol ) { ( *var )[iRow][iCol] = ( *first )[iCol]; }
         //
         ++iRow;
       }
 
       return StatusCode::SUCCESS;
     }

template<class FUN , class DATA >

StatusCode Tuples::TupleObj::fmatrix	(	const std::string &	name,
		FUN	funF,
		FUN	funL,
		DATA	first,
		DATA	last,
		const std::string &	length,
		size_t	maxv
	)

inline

fill N-Tuple with matrix of "direct-product" of "data-vector" [first,last) and "function-vector" [funF, funL)

The elements of effective matrix are:

mtrx[iCol][iRow] = (*(funF+iRow))( *(first+iCol) )

Attention: The length of data-vector is variable, while the length of "function" vector is fixed!

typedef std::vector<double> Array ;
Array array  = ... ;
typedef double (*fun)( double ) ;
typedef std::vector<fun>   Funs ;
Funs funs ;
funs.push_back( sin  ) ;
funs.push_back( cos  ) ;
funs.push_back( tan  ) ;
funs.push_back( sinh ) ;
funs.push_back( cosh ) ;
funs.push_back( tanh ) ;
tuple->fmatrix ( "mtrx"         , // N-Tuple entry name
                 funs.begin  () , // begin of "function-vector"
                 funs.end    () , // end of "function-vector"
                 array.begin () , // begin of "data-vector"
                 array.end   () , // end of "data-vector"
                 "Length"       ,
                 100            ) ;

This method is very convenient e.g. for using within LoKi:

 typedef std::vector<Fun>  VctFun ;
 // sequence of Particles
 Range particles = .... ;
 // vector of functions:
VctFun funs ;
funs.push_back( E  / GeV ) ;
funs.push_back( PX / GeV ) ;
funs.push_back( PY / GeV ) ;
funs.push_back( PZ / GeV ) ;
funs.push_back( PT / GeV ) ;
funs.push_back( M  / GeV ) ;
funs.push_back( ID       ) ;
// fill N-Tuple with information about each particle
tuple -> fmatrix ( "vars"             ,
                   funs.begin      () ,
                   funs.end        () ,
                   particles.begin () ,
                   particles.end   () ,
                   "nParts"           ,
                   200                ) ;

Parameters

name	entry name in N-Tuple
funF	"begin"-iterator for vector of functions
funL	"end"-iterator for vector of functions
first	"begin"-iterator for vector of data
last	"end"-iterator for vector of data
length	entry name in NTuple for number of matrix column
maxv	maximal number of rows in matrix

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@l.nosp@m.app..nosp@m.in2p3.nosp@m..fr

Date: 2005-05-01

fill the matrix

Definition at line 1473 of file TupleObj.h.

                                       {
       if ( invalid() ) return ErrorCodes::InvalidTuple;
       if ( rowWise() ) return ErrorCodes::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 ErrorCodes::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 ErrorCodes::InvalidColumn;
 
       size_t iRow = 0;
       for ( ; first != last; ++first ) {
         //
         for ( FUN fun = funF; fun < funL; ++fun ) { ( *var )[iRow][fun - funF] = Gaudi::invoke( *fun, *first ); }
         //
         ++iRow;
       }
 
       return StatusCode::SUCCESS;
     }

template<class KEY , class VALUE >

StatusCode Tuples::TupleObj::fmatrix	(	const std::string &	name,
		const GaudiUtils::VectorMap< KEY, VALUE > &	info,
		const std::string &	length,
		const size_t	maxv = `100`
	)

inline

shortcut to put "ExtraInfo" fields of major into N-Tuple

const LHCb::Particle* B = ...
Tuple tuple = nTuple("My N-Tuple") ;
// put the vector into N-Tuple:
tuple -> fmatrix ( "Info" , B->extraInfo() , "nInfo" , 100 ) ;

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-11-26

Definition at line 1819 of file TupleObj.h.

                                                                            {
       using Info                                                 = std::pair<KEY, VALUE>;
       static const std::array<float ( * )( const Info& ), 2> fns = {
           {[]( const Info& i ) -> float { return i.first; }, []( const Info& i ) -> float { return i.second; }}};
       return fmatrix( name, begin( fns ), end( fns ), begin( info ), end( info ), length, maxv );
     }

Tuples::TupleObj::FMatrix * Tuples::TupleObj::fMatrix	(	const std::string &	name,
		Int *	item,
		const MIndex &	cols
	)

private

get the column

Definition at line 429 of file TupleObj.cpp.

                                                                                          {
   // existing array ?
   auto found = m_fmatrices.find( name );
   if ( m_fmatrices.end() != found ) return found->second.get();
   return create_( this, m_fmatrices, name, [&]( const std::string& n, FMatrix& i ) {
     return this->tuple()->addIndexedItem( n, *length, cols, i );
   } );
 }

Tuples::TupleObj::FMatrix * Tuples::TupleObj::fMatrix	(	const std::string &	name,
		const MIndex &	rows,
		const MIndex &	cols
	)

private

get the column

Definition at line 441 of file TupleObj.cpp.

                                                                                          {
   // existing array ?
   auto found = m_matricesf.find( name );
   if ( m_matricesf.end() != found ) return found->second.get();
   return create_( this, m_matricesf, name,
                   [&]( const std::string& n, FMatrix& i ) { return this->tuple()->addItem( n, rows, cols, i ); } );
 }

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

inline

check the uniqueness of the name

Parameters

name	the name of the item

Returns: true if the name is indeed unique

Definition at line 1895 of file TupleObj.h.

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

std::map::end

T end(T...args)

Tuples::TupleObj::m_items

ItemMap m_items

all booked types:

Definition: TupleObj.h:2000

std::map::find

T find(T...args)

Tuples::TupleObj::Int * Tuples::TupleObj::ints	(	const std::string &	name,
		int	minv,
		int	maxv
	)

private

get the column

Definition at line 342 of file TupleObj.cpp.

                                                                                    {
   return find_or_create( this, name, m_ints, minv, maxv );
 }

bool Tuples::TupleObj::invalid ( ) const

inline

invalid pointer to tuple ?

Definition at line 1878 of file TupleObj.h.

1878 { return !valid(); }

Tuples::TupleObj::valid

bool valid() const

valid pointer to tuple ?

Definition: TupleObj.h:1875

const ItemMap& Tuples::TupleObj::items ( ) const

inline

get the full list of booked items

Definition at line 1898 of file TupleObj.h.

1898 { return m_items; }

Tuples::TupleObj::m_items

ItemMap m_items

all booked types:

Definition: TupleObj.h:2000

template<class MATRIX >

StatusCode Tuples::TupleObj::matrix	(	const std::string &	name,
		const MATRIX &	data,
		const MIndex &	rows,
		const MIndex &	cols
	)

inline

fill N-Tuple with fixed-size matrix

"MATRIX" must support indexing operations: data[iRow][iCol]

e.g it could be of type:

std::vector<std::vector<TYPE> >
CLHEP::HepMatrix , CLHEP::GenMatrix, etc ...
"TYPE"[n][m]

The content of MATRIX should be implicitly convertible to "float"

CLHEP::HepMatrix mtrx1(3,20) ;
...
tuple -> matrix ( "m1"             ,
                   mtrx1           ,
                   mtrx1.num_row() ,
                   mtrx1.num_col() ) ;
typedef std::vector<double> Row  ;
typedef std:vector<Row>     Mtrx ;
Mtrx mtrx2( 3 , Row(10) ) ;
...
tuple -> matrix ( "m2"   ,
                   mtrx2 ,
                   3     ,
                   10    ) ;
float mtrx3[3][10] ;
...
tuple -> matrix ( "m3"   ,
                   mtrx3 ,
                   3     ,
                   10    ) ;

Parameters

name	N-Tuple entry name
data	data source (matrix)
cols	number of columns
rows	number of rows

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@l.nosp@m.app..nosp@m.in2p3.nosp@m..fr

Date: 2005-05-01

fill the matrix

Definition at line 1689 of file TupleObj.h.

                                                                                                            {
       if ( invalid() ) return ErrorCodes::InvalidTuple;
       if ( rowWise() ) return ErrorCodes::InvalidOperation;
 
       // get the matrix itself
       FMatrix* var = fMatrix( name, rows, cols );
       if ( !var ) return ErrorCodes::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;
     }

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

StatusCode Tuples::TupleObj::matrix	(	const std::string &	name,
		const ROOT::Math::SMatrix< TYPE, D1, D2, REP > &	mtrx
	)

inline

shortcut to put Smatrix into N-tuple:

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-11-26

fill the matrix

Definition at line 1785 of file TupleObj.h.

                                                                                                {
       if ( invalid() ) return ErrorCodes::InvalidTuple;
       if ( rowWise() ) return ErrorCodes::InvalidOperation;
 
       // get the matrix itself
       FMatrix* var = fMatrix( name, (MIndex)D1, (MIndex)D2 );
       if ( !var ) return ErrorCodes::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;
     }

const std::string& Tuples::TupleObj::name ( ) const

inline

get the name

Definition at line 1847 of file TupleObj.h.

1847 { return m_name; }

Tuples::TupleObj::m_name

std::string m_name

name

Definition: TupleObj.h:1933

TupleObj& Tuples::TupleObj::operator= ( const TupleObj & )

privatedelete

template<class TYPE >

StatusCode Tuples::TupleObj::put	(	const std::string &	name,
		const TYPE *	obj
	)

inline

The function allows to add almost arbitrary object into N-tuple.

Attention: it requires POOL persistency

Parameters

name	column name
obj	pointer to the object

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2007-04-08

Definition at line 113 of file TuplePut.h.

                                                                               {
   if ( invalid() ) { return ErrorCodes::InvalidTuple; }         // RETURN
   if ( !evtColType() ) { return ErrorCodes::InvalidOperation; } // RETURN
 
   // static block: The type description & the flag
   static bool    s_fail = false;   // STATIC
   static TClass* s_type = nullptr; // STATIC
   // check the status
   if ( s_fail ) {
     return ErrorCodes::InvalidItem;
   } // RETURN
   else if ( !s_type ) {
     s_type = TClass::GetClass( typeid( TYPE ) );
     if ( !s_type ) {
       s_fail = true;
       return Error( " put('" + name + "'," + System::typeinfoName( typeid( TYPE ) ) + ") :Invalid ROOT Type",
                     ErrorCodes::InvalidItem ); // RETURN
     }
   }
   // the local storage of items
   static Tuples::ItemStore<TYPE*> s_map;
   // get the variable by name:
   auto item = s_map.getItem( name, this );
   if ( !item ) { return Error( " put('" + name + "'): invalid item detected", ErrorCodes::InvalidItem ); }
   // assign the item!
   ( *item ) = const_cast<TYPE*>( obj ); // THATS ALL!!
   //
   return StatusCode::SUCCESS; // RETURN
 }

bool Tuples::TupleObj::rowWise ( ) const

inline

row wise NTuple ?

Definition at line 1869 of file TupleObj.h.

1869 { return CLID_RowWiseTuple == clid(); }

Tuples::TupleObj::clid

const CLID & clid() const

accessor to the N-Tuple CLID

Definition: TupleObj.h:1860

const NTuple::Tuple* Tuples::TupleObj::tuple ( ) const

inline

provide the access to underlying Gaudi N-tuple

Returns: pointer to Gaudi N-tuple object

Definition at line 1852 of file TupleObj.h.

1852 { return m_tuple; }

Tuples::TupleObj::m_tuple

NTuple::Tuple * m_tuple

tuple itself

Definition: TupleObj.h:1936

NTuple::Tuple* Tuples::TupleObj::tuple ( )

inline

provide the access to underlying Gaudi N-tuple

Returns: pointer to Gaudi N-tuple object

Definition at line 1857 of file TupleObj.h.

1857 { return m_tuple; }

Tuples::TupleObj::m_tuple

NTuple::Tuple * m_tuple

tuple itself

Definition: TupleObj.h:1936

Tuples::Type Tuples::TupleObj::type ( ) const

inline

accessor to the N-Tuple type

Definition at line 1863 of file TupleObj.h.

1863 { return m_type; }

Tuples::TupleObj::m_type

Tuples::Type m_type

tuple 'type'

Definition: TupleObj.h:1942

bool Tuples::TupleObj::valid ( ) const

inline

valid pointer to tuple ?

Definition at line 1875 of file TupleObj.h.

1875 { return 0 != tuple(); }

Tuples::TupleObj::tuple

const NTuple::Tuple * tuple() const

provide the access to underlying Gaudi N-tuple

Definition: TupleObj.h:1852

virtual StatusCode Tuples::TupleObj::Warning	(	const std::string &	msg,
		const StatusCode	sc = `StatusCode::FAILURE`
	)		const

pure virtual

Implemented in Tuples::detail::TupleObjImp< HANDLER1, HANDLER2 >.

StatusCode Tuples::TupleObj::write ( )

write a record to NTuple

Returns: status code

Definition at line 229 of file TupleObj.cpp.

                                  {
   if ( invalid() ) return ErrorCodes::InvalidTuple;
   return tuple()->write();
 }

Member Data Documentation

ColumnStorage<Address> Tuples::TupleObj::m_addresses

mutableprivate

the actual storage of all 'Address' columns

Definition at line 1985 of file TupleObj.h.

ColumnStorage<FArray> Tuples::TupleObj::m_arraysf

mutableprivate

the actual storage of all 'FArray' columns (fixed)

Definition at line 1991 of file TupleObj.h.

ColumnStorage<Bool> Tuples::TupleObj::m_bools

mutableprivate

the actual storage of all 'bool' columns

Definition at line 1952 of file TupleObj.h.

ColumnStorage<Char> Tuples::TupleObj::m_chars

mutableprivate

the actual storage of all 'Int' columns

Definition at line 1955 of file TupleObj.h.

CLID Tuples::TupleObj::m_clid

private

tuple CLID

Definition at line 1939 of file TupleObj.h.

ColumnStorage<Double> Tuples::TupleObj::m_doubles

mutableprivate

the actual storage of all 'Double' columns

Definition at line 1982 of file TupleObj.h.

ColumnStorage<FArray> Tuples::TupleObj::m_farrays

mutableprivate

the actual storage of all 'FArray' columns

Definition at line 1988 of file TupleObj.h.

ColumnStorage<Float> Tuples::TupleObj::m_floats

mutableprivate

the actual storage of all 'Float' columns

Definition at line 1979 of file TupleObj.h.

ColumnStorage<FMatrix> Tuples::TupleObj::m_fmatrices

mutableprivate

the actual storage of all 'FArray' columns

Definition at line 1994 of file TupleObj.h.

ColumnStorage<Int> Tuples::TupleObj::m_ints

mutableprivate

the actual storage of all 'Int' columns

Definition at line 1967 of file TupleObj.h.

ItemMap Tuples::TupleObj::m_items

private

all booked types:

Definition at line 2000 of file TupleObj.h.

ColumnStorage<LongLong> Tuples::TupleObj::m_longlongs

mutableprivate

the actual storage of all 'long long' columns

Definition at line 1973 of file TupleObj.h.

ColumnStorage<FMatrix> Tuples::TupleObj::m_matricesf

mutableprivate

the actual storage of all 'FMatrix' columns (fixed)

Definition at line 1997 of file TupleObj.h.

std::string Tuples::TupleObj::m_name

private

name

Definition at line 1933 of file TupleObj.h.

size_t Tuples::TupleObj::m_refCount = 0

private

reference counter

Definition at line 1945 of file TupleObj.h.

ColumnStorage<Short> Tuples::TupleObj::m_shorts

mutableprivate

the actual storage of all 'Int' columns

Definition at line 1961 of file TupleObj.h.

NTuple::Tuple* Tuples::TupleObj::m_tuple

private

tuple itself

Definition at line 1936 of file TupleObj.h.

Tuples::Type Tuples::TupleObj::m_type

private

tuple 'type'

Definition at line 1942 of file TupleObj.h.

ColumnStorage<UChar> Tuples::TupleObj::m_uchars

mutableprivate

the actual storage of all 'unsigned int' columns

Definition at line 1958 of file TupleObj.h.

ColumnStorage<UInt> Tuples::TupleObj::m_uints

mutableprivate

the actual storage of all 'unsigned int' columns

Definition at line 1970 of file TupleObj.h.

ColumnStorage<ULongLong> Tuples::TupleObj::m_ulonglongs

mutableprivate

the actual storage of all 'unsigned long long' columns

Definition at line 1976 of file TupleObj.h.

ColumnStorage<UShort> Tuples::TupleObj::m_ushorts

mutableprivate

the actual storage of all 'unsigned int' columns

Definition at line 1964 of file TupleObj.h.

The documentation for this class was generated from the following files:

GaudiAlg/GaudiAlg/TupleObj.h
GaudiAlg/GaudiAlg/TuplePut.h
GaudiAlg/src/lib/TupleObj.cpp

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation