ViewCreatorCentredOnClusterROITool Class Reference

#include <ViewCreatorCentredOnClusterROITool.h>

Inheritance diagram for ViewCreatorCentredOnClusterROITool:

Collaboration diagram for ViewCreatorCentredOnClusterROITool:

Public Member Functions
	ViewCreatorCentredOnClusterROITool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~ViewCreatorCentredOnClusterROITool ()=default
virtual StatusCode	initialize () override
virtual StatusCode	attachROILinks (TrigCompositeUtils::DecisionContainer &decisions, const EventContext &ctx) const override
	Tool interface method. More...

Public Attributes
SG::WriteHandleKey< TrigRoiDescriptorCollection >	m_roisWriteHandleKey
Gaudi::Property< std::string >	m_clusterLinkName
Gaudi::Property< bool >	m_allowMultipleClusters
Gaudi::Property< double >	m_roiEtaWidth
Gaudi::Property< double >	m_roiPhiWidth
Gaudi::Property< double >	m_roiZedWidth

Detailed Description

Creates a new ROI centred on one or more xAOD::TrigEMCluster contained nominally within a L1 ROI.

By default the highest ET cluster is used (should there be multiple). Alternatively with AllowMultipleClusters, a superROI may be formed if multiple clusters are reconstructed inside the (L1) ROI.

Stores this new ROI in the output container, and links it to the Decision Object

The new EventView spawned by the parent EventViewCreatorAlgorithm of this tool will process in this new ROI.

Definition at line 26 of file ViewCreatorCentredOnClusterROITool.h.

Constructor & Destructor Documentation

ViewCreatorCentredOnClusterROITool()

ViewCreatorCentredOnClusterROITool::ViewCreatorCentredOnClusterROITool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 12 of file ViewCreatorCentredOnClusterROITool.cxx.

  : base_class(type, name, parent) 
  {}

~ViewCreatorCentredOnClusterROITool()

virtual ViewCreatorCentredOnClusterROITool::~ViewCreatorCentredOnClusterROITool ( )

virtualdefault

Member Function Documentation

attachROILinks()

StatusCode ViewCreatorCentredOnClusterROITool::attachROILinks ( TrigCompositeUtils::DecisionContainer &  decisions, const EventContext &  ctx  ) const

overridevirtual

Tool interface method.

should really use some z position from somewhere, since we might be using this function after some tracking, so to always assume that z=0 is maybe not ideal

Definition at line 23 of file ViewCreatorCentredOnClusterROITool.cxx.

                                                                                                                                           {
  SG::WriteHandle<TrigRoiDescriptorCollection> roisWriteHandle = createAndStoreNoAux(m_roisWriteHandleKey, ctx);
  
  for ( Decision* outputDecision : decisions ) { 
    const std::vector<LinkInfo<xAOD::TrigEMClusterContainer>> myClusters = findLinks<xAOD::TrigEMClusterContainer>(outputDecision, m_clusterLinkName, TrigDefs::lastFeatureOfType);
    
    if (myClusters.size() == 0) {
      ATH_MSG_ERROR("Found zero xAOD::TrigEMClusters '" << m_clusterLinkName << "' for Decision object index " << outputDecision->index());
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG("This merged Decision Object has " << myClusters.size() << " TrigEMClusters in its history from a previous Step."
      << " AllowMultipleClusters=" << (m_allowMultipleClusters ? "TRUE" : "FALSE"));
 
    // In NOT m_allowMultipleClusters mode, we centre on the highest et
    size_t singleClusterIndex = 0;
    if (!m_allowMultipleClusters && myClusters.size() > 1) {
      float maxEt = 0;
      for (const LinkInfo<xAOD::TrigEMClusterContainer>& myCluster : myClusters) {
        ATH_CHECK(myCluster.isValid());
        ATH_MSG_VERBOSE("- The TrigEMCluster at index " << myCluster.link.index() << " has Et " << (*myCluster.link)->et() << " MeV.");
        if ((*myCluster.link)->et() > maxEt) {
          maxEt = (*myCluster.link)->et();
          singleClusterIndex = myCluster.link.index();
        }
      }
      ATH_MSG_DEBUG("The TrigEMCluster at index " << singleClusterIndex << " will be used as the centre of the FTF ROI, as this one has the highest ET (" << maxEt << " MeV).");
    }
 
    // In m_allowMultipleClusters mode, they are all collected into a SuperRoI
    if (m_allowMultipleClusters) {
      TrigRoiDescriptor* superRoI = new TrigRoiDescriptor();
      superRoI->setComposite(true);
      superRoI->manageConstituents(true);
      roisWriteHandle->push_back(superRoI);
    }
 
    for (const LinkInfo<xAOD::TrigEMClusterContainer>& myCluster : myClusters) {
      ATH_CHECK(myCluster.isValid());
      if (!m_allowMultipleClusters && myCluster.link.index() != singleClusterIndex) {
        continue;
      }
 
      const xAOD::TrigEMCluster* c = *(myCluster.link);
 
      const double reta  = c->eta();
      const double retap = reta + m_roiEtaWidth;
      const double retam = reta - m_roiEtaWidth;
      const double rphi  = c->phi();
      const double rphip = rphi + m_roiPhiWidth;
      const double rphim = rphi - m_roiPhiWidth;
 
      ATH_MSG_DEBUG( "  New ROI for xAOD::TrigEMCluster ET="<< c->et() 
             << " eta="<< c->eta() << " +- " << m_roiEtaWidth 
             << " phi="<< c->phi() << " +- " << m_roiPhiWidth );
 
      if ( m_roiZedWidth==0 ) { 
    std::unique_ptr<TrigRoiDescriptor> roi = std::make_unique<TrigRoiDescriptor>(reta, retam, retap, rphi, rphim, rphip);
    if (m_allowMultipleClusters) {
      roisWriteHandle->back()->push_back( roi.release() ); // Note: manageConstituents=true, superRoI will handle deletion of roi
    } else {
      roisWriteHandle->push_back( roi.release() ); // Note: roi now owned by roisWriteHandle
    }
      }
      else {
    const double rzed  = 0;
    const double rzedm = rzed - m_roiZedWidth;
    const double rzedp = rzed + m_roiZedWidth;
 
    std::unique_ptr<TrigRoiDescriptor> roi = std::make_unique<TrigRoiDescriptor>(reta, retam, retap, rphi, rphim, rphip, rzed, rzedm, rzedp );
    if (m_allowMultipleClusters) {
      roisWriteHandle->back()->push_back( roi.release() ); // Note: manageConstituents=true, superRoI will handle deletion of roi
    } else {
      roisWriteHandle->push_back( roi.release() ); // Note: roi now owned by roisWriteHandle
    }
      }
      
    
    }
 
    // Link this ROI into the navigation. It will be used to spawn the Event View for this Decision Object.
    const ElementLink<TrigRoiDescriptorCollection> roiEL = ElementLink<TrigRoiDescriptorCollection>(*roisWriteHandle, roisWriteHandle->size() - 1, ctx);
    outputDecision->setObjectLink(roiString(), roiEL);
 
  }
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode ViewCreatorCentredOnClusterROITool::initialize ( )

overridevirtual

Definition at line 17 of file ViewCreatorCentredOnClusterROITool.cxx.

                                                           {
  ATH_CHECK(m_roisWriteHandleKey.initialize());
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_allowMultipleClusters

Gaudi::Property< bool > ViewCreatorCentredOnClusterROITool::m_allowMultipleClusters

Initial value:

{this, "AllowMultipleClusters", true,
    "If true, the tool will not take the highest energy cluster. Instead it will add them all to a superRoI"}

Definition at line 46 of file ViewCreatorCentredOnClusterROITool.h.

m_clusterLinkName

Gaudi::Property< std::string > ViewCreatorCentredOnClusterROITool::m_clusterLinkName

Initial value:

{this,"ClusterLinkName","feature",
    "Name of linked Cluster object to centre the new ROI on. Normally the 'feature' from the previous Step."}

Definition at line 43 of file ViewCreatorCentredOnClusterROITool.h.

m_roiEtaWidth

Gaudi::Property< double > ViewCreatorCentredOnClusterROITool::m_roiEtaWidth

Initial value:

{this,"RoIEtaWidth",0.05,
    "Extent of the ROI in eta from its centre"}

Definition at line 49 of file ViewCreatorCentredOnClusterROITool.h.

m_roiPhiWidth

Gaudi::Property< double > ViewCreatorCentredOnClusterROITool::m_roiPhiWidth

Initial value:

{this,"RoIPhiWidth",0.05,
    "Extent of the ROI in phi from its centre"}

Definition at line 52 of file ViewCreatorCentredOnClusterROITool.h.

m_roisWriteHandleKey

SG::WriteHandleKey< TrigRoiDescriptorCollection > ViewCreatorCentredOnClusterROITool::m_roisWriteHandleKey

Initial value:

{this,"RoisWriteHandleKey","",
    "Name of the ROI collection produced by this tool."}

Definition at line 40 of file ViewCreatorCentredOnClusterROITool.h.

m_roiZedWidth

Gaudi::Property< double > ViewCreatorCentredOnClusterROITool::m_roiZedWidth

Initial value:

{this,"RoIZedWidth",0.0,
    "Extent of the ROI in zed from its centre"}

Definition at line 55 of file ViewCreatorCentredOnClusterROITool.h.

---

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

• ViewCreatorCentredOnClusterROITool.h
• ViewCreatorCentredOnClusterROITool.cxx