DerivationFramework::DStarSelectionTool Class Reference

#include <DStarSelectionTool.h>

Inheritance diagram for DerivationFramework::DStarSelectionTool:

Collaboration diagram for DerivationFramework::DStarSelectionTool:

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

Private Attributes
SG::ReadHandleKey< xAOD::VertexContainer >	m_inputVtxContainerName {this, "InputVtxContainerName", ""}
Gaudi::Property< double >	m_deltaMassMax {this,"DeltaMassMax" ,200.,"invariant mass difference range"}
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trackKey {this, "TrackContainer", "InDetTrackParticles"}
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_trackDecoKey { this, "PassTrackDstarKey", m_trackKey, "trackPassDstar"}
SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_vertexDecoKey { this, "PassVertexDstarKey", m_inputVtxContainerName, "passed_Dstar"}
const double	m_pionMass = ParticleConstants::chargedPionMassInMeV
const double	m_kaonMass = ParticleConstants::chargedKaonMassInMeV
std::string	m_hypoName
	name of the mass hypothesis prefix for decorations More...

Detailed Description

Definition at line 33 of file DStarSelectionTool.h.

Member Function Documentation

addBranches()

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

overridevirtual

Definition at line 39 of file DStarSelectionTool.cxx.

                                                                        {
  
  // Track container
  const xAOD::TrackParticleContainer* trackParticleContainer{nullptr};
  ATH_CHECK(SG::get(trackParticleContainer, m_trackKey, ctx));    
  
  // Vertex container
  const xAOD::VertexContainer* D0Container{nullptr};
  ATH_CHECK(SG::get(D0Container, m_inputVtxContainerName, ctx));
  
  // Mask for track / vertex skimming
  std::vector<char> track_pass_map(trackParticleContainer->size());
  std::vector<char> vertex_pass_map(D0Container->size());
  
  // Loop over D0 candidate vertices
  for(const xAOD::Vertex* vertex: *D0Container) {
        
    // Check vertex passes loose D0 cuts defined in python 
    
    bool passed_D0_or_D0b = (flag_D0(*vertex) || flag_D0b(*vertex));
    
    // Only consider vertices which have passed D0 mass window for 
    // matching to soft pion canddiates
    if(!passed_D0_or_D0b) continue;
    
    const xAOD::TrackParticle* track1 = vertex->trackParticle(0);
    const xAOD::TrackParticle* track2 = vertex->trackParticle(1);
 
    if(!track1) { ATH_MSG_WARNING("Could not find track at D0 vertex (index 0)"); continue; }
    if(!track2) { ATH_MSG_WARNING("Could not find track at D0 vertex (index 1)"); continue; }
    
        // Re-fitted D0 track 4-vectors
    
    const std::vector<float>& reFit_Px = acc_reFit_Px(*vertex);
    const std::vector<float>& reFit_Py = acc_reFit_Py(*vertex);
    const std::vector<float>& reFit_Pz = acc_reFit_Pz(*vertex);
    
    TLorentzVector track1_pion, track1_kaon;
    track1_pion.SetXYZM(reFit_Px.at(0),reFit_Py.at(0),reFit_Pz.at(0),m_pionMass);
    track1_kaon.SetXYZM(reFit_Px.at(0),reFit_Py.at(0),reFit_Pz.at(0),m_kaonMass);
    
    TLorentzVector track2_pion, track2_kaon;
    track2_pion.SetXYZM(reFit_Px.at(1),reFit_Py.at(1),reFit_Pz.at(1),m_pionMass);
    track2_kaon.SetXYZM(reFit_Px.at(1),reFit_Py.at(1),reFit_Pz.at(1),m_kaonMass);
    
    // Consider both D0 and D0bar hypotheses (irrespective of charges)
    TLorentzVector D0_hypo1 = track1_pion + track2_kaon;
    TLorentzVector D0_hypo2 = track1_kaon + track2_pion;
    
    bool passed_Dstar = false;
    
    // Loop over tracks
    for(const xAOD::TrackParticle* track3: *trackParticleContainer) {
      
      // Avoid duplicates
      if( track1->index() == track3->index() ) continue;
      if( track2->index() == track3->index() ) continue;
      
      TLorentzVector track3_pion= track3->p4();
        
            const double deltaM_hypo1 = (D0_hypo1 + track3_pion).M() - D0_hypo1.M();
            const double deltaM_hypo2 = (D0_hypo2 + track3_pion).M() - D0_hypo2.M();
 
            // Selection of loose D*+ ->pi+ + D0 candidates based on mass difference
            // Keep both "right" and "wrong" charge combinations
            if( deltaM_hypo1 < m_deltaMassMax || deltaM_hypo2 < m_deltaMassMax ) {
 
                passed_Dstar = true;
 
                // Mark all tracks as being part of a D*+ -> D0 + pi+ (+c.c.) candidate
                track_pass_map[track1->index()] = true;
                track_pass_map[track2->index()] = true;
                track_pass_map[track3->index()] = true;
 
            }
 
        } // Loop over tracks
 
        // Adjust mask if we'd like to retain this vertex
        if(passed_Dstar) {
            vertex_pass_map[vertex->index()] = true;
        }
 
  } // Loop over D0 candidate vertices
  
  // Decorate tracks with skim decision flag
  
  SG::WriteDecorHandle<xAOD::TrackParticleContainer, int> flagTrackPass(m_trackDecoKey,ctx);
  // Loop over tracks
  for(const xAOD::TrackParticle* track:*trackParticleContainer) {
    
    flagTrackPass(*track)  = track_pass_map[track->index()] ; // Mark track to keep/drop during skimming 
    
  } // Loop over tracks
 
  // Decorate vertex for skimming decision (Char used for compatability for BPhys skim/slim tools)
  SG::WriteDecorHandle<xAOD::VertexContainer, Char_t> flagVertexPass(m_vertexDecoKey,ctx);
  
  // Loop over D0 candidate vertices
  for(const xAOD::Vertex* vertex: *D0Container) {
    
    // Mark vertex to keep during skimming, based on earlier decision
    flagVertexPass(*vertex) = vertex_pass_map[vertex->index()];
    
  } // Loop over D0 candidate vertices
  
  return StatusCode::SUCCESS;
}  

initialize()

StatusCode DerivationFramework::DStarSelectionTool::initialize ( )

override

Definition at line 29 of file DStarSelectionTool.cxx.

                                          {
    ATH_MSG_DEBUG("in initialize()");
    ATH_CHECK(m_trackKey.initialize());
    ATH_CHECK(m_inputVtxContainerName.initialize());    
    ATH_CHECK(m_trackDecoKey.initialize());
    ATH_CHECK(m_vertexDecoKey.initialize());    
    return StatusCode::SUCCESS;
    
}

Member Data Documentation

m_deltaMassMax

Gaudi::Property<double> DerivationFramework::DStarSelectionTool::m_deltaMassMax {this,"DeltaMassMax" ,200.,"invariant mass difference range"}

private

Definition at line 44 of file DStarSelectionTool.h.

m_hypoName

std::string DerivationFramework::DStarSelectionTool::m_hypoName

private

name of the mass hypothesis prefix for decorations

Definition at line 51 of file DStarSelectionTool.h.

m_inputVtxContainerName

SG::ReadHandleKey<xAOD::VertexContainer> DerivationFramework::DStarSelectionTool::m_inputVtxContainerName {this, "InputVtxContainerName", ""}

private

Definition at line 43 of file DStarSelectionTool.h.

m_kaonMass

const double DerivationFramework::DStarSelectionTool::m_kaonMass = ParticleConstants::chargedKaonMassInMeV

private

Definition at line 50 of file DStarSelectionTool.h.

m_pionMass

const double DerivationFramework::DStarSelectionTool::m_pionMass = ParticleConstants::chargedPionMassInMeV

private

Definition at line 49 of file DStarSelectionTool.h.

m_trackDecoKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> DerivationFramework::DStarSelectionTool::m_trackDecoKey { this, "PassTrackDstarKey", m_trackKey, "trackPassDstar"}

private

Definition at line 46 of file DStarSelectionTool.h.

m_trackKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::DStarSelectionTool::m_trackKey {this, "TrackContainer", "InDetTrackParticles"}

private

Definition at line 45 of file DStarSelectionTool.h.

m_vertexDecoKey

SG::WriteDecorHandleKey<xAOD::VertexContainer> DerivationFramework::DStarSelectionTool::m_vertexDecoKey { this, "PassVertexDstarKey", m_inputVtxContainerName, "passed_Dstar"}

private

Definition at line 47 of file DStarSelectionTool.h.

---

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

• DStarSelectionTool.h
• DStarSelectionTool.cxx