DerivationFramework::ZeeVertexRefittingTool Class Reference

#include <ZeeVertexRefittingTool.h>

Inheritance diagram for DerivationFramework::ZeeVertexRefittingTool:

Collaboration diagram for DerivationFramework::ZeeVertexRefittingTool:

Public Member Functions
	ZeeVertexRefittingTool (const std::string &t, const std::string &n, const IInterface *p)
StatusCode	initialize () override
StatusCode	finalize () override
StatusCode	addBranches () const override

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

Private Attributes
std::string	m_expression
float	m_massCut
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", "" }
std::vector< unsigned int >	m_MCSamples
ToolHandle< Analysis::PrimaryVertexRefitter >	m_pvrefitter {this, "PrimaryVertexRefitterTool", "Analysis::PrimaryVertexRefitter"}

Detailed Description

Definition at line 36 of file ZeeVertexRefittingTool.h.

Constructor & Destructor Documentation

ZeeVertexRefittingTool()

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

Definition at line 31 of file ZeeVertexRefittingTool.cxx.

                                            : 
    base_class(t, n, p),
    m_expression("true"),
    m_massCut(0.0)
  {
    declareProperty("ObjectRequirements", m_expression);  
    declareProperty("LowMassCut", m_massCut);
    declareProperty("MCSamples",m_MCSamples);
  }

Member Function Documentation

addBranches()

StatusCode DerivationFramework::ZeeVertexRefittingTool::addBranches ( ) const

override

Definition at line 71 of file ZeeVertexRefittingTool.cxx.

  {
    // skip mc samples not included in the MCSamples list
    SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey);
 
    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);
 
    xAOD::VertexContainer* refittedPVContainer = new xAOD::VertexContainer;
    xAOD::VertexAuxContainer* refittedPVAuxContainer = new xAOD::VertexAuxContainer;
    refittedPVContainer->setStore( refittedPVAuxContainer );
  
    SG::WriteHandle<xAOD::VertexContainer> vertexContainer(m_refitpvKey);
    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);
 
    // 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 ( )

override

Definition at line 65 of file ZeeVertexRefittingTool.cxx.

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

initialize()

StatusCode DerivationFramework::ZeeVertexRefittingTool::initialize ( )

override

Definition at line 43 of file ZeeVertexRefittingTool.cxx.

  {
 
    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 202 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 49 of file ZeeVertexRefittingTool.h.

m_eventInfoKey

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

private

Definition at line 51 of file ZeeVertexRefittingTool.h.

m_expression

std::string DerivationFramework::ZeeVertexRefittingTool::m_expression

private

Definition at line 45 of file ZeeVertexRefittingTool.h.

m_massCut

float DerivationFramework::ZeeVertexRefittingTool::m_massCut

private

Definition at line 46 of file ZeeVertexRefittingTool.h.

m_MCSamples

std::vector<unsigned int> DerivationFramework::ZeeVertexRefittingTool::m_MCSamples

private

Definition at line 53 of file ZeeVertexRefittingTool.h.

m_primaryVertexKey

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

private

Definition at line 48 of file ZeeVertexRefittingTool.h.

m_pvrefitter

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

private

Definition at line 55 of file ZeeVertexRefittingTool.h.

m_refitpvKey

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

private

Definition at line 50 of file ZeeVertexRefittingTool.h.

---

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

• ZeeVertexRefittingTool.h
• ZeeVertexRefittingTool.cxx