xAOD::AuxCompression Class Reference

#include <AuxCompression.h>

Collaboration diagram for xAOD::AuxCompression:

Public Member Functions
	AuxCompression ()
	Default constructor.
virtual void	setCompressedAuxIDs (const std::map< unsigned int, std::set< std::string > > &attributes)
	Set which variables should be compressed per compression setting.
virtual std::map< unsigned int, SG::auxid_set_t >	getCompressedAuxIDs (const SG::auxid_set_t &fullset) const
	Return those variables that are selected to be compressed per compression setting.

Protected Attributes
std::map< unsigned int, std::set< std::string > >	m_compression_map
	Properties following the variable selection convention.

Detailed Description

Definition at line 20 of file AuxCompression.h.

Constructor & Destructor Documentation

AuxCompression()

xAOD::AuxCompression::AuxCompression

(

)

Default constructor.

Definition at line 18 of file AuxCompression.cxx.

    : m_compression_map{}
  {
  }

Member Function Documentation

getCompressedAuxIDs()

std::map< unsigned int, SG::auxid_set_t > xAOD::AuxCompression::getCompressedAuxIDs ( const SG::auxid_set_t & fullset ) const

virtual

Return those variables that are selected to be compressed per compression setting.

This function takes care of interpreting the options passed to CompressionList in Athena.

It filters the list of variables passed to it, and returns the IDs of just the variables that should be compressed.

Parameters

fullset

The variables to be compressed based on the rules received

Returns

The list of variables to be compressed per compression level

Definition at line 52 of file AuxCompression.cxx.

                                                                          {
    //these are unnecessary if using a transparent comparitor in the set type
    static const std::string hyphenStr{"-"};
    static const std::string asteriskStr{"*"};
    //
    // Create an empty result map
    std::map< unsigned int, SG::auxid_set_t > result;
 
    // Loop over the internal map set by setCompressedAuxIDs
    for(const auto& val : m_compression_map) {
 
      // Set helper variables
      const unsigned int nmantissa = val.first;
      const std::set< std::string> &names = val.second;
 
      // Start from an empty list
      SG::auxid_set_t auxids;
 
      // Check the simplest case, nothing to be compressed
      if( names.empty() || ( names.find(hyphenStr) != names.end() ) ) {
        continue;
      }
 
      // Check that the user only put positive or negative selections on the
      // list. They can't be mixed.
      bool sub = false, add = false;
      auto name_itr = names.begin();
      auto name_end = names.end();
      for( ; name_itr != name_end; ++name_itr ) {
         if( ( *name_itr )[ 0 ] == '-' ) {
            sub = true;
         } else {
            add = true;
         }
      }
      if( sub && add ) {
         // At this level we don't have a handle to the MsgStream,
         // otherwise it'd be preferred!
        std::println( std::cerr, "xAOD::AuxCompression ERROR Mixing + and - options for "
                      "compression attributes" );
         continue;  // Ill-defined input, not compressing anything just in case
      }
 
      // Loop over the full set, find all float and std::vector<float> variables, add to the list
      // This is our starting point as we currently compress only floats.
      // This way we don't mistakenly float compress a random type based on wrong user input.
      SG::auxid_set_t fauxids;
 
      // not using reference, because our iterator doesn't return a reference
      for ( const SG::auxid_t auxid : fullset ) {
        const std::string cType = SG::AuxTypeRegistry::instance().getTypeName( auxid );
        if( cType == "float" || cType == "std::vector<float>" ) {
          fauxids.insert( auxid );
        }
      }
 
      // Check if all floats are to be compressed
      if( names.find(asteriskStr) != names.end() ) {
        auxids = std::move(fauxids);
      }
      // Here comes the parsing either + or - as in AuxSelection that we follow closely
      else if( add ) {
        // Build the list of variables to be compressed starting from the empty list
        name_itr = names.begin();
        name_end = names.end();
        for( ; name_itr != name_end; ++name_itr ) {
           // Get the ID of this name
           const SG::auxid_t auxid = SG::AuxTypeRegistry::instance().findAuxID( *name_itr );
           if( auxid != SG::null_auxid ) {
              // Add this variable if it exists
              if( fauxids.test( auxid ) ) {
                 auxids.insert( auxid );
              }
           }
        }
      } else {
        // Build the list of variables to be compressed starting from the full float list
        auxids = fauxids;
        // Loop over all float variables and remove if matching
        for ( SG::auxid_t auxid : fauxids ) {
           // Construct the name of this ID
           const std::string attrname = "-" + SG::AuxTypeRegistry::instance().getName( auxid );
           // Check if it is in the list to be removed
           if( names.find( attrname ) != names.end() ) {
              auxids.erase( auxid );
           }
        }
      }
 
      // Finally fill the result map
      result[ nmantissa ] = std::move(auxids);
 
    } // End of loop over internal map
 
    return result; // Return the result map
  }

setCompressedAuxIDs()

void xAOD::AuxCompression::setCompressedAuxIDs ( const std::map< unsigned int, std::set< std::string > > & attributes )

virtual

Set which variables should be compressed per compression setting.

Set which variables should be compressed The formalism is the following:

• A set containing "*" will compress all float attributes passed to the object.
• An empty set, or a single "-" attribute will not compress any of the float attributes.
• A set of variables (without "-" as the first character of the variable names) will compress just the variables listed.
• A set of variable names, each prefixed by "-", will compress all variables but the ones listed.

Parameters

attributes

The attributes from CompressionList. By convention the key is the nmantissa and the value is the set of variables that should be compressed at that level.

Definition at line 37 of file AuxCompression.cxx.

                                                                                                          {
 
     m_compression_map = attributes;
     return;
  }

Member Data Documentation

m_compression_map

std::map< unsigned int, std::set< std::string > > xAOD::AuxCompression::m_compression_map

protected

Properties following the variable selection convention.

Definition at line 36 of file AuxCompression.h.

---

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

• AuxCompression.h
• AuxCompression.cxx