InDetVertexTruthMatchUtils Namespace Reference

Typedefs
typedef std::tuple< ElementLink< xAOD::TruthEventBaseContainer >, float, float >	VertexTruthMatchInfo

Enumerations
enum	VertexMatchType {   MATCHED, MERGED, SPLIT, FAKE,   DUMMY, NTYPES }
enum	HardScatterType {   CLEAN, LOWPU, HIGHPU, HSSPLIT,   NONE, NHSTYPES }

Functions
const xAOD::Vertex *	bestHardScatterMatch (const xAOD::VertexContainer &vxContainer)
const std::vector< std::pair< const xAOD::Vertex *, size_t > >	hardScatterMatches (const xAOD::VertexContainer &vxContainer)
HardScatterType	classifyHardScatter (const xAOD::VertexContainer &vxContainer)

Typedef Documentation

VertexTruthMatchInfo

typedef std::tuple<ElementLink<xAOD::TruthEventBaseContainer>, float, float> InDetVertexTruthMatchUtils::VertexTruthMatchInfo

Definition at line 17 of file InDetVertexTruthMatchUtils.h.

Enumeration Type Documentation

HardScatterType

enum InDetVertexTruthMatchUtils::HardScatterType

Enumerator
CLEAN
LOWPU
HIGHPU
HSSPLIT
NONE
NHSTYPES

Definition at line 30 of file InDetVertexTruthMatchUtils.h.

                       {
    CLEAN,   // matched
    LOWPU,   // merged, but dominant contributor
    HIGHPU,  // merged and dominated by pile-up or fakes
    HSSPLIT, // split
    NONE,    // not found
    NHSTYPES
  };

VertexMatchType

enum InDetVertexTruthMatchUtils::VertexMatchType

Enumerator
MATCHED
MERGED
SPLIT
FAKE
DUMMY
NTYPES

Definition at line 20 of file InDetVertexTruthMatchUtils.h.

                       {
    MATCHED, // > threshold (default 70%) from one truth interaction
    MERGED,  // not matched
    SPLIT,   // highest weight truth interaction contributes to >1 vtx (vtx with highest fraction of sumpT2 remains matched/merged)
    FAKE,    // highest contribution is fake (if pile-up MC info not present those tracks end up as "fakes")
    DUMMY,   // is the dummy vertex
    NTYPES   // access to number of types
};

Function Documentation

bestHardScatterMatch()

const xAOD::Vertex * InDetVertexTruthMatchUtils::bestHardScatterMatch

(

const xAOD::VertexContainer &

vxContainer

)

Definition at line 20 of file InDetVertexTruthMatchUtils.cxx.

                                                                                   {
  //accessors for decorations
  xAOD::Vertex::ConstAccessor<int> nHSTrkDecor("nHSTrk");
 
  std::vector<std::pair<const xAOD::Vertex*, size_t> > allMatches = hardScatterMatches( vxContainer );
 
  int bestNHSTrk = 0;
  const xAOD::Vertex * best = nullptr;
  for ( auto it : allMatches ) {
    int nHSTrk = nHSTrkDecor( *(it.first) );
    if( nHSTrk > bestNHSTrk ){
      bestNHSTrk = nHSTrk;
      best = it.first;
    }
  }
 
  //if didn't find any matches will return 0
  return best;
}

classifyHardScatter()

HardScatterType InDetVertexTruthMatchUtils::classifyHardScatter

(

const xAOD::VertexContainer &

vxContainer

)

Definition at line 70 of file InDetVertexTruthMatchUtils.cxx.

                                                                               {
 
  // return a vector of reco vertices with contributions from the hard-scatter
  // if the second element in the pair is zero, it means tracks from the hard-scatter
  // contribute more weight to that reco vertex than any other interaction
  std::vector<std::pair<const xAOD::Vertex*, size_t> > matches = hardScatterMatches( vxContainer );
 
  // information indicating whether a given reco vertex is:
  // MATCHED, MERGED, SPLIT or FAKE
  xAOD::Vertex::Decorator<VertexMatchType> matchTypeDecor("VertexMatchType");
 
  if (  matches.empty() ) {
    // No reco vertices with tracks from hard-scatter
    return NONE;
  } else if ( matches.size() == 1 ) {
    // A single reco vertex has tracks from hard-scatter
    const VertexMatchType & type = matchTypeDecor( *(matches[0].first) );
    //check if the index in the matching info for HS is first, then can assign clean/lowpu based on match/merge
    if ( matches[0].second == 0 && type == MATCHED ) {
      // HS made largest contribution and vertex matched
      return CLEAN;
    } else if ( matches[0].second == 0 && type == MERGED ) {
      // HS made largest contribution and vertex merged
      return LOWPU;
    } else {
      // HS did not make largest contribution or vertex is fake or vertex is part of non-HS split pair
      return HIGHPU;
    }
 
  } else {
    // multiple reco vertices have tracks from hard-scatter
    // count how many have hard-scatter tracks as largest contribution
    int num_main = 0;
    const xAOD::Vertex* mainVtx = nullptr;
    for ( auto it : matches ) {
      if ( it.second == 0 ) // is hard-scatter the largest contribution?
      {
        num_main++;
        mainVtx = it.first;
      }
    }
    if (num_main == 0 ) {
      return HIGHPU;
    } else if (num_main == 1 ) {
      const VertexMatchType& type = matchTypeDecor(*mainVtx);
      if (type == MATCHED)
        return CLEAN;
      else if (type == MERGED)
        return LOWPU;
      else
        return HIGHPU;
    } else {
      return HSSPLIT;
    }
  }
 
  return NONE;
}

hardScatterMatches()

const std::vector< std::pair< const xAOD::Vertex *, size_t > > InDetVertexTruthMatchUtils::hardScatterMatches

(

const xAOD::VertexContainer &

vxContainer

)

Definition at line 41 of file InDetVertexTruthMatchUtils.cxx.

                                                                                                                   {
  //accessors for decorations
  xAOD::Vertex::ConstAccessor<std::vector<VertexTruthMatchInfo> > matchInfoDecor("TruthEventMatchingInfos");
 
  //return vector
  std::vector<std::pair<const xAOD::Vertex*, size_t> > result;
 
  //loop and look
  for ( auto vxit : vxContainer ) {
    try{
      const std::vector<VertexTruthMatchInfo> & info =  matchInfoDecor( *vxit );
      if (!matchInfoDecor.isAvailable(*vxit)){
        return result;
      }
      for ( size_t i = 0; i < info.size(); ++i ) {
        if ( isHardScatterEvent( std::get<0>(info[i]) ) ) {
          result.emplace_back(vxit, i );
          break;
        }
      }
    }
    catch (SG::ExcBadAuxVar &){
        return result;
    }
 
  }
  return result;
}