DerivationFramework::Thin_vtxDuplicates Class Reference

#include <Thin_vtxDuplicates.h>

Inheritance diagram for DerivationFramework::Thin_vtxDuplicates:

Collaboration diagram for DerivationFramework::Thin_vtxDuplicates:

Public Member Functions
	Thin_vtxDuplicates (const std::string &t, const std::string &n, const IInterface *p)
	~Thin_vtxDuplicates ()
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
virtual StatusCode	doThinning () const

Private Attributes
bool	m_noFlags
StringProperty	m_streamName { this, "StreamName", "", "Name of the stream being thinned" }
std::atomic< unsigned int >	m_nVtxTot
std::atomic< unsigned int >	m_nVtxPass
SG::ThinningHandleKey< xAOD::VertexContainer >	m_vertexContainerNames
SG::ReadDecorHandleKeyArray< xAOD::VertexContainer >	m_passFlags

Detailed Description

Definition at line 18 of file Thin_vtxDuplicates.h.

Constructor & Destructor Documentation

Thin_vtxDuplicates()

DerivationFramework::Thin_vtxDuplicates::Thin_vtxDuplicates	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 22 of file Thin_vtxDuplicates.cxx.

                                                                                                                      :
  base_class(t,n,p),
 // m_acceptanceR(-1.),
  m_noFlags(false),
  m_nVtxTot(0),
  m_nVtxPass(0)
{
  declareProperty("VertexContainerName"      , m_vertexContainerNames);
  declareProperty("PassFlags"                 , m_passFlags);
  //declareProperty("AcceptanceRadius"          , m_acceptanceR);
  declareProperty("IgnoreFlags"               , m_noFlags);
  //declareProperty("ApplyAndForTracks"         , m_trackAnd = false);
  //declareProperty("ThinTracks"                , m_thinTracks = true);
}

~Thin_vtxDuplicates()

DerivationFramework::Thin_vtxDuplicates::~Thin_vtxDuplicates ( )

default

Member Function Documentation

doThinning()

StatusCode DerivationFramework::Thin_vtxDuplicates::doThinning ( ) const

virtual

Definition at line 73 of file Thin_vtxDuplicates.cxx.

{
    // retieve vertex
    const EventContext& ctx = Gaudi::Hive::currentContext();
    SG::ThinningHandle< xAOD::VertexContainer > vertexContainer(m_vertexContainerNames, ctx);
    std::vector<bool> vtxMask(vertexContainer->size(), true); // default: keep all vertices
    int vtxTot = 0;
    int nVtxPass = 0;
    // loop over vertices
    int k = 0;
    std::vector<SG::ReadDecorHandle<xAOD::VertexContainer, Char_t>> handles;
    handles.reserve(m_passFlags.size());
    for(const auto &key : m_passFlags){
        handles.emplace_back(key, ctx);
        if(!handles.back().isPresent()) return StatusCode::FAILURE;
    }
    for(auto vtxItr = vertexContainer->cbegin(); vtxItr!=vertexContainer->cend(); ++vtxItr, ++k) {
      const xAOD::Vertex* vtx = *vtxItr;
      // check if the vertex passed the required selections criteria (is run when the vertex is already excluded, because the counter needs the info)
      bool passed = false;
      if(m_noFlags){passed = true; vtxTot++; }
      else{
        for(auto &flagAcc : handles) {
          if(flagAcc(*vtx) != 0) {
            passed = true;
            vtxTot++;//Have to count the ones which are accepted to start with
            break;
          }
        } // end of loop over flags
      }
 
      // Skip if it has already been identified as duplicate
      if(vtxMask[k] == false)continue;  //After the flag-check to have the total-passed work correctly
 
      if(!passed)vtxMask[k]= false;
 
      if(passed) {
          // vertex passed the selection
          nVtxPass++;
 
          // determine the sum of the tracks at vertex as centre for the cone
          std::vector<const xAOD::TrackParticle*> presentVertex, compareVertex;
 
          //Fill in the present vertex, for later comparison against other vertices
              presentVertex.clear();
          for(uint j=0; j<vtx->nTrackParticles(); ++j) {
            presentVertex.push_back(vtx->trackParticle(j));
          }
          sort( presentVertex.begin(), presentVertex.end() );  //Sort the trackparticles BY POINTER ADDRESS
 
          //Loop over the remaining vertices and remove them if needed
          int loop_k = k+1;
          for(auto vtxLoopItr = vtxItr+1; vtxLoopItr!=vertexContainer->cend(); vtxLoopItr++, loop_k++){
 
              const xAOD::Vertex* loop_vtx = *vtxLoopItr;
 
              //Vertices are distinct if have different size
              if(vtx->nTrackParticles() !=  loop_vtx->nTrackParticles())continue;
 
              //If the vertex is still active load and compare
              if(vtxMask[loop_k]){
 
                    compareVertex.clear();
                  for(uint j=0; j<loop_vtx->nTrackParticles(); ++j) {
                    compareVertex.push_back(loop_vtx->trackParticle(j));
                  } 
 
                  std::sort( compareVertex.begin(), compareVertex.end());
 
                  vtxMask[loop_k] = false;
            
                  ATH_MSG_DEBUG("Compared tracks: ");
                  ATH_MSG_DEBUG(std::setw(14)<<compareVertex[0]<<std::setw(14) << compareVertex[1]<<std::setw(14)<<compareVertex[2]);
                  ATH_MSG_DEBUG(std::setw(14)<<presentVertex[0]<<std::setw(14) << presentVertex[1]<<std::setw(14)<<presentVertex[2]);
 
                  for(uint j=0; j<loop_vtx->nTrackParticles(); ++j) {
                    if( compareVertex[j] != presentVertex[j] ){vtxMask[loop_k] = true;  break;}
                  }
                  ATH_MSG_DEBUG("Verdict:"<<(vtxMask[loop_k]? "keep": "erase") );
              }
 
          } // Endo of extra loop over remaining vertices
 
      } // if( passed )
    } // end of loop over vertices
    
    // Execute the thinning service based on the vtxMask.
    vertexContainer.keep(vtxMask);
    
    m_nVtxTot.fetch_add( vtxTot, std::memory_order_relaxed);
    m_nVtxPass.fetch_add( nVtxPass, std::memory_order_relaxed);
 
  
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode DerivationFramework::Thin_vtxDuplicates::finalize ( )

virtual

Definition at line 64 of file Thin_vtxDuplicates.cxx.

{
  ATH_MSG_VERBOSE("finalize() ...");
  ATH_MSG_INFO("Processed "<< m_nVtxTot <<" vertices, "<< m_nVtxPass<< " were retained ");
  
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::Thin_vtxDuplicates::initialize ( )

virtual

Definition at line 41 of file Thin_vtxDuplicates.cxx.

{
  // Decide which collections need to be checked for ID TrackParticles
  ATH_MSG_VERBOSE("initialize() ...");
  ATH_CHECK(m_vertexContainerNames.initialize(m_streamName));
 
  
  if (m_passFlags.empty()) {
    ATH_MSG_FATAL("No pass flags provided for thinning.");
    return StatusCode::FAILURE;
  } else {
    for(auto itr = m_passFlags.cbegin(); itr!=m_passFlags.cend(); ++itr) {
      ATH_MSG_INFO("Vertices must pass the \"" << itr->key() << "\" selection");
    }
  }
 
  for(auto &key : m_passFlags){
        key = m_vertexContainerNames.key() + '.' + key.key();
  }
  ATH_CHECK(m_passFlags.initialize());
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_noFlags

bool DerivationFramework::Thin_vtxDuplicates::m_noFlags

private

Definition at line 27 of file Thin_vtxDuplicates.h.

m_nVtxPass

std::atomic<unsigned int> DerivationFramework::Thin_vtxDuplicates::m_nVtxPass

private

Definition at line 29 of file Thin_vtxDuplicates.h.

m_nVtxTot

std::atomic<unsigned int> DerivationFramework::Thin_vtxDuplicates::m_nVtxTot

mutableprivate

Definition at line 29 of file Thin_vtxDuplicates.h.

m_passFlags

SG::ReadDecorHandleKeyArray<xAOD::VertexContainer> DerivationFramework::Thin_vtxDuplicates::m_passFlags

private

Definition at line 32 of file Thin_vtxDuplicates.h.

m_streamName

StringProperty DerivationFramework::Thin_vtxDuplicates::m_streamName { this, "StreamName", "", "Name of the stream being thinned" }

private

Definition at line 28 of file Thin_vtxDuplicates.h.

m_vertexContainerNames

SG::ThinningHandleKey< xAOD::VertexContainer > DerivationFramework::Thin_vtxDuplicates::m_vertexContainerNames

private

Definition at line 31 of file Thin_vtxDuplicates.h.

---

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

• Thin_vtxDuplicates.h
• Thin_vtxDuplicates.cxx