Commit 354de4fa authored by Christian Grefe's avatar Christian Grefe
Browse files

Add TRT NN PID to track variables. Clean up of TRT track decorations.

parent 88d23405
......@@ -30,6 +30,14 @@ namespace InDet {
TRTPIDNN()=default;
virtual ~TRTPIDNN()=default;
std::string getDefaultOutputNode() const {
return m_outputNode;
}
std::string getDefaultOutputLabel() const {
return m_outputLabel;
}
// get the structure of the scalar inputs to the NN
std::map<std::string, std::map<std::string, double>> getScalarInputs() const {
return m_scalarInputs;
......@@ -40,9 +48,16 @@ namespace InDet {
return m_vectorInputs;
}
// calculate NN response for default output node and label
double evaluate(std::map<std::string, std::map<std::string, double>>& scalarInputs,
std::map<std::string, std::map<std::string, std::vector<double>>>& vectorInputs) const {
return evaluate(scalarInputs, vectorInputs, m_outputNode, m_outputLabel);
}
// calculate NN response
double evaluate(std::map<std::string, std::map<std::string, double>>& scalarInputs,
std::map<std::string, std::map<std::string, std::vector<double>>>& vectorInputs) const;
std::map<std::string, std::map<std::string, std::vector<double>>>& vectorInputs,
const std::string& outputNode, const std::string& outputLabel) const;
// set up the NN
StatusCode configure(const std::string& json);
......@@ -53,6 +68,7 @@ namespace InDet {
std::map<std::string, std::map<std::string, double>> m_scalarInputs; // template for the structure of the scalar inputs to the NN
std::map<std::string, std::map<std::string, std::vector<double>>> m_vectorInputs; // template for the structure of the vector inputs to the NN
std::string m_outputNode; // name of the output node of the NN
std::string m_outputLabel; // name of the output label of the NN
};
}
CLASS_DEF(InDet::TRTPIDNN,341715853,1)
......
......@@ -17,9 +17,16 @@
#include "boost/property_tree/exceptions.hpp"
double InDet::TRTPIDNN::evaluate(std::map<std::string, std::map<std::string, double>>& scalarInputs,
std::map<std::string, std::map<std::string, std::vector<double>>>& vectorInputs) const {
const auto result = m_nn->compute(scalarInputs, vectorInputs);
return result.at("e_prob_0");
std::map<std::string, std::map<std::string, std::vector<double>>>& vectorInputs,
const std::string& outputNode, const std::string& outputLabel) const {
MsgStream log(Athena::getMessageSvc(),"TRTPIDNN");
const auto result = m_nn->compute(scalarInputs, vectorInputs, outputNode);
const auto itResult = result.find(outputLabel);
if (itResult == result.end()) {
log << MSG::ERROR << " unable to find output: node=" << outputNode << ", label=" << outputLabel << endmsg;
return 0.5;
}
return itResult->second;
}
StatusCode InDet::TRTPIDNN::configure(const std::string& json) {
......@@ -39,6 +46,14 @@ StatusCode InDet::TRTPIDNN::configure(const std::string& json) {
return StatusCode::FAILURE;
}
// set the default output node name
if (m_nnConfig.outputs.empty() or m_nnConfig.outputs.begin()->second.labels.empty()) {
log << MSG::ERROR << " unable to define NN output." << endmsg;
return StatusCode::FAILURE;
}
m_outputNode = m_nnConfig.outputs.begin()->first;
m_outputLabel = *(m_nnConfig.outputs[m_outputNode].labels.begin());
// store templates of the structure of the inputs to the NN
m_scalarInputs.clear();
for (auto input : m_nnConfig.inputs) {
......@@ -47,7 +62,6 @@ StatusCode InDet::TRTPIDNN::configure(const std::string& json) {
m_scalarInputs[input.name][variable.name] = input.defaults[variable.name];
}
}
m_vectorInputs.clear();
for (auto input : m_nnConfig.input_sequences) {
m_vectorInputs[input.name] = {};
......@@ -56,6 +70,5 @@ StatusCode InDet::TRTPIDNN::configure(const std::string& json) {
}
}
return StatusCode::SUCCESS;
}
......@@ -1088,7 +1088,6 @@ def getInDetTrackSummaryTool(name='InDetTrackSummaryTool',**kwargs) :
doSharedHits = False,
doHolesInDet = do_holes,
TRT_ElectronPidTool = None, # we don't want to use those tools during pattern
TRT_ToT_dEdxTool = None, # dito
PixelToTPIDTool = None) # we don't want to use those tools during pattern
from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
return Trk__TrackSummaryTool(name = the_name, **kwargs)
......@@ -1111,16 +1110,12 @@ def getInDetTrackSummaryToolSharedHits(name='InDetTrackSummaryToolSharedHits',**
if 'TRT_ElectronPidTool' not in kwargs :
kwargs = setDefaults( kwargs, TRT_ElectronPidTool = getInDetTRT_ElectronPidTool())
if 'TRT_ToT_dEdxTool' not in kwargs :
kwargs = setDefaults( kwargs, TRT_ToT_dEdxTool = getInDetTRT_dEdxTool())
if 'PixelToTPIDTool' not in kwargs :
kwargs = setDefaults( kwargs, PixelToTPIDTool = getInDetPixelToTPIDTool())
from InDetRecExample.InDetJobProperties import InDetFlags
kwargs = setDefaults(kwargs,
doSharedHits = InDetFlags.doSharedHits(),
minTRThitsForTRTdEdx = 1) # default is 1
doSharedHits = InDetFlags.doSharedHits())
return getInDetTrackSummaryTool( name, **kwargs)
......
......@@ -21,6 +21,7 @@
// Tracking:
#include "TrkTrack/Track.h"
#include "TrkTrackSummary/TrackSummary.h"
#include "TrkTrack/TrackStateOnSurface.h"
#include "TrkMeasurementBase/MeasurementBase.h"
#include "TrkRIO_OnTrack/RIO_OnTrack.h"
......@@ -35,6 +36,9 @@
// ToT Tool Interface
#include "TRT_ElectronPidTools/ITRT_ToT_dEdx.h"
// For the track length in straw calculations
#include "TRT_ToT_dEdx.h"
// Particle masses
// Math functions:
......@@ -48,6 +52,16 @@
//#include "TRT_ElectronPidToolRun2_HTcalculation.cxx"
// Helper method to store NN input variables into maps
template <typename T>
void storeNNVariable(std::map<std::string, T>& theMap, const std::string& name, const T& value) {
auto it = theMap.find(name);
if (it != theMap.end()) {
it->second = value;
}
}
/*****************************************************************************\
|*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*|
......@@ -121,13 +135,15 @@ StatusCode InDet::TRT_ElectronPidToolRun2::finalize()
std::vector<float> InDet::TRT_ElectronPidToolRun2::electronProbability_old(const Trk::Track& track)
{
// Simply return values without calculation
std::vector<float> PIDvalues(4);
PIDvalues[0] = 0.5;
PIDvalues[1] = 0.5;
PIDvalues[2] = 0.0;
PIDvalues[3] = 0.5;
//PIDvalues[4] = 0.0;
//PIDvalues[5] = 0.5;
std::vector<float> PIDvalues(Trk::numberOfeProbabilityTypes);
PIDvalues[Trk::eProbabilityComb] = 0.5;
PIDvalues[Trk::eProbabilityHT] = 0.5;
PIDvalues[Trk::eProbabilityToT] = 0.5;
PIDvalues[Trk::eProbabilityBrem] = 0.5;
PIDvalues[Trk::eProbabilityNN] = 0.5;
PIDvalues[Trk::TRTTrackOccupancy] = 0.0;
PIDvalues[Trk::TRTdEdx] = 0.0;
PIDvalues[Trk::eProbabilityNumberOfTRTHitsUsedFordEdx] = 0.0;
const Trk::TrackParameters* perigee = track.perigeeParameters();
if (!perigee) { return PIDvalues; }
return PIDvalues;
......@@ -158,16 +174,16 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
ATH_MSG_WARNING (" No PID NN available from the DB.");
}
//Initialize the return vector
std::vector<float> PIDvalues(6);
float & prob_El_Comb = PIDvalues[0] = 0.5;
float & prob_El_HT = PIDvalues[1] = 0.5;
float & prob_El_ToT = PIDvalues[2] = 0.5;
float & prob_El_Brem = PIDvalues[3] = 0.5;
float & occ_local = PIDvalues[4] = 0.0;
float & prob_El_NN = PIDvalues[5] = 0.5;
float dEdx = 0.0;
// Initialize the vector with default PID values
std::vector<float> PIDvalues(Trk::numberOfeProbabilityTypes);
PIDvalues[Trk::eProbabilityComb] = 0.5;
PIDvalues[Trk::eProbabilityHT] = 0.5;
PIDvalues[Trk::eProbabilityToT] = 0.5;
PIDvalues[Trk::eProbabilityBrem] = 0.5;
PIDvalues[Trk::eProbabilityNN] = 0.5;
PIDvalues[Trk::TRTTrackOccupancy] = 0.0;
PIDvalues[Trk::TRTdEdx] = 0.0;
PIDvalues[Trk::eProbabilityNumberOfTRTHitsUsedFordEdx] = 0.0;
// Check for perigee:
const Trk::TrackParameters* perigee = track.perigeeParameters();
......@@ -196,7 +212,12 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
double eta = -log(tan(theta/2.0));
// Check the tool to get the local occupancy (i.e. for the track in question):
occ_local = m_LocalOccTool->LocalOccupancy(ctx,track);
PIDvalues[Trk::TRTTrackOccupancy] = m_LocalOccTool->LocalOccupancy(ctx,track);
if (PIDvalues[Trk::TRTTrackOccupancy] > 1.0 || PIDvalues[Trk::TRTTrackOccupancy] < 0.0) {
ATH_MSG_WARNING(" Occupancy was outside allowed range! Returning default Pid values. Occupancy = " << PIDvalues[Trk::TRTTrackOccupancy] );
return PIDvalues;
}
ATH_MSG_DEBUG ("");
ATH_MSG_DEBUG ("");
......@@ -212,8 +233,20 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
// Loop over TRT hits on track, and calculate HT and R-ToT probability:
// ------------------------------------------------------------------------------------
std::vector<double> hit_HTMB;
std::vector<double> hit_gasType;
std::vector<double> hit_tot;
std::vector<double> hit_L;
std::vector<double> hit_rTrkWire;
std::vector<double> hit_HitZ;
std::vector<double> hit_HitR;
std::vector<double> hit_isPrec;
unsigned int nTRThits = 0;
unsigned int nTRThitsHTMB = 0;
unsigned int nXehits = 0;
unsigned int nArhits = 0;
unsigned int nPrecHits = 0;
// Check for track states:
......@@ -234,15 +267,7 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
if (!measurement) continue;
// Get drift circle (ensures that hit is from TRT):
const InDet::TRT_DriftCircleOnTrack* driftcircle = nullptr;
if (measurement->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
const Trk::RIO_OnTrack* tmpRio =
static_cast<const Trk::RIO_OnTrack*>(measurement);
if (tmpRio->rioType(Trk::RIO_OnTrackType::TRT_DriftCircle)) {
driftcircle = static_cast<const InDet::TRT_DriftCircleOnTrack*>(tmpRio);
}
}
const InDet::TRT_DriftCircleOnTrack* driftcircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack*>(measurement);
if (!driftcircle) continue;
// From now (May 2015) onwards, we ONLY USE MIDDLE HT BIT:
......@@ -250,6 +275,7 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
nTRThits++;
if (isHTMB) nTRThitsHTMB++;
hit_HTMB.push_back(double(isHTMB));
// ------------------------------------------------------------------------------------
......@@ -276,14 +302,17 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
}
// Get Z (Barrel) or R (Endcap) location of the hit, and distance from track to wire (i.e. anode) in straw:
double HitZ, HitR, rTrkWire;
bool hasTrackParameters= true; // Keep track of this for HT prob calculation
double HitZ = 0.;
double HitR = 0.;
double rTrkWire = 0.;
bool hasTrackParameters = true; // Keep track of this for HT prob calculation
if ((*tsosIter)->trackParameters()) {
// If we have precise information (from hit), get that:
const Amg::Vector3D& gp = driftcircle->globalPosition();
HitR = gp.perp();
HitZ = gp.z();
rTrkWire = fabs((*tsosIter)->trackParameters()->parameters()[Trk::driftRadius]);
if (rTrkWire > 2.2) rTrkWire = 2.175; // Happens once in a while - no need for warning!
} else {
// Otherwise just use the straw coordinates:
hasTrackParameters = false; // Jared - pass this to HT calculation
......@@ -292,6 +321,12 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
rTrkWire = 0;
}
// fill vectors for NN PID
hit_HitZ.push_back(HitZ);
hit_HitR.push_back(HitR);
hit_rTrkWire.push_back(rTrkWire);
hit_L.push_back(TRT_ToT_dEdx::calculateTrackLengthInStraw((*tsosIter), m_trtId));
hit_tot.push_back(driftcircle->timeOverThreshold());
// ------------------------------------------------------------------------------------
// Collection and checks of input variables for HT probability calculation:
......@@ -315,13 +350,6 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
ZRpos[TrtPart] = ZRpos_min[TrtPart] + 0.001;
}
if (rTrkWire > 2.2) rTrkWire = 2.175; // Happens once in a while - no need for warning!
if (occ_local > 1.0 || occ_local < 0.0) {
ATH_MSG_WARNING(" Occupancy was outside allowed range! TrtPart = " << TrtPart << " Occupancy = " << occ_local);
continue;
}
// ------------------------------------------------------------------------------------
// Calculate the HT probability:
// ------------------------------------------------------------------------------------
......@@ -345,7 +373,24 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
<< nTRThits << " TrtPart: " << TrtPart
<< " GasType: " << GasType << " SL: " << StrawLayer
<< " ZRpos: " << ZRpos[TrtPart] << " TWdist: " << rTrkWire
<< " Occ_Local: " << occ_local << " HTMB: " << isHTMB);
<< " Occ_Local: " << PIDvalues[Trk::TRTTrackOccupancy] << " HTMB: " << isHTMB);
// RNN gas type observables
hit_gasType.push_back(double(GasType));
if (GasType == 0) {
nXehits++;
} else if (GasType == 1) {
nArhits++;
}
// RNN hit preciion observables
float errDc = sqrt(driftcircle->localCovariance()(Trk::driftRadius, Trk::driftRadius));
bool isPrec = false;
if (errDc < 1.0) {
isPrec = true;
nPrecHits++;
}
hit_isPrec.push_back(double(isPrec));
// Then call pHT functions with these values:
// ------------------------------------------
......@@ -357,7 +402,7 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
StrawLayer,
ZRpos[TrtPart],
rTrkWire,
occ_local,
PIDvalues[Trk::TRTTrackOccupancy] ,
hasTrackParameters);
double pHTpi = HTcalc->getProbHT(pTrk,
Trk::pion,
......@@ -366,7 +411,7 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
StrawLayer,
ZRpos[TrtPart],
rTrkWire,
occ_local,
PIDvalues[Trk::TRTTrackOccupancy] ,
hasTrackParameters);
if (pHTel > 0.999 || pHTpi > 0.999 || pHTel < 0.001 || pHTpi < 0.001) {
......@@ -374,7 +419,7 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
<< pHTel << " pHTpi = " << pHTpi
<< " TrtPart: " << TrtPart << " SL: " << StrawLayer
<< " ZRpos: " << ZRpos[TrtPart] << " TWdist: " << rTrkWire
<< " Occ_Local: " << occ_local);
<< " Occ_Local: " << PIDvalues[Trk::TRTTrackOccupancy] );
continue;
}
......@@ -383,7 +428,7 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
<< pHTel << " pHTpi = " << pHTpi
<< " TrtPart: " << TrtPart << " SL: " << StrawLayer
<< " ZRpos: " << ZRpos[TrtPart] << " TWdist: " << rTrkWire
<< " Occ_Local: " << occ_local);
<< " Occ_Local: " << PIDvalues[Trk::TRTTrackOccupancy] );
continue;
}
......@@ -392,49 +437,84 @@ InDet::TRT_ElectronPidToolRun2::electronProbability(const Trk::Track& track) con
else {pHTel_prod *= 1.0-pHTel; pHTpi_prod *= 1.0-pHTpi;}
ATH_MSG_DEBUG ("check pHT(el): " << pHTel << " pHT(pi): " << pHTpi );
// Jared - Development Output...
//std::cout << "check pHT(el): " << pHTel << " pHT(pi): " << pHTpi << std::endl;
}//of loop over hits
} // end of loop over hits
// If number of hits is adequate (default is 5 hits), calculate HT and ToT probability.
if (not (nTRThits >= m_minTRThits)) return PIDvalues;
// Calculate electron probability (HT)
prob_El_HT = pHTel_prod / (pHTel_prod + pHTpi_prod);
PIDvalues[Trk::eProbabilityHT] = pHTel_prod / (pHTel_prod + pHTpi_prod);
ATH_MSG_DEBUG ("check---------------------------------------------------------------------------------------");
ATH_MSG_DEBUG("check nTRThits: " << nTRThits << " : " << nTRThitsHTMB
<< " pHTel_prod: " << pHTel_prod
<< " pHTpi_prod: " << pHTpi_prod
<< " probEl: " << prob_El_HT);
ATH_MSG_DEBUG ("check---------------------------------------------------------------------------------------");
ATH_MSG_DEBUG ("");
ATH_MSG_DEBUG ("");
ATH_MSG_DEBUG ("check nTRThits: " << nTRThits << " : " << nTRThitsHTMB
<< " pHTel_prod: " << pHTel_prod
<< " pHTpi_prod: " << pHTpi_prod
<< " probEl: " << PIDvalues[Trk::eProbabilityHT]);
// Jared - ToT Implementation
dEdx = m_TRTdEdxTool->dEdx(ctx,&track, false); // Divide by L, exclude HT hits
double usedHits = m_TRTdEdxTool->usedHits(ctx,&track, false);
prob_El_ToT = m_TRTdEdxTool->getTest(ctx,dEdx, pTrk, Trk::electron, Trk::pion, usedHits);
PIDvalues[Trk::TRTdEdx] = m_TRTdEdxTool->dEdx(ctx,&track); // default dEdx using all hits
PIDvalues[Trk::eProbabilityNumberOfTRTHitsUsedFordEdx] = m_TRTdEdxTool->usedHits(ctx,&track);
double dEdx_noHTHits = m_TRTdEdxTool->dEdx(ctx,&track, false); // Divide by L, exclude HT hits
double dEdx_usedHits_noHTHits = m_TRTdEdxTool->usedHits(ctx,&track, false);
PIDvalues[Trk::eProbabilityToT] = m_TRTdEdxTool->getTest(ctx, dEdx_noHTHits, pTrk, Trk::electron, Trk::pion, dEdx_usedHits_noHTHits);
// Limit the probability values the upper and lower limits that are given/trusted for each part:
double limProbHT = HTcalc->Limit(prob_El_HT);
double limProbToT = HTcalc->Limit(prob_El_ToT);
double limProbHT = HTcalc->Limit(PIDvalues[Trk::eProbabilityHT]);
double limProbToT = HTcalc->Limit(PIDvalues[Trk::eProbabilityToT]);
// Calculate the combined probability, assuming no correlations (none are expected).
prob_El_Comb = (limProbHT * limProbToT ) / ( (limProbHT * limProbToT) + ( (1.0-limProbHT) * (1.0-limProbToT)) );
PIDvalues[Trk::eProbabilityComb] = (limProbHT * limProbToT ) / ( (limProbHT * limProbToT) + ( (1.0-limProbHT) * (1.0-limProbToT)) );
// Troels: VERY NASTY NAMING, BUT AGREED UPON FOR NOW (for debugging, 27. NOV. 2014):
prob_El_Brem = pHTel_prod; // decorates electron LH to el brem for now... (still used?)
//std::cout << "Prob_HT = " << prob_El_HT << " Prob_ToT = " << prob_El_ToT << " Prob_Comb = " << prob_El_Comb << std::endl;
PIDvalues[Trk::eProbabilityBrem] = pHTel_prod; // decorates electron LH to el brem for now... (still used?)
// Calculate RNN PID score
std::map<std::string, std::map<std::string, double>> scalarInputs_NN = PIDNN->getScalarInputs();
std::map<std::string, std::map<std::string, std::vector<double>>> vectorInputs_NN = PIDNN->getVectorInputs();
prob_El_NN = PIDNN->evaluate(scalarInputs_NN, vectorInputs_NN);
// Calculate the hit fraction
double fAr = double(nArhits) / nTRThits;
double fHTMB = double(nTRThitsHTMB) / nTRThits;
double PHF = double(nPrecHits) / nTRThits;
if (!scalarInputs_NN.empty()) {
std::map<std::string, double>& trackVarMap = scalarInputs_NN.begin()->second;
storeNNVariable(trackVarMap, "trkOcc", (double) PIDvalues[Trk::TRTTrackOccupancy]);
storeNNVariable(trackVarMap, "p", pTrk);
storeNNVariable(trackVarMap, "pT", pT);
storeNNVariable(trackVarMap, "nXehits", (double) nXehits);
storeNNVariable(trackVarMap, "fAr", fAr);
storeNNVariable(trackVarMap, "fHTMB", fHTMB);
storeNNVariable(trackVarMap, "PHF", PHF);
storeNNVariable(trackVarMap, "dEdx", (double) dEdx_noHTHits);
}
if (!vectorInputs_NN.empty()) {
std::map<std::string, std::vector<double>>& hitVarMap = vectorInputs_NN.begin()->second;
storeNNVariable(hitVarMap, "hit_HTMB", hit_HTMB);
storeNNVariable(hitVarMap, "hit_gasType", hit_gasType);
storeNNVariable(hitVarMap, "hit_tot", hit_tot);
storeNNVariable(hitVarMap, "hit_L", hit_L);
storeNNVariable(hitVarMap, "hit_rTrkWire", hit_rTrkWire);
storeNNVariable(hitVarMap, "hit_HitZ", hit_HitZ);
storeNNVariable(hitVarMap, "hit_HitR", hit_HitR);
storeNNVariable(hitVarMap, "hit_isPrec", hit_isPrec);
}
PIDvalues[Trk::eProbabilityNN] = PIDNN->evaluate(scalarInputs_NN, vectorInputs_NN);
ATH_MSG_DEBUG ("check NN PID calculation: ");
for (auto scalarInputs : scalarInputs_NN) {
ATH_MSG_DEBUG (" scalar inputs: " << scalarInputs.first);
for (auto variable : scalarInputs.second) {
ATH_MSG_DEBUG (" " << variable.first << " = " << variable.second);
}
}
for (auto vectorInputs : vectorInputs_NN) {
ATH_MSG_DEBUG (" vector inputs: " << vectorInputs.first);
for (auto variable : vectorInputs.second) {
ATH_MSG_DEBUG (" " << variable.first << " = " << variable.second);
}
}
ATH_MSG_DEBUG (" eProbilityNN: " << PIDvalues[Trk::eProbabilityNN]);
return PIDvalues;
}
......
......@@ -1252,6 +1252,11 @@ double TRT_ToT_dEdx::calculateTrackLengthInStraw(const Trk::TrackStateOnSurface*
const InDetDD::TRT_BaseElement* element = driftcircle->detectorElement();
double strawphi = element->center(DCId).phi();
// check if track is an outlier
if (Trt_Rtrack >= 2.0) {
return 0.;
}
double length=0;
if (HitPart == 1) { //Barrel
length = 2*std::sqrt(4-Trt_Rtrack*Trt_Rtrack)*1./std::abs(std::sin(Trt_HitTheta));
......
......@@ -125,9 +125,11 @@ enum SummaryType {
eProbabilityBrem_res = 50, //!< Electron probability from Brem fitting (DNA) [float].
pixeldEdx_res = 51, //!< the dE/dx estimate, calculated using the pixel clusters [?]
eProbabilityNN_res = 73, //!< Electron probability from NN [float].
TRTTrackOccupancy_res = 74, //!< TRT track occupancy.
TRTdEdx_res = 75, //!< dEdx from TRT ToT measurement.
// -- numbers...
numberOfTrackSummaryTypes = 74
numberOfTrackSummaryTypes = 76
};
// Troels.Petersen@cern.ch:
......@@ -137,11 +139,11 @@ enum SummaryType {
eProbabilityToT = 2, //!< Electron probability from Time-Over-Threshold (ToT) information.
eProbabilityBrem = 3, //!< Electron probability from Brem fitting (DNA).
eProbabilityNN = 4, //!< Electron probability from NN.
numberOfeProbabilityTypes = 5
};
// the eProbability vector is abused to store :
// [5] TRT local occupancy
// [6] TRT dE/dx
TRTTrackOccupancy = 5, //!< TRT track occupancy.
TRTdEdx = 6, //!< dEdx from TRT ToT measurement.
eProbabilityNumberOfTRTHitsUsedFordEdx = 7, //!< Number of TRT hits used for dEdx measurement.
numberOfeProbabilityTypes = 8
};
/** enumerates the various detector types currently accessible from the isHit() method.
\todo work out how to add muons to this*/
......
......@@ -87,9 +87,8 @@ createEProbabilityMap(std::map<std::string, std::pair<Trk::eProbabilityType, boo
eprob_map.insert(std::make_pair("eProbabilityToT", std::make_pair(Trk::eProbabilityToT, true)));
eprob_map.insert(std::make_pair("eProbabilityBrem", std::make_pair(Trk::eProbabilityBrem, true)));
eprob_map.insert(std::make_pair("eProbabilityNN", std::make_pair(Trk::eProbabilityNN, true)));
eprob_map.insert(std::make_pair("TRTTrackOccupancy", std::make_pair(Trk::numberOfeProbabilityTypes, true)));
eprob_map.insert(std::make_pair(
"TRTdEdx", std::make_pair(static_cast<Trk::eProbabilityType>(Trk::numberOfeProbabilityTypes + 1), true)));
eprob_map.insert(std::make_pair("TRTdEdx", std::make_pair(Trk::TRTdEdx, true)));
eprob_map.insert(std::make_pair("TRTTrackOccupancy", std::make_pair(Trk::TRTTrackOccupancy, true)));
}
void
......
......@@ -12,7 +12,6 @@
#include "TrkTrack/Track.h"
#include "TrkTrackSummary/TrackSummary.h"
#include "TRT_ElectronPidTools/ITRT_ToT_dEdx.h"
#include "TrkToolInterfaces/IExtendedTrackSummaryHelperTool.h"
#include "TrkToolInterfaces/IPixelToTPIDTool.h"
#include "TrkToolInterfaces/ITRT_ElectronPidTool.h"
......@@ -22,7 +21,6 @@
class AtlasDetectorID;
class Identifier;
class ITRT_ToT_dEdx;
namespace Trk {
class ITRT_ElectronPidTool;
......@@ -222,8 +220,6 @@ private:
"TRT_ElectronPidTool",
"",
"" };
/** tool to calculate the TRT_ToT_dEdx.*/
ToolHandle<ITRT_ToT_dEdx> m_trt_dEdxTool{ this, "TRT_ToT_dEdxTool", "", "" };
/**tool to calculate dE/dx using pixel clusters*/
ToolHandle<IPixelToTPIDTool> m_dedxtool{ this, "PixelToTPIDTool", "", "" };
/**tool to decipher muon RoTs*/
......@@ -253,13 +249,6 @@ private:
/** switch to deactivate Pixel info init */
Gaudi::Property<bool> m_pixelExists{ this, "PixelExists", true, "" };
/** Only compute TRT dE/dx if there are at least this number of TRT hits or
* outliers.*/
Gaudi::Property<int> m_minTRThitsForTRTdEdx{ this,
"minTRThitsForTRTdEdx",
1,
"" };
Gaudi::Property<bool> m_alwaysRecomputeHoles {
this, "AlwaysRecomputeHoles", false, ""
};
......