DerivationFramework::VertexTrackIsolation Class Reference

#include <VertexTrackIsolation.h>

Inheritance diagram for DerivationFramework::VertexTrackIsolation:

Collaboration diagram for DerivationFramework::VertexTrackIsolation:

Public Member Functions
	VertexTrackIsolation (const std::string &t, const std::string &n, const IInterface *p)
StatusCode	initialize ()
StatusCode	finalize ()
virtual StatusCode	addBranches (const EventContext &ctx) const
bool	isSame (const xAOD::Vertex *theVtx1, const xAOD::Vertex *theVtx2) const
bool	isContainedIn (const xAOD::Vertex *theVtx, const std::vector< const xAOD::Vertex * > &theColl) const

Private Attributes
ToolHandle< xAOD::ITrackIsolationTool >	m_trackIsoTool
std::string	m_trackContainerName
std::string	m_vertexContainerName
std::vector< unsigned int >	m_cones
std::vector< std::string >	m_passFlags
int	m_vertexType
bool	m_doIsoPerTrk
int	m_removeDuplicate
bool	m_fixElecExclusion
bool	m_includeV0

Detailed Description

Definition at line 24 of file VertexTrackIsolation.h.

Constructor & Destructor Documentation

VertexTrackIsolation()

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

Definition at line 21 of file VertexTrackIsolation.cxx.

    : base_class(t, n, p),
      m_trackIsoTool("xAOD::TrackIsolationTool"),
      m_trackContainerName("InDetTrackParticles"),
      m_vertexContainerName("NONE"),
      m_cones(),
      m_vertexType(7),
      m_doIsoPerTrk(false),
      m_removeDuplicate(2),
      m_fixElecExclusion(false),
      m_includeV0(false) {
  ATH_MSG_DEBUG("in constructor");
 
  // Declare tools
  declareProperty("TrackIsoTool", m_trackIsoTool);
  declareProperty("TrackContainer", m_trackContainerName);
  declareProperty("InputVertexContainer", m_vertexContainerName);
  declareProperty("PassFlags", m_passFlags);
  declareProperty("IsolationTypes", m_cones);
  declareProperty("DoVertexTypes", m_vertexType);
 
  declareProperty("DoIsoPerTrk", m_doIsoPerTrk,
                  "New property to deal with track isolation per track, the default option "
                  "(m_doIsoPerTrk=false) preserves the old behavior");
  declareProperty("RemoveDuplicate", m_removeDuplicate, "Used with DoIsoPerTrk");
  declareProperty("FixElecExclusion", m_fixElecExclusion);
  declareProperty("IncludeV0", m_includeV0);
}

Member Function Documentation

addBranches()

StatusCode DerivationFramework::VertexTrackIsolation::addBranches ( const EventContext & ctx ) const

virtual

Definition at line 124 of file VertexTrackIsolation.cxx.

                                                                      {
 
  const xAOD::TrackParticleContainer* idTrackParticleContainer{};
  const xAOD::VertexContainer* vertexContainer{};
 
  if (evtStore()->contains<xAOD::TrackParticleContainer>(m_trackContainerName)) {
    CHECK(evtStore()->retrieve(idTrackParticleContainer, m_trackContainerName)); // FIXME Use Handles
  } else {
    ATH_MSG_ERROR("Failed loading IdTrackparticleContainer container");
    return StatusCode::FAILURE;
  }
 
  //  load vertices
  if (evtStore()->contains<xAOD::VertexContainer>(m_vertexContainerName)) {
    CHECK(evtStore()->retrieve(vertexContainer, m_vertexContainerName)); // FIXME Use Handles
  } else {
    ATH_MSG_ERROR("Failed loading vertex container");
    return StatusCode::FAILURE;
  }
 
  std::vector<const xAOD::Vertex*> outVtxContainer;
 
  // Convert m_cones (done per-event to avoid needing extra public dependency)
 
  std::vector<xAOD::Iso::IsolationType> cones(m_cones.size());
 
  for (unsigned int i = 0; i < m_cones.size(); i++)
    cones[i] = xAOD::Iso::IsolationType(m_cones[i]);
 
  // The provided IsolationTypes are re-ordered internally
  std::sort(cones.begin(), cones.end(), [](xAOD::Iso::IsolationType i, xAOD::Iso::IsolationType j) {
    return xAOD::Iso::coneSize(i) > xAOD::Iso::coneSize(j);
  });
 
  //  loop over vertices
  for (auto vertex : *vertexContainer) {
 
    bool passed = false;
    for (std::vector<std::string>::const_iterator flagItr = m_passFlags.begin(); flagItr != m_passFlags.end();
         ++flagItr) {
      SG::Accessor<Char_t> flagAcc(*flagItr);
      if (flagAcc.isAvailable(*vertex) && flagAcc(*vertex) != 0) {
        passed = true;
        break;
      }
    }  // end of loop over flags
    // if no passFlags given, decorate everything
    if (passed || m_passFlags.empty()) {
      if (!m_doIsoPerTrk) {  // for legacy
        // Removed warning was here
      } else {
        if (m_removeDuplicate) {
          if (isContainedIn(vertex, outVtxContainer))
            continue;
          outVtxContainer.push_back(vertex);
        }
      }
 
      TLorentzVector candidate;
 
      std::set<const xAOD::TrackParticle*> exclusionset;
 
      for (auto part : vertex->trackParticleLinks()) {  // Loop over tracks linked to vertex
 
        candidate += (*part)->p4();
 
        // if you have electron tracks that are GSF, need to get original ID
        // trackparticle for excluding this particle
        if (m_fixElecExclusion) {
          const xAOD::TrackParticle* partID = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(*part);
          exclusionset.insert(partID);
        } else
          exclusionset.insert(*part);  // If it crashes use the direct TP from the vertex
      }
      // No! the above candidate will fail acceptance of isolation() because
      // it's neither a muon nor a TrackParticle
 
      // Add in V0->XX particles
      if (m_includeV0) {
        static const SG::ConstAccessor<std::vector<ElementLink<DataVector<xAOD::Vertex_v1> > > >
          V0VertexLinksAcc("V0VertexLinks");
        auto V0VertLink = V0VertexLinksAcc(*vertex);
        const xAOD::Vertex* V0Vert = V0VertLink.at(0).getDataPtr()->at(0);
        for (auto part : V0Vert->trackParticleLinks()) {
          candidate += (*part)->p4();
          exclusionset.insert(*part);
        }
      }
 
      // Make a dummy TrackParticle, otherwise TrackIsolationTool cannot deal
      // with it
      xAOD::TrackParticle candidate_slyTrack;
      candidate_slyTrack.makePrivateStore();
      candidate_slyTrack.setDefiningParameters(0, 0., candidate.Phi(), candidate.Theta(), 0. /*1./candidate.P()*/);
      // The precision goes down a bit, but it's a matter of 10e-7 with our
      // values of interest
 
      // Make a correctionlist such that the given exclusionset will be removed
      // from the used tracks There is no danger that the input particle will be
      // excluded, as it is not part of inDetTrackContainer
      xAOD::TrackCorrection corrlist;
      corrlist.trackbitset.set(static_cast<unsigned int>(xAOD::Iso::coreTrackPtr));
 
      const string vtxType_name[3] = {"SumPt", "A0", "Z0"};
 
      xAOD::BPhysHelper vertex_h(vertex);  // Use the BPhysHelper to access vertex quantities
 
      // Loop over refitted primary vertex choice
      for (unsigned int vertex_type = 0; vertex_type <= xAOD::BPhysHelper::PV_MIN_Z0; vertex_type++) {
 
        if ((m_vertexType & (1 << vertex_type)) == 0)
          continue;  // Stop if the type of vertex is not required
 
        ATH_MSG_DEBUG("List of cone types");
        for (unsigned int i = 0; i < cones.size(); i++) {
          ATH_MSG_DEBUG("cone type = " << xAOD::Iso::toString(xAOD::Iso::IsolationType(cones[i])));
        }
 
        const xAOD::Vertex* refVtx = vertex_h.pv(static_cast<xAOD::BPhysHelper::pv_type>(vertex_type));  // Fix the cast
        if(refVtx == nullptr){
          ATH_MSG_WARNING("Could not retrieve Vertex type " << vertex_type <<  ", check vertex type setting. Comes from container " << m_vertexContainerName);
          continue;
        }
        xAOD::TrackIsolation result;
 
        if (!m_doIsoPerTrk) {
          m_trackIsoTool->trackIsolation(result, candidate_slyTrack, cones, corrlist, refVtx, &exclusionset,
                                         idTrackParticleContainer);
 
          // Decorate the vertex with all the isolation values
          for (unsigned int i = 0; i < cones.size(); i++) {
 
            string variableName = xAOD::Iso::toString(xAOD::Iso::IsolationType(cones[i]));
            variableName += vtxType_name[vertex_type];
 
            SG::Decorator<float> isolation(variableName);
            isolation(*vertex) = result.ptcones[i];
          }
        } else {
          for (size_t i = 0; i < vertex->nTrackParticles(); i++) {
            m_trackIsoTool->trackIsolation(result, *vertex->trackParticle(i), cones, corrlist, refVtx, &exclusionset,
                                           idTrackParticleContainer);
 
            for (unsigned int j = 0; j < cones.size(); j++) {
              string variableName = xAOD::Iso::toString(xAOD::Iso::IsolationType(cones[j]));
              variableName += vtxType_name[vertex_type];
              variableName += "_trk";
              variableName += std::to_string(i + 1);
              SG::Decorator<float> isolation(variableName);
              isolation(*vertex) = result.ptcones[j];
            }
          }
        }
      }
 
    }  // End of if passed
  }    // end of loop over vertices
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode DerivationFramework::VertexTrackIsolation::finalize

(

)

Definition at line 75 of file VertexTrackIsolation.cxx.

                                          {
  // everything all right
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::VertexTrackIsolation::initialize

(

)

Definition at line 52 of file VertexTrackIsolation.cxx.

                                            {
 
  ATH_MSG_DEBUG("in initialize()");
 
  CHECK(m_trackIsoTool.retrieve());
  // Check that flags were given to tag the correct vertices
 
  // Control the IsolationType sequence
  if (m_cones.empty()) {
    ATH_MSG_INFO("Setting ptcones to default");
 
    if (m_doIsoPerTrk)
      m_cones.push_back(xAOD::Iso::ptcone50);
    m_cones.push_back(xAOD::Iso::ptcone40);
    m_cones.push_back(xAOD::Iso::ptcone30);
    m_cones.push_back(xAOD::Iso::ptcone20);
  }
 
  return StatusCode::SUCCESS;
}

isContainedIn()

bool DerivationFramework::VertexTrackIsolation::isContainedIn	(	const xAOD::Vertex *	theVtx,
		const std::vector< const xAOD::Vertex * > &	theColl ) const

Definition at line 113 of file VertexTrackIsolation.cxx.

                                                                                            {
  for (const auto vtxPtr : theColl) {
    if (isSame(vtxPtr, theVtx))
      return true;
  }
  return false;
}

isSame()

bool DerivationFramework::VertexTrackIsolation::isSame	(	const xAOD::Vertex *	theVtx1,
		const xAOD::Vertex *	theVtx2 ) const

Definition at line 81 of file VertexTrackIsolation.cxx.

                                                                                            {
  assert(theVtx1);
  assert(theVtx2);
  if (theVtx1 == theVtx2)
    return true;
  if (theVtx1->nTrackParticles() != theVtx2->nTrackParticles())
    return false;
 
  if (m_removeDuplicate == 2 && theVtx1->nTrackParticles() == 4) {  // a special case with sub-structure
    bool firstTwoAreSame =
        std::set<const xAOD::TrackParticle*>({theVtx1->trackParticle(0), theVtx1->trackParticle(1)}) ==
        std::set<const xAOD::TrackParticle*>(
            {theVtx2->trackParticle(0), theVtx2->trackParticle(1)});  // the 1st pair of tracks
    bool lastTwoAreSame =
        std::set<const xAOD::TrackParticle*>({theVtx1->trackParticle(2), theVtx1->trackParticle(3)}) ==
        std::set<const xAOD::TrackParticle*>(
            {theVtx2->trackParticle(2), theVtx2->trackParticle(3)});  // the 2nd pair of tracks
    if (firstTwoAreSame && lastTwoAreSame)
      return true;
    else
      return false;
  } else {  // the general case
    std::set<const xAOD::TrackParticle*> vtxset1;
    std::set<const xAOD::TrackParticle*> vtxset2;
    for (size_t i = 0; i < theVtx1->nTrackParticles(); i++)
      vtxset1.insert(theVtx1->trackParticle(i));
    for (size_t i = 0; i < theVtx2->nTrackParticles(); i++)
      vtxset2.insert(theVtx2->trackParticle(i));
    return vtxset1 == vtxset2;
  }
}

Member Data Documentation

m_cones

std::vector<unsigned int> DerivationFramework::VertexTrackIsolation::m_cones

private

Definition at line 42 of file VertexTrackIsolation.h.

m_doIsoPerTrk

bool DerivationFramework::VertexTrackIsolation::m_doIsoPerTrk

private

Definition at line 46 of file VertexTrackIsolation.h.

m_fixElecExclusion

bool DerivationFramework::VertexTrackIsolation::m_fixElecExclusion

private

Definition at line 49 of file VertexTrackIsolation.h.

m_includeV0

bool DerivationFramework::VertexTrackIsolation::m_includeV0

private

Definition at line 50 of file VertexTrackIsolation.h.

m_passFlags

std::vector<std::string> DerivationFramework::VertexTrackIsolation::m_passFlags

private

Definition at line 43 of file VertexTrackIsolation.h.

m_removeDuplicate

int DerivationFramework::VertexTrackIsolation::m_removeDuplicate

private

Definition at line 47 of file VertexTrackIsolation.h.

m_trackContainerName

std::string DerivationFramework::VertexTrackIsolation::m_trackContainerName

private

Definition at line 40 of file VertexTrackIsolation.h.

m_trackIsoTool

ToolHandle<xAOD::ITrackIsolationTool> DerivationFramework::VertexTrackIsolation::m_trackIsoTool

private

Definition at line 38 of file VertexTrackIsolation.h.

m_vertexContainerName

std::string DerivationFramework::VertexTrackIsolation::m_vertexContainerName

private

Definition at line 41 of file VertexTrackIsolation.h.

m_vertexType

int DerivationFramework::VertexTrackIsolation::m_vertexType

private

Definition at line 44 of file VertexTrackIsolation.h.

---

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

• VertexTrackIsolation.h
• VertexTrackIsolation.cxx