From a20c37ccbc932b1723aac23d446d04d0db228211 Mon Sep 17 00:00:00 2001
From: Justin Griffiths <justin.adam.griffiths@cern.ch>
Date: Wed, 25 May 2016 15:53:07 +0200
Subject: [PATCH] fix ATLASRECTS-3184 (tauRecTools-00-01-03)
* tagging 00-01-03
* fix ATLASRECTS-3184
2016 23-05-2016: griffith@cern.ch
* about branches
* 00-00-12 : 20.7/ ABR
* 00-00-13 : r21 pre TauJet_v3
* 00-00-14 : MIG5 (Rec::Vertex removal)
2016 23-05-2016: griffith@cern.ch
* tagging 00-01-02
* fix MvaTES for cosmics running
2016 14-05-2016: griffith@cern.ch
* Updating to new EDM
* not suitable for r<=20.7
* branch off of tauRecTools-00-00-11 for r20.7 and older fixes
Former-commit-id: fd1f4dcc3f829b3069eeb871cb4218c6e3966549
---
Reconstruction/tauRecTools/CMakeLists.txt | 2 +-
.../Root/CombinedP4FromRecoTaus.cxx | 12 +-
Reconstruction/tauRecTools/Root/LinkDef.h | 4 +-
.../tauRecTools/Root/MvaTESEvaluator.cxx | 34 ++-
.../Root/MvaTESVariableDecorator.cxx | 47 ++-
.../tauRecTools/Root/TauBuilderTool.cxx | 36 ++-
.../tauRecTools/Root/TauCalibrateLC.cxx | 12 +-
.../tauRecTools/Root/TauCommonCalcVars.cxx | 74 ++---
.../tauRecTools/Root/TauProcessorTool.cxx | 9 +
.../Root/TauSubstructureVariables.cxx | 4 +-
.../tauRecTools/Root/TauTrackClassifier.cxx | 270 ++++++++++++++++++
.../tauRecTools/Root/TauTrackFilter.cxx | 121 ++++----
Reconstruction/tauRecTools/cmt/requirements | 2 +-
.../share/TF2pileupForOfflineID_1p.root | Bin 17230 -> 0 bytes
.../share/TF2pileupForOfflineID_3p.root | Bin 18865 -> 0 bytes
.../tauRecTools/src/JetSeedBuilder.cxx | 10 +-
.../src/PhotonConversionVertex.cxx | 12 +-
.../tauRecTools/src/TauAxisSetter.cxx | 8 +-
.../tauRecTools/src/TauCalibrateEM.cxx | 6 +-
.../tauRecTools/src/TauConversionFinder.cxx | 19 +-
.../tauRecTools/src/TauConversionTagger.cxx | 9 +-
.../src/TauElectronVetoVariables.cxx | 12 +-
.../tauRecTools/src/TauPi0ClusterScaler.cxx | 166 ++++++-----
.../tauRecTools/src/TauPi0ClusterScaler.h | 15 +-
.../tauRecTools/src/TauPi0CreateROI.cxx | 2 +-
.../tauRecTools/src/TauPi0Selector.cxx | 14 +-
.../src/TauShotVariableHelpers.cxx | 8 +-
.../tauRecTools/src/TauTrackFinder.cxx | 143 ++++++----
.../tauRecTools/src/TauTrackFinder.h | 7 +
.../tauRecTools/src/TauVertexFinder.cxx | 265 +++++++++--------
.../tauRecTools/src/TauVertexFinder.h | 70 ++---
.../tauRecTools/src/TauVertexVariables.cxx | 8 +-
.../src/components/tauRecTools_entries.cxx | 3 +
.../tauRecTools/tauRecTools/ITauToolBase.h | 4 +-
.../tauRecTools/MvaTESVariableDecorator.h | 2 +
.../tauRecTools/tauRecTools/TauBuilderTool.h | 2 +
.../tauRecTools/tauRecTools/TauCalibrateLC.h | 3 +-
.../tauRecTools/TauProcessorTool.h | 1 +
.../tauRecTools/TauTrackClassifier.h | 159 +++++++++++
.../tauRecTools/tauRecTools/TauTrackFilter.h | 1 +
40 files changed, 1056 insertions(+), 520 deletions(-)
create mode 100644 Reconstruction/tauRecTools/Root/TauTrackClassifier.cxx
delete mode 100644 Reconstruction/tauRecTools/share/TF2pileupForOfflineID_1p.root
delete mode 100644 Reconstruction/tauRecTools/share/TF2pileupForOfflineID_3p.root
create mode 100644 Reconstruction/tauRecTools/tauRecTools/TauTrackClassifier.h
diff --git a/Reconstruction/tauRecTools/CMakeLists.txt b/Reconstruction/tauRecTools/CMakeLists.txt
index cba8060dbeb0..8d2bbe9c02de 100644
--- a/Reconstruction/tauRecTools/CMakeLists.txt
+++ b/Reconstruction/tauRecTools/CMakeLists.txt
@@ -24,7 +24,7 @@ atlas_depends_on_subdirs( PUBLIC
Event/xAOD/xAODPFlow
GaudiKernel
InnerDetector/InDetRecTools/InDetRecToolInterfaces
- PhysicsAnalysis/TauID/TauAnalysisTools
+ InnerDetector/InDetRecTools/InDetTrackSelectionTool
Reconstruction/Jet/JetEDM
Reconstruction/Particle
Reconstruction/RecoTools/ITrackToVertex
diff --git a/Reconstruction/tauRecTools/Root/CombinedP4FromRecoTaus.cxx b/Reconstruction/tauRecTools/Root/CombinedP4FromRecoTaus.cxx
index 28cfabd82a5a..2c4fb4cac4e7 100644
--- a/Reconstruction/tauRecTools/Root/CombinedP4FromRecoTaus.cxx
+++ b/Reconstruction/tauRecTools/Root/CombinedP4FromRecoTaus.cxx
@@ -5,7 +5,7 @@
// Framework include(s)
#include "PathResolver/PathResolver.h"
-#include "TauAnalysisTools/HelperFunctions.h"
+//#include "TauAnalysisTools/HelperFunctions.h"
// local include(s)
#include "tauRecTools/CombinedP4FromRecoTaus.h"
@@ -139,7 +139,7 @@ StatusCode CombinedP4FromRecoTaus::initialize() {
StatusCode CombinedP4FromRecoTaus::execute(xAOD::TauJet& xTau) {
xAOD::TauJet* Tau = &xTau;
int tmpDecayModeProto;
- xTau.panTauDetail(xAOD::TauJetParameters::PanTauDetails::pantau_CellBasedInput_DecayModeProto, tmpDecayModeProto);
+ xTau.panTauDetail(xAOD::TauJetParameters::PanTauDetails::PanTau_DecayModeProto, tmpDecayModeProto);
if(tmpDecayModeProto>xAOD::TauJetParameters::Mode_3pXn){
xTau.auxdecor<float>("pt_combined") = 1.;
return StatusCode::SUCCESS;
@@ -554,7 +554,7 @@ TLorentzVector CombinedP4FromRecoTaus::getCombinedP4(const xAOD::TauJet* tau) {
ATH_MSG_DEBUG( "TauRecET: " << tauRecP4.Et() );
xAOD::TauJetParameters::DecayMode decayMode = xAOD::TauJetParameters::DecayMode::Mode_Error;
int tmpDecayMode;
- if (tau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::pantau_CellBasedInput_DecayMode, tmpDecayMode)) {
+ if (tau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::PanTau_DecayMode, tmpDecayMode)) {
decayMode = static_cast< xAOD::TauJetParameters::DecayMode>(tmpDecayMode);
}
ATH_MSG_DEBUG( "Decaymode is: " << decayMode );
@@ -598,7 +598,7 @@ TLorentzVector CombinedP4FromRecoTaus::getCalibratedConstituentP4(const xAOD::Ta
xAOD::TauJetParameters::DecayMode decayMode = xAOD::TauJetParameters::DecayMode::Mode_Error;
int tmpDecayMode;
- if (tau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::pantau_CellBasedInput_DecayMode, tmpDecayMode)) {
+ if (tau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::PanTau_DecayMode, tmpDecayMode)) {
decayMode = static_cast< xAOD::TauJetParameters::DecayMode>(tmpDecayMode);
}
ATH_MSG_DEBUG( "Decaymode is: " << decayMode );
@@ -638,7 +638,7 @@ TLorentzVector CombinedP4FromRecoTaus::getCalibratedTauRecP4(const xAOD::TauJet*
ATH_MSG_DEBUG( "TauRecET: " << tauRecP4.Et() );
xAOD::TauJetParameters::DecayMode decayMode = xAOD::TauJetParameters::DecayMode::Mode_Error;
int tmpDecayMode;
- if (tau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::pantau_CellBasedInput_DecayMode, tmpDecayMode)) {
+ if (tau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::PanTau_DecayMode, tmpDecayMode)) {
decayMode = static_cast< xAOD::TauJetParameters::DecayMode>(tmpDecayMode);
}
ATH_MSG_DEBUG( "Decaymode is: " << decayMode );
@@ -679,7 +679,7 @@ TLorentzVector CombinedP4FromRecoTaus::getWeightedP4(const xAOD::TauJet* tau) {
ATH_MSG_DEBUG( "TauRecET: " << tauRecP4.Et() );
xAOD::TauJetParameters::DecayMode decayMode = xAOD::TauJetParameters::DecayMode::Mode_Error;
int tmpDecayMode;
- if (tau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::pantau_CellBasedInput_DecayMode, tmpDecayMode)) {
+ if (tau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::PanTau_DecayMode, tmpDecayMode)) {
decayMode = static_cast< xAOD::TauJetParameters::DecayMode>(tmpDecayMode);
}
ATH_MSG_DEBUG( "Decaymode is: " << decayMode );
diff --git a/Reconstruction/tauRecTools/Root/LinkDef.h b/Reconstruction/tauRecTools/Root/LinkDef.h
index c13ca4fb2dbc..6f73af0eb338 100644
--- a/Reconstruction/tauRecTools/Root/LinkDef.h
+++ b/Reconstruction/tauRecTools/Root/LinkDef.h
@@ -12,6 +12,7 @@
#include "tauRecTools/ITauToolBase.h"
#include "tauRecTools/MvaTESVariableDecorator.h"
#include "tauRecTools/MvaTESEvaluator.h"
+#include "tauRecTools/TauTrackClassifier.h"
#include "tauRecTools/CombinedP4FromRecoTaus.h"
#ifdef __CINT__
@@ -23,7 +24,6 @@
#endif
-
#ifdef __CINT__
#pragma link C++ class TauCalibrateLC+;
@@ -37,6 +37,8 @@
#pragma link C++ class ITauToolBase+;
#pragma link C++ class MvaTESVariableDecorator+;
#pragma link C++ class MvaTESEvaluator+;
+#pragma link C++ class TauTrackClassifier+;
+#pragma link C++ class TrackMVABDT+;
#pragma link C++ class CombinedP4FromRecoTaus+;
#endif
diff --git a/Reconstruction/tauRecTools/Root/MvaTESEvaluator.cxx b/Reconstruction/tauRecTools/Root/MvaTESEvaluator.cxx
index 8c15a3bc1bca..3a92c1147312 100644
--- a/Reconstruction/tauRecTools/Root/MvaTESEvaluator.cxx
+++ b/Reconstruction/tauRecTools/Root/MvaTESEvaluator.cxx
@@ -7,7 +7,7 @@
// tools include(s)
-#include "TauAnalysisTools/HelperFunctions.h"
+//#include "TauAnalysisTools/HelperFunctions.h"
//_____________________________________________________________________________
MvaTESEvaluator::MvaTESEvaluator(const std::string& name)
@@ -75,36 +75,34 @@ StatusCode MvaTESEvaluator::execute(xAOD::TauJet& xTau){
nVtx = xTau.auxdata<int>("nVtx");
// Retrieve seed jet info
- center_lambda = xTau.auxdata<double>("center_lambda");
- first_eng_dens = xTau.auxdata<double>("first_eng_dens");
- em_probability = xTau.auxdata<double>("em_probability");
- second_lambda = xTau.auxdata<double>("second_lambda");
- presampler_frac = xTau.auxdata<double>("presampler_frac");
- nMuSeg = (float)xTau.auxdata<int>("GhostMuonSegmentCount");
-
+ xTau.detail(xAOD::TauJetParameters::ClustersMeanCenterLambda, center_lambda);
+ xTau.detail(xAOD::TauJetParameters::ClustersMeanFirstEngDens, first_eng_dens);
+ xTau.detail(xAOD::TauJetParameters::ClustersMeanEMProbability,em_probability);
+ xTau.detail(xAOD::TauJetParameters::ClustersMeanSecondLambda, second_lambda);
+ xTau.detail(xAOD::TauJetParameters::ClustersMeanPresamplerFrac, presampler_frac);
+ int nMuSeg_i=0;
+ xTau.detail(xAOD::TauJetParameters::GhostMuonSegmentCount, nMuSeg_i);
+ nMuSeg=nMuSeg_i;
+
// Retrieve pantau and LC-precalib TES
- seedCalo_eta = xTau.auxdata<float>("seedCalo_eta");
- float pT_LC = xTau.auxdata<float>("LC_TES_precalib");
+ seedCalo_eta = xTau.etaDetectorAxis();
+ float pT_LC = xTau.ptDetectorAxis();
float pT_pantau = xTau.ptPanTauCellBased();
- interpolPt = xTau.auxdata<double>("LC_pantau_interpolPt");
+ xTau.detail(xAOD::TauJetParameters::LC_pantau_interpolPt, interpolPt);
LC_D_interpolPt = pT_LC / interpolPt;
pantau_D_interpolPt = pT_pantau / interpolPt;
// Retrieve substructures info
nTracks = (float)xTau.nTracks();
- nPi0PFOs = (float)xTau.auxdata<int>("nPi0PFOs");
- PFOEngRelDiff = xTau.auxdata<double>("PFOEngRelDiff");
+ nPi0PFOs = (float) xTau.nPi0s();
+ xTau.detail(xAOD::TauJetParameters::PFOEngRelDiff, PFOEngRelDiff);
// "Retrieve" spectator variables
truthPtVis = 0.;
- // xTau.auxdecor<float>("ptMvaTES") = float( interpolPt * reader->EvaluateRegression( 0, "BDTG" ) );
float ptMVA = float( interpolPt * reader->EvaluateRegression( 0, "BDTG" ) );
if(ptMVA<1) ptMVA=1;
- xTau.auxdecor<float>("ptFinalCalib") = ptMVA;
- xTau.auxdecor<float>("etaFinalCalib") = xTau.auxdata<float>("etaPanTauCellBased");
- xTau.auxdecor<float>("phiFinalCalib") = xTau.auxdata<float>("phiPanTauCellBased");
- xTau.auxdecor<float>("mFinalCalib") = 0;
+ xTau.setP4(xAOD::TauJetParameters::FinalCalib, ptMVA, xTau.etaPanTauCellBased(), xTau.phiPanTauCellBased(), 0);
return StatusCode::SUCCESS;
diff --git a/Reconstruction/tauRecTools/Root/MvaTESVariableDecorator.cxx b/Reconstruction/tauRecTools/Root/MvaTESVariableDecorator.cxx
index bfaca23b3f9a..173bbb35c2b6 100644
--- a/Reconstruction/tauRecTools/Root/MvaTESVariableDecorator.cxx
+++ b/Reconstruction/tauRecTools/Root/MvaTESVariableDecorator.cxx
@@ -6,7 +6,7 @@
#include "tauRecTools/MvaTESVariableDecorator.h"
// tools include(s)
-#include "TauAnalysisTools/HelperFunctions.h"
+//#include "TauAnalysisTools/HelperFunctions.h"
//_____________________________________________________________________________
MvaTESVariableDecorator::MvaTESVariableDecorator(const std::string& name)
@@ -30,7 +30,7 @@ StatusCode MvaTESVariableDecorator::eventInitialize()
m_mu = m_xEventInfo->averageInteractionsPerCrossing();
if(evtStore()->contains<xAOD::VertexContainer>("PrimaryVertices")){
- ATH_CHECK(evtStore()->retrieve(m_xVertexContainer, "PrimaryVertices"));
+ ATH_CHECK(evtStore()->retrieve(m_xVertexContainer, "PrimaryVertices"));
m_nVtx = (int)m_xVertexContainer->size();
}
else {
@@ -45,6 +45,7 @@ StatusCode MvaTESVariableDecorator::eventInitialize()
StatusCode MvaTESVariableDecorator::execute(xAOD::TauJet& xTau) {
// Decorate event info
+
xTau.auxdata<double>("mu") = m_mu;
xTau.auxdata<int>("nVtx") = m_nVtx;
@@ -57,10 +58,10 @@ StatusCode MvaTESVariableDecorator::execute(xAOD::TauJet& xTau) {
double clE=0., Etot=0.;
TLorentzVector LC_P4;
- LC_P4.SetPtEtaPhiM(xTau.auxdata<float>("LC_TES_precalib"),
- xTau.auxdata<float>("seedCalo_eta"),
- xTau.auxdata<float>("seedCalo_phi"),
- xTau.m());
+ LC_P4.SetPtEtaPhiM(xTau.ptDetectorAxis(),
+ xTau.etaDetectorAxis(),
+ xTau.phiDetectorAxis(),
+ xTau.m());
// ----loop over jet seed constituents
xAOD::JetConstituentVector vec = jet_seed->getConstituents();
@@ -100,30 +101,27 @@ StatusCode MvaTESVariableDecorator::execute(xAOD::TauJet& xTau) {
}
// ----retrieve Ghost Muon Segment Count (for punch-through studies)
- const int nMuSeg = jet_seed->getAttribute<int>("GhostMuonSegmentCount");
+ int nMuSeg=0;
+ if(!jet_seed->getAttribute<int>("GhostMuonSegmentCount", nMuSeg)) nMuSeg=0;
// ----decorating jet seed information to tau
- xTau.auxdecor<double>("center_lambda") = mean_center_lambda;
- xTau.auxdecor<double>("first_eng_dens") = mean_first_eng_dens;
- xTau.auxdecor<double>("em_probability") = mean_em_probability;
- xTau.auxdecor<double>("second_lambda") = mean_second_lambda;
- xTau.auxdecor<double>("presampler_frac") = mean_presampler_frac;
- xTau.auxdecor<int>("GhostMuonSegmentCount") = nMuSeg;
+ xTau.setDetail(xAOD::TauJetParameters::ClustersMeanCenterLambda, (float) mean_center_lambda);
+ xTau.setDetail(xAOD::TauJetParameters::ClustersMeanFirstEngDens, (float) mean_first_eng_dens);
+ xTau.setDetail(xAOD::TauJetParameters::ClustersMeanEMProbability, (float) mean_em_probability);
+ xTau.setDetail(xAOD::TauJetParameters::ClustersMeanSecondLambda, (float) mean_second_lambda);
+ xTau.setDetail(xAOD::TauJetParameters::ClustersMeanPresamplerFrac, (float) mean_presampler_frac);
+ xTau.setDetail(xAOD::TauJetParameters::GhostMuonSegmentCount, nMuSeg);
// calculate PFO energy relative difference
// ----summing corrected Pi0 PFO energies
TLorentzVector Pi0_totalP4;
Pi0_totalP4.SetPtEtaPhiM(0,0,0,0);
- std::vector<TLorentzVector> Pi0PFOs;
- TauAnalysisTools::createPi0Vectors(&xTau,Pi0PFOs);
-
- for(size_t i=0; i<Pi0PFOs.size(); i++){
- Pi0_totalP4 += Pi0PFOs.at(i);
- };
+ //This should be available in EDM as of TauJet_v3
+ // TauAnalysisTools::createPi0Vectors(&xTau,Pi0PFOs);
+ for( size_t i=0; i != xTau.nPi0s(); ++i ) Pi0_totalP4+= xTau.pi0(i)->p4();
double Pi0_totalE = Pi0_totalP4.E();
- int nPi0PFOs = (int)Pi0PFOs.size();
// ----summing charged PFO energies
TLorentzVector charged_totalP4;
@@ -134,27 +132,24 @@ StatusCode MvaTESVariableDecorator::execute(xAOD::TauJet& xTau) {
};
double charged_totalE = charged_totalP4.E();
- int nChargedPFOs = (int)xTau.nChargedPFOs();
// ----calculate relative difference and decorate to tau
double relDiff=0.;
if(Pi0_totalE+charged_totalE){
relDiff = (charged_totalE - Pi0_totalE) / (charged_totalE + Pi0_totalE) ;
}
- xTau.auxdecor<int>("nPi0PFOs") = nPi0PFOs;
- xTau.auxdecor<int>("nChargedPFOs") = nChargedPFOs;
- xTau.auxdecor<double>("PFOEngRelDiff") = relDiff;
+ xTau.setDetail(xAOD::TauJetParameters::PFOEngRelDiff, (float) relDiff);
// calculate interpolated pT
double GeV = 1000.;
double pt_pantau = xTau.ptPanTauCellBased();
- double pt_LC = xTau.auxdata<float>("LC_TES_precalib");
+ double pt_LC = xTau.ptDetectorAxis();
double interpolWeight;
interpolWeight = 0.5 * ( 1. + TMath::TanH( ( pt_LC/GeV - 250. ) / 20. ) );
double LC_pantau_interpolPt = interpolWeight*pt_LC + (1.-interpolWeight)*pt_pantau;
- xTau.auxdecor<double>("LC_pantau_interpolPt") = LC_pantau_interpolPt;
+ xTau.setDetail(xAOD::TauJetParameters::LC_pantau_interpolPt, (float) LC_pantau_interpolPt);
return StatusCode::SUCCESS;
diff --git a/Reconstruction/tauRecTools/Root/TauBuilderTool.cxx b/Reconstruction/tauRecTools/Root/TauBuilderTool.cxx
index 239735e88a81..eb210a64ee6e 100644
--- a/Reconstruction/tauRecTools/Root/TauBuilderTool.cxx
+++ b/Reconstruction/tauRecTools/Root/TauBuilderTool.cxx
@@ -10,15 +10,18 @@
#include "xAODTau/TauJetContainer.h"
#include "xAODTau/TauJetAuxContainer.h"
#include "xAODTau/TauDefs.h"
+#include "xAODTau/TauTrackContainer.h"
+#include "xAODTau/TauTrackAuxContainer.h"
#include "tauRecTools/TauEventData.h"
-
//________________________________________
TauBuilderTool::TauBuilderTool(const std::string& type) :
asg::AsgTool(type),
m_tauContainerName("TauJets"),
m_tauAuxContainerName("TauJetsAux."),
+ m_tauTrackContainerName("TauTracks"),
+ m_tauTrackAuxContainerName("TauTracksAux."),
m_seedContainerName(""),
m_maxEta(2.5),
m_minPt(10000),
@@ -26,6 +29,8 @@ TauBuilderTool::TauBuilderTool(const std::string& type) :
{
declareProperty("TauContainer", m_tauContainerName);
declareProperty("TauAuxContainer", m_tauAuxContainerName);
+ declareProperty("TauTrackContainer", m_tauTrackContainerName);
+ declareProperty("TauTrackAuxContainer", m_tauTrackAuxContainerName);
declareProperty("SeedContainer", m_seedContainerName);
declareProperty("MaxEta", m_maxEta);
declareProperty("MinPt", m_minPt);
@@ -95,7 +100,8 @@ StatusCode TauBuilderTool::execute(){
xAOD::TauJetContainer * pContainer = 0;
xAOD::TauJetAuxContainer* pAuxContainer = 0;
-
+ xAOD::TauTrackContainer* pTracks = 0;
+ xAOD::TauTrackAuxContainer* pAuxTracks = 0;
if (m_doCreateTauContainers) {
@@ -123,6 +129,13 @@ StatusCode TauBuilderTool::execute(){
ATH_MSG_DEBUG( "Recorded xAOD tau jets with key: "
<< m_tauAuxContainerName );
+
+ pTracks = new xAOD::TauTrackContainer();
+ ATH_CHECK( evtStore()->record( pTracks, m_tauTrackContainerName) );
+ pAuxTracks = new xAOD::TauTrackAuxContainer();
+ ATH_CHECK( evtStore()->record( pAuxTracks, m_tauTrackAuxContainerName));
+ pTracks->setStore( pAuxTracks );
+
} else {
//-------------------------------------------------------------------------
// retrieve Tau Containers from StoreGate
@@ -192,7 +205,8 @@ StatusCode TauBuilderTool::execute(){
ATH_MSG_VERBOSE("Number of seeds in the container: " << pSeedContainer->size());
- for (; itS != itSE; ++itS) {
+ for (; itS != itSE; ++itS) {
+
const xAOD::Jet *pSeed = (*itS);
ATH_MSG_VERBOSE("Seeds eta:" << pSeed->eta() << ", pt:" << pSeed->pt());
@@ -261,11 +275,24 @@ StatusCode TauBuilderTool::execute(){
(*p_itT1)->cleanup(&m_data);
(*p_itT1)->cleanup(&m_data);
*/
+
+ //remove orphaned tracks before tau is deleted via pop_back
+ xAOD::TauJet* bad_tau = pContainer->back();
+ ATH_MSG_DEBUG("Deleting " << bad_tau->nAllTracks() << "Tracks associated with tau: ");
+ pTracks->erase(pTracks->end()-bad_tau->nAllTracks(), pTracks->end());
+
//m_data.xAODTauContainer->pop_back();
pContainer->pop_back();
- } else
+ } else{
+
+ //remove orphaned tracks before tau is deleted via pop_back
+ xAOD::TauJet* bad_tau = pContainer->back();
+ ATH_MSG_DEBUG("Deleting " << bad_tau->nAllTracks() << "Tracks associated with tau: ");
+ pTracks->erase(pTracks->end()-bad_tau->nAllTracks(), pTracks->end());
+
//m_data.xAODTauContainer->pop_back();
pContainer->pop_back();
+ }
}
@@ -282,6 +309,7 @@ StatusCode TauBuilderTool::execute(){
return StatusCode::FAILURE;
}
+
//keep this here for future use (in case more than one seeding algo exist)
/*
p_itET = m_endTools.begin();
diff --git a/Reconstruction/tauRecTools/Root/TauCalibrateLC.cxx b/Reconstruction/tauRecTools/Root/TauCalibrateLC.cxx
index e0dbb09b514e..adb81f2b6db0 100644
--- a/Reconstruction/tauRecTools/Root/TauCalibrateLC.cxx
+++ b/Reconstruction/tauRecTools/Root/TauCalibrateLC.cxx
@@ -43,12 +43,6 @@ m_clusterCone(0.2) //not used
declareProperty("isCaloOnly", m_isCaloOnly);
}
-TauCalibrateLC::TauCalibrateLC() :
- TauCalibrateLC("TauCalibrateLC")//c++11
-{
-}
-
-
/********************************************************************/
TauCalibrateLC::~TauCalibrateLC() {
}
@@ -73,7 +67,7 @@ StatusCode TauCalibrateLC::initialize() {
etaBinHist = dynamic_cast<TH1 *> (obj);
}
if (etaBinHist) {
- TH1 * tmp = const_cast<TH1*> (etaBinHist);
+ TH1 * tmp = dynamic_cast<TH1*> (obj);
tmp->SetDirectory(0);
} else {
ATH_MSG_FATAL("Failed to get an object with key " << key);
@@ -99,7 +93,7 @@ StatusCode TauCalibrateLC::initialize() {
etaCorrectionHist = dynamic_cast<TH1 *> (obj);
}
if (etaCorrectionHist) {
- TH1 * tmp = const_cast<TH1*> (etaCorrectionHist);
+ TH1 * tmp = dynamic_cast<TH1*> (obj);
tmp->SetDirectory(0);
} else {
ATH_MSG_FATAL("Failed to get an object with key " << key);
@@ -116,7 +110,7 @@ StatusCode TauCalibrateLC::initialize() {
slopeNPVHist[i] = dynamic_cast<TH1 *> (obj);
}
if (slopeNPVHist[i]) {
- TH1 * tmp = const_cast<TH1*> (slopeNPVHist[i]);
+ TH1 * tmp = dynamic_cast<TH1*> (obj);
tmp->SetDirectory(0);
} else {
ATH_MSG_FATAL("Failed to get an object with key " << tmpSlopKey[i]);
diff --git a/Reconstruction/tauRecTools/Root/TauCommonCalcVars.cxx b/Reconstruction/tauRecTools/Root/TauCommonCalcVars.cxx
index c5f3d986560b..a8617e7f773b 100644
--- a/Reconstruction/tauRecTools/Root/TauCommonCalcVars.cxx
+++ b/Reconstruction/tauRecTools/Root/TauCommonCalcVars.cxx
@@ -23,7 +23,7 @@
#include "tauRecTools/TauCommonCalcVars.h"
#include "tauRecTools/KineUtils.h"
-
+#include <vector>
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
@@ -106,54 +106,45 @@ StatusCode TauCommonCalcVars::execute(xAOD::TauJet& pTau) {
// }
// invariant mass of track system
- if ((pTau.nTracks() + pTau.nWideTracks()) > 0) {
+ std::vector<const xAOD::TauTrack*> tauTracks = pTau.tracks(xAOD::TauJetParameters::TauTrackFlag::classifiedCharged);
+ for( const xAOD::TauTrack* trk : pTau.tracks(xAOD::TauJetParameters::TauTrackFlag::classifiedIsolation) ) tauTracks.push_back(trk);
+ // if ((pTau.nTracks() + pTau.nWideTracks()) > 0) {
+ if (tauTracks.size()> 0) {
TLorentzVector sumOfTrackVector;
TLorentzVector tempTrackVector;
- for (unsigned int i = 0; i != pTau.nTracks(); ++i)
- {
- tempTrackVector.SetPtEtaPhiM( pTau.track(i)->pt(), pTau.track(i)->eta(), pTau.track(i)->phi(), pTau.track(i)->m());
- sumOfTrackVector += tempTrackVector;
- }
- for (unsigned int i = 0; i != pTau.nWideTracks(); ++i)
+ for (const xAOD::TauTrack* tauTrk : tauTracks)
{
- tempTrackVector.SetPtEtaPhiM( pTau.wideTrack(i)->pt(), pTau.wideTrack(i)->eta(), pTau.wideTrack(i)->phi(), pTau.wideTrack(i)->m());
+ tempTrackVector=tauTrk->p4();
sumOfTrackVector += tempTrackVector;
}
-
pTau.setDetail( xAOD::TauJetParameters::massTrkSys, static_cast<float>( sumOfTrackVector.M() ) );
float tempfloat = 0;
if ( pTau.detail( xAOD::TauJetParameters::massTrkSys, tempfloat ) )
- ATH_MSG_VERBOSE("set massTrkSys " << tempfloat);
+ ATH_MSG_VERBOSE("set massTrkSys " << tempfloat);
}
// width of track system squared (trkWidth2)
- if (pTau.nTracks() > 1) {
+ // if (pTau.nTracks() > 1) { // originally looped over core+wide tracks below
+ if (tauTracks.size()> 0 && pTau.nTracks()>1) {
- double leadTrkPhi = pTau.track(0)->phi();
- double leadTrkEta = pTau.track(0)->eta();
+ double leadTrkPhi = pTau.track(0)->phi();//fix this depending on how we choose to define this
+ double leadTrkEta = pTau.track(0)->eta();//dito. new TauJet_v3 track sorting doesn't guarantee this will be the same track
double ptSum = 0;
double sumWeightedDR = 0;
double sumWeightedDR2 = 0;
- for (unsigned int i = 0; i != pTau.nTracks(); ++i) {
- double deltaR = Tau1P3PKineUtils::deltaR(leadTrkEta, leadTrkPhi, pTau.track(i)->eta(), pTau.track(i)->phi() );
+ for (const xAOD::TauTrack* tauTrk : tauTracks){
- ptSum += pTau.track(i)->pt();
- sumWeightedDR += deltaR * (pTau.track(i)->pt());
- sumWeightedDR2 += deltaR * deltaR * (pTau.track(i)->pt());
- }
+ double deltaR = Tau1P3PKineUtils::deltaR(leadTrkEta, leadTrkPhi, tauTrk->eta(), tauTrk->phi() );
- for (unsigned int i = 0; i != pTau.nWideTracks(); ++i) {
+ ptSum += tauTrk->pt();
+ sumWeightedDR += deltaR * (tauTrk->pt());
+ sumWeightedDR2 += deltaR * deltaR * (tauTrk->pt());
- double deltaR = Tau1P3PKineUtils::deltaR(leadTrkEta, leadTrkPhi, pTau.wideTrack(i)->eta(), pTau.wideTrack(i)->phi() );
-
- ptSum += pTau.wideTrack(i)->pt();
- sumWeightedDR += deltaR * (pTau.wideTrack(i)->pt());
- sumWeightedDR2 += deltaR * deltaR * (pTau.wideTrack(i)->pt());
}
double trkWidth2 = sumWeightedDR2 / ptSum - sumWeightedDR * sumWeightedDR / ptSum / ptSum;
@@ -166,8 +157,9 @@ StatusCode TauCommonCalcVars::execute(xAOD::TauJet& pTau) {
//FF: use now the 4-vector of the tau intermediate axis
//P4EEtaPhiM P4CaloSeed(1., pDetails->seedCalo_eta(), pDetails->seedCalo_phi(), 0.);
-
- if ((pTau.nWideTracks() + pTau.nTracks()) > 0) {
+
+ // if ((pTau.nWideTracks() + pTau.nTracks()) > 0) {
+ if (tauTracks.size()> 0) {
double ptSum = 0;
double innerPtSum = 0;
@@ -175,26 +167,20 @@ StatusCode TauCommonCalcVars::execute(xAOD::TauJet& pTau) {
double innerSumWeightedDR = 0;
double sumWeightedDR2 = 0;
- for (unsigned int i = 0; i != pTau.nTracks(); ++i) {
- double deltaR = Tau1P3PKineUtils::deltaR(pTau.eta(), pTau.phi(), pTau.track(i)->eta(), pTau.track(i)->phi() );
+ for (const xAOD::TauTrack* tauTrk : tauTracks){
+
+ double deltaR = Tau1P3PKineUtils::deltaR(pTau.eta(), pTau.phi(), tauTrk->eta(), tauTrk->phi() );
- ptSum += pTau.track(i)->pt();
- sumWeightedDR += deltaR * (pTau.track(i)->pt());
- sumWeightedDR2 += deltaR * deltaR * (pTau.track(i)->pt());
+ ptSum += tauTrk->pt();
+ sumWeightedDR += deltaR * (tauTrk->pt());
+ sumWeightedDR2 += deltaR * deltaR * (tauTrk->pt());
//add calculation of innerTrkAvgDist
- innerPtSum += pTau.track(i)->pt();
- innerSumWeightedDR += deltaR * (pTau.track(i)->pt());
- }
-
- for (unsigned int i = 0; i != pTau.nWideTracks(); ++i) {
-
- double deltaR = Tau1P3PKineUtils::deltaR(pTau.eta(), pTau.phi(), pTau.wideTrack(i)->eta(), pTau.wideTrack(i)->phi() );
-
- ptSum += pTau.wideTrack(i)->pt();
- sumWeightedDR += deltaR * (pTau.wideTrack(i)->pt());
- sumWeightedDR2 += deltaR * deltaR * (pTau.wideTrack(i)->pt());
+ if(tauTrk->flag(xAOD::TauJetParameters::TauTrackFlag::classifiedCharged)){
+ innerPtSum += tauTrk->pt();
+ innerSumWeightedDR += deltaR * (tauTrk->pt());
+ }
}
if (ptSum > 0.0001) {
diff --git a/Reconstruction/tauRecTools/Root/TauProcessorTool.cxx b/Reconstruction/tauRecTools/Root/TauProcessorTool.cxx
index b304805894a6..d7928222168f 100644
--- a/Reconstruction/tauRecTools/Root/TauProcessorTool.cxx
+++ b/Reconstruction/tauRecTools/Root/TauProcessorTool.cxx
@@ -5,6 +5,8 @@
#include "tauRecTools/TauProcessorTool.h"
#include "xAODTau/TauJetContainer.h"
+#include "xAODTau/TauTrackContainer.h"
+#include "xAODTau/TauTrackAuxContainer.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODTracking/VertexAuxContainer.h"
#include "xAODPFlow/PFOContainer.h"
@@ -41,6 +43,7 @@ TauProcessorTool::TauProcessorTool(const std::string& type) :
declareProperty("deepCopyHadronicPFOContainer", m_deep_copy_hadronicPFOContainer=true);
declareProperty("deepCopyNeutralPFOContainer", m_deep_copy_neutralPFOContainer=true);
declareProperty("deepCopySecVtxContainer", m_deep_copy_SecVtxContainer=false);
+ declareProperty("deepCopyTauTrackContainer", m_deep_copy_TauTrackContainer=true);
}
//________________________________________
@@ -140,6 +143,12 @@ StatusCode TauProcessorTool::execute(){
xAOD::Vertex* v(0);
ATH_CHECK(deepCopy(pSecVtxContainer, pSecVtxAuxContainer, v, "TauSecondaryVertices"));
}
+ if(m_deep_copy_TauTrackContainer){
+ xAOD::TauTrackContainer* pTrackContainer(0);
+ xAOD::TauTrackAuxContainer* pTauTrackAuxContainer(0);
+ xAOD::TauTrack* v(0);
+ ATH_CHECK(deepCopy(pTrackContainer, pTauTrackAuxContainer, v, "TauTracks"));
+ }
if(m_deep_copy_neutralPFOContainer){
xAOD::PFOContainer* neutralPFOContainer(0);
diff --git a/Reconstruction/tauRecTools/Root/TauSubstructureVariables.cxx b/Reconstruction/tauRecTools/Root/TauSubstructureVariables.cxx
index 89e740aac7f3..cbfce175b1b5 100644
--- a/Reconstruction/tauRecTools/Root/TauSubstructureVariables.cxx
+++ b/Reconstruction/tauRecTools/Root/TauSubstructureVariables.cxx
@@ -110,7 +110,7 @@ StatusCode TauSubstructureVariables::execute(xAOD::TauJet& pTau) {
if (!taujetseed) ATH_MSG_DEBUG("Taujet->jet() pointer is NULL: calo cluster variables will be set to -1111");
else ATH_MSG_DEBUG("problem in calculating calo cluster variables -> will be set to -1111");
- pTau.setDetail(xAOD::TauJetParameters::numCells , static_cast<int>(0) );
+ if(!m_inAODmode) pTau.setDetail(xAOD::TauJetParameters::numCells , static_cast<int>(0) );
pTau.setDetail(xAOD::TauJetParameters::numTopoClusters , static_cast<int>(DEFAULT) );
pTau.setDetail(xAOD::TauJetParameters::numEffTopoClusters , static_cast<float>(DEFAULT) );
pTau.setDetail(xAOD::TauJetParameters::topoInvMass, static_cast<float>(DEFAULT) );
@@ -312,7 +312,7 @@ StatusCode TauSubstructureVariables::execute(xAOD::TauJet& pTau) {
}
// set new approximate energy flow variables for tau ID
- pTau.setDetail(xAOD::TauJetParameters::ptRatioEflowApprox, static_cast<float>(approxSubstructure4Vec.Pt()/ pTau.detail<float>(xAOD::TauJetParameters::LC_TES_precalib)) );
+ pTau.setDetail(xAOD::TauJetParameters::ptRatioEflowApprox, static_cast<float>(approxSubstructure4Vec.Pt()/ pTau.ptDetectorAxis()) );
pTau.setDetail(xAOD::TauJetParameters::mEflowApprox, static_cast<float>(approxSubstructure4Vec.M()) );
diff --git a/Reconstruction/tauRecTools/Root/TauTrackClassifier.cxx b/Reconstruction/tauRecTools/Root/TauTrackClassifier.cxx
new file mode 100644
index 000000000000..d00e9b3629f0
--- /dev/null
+++ b/Reconstruction/tauRecTools/Root/TauTrackClassifier.cxx
@@ -0,0 +1,270 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// ASG include(s)
+#include "PathResolver/PathResolver.h"
+
+// xAOD include(s)
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTau/TauTrackContainer.h"
+#include "xAODTau/TauxAODHelpers.h"
+
+// local include(s)
+#include "tauRecTools/TauTrackClassifier.h"
+
+using namespace tauRecTools;
+
+//==============================================================================
+// class TauTrackClassifier
+//==============================================================================
+
+//______________________________________________________________________________
+TauTrackClassifier::TauTrackClassifier(const std::string& sName)
+ : TauRecToolBase(sName)
+{
+ declareProperty("Classifiers", m_vClassifier );
+ declareProperty("TauTrackContainerName", m_tauTrackConName="TauTracks");
+}
+
+//______________________________________________________________________________
+TauTrackClassifier::~TauTrackClassifier()
+{
+}
+
+//______________________________________________________________________________
+StatusCode TauTrackClassifier::initialize()
+{
+ ATH_MSG_DEBUG("intialize classifiers");
+
+ for (auto cClassifier : m_vClassifier){
+ ATH_MSG_INFO("TauTrackClassifier tool : " << cClassifier );
+ ATH_CHECK(cClassifier.retrieve());
+ }
+ return StatusCode::SUCCESS;
+}
+
+//______________________________________________________________________________
+StatusCode TauTrackClassifier::execute(xAOD::TauJet& xTau)
+{
+ xAOD::TauTrackContainer* tauTrackCon = 0;
+ ATH_CHECK(evtStore()->retrieve(tauTrackCon, m_tauTrackConName));
+ std::vector<xAOD::TauTrack*> vTracks = xAOD::TauHelpers::allTauTracksNonConst(&xTau, tauTrackCon);
+ for (xAOD::TauTrack* xTrack : vTracks)
+ {
+ // reset all track flags and set status to unclassified
+ xTrack->setFlag(xAOD::TauJetParameters::classifiedCharged, false);
+ xTrack->setFlag(xAOD::TauJetParameters::classifiedConversion, false);
+ xTrack->setFlag(xAOD::TauJetParameters::classifiedIsolation, false);
+ xTrack->setFlag(xAOD::TauJetParameters::classifiedFake, false);
+ xTrack->setFlag(xAOD::TauJetParameters::unclassified, true);
+
+ // execute the bdt track classifier
+ for (auto cClassifier : m_vClassifier)
+ CHECK(cClassifier->classifyTrack(*xTrack, xTau));
+ }
+ std::vector< ElementLink< xAOD::TauTrackContainer > > &tauTrackLinks(xTau.tauTrackLinksNonConst());
+ std::sort(tauTrackLinks.begin(), tauTrackLinks.end(), sortTracks);
+ float charge=0.0;
+ for( const xAOD::TauTrack* trk : xTau.tracks(xAOD::TauJetParameters::classifiedCharged) ){
+ charge += trk->track()->charge();
+ }
+ xTau.setCharge(charge);
+ return StatusCode::SUCCESS;
+}
+
+//==============================================================================
+// class TrackMVABDT
+//==============================================================================
+
+//______________________________________________________________________________
+TrackMVABDT::TrackMVABDT(const std::string& sName)
+ : TauRecToolBase(sName)
+ , m_sInputWeightsPath("")
+ , m_fThreshold(0.)
+ , m_iSignalType(xAOD::TauJetParameters::classifiedCharged)
+ , m_iBackgroundType(xAOD::TauJetParameters::classifiedFake)
+ , m_iExpectedFlag(xAOD::TauJetParameters::unclassified)
+ , m_rReader(0)
+{
+ declareProperty( "InputWeightsPath", m_sInputWeightsPath );
+ declareProperty( "Threshold", m_fThreshold );
+ declareProperty( "BackgroundType" , m_iBackgroundType );
+ declareProperty( "SignalType", m_iSignalType );
+ declareProperty( "ExpectedFlag", m_iExpectedFlag );
+ m_mParsedVarsBDT.clear();
+}
+
+//______________________________________________________________________________
+TrackMVABDT::~TrackMVABDT()
+{
+ delete m_rReader;
+}
+
+//______________________________________________________________________________
+StatusCode TrackMVABDT::initialize()
+{
+ m_rReader = new TMVA::Reader( "!Silent" );
+ m_mAvailableVars=
+ {
+ {"TracksAuxDyn.tauPt",tauPt}
+ , {"TracksAuxDyn.tauEta",tauEta}
+ , {"TracksAuxDyn.trackEta",trackEta}
+ , {"TracksAuxDyn.z0sinThetaTJVA",z0sinThetaTJVA}
+ , {"TracksAuxDyn.rConv",rConv}
+ , {"TracksAuxDyn.rConvII",rConvII}
+ , {"TracksAuxDyn.DRJetSeedAxis",DRJetSeedAxis}
+ , {"TracksAux.d0",d0}
+ , {"TracksAux.qOverP",qOverP}
+ , {"TracksAux.theta",theta}
+ , {"TracksAux.numberOfInnermostPixelLayerHits", numberOfInnermostPixelLayerHits}
+ , {"TracksAux.numberOfPixelHits",numberOfPixelHits}
+ , {"TracksAux.numberOfPixelDeadSensors",numberOfPixelDeadSensors}
+ , {"TracksAux.numberOfPixelSharedHits",numberOfPixelSharedHits}
+ , {"TracksAux.numberOfSCTHits",numberOfSCTHits}
+ , {"TracksAux.numberOfSCTDeadSensors",numberOfSCTDeadSensors}
+ , {"TracksAux.numberOfSCTSharedHits",numberOfSCTSharedHits}
+ , {"TracksAux.numberOfTRTHighThresholdHits",numberOfTRTHighThresholdHits}
+ , {"TracksAux.numberOfTRTHits",numberOfTRTHits}
+ , {"TracksAux.numberOfPixelHits+TracksAux.numberOfPixelDeadSensors", nPixHits}
+ , {"TracksAux.numberOfPixelHits+TracksAux.numberOfPixelDeadSensors+TracksAux.numberOfSCTHits+TracksAux.numberOfSCTDeadSensors", nSiHits}
+ };
+
+ for (auto fVar : m_mAvailableVars)
+ fVar.second = 0.;
+
+ ATH_CHECK(addWeightsFile());
+
+ return StatusCode::SUCCESS;
+}
+
+//______________________________________________________________________________
+StatusCode TrackMVABDT::classifyTrack(xAOD::TauTrack& xTrack, const xAOD::TauJet& xTau)
+{
+ setVars(xTrack, xTau);
+
+ //why?
+ if (xTrack.flag((xAOD::TauJetParameters::TauTrackFlag) m_iExpectedFlag)==false)
+ return StatusCode::SUCCESS;
+
+ double dValue = m_rReader->EvaluateMVA( m_sInputWeightsPath );
+
+ xTrack.setFlag((xAOD::TauJetParameters::TauTrackFlag) m_iExpectedFlag, false);
+ if (m_fThreshold < dValue)
+ xTrack.setFlag((xAOD::TauJetParameters::TauTrackFlag) m_iSignalType, true);
+ else
+ xTrack.setFlag((xAOD::TauJetParameters::TauTrackFlag) m_iBackgroundType, true);
+
+ xTrack.addBdtScore(dValue);
+
+ return StatusCode::SUCCESS;
+}
+
+//______________________________________________________________________________
+StatusCode TrackMVABDT::addWeightsFile()
+{
+ // better to replace that part at some point
+ m_sInputWeightsPath = PathResolverFindCalibFile(m_sInputWeightsPath);
+ ATH_MSG_DEBUG("InputWeightsPath: " << m_sInputWeightsPath);
+
+ if (m_mParsedVarsBDT.empty())
+ {
+ ATH_CHECK(parseVariableContent());
+
+ for (auto i : m_mParsedVarsBDT)
+ ATH_MSG_DEBUG(i.first<<" "<<i.second);
+
+ for (size_t i = 0; i < m_mParsedVarsBDT.size(); i++){
+ std::string sVarName = m_mParsedVarsBDT[i];
+ m_rReader->AddVariable( sVarName, &(m_mAvailableVars[sVarName]));
+ }
+ }
+
+ m_rReader->BookMVA( m_sInputWeightsPath, m_sInputWeightsPath );
+ return StatusCode::SUCCESS;
+}
+
+//______________________________________________________________________________
+StatusCode TrackMVABDT::parseVariableContent()
+{
+ // example <Variable VarIndex="0" Expression="TracksAuxDyn.tauPt" Label="TracksAuxDyn.tauPt" Title="tauPt" Unit="" Internal="TracksAuxDyn.tauPt" Type="F" Min="1.50000762e+04" Max="5.32858625e+05"/>
+ std::string sLine;
+ std::ifstream sFileStream (m_sInputWeightsPath);
+ if (sFileStream.is_open())
+ {
+ while ( getline (sFileStream,sLine) )
+ {
+ size_t iPosVarindex = sLine.find("VarIndex=");
+
+ if ( iPosVarindex == std::string::npos )
+ continue;
+
+ iPosVarindex += 10;
+
+ size_t iPosVarindexEnd = sLine.find("\"",iPosVarindex);
+ size_t iPosExpression = sLine.find("Expression=")+12;
+ size_t iPosExpressionEnd = sLine.find("\"",iPosExpression);
+
+ int iVarIndex = std::stoi(sLine.substr(iPosVarindex, iPosVarindexEnd-iPosVarindex));
+ std::string sExpression = sLine.substr(iPosExpression, iPosExpressionEnd-iPosExpression);
+
+ m_mParsedVarsBDT.insert(std::pair<int, std::string >(iVarIndex,sExpression));
+ }
+ sFileStream.close();
+ return StatusCode::SUCCESS;
+ }
+
+ ATH_MSG_ERROR("Unable to open file "<<m_sInputWeightsPath);
+ return StatusCode::FAILURE;
+}
+
+//______________________________________________________________________________
+void TrackMVABDT::setVars(const xAOD::TauTrack& xTrack, const xAOD::TauJet& xTau)
+{
+ const xAOD::TrackParticle* xTrackParticle = xTrack.track();
+ uint8_t iTracksNumberOfInnermostPixelLayerHits = 0; xTrackParticle->summaryValue(iTracksNumberOfInnermostPixelLayerHits, xAOD::numberOfInnermostPixelLayerHits);
+ uint8_t iTracksNPixelHits = 0; xTrackParticle->summaryValue(iTracksNPixelHits, xAOD::numberOfPixelHits);
+ uint8_t iTracksNPixelSharedHits = 0; xTrackParticle->summaryValue(iTracksNPixelSharedHits, xAOD::numberOfPixelSharedHits);
+ uint8_t iTracksNPixelDeadSensors = 0; xTrackParticle->summaryValue(iTracksNPixelDeadSensors, xAOD::numberOfPixelDeadSensors);
+ uint8_t iTracksNSCTHits = 0; xTrackParticle->summaryValue(iTracksNSCTHits, xAOD::numberOfSCTHits);
+ uint8_t iTracksNSCTSharedHits = 0; xTrackParticle->summaryValue(iTracksNSCTSharedHits, xAOD::numberOfSCTSharedHits);
+ uint8_t iTracksNSCTDeadSensors = 0; xTrackParticle->summaryValue(iTracksNSCTDeadSensors, xAOD::numberOfSCTDeadSensors);
+ uint8_t iTracksNTRTHighThresholdHits = 0; xTrackParticle->summaryValue( iTracksNTRTHighThresholdHits, xAOD::numberOfTRTHighThresholdHits);
+ uint8_t iTracksNTRTHits = 0; xTrackParticle->summaryValue( iTracksNTRTHits, xAOD::numberOfTRTHits);
+
+ float fTracksNumberOfInnermostPixelLayerHits = (float)iTracksNumberOfInnermostPixelLayerHits;
+ float fTracksNPixelHits = (float)iTracksNPixelHits;
+ float fTracksNPixelDeadSensors = (float)iTracksNPixelDeadSensors;
+ float fTracksNPixelSharedHits = (float)iTracksNPixelSharedHits;
+ float fTracksNSCTHits = (float)iTracksNSCTHits;
+ float fTracksNSCTDeadSensors = (float)iTracksNSCTDeadSensors;
+ float fTracksNSCTSharedHits = (float)iTracksNSCTSharedHits;
+ float fTracksNTRTHighThresholdHits = (float)iTracksNTRTHighThresholdHits;
+ float fTracksNTRTHits = (float)iTracksNTRTHits;
+
+ float fTracksNPixHits = fTracksNPixelHits + fTracksNPixelDeadSensors;
+ float fTracksNSiHits = fTracksNPixelHits + fTracksNPixelDeadSensors + fTracksNSCTHits + fTracksNSCTDeadSensors;
+
+
+ m_mAvailableVars["TracksAuxDyn.tauPt"] = xTau.pt();
+ m_mAvailableVars["TracksAuxDyn.tauEta"] = xTau.eta();
+ m_mAvailableVars["TracksAuxDyn.z0sinThetaTJVA"] = xTrack.z0sinThetaTJVA(xTau);
+ m_mAvailableVars["TracksAuxDyn.rConv"] = xTrack.rConv(xTau);
+ m_mAvailableVars["TracksAuxDyn.rConvII"] = xTrack.rConvII(xTau);
+ m_mAvailableVars["TracksAuxDyn.DRJetSeedAxis"] = xTrack.dRJetSeedAxis(xTau);
+ m_mAvailableVars["TracksAuxDyn.trackEta"] = xTrackParticle->d0();
+ m_mAvailableVars["TracksAux.d0"] = xTrackParticle->d0();
+ m_mAvailableVars["TracksAux.qOverP"] = xTrackParticle->qOverP();
+ m_mAvailableVars["TracksAux.theta"] = xTrackParticle->theta();
+ m_mAvailableVars["TracksAux.numberOfInnermostPixelLayerHits"] = fTracksNumberOfInnermostPixelLayerHits;
+ m_mAvailableVars["TracksAux.numberOfPixelHits"] = fTracksNPixelHits;
+ m_mAvailableVars["TracksAux.numberOfPixelDeadSensors"] = fTracksNPixelDeadSensors;
+ m_mAvailableVars["TracksAux.numberOfPixelSharedHits"] = fTracksNPixelSharedHits;
+ m_mAvailableVars["TracksAux.numberOfSCTHits"] = fTracksNSCTHits;
+ m_mAvailableVars["TracksAux.numberOfSCTDeadSensors"] = fTracksNSCTDeadSensors;
+ m_mAvailableVars["TracksAux.numberOfSCTSharedHits"] = fTracksNSCTSharedHits;
+ m_mAvailableVars["TracksAux.numberOfTRTHighThresholdHits"] = fTracksNTRTHighThresholdHits;
+ m_mAvailableVars["TracksAux.numberOfTRTHits"] = fTracksNTRTHits;
+ m_mAvailableVars["TracksAux.numberOfPixelHits+TracksAux.numberOfPixelDeadSensors"] = fTracksNPixHits;
+ m_mAvailableVars["TracksAux.numberOfPixelHits+TracksAux.numberOfPixelDeadSensors+TracksAux.numberOfSCTHits+TracksAux.numberOfSCTDeadSensors"] = fTracksNSiHits;
+}
diff --git a/Reconstruction/tauRecTools/Root/TauTrackFilter.cxx b/Reconstruction/tauRecTools/Root/TauTrackFilter.cxx
index df2cf026b42b..d89b61b185c6 100644
--- a/Reconstruction/tauRecTools/Root/TauTrackFilter.cxx
+++ b/Reconstruction/tauRecTools/Root/TauTrackFilter.cxx
@@ -23,18 +23,19 @@
#include "tauRecTools/TauTrackFilterUtils.h"
#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTau/TauxAODHelpers.h"
#include "TLorentzVector.h"
void TrackFilterAlg(TLorentzVector tau,
- std::vector<TLorentzVector>* inputtracks20,
- std::vector<int>* inputtracks20charge,
- std::vector<TLorentzVector>* inputtracks40,
- std::vector<int>* inputtracks40charge,
- std::vector<TLorentzVector>* outputtracksgood,
- std::vector<int>* outputtracksgoodcharge,
- std::vector<TLorentzVector>* outputtracksbad,
- std::vector<int>* outputtracksbadcharge,
+ std::vector<TLorentzVector>& inputtracks20,
+ std::vector<int>& inputtracks20charge,
+ std::vector<TLorentzVector>& inputtracks40,
+ std::vector<int>& inputtracks40charge,
+ std::vector<TLorentzVector>& outputtracksgood,
+ std::vector<int>& outputtracksgoodcharge,
+ std::vector<TLorentzVector>& outputtracksbad,
+ std::vector<int>& outputtracksbadcharge,
int& nProng,
int& flag);
@@ -49,6 +50,7 @@ TauTrackFilter::TauTrackFilter(const std::string &name ) :
{
declareProperty("ConfigPath", m_configPath);
declareProperty("TrackContainerName", m_trackContainerName = "InDetTrackParticles");
+ declareProperty("TauTrackContainerName", m_tauTrackConName = "TauTracks");
}
//-----------------------------------------------------------------------------
@@ -104,14 +106,14 @@ StatusCode TauTrackFilter::execute(xAOD::TauJet& pTau) {
pTau.phi(),
pTau.e()/1000); //GeV
- std::vector<TLorentzVector>* inputtracks20 = new std::vector<TLorentzVector>;
- std::vector<TLorentzVector>* inputtracks40 = new std::vector<TLorentzVector>;
- std::vector<int>* inputtracks20charge = new std::vector<int>;
- std::vector<int>* inputtracks40charge = new std::vector<int>;
- std::vector<TLorentzVector>* outputtracksgood = new std::vector<TLorentzVector>;
- std::vector<TLorentzVector>* outputtracksbad = new std::vector<TLorentzVector>;
- std::vector<int>* outputtracksgoodcharge = new std::vector<int>;
- std::vector<int>* outputtracksbadcharge = new std::vector<int>;
+ std::vector<TLorentzVector> inputtracks20;
+ std::vector<TLorentzVector> inputtracks40;
+ std::vector<int> inputtracks20charge;
+ std::vector<int> inputtracks40charge;
+ std::vector<TLorentzVector> outputtracksgood;
+ std::vector<TLorentzVector> outputtracksbad;
+ std::vector<int> outputtracksgoodcharge;
+ std::vector<int> outputtracksbadcharge;
int nProng = 0;
int flag = 0;
@@ -121,7 +123,7 @@ StatusCode TauTrackFilter::execute(xAOD::TauJet& pTau) {
m_TrkPass.clear();
for(unsigned int j=0; j<pTau.nTracks(); j++ ) {
- const xAOD::TrackParticle *TauJetTrack = pTau.track(j);
+ const xAOD::TrackParticle *TauJetTrack = pTau.track(j)->track();
TLorentzVector inputTrack;
inputTrack.SetPtEtaPhiE(TauJetTrack->pt()/1000, //GeV
TauJetTrack->eta(),
@@ -129,13 +131,13 @@ StatusCode TauTrackFilter::execute(xAOD::TauJet& pTau) {
TauJetTrack->e()/1000); //GeV
float dR = tau.DeltaR(inputTrack);
if (dR < 0.2) {
- inputtracks20->push_back(inputTrack);
- inputtracks20charge->push_back(TauJetTrack->charge());
+ inputtracks20.push_back(inputTrack);
+ inputtracks20charge.push_back(TauJetTrack->charge());
inputtracks20index.push_back(j);
}
else if (dR < 0.4) {
- inputtracks40->push_back(inputTrack);
- inputtracks40charge->push_back(TauJetTrack->charge());
+ inputtracks40.push_back(inputTrack);
+ inputtracks40charge.push_back(TauJetTrack->charge());
inputtracks40index.push_back(j);
}
@@ -157,14 +159,14 @@ StatusCode TauTrackFilter::execute(xAOD::TauJet& pTau) {
flag);
// Store results
- for (unsigned int j=0; j<outputtracksgood->size(); j++ ) {
- for (unsigned int k=0; k<inputtracks20->size(); k++ ) {
- if (outputtracksgood->at(j) == inputtracks20->at(k)) {
+ for (unsigned int j=0; j<outputtracksgood.size(); j++ ) {
+ for (unsigned int k=0; k<inputtracks20.size(); k++ ) {
+ if (outputtracksgood.at(j) == inputtracks20.at(k)) {
m_TrkPass.at(inputtracks20index.at(k)) = true;
}
}
- for (unsigned int k=0; k<inputtracks40->size(); k++ ) {
- if (outputtracksgood->at(j) == inputtracks40->at(k)) {
+ for (unsigned int k=0; k<inputtracks40.size(); k++ ) {
+ if (outputtracksgood.at(j) == inputtracks40.at(k)) {
m_TrkPass.at(inputtracks40index.at(k)) = true;
}
}
@@ -172,19 +174,12 @@ StatusCode TauTrackFilter::execute(xAOD::TauJet& pTau) {
m_nProng = nProng;
m_flag = flag;
- // Cleanup
- delete inputtracks20;
- delete inputtracks20charge;
- delete inputtracks40;
- delete inputtracks40charge;
- delete outputtracksgood;
- delete outputtracksbad;
- delete outputtracksgoodcharge;
- delete outputtracksbadcharge;
-
// Set values in EDM
+ xAOD::TauTrackContainer* tauTracks = 0;
+ ATH_CHECK(evtStore()->retrieve(tauTracks, m_tauTrackConName));
for (unsigned int numTrack=0; numTrack<m_TrkPass.size(); numTrack++) {
- pTau.setTrackFlag(pTau.track(numTrack), xAOD::TauJetParameters::failTrackFilter, !m_TrkPass.at(numTrack));
+ xAOD::TauTrack* tauTrk = xAOD::TauHelpers::tauTrackNonConst(&pTau, tauTracks, numTrack); //pTau.trackNonConst(numTrack);
+ tauTrk->setFlag(xAOD::TauJetParameters::failTrackFilter, !m_TrkPass.at(numTrack));
}
pTau.setTrackFilterProngs(m_nProng);
pTau.setTrackFilterQuality(m_flag);
@@ -197,24 +192,24 @@ StatusCode TauTrackFilter::execute(xAOD::TauJet& pTau) {
// Main algorithm
//-----------------------------------------------------------------------------
void TrackFilterAlg(TLorentzVector tau,
- std::vector<TLorentzVector>* inputtracks20,
- std::vector<int>* inputtracks20charge,
- std::vector<TLorentzVector>* inputtracks40,
- std::vector<int>* inputtracks40charge,
- std::vector<TLorentzVector>* outputtracksgood,
- std::vector<int>* outputtracksgoodcharge,
- std::vector<TLorentzVector>* outputtracksbad,
- std::vector<int>* outputtracksbadcharge,
+ std::vector<TLorentzVector>& inputtracks20,
+ std::vector<int>& inputtracks20charge,
+ std::vector<TLorentzVector>& inputtracks40,
+ std::vector<int>& inputtracks40charge,
+ std::vector<TLorentzVector>& outputtracksgood,
+ std::vector<int>& outputtracksgoodcharge,
+ std::vector<TLorentzVector>& outputtracksbad,
+ std::vector<int>& outputtracksbadcharge,
int& nProng,
int& flag) {
std::vector<TauTrackFilterUtils::TrackInfo> unsorted,tracks,SScombination;
TauTrackFilterUtils::TrackInfo track;
- unsigned int tracknum = inputtracks20->size();
- unsigned int widetracknum = inputtracks40->size();
+ unsigned int tracknum = inputtracks20.size();
+ unsigned int widetracknum = inputtracks40.size();
for(unsigned int i=0;i<tracknum;i++){
- track.p4 = (*inputtracks20)[i];
- track.charge = (*inputtracks20charge)[i];
+ track.p4 = (inputtracks20)[i];
+ track.charge = (inputtracks20charge)[i];
unsorted.push_back(track);
}
while (unsorted.size() > 0){
@@ -235,8 +230,8 @@ void TrackFilterAlg(TLorentzVector tau,
bool test3prong = true, test2prong = true, test1prong = true;
for(unsigned int i=0;i<widetracknum;i++){
- outputtracksbad->push_back((*inputtracks40)[i]);
- outputtracksbadcharge->push_back((*inputtracks40charge)[i]);
+ outputtracksbad.push_back((inputtracks40)[i]);
+ outputtracksbadcharge.push_back((inputtracks40charge)[i]);
}
if(tracknum > 4){ //Anything with more than 4 tracks is a fake.
flag = 0;
@@ -283,8 +278,8 @@ void TrackFilterAlg(TLorentzVector tau,
if(goodcombo){ //A Combination is found which passes 3prong hypothesis
for(unsigned int i=0;i<combination.size();i++){
if (isSS) SScombination.push_back(combination[i]);
- outputtracksgood->push_back(combination[i].p4);
- outputtracksgoodcharge->push_back(combination[i].charge);
+ outputtracksgood.push_back(combination[i].p4);
+ outputtracksgoodcharge.push_back(combination[i].charge);
}
if(isSS) flag = 0;
else flag = 1;
@@ -293,8 +288,8 @@ void TrackFilterAlg(TLorentzVector tau,
test2prong = false;
if(!test1prong){ //Fill Bad Track in the Case of 4 trk taus
if(tracknum == 4){
- outputtracksbad->push_back(tracks[3].p4);
- outputtracksbadcharge->push_back(tracks[3].charge);
+ outputtracksbad.push_back(tracks[3].p4);
+ outputtracksbadcharge.push_back(tracks[3].charge);
}
}
}
@@ -305,14 +300,14 @@ void TrackFilterAlg(TLorentzVector tau,
if(TauTrackFilterUtils::pass2prong(pair,tau)){
nProng = 2;
for(unsigned int i=0;i<pair.size();i++){ //Fill Good Tracks
- outputtracksgood->push_back(pair[i].p4);
- outputtracksgoodcharge->push_back(pair[i].charge);
+ outputtracksgood.push_back(pair[i].p4);
+ outputtracksgoodcharge.push_back(pair[i].charge);
}
test1prong = false;
if(tracknum == 3){
flag = 2;
- outputtracksbad->push_back(tracks[2].p4); //Fill Bad Track in Case of 3 trk Taus
- outputtracksbadcharge->push_back(tracks[2].charge);
+ outputtracksbad.push_back(tracks[2].p4); //Fill Bad Track in Case of 3 trk Taus
+ outputtracksbadcharge.push_back(tracks[2].charge);
}
else flag = 1; //Good 2 Prong if only 2 trks
}
@@ -338,13 +333,13 @@ void TrackFilterAlg(TLorentzVector tau,
if(tracks[1].p4.Pt()/tracks[0].p4.Pt() < ratio10) goodcase = true; //Test 2trk taus most likely to actually be 1pngs
}
if((TauTrackFilterUtils::pass1prong(tracks[0].p4,tau))&&(goodcase)){ //A track is found which passes 1prong hypothesis
- outputtracksgood->push_back(tracks[0].p4);
- outputtracksgoodcharge->push_back(tracks[0].charge);
+ outputtracksgood.push_back(tracks[0].p4);
+ outputtracksgoodcharge.push_back(tracks[0].charge);
nProng = 1;
if (tracknum == 2){
flag = 2;
- outputtracksbad->push_back(tracks[1].p4); //Fill Bad Track in Case of 3 trk Taus
- outputtracksbadcharge->push_back(tracks[1].charge);
+ outputtracksbad.push_back(tracks[1].p4); //Fill Bad Track in Case of 3 trk Taus
+ outputtracksbadcharge.push_back(tracks[1].charge);
}
else flag = 1;
}
diff --git a/Reconstruction/tauRecTools/cmt/requirements b/Reconstruction/tauRecTools/cmt/requirements
index 1ba42c91abf4..3c53df7bfca3 100644
--- a/Reconstruction/tauRecTools/cmt/requirements
+++ b/Reconstruction/tauRecTools/cmt/requirements
@@ -51,7 +51,7 @@ use VxVertex VxVertex-* Tracking/TrkEven
#use tauEvent tauEvent-* Reconstruction
use xAODCaloEvent xAODCaloEvent-* Event/xAOD
use xAODPFlow xAODPFlow-* Event/xAOD
-use TauAnalysisTools TauAnalysisTools-* PhysicsAnalysis/TauID
+use InDetTrackSelectionTool InDetTrackSelectionTool-* InnerDetector/InDetRecTools
diff --git a/Reconstruction/tauRecTools/share/TF2pileupForOfflineID_1p.root b/Reconstruction/tauRecTools/share/TF2pileupForOfflineID_1p.root
deleted file mode 100644
index 9c291900a685fdad8f49e16df169aa7b6b1dabec..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 17230
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
E01)HL5dZ)H
diff --git a/Reconstruction/tauRecTools/share/TF2pileupForOfflineID_3p.root b/Reconstruction/tauRecTools/share/TF2pileupForOfflineID_3p.root
deleted file mode 100644
index 3be443eab64f1fe1c8aa05d264f9ff8e625f3007..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 18865
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
diff --git a/Reconstruction/tauRecTools/src/JetSeedBuilder.cxx b/Reconstruction/tauRecTools/src/JetSeedBuilder.cxx
index f67c1dc36d25..6d23975ca841 100644
--- a/Reconstruction/tauRecTools/src/JetSeedBuilder.cxx
+++ b/Reconstruction/tauRecTools/src/JetSeedBuilder.cxx
@@ -179,8 +179,8 @@ StatusCode JetSeedBuilder::execute(xAOD::TauJet& pTau) {
// SL/SX trigger mode with negative jet_seed - do not set TauJet eta and phi in JetSeedBuilder
ATH_MSG_DEBUG("TauJet eta/phi will be set in Level2 Trigger for negative energy jet");
- pTau.setDetail(xAOD::TauJetParameters::seedCalo_eta , static_cast<float>( pTau.eta() ) );
- pTau.setDetail(xAOD::TauJetParameters::seedCalo_phi , static_cast<float>( pTau.phi() ) );
+ // pTau.setDetail(xAOD::TauJetParameters::seedCalo_eta , static_cast<float>( pTau.eta() ) );
+ // pTau.setDetail(xAOD::TauJetParameters::seedCalo_phi , static_cast<float>( pTau.phi() ) );
pTau.setP4(pJetSeed->pt(),pTau.eta(),pTau.phi(),0.0);
@@ -192,12 +192,12 @@ StatusCode JetSeedBuilder::execute(xAOD::TauJet& pTau) {
// sigstateH.controlObject(pJetSeed);
}
- pTau.setDetail(xAOD::TauJetParameters::seedCalo_eta , static_cast<float>( pJetSeed->eta() ) );
- pTau.setDetail(xAOD::TauJetParameters::seedCalo_phi , static_cast<float>( pJetSeed->phi() ) );
+ // pTau.setDetail(xAOD::TauJetParameters::seedCalo_eta , static_cast<float>( pJetSeed->eta() ) );
+ // pTau.setDetail(xAOD::TauJetParameters::seedCalo_phi , static_cast<float>( pJetSeed->phi() ) );
if ( pJetSeed->pt() > 1e-7)
pTau.setP4(static_cast<float>( pJetSeed->pt() ) ,static_cast<float>( pJetSeed->eta() ) ,static_cast<float>( pJetSeed->phi() ) ,0.0 );
else
- pTau.setP4(static_cast<float>( pJetSeed->pt() ) ,static_cast<float>( pJetSeed->eta() ) ,static_cast<float>( pJetSeed->phi() ) , 0.0 );
+ pTau.setP4(static_cast<float>( 1e-7 ) ,static_cast<float>( pJetSeed->eta() ) ,static_cast<float>( pJetSeed->phi() ) , 0.0 );
//store 4-vector of seed
pTau.setP4( xAOD::TauJetParameters::JetSeed, pJetSeed->pt(), pJetSeed->eta(), pJetSeed->phi(), pJetSeed->m() );
diff --git a/Reconstruction/tauRecTools/src/PhotonConversionVertex.cxx b/Reconstruction/tauRecTools/src/PhotonConversionVertex.cxx
index 5acee948f63e..03b5efb82625 100644
--- a/Reconstruction/tauRecTools/src/PhotonConversionVertex.cxx
+++ b/Reconstruction/tauRecTools/src/PhotonConversionVertex.cxx
@@ -124,10 +124,14 @@ bool PhotonConversionVertex::openContainer(T* &container, std::string containerN
template <class T>
bool PhotonConversionVertex::saveContainer(T* &container, std::string containerName) {
- StatusCode sc = evtStore()->record(container, containerName);
- if (!container || sc.isFailure())
- ATH_MSG_FATAL("Container (" << containerName << ") cannot be saved in StoreGate");
- return container;
+ if(!container){
+ ATH_MSG_FATAL("Container (" << containerName << ") cannot be saved in StoreGate");
+ return false;
+ }
+ StatusCode sc = evtStore()->record(container, containerName);
+ if (sc.isFailure())
+ ATH_MSG_FATAL("Container (" << containerName << ") cannot be saved in StoreGate");
+ return container;
}
template <class T>
diff --git a/Reconstruction/tauRecTools/src/TauAxisSetter.cxx b/Reconstruction/tauRecTools/src/TauAxisSetter.cxx
index 81b7015147c5..360327ca3298 100644
--- a/Reconstruction/tauRecTools/src/TauAxisSetter.cxx
+++ b/Reconstruction/tauRecTools/src/TauAxisSetter.cxx
@@ -88,6 +88,10 @@ StatusCode TauAxisSetter::execute(xAOD::TauJet& pTau)
if (BaryCenter.DeltaR(tempClusterVector) > m_clusterCone)
continue;
+ ElementLink<xAOD::IParticleContainer> linkToCluster;
+ linkToCluster.toContainedElement( *(static_cast<const xAOD::IParticleContainer*> ((*cItr)->rawConstituent()->container())), (*cItr)->rawConstituent() );
+ pTau.addClusterLink(linkToCluster);
+
nConstituents++;
tauDetectorAxis += tempClusterVector;
}
@@ -111,10 +115,6 @@ StatusCode TauAxisSetter::execute(xAOD::TauJet& pTau)
ATH_MSG_VERBOSE("jet axis:" << (*pTau.jetLink())->pt()<< " " << (*pTau.jetLink())->eta() << " " << (*pTau.jetLink())->phi() << " " << (*pTau.jetLink())->e() );
// save values for detector axis.
- // FixMe: consider dropping these details variables as they are duplicated in the detector axis 4 vector
- pTau.setDetail(xAOD::TauJetParameters::LC_TES_precalib , static_cast<float>( tauDetectorAxis.Pt() ) );
- pTau.setDetail(xAOD::TauJetParameters::seedCalo_eta, static_cast<float>( tauDetectorAxis.Eta() ) );
- pTau.setDetail(xAOD::TauJetParameters::seedCalo_phi, static_cast<float>( tauDetectorAxis.Phi() ) );
ATH_MSG_VERBOSE("detector axis:" << tauDetectorAxis.Pt()<< " " << tauDetectorAxis.Eta() << " " << tauDetectorAxis.Phi() << " " << tauDetectorAxis.E() );
// detectorAxis (set default)
diff --git a/Reconstruction/tauRecTools/src/TauCalibrateEM.cxx b/Reconstruction/tauRecTools/src/TauCalibrateEM.cxx
index 5061009ebde1..e0ee73b556c0 100644
--- a/Reconstruction/tauRecTools/src/TauCalibrateEM.cxx
+++ b/Reconstruction/tauRecTools/src/TauCalibrateEM.cxx
@@ -110,7 +110,7 @@ StatusCode TauCalibrateEM::execute(xAOD::TauJet& pTau) {
ATH_MSG_DEBUG("input variables: em_pt " << emscale_pt << " eta " << emscale_eta << " ntrack " << pTau.nTracks() << " emfrac " << emfrac);
- double new_pt = evaluate_new_pt(emscale_pt / GeV, fabs(emscale_eta), pTau.nTracks(), emfrac);
+ /*double new_pt = */evaluate_new_pt(emscale_pt / GeV, fabs(emscale_eta), pTau.nTracks(), emfrac);
// do NOT set TauJet energy, as this will be done in tauCalibrateLC
@@ -119,7 +119,9 @@ StatusCode TauCalibrateEM::execute(xAOD::TauJet& pTau) {
// instead fill place holder in TauCommonDetails
//pDetails->setSeedCalo_etEMCalib(new_pt * GeV);
- pTau.setDetail( xAOD::TauJetParameters::EM_TES_scale, static_cast<float>( new_pt * GeV ) );
+ //r21 cleanup
+ ATH_MSG_WARNING("EM_TES_scale removed");
+ //pTau.setDetail( xAOD::TauJetParameters::EM_TES_scale, static_cast<float>( new_pt * GeV ) );
return StatusCode::SUCCESS;
}
diff --git a/Reconstruction/tauRecTools/src/TauConversionFinder.cxx b/Reconstruction/tauRecTools/src/TauConversionFinder.cxx
index a435d146412f..449b45b79391 100644
--- a/Reconstruction/tauRecTools/src/TauConversionFinder.cxx
+++ b/Reconstruction/tauRecTools/src/TauConversionFinder.cxx
@@ -119,21 +119,24 @@ StatusCode TauConversionFinder::eventFinalize() {
// Find conversion in normal tau tracks
if (m_do_normal) {
for (unsigned int j = 0; j < numTracks; ++j) {
- const xAOD::TrackParticle *pTauTrack = pTau.track(j);
- const Trk::Track* tau_trk_def = pTauTrack->track();
+ //const xAOD::TrackParticle *pTauTrack = pTau.track(j);
+ xAOD::TauTrack *pTauTrack = pTau.trackNonConst(j);
+ const Trk::Track* tau_trk_def = pTauTrack->track()->track();
if (conv_trk == tau_trk_def) {
if (conv_trk->trackSummary()->getPID(Trk::eProbabilityHT) > m_eProb_cut) {
- if (!pTau.trackFlag(pTauTrack, xAOD::TauJetParameters::isConversion)) {
+ //if (!pTau.trackFlag(pTauTrack, xAOD::TauJetParameters::isConversion)) {
+ if (!pTauTrack->flag(xAOD::TauJetParameters::isConversionOld)) {
ElementLink<xAOD::TrackParticleContainer> phoConvLink ;
- phoConvLink.setElement(pTauTrack) ;
+ //phoConvLink.setElement(pTauTrack) ;
+ phoConvLink.setElement(pTauTrack->track()) ;
phoConvLink.setStorableObject( *trackContainer ) ;
- phoConvLink.index();
- pTau.addTrackLink( phoConvLink ) ;
- pTau.setTrackFlag(pTauTrack, xAOD::TauJetParameters::isConversion, true);
+ //phoConvLink.index();
+ pTauTrack->addTrackLink( phoConvLink );
+ pTauTrack->setFlag(xAOD::TauJetParameters::isConversionOld, true);
if (m_adjust_tau_charge)
- pTau.setCharge(pTau.charge() - pTau.track(j)->charge());
+ pTau.setCharge(pTau.charge() - pTau.track(j)->track()->charge());
m_numProng--;
}
diff --git a/Reconstruction/tauRecTools/src/TauConversionTagger.cxx b/Reconstruction/tauRecTools/src/TauConversionTagger.cxx
index b44a2ecb8949..1f1907c5e6cf 100644
--- a/Reconstruction/tauRecTools/src/TauConversionTagger.cxx
+++ b/Reconstruction/tauRecTools/src/TauConversionTagger.cxx
@@ -90,7 +90,7 @@ StatusCode TauConversionTagger::execute(xAOD::TauJet& pTau) {
for(unsigned int j=0; j<pTau.nTracks(); j++ ) {
- const xAOD::TrackParticle *TauJetTrack = pTau.track(j);
+ const xAOD::TrackParticle *TauJetTrack = pTau.track(j)->track();
const Trk::Perigee* perigee = m_trackToVertexTool->perigeeAtVertex(*TauJetTrack, (*pTau.vertexLink())->position());
// Declare TrackSummary info
@@ -169,8 +169,11 @@ StatusCode TauConversionTagger::execute(xAOD::TauJet& pTau) {
}
ATH_MSG_VERBOSE("Is tau track a conversion? : " << m_TrkIsConv);
- if (m_TrkIsConv && !pTau.trackFlag(TauJetTrack, xAOD::TauJetParameters::isConversion))
- pTau.setTrackFlag(TauJetTrack, xAOD::TauJetParameters::isConversion, true);
+ // if (m_TrkIsConv && !pTau.trackFlag(TauJetTrack, xAOD::TauJetParameters::isConversion))
+ // pTau.setTrackFlag(TauJetTrack, xAOD::TauJetParameters::isConversion, true);
+ xAOD::TauTrack* tauTrack = pTau.trackNonConst(j);
+ if(m_TrkIsConv && !tauTrack->flag(xAOD::TauJetParameters::isConversionOld))
+ tauTrack->setFlag( xAOD::TauJetParameters::isConversionOld, true);
}
return StatusCode::SUCCESS;
diff --git a/Reconstruction/tauRecTools/src/TauElectronVetoVariables.cxx b/Reconstruction/tauRecTools/src/TauElectronVetoVariables.cxx
index 60edf799ae43..e5d949ded6a6 100644
--- a/Reconstruction/tauRecTools/src/TauElectronVetoVariables.cxx
+++ b/Reconstruction/tauRecTools/src/TauElectronVetoVariables.cxx
@@ -166,7 +166,7 @@ StatusCode TauElectronVetoVariables::execute(xAOD::TauJet& pTau)
// get the extrapolation into the calo
const Trk::CaloExtension* caloExtension = 0;
- if( !m_caloExtensionTool->caloExtension(*pTau.track(0),caloExtension) || caloExtension->caloLayerIntersections().empty() ){
+ if( !m_caloExtensionTool->caloExtension(*pTau.track(0)->track(),caloExtension) || caloExtension->caloLayerIntersections().empty() ){
ATH_MSG_WARNING("extrapolation of leading track to calo surfaces failed " );
return StatusCode::SUCCESS;
}
@@ -340,23 +340,25 @@ StatusCode TauElectronVetoVariables::execute(xAOD::TauJet& pTau)
uint8_t TRTHTOutliers;
uint8_t TRTHits;
uint8_t TRTOutliers;
+
+ const xAOD::TrackParticle* leadTrack = pTau.track(0)->track();
- if ( !pTau.track(0)->summaryValue( TRTHits, xAOD::SummaryType::numberOfTRTHits ) )
+ if ( !leadTrack->summaryValue( TRTHits, xAOD::SummaryType::numberOfTRTHits ) )
{
ATH_MSG_DEBUG("retrieval of track summary value failed. Not filling electron veto variables for this one prong candidate");
return StatusCode::SUCCESS;
}
- if ( !pTau.track(0)->summaryValue( TRTHTHits, xAOD::SummaryType::numberOfTRTHighThresholdHits ) )
+ if ( !leadTrack->summaryValue( TRTHTHits, xAOD::SummaryType::numberOfTRTHighThresholdHits ) )
{
ATH_MSG_DEBUG("retrieval of track summary value failed. Not filling electron veto variables for this one prong candidate");
return StatusCode::SUCCESS;
}
- if ( !pTau.track(0)->summaryValue( TRTOutliers, xAOD::SummaryType::numberOfTRTOutliers ) )
+ if ( !leadTrack->summaryValue( TRTOutliers, xAOD::SummaryType::numberOfTRTOutliers ) )
{
ATH_MSG_DEBUG("retrieval of track summary value failed. Not filling electron veto variables for this one prong candidate");
return StatusCode::SUCCESS;
}
- if ( !pTau.track(0)->summaryValue( TRTHTOutliers, xAOD::SummaryType::numberOfTRTHighThresholdOutliers ) )
+ if ( !leadTrack->summaryValue( TRTHTOutliers, xAOD::SummaryType::numberOfTRTHighThresholdOutliers ) )
{
ATH_MSG_DEBUG("retrieval of track summary value failed. Not filling electron veto variables for this one prong candidate");
return StatusCode::SUCCESS;
diff --git a/Reconstruction/tauRecTools/src/TauPi0ClusterScaler.cxx b/Reconstruction/tauRecTools/src/TauPi0ClusterScaler.cxx
index 0a9a9de73bcf..02bc803bf643 100644
--- a/Reconstruction/tauRecTools/src/TauPi0ClusterScaler.cxx
+++ b/Reconstruction/tauRecTools/src/TauPi0ClusterScaler.cxx
@@ -37,6 +37,7 @@ TauPi0ClusterScaler::TauPi0ClusterScaler( const string& name ) :
declareProperty("ParticleCaloExtensionTool", m_caloExtensionTool);
declareProperty("ChargedPFOContainerName", m_chargedPFOContainerName);
declareProperty("runOnAOD", m_AODmode=false);
+ declareProperty("storeCaloSamplings", m_storeCaloSamplings=true);
}
//-------------------------------------------------------------------------
@@ -53,10 +54,6 @@ StatusCode TauPi0ClusterScaler::initialize()
// retrieve tools
ATH_MSG_DEBUG( "Retrieving tools" );
CHECK( m_caloExtensionTool.retrieve() );
- // Create vector with default values
- for (int layer = 0 ; layer != CaloCell_ID::FCAL0; ++layer) {
- m_defaultValues.push_back(-10.);
- }
return StatusCode::SUCCESS;
}
@@ -77,7 +74,19 @@ StatusCode TauPi0ClusterScaler::eventInitialize() {
CHECK( evtStore()->retrieve(m_chargedPFOContainer, m_chargedPFOContainerName) );
CHECK( evtStore()->retrieve( m_chargedPFOAuxStore, m_chargedPFOContainerName + "Aux." ) );
}
- return StatusCode::SUCCESS;
+
+ //Check if TauTracks have sampling decorations
+ const xAOD::TauTrackContainer* tauTracks = 0;
+ ATH_CHECK( evtStore()->retrieve(tauTracks, "TauTracks") );
+ for( const xAOD::TauTrack* trk : *tauTracks ){
+ if( trk->isAvailable<float>("CaloSamplingEtaEM") ) {
+ m_caloSamplingsStored = true;
+ break;
+ }
+ m_caloSamplingsStored = false;
+ }
+
+ return StatusCode::SUCCESS;
}
@@ -93,23 +102,11 @@ StatusCode TauPi0ClusterScaler::execute(xAOD::TauJet& pTau)
// Clear vector of cell-based charged PFO Links. Required when rerunning on xAOD level.
pTau.clearProtoChargedPFOLinks();
- //---------------------------------------------------------------------
- // only run on 1-5 prong taus
- //---------------------------------------------------------------------
- if (pTau.nTracks() == 0 || pTau.nTracks() >5 ) {
- return StatusCode::SUCCESS;
- }
- ATH_MSG_DEBUG("ClusterScaler: new tau. \tpt = " << pTau.pt() << "\teta = " << pTau.eta() << "\tphi = " << pTau.phi() << "\tnprongs = " << pTau.nTracks());
-
+ //incase tau is rejected, still fill vector of samplings
+ //so that TauTracks are consistently decorated
//---------------------------------------------------------------------
// get tau tracks
//---------------------------------------------------------------------
- vector<const xAOD::TrackParticle*> tracks;
- for(unsigned iTrack = 0; iTrack<pTau.nTracks();++iTrack){
- const xAOD::TrackParticle* track = pTau.track(iTrack);
- tracks.push_back(track);
- }
-
//---------------------------------------------------------------------
// prepare extrapolation of tracks to calo layers
//---------------------------------------------------------------------
@@ -118,16 +115,54 @@ StatusCode TauPi0ClusterScaler::execute(xAOD::TauJet& pTau)
// which is called once per event (and not once per tau)
m_tracksEtaAtSampling.clear();
m_tracksPhiAtSampling.clear();
- m_extrapolatedSamplings.clear();
- // Fill with default values
- for(int layer = 0 ; layer != CaloCell_ID::FCAL0; ++layer) {
- m_extrapolatedSamplings.push_back(false);
- }
- for(unsigned iTrack = 0; iTrack<tracks.size();++iTrack){
- m_tracksEtaAtSampling.push_back( m_defaultValues );
- m_tracksPhiAtSampling.push_back( m_defaultValues );
+ vector<const xAOD::TauTrack*> tracks;
+ for(xAOD::TauTrack* track : pTau.allTracks()){
+
+ float extrap_eta_EM, extrap_phi_EM, extrap_eta_Had, extrap_phi_Had;
+
+ if(m_caloSamplingsStored==false) {
+ //no decorations, so do calo extrapolations
+ int sampling_EM, sampling_Had;
+ if(fabs(track->eta())<1.45) sampling_EM = CaloSampling::EMB2;//2
+ else sampling_EM = CaloSampling::EME2;//6
+ if(fabs(track->eta())<1.0) sampling_Had = CaloSampling::TileBar1;
+ else if(fabs(track->eta())<1.5) sampling_Had = CaloSampling::TileExt1;
+ else sampling_Had = CaloSampling::HEC1;
+
+ getExtrapolatedPositions(track, sampling_EM, extrap_eta_EM, extrap_phi_EM);
+ getExtrapolatedPositions(track, sampling_Had, extrap_eta_Had, extrap_phi_Had);
+ if(m_storeCaloSamplings) {
+ //store the values in tracks
+ track->setDetail(xAOD::TauJetParameters::CaloSamplingEtaEM, extrap_eta_EM);
+ track->setDetail(xAOD::TauJetParameters::CaloSamplingPhiEM, extrap_phi_EM);
+ track->setDetail(xAOD::TauJetParameters::CaloSamplingEtaHad, extrap_eta_Had);
+ track->setDetail(xAOD::TauJetParameters::CaloSamplingPhiHad, extrap_phi_Had);
+ }
+ }
+ else {
+ //no need to perform calo extrapolation
+ track->detail(xAOD::TauJetParameters::CaloSamplingEtaEM, extrap_eta_EM );
+ track->detail(xAOD::TauJetParameters::CaloSamplingPhiEM, extrap_phi_EM );
+ track->detail(xAOD::TauJetParameters::CaloSamplingEtaHad, extrap_eta_Had);
+ track->detail(xAOD::TauJetParameters::CaloSamplingPhiHad, extrap_phi_Had);
+ }
+ if(track->flag(xAOD::TauJetParameters::classifiedCharged)) {
+ //now fill the extrapolated values in the v<v<float> >
+ tracks.push_back(track);
+ m_tracksEtaAtSampling.push_back({extrap_eta_EM, extrap_eta_Had});
+ m_tracksPhiAtSampling.push_back({extrap_phi_EM, extrap_phi_Had});
+ }
}
+
+ //---------------------------------------------------------------------
+ // only run on 1-5 prong taus
+ //---------------------------------------------------------------------
+ if (pTau.nTracks() == 0 || pTau.nTracks() >5 ) {
+ return StatusCode::SUCCESS;
+ }
+ ATH_MSG_DEBUG("ClusterScaler: new tau. \tpt = " << pTau.pt() << "\teta = " << pTau.eta() << "\tphi = " << pTau.phi() << "\tnprongs = " << pTau.nTracks());
+
//---------------------------------------------------------------------
// get energy in HCal associated to the different tracks
//---------------------------------------------------------------------
@@ -138,10 +173,10 @@ StatusCode TauPi0ClusterScaler::execute(xAOD::TauJet& pTau)
// Create charged PFOs
//---------------------------------------------------------------------
for(unsigned iTrack = 0; iTrack<tracks.size();++iTrack){
- const xAOD::TrackParticle* track = tracks.at(iTrack);
+ const xAOD::TrackParticle* track = tracks.at(iTrack)->track();
xAOD::PFO* chargedPFO = new xAOD::PFO();
m_chargedPFOContainer->push_back(chargedPFO);
- ElementLink<xAOD::TrackParticleContainer> myTrackLink = pTau.trackLinks().at(iTrack);
+ ElementLink<xAOD::TrackParticleContainer> myTrackLink = pTau.trackNonConst(iTrack)->trackLinks()[0];
if(!chargedPFO->setTrackLink(myTrackLink)) ATH_MSG_WARNING("Could not add Track to PFO");
chargedPFO->setCharge(track->charge());
chargedPFO->setP4(track->pt(),track->eta(),track->phi(),track->m());
@@ -169,19 +204,12 @@ StatusCode TauPi0ClusterScaler::execute(xAOD::TauJet& pTau)
unsigned nNeutPFO = pTau.nProtoNeutralPFOs();
for(unsigned int iNeutPFO=0; iNeutPFO<nNeutPFO; iNeutPFO++, thisCluster++) {
const xAOD::PFO* curNeutPFO_const = pTau.protoNeutralPFO( iNeutPFO );
- int maxESample = 2;
- if (fabs(curNeutPFO_const->eta()) > 1.45) maxESample = 6;
- // check if tracks have been extrapolated to this sampling. Do so if this is not the case
- if(m_extrapolatedSamplings.at(maxESample)==false){
- this->getExtrapolatedPositions(tracks,maxESample);
- m_extrapolatedSamplings.at(maxESample)=true;
- }
for(unsigned iTrack = 0; iTrack<tracks.size();++iTrack){
if(EestInEcal.at(iTrack)<0.001) continue; // No need to subtract
TLorentzVector extTrack;
- extTrack.SetPtEtaPhiE(tracks.at(iTrack)->pt(), m_tracksEtaAtSampling.at(iTrack).at(maxESample), m_tracksPhiAtSampling.at(iTrack).at(maxESample), tracks.at(iTrack)->e());
+ extTrack.SetPtEtaPhiE(tracks.at(iTrack)->pt(), m_tracksEtaAtSampling.at(iTrack).at(0), m_tracksPhiAtSampling.at(iTrack).at(0), tracks.at(iTrack)->e());
// get eta/phi distance of cell to track
double deltaEta = extTrack.Eta()-curNeutPFO_const->eta();
double deltaPhi = TVector2::Phi_mpi_pi( extTrack.Phi() - curNeutPFO_const->phi());;
@@ -252,35 +280,33 @@ StatusCode TauPi0ClusterScaler::execute(xAOD::TauJet& pTau)
}
void TauPi0ClusterScaler::getExtrapolatedPositions(
- vector<const xAOD::TrackParticle*> tracks,
- int sampling)
+ const xAOD::TauTrack* track,
+ int sampling, float& extrap_eta, float& extrap_phi)
{
- for (unsigned iTrack = 0 ; iTrack < tracks.size(); ++iTrack ) {
- // get the extrapolation into the calo
- ATH_MSG_DEBUG( "Try extrapolation of track with pt = " << tracks.at(iTrack)->pt() << ", eta " << tracks.at(iTrack)->eta() << ", phi" << tracks.at(iTrack)->phi()
- << " to layer " << sampling);
- const Trk::CaloExtension* caloExtension = 0;
- if (!m_caloExtensionTool->caloExtension(*tracks.at(iTrack),caloExtension)
- || caloExtension->caloLayerIntersections().size() < (unsigned int)(sampling+1)) return;
-
- // store if track extrapolation successful, only use entry layer
- const Trk::TrackParameters* param_at_calo = caloExtension->caloLayerIntersections().at(sampling);
- if (param_at_calo) {
- ATH_MSG_DEBUG( "Extrapolated track with eta=" << tracks.at(iTrack)->eta()
- << " phi="<<tracks.at(iTrack)->phi()
- << " to eta=" << param_at_calo->position().eta()
- << " phi="<<param_at_calo->position().phi()
- );
- m_tracksEtaAtSampling.at(iTrack).at(sampling)=param_at_calo->position().eta();
- m_tracksPhiAtSampling.at(iTrack).at(sampling)=param_at_calo->position().phi();
- }
- else ATH_MSG_DEBUG("Could not extrapolate track with pt = " << tracks.at(iTrack)->pt() << ", eta " << tracks.at(iTrack)->eta() << ", phi" << tracks.at(iTrack)->phi()
- << " to layer " << sampling);
- }
+ extrap_eta=-10;
+ extrap_phi=-10;
+ ATH_MSG_DEBUG( "Try extrapolation of track with pt = " << track->pt() << ", eta " << track->eta() << ", phi" << track->phi()
+ << " to layer " << sampling);
+ const Trk::CaloExtension* caloExtension = 0;
+ if (!m_caloExtensionTool->caloExtension(*track->track(),caloExtension)
+ || caloExtension->caloLayerIntersections().size() < (unsigned int)(sampling+1)) return;
+ // store if track extrapolation successful, only use entry layer
+ const Trk::TrackParameters* param_at_calo = caloExtension->caloLayerIntersections().at(sampling);
+ if (param_at_calo) {
+ ATH_MSG_DEBUG( "Extrapolated track with eta=" << track->eta()
+ << " phi="<<track->phi()
+ << " to eta=" << param_at_calo->position().eta()
+ << " phi="<<param_at_calo->position().phi()
+ );
+ extrap_eta=param_at_calo->position().eta();
+ extrap_phi=param_at_calo->position().phi();
+ }
+ else ATH_MSG_DEBUG("Could not extrapolate track with pt = " << track->pt() << ", eta " << track->eta() << ", phi" << track->phi()
+ << " to layer " << sampling);
}
vector<double> TauPi0ClusterScaler::getEstEcalEnergy(
- vector<const xAOD::TrackParticle*> tracks,
+ vector<const xAOD::TauTrack*> tracks,
const xAOD::TauJet& pTau,
vector<vector<ElementLink<xAOD::IParticleContainer> > >& hadPFOLinks)
{
@@ -310,28 +336,16 @@ vector<double> TauPi0ClusterScaler::getEstEcalEnergy(
"\t deltaEtaToTau = " << deltaEtaToTau << "\t deltaPhiToTau = " << deltaPhiToTau << "\t deltaRToTau_squared = " << deltaRToTau_squared );
*/
- // Decide which sampling to extrapolate to. Choose Hcal samplings that usually contain most energy (|eta| dependent)
- int sample = 13; // |eta| <= 1.0
- if ( fabs(curHadPFO->eta())>1.5 ) sample = 9; // 1.5 < |eta|
- else if( fabs(curHadPFO->eta())>1.0 ) sample = 19; // 1.0 < |eta| <= 1.5
-
- // check if tracks have been extrapolated to this sampling. Do so if this is not the case
- if(m_extrapolatedSamplings.at(sample)==false){
- this->getExtrapolatedPositions(tracks,sample);
- ATH_MSG_DEBUG("Extrapolate to layer " << sample << "\teta = "
- << m_tracksEtaAtSampling.at(0).at(sample) << "\t phi = " << m_tracksPhiAtSampling.at(0).at(sample) );
- m_extrapolatedSamplings.at(sample)=true;
- }
// Assign PFO to track
int closestTrack = -1;
double dRToClosestTrack_squared = 0.16; // XXX can be tuned later
for(unsigned iTrack = 0; iTrack<tracks.size();++iTrack){
- const xAOD::TrackParticle* track = tracks.at(iTrack);
+ const xAOD::TrackParticle* track = tracks.at(iTrack)->track();
// set extrapolated track direction
TLorentzVector extTrack;
- extTrack.SetPtEtaPhiE(track->pt(), m_tracksEtaAtSampling.at(iTrack).at(sample), m_tracksPhiAtSampling.at(iTrack).at(sample), track->e());
+ extTrack.SetPtEtaPhiE(track->pt(), m_tracksEtaAtSampling.at(iTrack).at(1), m_tracksPhiAtSampling.at(iTrack).at(1), track->e());
// get eta/phi distance of cell to track
double deltaEta = extTrack.Eta()-curHadPFO->eta();
diff --git a/Reconstruction/tauRecTools/src/TauPi0ClusterScaler.h b/Reconstruction/tauRecTools/src/TauPi0ClusterScaler.h
index 2cc3ed596015..ac68d0225a3f 100644
--- a/Reconstruction/tauRecTools/src/TauPi0ClusterScaler.h
+++ b/Reconstruction/tauRecTools/src/TauPi0ClusterScaler.h
@@ -42,14 +42,13 @@ private:
ToolHandle<Trk::IParticleCaloExtensionTool> m_caloExtensionTool;
/** @brief extrapolated position of tracks and vector of bools to keep track for which samplings this has already been done */
- std::vector<std::vector<double> > m_tracksEtaAtSampling;
- std::vector<std::vector<double> > m_tracksPhiAtSampling;
- std::vector<bool> m_extrapolatedSamplings;
- std::vector<double> m_defaultValues;
+ //inner vector is size 2: EM, Had layers
+ std::vector<std::vector<float> > m_tracksEtaAtSampling;
+ std::vector<std::vector<float> > m_tracksPhiAtSampling;
/** @brief get extrapolated track position at each layer */
- void getExtrapolatedPositions( std::vector<const xAOD::TrackParticle*>,
- int sampling);
+ void getExtrapolatedPositions( const xAOD::TauTrack*,
+ int sampling, float& eta, float& phi);
/** @brief new charged PFO container and name */
xAOD::PFOContainer* m_chargedPFOContainer;
@@ -58,10 +57,12 @@ private:
/** @brief run on AOD */
bool m_AODmode;
+ bool m_storeCaloSamplings;//configurable to store whether you want calo samplings on TauTracks
+ bool m_caloSamplingsStored=false;//check whether TauJets have sampling decorations or not
/** @brief estimate energy deposited in Ecal by each charged pion */
std::vector<double> getEstEcalEnergy(
- std::vector<const xAOD::TrackParticle*> tracks,
+ std::vector<const xAOD::TauTrack*> tracks,
const xAOD::TauJet& pTau,
std::vector<std::vector<ElementLink<xAOD::IParticleContainer> > >& hadPFOLinks);
diff --git a/Reconstruction/tauRecTools/src/TauPi0CreateROI.cxx b/Reconstruction/tauRecTools/src/TauPi0CreateROI.cxx
index 763b2d9c802e..0e73063fdbc5 100644
--- a/Reconstruction/tauRecTools/src/TauPi0CreateROI.cxx
+++ b/Reconstruction/tauRecTools/src/TauPi0CreateROI.cxx
@@ -166,7 +166,7 @@ void TauPi0CreateROI::storeCell(const CaloCell* cell){
if(isNewCell){
CaloCell* copyCell = cell->clone();
- m_pPi0CellContainer->push_back(const_cast<CaloCell*> (copyCell));
+ m_pPi0CellContainer->push_back(copyCell);
m_addedCellsMap[cellHash] = copyCell;
}
}
diff --git a/Reconstruction/tauRecTools/src/TauPi0Selector.cxx b/Reconstruction/tauRecTools/src/TauPi0Selector.cxx
index 67fa5d2e2613..a0c9609bbc6d 100644
--- a/Reconstruction/tauRecTools/src/TauPi0Selector.cxx
+++ b/Reconstruction/tauRecTools/src/TauPi0Selector.cxx
@@ -51,7 +51,7 @@ StatusCode TauPi0Selector::execute(xAOD::TauJet& pTau)
// Clear vector of cell-based pi0 PFO Links. Required when rerunning on xAOD level.
pTau.clearProtoPi0PFOLinks();
// Set proto decay mode to "not set". Will be overwritten for taus with 1-5 tracks
- pTau.setPanTauDetail(xAOD::TauJetParameters::pantau_CellBasedInput_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_NotSet);
+ pTau.setPanTauDetail(xAOD::TauJetParameters::PanTau_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_NotSet);
//---------------------------------------------------------------------
// only run on 1-5 prong taus
@@ -61,7 +61,7 @@ StatusCode TauPi0Selector::execute(xAOD::TauJet& pTau)
}
// Set proto decay mode to "other". Will be overwritten for taus with 1 or 3 tracks
- pTau.setPanTauDetail(xAOD::TauJetParameters::pantau_CellBasedInput_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_Other);
+ pTau.setPanTauDetail(xAOD::TauJetParameters::PanTau_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_Other);
//---------------------------------------------------------------------
// retrieve neutral PFOs from tau. Apply selection and create links to
@@ -115,13 +115,13 @@ StatusCode TauPi0Selector::execute(xAOD::TauJet& pTau)
// pTau.setMPanTauCellBasedProto( p4.M());
if(pTau.nTracks()==1){
- if(nRecoPi0s==0) pTau.setPanTauDetail(xAOD::TauJetParameters::pantau_CellBasedInput_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_1p0n);
- else if(nRecoPi0s==1) pTau.setPanTauDetail(xAOD::TauJetParameters::pantau_CellBasedInput_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_1p1n);
- else pTau.setPanTauDetail(xAOD::TauJetParameters::pantau_CellBasedInput_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_1pXn);
+ if(nRecoPi0s==0) pTau.setPanTauDetail(xAOD::TauJetParameters::PanTau_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_1p0n);
+ else if(nRecoPi0s==1) pTau.setPanTauDetail(xAOD::TauJetParameters::PanTau_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_1p1n);
+ else pTau.setPanTauDetail(xAOD::TauJetParameters::PanTau_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_1pXn);
}
if(pTau.nTracks()==3){
- if(nRecoPi0s==0) pTau.setPanTauDetail(xAOD::TauJetParameters::pantau_CellBasedInput_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_3p0n);
- else pTau.setPanTauDetail(xAOD::TauJetParameters::pantau_CellBasedInput_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_3pXn);
+ if(nRecoPi0s==0) pTau.setPanTauDetail(xAOD::TauJetParameters::PanTau_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_3p0n);
+ else pTau.setPanTauDetail(xAOD::TauJetParameters::PanTau_DecayModeProto, xAOD::TauJetParameters::DecayMode::Mode_3pXn);
}
diff --git a/Reconstruction/tauRecTools/src/TauShotVariableHelpers.cxx b/Reconstruction/tauRecTools/src/TauShotVariableHelpers.cxx
index 3645dd3b5db9..87eeb517b977 100644
--- a/Reconstruction/tauRecTools/src/TauShotVariableHelpers.cxx
+++ b/Reconstruction/tauRecTools/src/TauShotVariableHelpers.cxx
@@ -323,10 +323,10 @@ namespace TauShotVariableHelpers {
float pt_largerWindow = 0.;
float pt_smallerWindow = 0.;
for(int iCell = 0; iCell != nCells_eta; ++iCell ){
- if(fabs(iCell-seedIndex)>largerWindow/2) continue;
+ if(abs(iCell-seedIndex)>largerWindow/2) continue;
if(shotCells.at(0).at(iCell)!=NULL) pt_largerWindow+=shotCells.at(0).at(iCell)->pt()*m_caloWeightTool->wtCell(shotCells.at(0).at(iCell));
if(shotCells.at(1).at(iCell)!=NULL) pt_largerWindow+=shotCells.at(1).at(iCell)->pt()*m_caloWeightTool->wtCell(shotCells.at(1).at(iCell));
- if(fabs(iCell-seedIndex)>smallerWindow/2) continue;
+ if(abs(iCell-seedIndex)>smallerWindow/2) continue;
if(shotCells.at(0).at(iCell)!=NULL) pt_smallerWindow+=shotCells.at(0).at(iCell)->pt()*m_caloWeightTool->wtCell(shotCells.at(0).at(iCell));
if(shotCells.at(1).at(iCell)!=NULL) pt_smallerWindow+=shotCells.at(1).at(iCell)->pt()*m_caloWeightTool->wtCell(shotCells.at(1).at(iCell));
}
@@ -344,10 +344,10 @@ namespace TauShotVariableHelpers {
float pt_largerWindow = 0.;
float pt_smallerWindow = 0.;
for(int iCell = 0; iCell != nCells_eta; ++iCell ){
- if(fabs(iCell-seedIndex)>largerWindow/2) continue;
+ if(abs(iCell-seedIndex)>largerWindow/2) continue;
if(shotCells.at(0).at(iCell)!=NULL) pt_largerWindow+=shotCells.at(0).at(iCell)->pt()*m_caloWeightTool->wtCell(shotCells.at(0).at(iCell));
if(shotCells.at(1).at(iCell)!=NULL) pt_largerWindow+=shotCells.at(1).at(iCell)->pt()*m_caloWeightTool->wtCell(shotCells.at(1).at(iCell));
- if(fabs(iCell-seedIndex)>smallerWindow/2) continue;
+ if(abs(iCell-seedIndex)>smallerWindow/2) continue;
if(shotCells.at(0).at(iCell)!=NULL) pt_smallerWindow+=shotCells.at(0).at(iCell)->pt()*m_caloWeightTool->wtCell(shotCells.at(0).at(iCell));
if(shotCells.at(1).at(iCell)!=NULL) pt_smallerWindow+=shotCells.at(1).at(iCell)->pt()*m_caloWeightTool->wtCell(shotCells.at(1).at(iCell));
}
diff --git a/Reconstruction/tauRecTools/src/TauTrackFinder.cxx b/Reconstruction/tauRecTools/src/TauTrackFinder.cxx
index 9ab9fa9621f3..d3bd289915d6 100644
--- a/Reconstruction/tauRecTools/src/TauTrackFinder.cxx
+++ b/Reconstruction/tauRecTools/src/TauTrackFinder.cxx
@@ -8,6 +8,7 @@
#include "xAODTau/TauJet.h"
#include "xAODTau/TauJetContainer.h"
+#include "xAODTau/TauTrackContainer.h"
#include "TauTrackFinder.h"
#include "tauRecTools/KineUtils.h"
@@ -19,6 +20,7 @@ TauTrackFinder::TauTrackFinder(const std::string& name ) :
m_caloExtensionTool("Trk::ParticleCaloExtensionTool/ParticleCaloExtensionTool"),
m_trackSelectorTool_tau(""),
m_trackToVertexTool("Reco::TrackToVertex"),
+ m_trackSelectorTool_tau_xAOD(""),
m_z0maxDelta(1000),
m_applyZ0cut(false),
m_storeInOtherTrks(true),
@@ -28,12 +30,15 @@ TauTrackFinder::TauTrackFinder(const std::string& name ) :
declareProperty("MaxJetDrTau", m_maxJetDr_tau = 0.2);
declareProperty("MaxJetDrWide", m_maxJetDr_wide = 0.4);
declareProperty("TrackSelectorToolTau", m_trackSelectorTool_tau);
+ declareProperty("TrackSelectorToolTauxAOD", m_trackSelectorTool_tau_xAOD);
declareProperty("TrackParticleContainer", m_inputTrackParticleContainerName = "InDetTrackParticles");
+ declareProperty("TrackParticleContainer", m_inputTauTrackContainerName = "TauTracks");
declareProperty("ParticleCaloExtensionTool", m_caloExtensionTool );
declareProperty("TrackToVertexTool",m_trackToVertexTool);
declareProperty("maxDeltaZ0wrtLeadTrk", m_z0maxDelta);
declareProperty("removeTracksOutsideZ0wrtLeadTrk", m_applyZ0cut);
declareProperty("StoreRemovedCoreWideTracksInOtherTracks", m_storeInOtherTrks = true);
+ declareProperty("removeDuplicateCoreTracks", m_removeDuplicateCoreTracks = true);
declareProperty("BypassSelector", m_bypassSelector = false);
declareProperty("BypassExtrapolator", m_bypassExtrapolator = false);
}
@@ -46,6 +51,7 @@ StatusCode TauTrackFinder::initialize() {
// Get the TrackSelectorTool
if (!retrieveTool(m_trackSelectorTool_tau)) return StatusCode::FAILURE;
+ //if (!retrieveTool(m_trackSelectorTool_tau_xAOD)) return StatusCode::FAILURE;
// Get the TJVA
if (!retrieveTool(m_trackToVertexTool)) return StatusCode::FAILURE;
@@ -77,10 +83,14 @@ StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
StatusCode sc;
// get the track particle container from StoreGate
const xAOD::TrackParticleContainer* trackParticleCont = 0;
+ xAOD::TauTrackContainer* tauTrackCon = 0;
//for tau trigger
bool inTrigger = tauEventData()->inTrigger();
- if (inTrigger) sc = tauEventData()->getObject( "TrackContainer", trackParticleCont );
+ if (inTrigger) {
+ ATH_CHECK(tauEventData()->getObject( "TrackContainer", trackParticleCont ));
+ ATH_CHECK(tauEventData()->getObject( "TauTrackContainer", tauTrackCon ));
+ }
if( !inTrigger || !trackParticleCont || sc.isFailure() ) {
// try standard
@@ -90,6 +100,14 @@ StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
}
}
+ if( !inTrigger || !tauTrackCon || sc.isFailure() ) {
+ // try standard
+ if (!openContainer(tauTrackCon, m_inputTauTrackContainerName)) {
+ if (!inTrigger) return StatusCode::FAILURE; // in offline we don't reconstruct tau candidates without having a track container
+ else return StatusCode::SUCCESS; // we don't want stop trigger if there is no track container
+ }
+ }
+
std::vector<const xAOD::TrackParticle*> tauTracks;
std::vector<const xAOD::TrackParticle*> wideTracks;
std::vector<const xAOD::TrackParticle*> otherTracks;
@@ -106,12 +124,6 @@ StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
this->removeOffsideTracksWrtLeadTrk(tauTracks, wideTracks, otherTracks, pVertex, m_z0maxDelta);
}
- //clear tracks first (needed for "rerun mode" if called on AODs again)
- pTau.clearTrackLinks();
- pTau.clearWideTrackLinks();
- pTau.clearOtherTrackLinks();
-
- bool alreadyUsed = false;
//check for tracks used in multiple taus
xAOD::TauJetContainer* pContainer = tauEventData()->xAODTauContainer;
if(pContainer==0){
@@ -122,34 +134,25 @@ StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
return StatusCode::FAILURE;
}
-
- for (std::vector<const xAOD::TrackParticle*>::iterator track_it = tauTracks.begin(); track_it != tauTracks.end() ;)
- {
- alreadyUsed = false;
-
- //loop over all up-to-now reconstructed tau candidates
- xAOD::TauJetContainer::const_iterator tau_it = pContainer->begin();
- xAOD::TauJetContainer::const_iterator tau_end = pContainer->end();
- for( ; tau_it != tau_end; tau_it++ )
- {
- if( (*tau_it) == &pTau ) continue;
- //loop over core tracks
- for (unsigned int j = 0; j < (*tau_it)->nTracks(); ++j)
- {
- if ((*track_it) == (*tau_it)->track(j))
- {
- ATH_MSG_WARNING("Found a track that is identical with a track already associated to another tau. Will not add this track to more than one tau candidate");
- alreadyUsed = true;
- }
- }
- }
- //if this track has already been used by another tau, don't associate it to this new one
- if (alreadyUsed) track_it = tauTracks.erase(track_it);
- else ++track_it;
+ if(m_removeDuplicateCoreTracks){
+ bool alreadyUsed = false;
+ for (std::vector<const xAOD::TrackParticle*>::iterator track_it = tauTracks.begin(); track_it != tauTracks.end() ;)
+ {
+ alreadyUsed = false;
+
+ //loop over all up-to-now core tracks
+ for( const xAOD::TauTrack* tau_trk : (*tauTrackCon) ) {
+ if(! tau_trk->flagWithMask( (1<<xAOD::TauJetParameters::TauTrackFlag::coreTrack) | (1<<xAOD::TauJetParameters::TauTrackFlag::passTrkSelector))) continue; //originally it was coreTrack&passTrkSelector
+ if( (*track_it) == tau_trk->track()) alreadyUsed = true;
+ }
+ //if this track has already been used by another tau, don't associate it to this new one
+ if(alreadyUsed) ATH_MSG_WARNING( "Found Already Used track new, now removing: " << *track_it );
+ if (alreadyUsed) track_it = tauTracks.erase(track_it);
+ else ++track_it;
+ }
}
-
// associated track to tau candidate and calculate charge
float charge = 0;
for (unsigned int i = 0; i < tauTracks.size(); ++i) {
@@ -160,9 +163,24 @@ StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
<< " phi " << trackParticle->phi()
);
charge += trackParticle->charge();
+
+ xAOD::TauTrack* track = new xAOD::TauTrack();
+ tauTrackCon->push_back(track);
ElementLink<xAOD::TrackParticleContainer> linkToTrackParticle;
linkToTrackParticle.toContainedElement(*trackParticleCont, trackParticle);
- pTau.addTrackLink(linkToTrackParticle);
+ track->addTrackLink(linkToTrackParticle);
+ track->setP4(trackParticle->pt(), trackParticle->eta(), trackParticle->phi(), trackParticle->m());
+ //track->setCharge(track->charge());
+ track->setFlag(xAOD::TauJetParameters::TauTrackFlag::coreTrack, true);
+ track->setFlag(xAOD::TauJetParameters::TauTrackFlag::passTrkSelector, true);
+ // in case TrackClassifier is not run, still get sensible results
+ track->setFlag(xAOD::TauJetParameters::TauTrackFlag::classifiedCharged, true);
+ track->setFlag(xAOD::TauJetParameters::TauTrackFlag::unclassified, true);
+ //track->setFlag(xAOD::TauJetParameters::TauTrackFlag::passTrkSelectionTight, m_trackSelectorTool_tau_xAOD->accept(trackParticle));
+ ElementLink<xAOD::TauTrackContainer> linkToTauTrack;
+ linkToTauTrack.toContainedElement(*tauTrackCon, track);
+ pTau.addTauTrackLink(linkToTauTrack);
+
ATH_MSG_VERBOSE(name() << " added core track nr: " << i
<< " eta " << pTau.track(i)->eta()
<< " phi " << pTau.track(i)->phi()
@@ -182,13 +200,24 @@ StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
<< " eta " << trackParticle->eta()
<< " phi " << trackParticle->phi()
);
+
+ xAOD::TauTrack* track = new xAOD::TauTrack();
+ tauTrackCon->push_back(track);
ElementLink<xAOD::TrackParticleContainer> linkToTrackParticle;
linkToTrackParticle.toContainedElement(*trackParticleCont, trackParticle);
- pTau.addWideTrackLink(linkToTrackParticle);
- ATH_MSG_VERBOSE(name() << " added wide track nr: " << i
- << " eta " << pTau.wideTrack(i)->eta()
- << " phi " << pTau.wideTrack(i)->phi()
- );
+ track->addTrackLink(linkToTrackParticle);
+ track->setP4(trackParticle->pt(), trackParticle->eta(), trackParticle->phi(), trackParticle->m());
+ //track->setCharge(track->charge());
+ track->setFlag(xAOD::TauJetParameters::TauTrackFlag::wideTrack, true);
+ track->setFlag(xAOD::TauJetParameters::TauTrackFlag::passTrkSelector, true);
+ // in case TrackClassifier is not run, still get sensible results
+ track->setFlag(xAOD::TauJetParameters::TauTrackFlag::classifiedIsolation, true); // for sake of trigger, reset in TauTrackClassifier
+ track->setFlag(xAOD::TauJetParameters::TauTrackFlag::unclassified, true);
+ //track->setFlag(xAOD::TauJetParameters::TauTrackFlag::passTrkSelectionTight, m_trackSelectorTool_tau_xAOD->accept(trackParticle));
+ ElementLink<xAOD::TauTrackContainer> linkToTauTrack;
+ linkToTauTrack.toContainedElement(*tauTrackCon, track);
+ pTau.addTauTrackLink(linkToTauTrack);
+
}
/// was
@@ -201,13 +230,24 @@ StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
<< " eta " << trackParticle->eta()
<< " phi " << trackParticle->phi()
);
- ElementLink<xAOD::TrackParticleContainer> linkToTrackParticle;
- linkToTrackParticle.toContainedElement(*trackParticleCont, trackParticle);
- pTau.addOtherTrackLink(linkToTrackParticle);
- ATH_MSG_VERBOSE(name() << " added other track nr: " << i
- << " eta " << pTau.otherTrack(i)->eta()
- << " phi " << pTau.otherTrack(i)->phi()
- );
+
+ // bool accepted=m_trackSelectorTool_tau_xAOD->accept(trackParticle);
+ // if(accepted){
+ xAOD::TauTrack* track = new xAOD::TauTrack();
+ tauTrackCon->push_back(track);
+ ElementLink<xAOD::TrackParticleContainer> linkToTrackParticle;
+ linkToTrackParticle.toContainedElement(*trackParticleCont, trackParticle);
+ track->addTrackLink(linkToTrackParticle);
+ track->setP4(trackParticle->pt(), trackParticle->eta(), trackParticle->phi(), trackParticle->m());
+ float dR = track->p4().DeltaR(pTau.p4());
+ if(dR<=0.2) track->setFlag(xAOD::TauJetParameters::TauTrackFlag::coreTrack, true);
+ else track->setFlag(xAOD::TauJetParameters::TauTrackFlag::wideTrack, true);
+ track->setFlag(xAOD::TauJetParameters::TauTrackFlag::unclassified, true);
+ // track->setFlag(xAOD::TauJetParameters::TauTrackFlag::passTrkSelectionTight, accepted);
+ ElementLink<xAOD::TauTrackContainer> linkToTauTrack;
+ linkToTauTrack.toContainedElement(*tauTrackCon, track);
+ pTau.addTauTrackLink(linkToTauTrack);
+ // }
}
@@ -287,10 +327,11 @@ StatusCode TauTrackFinder::extrapolateToCaloSurface(xAOD::TauJet& pTau) {
Trk::TrackParametersIdHelper parsIdHelper;
- for (unsigned int itr = 0; itr < 10 && itr < pTau.nTracks(); ++itr) {
-
- const xAOD::TrackParticle *orgTrack = pTau.track(itr);
-
+ // for (unsigned int itr = 0; itr < 10 && itr < pTau.nAllTracks(); ++itr) {
+
+ for( xAOD::TauTrack* tauTrack : pTau.allTracks() ) {
+ const xAOD::TrackParticle *orgTrack = tauTrack->track();
+
if( !orgTrack ) continue;
// get the extrapolation into the calo
@@ -306,8 +347,8 @@ StatusCode TauTrackFinder::extrapolateToCaloSurface(xAOD::TauJet& pTau) {
CaloSampling::CaloSample sample = parsIdHelper.caloSample((*cur)->cIdentifier());
if( sample == CaloSampling::EME1 || sample == CaloSampling::EMB1 ){
- pTau.setTrackEtaStrip( itr, (*cur)->position().eta() );
- pTau.setTrackPhiStrip( itr, (*cur)->position().phi() );
+ tauTrack->setEtaStrip((*cur)->position().eta());
+ tauTrack->setPhiStrip((*cur)->position().phi());
break;
}
}
diff --git a/Reconstruction/tauRecTools/src/TauTrackFinder.h b/Reconstruction/tauRecTools/src/TauTrackFinder.h
index e6ad1425b930..2206aec17aca 100644
--- a/Reconstruction/tauRecTools/src/TauTrackFinder.h
+++ b/Reconstruction/tauRecTools/src/TauTrackFinder.h
@@ -15,6 +15,9 @@
#include "VxVertex/RecVertex.h"
+// xAOD Tracking Tool
+#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
+
namespace Trk {
class ITrackSelectorTool;
class IParticleCaloExtensionTool;
@@ -110,6 +113,7 @@ private:
std::string m_inputTauJetContainerName;
std::string m_inputTrackParticleContainerName;
std::string m_inputPrimaryVertexContainerName;
+ std::string m_inputTauTrackContainerName;
//-------------------------------------------------------------
//! tools
@@ -117,6 +121,8 @@ private:
ToolHandle< Trk::IParticleCaloExtensionTool > m_caloExtensionTool;
ToolHandle<Trk::ITrackSelectorTool> m_trackSelectorTool_tau;
ToolHandle<Reco::ITrackToVertex> m_trackToVertexTool;
+ ToolHandle<InDet::IInDetTrackSelectionTool> m_trackSelectorTool_tau_xAOD;
+
//-------------------------------------------------------------
//! Input parameters for algorithm
@@ -130,6 +136,7 @@ private:
float m_z0maxDelta;
bool m_applyZ0cut;
bool m_storeInOtherTrks;
+ bool m_removeDuplicateCoreTracks;
std::vector<float> m_vDeltaZ0coreTrks;
std::vector<float> m_vDeltaZ0wideTrks;
diff --git a/Reconstruction/tauRecTools/src/TauVertexFinder.cxx b/Reconstruction/tauRecTools/src/TauVertexFinder.cxx
index 09fbbee02024..1367033dd700 100644
--- a/Reconstruction/tauRecTools/src/TauVertexFinder.cxx
+++ b/Reconstruction/tauRecTools/src/TauVertexFinder.cxx
@@ -4,8 +4,8 @@
#include "TauVertexFinder.h"
-//#include "VxVertex/RecVertex.h"
-//#include "VxVertex/VxCandidate.h"
+#include "VxVertex/RecVertex.h"
+#include "VxVertex/VxCandidate.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODTracking/Vertex.h"
@@ -15,16 +15,18 @@
#include "xAODTau/TauJet.h"
TauVertexFinder::TauVertexFinder(const std::string& name ) :
-TauRecToolBase(name),
-m_printMissingContainerINFO(true),
-m_maxJVF(-100.),
-m_assocTracksName(""),
-m_trackVertexAssocName("")
+ TauRecToolBase(name),
+ m_printMissingContainerINFO(true),
+ m_maxJVF(-100.),
+ m_TrackSelectionToolForTJVA(""),
+ m_assocTracksName(""),
+ m_trackVertexAssocName("")
{
- declareProperty("UseTJVA", m_useTJVA=true);
- declareProperty("PrimaryVertexContainer", m_inputPrimaryVertexContainerName = "PrimaryVertices");
- declareProperty("AssociatedTracks",m_assocTracksName);
- declareProperty("TrackVertexAssociation",m_trackVertexAssocName);
+ declareProperty("UseTJVA", m_useTJVA=true);
+ declareProperty("PrimaryVertexContainer", m_inputPrimaryVertexContainerName = "PrimaryVertices");
+ declareProperty("AssociatedTracks",m_assocTracksName);
+ declareProperty("TrackVertexAssociation",m_trackVertexAssocName);
+ declareProperty("InDetTrackSelectionToolForTJVA",m_TrackSelectionToolForTJVA);
}
TauVertexFinder::~TauVertexFinder() {
@@ -32,23 +34,24 @@ TauVertexFinder::~TauVertexFinder() {
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode TauVertexFinder::initialize() {
- if (m_useTJVA) ATH_MSG_INFO("using TJVA to determine tau vertex");
- return StatusCode::SUCCESS;
+ if (m_useTJVA) ATH_MSG_INFO("using TJVA to determine tau vertex");
+ ATH_CHECK(retrieveTool(m_TrackSelectionToolForTJVA));
+ return StatusCode::SUCCESS;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode TauVertexFinder::finalize() {
- return StatusCode::SUCCESS;
+ return StatusCode::SUCCESS;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode TauVertexFinder::eventInitialize() {
- return StatusCode::SUCCESS;
+ return StatusCode::SUCCESS;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode TauVertexFinder::eventFinalize() {
- return StatusCode::SUCCESS;
+ return StatusCode::SUCCESS;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
@@ -64,107 +67,117 @@ StatusCode TauVertexFinder::execute(xAOD::TauJet& pTau) {
sc = tauEventData()->getObject("VxPrimaryCandidate", vxContainer);
if (sc.isFailure() || !vxContainer) { //not in trigger mode or no vxContainer was set by trigger
- ATH_MSG_DEBUG("no VxPrimaryCandidateContainer for trigger -> try standard way");
- if (!openContainer(vxContainer, m_inputPrimaryVertexContainerName)) {
- if (m_printMissingContainerINFO) {
- ATH_MSG_INFO(m_inputPrimaryVertexContainerName << " container not found --> skip TauVertexFinder (no further info)");
- m_printMissingContainerINFO=false;
- }
- return StatusCode::SUCCESS;
- }
-
- // find default PrimaryVertex (needed if TJVA is switched off or fails)
- // see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/VertexReselectionOnAOD
- // code adapted from
- // https://svnweb.cern.ch/trac/atlasoff/browser/Tracking/TrkEvent/VxVertex/trunk/VxVertex/PrimaryVertexSelector.h
- if (vxContainer->size()>0) {
- // simple loop through and get the primary vertex
- xAOD::VertexContainer::const_iterator vxIter = vxContainer->begin();
- xAOD::VertexContainer::const_iterator vxIterEnd = vxContainer->end();
- for ( size_t ivtx = 0; vxIter != vxIterEnd; ++vxIter, ++ivtx ){
- // the first and only primary vertex candidate is picked
- if ( (*vxIter)->vertexType() == xAOD::VxType::PriVtx){
- primaryVertex = (*vxIter);
- break;
- }
- }
- }
+ ATH_MSG_DEBUG("no VxPrimaryCandidateContainer for trigger -> try standard way");
+ if (!openContainer(vxContainer, m_inputPrimaryVertexContainerName)) {
+ if (m_printMissingContainerINFO) {
+ ATH_MSG_INFO(m_inputPrimaryVertexContainerName << " container not found --> skip TauVertexFinder (no further info)");
+ m_printMissingContainerINFO=false;
+ }
+ return StatusCode::SUCCESS;
}
- else { // trigger mode
- // find default PrimaryVertex (highest sum pt^2)
- if (vxContainer->size()>0) primaryVertex = (*vxContainer)[0];
+
+ // find default PrimaryVertex (needed if TJVA is switched off or fails)
+ // see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/VertexReselectionOnAOD
+ // code adapted from
+ // https://svnweb.cern.ch/trac/atlasoff/browser/Tracking/TrkEvent/VxVertex/trunk/VxVertex/PrimaryVertexSelector.h
+ if (vxContainer->size()>0) {
+ // simple loop through and get the primary vertex
+ xAOD::VertexContainer::const_iterator vxIter = vxContainer->begin();
+ xAOD::VertexContainer::const_iterator vxIterEnd = vxContainer->end();
+ for ( size_t ivtx = 0; vxIter != vxIterEnd; ++vxIter, ++ivtx ){
+ // the first and only primary vertex candidate is picked
+ if ( (*vxIter)->vertexType() == xAOD::VxType::PriVtx){
+ primaryVertex = (*vxIter);
+ break;
+ }
+ }
}
+ }
+ else { // trigger mode
+ // find default PrimaryVertex (highest sum pt^2)
+ if (vxContainer->size()>0) primaryVertex = (*vxContainer)[0];
+ }
- ATH_MSG_VERBOSE("size of VxPrimaryContainer is: " << vxContainer->size() );
+ ATH_MSG_VERBOSE("size of VxPrimaryContainer is: " << vxContainer->size() );
- // associate vertex to tau
- if (primaryVertex) pTau.setVertex(vxContainer, primaryVertex);
+ // associate vertex to tau
+ if (primaryVertex) pTau.setVertex(vxContainer, primaryVertex);
- //stop here if TJVA is disabled or vertex container is empty
- if (!m_useTJVA || vxContainer->size()==0) return StatusCode::SUCCESS;
-
- // try to find new PV with TJVA
- ATH_MSG_DEBUG("TJVA enabled -> try to find new PV for the tau candidate");
-
- ElementLink<xAOD::VertexContainer> newPrimaryVertexLink = getPV_TJVA(pTau, *vxContainer );
- if (newPrimaryVertexLink.isValid()) {
- // set new primary vertex
- // will overwrite default one which was set above
- pTau.setVertexLink(newPrimaryVertexLink);
- // save highest JVF value
- pTau.setDetail(xAOD::TauJetParameters::TauJetVtxFraction,static_cast<float>(m_maxJVF));
- ATH_MSG_DEBUG("TJVA vertex found and set");
- }
- else {
- ATH_MSG_DEBUG("couldn't find new PV for TJVA");
- }
-
- return StatusCode::SUCCESS;
+ //stop here if TJVA is disabled or vertex container is empty
+ if (!m_useTJVA || vxContainer->size()==0) return StatusCode::SUCCESS;
+
+ // try to find new PV with TJVA
+ ATH_MSG_DEBUG("TJVA enabled -> try to find new PV for the tau candidate");
+
+ ElementLink<xAOD::VertexContainer> newPrimaryVertexLink = getPV_TJVA(pTau, *vxContainer );
+ if (newPrimaryVertexLink.isValid()) {
+ // set new primary vertex
+ // will overwrite default one which was set above
+ pTau.setVertexLink(newPrimaryVertexLink);
+ // save highest JVF value
+ pTau.setDetail(xAOD::TauJetParameters::TauJetVtxFraction,static_cast<float>(m_maxJVF));
+ ATH_MSG_DEBUG("TJVA vertex found and set");
+ }
+ else {
+ ATH_MSG_DEBUG("couldn't find new PV for TJVA");
+ }
+
+ return StatusCode::SUCCESS;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
ElementLink<xAOD::VertexContainer> TauVertexFinder::getPV_TJVA(const xAOD::TauJet& pTau, const xAOD::VertexContainer& vertices)
{
- const xAOD::Jet* pJetSeed = (*pTau.jetLink());
-
- // the implementation follows closely the example given in modifyJet(...) in https://svnweb.cern.ch/trac/atlasoff/browser/Reconstruction/Jet/JetMomentTools/trunk/Root/JetVertexFractionTool.cxx#15
-
- // Get the tracks associated to the jet
- std::vector<const xAOD::TrackParticle*> assocTracks;
- if (! pJetSeed->getAssociatedObjects(m_assocTracksName, assocTracks)) {
- ATH_MSG_ERROR("Could not retrieve the AssociatedObjects named \""<< m_assocTracksName <<"\" from jet");
- return ElementLink<xAOD::VertexContainer>();
- }
-
- // Get the TVA object
- const jet::TrackVertexAssociation* tva = NULL;
- if (evtStore()->retrieve(tva,m_trackVertexAssocName).isFailure()) {
- ATH_MSG_ERROR("Could not retrieve the TrackVertexAssociation from evtStore: " << m_trackVertexAssocName);
- return ElementLink<xAOD::VertexContainer>();
- }
-
- // Calculate Jet Vertex Fraction
- std::vector<float> jvf;
- jvf.resize(vertices.size());
- for (size_t iVertex = 0; iVertex < vertices.size(); ++iVertex) {
- jvf.at(iVertex) = getJetVertexFraction(vertices.at(iVertex),assocTracks,tva);
- }
+ const xAOD::Jet* pJetSeed = (*pTau.jetLink());
+ std::vector<const xAOD::TrackParticle*> tracksForTJVA;
+ const double dDeltaRMax(0.2);
+
+ // the implementation follows closely the example given in modifyJet(...) in https://svnweb.cern.ch/trac/atlasoff/browser/Reconstruction/Jet/JetMomentTools/trunk/Root/JetVertexFractionTool.cxx#15
+
+ // Get the tracks associated to the jet
+ std::vector<const xAOD::TrackParticle*> assocTracks;
+ if (! pJetSeed->getAssociatedObjects(m_assocTracksName, assocTracks)) {
+ ATH_MSG_ERROR("Could not retrieve the AssociatedObjects named \""<< m_assocTracksName <<"\" from jet");
+ return ElementLink<xAOD::VertexContainer>();
+ }
+
+ // Store tracks that meet TJVA track selection criteria and are between deltaR of 0.2 with the jet seed
+ // To be included in the TJVA calculation
+ // Maybe not as efficient as deleting unwanted tracks from assocTrack but quicker and safer for now.
+ for ( auto xTrack : assocTracks ){
+ if ( (xTrack->p4().DeltaR(pJetSeed->p4())<dDeltaRMax) && m_TrackSelectionToolForTJVA->accept(*xTrack) )
+ tracksForTJVA.push_back(xTrack);
+ }
+
+ // Get the TVA object
+ const jet::TrackVertexAssociation* tva = NULL;
+ if (evtStore()->retrieve(tva,m_trackVertexAssocName).isFailure()) {
+ ATH_MSG_ERROR("Could not retrieve the TrackVertexAssociation from evtStore: " << m_trackVertexAssocName);
+ return ElementLink<xAOD::VertexContainer>();
+ }
+
+ // Calculate Jet Vertex Fraction
+ std::vector<float> jvf;
+ jvf.resize(vertices.size());
+ for (size_t iVertex = 0; iVertex < vertices.size(); ++iVertex) {
+ jvf.at(iVertex) = getJetVertexFraction(vertices.at(iVertex),tracksForTJVA,tva);
+ }
- // Get the highest JVF vertex and store maxJVF for later use
- // Note: the official JetMomentTools/JetVertexFractionTool doesn't provide any possibility to access the JVF value, but just the vertex.
- m_maxJVF=-100.;
- size_t maxIndex = 0;
- for (size_t iVertex = 0; iVertex < jvf.size(); ++iVertex) {
- if (jvf.at(iVertex) > m_maxJVF) {
- m_maxJVF = jvf.at(iVertex);
- maxIndex = iVertex;
- }
+ // Get the highest JVF vertex and store maxJVF for later use
+ // Note: the official JetMomentTools/JetVertexFractionTool doesn't provide any possibility to access the JVF value, but just the vertex.
+ m_maxJVF=-100.;
+ size_t maxIndex = 0;
+ for (size_t iVertex = 0; iVertex < jvf.size(); ++iVertex) {
+ if (jvf.at(iVertex) > m_maxJVF) {
+ m_maxJVF = jvf.at(iVertex);
+ maxIndex = iVertex;
}
+ }
- // Set the highest JVF vertex
- ElementLink<xAOD::VertexContainer> vtxlink = ElementLink<xAOD::VertexContainer>(vertices,vertices.at(maxIndex)->index());
+ // Set the highest JVF vertex
+ ElementLink<xAOD::VertexContainer> vtxlink = ElementLink<xAOD::VertexContainer>(vertices,vertices.at(maxIndex)->index());
- return vtxlink;
+ return vtxlink;
}
// reimplementation of JetVertexFractionTool::getJetVertexFraction(const xAOD::Vertex* vertex, const std::vector<const xAOD::TrackParticle*>& tracks, const jet::TrackVertexAssociation* tva) const
@@ -172,40 +185,40 @@ ElementLink<xAOD::VertexContainer> TauVertexFinder::getPV_TJVA(const xAOD::TauJe
// see https://svnweb.cern.ch/trac/atlasoff/browser/Reconstruction/Jet/JetMomentTools/trunk/Root/JetVertexFractionTool.cxx
float TauVertexFinder::getJetVertexFraction(const xAOD::Vertex* vertex, const std::vector<const xAOD::TrackParticle*>& tracks, const jet::TrackVertexAssociation* tva) const
{
- float sumTrackPV = 0;
- float sumTrackAll = 0;
- for (size_t iTrack = 0; iTrack < tracks.size(); ++iTrack)
+ float sumTrackPV = 0;
+ float sumTrackAll = 0;
+ for (size_t iTrack = 0; iTrack < tracks.size(); ++iTrack)
{
- const xAOD::TrackParticle* track = tracks.at(iTrack);
- const xAOD::Vertex* ptvtx = tva->associatedVertex(track);
- if (ptvtx != nullptr) { // C++11 feature
- if (ptvtx->index() == vertex->index()) sumTrackPV += track->pt();
- }
- sumTrackAll += track->pt();
+ const xAOD::TrackParticle* track = tracks.at(iTrack);
+ const xAOD::Vertex* ptvtx = tva->associatedVertex(track);
+ if (ptvtx != nullptr) { // C++11 feature
+ if (ptvtx->index() == vertex->index()) sumTrackPV += track->pt();
+ }
+ sumTrackAll += track->pt();
}
- return sumTrackAll!=0 ? sumTrackPV/sumTrackAll : 0;
+ return sumTrackAll!=0 ? sumTrackPV/sumTrackAll : 0;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// Helpers
template <class T>
bool TauVertexFinder::openContainer(T* &container, std::string containerName, bool printFATAL) {
- StatusCode sc = evtStore()->retrieve(container, containerName);
- if (sc.isFailure() || !container) {
- if (printFATAL) ATH_MSG_FATAL("Container (" << containerName << ") not found in StoreGate");
- return 0;
- }
- return container;
+ StatusCode sc = evtStore()->retrieve(container, containerName);
+ if (sc.isFailure() || !container) {
+ if (printFATAL) ATH_MSG_FATAL("Container (" << containerName << ") not found in StoreGate");
+ return 0;
+ }
+ return container;
}
template <class T>
bool TauVertexFinder::retrieveTool(T & tool) {
- if (tool.retrieve().isFailure()) {
- ATH_MSG_FATAL("Failed to retrieve tool " << tool);
- return false;
- } else {
- ATH_MSG_VERBOSE("Retrieved tool " << tool);
- }
- return true;
+ if (tool.retrieve().isFailure()) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << tool);
+ return false;
+ } else {
+ ATH_MSG_VERBOSE("Retrieved tool " << tool);
+ }
+ return true;
}
diff --git a/Reconstruction/tauRecTools/src/TauVertexFinder.h b/Reconstruction/tauRecTools/src/TauVertexFinder.h
index de30101ac0ea..8aca69d0bffe 100644
--- a/Reconstruction/tauRecTools/src/TauVertexFinder.h
+++ b/Reconstruction/tauRecTools/src/TauVertexFinder.h
@@ -9,6 +9,7 @@
#include "GaudiKernel/ToolHandle.h"
#include "xAODTracking/VertexContainer.h"
#include "JetEDM/TrackVertexAssociation.h"
+#include "InDetTrackSelectionTool/InDetTrackSelectionTool.h"
/////////////////////////////////////////////////////////////////////////////
@@ -25,50 +26,51 @@
class TauVertexFinder : virtual public TauRecToolBase {
public:
- //-------------------------------------------------------------
- //! Constructor and Destructor
- //-------------------------------------------------------------
- TauVertexFinder(const std::string& name);
- ASG_TOOL_CLASS2(TauVertexFinder, TauRecToolBase, ITauToolBase);
- ~TauVertexFinder();
+ //-------------------------------------------------------------
+ //! Constructor and Destructor
+ //-------------------------------------------------------------
+ TauVertexFinder(const std::string& name);
+ ASG_TOOL_CLASS2(TauVertexFinder, TauRecToolBase, ITauToolBase);
+ ~TauVertexFinder();
- //-------------------------------------------------------------
- //! Algorithm functions
- //-------------------------------------------------------------
- virtual StatusCode initialize();
- virtual StatusCode eventInitialize();
- virtual StatusCode execute(xAOD::TauJet& pTau);
- virtual StatusCode eventFinalize();
- virtual StatusCode finalize();
+ //-------------------------------------------------------------
+ //! Algorithm functions
+ //-------------------------------------------------------------
+ virtual StatusCode initialize();
+ virtual StatusCode eventInitialize();
+ virtual StatusCode execute(xAOD::TauJet& pTau);
+ virtual StatusCode eventFinalize();
+ virtual StatusCode finalize();
- virtual void cleanup(xAOD::TauJet* ) { }
- virtual void print() const { }
+ virtual void cleanup(xAOD::TauJet* ) { }
+ virtual void print() const { }
- ElementLink<xAOD::VertexContainer> getPV_TJVA(const xAOD::TauJet& tauJet, const xAOD::VertexContainer& vertices);
+ ElementLink<xAOD::VertexContainer> getPV_TJVA(const xAOD::TauJet& tauJet, const xAOD::VertexContainer& vertices);
private:
- float getJetVertexFraction(const xAOD::Vertex* vertex, const std::vector<const xAOD::TrackParticle*>& tracks, const jet::TrackVertexAssociation* tva) const;
+ float getJetVertexFraction(const xAOD::Vertex* vertex, const std::vector<const xAOD::TrackParticle*>& tracks, const jet::TrackVertexAssociation* tva) const;
- //-------------------------------------------------------------
- //! Convenience functions to handle storegate objects
- //-------------------------------------------------------------
- template <class T>
- bool openContainer(T* &container, std::string containerName, bool printFATAL=false);
+ //-------------------------------------------------------------
+ //! Convenience functions to handle storegate objects
+ //-------------------------------------------------------------
+ template <class T>
+ bool openContainer(T* &container, std::string containerName, bool printFATAL=false);
- template <class T>
- bool retrieveTool(T &tool);
+ template <class T>
+ bool retrieveTool(T &tool);
private:
- bool m_printMissingContainerINFO;
- float m_maxJVF;
+ bool m_printMissingContainerINFO;
+ float m_maxJVF;
+ ToolHandle< InDet::IInDetTrackSelectionTool > m_TrackSelectionToolForTJVA;
- //-------------------------------------------------------------
- //! Configureables
- //-------------------------------------------------------------
- bool m_useTJVA;
- std::string m_inputPrimaryVertexContainerName;
- std::string m_assocTracksName;
- std::string m_trackVertexAssocName;
+ //-------------------------------------------------------------
+ //! Configureables
+ //-------------------------------------------------------------
+ bool m_useTJVA;
+ std::string m_inputPrimaryVertexContainerName;
+ std::string m_assocTracksName;
+ std::string m_trackVertexAssocName;
};
#endif // not TAUREC_TAUVERTEXFINDER_H
diff --git a/Reconstruction/tauRecTools/src/TauVertexVariables.cxx b/Reconstruction/tauRecTools/src/TauVertexVariables.cxx
index 5960a223fee0..07ae82fd651c 100644
--- a/Reconstruction/tauRecTools/src/TauVertexVariables.cxx
+++ b/Reconstruction/tauRecTools/src/TauVertexVariables.cxx
@@ -131,7 +131,7 @@ StatusCode TauVertexVariables::execute(xAOD::TauJet& pTau) {
if (tauEventData()->hasObject("Beamspot")) scBeam = tauEventData()->getObject("Beamspot", vxcand);
if(scBeam){
- myIPandSigma = m_trackToVertexIPEstimator->estimate(pTau.track(0), vxcand);
+ myIPandSigma = m_trackToVertexIPEstimator->estimate(pTau.track(0)->track(), vxcand);
} else {
ATH_MSG_DEBUG("No Beamspot object in tau candidate");
}
@@ -142,7 +142,7 @@ StatusCode TauVertexVariables::execute(xAOD::TauJet& pTau) {
//check if vertex has a valid type (skip if vertex has type NoVtx)
if (vxcand->vertexType() > 0){
- myIPandSigma = m_trackToVertexIPEstimator->estimate(pTau.track(0), vxcand);
+ myIPandSigma = m_trackToVertexIPEstimator->estimate(pTau.track(0)->track(), vxcand);
}
}
@@ -204,10 +204,10 @@ StatusCode TauVertexVariables::execute(xAOD::TauJet& pTau) {
std::vector<const xAOD::TrackParticle*> xaodTracks;
std::vector<const Trk::Track*> origTracks;
for (unsigned i = 0; i < pTau.nTracks(); ++i) {
- xaodTracks.push_back(pTau.track(i));
+ xaodTracks.push_back(pTau.track(i)->track());
ATH_MSG_VERBOSE("xAOD::TrackParticle " <<i<<": "<< pTau.track(i)->pt() << " " << pTau.track(i)->eta() << " " << pTau.track(i)->phi());
if (pTau.track(i)->track()) {
- origTracks.push_back(pTau.track(i)->track());
+ origTracks.push_back(pTau.track(i)->track()->track());
// for debugging
/*
diff --git a/Reconstruction/tauRecTools/src/components/tauRecTools_entries.cxx b/Reconstruction/tauRecTools/src/components/tauRecTools_entries.cxx
index 7f25d5e6416d..a635f917a838 100644
--- a/Reconstruction/tauRecTools/src/components/tauRecTools_entries.cxx
+++ b/Reconstruction/tauRecTools/src/components/tauRecTools_entries.cxx
@@ -29,6 +29,7 @@
#include "tauRecTools/TauBuilderTool.h"
#include "tauRecTools/MvaTESEvaluator.h"
#include "tauRecTools/MvaTESVariableDecorator.h"
+#include "tauRecTools/TauTrackClassifier.h"
#include "tauRecTools/CombinedP4FromRecoTaus.h"
@@ -65,4 +66,6 @@ DECLARE_TOOL_FACTORY( TauProcessorTool )
DECLARE_TOOL_FACTORY( TauBuilderTool )
DECLARE_TOOL_FACTORY( MvaTESVariableDecorator )
DECLARE_TOOL_FACTORY( MvaTESEvaluator )
+DECLARE_NAMESPACE_TOOL_FACTORY( tauRecTools, TauTrackClassifier )
+DECLARE_NAMESPACE_TOOL_FACTORY( tauRecTools, TrackMVABDT )
DECLARE_TOOL_FACTORY( CombinedP4FromRecoTaus )
diff --git a/Reconstruction/tauRecTools/tauRecTools/ITauToolBase.h b/Reconstruction/tauRecTools/tauRecTools/ITauToolBase.h
index 2125058976c2..953f17d1b1f2 100644
--- a/Reconstruction/tauRecTools/tauRecTools/ITauToolBase.h
+++ b/Reconstruction/tauRecTools/tauRecTools/ITauToolBase.h
@@ -51,8 +51,8 @@ class ITauToolBase : virtual public asg::IAsgTool
virtual void setTauEventData(TauEventData* data) = 0;
- //make virtual
- virtual StatusCode readConfig() {return StatusCode::SUCCESS; }
+ //make pure
+ virtual StatusCode readConfig() = 0;
};
diff --git a/Reconstruction/tauRecTools/tauRecTools/MvaTESVariableDecorator.h b/Reconstruction/tauRecTools/tauRecTools/MvaTESVariableDecorator.h
index 980d2bb90848..94eab92a82f3 100644
--- a/Reconstruction/tauRecTools/tauRecTools/MvaTESVariableDecorator.h
+++ b/Reconstruction/tauRecTools/tauRecTools/MvaTESVariableDecorator.h
@@ -30,6 +30,8 @@ class MvaTESVariableDecorator
const xAOD::VertexContainer* m_xVertexContainer; //!
int m_mu; //!
int m_nVtx; //!
+
+
};
diff --git a/Reconstruction/tauRecTools/tauRecTools/TauBuilderTool.h b/Reconstruction/tauRecTools/tauRecTools/TauBuilderTool.h
index c8776c84da2a..73229c053429 100644
--- a/Reconstruction/tauRecTools/tauRecTools/TauBuilderTool.h
+++ b/Reconstruction/tauRecTools/tauRecTools/TauBuilderTool.h
@@ -32,6 +32,8 @@ class TauBuilderTool : public asg::AsgTool, virtual public ITauToolExecBase {
private:
std :: string m_tauContainerName; //!< tau output container
std :: string m_tauAuxContainerName; //!< tau output aux store container
+ std::string m_tauTrackContainerName;
+ std::string m_tauTrackAuxContainerName;
std::string m_seedContainerName; //!< seed input container
double m_maxEta; //!< only build taus with eta_seed < m_maxeta
double m_minPt; //!< only build taus with pt_seed > m_minpt
diff --git a/Reconstruction/tauRecTools/tauRecTools/TauCalibrateLC.h b/Reconstruction/tauRecTools/tauRecTools/TauCalibrateLC.h
index 5c76e9702eff..0599d63f1fb7 100644
--- a/Reconstruction/tauRecTools/tauRecTools/TauCalibrateLC.h
+++ b/Reconstruction/tauRecTools/tauRecTools/TauCalibrateLC.h
@@ -25,8 +25,7 @@ public:
ASG_TOOL_CLASS2( TauCalibrateLC, TauRecToolBase, ITauToolBase )
- TauCalibrateLC(const std::string& type);
- TauCalibrateLC();
+ TauCalibrateLC(const std::string& name="TauCalibrateLC");
~TauCalibrateLC();
virtual StatusCode initialize();
diff --git a/Reconstruction/tauRecTools/tauRecTools/TauProcessorTool.h b/Reconstruction/tauRecTools/tauRecTools/TauProcessorTool.h
index 5b4ec84d8e47..adfe60f6b6a5 100644
--- a/Reconstruction/tauRecTools/tauRecTools/TauProcessorTool.h
+++ b/Reconstruction/tauRecTools/tauRecTools/TauProcessorTool.h
@@ -41,6 +41,7 @@ class TauProcessorTool : public asg::AsgTool, virtual public ITauToolExecBase {
bool m_deep_copy_hadronicPFOContainer;
bool m_deep_copy_neutralPFOContainer;
bool m_deep_copy_SecVtxContainer;
+ bool m_deep_copy_TauTrackContainer;
TauEventData m_data;
ToolHandleArray<ITauToolBase> m_tools;
diff --git a/Reconstruction/tauRecTools/tauRecTools/TauTrackClassifier.h b/Reconstruction/tauRecTools/tauRecTools/TauTrackClassifier.h
new file mode 100644
index 000000000000..e87aaaea93e3
--- /dev/null
+++ b/Reconstruction/tauRecTools/tauRecTools/TauTrackClassifier.h
@@ -0,0 +1,159 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TAUREC_TAUTRACKCLASSIFIER_H
+#define TAUREC_TAUTRACKCLASSIFIER_H
+
+// ASG include(s)
+#include "AsgTools/AsgTool.h"
+#include "AsgTools/ToolHandleArray.h"
+
+// xAOD include(s)
+#include "xAODTau/TauJet.h"
+#include "xAODTau/TauTrack.h"
+
+// local include(s)
+#include "tauRecTools/TauRecToolBase.h"
+
+// ROOT include(s)
+#include "TMVA/Reader.h"
+
+/**
+ * @brief Implementation of a TrackClassifier based on an MVA
+ *
+ * @author Dirk Duschinger
+ *
+ */
+
+namespace tauRecTools
+{
+
+class TrackMVABDT;
+
+//______________________________________________________________________________
+class TauTrackClassifier
+ : virtual public TauRecToolBase
+{
+public:
+
+ ASG_TOOL_CLASS2( TauTrackClassifier, TauRecToolBase, ITauToolBase )
+
+ TauTrackClassifier(const std::string& sName="TauTrackClassifier");
+ ~TauTrackClassifier();
+
+ // retrieve all track classifier sub tools
+ virtual StatusCode initialize();
+ // pass all tracks in the tau cone to all track classifier sub tools
+ virtual StatusCode execute(xAOD::TauJet& pTau);
+
+private:
+ ToolHandleArray<TrackMVABDT> m_vClassifier;
+ std::string m_tauTrackConName;
+
+}; // class TauTrackClassifier
+
+//______________________________________________________________________________
+class TrackMVABDT
+ : public TauRecToolBase
+{
+ /// Create a proper constructor for Athena
+ ASG_TOOL_CLASS2( TrackMVABDT,
+ TauRecToolBase,
+ ITauToolBase)
+
+ public:
+
+ TrackMVABDT(const std::string& sName);
+ ~TrackMVABDT();
+
+ // configure the TMVA reader object and build a general map to store variables
+ // for possible TMVA inputs. Only Variables defined in the xml weights file
+ // are passed to the TMVA reader
+ StatusCode initialize();
+
+ // executes TMVA reader to get the BDT score, makes the decision and resets
+ // classification flags
+ StatusCode classifyTrack(xAOD::TauTrack& xTrack, const xAOD::TauJet& xTau);
+ // set BDT input variables in the corresponding map entries
+ void setVars(const xAOD::TauTrack& xTrack, const xAOD::TauJet& xTau);
+
+ // load the xml weights file and configure the TMVA reader with the correct
+ // variable addresses
+ StatusCode addWeightsFile();
+ // parse the weights file for the line showing the input variable used by that
+ // particular BDT names and store them
+ StatusCode parseVariableContent();
+
+private:
+ // configurable variables
+ std::string m_sInputWeightsPath;
+ float m_fThreshold;
+ int m_iSignalType;
+ int m_iBackgroundType;
+ int m_iExpectedFlag;
+
+private:
+ TMVA::Reader* m_rReader; //!
+
+ std::map<int, std::string> m_mParsedVarsBDT; //!
+ std::map<std::string, float> m_mAvailableVars; //!
+
+ // possible bdt input variables
+ float tauPt;
+ float tauEta;
+ float trackEta;
+ float z0sinThetaTJVA;
+ float rConv;
+ float rConvII;
+ float DRJetSeedAxis;
+ float d0;
+ float qOverP;
+ float theta;
+ float numberOfInnermostPixelLayerHits;
+ float numberOfPixelHits;
+ float numberOfPixelDeadSensors;
+ float numberOfPixelSharedHits;
+ float numberOfSCTHits;
+ float numberOfSCTDeadSensors;
+ float numberOfSCTSharedHits;
+ float numberOfTRTHighThresholdHits;
+ float numberOfTRTHits;
+ float nPixHits;
+ float nSiHits;
+
+}; // class TrackMVABDT
+
+
+ xAOD::TauTrack::TrackFlagType isolateClassifiedBits(xAOD::TauTrack::TrackFlagType flag){
+ static int flagsize=sizeof(flag)*8;
+ flag=flag<<(flagsize-xAOD::TauJetParameters::classifiedFake-1);
+ flag=flag>>(flagsize-xAOD::TauJetParameters::classifiedCharged+1);
+ return flag;
+ }
+
+//bool sortTracks(xAOD::TauTrack* xTrack1, xAOD::TauTrack* xTrack2)
+ bool sortTracks(const ElementLink<xAOD::TauTrackContainer> &l1, const ElementLink<xAOD::TauTrackContainer> &l2)
+{
+ //should we be safe and ask if the links are available?
+ const xAOD::TauTrack* xTrack1 = *l1;
+ const xAOD::TauTrack* xTrack2 = *l2;
+
+ //return classified charged, then isolation (wide tracks), else by pt
+ xAOD::TauTrack::TrackFlagType f1 = isolateClassifiedBits(xTrack1->flagSet());
+ xAOD::TauTrack::TrackFlagType f2 = isolateClassifiedBits(xTrack2->flagSet());
+
+ if(f1==f2)
+ return xTrack1->pt()>xTrack2->pt();
+ return f1<f2;
+
+ //this somehow causes a crash
+ /* static uint16_t flag1 = xTrack1->flagSet() >> (xAOD::TauJetParameters::classifiedCharged - 1); */
+ /* static uint16_t flag2 = xTrack2->flagSet() >> (uint16_t(xAOD::TauJetParameters::classifiedCharged) - 1); */
+ /* return (flag1<flag2) || // sort by type, true tracks first */
+ /* ((flag1==flag2) && (xTrack1->pt()>xTrack2->pt())); // sort by pt if equal types */
+}
+
+} // namespace tauRecTools
+
+#endif // not TAUTRACKCLASSIFIER
diff --git a/Reconstruction/tauRecTools/tauRecTools/TauTrackFilter.h b/Reconstruction/tauRecTools/tauRecTools/TauTrackFilter.h
index 907309a8e8f7..a7d39dda7ee7 100644
--- a/Reconstruction/tauRecTools/tauRecTools/TauTrackFilter.h
+++ b/Reconstruction/tauRecTools/tauRecTools/TauTrackFilter.h
@@ -40,6 +40,7 @@ public:
private:
std::string m_configPath;
std::string m_trackContainerName;
+ std::string m_tauTrackConName;
std::vector<bool> m_TrkPass;
int m_nProng;
int m_flag;
--
GitLab