#include <JetConstituentModSequence.h>

Inheritance diagram for JetConstituentModSequence:

Public Member Functions
	JetConstituentModSequence (const std::string &name)
StatusCode	initialize ()
	Dummy implementation of the initialisation function.
int	execute () const
	Method to be called for each event.
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
virtual int	inputContainerNames (std::vector< std::string > &connames)
	Method to return the list of input containers.
virtual int	outputContainerNames (std::vector< std::string > &connames)
	Method to return the list of output containers.
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
template<class T>
StatusCode	copyModRecord (const SG::ReadHandleKey< T > &, const SG::WriteHandleKey< T > &) const
	helper function to cast, shallow copy and record a container.
template<class T, class U>
StatusCode	copyModRecordFlowLike (const SG::ReadHandleKey< T > &, const SG::ReadHandleKey< T > &, const SG::WriteHandleKey< T > &, const SG::WriteHandleKey< T > &, const SG::WriteHandleKey< T > &) const
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.

Protected Attributes
Gaudi::Property< std::string >	m_inputContainer {this, "InputContainer", "", "The input container for the sequence"}
Gaudi::Property< std::string >	m_outputContainer = {this, "OutputContainer", "", "The output container for the sequence"}
Gaudi::Property< bool >	m_byVertex = {this, "DoByVertex", false, "True if we should match to each primary vertex, not just PV0"}
SG::ReadHandleKey< xAOD::VertexContainer >	m_vertexContainerKey {this, "VertexContainerKey", "PrimaryVertices", "Reconstructed primary vertex container name"}
unsigned short	m_inputType
ToolHandleArray< IJetConstituentModifier >	m_modifiers {this , "Modifiers" , {} , "List of constit modifier tools."}
ToolHandle< GenericMonitoringTool >	m_monTool {this,"MonTool","","Monitoring tool"}
bool	m_saveAsShallow = true
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_inClusterKey {this, "InClusterKey", "", "ReadHandleKey for unmodified CaloClusters"}
SG::WriteHandleKey< xAOD::CaloClusterContainer >	m_outClusterKey {this, "OutClusterKey", "", "WriteHandleKey for modified CaloClusters"}
SG::ReadHandleKey< xAOD::TrackCaloClusterContainer >	m_inTCCKey {this, "InTCCKey", "", "ReadHandleKey for unmodified TrackCaloClusters"}
SG::WriteHandleKey< xAOD::TrackCaloClusterContainer >	m_outTCCKey {this, "OutTCCKey", "", "WriteHandleKey for modified TrackCaloClusters"}
SG::ReadHandleKey< xAOD::PFOContainer >	m_inChargedPFOKey {this, "InChargedPFOKey", "", "ReadHandleKey for modified Charged PFlow Objects"}
SG::WriteHandleKey< xAOD::PFOContainer >	m_outChargedPFOKey {this, "OutChargedPFOKey", "", "WriteHandleKey for modified Charged PFlow Objects"}
SG::ReadHandleKey< xAOD::PFOContainer >	m_inNeutralPFOKey {this, "InNeutralPFOKey", "", "ReadHandleKey for modified Neutral PFlow Objects"}
SG::WriteHandleKey< xAOD::PFOContainer >	m_outNeutralPFOKey {this, "OutNeutralPFOKey", "", "WriteHandleKey for modified Neutral PFlow Objects"}
SG::WriteHandleKey< xAOD::PFOContainer >	m_outAllPFOKey {this, "OutAllPFOKey", "", "WriteHandleKey for all modified PFlow Objects"}
SG::ReadHandleKey< xAOD::FlowElementContainer >	m_inChargedFEKey {this, "InChargedFEKey", "", "ReadHandleKey for modified Charged FlowElements"}
SG::WriteHandleKey< xAOD::FlowElementContainer >	m_outChargedFEKey {this, "OutChargedFEKey", "", "WriteHandleKey for modified Charged FlowElements"}
SG::ReadHandleKey< xAOD::FlowElementContainer >	m_inNeutralFEKey {this, "InNeutralFEKey", "", "ReadHandleKey for modified Neutral FlowElements"}
SG::WriteHandleKey< xAOD::FlowElementContainer >	m_outNeutralFEKey {this, "OutNeutralFEKey", "", "WriteHandleKey for modified Neutral FlowElements"}
SG::WriteHandleKey< xAOD::FlowElementContainer >	m_outAllFEKey {this, "OutAllFEKey", "", "WriteHandleKey for all modified FlowElements"}
SG::ReadDecorHandleKeyArray< xAOD::FlowElementContainer >	m_inChargedFEDecorKeys {this, "InChargedFEDecorKeys", {}, "Dummy keys that force all neccessary charged FlowElement decorations to be applied before running this algorithm"}
SG::ReadDecorHandleKeyArray< xAOD::FlowElementContainer >	m_inNeutralFEDecorKeys {this, "InNeutralFEDecorKeys", {}, "Dummy keys that force all neccessary neutral FlowElement decorations to be applied before running this algorithm"}

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
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 51 of file JetConstituentModSequence.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

◆ JetConstituentModSequence()

JetConstituentModSequence::JetConstituentModSequence ( const std::string & name )

Definition at line 26 of file JetConstituentModSequence.cxx.

                                                                         :
  asg::AsgTool(name) {
 
#ifdef ASG_TOOL_ATHENA
  declareInterface<IJetConstituentModifier>(this);
#endif
  declareProperty("InputType", m_inputType, "The xAOD type name for the input container.");
  declareProperty("SaveAsShallow", m_saveAsShallow=true, "Save as shallow copy");
 
}

Member Function Documentation

◆ copyModRecord()

template<class T>

StatusCode JetConstituentModSequence::copyModRecord	(	const SG::ReadHandleKey< T > &	inKey,
		const SG::WriteHandleKey< T > &	outKey ) const

protected

helper function to cast, shallow copy and record a container.

Definition at line 121 of file JetConstituentModSequence.h.

                                                                                  {
 
  /* Read in a container of (type is template parameter),
     optionally modify the elements of this container, and store.
     This puts a (modified) copy of the container  into storegate.
  */
  
  auto inHandle = makeHandle(inKey);
  if(!inHandle.isValid()){
    ATH_MSG_WARNING("Unable to retrieve input container from " << inKey.key());
    return StatusCode::FAILURE;
  }
 
  std::pair< T*, xAOD::ShallowAuxContainer* > newconstit =
    xAOD::shallowCopyContainer(*inHandle);    
  newconstit.second->setShallowIO(m_saveAsShallow);
 
  for (auto t : m_modifiers) {ATH_CHECK(t->process(newconstit.first));}
 
  auto handle = makeHandle(outKey);
  ATH_CHECK(handle.record(std::unique_ptr<T>(newconstit.first),
                          std::unique_ptr<xAOD::ShallowAuxContainer>(newconstit.second)));
  
  xAOD::setOriginalObjectLink(*inHandle, *handle);
  
  return StatusCode::SUCCESS;
}

◆ copyModRecordFlowLike()

template<class T, class U>

StatusCode JetConstituentModSequence::copyModRecordFlowLike	(	const SG::ReadHandleKey< T > &	inNeutralKey,
		const SG::ReadHandleKey< T > &	inChargedKey,
		const SG::WriteHandleKey< T > &	outNeutralKey,
		const SG::WriteHandleKey< T > &	outChargedKey,
		const SG::WriteHandleKey< T > &	outAllKey ) const

protected

Definition at line 150 of file JetConstituentModSequence.h.

                                                                                                                                                                                                                                                                                                     {
 
  // Cannot be handled the same way as other objects (e.g. clusters),
  // because the data is split between two containers, but we need
  // information from both to do the modifications.
  //
  // The logic is:
  //   1. Copy the charged container via a shallow copy
  //   2. Create N copies of neutral container for by-vertex reconstruction OR
  //      Create a single copy of neutral container for regular jet reconstruction
  //   3. Merge into a combined view container
  //   4. Modify the combined container
 
  // 1. Retrieve the input containers
  SG::ReadHandle<T> inNeutralHandle = makeHandle(inNeutralKey);
  SG::ReadHandle<T> inChargedHandle = makeHandle(inChargedKey);
  if(!inNeutralHandle.isValid()){
    ATH_MSG_WARNING("Unable to retrieve input containers \""
                    << inNeutralKey.key() << "\" and \""
                    << inChargedKey.key() << "\"");
    return StatusCode::FAILURE;
  }
 
  unsigned numNeutralCopies = 1;
  if (m_byVertex){
    // Retrieve Primary Vertices
    auto handle = SG::makeHandle(m_vertexContainerKey);
    if (!handle.isValid()){
        ATH_MSG_WARNING(" This event has no primary vertex container" );
        return StatusCode::FAILURE;
    }
    
    const xAOD::VertexContainer* vertices = handle.cptr();
    if(vertices->empty()){
        ATH_MSG_WARNING(" Failed to retrieve valid primary vertex container" );
        return StatusCode::FAILURE;
    } 
    numNeutralCopies = static_cast<unsigned>(vertices->size());
  }
 
  // Copy the input containers individually, set I/O option and record
  // Charged elements
  SG::WriteHandle<T> outChargedHandle = makeHandle(outChargedKey);
 
  std::pair<T*, xAOD::ShallowAuxContainer* > chargedCopy = xAOD::shallowCopyContainer(*inChargedHandle);
  chargedCopy.second->setShallowIO(m_saveAsShallow);
  xAOD::setOriginalObjectLink(*inChargedHandle, *chargedCopy.first);
 
  ATH_CHECK(outChargedHandle.record(std::unique_ptr<T>(chargedCopy.first),
                                    std::unique_ptr<xAOD::ShallowAuxContainer>(chargedCopy.second)));
 
  // Neutral elements
  SG::WriteHandle<T> outNeutralHandle = makeHandle(outNeutralKey);
 
  // Shallow copy
  if (m_saveAsShallow){
 
    std::pair<T*, xAOD::ShallowAuxContainer* > neutralCopy = xAOD::shallowCopyContainer(*inNeutralHandle);
    chargedCopy.second->setShallowIO(true);
    xAOD::setOriginalObjectLink(*inNeutralHandle, *neutralCopy.first);
 
    ATH_CHECK(outNeutralHandle.record(std::unique_ptr<T>(neutralCopy.first),
                                      std::unique_ptr<xAOD::ShallowAuxContainer>(neutralCopy.second)));
 
  }
  // Deep copy
  else{
    // Define the accessor which will add the index
    const SG::AuxElement::Accessor<unsigned> copyIndex("ConstituentCopyIndex");
 
    // Create the new container and its auxiliary store.
    auto neutralCopies = std::make_unique<T>();
    auto neutralCopiesAux = std::make_unique<xAOD::AuxContainerBase>();
    neutralCopies->setStore(neutralCopiesAux.get()); //< Connect the two
 
    // Create N copies and set copy index
    // Necessary for by-vertex jet reconstruction
    for (unsigned i = 0; i < numNeutralCopies; i++){
      for (const U* fe : *inNeutralHandle) {
          U* copy = new U();
          neutralCopies->push_back(copy);
          *copy = *fe;
          copyIndex(*copy) = i;
          xAOD::setOriginalObjectLink(*fe, *copy);
      }
    }
 
    ATH_CHECK(outNeutralHandle.record(std::move(neutralCopies),
                                        std::move(neutralCopiesAux))
    );
  }
 
 
  // 2. Set up output handle for merged (view) container and record
  SG::WriteHandle<T> outAllHandle = makeHandle(outAllKey);
  ATH_CHECK(outAllHandle.record(std::make_unique<T>(SG::VIEW_ELEMENTS)));
  (*outAllHandle).assign((*outNeutralHandle).begin(), (*outNeutralHandle).end());
  (*outAllHandle).insert((*outAllHandle).end(),
      (*outChargedHandle).begin(), 
      (*outChargedHandle).end());
 
  // 3. Now process modifications on all elements
  for (auto t : m_modifiers) {ATH_CHECK(t->process(&*outAllHandle));}
  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

◆ 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

◆ execute()

int JetConstituentModSequence::execute ( ) const

virtual

Method to be called for each event.

Returns 0 for success.

Implements IJetExecuteTool.

Definition at line 189 of file JetConstituentModSequence.cxx.

                                             {
 
#ifndef XAOD_ANALYSIS
  // Define monitored quantities
  auto t_exec     = Monitored::Timer<std::chrono::milliseconds>( "TIME_constitmod"  );
#endif
 
  // Create the shallow copy according to the input type
  switch(m_inputType){
 
    case xAOD::Type::CaloCluster: {
      auto sc  = copyModRecord(m_inClusterKey,
                               m_outClusterKey);
      if(!sc.isSuccess()) return 1;
      break;
    }
 
    case xAOD::Type::ParticleFlow: {
      auto sc = copyModRecordFlowLike<xAOD::PFOContainer, xAOD::PFO>(m_inNeutralPFOKey, m_inChargedPFOKey, m_outNeutralPFOKey, m_outChargedPFOKey, m_outAllPFOKey);
      if(!sc.isSuccess()) return 1;
      break;
    }
    case xAOD::Type::FlowElement: {
      auto sc = copyModRecordFlowLike<xAOD::FlowElementContainer, xAOD::FlowElement>(m_inNeutralFEKey, m_inChargedFEKey, m_outNeutralFEKey, m_outChargedFEKey, m_outAllFEKey);
      if(!sc.isSuccess()) return 1;
      break;
    }
 
    case xAOD::Type::TrackCaloCluster : {
      auto sc  = copyModRecord(m_inTCCKey, 
                                m_outTCCKey);
      if(!sc.isSuccess()){return 1;}
      break;
    }
 
    default: {
      ATH_MSG_WARNING( "Unsupported input type " << m_inputType );
    }
 
  }
 
  #ifndef XAOD_ANALYSIS
    auto mon = Monitored::Group(m_monTool, t_exec);
  #endif
    return 0;
}

◆ 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

◆ 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.

◆ initialize()

StatusCode JetConstituentModSequence::initialize ( void )

virtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 37 of file JetConstituentModSequence.cxx.

                                                 {
  ATH_MSG_INFO("Initializing tool " << name() << "...");
  ATH_MSG_DEBUG("initializing version with data handles");
 
 
  ATH_CHECK( m_modifiers.retrieve() );
  ATH_CHECK(m_vertexContainerKey.initialize(m_byVertex));
 
  // Shallow copies are not supported for by-vertex jet reconstruction
  if (m_byVertex){
    m_saveAsShallow = false;
  }
 
#ifndef XAOD_ANALYSIS
  ATH_CHECK( m_monTool.retrieve( DisableTool{m_monTool.empty()} ) );
#endif
  
  // Set and initialise DataHandleKeys only for the correct input type
  // Die if the input type is unsupported
  switch(m_inputType) {
  case xAOD::Type::CaloCluster:
    {
      m_inClusterKey = m_inputContainer;
      m_outClusterKey = m_outputContainer;
  
      ATH_CHECK(m_inClusterKey.initialize());
      ATH_CHECK(m_outClusterKey.initialize());
      break;
    }
  case xAOD::Type::ParticleFlow:
    {
      std::string inputContainerBase = m_inputContainer;
      std::string outputContainerBase = m_outputContainer;
 
      // Know what the user means if they give the full input/output container name in this format
      size_t pos = inputContainerBase.find("ParticleFlowObjects");
      if(pos != std::string::npos) inputContainerBase.erase(pos);
 
      pos = outputContainerBase.find("ParticleFlowObjects");
      if(pos != std::string::npos) outputContainerBase.erase(pos);
 
      m_inChargedPFOKey = inputContainerBase + "ChargedParticleFlowObjects";
      m_inNeutralPFOKey = inputContainerBase + "NeutralParticleFlowObjects";
 
      m_outChargedPFOKey = outputContainerBase + "ChargedParticleFlowObjects";
      m_outNeutralPFOKey = outputContainerBase + "NeutralParticleFlowObjects";
      m_outAllPFOKey = outputContainerBase + "ParticleFlowObjects";
 
      ATH_CHECK(m_inChargedPFOKey.initialize());
      ATH_CHECK(m_inNeutralPFOKey.initialize());
      ATH_CHECK(m_outChargedPFOKey.initialize());
      ATH_CHECK(m_outNeutralPFOKey.initialize());
      ATH_CHECK(m_outAllPFOKey.initialize());
      break;
    }
    break;
  case xAOD::Type::TrackCaloCluster:
    m_inTCCKey = m_inputContainer;
    m_outTCCKey = m_outputContainer;
 
    ATH_CHECK(m_inTCCKey.initialize());
    ATH_CHECK(m_outTCCKey.initialize());
    break;
  case xAOD::Type::FlowElement:
    {
      // TODO: This assumes a PFlow-style neutral and charged collection.
      //       More general FlowElements (e.g. CaloClusters) may necessitate a rework here later.
 
      const std::string subString = "ParticleFlowObjects";
      const std::string subStringCharged = "ChargedParticleFlowObjects";
      const std::string subStringNeutral = "NeutralParticleFlowObjects";
 
      std::string inputContainerBase = m_inputContainer;
      std::string outputContainerBase = m_outputContainer;
 
      m_inChargedFEKey = inputContainerBase;
      m_inNeutralFEKey = inputContainerBase;
 
      m_outChargedFEKey = outputContainerBase;
      m_outNeutralFEKey = outputContainerBase;
      
      //For both the input and output container basenames we first check if the string
      //contains "ParticleFlowObjects". If it does we swap this for "ChargedParticleFlowObjects"
      //and "NeutralParticleFlowObjects" respectively. If it doesn't we just append these two
      //substrings to the end of the strings.
 
      size_t pos = inputContainerBase.find(subString);
      if(pos != std::string::npos) {
        std::string inChargedString = m_inChargedFEKey.key();
        m_inChargedFEKey = inChargedString.replace(pos,subString.size(),subStringCharged);
        std::string inNeutralString = m_inNeutralFEKey.key();
        m_inNeutralFEKey = inNeutralString.replace(pos,subString.size(),subStringNeutral);
      }
      else {
        m_inChargedFEKey = inputContainerBase + subStringCharged;
        m_inNeutralFEKey = inputContainerBase + subStringNeutral;
      }
 
      pos = outputContainerBase.find(subString);
      if(pos != std::string::npos) {
        std::string outChargedString = m_outChargedFEKey.key();
        m_outChargedFEKey = outChargedString.replace(pos,subString.size(),subStringCharged);
        std::string outNeutralString = m_outNeutralFEKey.key();
        m_outNeutralFEKey = outNeutralString.replace(pos,subString.size(),subStringNeutral);
      }
      else{
        m_outChargedFEKey = outputContainerBase + subStringCharged;
        m_outNeutralFEKey = outputContainerBase + subStringNeutral;
      }
 
      //The all FE container is a bit different. If the input container base contains
      //"ParticleFlowObjects" we do nothing, otherwise we add this string onto the end.
      pos = outputContainerBase.find(subString);  
      if(pos == std::string::npos) m_outAllFEKey = outputContainerBase + subString;
      else m_outAllFEKey = outputContainerBase;
 
      ATH_CHECK(m_inChargedFEKey.initialize());
      ATH_CHECK(m_inNeutralFEKey.initialize());
 
      ATH_CHECK(m_outChargedFEKey.initialize());
      ATH_CHECK(m_outNeutralFEKey.initialize());
      ATH_CHECK(m_outAllFEKey.initialize());
 
      // It is enough to initialise the ReadDecorHandleKeys for thread-safety
      // We are not actually accessing the decorations, only ensuring they are present at runtime
      // Hence, ReadDecorHandles are not explicitly required to be created
 
      // Prepend the FE input container name to the decorations
      for (auto& key : m_inChargedFEDecorKeys) {
        const std::string keyString = m_inChargedFEKey.key() + "." + key.key();
        ATH_CHECK(key.assign(keyString));
 
      }
 
      for (auto& key : m_inNeutralFEDecorKeys) {
        const std::string keyString = m_inNeutralFEKey.key() + "." + key.key();
        ATH_CHECK(key.assign(keyString));
      }
 
      ATH_CHECK(m_inChargedFEDecorKeys.initialize());
      ATH_CHECK(m_inNeutralFEDecorKeys.initialize());
 
      break;
    }
  default:
    ATH_MSG_ERROR(" Unsupported input type "<< m_inputType );
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

◆ inputContainerNames()

int IJetExecuteTool::inputContainerNames ( std::vector< std::string > & connames )

virtualinherited

Method to return the list of input containers.

The names of required input containers are appended to connames. Returns nonzero for error. Default returns 0 and adds no names.

Reimplemented in JetRecTool.

Definition at line 11 of file IJetExecuteTool.cxx.

                                                              {
  return 0;
}

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

◆ outputContainerNames()

int IJetExecuteTool::outputContainerNames ( std::vector< std::string > & connames )

virtualinherited

Method to return the list of output containers.

The names of produced output containers are appended to connames. Returns nonzero for error. Default returns 0 and adds no names.

Reimplemented in JetRecTool.

Definition at line 17 of file IJetExecuteTool.cxx.

                                                               {
  return 0;
}

◆ 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.

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

Member Data Documentation

◆ m_byVertex

Gaudi::Property<bool> JetConstituentModSequence::m_byVertex = {this, "DoByVertex", false, "True if we should match to each primary vertex, not just PV0"}

protected

Definition at line 62 of file JetConstituentModSequence.h.

62{this, "DoByVertex", false, "True if we should match to each primary vertex, not just PV0"};

◆ 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_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_inChargedFEDecorKeys

SG::ReadDecorHandleKeyArray<xAOD::FlowElementContainer> JetConstituentModSequence::m_inChargedFEDecorKeys {this, "InChargedFEDecorKeys", {}, "Dummy keys that force all neccessary charged FlowElement decorations to be applied before running this algorithm"}

protected

Definition at line 104 of file JetConstituentModSequence.h.

104{this, "InChargedFEDecorKeys", {}, "Dummy keys that force all neccessary charged FlowElement decorations to be applied before running this algorithm"};

◆ m_inChargedFEKey

SG::ReadHandleKey<xAOD::FlowElementContainer> JetConstituentModSequence::m_inChargedFEKey {this, "InChargedFEKey", "", "ReadHandleKey for modified Charged FlowElements"}

protected

Definition at line 94 of file JetConstituentModSequence.h.

94{this, "InChargedFEKey", "", "ReadHandleKey for modified Charged FlowElements"};

◆ m_inChargedPFOKey

SG::ReadHandleKey<xAOD::PFOContainer> JetConstituentModSequence::m_inChargedPFOKey {this, "InChargedPFOKey", "", "ReadHandleKey for modified Charged PFlow Objects"}

protected

Definition at line 86 of file JetConstituentModSequence.h.

86{this, "InChargedPFOKey", "", "ReadHandleKey for modified Charged PFlow Objects"};

◆ m_inClusterKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> JetConstituentModSequence::m_inClusterKey {this, "InClusterKey", "", "ReadHandleKey for unmodified CaloClusters"}

protected

Definition at line 80 of file JetConstituentModSequence.h.

80{this, "InClusterKey", "", "ReadHandleKey for unmodified CaloClusters"};

◆ m_inNeutralFEDecorKeys

SG::ReadDecorHandleKeyArray<xAOD::FlowElementContainer> JetConstituentModSequence::m_inNeutralFEDecorKeys {this, "InNeutralFEDecorKeys", {}, "Dummy keys that force all neccessary neutral FlowElement decorations to be applied before running this algorithm"}

protected

Definition at line 105 of file JetConstituentModSequence.h.

105{this, "InNeutralFEDecorKeys", {}, "Dummy keys that force all neccessary neutral FlowElement decorations to be applied before running this algorithm"};

◆ m_inNeutralFEKey

SG::ReadHandleKey<xAOD::FlowElementContainer> JetConstituentModSequence::m_inNeutralFEKey {this, "InNeutralFEKey", "", "ReadHandleKey for modified Neutral FlowElements"}

protected

Definition at line 97 of file JetConstituentModSequence.h.

97{this, "InNeutralFEKey", "", "ReadHandleKey for modified Neutral FlowElements"};

◆ m_inNeutralPFOKey

SG::ReadHandleKey<xAOD::PFOContainer> JetConstituentModSequence::m_inNeutralPFOKey {this, "InNeutralPFOKey", "", "ReadHandleKey for modified Neutral PFlow Objects"}

protected

Definition at line 89 of file JetConstituentModSequence.h.

89{this, "InNeutralPFOKey", "", "ReadHandleKey for modified Neutral PFlow Objects"};

◆ m_inputContainer

Gaudi::Property<std::string> JetConstituentModSequence::m_inputContainer {this, "InputContainer", "", "The input container for the sequence"}

protected

Definition at line 60 of file JetConstituentModSequence.h.

60{this, "InputContainer", "", "The input container for the sequence"};

◆ m_inputType

unsigned short JetConstituentModSequence::m_inputType

protected

Definition at line 68 of file JetConstituentModSequence.h.

◆ m_inTCCKey

SG::ReadHandleKey<xAOD::TrackCaloClusterContainer> JetConstituentModSequence::m_inTCCKey {this, "InTCCKey", "", "ReadHandleKey for unmodified TrackCaloClusters"}

protected

Definition at line 83 of file JetConstituentModSequence.h.

83{this, "InTCCKey", "", "ReadHandleKey for unmodified TrackCaloClusters"};

◆ m_modifiers

ToolHandleArray<IJetConstituentModifier> JetConstituentModSequence::m_modifiers {this , "Modifiers" , {} , "List of constit modifier tools."}

protected

Definition at line 71 of file JetConstituentModSequence.h.

71{this , "Modifiers" , {} , "List of constit modifier tools."};

◆ m_monTool

ToolHandle<GenericMonitoringTool> JetConstituentModSequence::m_monTool {this,"MonTool","","Monitoring tool"}

protected

Definition at line 74 of file JetConstituentModSequence.h.

74{this,"MonTool","","Monitoring tool"};

◆ m_outAllFEKey

SG::WriteHandleKey<xAOD::FlowElementContainer> JetConstituentModSequence::m_outAllFEKey {this, "OutAllFEKey", "", "WriteHandleKey for all modified FlowElements"}

protected

Definition at line 100 of file JetConstituentModSequence.h.

100{this, "OutAllFEKey", "", "WriteHandleKey for all modified FlowElements"};

◆ m_outAllPFOKey

SG::WriteHandleKey<xAOD::PFOContainer> JetConstituentModSequence::m_outAllPFOKey {this, "OutAllPFOKey", "", "WriteHandleKey for all modified PFlow Objects"}

protected

Definition at line 92 of file JetConstituentModSequence.h.

92{this, "OutAllPFOKey", "", "WriteHandleKey for all modified PFlow Objects"};

◆ m_outChargedFEKey

SG::WriteHandleKey<xAOD::FlowElementContainer> JetConstituentModSequence::m_outChargedFEKey {this, "OutChargedFEKey", "", "WriteHandleKey for modified Charged FlowElements"}

protected

Definition at line 95 of file JetConstituentModSequence.h.

95{this, "OutChargedFEKey", "", "WriteHandleKey for modified Charged FlowElements"};

◆ m_outChargedPFOKey

SG::WriteHandleKey<xAOD::PFOContainer> JetConstituentModSequence::m_outChargedPFOKey {this, "OutChargedPFOKey", "", "WriteHandleKey for modified Charged PFlow Objects"}

protected

Definition at line 87 of file JetConstituentModSequence.h.

87{this, "OutChargedPFOKey", "", "WriteHandleKey for modified Charged PFlow Objects"};

◆ m_outClusterKey

SG::WriteHandleKey<xAOD::CaloClusterContainer> JetConstituentModSequence::m_outClusterKey {this, "OutClusterKey", "", "WriteHandleKey for modified CaloClusters"}

protected

Definition at line 81 of file JetConstituentModSequence.h.

81{this, "OutClusterKey", "", "WriteHandleKey for modified CaloClusters"};

◆ m_outNeutralFEKey

SG::WriteHandleKey<xAOD::FlowElementContainer> JetConstituentModSequence::m_outNeutralFEKey {this, "OutNeutralFEKey", "", "WriteHandleKey for modified Neutral FlowElements"}

protected

Definition at line 98 of file JetConstituentModSequence.h.

98{this, "OutNeutralFEKey", "", "WriteHandleKey for modified Neutral FlowElements"};

◆ m_outNeutralPFOKey

SG::WriteHandleKey<xAOD::PFOContainer> JetConstituentModSequence::m_outNeutralPFOKey {this, "OutNeutralPFOKey", "", "WriteHandleKey for modified Neutral PFlow Objects"}

protected

Definition at line 90 of file JetConstituentModSequence.h.

90{this, "OutNeutralPFOKey", "", "WriteHandleKey for modified Neutral PFlow Objects"};

◆ m_outputContainer

Gaudi::Property<std::string> JetConstituentModSequence::m_outputContainer = {this, "OutputContainer", "", "The output container for the sequence"}

protected

Definition at line 61 of file JetConstituentModSequence.h.

61{this, "OutputContainer", "", "The output container for the sequence"};

◆ m_outTCCKey

SG::WriteHandleKey<xAOD::TrackCaloClusterContainer> JetConstituentModSequence::m_outTCCKey {this, "OutTCCKey", "", "WriteHandleKey for modified TrackCaloClusters"}

protected

Definition at line 84 of file JetConstituentModSequence.h.

84{this, "OutTCCKey", "", "WriteHandleKey for modified TrackCaloClusters"};

◆ m_saveAsShallow

bool JetConstituentModSequence::m_saveAsShallow = true

protected

Definition at line 77 of file JetConstituentModSequence.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vertexContainerKey

SG::ReadHandleKey<xAOD::VertexContainer> JetConstituentModSequence::m_vertexContainerKey {this, "VertexContainerKey", "PrimaryVertices", "Reconstructed primary vertex container name"}

protected

Definition at line 63 of file JetConstituentModSequence.h.

63{this, "VertexContainerKey", "PrimaryVertices", "Reconstructed primary vertex container name"};

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.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

◆ JetConstituentModSequence()

Member Function Documentation

◆ copyModRecord()

◆ copyModRecordFlowLike()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ getKey()

◆ getName()

◆ getProperty()

◆ initialize()

◆ inputContainerNames()

◆ inputHandles()

◆ msg()

◆ msg_level_name()

◆ msgLvl()

◆ outputContainerNames()

◆ outputHandles()

◆ print()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_byVertex

◆ m_detStore

◆ m_evtStore

◆ m_inChargedFEDecorKeys

◆ m_inChargedFEKey

◆ m_inChargedPFOKey

◆ m_inClusterKey

◆ m_inNeutralFEDecorKeys

◆ m_inNeutralFEKey

◆ m_inNeutralPFOKey

◆ m_inputContainer

◆ m_inputType

◆ m_inTCCKey

◆ m_modifiers

◆ m_monTool

◆ m_outAllFEKey

◆ m_outAllPFOKey

◆ m_outChargedFEKey

◆ m_outChargedPFOKey

◆ m_outClusterKey

◆ m_outNeutralFEKey

◆ m_outNeutralPFOKey

◆ m_outputContainer

◆ m_outTCCKey

◆ m_saveAsShallow

◆ m_varHandleArraysDeclared

◆ m_vertexContainerKey

◆ m_vhka