top::TopEventMaker Class Reference

TopEventMaker produce top::Event objects from xAOD::SystematicEvent objects. More...

#include <TopEventMaker.h>

Inheritance diagram for top::TopEventMaker:

Collaboration diagram for top::TopEventMaker:

Public Member Functions
	TopEventMaker (const std::string &name)
virtual	~TopEventMaker ()
StatusCode	initialize ()
	Dummy implementation of the initialisation function. More...
	TopEventMaker (const TopEventMaker &rhs)=delete
	TopEventMaker (TopEventMaker &&rhs)=delete
TopEventMaker &	operator= (const TopEventMaker &rhs)=delete
top::Event	makeTopEvent (const xAOD::SystematicEvent *currentSystematic)
	Make a top::Event from a xAOD::SystematicEvent. More...
const xAOD::SystematicEventContainer *	systematicEvents (const std::string &sgKey) const
	As top-xaod isn't an asg::AsgTool, it doesn't have access to all the information Very annoying. More...
virtual void	print () const
	Print the state of the tool. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	decorateTopEvent (top::Event &event)
void	decorateTopEventSoftMuons (top::Event &event)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::shared_ptr< top::TopConfig >	m_config
std::unique_ptr< RCJet >	m_rc
std::map< std::string, std::unique_ptr< RCJet > >	m_VarRC
std::vector< std::string >	m_VarRCJetRho
std::vector< std::string >	m_VarRCJetMassScale
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static bool	s_hasTruthEvent = true

Detailed Description

TopEventMaker produce top::Event objects from xAOD::SystematicEvent objects.

Author

John Morris john..nosp@m.morr.nosp@m.is@ce.nosp@m.rn.c.nosp@m.h

Definition at line 32 of file TopEventMaker.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

TopEventMaker() [1/3]

top::TopEventMaker::TopEventMaker ( const std::string &  name )

explicit

Definition at line 34 of file TopEventMaker.cxx.

                                                    :
    asg::AsgTool(name),
    m_config(nullptr) {
    declareProperty("config", m_config);
  }

~TopEventMaker()

virtual top::TopEventMaker::~TopEventMaker ( )

inlinevirtual

Definition at line 35 of file TopEventMaker.h.

{}

TopEventMaker() [2/3]

top::TopEventMaker::TopEventMaker ( const TopEventMaker &  rhs )

delete

TopEventMaker() [3/3]

top::TopEventMaker::TopEventMaker ( TopEventMaker &&  rhs )

delete

Member Function Documentation

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

decorateTopEvent()

void top::TopEventMaker::decorateTopEvent ( top::Event &  event )

private

Definition at line 628 of file TopEventMaker.cxx.

  {
    if(m_config->useSoftMuons()) decorateTopEventSoftMuons(event);
  }

decorateTopEventSoftMuons()

void top::TopEventMaker::decorateTopEventSoftMuons ( top::Event &  event )

private

Definition at line 633 of file TopEventMaker.cxx.

  {
    if(!m_config->useJets()) return;
    
    //first we initialize decorations for all jets
    for(const xAOD::Jet* jet : event.m_jets) 
    {
      jet->auxdecor<int>("AT_SoftMuonIndex")=-1;
      jet->auxdecor<float>("AT_SoftMuonDR")=-1;
    }
      
    int imuon=0;
    for(const xAOD::Muon* sm : event.m_softmuons)
    {
      //writing auxiliary info for SMT jet tagging
      double dRmin=100.;
      int nearestJetIndex=-1;
      int ijet=0;
      for(const xAOD::Jet *jet : event.m_jets)
      {
        double dr= xAOD::P4Helpers::deltaR(sm,jet,m_config->softmuonDRJetcutUseRapidity());
        if(dr<dRmin && dr<m_config->softmuonDRJetcut())
        {
          dRmin=dr;
          nearestJetIndex=ijet;
        }
        ijet++;
      }
      sm->auxdecor<int>("AT_SMTJetIndex")=nearestJetIndex;
      sm->auxdecor<float>("AT_SMTJetDR")=dRmin;
      
      if(nearestJetIndex>=0)
      {
        const xAOD::Jet *jet = event.m_jets[nearestJetIndex];
        if(jet->auxdecor<int>("AT_SoftMuonIndex")<0) //in this way we only associate a jet with the highest pt soft muon
        {
          jet->auxdecor<int>("AT_SoftMuonIndex")=imuon;
          jet->auxdecor<float>("AT_SoftMuonDR")=dRmin;
        }
      }//end of case where we found a jet nearby
      
      imuon++;
    }//end of loop on muons
    
  }//end of TopEventMaker::decorateTopEvent

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.

{ return m_detStore; }

evtStore() [1/2]

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.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

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 top::TopEventMaker::initialize ( )

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 40 of file TopEventMaker.cxx.

                                       {
    if (m_config->useRCJets() == true) {
      m_rc = std::unique_ptr<RCJet> (new RCJet("RCJet"));
      top::check(m_rc->setProperty("config", m_config), "Failed to set config property of RCJet");
      top::check(m_rc->initialize(), "Failed to initialize RCJet");
    }
 
    if (m_config->useVarRCJets() == true) {
      boost::split(m_VarRCJetRho, m_config->VarRCJetRho(), boost::is_any_of(","));
      boost::split(m_VarRCJetMassScale, m_config->VarRCJetMassScale(), boost::is_any_of(","));
 
      for (auto& rho : m_VarRCJetRho) {
        for (auto& mass_scale : m_VarRCJetMassScale) {
          std::replace(rho.begin(), rho.end(), '.', '_');
          std::string name = rho + mass_scale;
          m_VarRC[name] = std::unique_ptr<RCJet> (new RCJet("VarRCJet_" + name));
          top::check(m_VarRC[name]->setProperty("config", m_config), "Failed to set config property of VarRCJet");
          top::check(m_VarRC[name]->setProperty("VarRCjets", true), "Failed to set VarRCjets property of VarRCJet");
          top::check(m_VarRC[name]->setProperty("VarRCjets_rho",
                                                rho), "Failed to set VarRCjets rho property of VarRCJet");
          top::check(m_VarRC[name]->setProperty("VarRCjets_mass_scale",
                                                mass_scale),
                     "Failed to set VarRCjets mass scale property of VarRCJet");
          top::check(m_VarRC[name]->initialize(), "Failed to initialize VarRCJet");
        } // end loop over mass scale parameters (e.g., top mass, w mass, etc.)
      } // end loop over mass scale multiplies (e.g., 1.,2.,etc.)
    }
 
    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.

makeTopEvent()

top::Event top::TopEventMaker::makeTopEvent

(

const xAOD::SystematicEvent *

currentSystematic

)

Make a top::Event from a xAOD::SystematicEvent.

A SingleSystEvent contains only access to calibrated/systematic StoreGate keys and vectors telling it which objects in a collection are good

You want to do physics on a top::Event

Parameters

systEvent

Essentially this make an analysis friendly version of the information in systEvent

Returns

A top::Event that you can do analysis on containing the good objects, which you can then perform selection based on event-level info with. Such as object multiplicity. Fun times are ahead.

– Need to read const collections for mini-xaod read back –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

– Need to read const collections for mini-xaod read back –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

– Need to read const collections for mini-xaod read back –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

– Need to read const collections for mini-xaod read back –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

– Need to read const collections for mini-xaod read back –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

– Need to read const collections for mini-xaod read back –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

– Need to read const collections for mini-xaod read back –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

– Need to read const collections for mini-xaod read back –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

– Need to read const collections for mini-xaod read back –///

– Shallow copy and save to TStore –///

– Pull shallow copy back out of TStore in non-const way –///

Definition at line 80 of file TopEventMaker.cxx.

                                                                                      {
    xAOD::SystematicEvent const& currentSystematic = *currentSystematicPtr;
    //create a new event object
    top::Event event;
 
    // Set systematic hash value
    std::size_t hash = currentSystematic.hashValue();
    event.m_hashValue = hash;
 
    // TTree index
    event.m_ttreeIndex = currentSystematic.ttreeIndex();
 
    // Is Loose event?
    event.m_isLoose = currentSystematic.isLooseEvent();
 
    //event info
    top::check(evtStore()->retrieve(event.m_info, m_config->sgKeyEventInfo()), "Failed to retrieve EventInfo");
    event.m_systematicEvent = currentSystematicPtr;
 
    //Primary Vertices
    if (evtStore()->contains<xAOD::VertexContainer>(m_config->sgKeyPrimaryVertices())) {
      top::check(evtStore()->retrieve(event.m_primaryVertices,
                                      m_config->sgKeyPrimaryVertices()), "Failed to retrieve Primary Vertices");
    }
 
    //Poisson bootstrap weights
    if (m_config->saveBootstrapWeights()) {
      int second_seed;
      if (m_config->isMC()) {
        second_seed = event.m_info->mcChannelNumber();
      } else {
        second_seed = event.m_info->runNumber();
      }
      std::vector<int> weight_poisson = top::calculateBootstrapWeights(m_config->getNumberOfBootstrapReplicas(),
                                                                       event.m_info->eventNumber(),
                                                                       second_seed);
      event.m_info->auxdecor< std::vector<int> >("weight_poisson") = weight_poisson;
    }
 
    //electrons
    if (m_config->useElectrons()) {
 
      const xAOD::ElectronContainer* calibratedElectrons(nullptr);
      top::check(evtStore()->retrieve(calibratedElectrons, m_config->sgKeyElectrons(
                                        hash)), "Failed to retrieve electrons");
 
      if (!evtStore()->contains<xAOD::ElectronContainer>(m_config->sgKeyElectronsTDS(hash))) {
        std::pair< xAOD::ElectronContainer*,
                   xAOD::ShallowAuxContainer* > shallow_electrons = xAOD::shallowCopyContainer(*calibratedElectrons);
 
        StatusCode save = evtStore()->tds()->record(shallow_electrons.first, m_config->sgKeyElectronsTDS(hash));
        StatusCode saveAux =
          evtStore()->tds()->record(shallow_electrons.second, m_config->sgKeyElectronsTDSAux(hash));
        top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::ElectronContainer* calibratedElectronsTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedElectronsTDS, m_config->sgKeyElectronsTDS(
                                        hash)), "Failed to retrieve electrons");
 
 
      // re-write overlap information if it is decorated onto currentSystematic
      if (currentSystematic.isAvailable< std::vector<unsigned int> >("overlapsEl")) {
        std::vector<unsigned int> overlapsEl =
          currentSystematic.auxdataConst< std::vector<unsigned int> >("overlapsEl");
        if (overlapsEl.size() == calibratedElectronsTDS->size()) {
          unsigned int counter(0);
          for (auto x : *calibratedElectronsTDS) {
            x->auxdecor<char>("overlaps") = overlapsEl.at(counter);
            ++counter;
          }
        }
      }
 
      for (auto index : currentSystematic.goodElectrons()) {
        event.m_electrons.push_back(calibratedElectronsTDS->at(index));
      }
 
      //shallow copies aren't sorted!
      //sort only the selected electrons (faster)
      event.m_electrons.sort(top::descendingPtSorter);
    }
 
    //forward electrons
    if (m_config->useFwdElectrons()) {
      const xAOD::ElectronContainer* calibratedFwdElectrons(nullptr);
      top::check(evtStore()->retrieve(calibratedFwdElectrons, m_config->sgKeyFwdElectrons(
                                        hash)), "Failed to retrieve fwd electrons");
 
      if (!evtStore()->contains<xAOD::ElectronContainer>(m_config->sgKeyFwdElectronsTDS(hash))) {
        std::pair< xAOD::ElectronContainer*,
                   xAOD::ShallowAuxContainer* > shallow_fwdelectrons = xAOD::shallowCopyContainer(
          *calibratedFwdElectrons);
 
        StatusCode save =
          evtStore()->tds()->record(shallow_fwdelectrons.first, m_config->sgKeyFwdElectronsTDS(hash));
        StatusCode saveAux = evtStore()->tds()->record(shallow_fwdelectrons.second, m_config->sgKeyFwdElectronsTDSAux(
                                                                hash));
        top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::ElectronContainer* calibratedFwdElectronsTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedFwdElectronsTDS, m_config->sgKeyFwdElectronsTDS(
                                        hash)), "Failed to retrieve fwd electrons");
 
      for (const auto& index : currentSystematic.goodFwdElectrons()) {
        event.m_fwdElectrons.push_back(calibratedFwdElectronsTDS->at(index));
      }
 
      //shallow copies aren't sorted!
      //sort only the selected fwd electrons (faster)
      event.m_fwdElectrons.sort(top::descendingPtSorter);
    }
 
    //photons
    if (m_config->usePhotons()) {
 
      const xAOD::PhotonContainer* calibratedPhotons(nullptr);
      top::check(evtStore()->retrieve(calibratedPhotons, m_config->sgKeyPhotons(hash)), "Failed to retrieve photons");
 
      if (!evtStore()->contains<xAOD::PhotonContainer>(m_config->sgKeyPhotonsTDS(hash))) {
        std::pair< xAOD::PhotonContainer*, xAOD::ShallowAuxContainer* > shallow_photons = xAOD::shallowCopyContainer(
          *calibratedPhotons);
 
        StatusCode save = evtStore()->tds()->record(shallow_photons.first, m_config->sgKeyPhotonsTDS(hash));
        StatusCode saveAux =
          evtStore()->tds()->record(shallow_photons.second, m_config->sgKeyPhotonsTDSAux(hash));
        top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::PhotonContainer* calibratedPhotonsTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedPhotonsTDS, m_config->sgKeyPhotonsTDS(
                                        hash)), "Failed to retrieve photons");
 
      for (auto index : currentSystematic.goodPhotons()) {
        event.m_photons.push_back(calibratedPhotonsTDS->at(index));
      }
      //shallow copies aren't sorted!
      //sort only the selected photons (faster)
      event.m_photons.sort(top::descendingPtSorter);
    }
 
    //muons
    if (m_config->useMuons()) {
      const xAOD::MuonContainer* calibratedMuons(nullptr);
      top::check(evtStore()->retrieve(calibratedMuons, m_config->sgKeyMuons(hash)), "Failed to retrieve muons");
 
      if (!evtStore()->contains<xAOD::MuonContainer>(m_config->sgKeyMuonsTDS(hash))) {
        std::pair< xAOD::MuonContainer*, xAOD::ShallowAuxContainer* > shallow_muons = xAOD::shallowCopyContainer(
          *calibratedMuons);
 
        StatusCode save = evtStore()->tds()->record(shallow_muons.first, m_config->sgKeyMuonsTDS(hash));
        StatusCode saveAux = evtStore()->tds()->record(shallow_muons.second, m_config->sgKeyMuonsTDSAux(hash));
        top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::MuonContainer* calibratedMuonsTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedMuonsTDS, m_config->sgKeyMuonsTDS(hash)), "Failed to retrieve muons");
 
      // re-write overlap information if it is decorated onto currentSystematic
      if (currentSystematic.isAvailable< std::vector<unsigned int> >("overlapsMu")) {
        std::vector<unsigned int> overlapsMu =
          currentSystematic.auxdataConst< std::vector<unsigned int> >("overlapsMu");
        if (overlapsMu.size() == calibratedMuonsTDS->size()) {
          unsigned int counter(0);
          for (auto x : *calibratedMuons) {
            x->auxdecor<char>("overlaps") = overlapsMu.at(counter);
            ++counter;
          }
        }
      }
 
      for (auto index : currentSystematic.goodMuons()) {
        event.m_muons.push_back(calibratedMuonsTDS->at(index));
      }
 
      //shallow copies aren't sorted!
      //sort only the selected muons (faster)
      event.m_muons.sort(top::descendingPtSorter);
    }
 
    //soft muons
    if (m_config->useSoftMuons()) {
      const xAOD::MuonContainer* calibratedSoftMuons(nullptr);
 
      top::check(evtStore()->retrieve(calibratedSoftMuons, m_config->sgKeySoftMuons(hash)), "Failed to retrieve muons");
 
 
      if (!evtStore()->contains<xAOD::MuonContainer>(m_config->sgKeySoftMuonsTDS(hash))) {
        std::pair< xAOD::MuonContainer*, xAOD::ShallowAuxContainer* > shallow_softmuons = xAOD::shallowCopyContainer(
          *calibratedSoftMuons);
 
        StatusCode save = evtStore()->tds()->record(shallow_softmuons.first, m_config->sgKeySoftMuonsTDS(hash));
        StatusCode saveAux =
          evtStore()->tds()->record(shallow_softmuons.second, m_config->sgKeySoftMuonsTDSAux(hash));
        top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::MuonContainer* calibratedSoftMuonsTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedSoftMuonsTDS, m_config->sgKeySoftMuonsTDS(
                                        hash)), "Failed to retrieve soft muons");
 
      //no overlap procedure applied to soft muons for the time being
 
      for (auto index : currentSystematic.goodSoftMuons()) {
        event.m_softmuons.push_back(calibratedSoftMuonsTDS->at(index));
      }
 
      //shallow copies aren't sorted!
      //sort only the selected soft muons (faster)
      event.m_softmuons.sort(top::descendingPtSorter);
    }
 
    //taus
    if (m_config->useTaus()) {
      const xAOD::TauJetContainer* calibratedTaus(nullptr);
      top::check(evtStore()->retrieve(calibratedTaus, m_config->sgKeyTaus(hash)), "Failed to retrieve taus");
 
      if (!evtStore()->contains<xAOD::TauJetContainer>(m_config->sgKeyTausTDS(hash))) {
        std::pair< xAOD::TauJetContainer*, xAOD::ShallowAuxContainer* > shallow_taus = xAOD::shallowCopyContainer(
          *calibratedTaus);
 
        StatusCode save = evtStore()->tds()->record(shallow_taus.first, m_config->sgKeyTausTDS(hash));
        StatusCode saveAux = evtStore()->tds()->record(shallow_taus.second, m_config->sgKeyTausTDSAux(hash));
        top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::TauJetContainer* calibratedTausTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedTausTDS, m_config->sgKeyTausTDS(hash)), "Failed to retrieve taus");
 
      for (auto index : currentSystematic.goodTaus()) {
        event.m_tauJets.push_back(calibratedTausTDS->at(index));
      }
 
      //shallow copies aren't sorted!
      //sort only the selected taus (faster)
      event.m_tauJets.sort(top::descendingPtSorter);
    }
 
    //jets
    // We need to be careful with the boosted analysis,
    // Do we take the jets collection that has loose or tight leptons subtracted?
    bool looseJets(false);
    if (m_config->applyElectronInJetSubtraction()) {
      if (m_config->doOverlapRemovalOnLooseLeptonDef() || currentSystematic.isLooseEvent()) {
        looseJets = true;
      }
    }
 
    if (m_config->useJets()) {
      std::string sgKeyCalibrated(m_config->sgKeyJets(hash, looseJets));
      std::string sgKeyTmp = "tmp_" + sgKeyCalibrated;
      std::string sgKeyTmpAux = sgKeyTmp + "Aux.";
 
      const xAOD::JetContainer* calibratedJets(nullptr);
      top::check(evtStore()->retrieve(calibratedJets, m_config->sgKeyJets(hash, looseJets)), "Failed to retrieve jets");
 
      if (!evtStore()->contains<xAOD::JetContainer>(m_config->sgKeyJetsTDS(hash, looseJets))) {
        std::pair< xAOD::JetContainer*, xAOD::ShallowAuxContainer* > shallow_jets = xAOD::shallowCopyContainer(
          *calibratedJets);
 
        StatusCode save = evtStore()->tds()->record(shallow_jets.first, m_config->sgKeyJetsTDS(hash, looseJets));
        StatusCode saveAux =
          evtStore()->tds()->record(shallow_jets.second, m_config->sgKeyJetsTDSAux(hash, looseJets));
        top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::JetContainer* calibratedJetsTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedJetsTDS, m_config->sgKeyJetsTDS(hash,
                                                                                looseJets)), "Failed to retrieve taus");
 
 
      for (auto index : currentSystematic.goodJets()) {
        auto jet = calibratedJetsTDS->at(index);
 
        if (m_config->isMC()) {
          // JVT and fJVT, make product of SF (initialised to 1 in the header)
          top::check(jet->isAvailable<float>(
                       "JET_SF_jvt"),
                     " Can't find jet decoration \"JET_SF_jvt\" - we need it to calculate the jet scale-factors!");
      if (jet->auxdataConst<float>("JET_SF_jvt") > 0) {
        event.m_jvtSF *= jet->auxdataConst<float>("JET_SF_jvt");
      }
      
      // fJVT scale factors not added to jets unless fJVT is requested
      if (m_config->getfJVTWP() != "None") {
        top::check(jet->isAvailable<float>(
                "JET_SF_fjvt"),
               " Can't find jet decoration \"JET_SF_fjvt\" - we need it to calculate the forward jet scale-factors!");
        event.m_fjvtSF *= jet->auxdataConst<float>("JET_SF_fjvt");
      }
          if (currentSystematic.hashValue() == m_config->nominalHashValue()) {// we only need the up/down JVT SF systs
                                                                              // for nominal
            top::check(jet->isAvailable<float>(
                         "JET_SF_jvt_UP"),
                       " Can't find jet decoration \"JET_SF_jvt_UP\" - we need it to calculate the jet scale-factors!");
            event.m_jvtSF_UP *= jet->auxdataConst<float>("JET_SF_jvt_UP");
            top::check(jet->isAvailable<float>(
                         "JET_SF_jvt_DOWN"),
                       " Can't find jet decoration \"JET_SF_jvt_DOWN\" - we need it to calculate the jet scale-factors!");
            event.m_jvtSF_DOWN *= jet->auxdataConst<float>("JET_SF_jvt_DOWN");
 
        // fJVT scale factors not added to jets unless fJVT is requested
        if (m_config->getfJVTWP() != "None") {
          top::check(jet->isAvailable<float>(
                         "JET_SF_fjvt_UP"),
             " Can't find jet decoration \"JET_SF_fjvt_UP\" - we need it to calculate the forward jet scale-factors!");
          event.m_fjvtSF_UP *= jet->auxdataConst<float>("JET_SF_fjvt_UP");
          top::check(jet->isAvailable<float>(
                         "JET_SF_fjvt_DOWN"),
             " Can't find jet decoration \"JET_SF_fjvt_DOWN\" - we need it to calculate the forward jet scale-factors!");
          event.m_fjvtSF_DOWN *= jet->auxdataConst<float>("JET_SF_fjvt_DOWN");
        }
          } //isNominal
        } //isMC
 
        top::check(jet->isAvailable<char>(
                     "passJVT"),
                   " Can't find jet decoration \"passJVT\" - we need it to decide if we should keep the jet in the top::Event instance or not!");
    bool passfJVT(true);
    if (m_config->doForwardJVTinMET() || m_config->getfJVTWP() != "None") {
      top::check(jet->isAvailable<char>("AnalysisTop_fJVTdecision"),
             " Can't find jet decoration \"AnalysisTop_fJVTdecision\" - we need it to decide if we should keep forward jets in the top::Event instance or not!");
      passfJVT = jet->auxdataConst<char>("AnalysisTop_fJVTdecision");
      if (m_config->saveFailForwardJVTJets()) {
        if (!passfJVT) event.m_failFJvt_jets.push_back(calibratedJetsTDS->at(index));
      }
      //Add to failFJVT collection but don't actually cut on fJVT if fJVT is only requested in MET calculation (I'm not sure people will ever actually do this)
      if (m_config->getfJVTWP() == "None") passfJVT = true;
    }
 
        if (jet->auxdataConst<char>("passJVT") && passfJVT) event.m_jets.push_back(calibratedJetsTDS->at(index));
        if (m_config->saveFailJVTJets()) {
          if (!jet->auxdataConst<char>("passJVT")) event.m_failJvt_jets.push_back(calibratedJetsTDS->at(index));
        }
      }
 
      //shallow copies aren't sorted!
      //sort only the selected taus (faster)
      event.m_jets.sort(top::descendingPtSorter);
      if (m_config->saveFailJVTJets()) event.m_failJvt_jets.sort(top::descendingPtSorter);
      if ( (m_config->doForwardJVTinMET() || m_config->getfJVTWP() != "None") && m_config->saveFailForwardJVTJets()){
    event.m_failFJvt_jets.sort(top::descendingPtSorter);
      }
    }
 
    // Reclustered jets
    if (m_config->useRCJets()) {
      top::check(m_rc->execute(event), "Failed to execute RCJet container");
      std::string rcJetContainerName = m_rc->rcjetContainerName(event.m_hashValue, event.m_isLoose);
      const xAOD::JetContainer* rc_jets(nullptr);
      top::check(evtStore()->retrieve(rc_jets, rcJetContainerName), "Failed to retrieve RC JetContainer");
      //Object selection
      for (auto rcjet : *rc_jets) {
        top::check(rcjet->isAvailable<bool>(
                     "PassedSelection"),
                   " Can't find jet decoration \"PassedSelection\" - we need it to decide if we should keep the reclustered jet in the top::Event instance or not!");
        if (rcjet->auxdataConst<bool>("PassedSelection")) event.m_RCJets.push_back((xAOD::Jet*) rcjet);
      }
    }
    // Variable-R reclustered jets
    if (m_config->useVarRCJets()) {
      for (auto& rho : m_VarRCJetRho) {
        for (auto& mass_scale : m_VarRCJetMassScale) {
          std::replace(rho.begin(), rho.end(), '.', '_');
          std::string name = rho + mass_scale;
          top::check(m_VarRC[name]->execute(event), "Failed to execute RCJet container");
 
          // Get the name of the container of re-clustered jets in TStore
          std::string varRCJetContainerName = m_VarRC[name]->rcjetContainerName(event.m_hashValue, event.m_isLoose);
 
          // -- Retrieve the re-clustered jets from TStore & save good re-clustered jets -- //
          const xAOD::JetContainer* vrc_jets(nullptr);
          top::check(evtStore()->retrieve(vrc_jets, varRCJetContainerName), "Failed to retrieve RC JetContainer");
 
          event.m_VarRCJets[name] = std::make_shared<xAOD::JetContainer>(SG::VIEW_ELEMENTS);
          for (auto vrcjet : *vrc_jets) {
            top::check(vrcjet->isAvailable<bool>(
                         "PassedSelection"),
                       " Can't find jet decoration \"PassedSelection\" - we need it to decide if we should keep the variable-R reclustered jet in the top::Event instance or not!");
            if (vrcjet->auxdataConst<bool>("PassedSelection")) event.m_VarRCJets[name]->push_back((xAOD::Jet*) vrcjet);
          }
        }
      }
    }
 
 
    //large-R jets
    if (m_config->useLargeRJets()) {
      const xAOD::JetContainer* calibratedJets(nullptr);
      top::check(evtStore()->retrieve(calibratedJets, m_config->sgKeyLargeRJets(hash)),
                 "Failed to retrieve largeR jets");
 
      if (!evtStore()->contains<xAOD::JetContainer>(m_config->sgKeyLargeRJetsTDS(hash))) {
        std::pair< xAOD::JetContainer*, xAOD::ShallowAuxContainer* > shallow_jets = xAOD::shallowCopyContainer(
          *calibratedJets);
 
        StatusCode save = evtStore()->tds()->record(shallow_jets.first, m_config->sgKeyLargeRJetsTDS(hash));
        StatusCode saveAux =
          evtStore()->tds()->record(shallow_jets.second, m_config->sgKeyLargeRJetsTDSAux(hash));
        top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::JetContainer* calibratedJetsTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedJetsTDS, m_config->sgKeyLargeRJetsTDS(
                                        hash)), "Failed to retrieve largeR jets");
 
      for (auto index : currentSystematic.goodLargeRJets()) {
        event.m_largeJets.push_back(calibratedJetsTDS->at(index));
      }
 
      //shallow copies aren't sorted!
      //sort only the selected jets (faster)
      event.m_largeJets.sort(top::descendingPtSorter);
    }
 
    //track jets
    if (m_config->useTrackJets()) {
      const xAOD::JetContainer* calibratedJets(nullptr);
      top::check(evtStore()->retrieve(calibratedJets, m_config->sgKeyTrackJets(hash)), "Failed to retrieve track jets");
 
      if (!evtStore()->contains<xAOD::JetContainer>(m_config->sgKeyTrackJetsTDS(hash))) {
        std::pair< xAOD::JetContainer*, xAOD::ShallowAuxContainer* > shallow_jets = xAOD::shallowCopyContainer(
          *calibratedJets);
 
        StatusCode save = evtStore()->tds()->record(shallow_jets.first, m_config->sgKeyTrackJetsTDS(hash));
        StatusCode saveAux =
          evtStore()->tds()->record(shallow_jets.second, m_config->sgKeyTrackJetsTDSAux(hash));
        top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::JetContainer* calibratedJetsTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedJetsTDS, m_config->sgKeyTrackJetsTDS(
                                        hash)), "Failed to retrieve track jets");
 
 
      for (auto index : currentSystematic.goodTrackJets()) {
        event.m_trackJets.push_back(calibratedJetsTDS->at(index));
      }
 
      //shallow copies aren't sorted!
      //sort only the selected jets (faster)
      event.m_trackJets.sort(top::descendingPtSorter);
    }
 
    if (m_config->useTracks()) {
 
      const xAOD::TrackParticleContainer* calibratedTracks(nullptr);
      top::check(evtStore()->retrieve(calibratedTracks, m_config->sgKeyTracks(hash)), "Failed to retrieve tracks");
 
      if (!evtStore()->contains<xAOD::TrackParticleContainer>(m_config->sgKeyTracksTDS(hash))) {
 
    std::pair< xAOD::TrackParticleContainer*, xAOD::ShallowAuxContainer* > shallow_tracks = xAOD::shallowCopyContainer(*calibratedTracks);
 
    StatusCode save = evtStore()->tds()->record(shallow_tracks.first, m_config->sgKeyTracksTDS(hash));
    StatusCode saveAux =
          evtStore()->tds()->record(shallow_tracks.second, m_config->sgKeyTracksTDSAux(hash));
    top::check((save && saveAux), "Failed to store object in TStore");
      }
 
      xAOD::TrackParticleContainer* calibratedTracksTDS(nullptr);
      top::check(evtStore()->retrieve(calibratedTracksTDS, m_config->sgKeyTracksTDS(hash)), "Failed to retrieve tracks");
 
      for (auto index : currentSystematic.goodTracks()) {
        event.m_tracks.push_back(calibratedTracksTDS->at(index));
      }
 
      //shallow copies aren't sorted!                                                                                                                                                                     
      //sort only the selected tracks (faster)     
      event.m_tracks.sort(top::descendingPtSorter);
 
    }
 
 
    //met
    const xAOD::MissingETContainer* mets(nullptr);
    if (!currentSystematic.isLooseEvent()) {
      top::check(evtStore()->retrieve(mets, m_config->sgKeyMissingEt(hash)), "Failed to retrieve MET");
    }
    if (currentSystematic.isLooseEvent()) {
      top::check(evtStore()->retrieve(mets, m_config->sgKeyMissingEtLoose(hash)), "Failed to retrieve MET");
    }
    event.m_met = (*mets)["FinalTrk"];  // MissingETBase::Source::total()];
 
    //MC
    if (m_config->isMC()) {
      // Truth particles (these are BIG)
      if (m_config->useTruthParticles()) {
        top::check(evtStore()->retrieve(event.m_truth,
                                        m_config->sgKeyMCParticle()), "Failed to retrieve truth particles");
      }
 
      // Truth Event
      if (TopEventMaker::s_hasTruthEvent) {
        bool hasTruthEvent = evtStore()->retrieve(event.m_truthEvent, m_config->sgKeyTruthEvent());
        if (!hasTruthEvent) {
          ATH_MSG_WARNING("Failed to retrieve truth Event. TopEvent::m_truthEvent will be nullptr!");
          TopEventMaker::s_hasTruthEvent = false;
        }
      }
 
      // Parton History
      if (m_config->doTopPartonHistory()) {
        if (evtStore()->contains<xAOD::PartonHistoryContainer>(m_config->sgKeyTopPartonHistory())) {
          const xAOD::PartonHistoryContainer* partonHistory(nullptr);
          top::check(evtStore()->retrieve(partonHistory,
                                          m_config->sgKeyTopPartonHistory()), "Failed to retrieve Top Parton History");
          if (partonHistory->size() == 1) {
            event.m_partonHistory = partonHistory->at(0);
          }
        }
      } // end doTopPartonHistory
    } // end isMC
 
    decorateTopEvent(event);
    
    return event;
  }

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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

operator=()

TopEventMaker& top::TopEventMaker::operator= ( const TopEventMaker &  rhs )

delete

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 JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, top::TopObjectSelection, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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.

systematicEvents()

const xAOD::SystematicEventContainer * top::TopEventMaker::systematicEvents

(

const std::string &

sgKey

)

const

As top-xaod isn't an asg::AsgTool, it doesn't have access to all the information Very annoying.

As top-xaod isn't an asg::AsgTool, it doesn't have access to all the information Very annoying, as it's actually quite simple.

Definition at line 73 of file TopEventMaker.cxx.

                                                                                                  {
    const xAOD::SystematicEventContainer* systEvents(nullptr);
 
    top::check(evtStore()->retrieve(systEvents, sgKey), "Failed to get xAOD::SystematicEventContainer");
    return systEvents;
  }

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_config

std::shared_ptr<top::TopConfig> top::TopEventMaker::m_config

private

Definition at line 69 of file TopEventMaker.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_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_rc

std::unique_ptr<RCJet> top::TopEventMaker::m_rc

private

Definition at line 70 of file TopEventMaker.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_VarRC

std::map<std::string, std::unique_ptr<RCJet> > top::TopEventMaker::m_VarRC

private

Definition at line 71 of file TopEventMaker.h.

m_VarRCJetMassScale

std::vector<std::string> top::TopEventMaker::m_VarRCJetMassScale

private

Definition at line 73 of file TopEventMaker.h.

m_VarRCJetRho

std::vector<std::string> top::TopEventMaker::m_VarRCJetRho

private

Definition at line 72 of file TopEventMaker.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

s_hasTruthEvent

bool top::TopEventMaker::s_hasTruthEvent = true

staticprivate

Definition at line 75 of file TopEventMaker.h.

---

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

• TopEventMaker.h
• TopEventMaker.cxx