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. More...
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. More...
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. More...
char	rootType (char typeidType)
	This function is used internally in the code when creating primitive dynamic auxiliary branches. More...
std::string	getTypeName (const std::type_info &ti)
	This function is necessary in order to create type names that ROOT can understand. More...
std::string	getFirstBranchMatch (TTree *tree, const std::string &pre)
	Search for branches, returns search term on no result. More...
std::string	timeToString (::Double_t secs)
	Function creating a human-readable elapsed time printout. More...
std::string	sizeToString (::Long64_t bytes)
	Function for printing data sizes in human-readable format. More...
std::string	speedToString (::Double_t bytespersec)
	Function for printing data processing speeds in a human-readable format. More...

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.

It needs to work in sync wiht 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 144 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;
      }

getFirstBranchMatch()

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

Search for branches, returns search term on no result.

Definition at line 318 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()

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 169 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 );
         }
      }

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 285 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 125 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 );
      }

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 226 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 129 of file Event/xAOD/xAODCore/Root/Utils.cxx.

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

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 151 of file Event/xAOD/xAODCore/Root/Utils.cxx.

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

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 99 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 ) {
         result << ts.days << "d ";
      }
      if( ts.hours || ts.days ) {
         result << ts.hours << "h ";
      }
      if( ts.minutes || ts.hours || ts.days ) {
         result << ts.minutes << "m ";
      }
      if( ts.seconds || ts.minutes || ts.hours || ts.days ) {
         result << ts.seconds << "s ";
      }
      result << ts.miliseconds << "ms";
 
      return result.str();
   }