DerivationFramework::ZeeVertexRefittingTool Class Reference

#include <ZeeVertexRefittingTool.h>

Inheritance diagram for DerivationFramework::ZeeVertexRefittingTool:

Collaboration diagram for DerivationFramework::ZeeVertexRefittingTool:

Public Member Functions
virtual StatusCode	initialize () override final
virtual StatusCode	finalize () override final
virtual StatusCode	addBranches (const EventContext &ctx) const override final

Private Member Functions
StatusCode	makeZeePairs (const xAOD::ElectronContainer *particles, std::vector< std::vector< unsigned int > > &ZeePairs) const

Private Attributes
Gaudi::Property< std::string >	m_expression {this, "ObjectRequirements", "true"}
Gaudi::Property< float >	m_massCut {this, "LowMassCut", 0.f}
SG::ReadHandleKey< xAOD::VertexContainer >	m_primaryVertexKey {this, "PVContainerName", "PrimaryVertices", "" }
SG::ReadHandleKey< xAOD::ElectronContainer >	m_electronKey { this, "ElectronContainerName", "Electrons", "" }
SG::WriteHandleKey< xAOD::VertexContainer >	m_refitpvKey {this, "RefittedPVContainerName", "HggPrimaryVertices", "" }
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }
Gaudi::Property< std::vector< unsigned int > >	m_MCSamples {this, "MCSamples", {} }
ToolHandle< Analysis::PrimaryVertexRefitter >	m_pvrefitter {this, "PrimaryVertexRefitterTool", "Analysis::PrimaryVertexRefitter"}

Detailed Description

Definition at line 36 of file ZeeVertexRefittingTool.h.

Member Function Documentation

addBranches()

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

finaloverridevirtual

Definition at line 59 of file ZeeVertexRefittingTool.cxx.

  {
    // skip mc samples not included in the MCSamples list
    SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey, ctx);
 
    if(eventInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
      bool skipSample = true;
      for (auto mcid : m_MCSamples) {
        if (mcid==eventInfo->mcChannelNumber()) {
          skipSample = false;
          break;
        }
      }
      if (skipSample) return StatusCode::SUCCESS;
    }
 
    // check that container we want to write in SG does not yet exist
    if (evtStore()->contains<xAOD::VertexContainer>(m_refitpvKey.key())) {
      ATH_MSG_ERROR("Tool is attempting to write a StoreGate key " << m_refitpvKey.key() << " which already exists. Please use a different key");
      return StatusCode::FAILURE;
    }
 
 
    SG::ReadHandle<xAOD::VertexContainer> pv_cont (m_primaryVertexKey, ctx);
 
    xAOD::VertexContainer* refittedPVContainer = new xAOD::VertexContainer;
    xAOD::VertexAuxContainer* refittedPVAuxContainer = new xAOD::VertexAuxContainer;
    refittedPVContainer->setStore( refittedPVAuxContainer );
 
    SG::WriteHandle<xAOD::VertexContainer> vertexContainer(m_refitpvKey, ctx);
    ATH_CHECK(vertexContainer.recordNonConst(std::unique_ptr< xAOD::VertexContainer >(refittedPVContainer),
                                             std::unique_ptr< xAOD::VertexAuxContainer >(refittedPVAuxContainer)));
 
    const xAOD::Vertex* pv = nullptr;
    for ( const auto *v : *pv_cont ) {
      if (v->vertexType()==xAOD::VxType::PriVtx) {
        pv = v;
        break;
      }
    }
    if (!pv) {
      return StatusCode::SUCCESS;
    }
    ATH_MSG_DEBUG("Found PV");
 
    // retrieve particle collections
    SG::ReadHandle<xAOD::ElectronContainer> electrons (m_electronKey, ctx);
 
    // create the vector which will hold the Zee pairs
    std::vector< std::vector<unsigned int> > eepairs;
    CHECK( makeZeePairs( &*electrons, eepairs ) );
 
    ATH_MSG_DEBUG("ee pairs found: " << eepairs.size());
 
    for (auto pair : eepairs) {
      std::vector<const xAOD::TrackParticle*> tps = {
        xAOD::EgammaHelpers::getOriginalTrackParticle( electrons->at(pair[0]) ),
        xAOD::EgammaHelpers::getOriginalTrackParticle( electrons->at(pair[1]) )
      };
 
      TLorentzVector v0, v1, egamVec;
      if(electrons->at(pair[0])->caloCluster())
        {
          v0.SetPtEtaPhiM(electrons->at(pair[0])->e()/cosh(electrons->at(pair[0])->caloCluster()->etaBE(2)),
                          electrons->at(pair[0])->caloCluster()->etaBE(2),
                          electrons->at(pair[0])->caloCluster()->phiBE(2),
                          0.0);
        }
 
      if(electrons->at(pair[1])->caloCluster())
        {
          v1.SetPtEtaPhiM(electrons->at(pair[1])->e()/cosh(electrons->at(pair[1])->caloCluster()->etaBE(2)),
                          electrons->at(pair[1])->caloCluster()->etaBE(2),
                          electrons->at(pair[1])->caloCluster()->phiBE(2),
                          0.0);
        }
 
      egamVec = v0+v1;
 
      ATH_MSG_DEBUG("Refitting PV for e tracks: " << tps[0] << " " << tps[1]);
      xAOD::Vertex* pv_ref = m_pvrefitter->refitVertex(pv,tps);
      if (pv_ref) {
        refittedPVContainer->push_back(pv_ref);
 
        int ipv = 0;
        for (const xAOD::Vertex* v : *pv_cont) {
          xAOD::Vertex * nv = new xAOD::Vertex();
          nv->makePrivateStore(v);
          if(ipv !=0 ) refittedPVContainer->push_back(nv);
          ipv++;
        }
 
        for ( xAOD::Vertex *v : *refittedPVContainer )
          {
            float vert_sumpt = (log10(xAOD::PVHelpers::getVertexSumPt(v)));
            float vert_sumpt2 = (log10(xAOD::PVHelpers::getVertexSumPt(v,2, false)));
 
            TLorentzVector vtxmom = xAOD::PVHelpers::getVertexMomentum(v, true, "");
            float vert_dphi = (fabs(vtxmom.DeltaPhi(egamVec)));
            //fill vertex variables
            vertices_sumPt(*v) = vert_sumpt;
            vertices_sumPt2(*v) = vert_sumpt2;
            vertices_dPhi(*v) = vert_dphi;
          }
 
 
        ATH_MSG_DEBUG("refitted PV nTP: " << pv_ref->nTrackParticles() << " -- " << pv->nTrackParticles());
        ATH_MSG_DEBUG("refitted PV z: " << pv_ref->z() << " -- " << pv->z());
 
        if (pv_ref->nTrackParticles() < pv->nTrackParticles()) {
          sumPt2(*pv_ref) = xAOD::PVHelpers::getVertexSumPt(pv_ref, 2, false);
          //set links to electrons, used only for matching, not for vertexing
          std::vector<ElementLink<xAOD::TrackParticleContainer> > electronTrackLinks = {
            electrons->at(pair[0])->trackParticleLink(),
            electrons->at(pair[1])->trackParticleLink()
          };
          electronTrackLinksDecor(*pv_ref) = electronTrackLinks;
        } else {
          ATH_MSG_DEBUG("Electrons from pair not used in the refitting ");
        }
      }
      else {
        ATH_MSG_DEBUG("refitting failed");
      }
    }
 
    ATH_MSG_DEBUG("Vertex container size: " << refittedPVContainer->size());
 
    return StatusCode::SUCCESS;
  }

finalize()

StatusCode DerivationFramework::ZeeVertexRefittingTool::finalize ( )

finaloverridevirtual

Definition at line 53 of file ZeeVertexRefittingTool.cxx.

  {
    ATH_CHECK( finalizeParser() );
    return StatusCode::SUCCESS;
  }

initialize()

StatusCode DerivationFramework::ZeeVertexRefittingTool::initialize ( )

finaloverridevirtual

Definition at line 31 of file ZeeVertexRefittingTool.cxx.

  {
 
    ATH_CHECK( m_pvrefitter.retrieve() );
 
    if (!m_expression.empty()) {
      ATH_CHECK(initializeParser(m_expression));
    } else {
      ATH_CHECK(initializeParser("true"));
    }
    ATH_CHECK( m_eventInfoKey.initialize() );
    ATH_CHECK( m_primaryVertexKey.initialize() );
    ATH_CHECK( m_electronKey.initialize() );
    ATH_CHECK( m_refitpvKey.initialize() );
    if (m_refitpvKey.key().empty()) {
      ATH_MSG_ERROR("No SG name provided for the output of ZeeVertexRefittingTool!");
      return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
  }

makeZeePairs()

StatusCode DerivationFramework::ZeeVertexRefittingTool::makeZeePairs ( const xAOD::ElectronContainer * particles, std::vector< std::vector< unsigned int > > & ZeePairs ) const

private

Definition at line 190 of file ZeeVertexRefittingTool.cxx.

  {
    if (particles->size()<2) return StatusCode::SUCCESS;
 
    // flags for the result of selection for each electron
    std::vector<int> isSelected = m_parser->evaluateAsVector();
    unsigned int nEntries = isSelected.size();
 
    // if there are no particles in one of the two lists to combine, just leave function
    if (nEntries==0) return StatusCode::SUCCESS;
 
    // check the sizes are compatible
    if (particles->size() != nEntries ) {
      ATH_MSG_ERROR("Branch sizes incompatible - returning zero");
      return StatusCode::FAILURE;
    }
 
    // Double loop to get the opposite-charge pairs with m>50 GeV
    for (unsigned int i=0; i<nEntries-1; ++i) {
      if (isSelected[i]!=1) continue;
      float qi = particles->at(i)->charge();
 
      for (unsigned int j=i+1; j<nEntries; ++j) {
        if (isSelected[j]!=1) continue;
        //std::vector<int> tmpPair; tmpPair.clear();
        float qj = particles->at(j)->charge();
        // opposite charge
        if (qi*qj>=0) continue;
 
        //invariant mass
        float mass = (particles->at(i)->p4()+particles->at(j)->p4()).M();
        if (mass<m_massCut) continue;
 
        ZeePairs.push_back( {i, j} );
      }
    }
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_electronKey

SG::ReadHandleKey<xAOD::ElectronContainer> DerivationFramework::ZeeVertexRefittingTool::m_electronKey { this, "ElectronContainerName", "Electrons", "" }

private

Definition at line 50 of file ZeeVertexRefittingTool.h.

{ this, "ElectronContainerName", "Electrons", "" };

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> DerivationFramework::ZeeVertexRefittingTool::m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }

private

Definition at line 52 of file ZeeVertexRefittingTool.h.

{ this, "EventInfoKey", "EventInfo", "" };

m_expression

Gaudi::Property<std::string> DerivationFramework::ZeeVertexRefittingTool::m_expression {this, "ObjectRequirements", "true"}

private

Definition at line 46 of file ZeeVertexRefittingTool.h.

{this, "ObjectRequirements",  "true"};

m_massCut

Gaudi::Property<float> DerivationFramework::ZeeVertexRefittingTool::m_massCut {this, "LowMassCut", 0.f}

private

Definition at line 47 of file ZeeVertexRefittingTool.h.

{this, "LowMassCut", 0.f};

m_MCSamples

Gaudi::Property<std::vector<unsigned int> > DerivationFramework::ZeeVertexRefittingTool::m_MCSamples {this, "MCSamples", {} }

private

Definition at line 54 of file ZeeVertexRefittingTool.h.

{this, "MCSamples", {} };

m_primaryVertexKey

SG::ReadHandleKey<xAOD::VertexContainer> DerivationFramework::ZeeVertexRefittingTool::m_primaryVertexKey {this, "PVContainerName", "PrimaryVertices", "" }

private

Definition at line 49 of file ZeeVertexRefittingTool.h.

{this, "PVContainerName", "PrimaryVertices", "" };

m_pvrefitter

ToolHandle< Analysis::PrimaryVertexRefitter > DerivationFramework::ZeeVertexRefittingTool::m_pvrefitter {this, "PrimaryVertexRefitterTool", "Analysis::PrimaryVertexRefitter"}

private

Definition at line 56 of file ZeeVertexRefittingTool.h.

{this, "PrimaryVertexRefitterTool", "Analysis::PrimaryVertexRefitter"};

m_refitpvKey

SG::WriteHandleKey<xAOD::VertexContainer> DerivationFramework::ZeeVertexRefittingTool::m_refitpvKey {this, "RefittedPVContainerName", "HggPrimaryVertices", "" }

private

Definition at line 51 of file ZeeVertexRefittingTool.h.

{this, "RefittedPVContainerName", "HggPrimaryVertices", "" };

---

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

• ZeeVertexRefittingTool.h
• ZeeVertexRefittingTool.cxx