xAOD::AuxSelection Class Reference

Class helping in dealing with dynamic branch selection. More...

#include <AuxSelection.h>

Collaboration diagram for xAOD::AuxSelection:

Public Member Functions
	AuxSelection ()
	Default constructor.
virtual void	selectAux (const std::set< std::string > &attributes)
	Select which variables should be written out.
virtual SG::auxid_set_t	getSelectedAuxIDs (const SG::auxid_set_t &fullset) const
	Return which variables were selected to be written out.

Protected Attributes
std::set< std::string >	m_names
	Properties following the variable selection convention.

Detailed Description

Class helping in dealing with dynamic branch selection.

This class is used by the code internally to select which of the dynamic branches should be written out into an output file.

Author

Marcin Nowak Marci.nosp@m.n.No.nosp@m.wak@c.nosp@m.ern..nosp@m.ch

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Revision

583607

Date

2014-02-17 12:02:08 +0100 (Mon, 17 Feb 2014)

Definition at line 31 of file AuxSelection.h.

Constructor & Destructor Documentation

AuxSelection()

xAOD::AuxSelection::AuxSelection

(

)

Default constructor.

Definition at line 32 of file AuxSelection.cxx.

      : m_names()
   {
   }

Member Function Documentation

getSelectedAuxIDs()

SG::auxid_set_t xAOD::AuxSelection::getSelectedAuxIDs ( const SG::auxid_set_t & fullset ) const

virtual

Return which variables were selected to be written out.

This function takes care of interpreting the options passed to ItemList in Athena, and TEvent in ROOT.

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

Parameters

fullset

The variables to be filtered based on the rules received

Returns

The list of variables to be written out

Definition at line 64 of file AuxSelection.cxx.

                                                                       {
      static const std::string asteriskStr{"*"}; //..or use a transparent comparitor
      // Check for the simplest case... all variables selected:
      if( m_names.empty() || ( m_names.find( asteriskStr ) != m_names.end() ) ) {
         return fullset;
      }
 
      // Start from an empty list:
      SG::auxid_set_t auxids;
      static const std::string hyphenStr{"-"};
      // Check if everything should be disregarded:
      if( m_names.find( hyphenStr ) != m_names.end() ) {
         return auxids;
      }
 
      // Check that the user only put positive or negative selections on the
      // list. They can't be mixed.
      bool sub = false, add = false;
      std::set< std::string >::const_iterator name_itr = m_names.begin();
      std::set< std::string >::const_iterator name_end = m_names.end();
      for( ; name_itr != name_end; ++name_itr ) {
         if( ( *name_itr )[ 0 ] == '-' ) {
            sub = true;
         } else {
            add = true;
         }
      }
      if( sub && add ) {
         std::cerr << "xAOD::AuxSelection ERROR Mixing + and - options for "
                   << "dynamic attributes" << std::endl;
         return fullset;  //better safe than sorry
      }
 
      if( add ) {
         // Start with an empty list, and loop over the selected names:
         name_itr = m_names.begin();
         name_end = m_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( fullset.test( auxid ) ) {
                  auxids.insert( auxid );
               }
            } else {
               // Check if a warning should be printed at this time or not:
               std::lock_guard<std::mutex> lock (mentionedMutex);
               if( ::mentionedVariableNames.insert( *name_itr ).second ) {
                  // Apparently we didn't complain about this name yet...
                  std::cerr << "xAOD::AuxSelection WARNING Selected dynamic "
                            << "Aux atribute \"" << *name_itr
                            << "\" not found in the registry" << std::endl;
               }
            }
         }
      } else {
         // Start from the full list:
         auxids = fullset;
         // ...and check which variables should be removed:
         for (SG::auxid_t id : fullset) {
            // Construct the name that we need to look for:
            const std::string attrname =
               "-" + SG::AuxTypeRegistry::instance().getName( id );
            // Check if it is in the list to be removed:
            if( m_names.find( attrname ) != m_names.end() ) {
               auxids.erase( id );
            }
         }
      }
 
      // Return the list of variables to be written out:
      return auxids;
   }

selectAux()

void xAOD::AuxSelection::selectAux ( const std::set< std::string > & attributes )

virtual

Select which variables should be written out.

Sets which variables should be selected from a store object.

The formalism is the following:

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

Parameters

attributes

The attributes from ItemList or TEvent

Definition at line 49 of file AuxSelection.cxx.

                                                                       {
 
      m_names = attributes;
      return;
   }

Member Data Documentation

m_names

std::set< std::string > xAOD::AuxSelection::m_names

protected

Properties following the variable selection convention.

Definition at line 45 of file AuxSelection.h.

---

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

• AuxSelection.h
• AuxSelection.cxx