xAOD::Utils Namespace Reference

Functions
SG::sgkey_t	hash (const std::string &name)
	This function provides a hashed version of the key (branch) names used in the xAOD file, similar to how Athena saves hashed numbers in persistent ElementLinks.
std::string	dynBranchPrefix (const std::string &key)
	This function is used to figure out what to name dynamic auxiliary branches coming from a container called key.
std::string	dynFieldPrefix (const std::string &key)
	This function is used to figure out what to name dynamic auxiliary field coming from a container called key.
const std::type_info &	getTypeInfo (EDataType type)
	This function is used when reading a primitive branch from an input file without the user explicitly asking for it.
const std::type_info &	getTypeInfo (std::string_view typeName)
	Get the type info of a primitive variable, in an RNTuple.
bool	isPrimitiveType (std::string_view typeName)
	Check if the type name describes a primitive type.
char	rootType (char typeidType)
	This function is used internally in the code when creating primitive dynamic auxiliary branches.
std::string	getTypeName (const std::type_info &ti)
	This function is necessary in order to create type names that ROOT can understand.
std::string	getFirstBranchMatch (TTree *tree, const std::string &pre)
	This function is used to search for a branch in a TTree that contains a given substring.
std::string	getFieldName (const ROOT::RNTupleDescriptor &descriptor, const std::string &key)
	This function is used to find the name of the field in an RNTuple that stores the object with a given key.
std::string	timeToString (::Double_t secs)
	Function creating a human-readable elapsed time printout.
std::string	sizeToString (::Long64_t bytes)
	Function for printing data sizes in human-readable format.
std::string	speedToString (::Double_t bytespersec)
	Function for printing data processing speeds in a human-readable format.

Function Documentation

dynBranchPrefix()

std::string xAOD::Utils::dynBranchPrefix

(

const std::string &

key

)

This function is used to figure out what to name dynamic auxiliary branches coming from a container called key.

Get the dynamic auxiliary variable prefix based on a container name (for TTree).

It needs to work in sync with how it is done in the offline code, so will eventually probably end up in another package.

Parameters

key	The key/branch name of the auxiliary container

Returns

The prefix of the dynamic variables created based on the contents of the object

Definition at line 147 of file Control/xAODRootAccess/Root/Utils.cxx.

                                                        {
 
         // Make a copy of the key that we can modify:
         std::string result = key;
 
         // If it ends in a dot, then let's exchange that dot for
         // "Dyn.":
         if( result[ result.size() - 1 ] == '.' ) {
            result.replace( result.size() - 1, 1, "Dyn." );
         }
         // If it doesn't end in a dot, then let's just add "Dyn." at
         // the end, and be done with it:
         else {
            result += "Dyn.";
         }
 
         return result;
      }

dynFieldPrefix()

std::string xAOD::Utils::dynFieldPrefix

(

const std::string &

key

)

This function is used to figure out what to name dynamic auxiliary field coming from a container called key.

Get the dynamic auxiliary variable prefix based on a container name (for RNTuple).

Parameters

key	The key/field name of the auxiliary container

Returns

The prefix of the dynamic variables created based on the contents of the object

Definition at line 173 of file Control/xAODRootAccess/Root/Utils.cxx.

                                                       {
         // Make a copy of the key that we can modify:
         std::string result = key;
 
         // If it ends in a colon, then let's exchange that colon for
         // "Dyn:":
         if( result[ result.size() - 1 ] == ':' ) {
            result.replace( result.size() - 1, 1, "Dyn:" );
         }
         // If it doesn't end in a colon, then let's just add "Dyn:" at
         // the end:
         else {
            result += "Dyn:";
         }
 
         return result;
      }

getFieldName()

std::string xAOD::Utils::getFieldName	(	const ROOT::RNTupleDescriptor &	descriptor,
		const std::string &	key )

This function is used to find the name of the field in an RNTuple that stores the object with a given key.

Get the name of the RNTuple field storing the object with a given key.

RNTuples store the auxiliary stores with an "Aux:" postfix instead of "Aux.". Athena also replaces all non-alphanumeric characters of the key with underscores when writing the fields (e.g. for trigger chain names containing '-' characters), so that name is used if no field is found for the key itself.

Parameters

descriptor	The descriptor of the RNTuple to search in
key	The key (branch name) of the object

Returns

The name of the field to read the object from

Definition at line 426 of file Control/xAODRootAccess/Root/Utils.cxx.

                                                       {
 
         std::string fieldName = key;
         if( fieldName.ends_with( "Aux." ) ) {
            fieldName.back() = ':';
         }
         if( descriptor.FindFieldId( fieldName ) !=
             ROOT::kInvalidDescriptorId ) {
            return fieldName;
         }
 
         // Replace the characters the same way as Athena does when writing.
         fieldName = key;
         std::replace_if( fieldName.begin(), fieldName.end(),
                          []( unsigned char c ) { return !std::isalnum( c ); },
                          '_' );
         if( fieldName.ends_with( "Aux_" ) ) {
            fieldName.back() = ':';
         }
         return fieldName;
      }

getFirstBranchMatch()

std::string xAOD::Utils::getFirstBranchMatch	(	TTree *	tree,
		const std::string &	pre )

This function is used to search for a branch in a TTree that contains a given substring.

Search for branches, returns search term on no result.

It returns the name of the first branch that contains the search term. If no branch is found, the function returns the search term itself.

Parameters

tree	The TTree to search in
pre	The search term

Returns

The name of the first branch that contains the search term

Definition at line 397 of file Control/xAODRootAccess/Root/Utils.cxx.

                                                               {
         const TObjArray * pBranches = tree->GetListOfBranches();
         const std::regex pattern( ".*" + pre + ".*" );
 
         for( int i = 0, nLast = pBranches->GetLast(); i <= nLast; ++i ) {
            const std::string name = pBranches->At(i)->GetName();
 
            if( std::regex_match( name, pattern ) )
               return name;
 
         }
 
         return pre;
      }

getTypeInfo() [1/2]

const std::type_info & xAOD::Utils::getTypeInfo

(

EDataType

type

)

This function is used when reading a primitive branch from an input file without the user explicitly asking for it.

Get the type info of a primitive variable, as declared by ROOT.

Parameters

type	The type taken from ROOT

Returns

The typeid of the primitive type in question

Definition at line 197 of file Control/xAODRootAccess/Root/Utils.cxx.

                                                        {
 
         switch( type ) {
 
         case kChar_t:
         case kchar:
            return typeid( Char_t );
         case kUChar_t:
            return typeid( UChar_t );
         case kShort_t:
            return typeid( Short_t );
         case kUShort_t:
            return typeid( UShort_t );
         case kInt_t:
         case kCounter:
            return typeid( Int_t );
         case kUInt_t:
         case kBits:
         case kDataTypeAliasUnsigned_t:
            return typeid( UInt_t );
         case kLong_t:
            return typeid( Long_t );
         case kULong_t:
            return typeid( ULong_t );
         case kFloat_t:
            return typeid( Float_t );
         case kDouble_t:
            return typeid( Double_t );
         case kDouble32_t:
            return typeid( Double32_t );
         case kBool_t:
            return typeid( Bool_t );
         case kLong64_t:
            return typeid( Long64_t );
         case kULong64_t:
            return typeid( ULong64_t );
         case kFloat16_t:
            return typeid( Float16_t );
         case kCharStar:
            return typeid( char* );
         case kVoid_t:
            return typeid( void );
         default:
            ::Error( "xAOD::Utils::getTypeInfo",
                     XAOD_MESSAGE( "Unknown data type (%i) received" ),
                     static_cast< int >( type ) );
            return typeid( void );
         }
      }

getTypeInfo() [2/2]

const std::type_info & xAOD::Utils::getTypeInfo

(

std::string_view

typeName

)

Get the type info of a primitive variable, in an RNTuple.

Definition at line 268 of file Control/xAODRootAccess/Root/Utils.cxx.

                                                               {
         TYPE_CHECK_INSTANTIATE(GETTYPEINFO_SPECIALIZE)
         ::Error("xAOD::Utils::getTypeInfo",
                 XAOD_MESSAGE("Unknown data type (%s) received"),
                 typeName.data());
         return typeid(void);
      }

getTypeName()

std::string xAOD::Utils::getTypeName

(

const std::type_info &

ti

)

This function is necessary in order to create type names that ROOT can understand.

Get the type name as it is known to ROOT, based on std::type_info.

For instance, a type name like std::vector<ElementLink<DataVector<xAOD::IParticle, DataModel_detail::NoBase> >, std::allocator<ElementLink<DataVector<xAOD::IParticle, DataModel_detail::NoBase> > > > as seen by the compiler, needs to become std::vector<ElementLink<DataVector<xAOD::IParticle> > > for ROOT to find a dictionary for it.

This function executes the string manipulation necessary to do this.

Parameters

ti	The type for which we want to find a string type name

Returns

The type name in a format that ROOT understands

Definition at line 357 of file Control/xAODRootAccess/Root/Utils.cxx.

                                                      {
 
         // Get the "raw" type name:
         std::string result = AthContainers_detail::typeinfoName( ti );
 
         // If there are no "tricky" classes in the name, then we're done
         // already:
         if( ( result.find( "DataVector<" ) == std::string::npos ) &&
             ( result.find( "std::vector<" ) == std::string::npos ) &&
             ( result.find( "std::__1::vector<") == std::string::npos ) ) {
            return result;
         }
 
         // Deal with the vector types:
         removeDefaultTemplateParameters( result, "DataVector" );
         removeDefaultTemplateParameters( result, "std::vector" );
         removeDefaultTemplateParameters( result, "std::__1::vector" );
 
         // Make sure that no ">>" parts are left in the type name:
         size_t pos = 0;
         while( ( pos = result.find( ">>" ) ) != std::string::npos ) {
            result.replace( pos, 2, "> >" );
         }
 
         // Remove all "__1" namespaces from the type name:
         while( ( pos = result.find( "__1::" ) ) != std::string::npos ) {
            result.replace( pos, 5, "" );
         }
 
         // Return the massaged name:
         return result;
      }

hash()

SG::sgkey_t xAOD::Utils::hash

(

const std::string &

name

)

This function provides a hashed version of the key (branch) names used in the xAOD file, similar to how Athena saves hashed numbers in persistent ElementLinks.

Function creating a hash out of a "key name".

Since Athena uses the top 2 bits in a hashed key to save additional state information about the link, the top 2 bits of the hash are always set to 0.

Parameters

name	The name that we want to create a unique hash for

Returns

A more or less unique hash for the string

Definition at line 128 of file Control/xAODRootAccess/Root/Utils.cxx.

                                             {
 
         static constexpr SG::sgkey_t MASK = (~static_cast<SG::sgkey_t>(0)) >> 2;
 
         // The helper object:
         static const std::hash< std::string > helper;
         // Let the helper do the work:
         return ( static_cast< SG::sgkey_t >( helper( name ) ) & MASK );
      }

isPrimitiveType()

bool xAOD::Utils::isPrimitiveType

(

std::string_view

typeName

)

Check if the type name describes a primitive type.

Definition at line 283 of file Control/xAODRootAccess/Root/Utils.cxx.

                                                    {
         TYPE_CHECK_INSTANTIATE(ISPRIMITIVETYPE_SPECIALIZE)
         return false;
      }

rootType()

char xAOD::Utils::rootType

(

char

typeidType

)

This function is used internally in the code when creating primitive dynamic auxiliary branches.

Get the character describing a given primitive type for ROOT.

I just took the code from SFrame to be honest...

Parameters

typeidType

The type name coming from typeid(...).name()

Returns

The character describing this type for TTree::Branch(...)

Definition at line 298 of file Control/xAODRootAccess/Root/Utils.cxx.

                                       {
 
         // Do the hard-coded translation:
         switch( typeidType ) {
 
         case 'c':
            return 'B';
            break;
         case 'h':
            return 'b';
            break;
         case 's':
            return 'S';
            break;
         case 't':
            return 's';
            break;
         case 'i':
            return 'I';
            break;
         case 'j':
            return 'i';
            break;
         case 'f':
            return 'F';
            break;
         case 'd':
            return 'D';
            break;
         case 'x':
            return 'L';
            break;
         case 'y':
         case 'm': // Not sure how platform-independent this one is...
            return 'l';
            break;
         case 'b':
            return 'O';
            break;
         }
 
         // If we didn't find this type:
         Error( "xAOD::Utils::rootType",
                XAOD_MESSAGE( "Received an unknown type: %c" ), typeidType );
         return '\0';
      }

sizeToString()

std::string xAOD::Utils::sizeToString

(

::Long64_t

bytes

)

Function for printing data sizes in human-readable format.

This function is used to produce nicely readable printouts for amounts of data.

Parameters

bytes

The amount of data expressed in bytes

Returns

A human-readable printout of the data size

Definition at line 131 of file Event/xAOD/xAODCore/Root/Utils.cxx.

                                                 {
 
      if( std::abs( bytes ) > 1e12 ) {
         return std::format( "{} TB", bytes * 1e-12 );
      } else if( std::abs( bytes ) > 1e9 ) {
         return std::format( "{} GB", bytes * 1e-9 );
      } else if( std::abs( bytes ) > 1e6 ) {
         return std::format( "{} MB", bytes * 1e-6 );
      } else if( std::abs( bytes ) > 1e3 ) {
         return std::format( "{} kB", bytes * 1e-3 );
      } else {
         return std::format( "{} bytes", bytes );
      }
   }

speedToString()

std::string xAOD::Utils::speedToString

(

::Double_t

bytespersec

)

Function for printing data processing speeds in a human-readable format.

Parameters

bytespersec

The speed expressed in bytes / seconds

Returns

A human-readable printout of the data processing speed

Definition at line 149 of file Event/xAOD/xAODCore/Root/Utils.cxx.

                                                        {
 
      if( ::fabs( bytespersec ) > 1e12 ) {
         return std::format( "{} TB/s", bytespersec * 1e-12 );
      } else if( ::fabs( bytespersec ) > 1e9 ) {
         return std::format( "{} GB/s", bytespersec * 1e-9 );
      } else if( ::fabs( bytespersec ) > 1e6 ) {
         return std::format( "{} MB/s", bytespersec * 1e-6 );
      } else if( ::fabs( bytespersec ) > 1e3 ) {
         return std::format( "{} kB/s", bytespersec * 1e-3 );
      } else {
         return std::format( "{} B/s", bytespersec );
      }
   }

timeToString()

std::string xAOD::Utils::timeToString

(

::Double_t

secs

)

Function creating a human-readable elapsed time printout.

Since I wasn't able to find a nice function printing elapsed times in a human-readable format, I ended up writing one.

This function is used in printing the statistics about an analysis.

Parameters

secs	An amount of time passed, expressed in seconds

Returns

A formatted, human-readable version of the amount of time passed

Definition at line 101 of file Event/xAOD/xAODCore/Root/Utils.cxx.

                                                {
 
      // Do meat of the calculation:
      const TimeStruct ts = timeToStruct( secs );
 
      // Construct the string:
      std::ostringstream result;
      if( ts.days ) {
         std::print (result, "{}d ", ts.days);
      }
      if( ts.hours || ts.days ) {
         std::print (result, "{}h ", ts.hours);
      }
      if( ts.minutes || ts.hours || ts.days ) {
         std::print (result, "{}m ", ts.minutes);
      }
      if( ts.seconds || ts.minutes || ts.hours || ts.days ) {
         std::print (result, "{}s ", ts.seconds);
      }
      std::print (result, "{}ms", ts.milliseconds);
 
      return result.str();
   }