#include <BPhysBlindingTool.h>

Inheritance diagram for xAOD::BPhysBlindingTool:

Collaboration diagram for xAOD::BPhysBlindingTool:

Public Member Functions

BPhysBlindingTool (const std::string &name="BPhysBlindingTool")

Declare the correct constructor for Athena.

virtual StatusCode initialize () override

Method initialising the tool.

virtual StatusCode finalize () override

Method finalizing the tool.

virtual float doBlind (const float &val) override

Simply blind one positive float value.

virtual void print () const

Print the state of the tool.

ServiceHandle< StoreGateSvc > & evtStore ()

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

const ServiceHandle< StoreGateSvc > & detStore () const

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

virtual StatusCode sysInitialize () override

Perform system initialization for an algorithm.

virtual StatusCode sysStart () override

Handle START transition.

virtual std::vector< Gaudi::DataHandle * > inputHandles () const override

Return this algorithm's input handles.

virtual std::vector< Gaudi::DataHandle * > outputHandles () const override

Return this algorithm's output handles.

Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)

void updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream & msg () const

bool msgLvl (const MSG::Level lvl) const

Methods to be called by user classes

Simply unblind one (positive) float value with corrections

Parameters

[in]	val	: Blinded float value.
[in]	negativeSign	: flip sign before unblinding
[in]	offset	: after unblinding, shift by offset
[in]	factor	: after unblinding, stretch by factor

Returns: Unblinded positive float value; same value as input on error.

virtual float doUnblind (const float &val) override

Simply unblind one positive float value.

virtual float doBlind (const float &val, const bool &negativeSign, const float &offset, const float &factor) override

Simply blind one (positive) float value with corrections.

virtual float doUnblind (const float &val, const bool &negativeSign, const float &offset, const float &factor) override

Simply unblind one (positive) float value with corrections.

virtual StatusCode doBlind () override

Perform blinding of requested variables.

virtual StatusCode doUnblind () override

Perform unblinding of requested variables.

Additional helper functions, not directly mimicking Athena

template<class T>

const T * getProperty (const std::string &name) const

Get one of the tool's properties.

const std::string & msg_level_name () const __attribute__((deprecated))

A deprecated function for getting the message level's name.

const std::string & getName (const void *ptr) const

Get the name of an object that is / should be in the event store.

SG::sgkey_t getKey (const void *ptr) const

Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.
Perform blinding or unblinding action
virtual StatusCode	doBlindingAction (bool unblind=false)
Utility methods
Check whether an element is marked as passing a hypothesis.
virtual bool	pass (const SG::AuxElement &em, std::string hypo)
virtual std::vector< std::string >	getTokens (std::string input, std::string seperators)
	Tokenize a string using certain separators.
virtual std::string	vecToString (const std::vector< float > &v) const
	Convert vector of floats to string.
virtual std::string	vecToString (const std::vector< bool > &v) const
	Convert vector of bools to string.
Cache current event.
virtual StatusCode	cacheEvent ()

Protected Attributes
Job options
Vertex container name
std::string	m_vertexContainerName
std::string	m_varToBlindNames
	List of variables to blind.
std::string	m_blindingFlag
	Flag to indicate candidates for blinding.
std::vector< float >	m_vOffsets
	Offsets applied to values before blinding.
std::vector< float >	m_vFactors
	Scale factors applied before blinding.
std::vector< bool >	m_vNegSigns
	Flip signs to negative range?
std::string	m_blindKey
	Key for blinding.
std::string	m_unblindKey
	Key for unblinding.
Containers
xAOD::VertexContainer *	m_vtxContainer
xAOD::VertexAuxContainer *	m_vtxAuxContainer
Event caching
int	m_cachedRun
int	m_cachedEvent
Counters
long	m_eventsForBlindingSeen
long	m_candidatesForBlindingSeen
long	m_eventsForUnblindingSeen
long	m_candidatesForUnblindingSeen
long	m_eventsBlinded
long	m_candidatesBlinded
long	m_eventsUnblinded
long	m_candidatesUnblinded

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::vector< std::string >	m_vVarNames
	Vector of variable names.
SimpleEncrypter	m_senc
	Instance of SimpleEncrypter.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 85 of file BPhysBlindingTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ BPhysBlindingTool()

xAOD::BPhysBlindingTool::BPhysBlindingTool ( const std::string & name = "BPhysBlindingTool" )

Declare the correct constructor for Athena.

Regular AsgTool constructor

Definition at line 25 of file BPhysBlindingTool.cxx.

    : asg::AsgTool( name ),
      m_vtxContainer(nullptr), m_vtxAuxContainer(nullptr),
      m_cachedRun(-1), m_cachedEvent(-1),
      m_eventsForBlindingSeen(0),
      m_candidatesForBlindingSeen(0),
      m_eventsForUnblindingSeen(0),
      m_candidatesForUnblindingSeen(0),
      m_eventsBlinded(0),
      m_candidatesBlinded(0),
      m_eventsUnblinded(0),
      m_candidatesUnblinded(0) {
 
#ifdef ASGTOOL_ATHENA
    declareInterface< IBPhysBlindingTool >( this );
#endif // ASGTOOL_ATHENA
 
    // Vertex container
    declareProperty("VertexContainerName", m_vertexContainerName = "");
 
    // List of variables to blind
    // (as concatenated string using . as delimiter) 
    declareProperty("VarToBlindNames", m_varToBlindNames = "");
 
    // Flag to indicate candidates for blinding
    // Left empty: Blind values for all candidates.
    declareProperty("BlindingFlag"   , m_blindingFlag = "");
    
    // Offsets applied to values before blinding
    // List must have same length as VarToBlindNames or zero.
    declareProperty("BlindingOffsets", m_vOffsets);
 
    // Scale factors applied before blinding
    // List must have same length as VarToBlindNames or zero.
    declareProperty("BlindingFactors", m_vFactors);
 
    // Flip signs to negative range?
    declareProperty("NegativeSigns"  , m_vNegSigns);
    
    // Key for blinding
    declareProperty("BlindingKey"    , m_blindKey = "");
    
    // Key for unblinding
    declareProperty("UnblindingKey"  , m_unblindKey = "");
 
  }

Member Function Documentation

◆ cacheEvent()

StatusCode xAOD::BPhysBlindingTool::cacheEvent ( )

protectedvirtual

Definition at line 351 of file BPhysBlindingTool.cxx.

                                           {
 
    ATH_MSG_DEBUG("BPhysBlindingTool::cacheEvent -- begin");
    
    const xAOD::EventInfo* eventInfo = NULL;
    ATH_CHECK(evtStore()->retrieve(eventInfo, "EventInfo"));
 
    if ( m_cachedRun   != (int)eventInfo->runNumber() ||
         m_cachedEvent != (int)eventInfo->eventNumber() ) {
 
      // note update
      m_cachedRun   = eventInfo->runNumber();
      m_cachedEvent = eventInfo->eventNumber();
 
      ATH_MSG_DEBUG("BPhysBlindingTool::cacheEvent: caching now: "
                    << "run " << m_cachedRun << " event " << m_cachedEvent);
 
      // retrieve vertices container
      m_vtxContainer    = nullptr;
      m_vtxAuxContainer = nullptr;
 
      if ( evtStore()->transientContains<xAOD::VertexContainer>(m_vertexContainerName) ) {
        ATH_MSG_DEBUG("In transient store: " << m_vertexContainerName);
        ATH_CHECK(evtStore()->retrieve(m_vtxContainer,
                                       m_vertexContainerName));
        ATH_CHECK(evtStore()->retrieve(m_vtxAuxContainer,
                                       m_vertexContainerName+"Aux."));
      }  else {
        ATH_MSG_DEBUG("Not in transient store: " << m_vertexContainerName);
        const xAOD::VertexContainer*    constVtxContainer    = nullptr;
        const xAOD::VertexAuxContainer* constVtxAuxContainer = nullptr;
        ATH_CHECK(evtStore()->retrieve(constVtxContainer,
                                       m_vertexContainerName));
        ATH_CHECK(evtStore()->retrieve(constVtxAuxContainer,
                                       m_vertexContainerName+"Aux."));
        // create a copy
        m_vtxContainer    = new xAOD::VertexContainer();
        m_vtxAuxContainer = new xAOD::VertexAuxContainer();
        m_vtxContainer->setStore(m_vtxAuxContainer);
        for (const xAOD::Vertex* constVtx : *constVtxContainer) {
          xAOD::Vertex* vtx = new xAOD::Vertex();
          m_vtxContainer->push_back(vtx);
          *vtx = *constVtx;
        }
        ATH_CHECK(evtStore()->record(m_vtxContainer,
                                     m_vertexContainerName));
        ATH_CHECK(evtStore()->record(m_vtxAuxContainer,
                                     m_vertexContainerName+"Aux."));
      }
      
      ATH_MSG_DEBUG("Found vertex collection with key "
                    << m_vertexContainerName);
 
    } // if new run/event
    
    ATH_MSG_DEBUG("BPhysBlindingTool::cacheEvent -- end");
    
    // Return gracefully:
    return StatusCode::SUCCESS;
  } 

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ doBlind() [1/3]

StatusCode xAOD::BPhysBlindingTool::doBlind ( )

overridevirtual

Perform blinding of requested variables.

Implements xAOD::IBPhysBlindingTool.

Definition at line 237 of file BPhysBlindingTool.cxx.

                                        {
 
    if ( m_blindKey == "" ) {
      ATH_MSG_WARNING("Can not blind without blinding key!");
    } else {
      ATH_CHECK( doBlindingAction(false) );
    }
    
    // Return gracefully:
    return StatusCode::SUCCESS;
  }

◆ doBlind() [2/3]

float xAOD::BPhysBlindingTool::doBlind ( const float & val )

overridevirtual

Simply blind one positive float value.

Parameters

[in] val : positive float value to blind.

Returns: Blinded positive float value; same value as input on error.

Implements xAOD::IBPhysBlindingTool.

Definition at line 172 of file BPhysBlindingTool.cxx.

                                                   {
 
    return m_senc.encrypt(val);
  }  

◆ doBlind() [3/3]

float xAOD::BPhysBlindingTool::doBlind	(	const float &	val,
		const bool &	negativeSign,
		const float &	offset,
		const float &	factor )

overridevirtual

Simply blind one (positive) float value with corrections.

Parameters

[in]	val	: float value to blind.
[in]	negativeSign	: flip sign after blinding
[in]	offset	: before blinding, shift by offset
[in]	factor	: before blinding, stretch by factor

Returns: Blinded float value; same value as input on error.

Implements xAOD::IBPhysBlindingTool.

Definition at line 186 of file BPhysBlindingTool.cxx.

                                                        {
 
    // adjustment if requested
    float bval(val);
    float cval = val*factor + offset;
    if ( cval > 0. ) {
      // perform actual blinding
      bval = m_senc.encrypt(cval);
      if (negativeSign) bval *= -1.;
    } else {
      ATH_MSG_WARNING("Blinding: Corrected value not positive: "
                      << val << Form(" (%a) -> ", val)
                      << cval << Form(" (%a)", cval));
    } // if cval > 0
 
    return bval;
  }  

◆ doBlindingAction()

StatusCode xAOD::BPhysBlindingTool::doBlindingAction ( bool unblind = false )

protectedvirtual

Definition at line 271 of file BPhysBlindingTool.cxx.

                                                             {
 
    ATH_CHECK(cacheEvent());
 
    // counters
    if ( unblind ) {
      ++m_eventsForUnblindingSeen;
    } else {
      ++m_eventsForBlindingSeen;
    }
    
    if ( m_vVarNames.size() > 0 ) {
      long candidatesBlinded(0);
      long candidatesUnblinded(0);
      // loop over vertices
      // int ivtx(0);
      for (xAOD::VertexContainer::const_iterator
             vtxItr = m_vtxContainer->begin();
           vtxItr != m_vtxContainer->end(); ++vtxItr) {
        // counters
        if ( unblind ) {
          ++m_candidatesForUnblindingSeen;
        } else {
          ++m_candidatesForBlindingSeen;
        }
        const xAOD::Vertex* vtx = *vtxItr;
        // check whether to apply (un-)blinding to this candidate
        if ( m_blindingFlag == "" || pass(*vtx, m_blindingFlag) ) {
          // counters
          if ( unblind ) {
            ++candidatesUnblinded;
          } else {
            ++candidatesBlinded;
          }
          // loop over variable names
          for (size_t iv=0; iv<m_vVarNames.size(); ++iv) {
            SG::AuxElement::Decorator<float> floatDec(m_vVarNames[iv]);
            // check for variable
            if ( floatDec.isAvailable(*vtx) ) {
              float val = floatDec(*vtx);
              if ( unblind ) {
                // unblinding
                floatDec(*vtx) = doUnblind(val, m_vNegSigns[iv],
                                           m_vOffsets[iv], m_vFactors[iv]);
                ATH_MSG_DEBUG("Unblind: " << val << Form(" (%a) -> ", val)
                              << floatDec(*vtx)
                              << Form(" (%a)", floatDec(*vtx)));
              } else {
                // blinding
                floatDec(*vtx) = doBlind(val, m_vNegSigns[iv],
                                         m_vOffsets[iv], m_vFactors[iv]);
                ATH_MSG_DEBUG("Blind: " << val << Form(" (%a) -> ", val)
                              << floatDec(*vtx)
                              << Form(" (%a)", floatDec(*vtx)));
              } // if unblind
            } else {
              ATH_MSG_WARNING("Missing variable " << m_vVarNames[iv]);
            } // if isAvailable
          } // for m_vVarNames
        } // if blinding
      } // for iv
      // counters
      if ( unblind ) {
        m_candidatesUnblinded += candidatesUnblinded;
        if ( candidatesUnblinded > 0 ) ++m_eventsUnblinded;
      } else {
        m_candidatesBlinded += candidatesBlinded;
        if ( candidatesBlinded > 0 ) ++m_eventsBlinded;
      }
    } // if m_vVarNames.size()
    
    // Return gracefully:
    return StatusCode::SUCCESS;    
  }

◆ doUnblind() [1/3]

StatusCode xAOD::BPhysBlindingTool::doUnblind ( )

overridevirtual

Perform unblinding of requested variables.

Implements xAOD::IBPhysBlindingTool.

Definition at line 251 of file BPhysBlindingTool.cxx.

                                          {
    
    if ( m_unblindKey == "" ) {
      ATH_MSG_WARNING("Can not unblind without unblinding key!");
    } else {
      ATH_CHECK( doBlindingAction(true) );
    }
 
    // Return gracefully:
    return StatusCode::SUCCESS;
  }

◆ doUnblind() [2/3]

float xAOD::BPhysBlindingTool::doUnblind ( const float & val )

overridevirtual

Simply unblind one positive float value.

Implements xAOD::IBPhysBlindingTool.

Definition at line 179 of file BPhysBlindingTool.cxx.

                                                     {
 
    return m_senc.decrypt(val);
  }

◆ doUnblind() [3/3]

float xAOD::BPhysBlindingTool::doUnblind	(	const float &	val,
		const bool &	negativeSign,
		const float &	offset,
		const float &	factor )

overridevirtual

Simply unblind one (positive) float value with corrections.

Implements xAOD::IBPhysBlindingTool.

Definition at line 209 of file BPhysBlindingTool.cxx.

                                                          {
 
    float bval(val), cval(val);
    if (negativeSign) bval *= -1.;
    // if ( bval > 0. || isnan(bval) ) {
    if ( bval > 0. || !std::isnormal(bval) ) {
      // perform actual unblinding
      cval = m_senc.decrypt(bval);
      if ( factor != 0. ) {
        cval = (cval - offset)/factor;
      } else {
        ATH_MSG_WARNING("Unblinding: BlindingFactor == 0!: "
                        << val << Form(" (%a)", val));
      } // if m_vFactors[ivtx] != 0
    } else {
      ATH_MSG_WARNING("Unblinding: Corrected value not positive: "
                      << val << Form(" (%a) -> ", val)
                      << bval << Form(" (%a)", bval));
    } // if bval > 0
 
    return cval;
  }

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ finalize()

StatusCode xAOD::BPhysBlindingTool::finalize ( )

overridevirtual

Method finalizing the tool.

Implements xAOD::IBPhysBlindingTool.

Definition at line 144 of file BPhysBlindingTool.cxx.

                                         {
 
    ATH_MSG_DEBUG( "Finalizing xAOD::BPhysBlindingTool" );
 
    ATH_MSG_INFO("Statistics for " << name() << ":");
    ATH_MSG_INFO(Form("N_eventsForBlindingSeen       : %10ld",
                      m_eventsForBlindingSeen));
    ATH_MSG_INFO(Form("N_eventsBlinded               : %10ld",
                      m_eventsBlinded));
    ATH_MSG_INFO(Form("N_eventsForUnblindingSeen     : %10ld",
                      m_eventsForUnblindingSeen));
    ATH_MSG_INFO(Form("N_eventsUnblinded             : %10ld",
                      m_eventsUnblinded));
    ATH_MSG_INFO(Form("N_candidatesForBlindingSeen   : %10ld",
                      m_candidatesForBlindingSeen));
    ATH_MSG_INFO(Form("N_candidatesBlinded           : %10ld",
                      m_candidatesBlinded));
    ATH_MSG_INFO(Form("N_candidatesForUnblindingSeen : %10ld",
                      m_candidatesForUnblindingSeen));
    ATH_MSG_INFO(Form("N_candidatesUnblinded         : %10ld",
                      m_candidatesUnblinded));
 
    // Return gracefully:
    return StatusCode::SUCCESS;
  }  

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also: asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns: The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

◆ getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also: asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns: The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

◆ getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

◆ getTokens()

std::vector< std::string > xAOD::BPhysBlindingTool::getTokens	(	std::string	input,
		std::string	seperators )

protectedvirtual

Tokenize a string using certain separators.

Definition at line 426 of file BPhysBlindingTool.cxx.

                                                                    {
    
    std::vector<std::string> tokens;
    boost::char_separator<char> sep(seperators.c_str());
    typedef boost::tokenizer<boost::char_separator<char> > Tokenizer_t;
    Tokenizer_t tokenizer(input, sep);
    for (auto& token : tokenizer) {
      tokens.push_back(token);
    }
    return tokens;
  }

◆ initialize()

StatusCode xAOD::BPhysBlindingTool::initialize ( void )

overridevirtual

Method initialising the tool.

Reimplemented from asg::AsgTool.

Definition at line 72 of file BPhysBlindingTool.cxx.

                                           {
    
    // Greet the user:
    ATH_MSG_DEBUG( "Initializing xAOD::BPhysBlindingTool" );
 
    // Setup of variables
    if ( m_vertexContainerName == "" ) {
      ATH_MSG_INFO("No vertex container name provided.");
    }
 
    if ( m_varToBlindNames != ""  ) {
      m_vVarNames = getTokens(m_varToBlindNames, ".,:;|");
    }
 
    // Blinding and unblinding keys
    if ( m_blindKey == "" && m_unblindKey == "" ) {
      ATH_MSG_ERROR("You must at least set a key for blinding or unblinding!");
    } else {
      if ( m_blindKey != "" ) {
        m_senc.setPubKey(m_blindKey);
        ATH_MSG_INFO("Setting blinding key.");
      }
      if ( m_unblindKey != "" ) {
        m_senc.setPrivKey(m_unblindKey);
        ATH_MSG_INFO("Setting unblinding key.");
      }
    }
 
    // make sure offsets vector is of correct length
    if ( m_vOffsets.size() < m_vVarNames.size() ) {
      for (uint i=m_vOffsets.size(); i<m_vVarNames.size(); ++i) {
        m_vOffsets.push_back(0.);
      }
      ATH_MSG_INFO("Extending BlindingOffsets list ...");
    } else if ( m_vOffsets.size() > m_vVarNames.size() ) {
      ATH_MSG_WARNING("BlindingOffsets list longer than VarToBlindNames.");
    }
    
    // make sure scale factors vector is of correct length
    if ( m_vFactors.size() < m_vVarNames.size() ) {
      for (uint i=m_vFactors.size(); i<m_vVarNames.size(); ++i) {
        m_vFactors.push_back(1.);
      }
      ATH_MSG_INFO("Extending BlindingOffsets list ...");
    } else if ( m_vFactors.size() > m_vVarNames.size() ) {
      ATH_MSG_WARNING("BlindingFactors list longer than VarToBlindNames.");
    }
 
    // make sure negative signs vector is of correct length
    if ( m_vNegSigns.size() < m_vVarNames.size() ) {
      for (uint i=m_vNegSigns.size(); i<m_vVarNames.size(); ++i) {
        m_vNegSigns.push_back(1.);
      }
      ATH_MSG_INFO("Extending NegativeSigns list ...");
    } else if ( m_vNegSigns.size() > m_vVarNames.size() ) {
      ATH_MSG_WARNING("NegativeSigns list longer than VarToBlindNames.");
    }
 
    // some info for the job log
    ATH_MSG_INFO("VertexContainerName        : " << m_vertexContainerName);
    ATH_MSG_INFO("BlindingFlag               : " << m_blindingFlag);
    ATH_MSG_INFO("VarToBlindNames            : " << m_varToBlindNames);
    ATH_MSG_INFO("BlindingOffsets            : " << vecToString(m_vOffsets));
    ATH_MSG_INFO("BlindingFactors            : " << vecToString(m_vFactors));
    ATH_MSG_INFO("NegativeSigns              : " << vecToString(m_vNegSigns));
    ATH_MSG_INFO("BlindingKey                : " << m_blindKey);
    ATH_MSG_INFO("UnblindingKey              : " << m_unblindKey);
 
    // Return gracefully:
    return StatusCode::SUCCESS;
  }

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns: The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ pass()

bool xAOD::BPhysBlindingTool::pass	(	const SG::AuxElement &	em,
		std::string	hypo )

protectedvirtual

Definition at line 415 of file BPhysBlindingTool.cxx.

                                                                     {
    
    if ( !hypo.starts_with( "passed_") )
      hypo = "passed_" + hypo;
    SG::AuxElement::Accessor<Char_t> flagAcc(hypo);
    return flagAcc.isAvailable(em) && flagAcc(em) != 0;
  }

◆ print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

◆ vecToString() [1/2]

std::string xAOD::BPhysBlindingTool::vecToString ( const std::vector< bool > & v ) const

protectedvirtual

Convert vector of bools to string.

Definition at line 453 of file BPhysBlindingTool.cxx.

           {
     std::string str("[");
     for (unsigned int i=0; i<v.size(); ++i) {
       str += std::to_string(v[i]);
       if ( i < v.size()-1 ) str += ",";
     }
     str += "]";
     return str;
  }

◆ vecToString() [2/2]

std::string xAOD::BPhysBlindingTool::vecToString ( const std::vector< float > & v ) const

protectedvirtual

Convert vector of floats to string.

Definition at line 440 of file BPhysBlindingTool.cxx.

           {
     std::string str("[");
     for (unsigned int i=0; i<v.size(); ++i) {
       str += std::to_string(v[i]);
       if ( i < v.size()-1 ) str += ",";
     }
     str += "]";
     return str;
  }

Member Data Documentation

◆ m_blindingFlag

std::string xAOD::BPhysBlindingTool::m_blindingFlag

protected

Flag to indicate candidates for blinding.

Left empty: Blind values for all candidates.

Definition at line 209 of file BPhysBlindingTool.h.

◆ m_blindKey

std::string xAOD::BPhysBlindingTool::m_blindKey

protected

Key for blinding.

Definition at line 230 of file BPhysBlindingTool.h.

◆ m_cachedEvent

int xAOD::BPhysBlindingTool::m_cachedEvent

protected

Definition at line 247 of file BPhysBlindingTool.h.

◆ m_cachedRun

int xAOD::BPhysBlindingTool::m_cachedRun

protected

Definition at line 246 of file BPhysBlindingTool.h.

◆ m_candidatesBlinded

long xAOD::BPhysBlindingTool::m_candidatesBlinded

protected

Definition at line 259 of file BPhysBlindingTool.h.

◆ m_candidatesForBlindingSeen

long xAOD::BPhysBlindingTool::m_candidatesForBlindingSeen

protected

Definition at line 255 of file BPhysBlindingTool.h.

◆ m_candidatesForUnblindingSeen

long xAOD::BPhysBlindingTool::m_candidatesForUnblindingSeen

protected

Definition at line 257 of file BPhysBlindingTool.h.

◆ m_candidatesUnblinded

long xAOD::BPhysBlindingTool::m_candidatesUnblinded

protected

Definition at line 261 of file BPhysBlindingTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_eventsBlinded

long xAOD::BPhysBlindingTool::m_eventsBlinded

protected

Definition at line 258 of file BPhysBlindingTool.h.

◆ m_eventsForBlindingSeen

long xAOD::BPhysBlindingTool::m_eventsForBlindingSeen

protected

Definition at line 254 of file BPhysBlindingTool.h.

◆ m_eventsForUnblindingSeen

long xAOD::BPhysBlindingTool::m_eventsForUnblindingSeen

protected

Definition at line 256 of file BPhysBlindingTool.h.

◆ m_eventsUnblinded

long xAOD::BPhysBlindingTool::m_eventsUnblinded

protected

Definition at line 260 of file BPhysBlindingTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_senc

SimpleEncrypter xAOD::BPhysBlindingTool::m_senc

private

Instance of SimpleEncrypter.

Definition at line 272 of file BPhysBlindingTool.h.

◆ m_unblindKey

std::string xAOD::BPhysBlindingTool::m_unblindKey

protected

Key for unblinding.

Definition at line 233 of file BPhysBlindingTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_varToBlindNames

std::string xAOD::BPhysBlindingTool::m_varToBlindNames

protected

List of variables to blind.

(as concatenated string using . as delimiter)

Definition at line 204 of file BPhysBlindingTool.h.

◆ m_vertexContainerName

std::string xAOD::BPhysBlindingTool::m_vertexContainerName

protected

Definition at line 199 of file BPhysBlindingTool.h.

◆ m_vFactors

std::vector<float> xAOD::BPhysBlindingTool::m_vFactors

protected

Scale factors applied before blinding.

List must have same length as VarToBlindNames or zero. Applied before blinding/after unblinding.

Definition at line 221 of file BPhysBlindingTool.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vNegSigns

std::vector<bool> xAOD::BPhysBlindingTool::m_vNegSigns

protected

Flip signs to negative range?

List must have same length as VarToBlindNames or zero. Applied after blinding/before unblinding.

Definition at line 227 of file BPhysBlindingTool.h.

◆ m_vOffsets

std::vector<float> xAOD::BPhysBlindingTool::m_vOffsets

protected

Offsets applied to values before blinding.

List must have same length as VarToBlindNames or zero. Applied before blinding/after unblinding.

Definition at line 215 of file BPhysBlindingTool.h.

◆ m_vtxAuxContainer

xAOD::VertexAuxContainer* xAOD::BPhysBlindingTool::m_vtxAuxContainer

protected

Definition at line 240 of file BPhysBlindingTool.h.

◆ m_vtxContainer

xAOD::VertexContainer* xAOD::BPhysBlindingTool::m_vtxContainer

protected

Definition at line 239 of file BPhysBlindingTool.h.

◆ m_vVarNames

std::vector<std::string> xAOD::BPhysBlindingTool::m_vVarNames

private

Vector of variable names.

Definition at line 267 of file BPhysBlindingTool.h.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ BPhysBlindingTool()

Member Function Documentation

◆ cacheEvent()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ doBlind() [1/3]

◆ doBlind() [2/3]

◆ doBlind() [3/3]

◆ doBlindingAction()

◆ doUnblind() [1/3]

◆ doUnblind() [2/3]

◆ doUnblind() [3/3]

◆ evtStore()

◆ extraDeps_update_handler()

◆ finalize()

◆ getKey()

◆ getName()

◆ getProperty()

◆ getTokens()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ msg_level_name()

◆ msgLvl()

◆ outputHandles()

◆ pass()

◆ print()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

◆ vecToString() [1/2]

◆ vecToString() [2/2]

Member Data Documentation

◆ m_blindingFlag

◆ m_blindKey

◆ m_cachedEvent

◆ m_cachedRun

◆ m_candidatesBlinded

◆ m_candidatesForBlindingSeen

◆ m_candidatesForUnblindingSeen

◆ m_candidatesUnblinded

◆ m_detStore

◆ m_eventsBlinded

◆ m_eventsForBlindingSeen

◆ m_eventsForUnblindingSeen

◆ m_eventsUnblinded

◆ m_evtStore

◆ m_senc

◆ m_unblindKey

◆ m_varHandleArraysDeclared

◆ m_varToBlindNames

◆ m_vertexContainerName

◆ m_vFactors

◆ m_vhka

◆ m_vNegSigns

◆ m_vOffsets

◆ m_vtxAuxContainer

◆ m_vtxContainer

◆ m_vVarNames