TrigHitDVHypoAlg.cxx File Reference

#include "TrigHitDVHypoAlg.h"
#include "AthViews/ViewHelper.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
#include "GaudiKernel/SystemOfUnits.h"
#include "AthenaMonitoringKernel/Monitored.h"
#include "GaudiKernel/PhysicalConstants.h"
#include "PathResolver/PathResolver.h"
#include "xAODTrigger/jFexSRJetRoI.h"
#include "TrigInDetPattRecoTools/TrigInDetUtils.h"
#include "CxxUtils/phihelper.h"
#include "TrigInDetToolInterfaces/ITrigSpacePointConversionTool.h"
#include "TFile.h"
#include "TTree.h"
#include <vector>
#include <unordered_map>

Go to the source code of this file.

Typedefs
typedef xAOD::TrigCompositeContainer	DecisionContainer
typedef xAOD::TrigCompositeAuxContainer	DecisionAuxContainer
typedef std::set< DecisionID >	DecisionIDContainer
typedef xAOD::TrigComposite	Decision
typedef JetContainer_v1	JetContainer
	Definition of the current "jet container version".

Functions
SG::WriteHandle< DecisionContainer >	createAndStore (const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx)
	Creates and right away records the DecisionContainer with the key.
void	decisionIDs (const Decision *d, DecisionIDContainer &id)
	Extracts DecisionIDs stored in the Decision object.
Decision *	newDecisionIn (DecisionContainer *dc, const std::string &name="")
	Helper method to create a Decision object, place it in the container and return a pointer to it.
void	linkToPrevious (Decision *d, const std::string &previousCollectionKey, size_t previousIndex)
	Links to the previous object, location of previous 'seed' decision supplied by hand.
const std::string &	viewString ()
const std::string &	featureString ()
const std::string &	hypoAlgNodeName ()
template<typename T>
LinkInfo< T >	findLink (const Decision *start, const std::string &linkName, const bool suppressMultipleLinksWarning=false)
	Perform a recursive search for ElementLinks of type T and name 'linkName', starting from Decision object 'start' For the case of multiple links, this function only returns the first one found.
bool	allFailed (const Decision *d)
	return true if there is no positive decision stored

Typedef Documentation

Decision

typedef xAOD::TrigComposite TrigCompositeUtils::Decision

Definition at line 20 of file Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h.

DecisionAuxContainer

typedef xAOD::TrigCompositeAuxContainer TrigCompositeUtils::DecisionAuxContainer

Definition at line 20 of file TrigCompositeAuxContainer.h.

DecisionContainer

typedef xAOD::TrigCompositeContainer TrigCompositeUtils::DecisionContainer

Definition at line 21 of file Event/xAOD/xAODTrigger/xAODTrigger/TrigCompositeContainer.h.

DecisionIDContainer

typedef std::set<DecisionID> TrigCompositeUtils::DecisionIDContainer

Definition at line 28 of file TrigComposite_v1.h.

JetContainer

typedef DataVector< Jet > xAOD::JetContainer

Definition of the current "jet container version".

Definition of the current container version.

Definition at line 17 of file JetContainer.h.

Function Documentation

allFailed()

bool TrigCompositeUtils::allFailed

(

const Decision *

d

)

return true if there is no positive decision stored

Definition at line 104 of file TrigCompositeUtilsRoot.cxx.

                                      {
    const std::vector<DecisionID>& decisions = readOnlyAccessor( *d );    
    return decisions.empty();
  }

createAndStore()

SG::WriteHandle< DecisionContainer > TrigCompositeUtils::createAndStore	(	const SG::WriteHandleKey< DecisionContainer > &	key,
		const EventContext &	ctx )

Creates and right away records the DecisionContainer with the key.

Returns the WriteHandle.

Definition at line 28 of file TrigCompositeUtilsRoot.cxx.

                                                                                                                             {
    SG::WriteHandle<DecisionContainer> handle( key, ctx );
    auto data = std::make_unique<DecisionContainer>() ;
    auto aux = std::make_unique<DecisionAuxContainer>() ;
    data->setStore( aux.get() );
    handle.record( std::move( data ), std::move( aux )  ).ignore();
    return handle;
  }

decisionIDs()

void TrigCompositeUtils::decisionIDs	(	const Decision *	d,
		DecisionIDContainer &	destination )

Extracts DecisionIDs stored in the Decision object.

Definition at line 65 of file TrigCompositeUtilsRoot.cxx.

                                                                          {    
    const std::vector<DecisionID>& decisions = readOnlyAccessor( *d );    
    destination.insert( decisions.begin(), decisions.end() );
  }

featureString()

const std::string & TrigCompositeUtils::featureString ( )

inline

Definition at line 421 of file TrigCompositeUtils.h.

{ return Decision::s_featureString; }

findLink()

template<typename T>

LinkInfo< T > TrigCompositeUtils::findLink	(	const Decision *	start,
		const std::string &	linkName,
		const bool	suppressMultipleLinksWarning = false )

Perform a recursive search for ElementLinks of type T and name 'linkName', starting from Decision object 'start' For the case of multiple links, this function only returns the first one found.

See also

findLinks

Parameters

[in]	start	the Decision Object from where recursive search should begin
[in]	linkName	the name of the ElementLink stored inside one or more DecisionObjects.
[in]	suppressMultipleLinksWarning	findLink will print a warning if more than one ElementLink is found, this can be silenced here.

Returns

LinkInfo A wrapper around an ElementLink and the location in the graph

hypoAlgNodeName()

const std::string & TrigCompositeUtils::hypoAlgNodeName ( )

inline

Definition at line 427 of file TrigCompositeUtils.h.

{ return Decision::s_hypoAlgNodeNameString; }

linkToPrevious()

void TrigCompositeUtils::linkToPrevious	(	Decision *	d,
		const std::string &	previousCollectionKey,
		size_t	previousIndex )

Links to the previous object, location of previous 'seed' decision supplied by hand.

Definition at line 140 of file TrigCompositeUtilsRoot.cxx.

                                                                                                    {
    ElementLink<DecisionContainer> seed = ElementLink<DecisionContainer>( previousCollectionKey, previousIndex );
    if (!seed.isValid()) {
      throw std::runtime_error("TrigCompositeUtils::linkToPrevious Invalid Decision Link key or index provided");
    } else {
      d->addObjectCollectionLink(seedString(), seed);
    }
  }

newDecisionIn()

Decision * TrigCompositeUtils::newDecisionIn	(	DecisionContainer *	dc,
		const std::string &	name = "" )

Helper method to create a Decision object, place it in the container and return a pointer to it.

This is to make this: auto d = newDecisionIn(output); instead of: auto d = new Decision; output->push_back(d); If provided, the name is assigned to the TC object Note that the supplied DecisionContainer must have been recorded in the event store.

Definition at line 44 of file TrigCompositeUtilsRoot.cxx.

                                                                          {
    Decision * x = new Decision;
    dc->push_back( x );
    if ( ! name.empty() ) {
      x->setName( name );
    }
    return x;
  }

viewString()

const std::string & TrigCompositeUtils::viewString ( )

inline

Definition at line 420 of file TrigCompositeUtils.h.

{ return Decision::s_viewString; }