CMS 3D CMS Logo

List of all members | Classes | Public Types | Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes
TemplatedSecondaryVertexProducer< IPTI, VTX > Class Template Reference
Inheritance diagram for TemplatedSecondaryVertexProducer< IPTI, VTX >:
edm::stream::EDProducer<>

Classes

struct  SVBuilder
 
struct  SVFilter
 

Public Types

typedef IPTI::input_container input_container
 
typedef IPTI::input_container::value_type input_item
 
typedef std::vector< TemplatedSecondaryVertexTagInfo< IPTI, VTX > > Product
 
typedef TemplatedSecondaryVertex< VTX > SecondaryVertex
 
typedef std::vector< reco::btag::IndexedTrackDataTrackDataVector
 
- Public Types inherited from edm::stream::EDProducer<>
using CacheTypes = CacheContexts< T... >
 
using GlobalCache = typename CacheTypes::GlobalCache
 
using HasAbility = AbilityChecker< T... >
 
using InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
 
using LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
 
using LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
 
using LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
 
using RunCache = typename CacheTypes::RunCache
 
using RunContext = RunContextT< RunCache, GlobalCache >
 
using RunSummaryCache = typename CacheTypes::RunSummaryCache
 

Public Member Functions

void produce (edm::Event &event, const edm::EventSetup &es) override
 
 TemplatedSecondaryVertexProducer (const edm::ParameterSet &params)
 
 ~TemplatedSecondaryVertexProducer () override
 
- Public Member Functions inherited from edm::stream::EDProducer<>
 EDProducer ()=default
 
 EDProducer (const EDProducer &)=delete
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () const final
 
bool hasAbilityToProduceInEndRuns () const final
 
const EDProduceroperator= (const EDProducer &)=delete
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 

Private Types

enum  ConstraintType {
  CONSTRAINT_NONE = 0, CONSTRAINT_BEAMSPOT, CONSTRAINT_PV_BEAMSPOT_SIZE, CONSTRAINT_PV_BS_Z_ERRORS_SCALED,
  CONSTRAINT_PV_ERROR_SCALED, CONSTRAINT_PV_PRIMARIES_IN_FIT
}
 

Private Member Functions

void markUsedTracks (TrackDataVector &trackData, const input_container &trackRefs, const SecondaryVertex &sv, size_t idx)
 
template<>
void markUsedTracks (TrackDataVector &trackData, const input_container &trackRefs, const SecondaryVertex &sv, size_t idx)
 
template<>
void markUsedTracks (TrackDataVector &trackData, const input_container &trackRefs, const SecondaryVertex &sv, size_t idx)
 
void matchGroomedJets (const edm::Handle< edm::View< reco::Jet > > &jets, const edm::Handle< edm::View< reco::Jet > > &matchedJets, std::vector< int > &matchedIndices)
 
template<class CONTAINER >
void matchReclusteredJets (const edm::Handle< CONTAINER > &jets, const std::vector< fastjet::PseudoJet > &matchedJets, std::vector< int > &matchedIndices, const std::string &jetType="")
 
void matchSubjets (const edm::Handle< edm::View< reco::Jet > > &fatJets, const edm::Handle< std::vector< IPTI > > &subjets, std::vector< std::vector< int > > &matchedIndices)
 
void matchSubjets (const std::vector< int > &groomedIndices, const edm::Handle< edm::View< reco::Jet > > &groomedJets, const edm::Handle< std::vector< IPTI > > &subjets, std::vector< std::vector< int > > &matchedIndices)
 
const reco::JettoJet (const IPTI &j)
 
const reco::JettoJet (const reco::Jet &j)
 

Static Private Member Functions

static ConstraintType getConstraintType (const std::string &name)
 

Private Attributes

ConstraintType constraint
 
double constraintScaling
 
double extSVDeltaRToJet
 
ClusterSequencePtr fjClusterSeq
 
JetDefPtr fjJetDefinition
 
double ghostRescaling
 
std::string jetAlgorithm
 
double jetPtMin
 
double minTrackWeight
 
double relPtTolerance
 
double rParam
 
reco::btag::SortCriteria sortCriterium
 
edm::EDGetTokenT< reco::BeamSpottoken_BeamSpot
 
edm::EDGetTokenT< edm::View< VTX > > token_extSVCollection
 
edm::EDGetTokenT< edm::View< reco::Jet > > token_fatJets
 
edm::EDGetTokenT< edm::View< reco::Jet > > token_groomedFatJets
 
edm::ESGetToken< TransientTrackBuilder, TransientTrackRecordtoken_trackBuilder
 
edm::EDGetTokenT< std::vector< IPTI > > token_trackIPTagInfo
 
edm::EDGetTokenT< edm::ValueMap< float > > token_weights
 
TrackSelector trackSelector
 
bool useExternalSV
 
bool useFatJets
 
bool useGhostTrack
 
bool useGroomedFatJets
 
bool useSVClustering
 
bool useSVMomentum
 
VertexFilter vertexFilter
 
VertexSorting< SecondaryVertexvertexSorting
 
edm::ParameterSet vtxRecoPSet
 
bool withPVError
 

Detailed Description

template<class IPTI, class VTX>
class TemplatedSecondaryVertexProducer< IPTI, VTX >

Definition at line 102 of file TemplatedSecondaryVertexProducer.cc.

Member Typedef Documentation

◆ input_container

template<class IPTI, class VTX>
typedef IPTI::input_container TemplatedSecondaryVertexProducer< IPTI, VTX >::input_container

Definition at line 109 of file TemplatedSecondaryVertexProducer.cc.

◆ input_item

template<class IPTI, class VTX>
typedef IPTI::input_container::value_type TemplatedSecondaryVertexProducer< IPTI, VTX >::input_item

Definition at line 110 of file TemplatedSecondaryVertexProducer.cc.

◆ Product

template<class IPTI, class VTX>
typedef std::vector<TemplatedSecondaryVertexTagInfo<IPTI, VTX> > TemplatedSecondaryVertexProducer< IPTI, VTX >::Product

Definition at line 107 of file TemplatedSecondaryVertexProducer.cc.

◆ SecondaryVertex

template<class IPTI, class VTX>
typedef TemplatedSecondaryVertex<VTX> TemplatedSecondaryVertexProducer< IPTI, VTX >::SecondaryVertex

Definition at line 108 of file TemplatedSecondaryVertexProducer.cc.

◆ TrackDataVector

template<class IPTI, class VTX>
typedef std::vector<reco::btag::IndexedTrackData> TemplatedSecondaryVertexProducer< IPTI, VTX >::TrackDataVector

Definition at line 111 of file TemplatedSecondaryVertexProducer.cc.

Member Enumeration Documentation

◆ ConstraintType

template<class IPTI, class VTX>
enum TemplatedSecondaryVertexProducer::ConstraintType
private
Enumerator
CONSTRAINT_NONE 
CONSTRAINT_BEAMSPOT 
CONSTRAINT_PV_BEAMSPOT_SIZE 
CONSTRAINT_PV_BS_Z_ERRORS_SCALED 
CONSTRAINT_PV_ERROR_SCALED 
CONSTRAINT_PV_PRIMARIES_IN_FIT 

Definition at line 134 of file TemplatedSecondaryVertexProducer.cc.

Constructor & Destructor Documentation

◆ TemplatedSecondaryVertexProducer()

template<class IPTI , class VTX >
TemplatedSecondaryVertexProducer< IPTI, VTX >::TemplatedSecondaryVertexProducer ( const edm::ParameterSet params)
explicit

Definition at line 244 of file TemplatedSecondaryVertexProducer.cc.

245  : sortCriterium(TrackSorting::getCriterium(params.getParameter<std::string>("trackSort"))),
246  trackSelector(params.getParameter<edm::ParameterSet>("trackSelection")),
247  constraint(getConstraintType(params.getParameter<std::string>("constraint"))),
248  constraintScaling(1.0),
249  vtxRecoPSet(params.getParameter<edm::ParameterSet>("vertexReco")),
250  useGhostTrack(vtxRecoPSet.getParameter<std::string>("finder") == "gtvr"),
251  withPVError(params.getParameter<bool>("usePVError")),
252  minTrackWeight(params.getParameter<double>("minimumTrackWeight")),
253  vertexFilter(params.getParameter<edm::ParameterSet>("vertexCuts")),
254  vertexSorting(params.getParameter<edm::ParameterSet>("vertexSelection")) {
255  token_trackIPTagInfo = consumes<std::vector<IPTI> >(params.getParameter<edm::InputTag>("trackIPTagInfos"));
257  constraintScaling = params.getParameter<double>("pvErrorScaling");
258 
261  token_BeamSpot = consumes<reco::BeamSpot>(params.getParameter<edm::InputTag>("beamSpotTag"));
262  useExternalSV = false;
263  if (params.existsAs<bool>("useExternalSV"))
264  useExternalSV = params.getParameter<bool>("useExternalSV");
265  if (useExternalSV) {
266  token_extSVCollection = consumes<edm::View<VTX> >(params.getParameter<edm::InputTag>("extSVCollection"));
267  extSVDeltaRToJet = params.getParameter<double>("extSVDeltaRToJet");
268  }
269  useSVClustering = (params.existsAs<bool>("useSVClustering") ? params.getParameter<bool>("useSVClustering") : false);
270  useSVMomentum = (params.existsAs<bool>("useSVMomentum") ? params.getParameter<bool>("useSVMomentum") : false);
271  useFatJets = (useExternalSV && params.exists("fatJets"));
272  useGroomedFatJets = (useExternalSV && params.exists("groomedFatJets"));
273  if (useSVClustering) {
274  jetAlgorithm = params.getParameter<std::string>("jetAlgorithm");
275  rParam = params.getParameter<double>("rParam");
276  jetPtMin =
277  0.; // hardcoded to 0. since we simply want to recluster all input jets which already had some PtMin applied
279  (params.existsAs<double>("ghostRescaling") ? params.getParameter<double>("ghostRescaling") : 1e-18);
281  (params.existsAs<double>("relPtTolerance")
282  ? params.getParameter<double>("relPtTolerance")
283  : 1e-03); // 0.1% relative difference in Pt should be sufficient to detect possible misconfigurations
284 
285  // set jet algorithm
286  if (jetAlgorithm == "Kt")
287  fjJetDefinition = std::make_shared<fastjet::JetDefinition>(fastjet::kt_algorithm, rParam);
288  else if (jetAlgorithm == "CambridgeAachen")
289  fjJetDefinition = std::make_shared<fastjet::JetDefinition>(fastjet::cambridge_algorithm, rParam);
290  else if (jetAlgorithm == "AntiKt")
291  fjJetDefinition = std::make_shared<fastjet::JetDefinition>(fastjet::antikt_algorithm, rParam);
292  else
293  throw cms::Exception("InvalidJetAlgorithm") << "Jet clustering algorithm is invalid: " << jetAlgorithm
294  << ", use CambridgeAachen | Kt | AntiKt" << std::endl;
295  }
297  esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"));
298  if (useFatJets) {
299  token_fatJets = consumes<edm::View<reco::Jet> >(params.getParameter<edm::InputTag>("fatJets"));
300  }
301  edm::InputTag srcWeights = params.getParameter<edm::InputTag>("weights");
302  if (!srcWeights.label().empty())
304  if (useGroomedFatJets) {
305  token_groomedFatJets = consumes<edm::View<reco::Jet> >(params.getParameter<edm::InputTag>("groomedFatJets"));
306  }
307  if (useFatJets && !useSVClustering)
308  rParam = params.getParameter<double>("rParam"); // will be used later as a dR cut
309 
310  produces<Product>();
311 }

References TemplatedSecondaryVertexProducer< IPTI, VTX >::constraint, TemplatedSecondaryVertexProducer< IPTI, VTX >::CONSTRAINT_BEAMSPOT, TemplatedSecondaryVertexProducer< IPTI, VTX >::CONSTRAINT_PV_BEAMSPOT_SIZE, TemplatedSecondaryVertexProducer< IPTI, VTX >::CONSTRAINT_PV_BS_Z_ERRORS_SCALED, TemplatedSecondaryVertexProducer< IPTI, VTX >::CONSTRAINT_PV_ERROR_SCALED, TemplatedSecondaryVertexProducer< IPTI, VTX >::CONSTRAINT_PV_PRIMARIES_IN_FIT, TemplatedSecondaryVertexProducer< IPTI, VTX >::constraintScaling, MillePedeFileConverter_cfg::e, Exception, TemplatedSecondaryVertexProducer< IPTI, VTX >::extSVDeltaRToJet, TemplatedSecondaryVertexProducer< IPTI, VTX >::fjJetDefinition, TemplatedSecondaryVertexProducer< IPTI, VTX >::ghostRescaling, TemplatedSecondaryVertexProducer< IPTI, VTX >::jetAlgorithm, TemplatedSecondaryVertexProducer< IPTI, VTX >::jetPtMin, CalibrationSummaryClient_cfi::params, TemplatedSecondaryVertexProducer< IPTI, VTX >::relPtTolerance, TemplatedSecondaryVertexProducer< IPTI, VTX >::rParam, HLT_FULL_cff::srcWeights, AlCaHLTBitMon_QueryRunRegistry::string, TemplatedSecondaryVertexProducer< IPTI, VTX >::token_BeamSpot, TemplatedSecondaryVertexProducer< IPTI, VTX >::token_extSVCollection, TemplatedSecondaryVertexProducer< IPTI, VTX >::token_fatJets, TemplatedSecondaryVertexProducer< IPTI, VTX >::token_groomedFatJets, TemplatedSecondaryVertexProducer< IPTI, VTX >::token_trackBuilder, TemplatedSecondaryVertexProducer< IPTI, VTX >::token_trackIPTagInfo, TemplatedSecondaryVertexProducer< IPTI, VTX >::token_weights, TemplatedSecondaryVertexProducer< IPTI, VTX >::useExternalSV, TemplatedSecondaryVertexProducer< IPTI, VTX >::useFatJets, TemplatedSecondaryVertexProducer< IPTI, VTX >::useGroomedFatJets, TemplatedSecondaryVertexProducer< IPTI, VTX >::useSVClustering, and TemplatedSecondaryVertexProducer< IPTI, VTX >::useSVMomentum.

◆ ~TemplatedSecondaryVertexProducer()

template<class IPTI , class VTX >
TemplatedSecondaryVertexProducer< IPTI, VTX >::~TemplatedSecondaryVertexProducer ( )
override

Definition at line 313 of file TemplatedSecondaryVertexProducer.cc.

313 {}

Member Function Documentation

◆ fillDescriptions()

template<class IPTI , class VTX >
void TemplatedSecondaryVertexProducer< IPTI, VTX >::fillDescriptions ( edm::ConfigurationDescriptions descriptions)
static

Definition at line 1216 of file TemplatedSecondaryVertexProducer.cc.

1216  {
1218  desc.add<double>("extSVDeltaRToJet", 0.3);
1219  desc.add<edm::InputTag>("beamSpotTag", edm::InputTag("offlineBeamSpot"));
1220  {
1222  vertexReco.add<double>("primcut", 1.8);
1223  vertexReco.add<double>("seccut", 6.0);
1224  vertexReco.add<std::string>("finder", "avr");
1225  vertexReco.addOptionalNode(edm::ParameterDescription<double>("minweight", 0.5, true) and
1226  edm::ParameterDescription<double>("weightthreshold", 0.001, true) and
1227  edm::ParameterDescription<bool>("smoothing", false, true),
1228  true);
1229  vertexReco.addOptionalNode(
1230  edm::ParameterDescription<double>("maxFitChi2", 10.0, true) and
1231  edm::ParameterDescription<double>("mergeThreshold", 3.0, true) and
1232  edm::ParameterDescription<std::string>("fitType", "RefitGhostTrackWithVertices", true),
1233  true);
1234  desc.add<edm::ParameterSetDescription>("vertexReco", vertexReco);
1235  }
1236  {
1238  vertexSelection.add<std::string>("sortCriterium", "dist3dError");
1239  desc.add<edm::ParameterSetDescription>("vertexSelection", vertexSelection);
1240  }
1241  desc.add<std::string>("constraint", "BeamSpot");
1242  desc.add<edm::InputTag>("trackIPTagInfos", edm::InputTag("impactParameterTagInfos"));
1243  {
1245  vertexCuts.add<double>("distSig3dMax", 99999.9);
1246  vertexCuts.add<double>("fracPV", 0.65);
1247  vertexCuts.add<double>("distVal2dMax", 2.5);
1248  vertexCuts.add<bool>("useTrackWeights", true);
1249  vertexCuts.add<double>("maxDeltaRToJetAxis", 0.4);
1250  {
1252  v0Filter.add<double>("k0sMassWindow", 0.05);
1254  }
1255  vertexCuts.add<double>("distSig2dMin", 3.0);
1256  vertexCuts.add<unsigned int>("multiplicityMin", 2);
1257  vertexCuts.add<double>("distVal2dMin", 0.01);
1258  vertexCuts.add<double>("distSig2dMax", 99999.9);
1259  vertexCuts.add<double>("distVal3dMax", 99999.9);
1260  vertexCuts.add<double>("minimumTrackWeight", 0.5);
1261  vertexCuts.add<double>("distVal3dMin", -99999.9);
1262  vertexCuts.add<double>("massMax", 6.5);
1263  vertexCuts.add<double>("distSig3dMin", -99999.9);
1264  desc.add<edm::ParameterSetDescription>("vertexCuts", vertexCuts);
1265  }
1266  desc.add<bool>("useExternalSV", false);
1267  desc.add<double>("minimumTrackWeight", 0.5);
1268  desc.add<bool>("usePVError", true);
1269  {
1271  trackSelection.add<double>("b_pT", 0.3684);
1272  trackSelection.add<double>("max_pT", 500);
1273  trackSelection.add<bool>("useVariableJTA", false);
1274  trackSelection.add<double>("maxDecayLen", 99999.9);
1275  trackSelection.add<double>("sip3dValMin", -99999.9);
1276  trackSelection.add<double>("max_pT_dRcut", 0.1);
1277  trackSelection.add<double>("a_pT", 0.005263);
1278  trackSelection.add<unsigned int>("totalHitsMin", 8);
1279  trackSelection.add<double>("jetDeltaRMax", 0.3);
1280  trackSelection.add<double>("a_dR", -0.001053);
1281  trackSelection.add<double>("maxDistToAxis", 0.2);
1282  trackSelection.add<double>("ptMin", 1.0);
1283  trackSelection.add<std::string>("qualityClass", "any");
1284  trackSelection.add<unsigned int>("pixelHitsMin", 2);
1285  trackSelection.add<double>("sip2dValMax", 99999.9);
1286  trackSelection.add<double>("max_pT_trackPTcut", 3);
1287  trackSelection.add<double>("sip2dValMin", -99999.9);
1288  trackSelection.add<double>("normChi2Max", 99999.9);
1289  trackSelection.add<double>("sip3dValMax", 99999.9);
1290  trackSelection.add<double>("sip3dSigMin", -99999.9);
1291  trackSelection.add<double>("min_pT", 120);
1292  trackSelection.add<double>("min_pT_dRcut", 0.5);
1293  trackSelection.add<double>("sip2dSigMax", 99999.9);
1294  trackSelection.add<double>("sip3dSigMax", 99999.9);
1295  trackSelection.add<double>("sip2dSigMin", -99999.9);
1296  trackSelection.add<double>("b_dR", 0.6263);
1297  desc.add<edm::ParameterSetDescription>("trackSelection", trackSelection);
1298  }
1299  desc.add<std::string>("trackSort", "sip3dSig");
1300  desc.add<edm::InputTag>("extSVCollection", edm::InputTag("secondaryVertices"));
1301  desc.addOptionalNode(edm::ParameterDescription<bool>("useSVClustering", false, true) and
1302  edm::ParameterDescription<std::string>("jetAlgorithm", true) and
1303  edm::ParameterDescription<double>("rParam", true),
1304  true);
1305  desc.addOptional<bool>("useSVMomentum", false);
1306  desc.addOptional<double>("ghostRescaling", 1e-18);
1307  desc.addOptional<double>("relPtTolerance", 1e-03);
1308  desc.addOptional<edm::InputTag>("fatJets");
1309  desc.addOptional<edm::InputTag>("groomedFatJets");
1310  desc.add<edm::InputTag>("weights", edm::InputTag(""));
1311  descriptions.addDefault(desc);
1312 }

References edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, MillePedeFileConverter_cfg::e, HLT_FULL_cff::InputTag, AlCaHLTBitMon_QueryRunRegistry::string, HLT_FULL_cff::trackSelection, HLT_FULL_cff::v0Filter, HLT_FULL_cff::vertexCuts, HLT_FULL_cff::vertexReco, and HiggsMonitoring_cfi::vertexSelection.

◆ getConstraintType()

template<class IPTI , class VTX >
TemplatedSecondaryVertexProducer< IPTI, VTX >::ConstraintType TemplatedSecondaryVertexProducer< IPTI, VTX >::getConstraintType ( const std::string &  name)
staticprivate

Definition at line 207 of file TemplatedSecondaryVertexProducer.cc.

207  {
208  if (name == "None")
209  return CONSTRAINT_NONE;
210  else if (name == "BeamSpot")
211  return CONSTRAINT_BEAMSPOT;
212  else if (name == "BeamSpot+PVPosition")
214  else if (name == "BeamSpotZ+PVErrorScaledXY")
216  else if (name == "PVErrorScaled")
218  else if (name == "BeamSpot+PVTracksInFit")
220  else
221  throw cms::Exception("InvalidArgument") << "TemplatedSecondaryVertexProducer: ``constraint'' parameter "
222  "value \""
223  << name << "\" not understood." << std::endl;
224 }

References Exception, and Skims_PA_cff::name.

◆ markUsedTracks() [1/3]

template<class IPTI, class VTX>
void TemplatedSecondaryVertexProducer< IPTI, VTX >::markUsedTracks ( TrackDataVector trackData,
const input_container trackRefs,
const SecondaryVertex sv,
size_t  idx 
)
private

◆ markUsedTracks() [2/3]

template<>
void TemplatedSecondaryVertexProducer< TrackIPTagInfo, reco::Vertex >::markUsedTracks ( TrackDataVector trackData,
const input_container trackRefs,
const SecondaryVertex sv,
size_t  idx 
)
private

Definition at line 932 of file TemplatedSecondaryVertexProducer.cc.

935  {
936  for (Vertex::trackRef_iterator iter = sv.tracks_begin(); iter != sv.tracks_end(); ++iter) {
937  if (sv.trackWeight(*iter) < minTrackWeight)
938  continue;
939 
940  typename input_container::const_iterator pos =
941  std::find(trackRefs.begin(), trackRefs.end(), iter->castTo<input_item>());
942 
943  if (pos == trackRefs.end()) {
944  if (!useExternalSV)
945  throw cms::Exception("TrackNotFound") << "Could not find track from secondary "
946  "vertex in original tracks."
947  << std::endl;
948  } else {
949  unsigned int index = pos - trackRefs.begin();
950  trackData[index].second.svStatus =
951  (btag::TrackData::Status)((unsigned int)btag::TrackData::trackAssociatedToVertex + idx);
952  }
953  }
954 }

References Exception, spr::find(), heavyIonCSV_trainingSettings::idx, pfDeepBoostedJetPreprocessParams_cfi::sv, and HLT_FULL_cff::useExternalSV.

◆ markUsedTracks() [3/3]

template<>
void TemplatedSecondaryVertexProducer< CandIPTagInfo, reco::VertexCompositePtrCandidate >::markUsedTracks ( TrackDataVector trackData,
const input_container trackRefs,
const SecondaryVertex sv,
size_t  idx 
)
private

Definition at line 956 of file TemplatedSecondaryVertexProducer.cc.

957  {
958  for (typename input_container::const_iterator iter = sv.daughterPtrVector().begin();
959  iter != sv.daughterPtrVector().end();
960  ++iter) {
961  typename input_container::const_iterator pos = std::find(trackRefs.begin(), trackRefs.end(), *iter);
962 
963  if (pos != trackRefs.end()) {
964  unsigned int index = pos - trackRefs.begin();
965  trackData[index].second.svStatus =
966  (btag::TrackData::Status)((unsigned int)btag::TrackData::trackAssociatedToVertex + idx);
967  }
968  }
969 }

References spr::find(), heavyIonCSV_trainingSettings::idx, and pfDeepBoostedJetPreprocessParams_cfi::sv.

◆ matchGroomedJets()

template<class IPTI , class VTX >
void TemplatedSecondaryVertexProducer< IPTI, VTX >::matchGroomedJets ( const edm::Handle< edm::View< reco::Jet > > &  jets,
const edm::Handle< edm::View< reco::Jet > > &  matchedJets,
std::vector< int > &  matchedIndices 
)
private

Definition at line 1076 of file TemplatedSecondaryVertexProducer.cc.

1078  {
1079  std::vector<bool> jetLocks(jets->size(), false);
1080  std::vector<int> jetIndices;
1081 
1082  for (size_t gj = 0; gj < groomedJets->size(); ++gj) {
1083  double matchedDR2 = 1e9;
1084  int matchedIdx = -1;
1085 
1086  if (groomedJets->at(gj).pt() > 0.) // skip pathological cases of groomed jets with Pt=0
1087  {
1088  for (size_t j = 0; j < jets->size(); ++j) {
1089  if (jetLocks.at(j))
1090  continue; // skip jets that have already been matched
1091 
1092  double tempDR2 = Geom::deltaR2(
1093  jets->at(j).rapidity(), jets->at(j).phi(), groomedJets->at(gj).rapidity(), groomedJets->at(gj).phi());
1094  if (tempDR2 < matchedDR2) {
1095  matchedDR2 = tempDR2;
1096  matchedIdx = j;
1097  }
1098  }
1099  }
1100 
1101  if (matchedIdx >= 0) {
1102  if (matchedDR2 > rParam * rParam) {
1103  edm::LogWarning("MatchedJetsFarApart")
1104  << "Matched groomed jet " << gj << " and original jet " << matchedIdx
1105  << " are separated by dR=" << sqrt(matchedDR2) << " which is greater than the jet size R=" << rParam
1106  << ".\n"
1107  << "This is not expected so the matching of these two jets has been discarded. Please check that the two "
1108  "jet collections belong to each other.";
1109  matchedIdx = -1;
1110  } else
1111  jetLocks.at(matchedIdx) = true;
1112  }
1113  jetIndices.push_back(matchedIdx);
1114  }
1115 
1116  for (size_t j = 0; j < jets->size(); ++j) {
1117  std::vector<int>::iterator matchedIndex = std::find(jetIndices.begin(), jetIndices.end(), j);
1118 
1119  matchedIndices.push_back(matchedIndex != jetIndices.end() ? std::distance(jetIndices.begin(), matchedIndex) : -1);
1120  }
1121 }

References HLTMuonOfflineAnalyzer_cfi::deltaR2, HLT_FULL_cff::distance, spr::find(), dqmiolumiharvest::j, singleTopDQM_cfi::jets, TemplatedSecondaryVertexProducer< IPTI, VTX >::rParam, and mathSSE::sqrt().

◆ matchReclusteredJets()

template<class IPTI , class VTX >
template<class CONTAINER >
void TemplatedSecondaryVertexProducer< IPTI, VTX >::matchReclusteredJets ( const edm::Handle< CONTAINER > &  jets,
const std::vector< fastjet::PseudoJet > &  matchedJets,
std::vector< int > &  matchedIndices,
const std::string &  jetType = "" 
)
private

Definition at line 1027 of file TemplatedSecondaryVertexProducer.cc.

1031  {
1032  std::string type = (!jetType.empty() ? jetType + " " : jetType);
1033 
1034  std::vector<bool> matchedLocks(reclusteredJets.size(), false);
1035 
1036  for (size_t j = 0; j < jets->size(); ++j) {
1037  double matchedDR2 = 1e9;
1038  int matchedIdx = -1;
1039 
1040  for (size_t rj = 0; rj < reclusteredJets.size(); ++rj) {
1041  if (matchedLocks.at(rj))
1042  continue; // skip jets that have already been matched
1043 
1044  double tempDR2 = Geom::deltaR2(toJet(jets->at(j))->rapidity(),
1045  toJet(jets->at(j))->phi(),
1046  reclusteredJets.at(rj).rapidity(),
1047  reclusteredJets.at(rj).phi_std());
1048  if (tempDR2 < matchedDR2) {
1049  matchedDR2 = tempDR2;
1050  matchedIdx = rj;
1051  }
1052  }
1053 
1054  if (matchedIdx >= 0) {
1055  if (matchedDR2 > rParam * rParam) {
1056  edm::LogError("JetMatchingFailed") << "Matched reclustered jet " << matchedIdx << " and original " << type
1057  << "jet " << j << " are separated by dR=" << sqrt(matchedDR2)
1058  << " which is greater than the jet size R=" << rParam << ".\n"
1059  << "This is not expected so please check that the jet algorithm and jet "
1060  "size match those used for the original "
1061  << type << "jet collection.";
1062  } else
1063  matchedLocks.at(matchedIdx) = true;
1064  } else
1065  edm::LogError("JetMatchingFailed")
1066  << "Matching reclustered to original " << type
1067  << "jets failed. Please check that the jet algorithm and jet size match those used for the original " << type
1068  << "jet collection.";
1069 
1070  matchedIndices.push_back(matchedIdx);
1071  }
1072 }

References HLTMuonOfflineAnalyzer_cfi::deltaR2, dqmiolumiharvest::j, singleTopDQM_cfi::jets, HLT_FULL_cff::jetType, phi, TemplatedSecondaryVertexProducer< IPTI, VTX >::rParam, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, and TemplatedSecondaryVertexProducer< IPTI, VTX >::toJet().

◆ matchSubjets() [1/2]

template<class IPTI, class VTX >
void TemplatedSecondaryVertexProducer< IPTI, VTX >::matchSubjets ( const edm::Handle< edm::View< reco::Jet > > &  fatJets,
const edm::Handle< std::vector< IPTI > > &  subjets,
std::vector< std::vector< int > > &  matchedIndices 
)
private

Definition at line 1157 of file TemplatedSecondaryVertexProducer.cc.

1159  {
1160  for (size_t fj = 0; fj < fatJets->size(); ++fj) {
1161  std::vector<int> subjetIndices;
1162  size_t nSubjetCollections = 0;
1163  size_t nSubjets = 0;
1164 
1165  const pat::Jet *fatJet = dynamic_cast<const pat::Jet *>(fatJets->ptrAt(fj).get());
1166 
1167  if (!fatJet) {
1168  if (fj == 0)
1169  edm::LogError("WrongJetType")
1170  << "Wrong jet type for input fat jets. Please check that the input fat jets are of the pat::Jet type.";
1171 
1172  matchedIndices.push_back(subjetIndices);
1173  continue;
1174  } else {
1175  nSubjetCollections = fatJet->subjetCollectionNames().size();
1176 
1177  if (nSubjetCollections > 0) {
1178  for (size_t coll = 0; coll < nSubjetCollections; ++coll) {
1179  const pat::JetPtrCollection &fatJetSubjets = fatJet->subjets(coll);
1180 
1181  for (size_t fjsj = 0; fjsj < fatJetSubjets.size(); ++fjsj) {
1182  ++nSubjets;
1183 
1184  for (size_t sj = 0; sj < subjets->size(); ++sj) {
1185  const pat::Jet *subJet = dynamic_cast<const pat::Jet *>(subjets->at(sj).jet().get());
1186 
1187  if (!subJet) {
1188  if (fj == 0 && coll == 0 && fjsj == 0 && sj == 0)
1189  edm::LogError("WrongJetType") << "Wrong jet type for input subjets. Please check that the input "
1190  "subjets are of the pat::Jet type.";
1191 
1192  break;
1193  } else {
1194  if (subJet->originalObjectRef() == fatJetSubjets.at(fjsj)->originalObjectRef()) {
1195  subjetIndices.push_back(sj);
1196  break;
1197  }
1198  }
1199  }
1200  }
1201  }
1202 
1203  if (subjetIndices.empty() && nSubjets > 0)
1204  edm::LogError("SubjetMatchingFailed") << "Matching subjets to fat jets failed. Please check that the fat jet "
1205  "and subjet collections belong to each other.";
1206 
1207  matchedIndices.push_back(subjetIndices);
1208  } else
1209  matchedIndices.push_back(subjetIndices);
1210  }
1211  }
1212 }

References pat::PATObject< ObjectType >::originalObjectRef(), pat::Jet::subjetCollectionNames(), and pat::Jet::subjets().

◆ matchSubjets() [2/2]

template<class IPTI, class VTX >
void TemplatedSecondaryVertexProducer< IPTI, VTX >::matchSubjets ( const std::vector< int > &  groomedIndices,
const edm::Handle< edm::View< reco::Jet > > &  groomedJets,
const edm::Handle< std::vector< IPTI > > &  subjets,
std::vector< std::vector< int > > &  matchedIndices 
)
private

Definition at line 1125 of file TemplatedSecondaryVertexProducer.cc.

1128  {
1129  for (size_t g = 0; g < groomedIndices.size(); ++g) {
1130  std::vector<int> subjetIndices;
1131 
1132  if (groomedIndices.at(g) >= 0) {
1133  for (size_t s = 0; s < groomedJets->at(groomedIndices.at(g)).numberOfDaughters(); ++s) {
1134  const edm::Ptr<reco::Candidate> &subjet = groomedJets->at(groomedIndices.at(g)).daughterPtr(s);
1135 
1136  for (size_t sj = 0; sj < subjets->size(); ++sj) {
1137  const edm::RefToBase<reco::Jet> &subjetRef = subjets->at(sj).jet();
1138  if (subjet == edm::Ptr<reco::Candidate>(subjetRef.id(), subjetRef.get(), subjetRef.key())) {
1139  subjetIndices.push_back(sj);
1140  break;
1141  }
1142  }
1143  }
1144 
1145  if (subjetIndices.empty())
1146  edm::LogError("SubjetMatchingFailed") << "Matching subjets to original fat jets failed. Please check that the "
1147  "groomed fat jet and subjet collections belong to each other.";
1148 
1149  matchedIndices.push_back(subjetIndices);
1150  } else
1151  matchedIndices.push_back(subjetIndices);
1152  }
1153 }

References g, edm::RefToBase< T >::get(), edm::RefToBase< T >::id(), edm::RefToBase< T >::key(), and alignCSCRings::s.

◆ produce()

template<class IPTI , class VTX >
void TemplatedSecondaryVertexProducer< IPTI, VTX >::produce ( edm::Event event,
const edm::EventSetup es 
)
override

Definition at line 316 of file TemplatedSecondaryVertexProducer.cc.

316  {
317  // typedef std::map<TrackBaseRef, TransientTrack,
318  // RefToBaseLess<Track> > TransientTrackMap;
319  //How about good old pointers?
320  typedef std::map<const Track *, TransientTrack> TransientTrackMap;
321 
323 
325  event.getByToken(token_trackIPTagInfo, trackIPTagInfos);
326 
327  // External Sec Vertex collection (e.g. for IVF usage)
328  edm::Handle<edm::View<VTX> > extSecVertex;
329  if (useExternalSV)
330  event.getByToken(token_extSVCollection, extSecVertex);
331 
332  edm::Handle<edm::View<reco::Jet> > fatJetsHandle;
333  edm::Handle<edm::View<reco::Jet> > groomedFatJetsHandle;
334  if (useFatJets) {
335  event.getByToken(token_fatJets, fatJetsHandle);
336  if (useGroomedFatJets) {
337  event.getByToken(token_groomedFatJets, groomedFatJetsHandle);
338 
339  if (groomedFatJetsHandle->size() > fatJetsHandle->size())
340  edm::LogError("TooManyGroomedJets")
341  << "There are more groomed (" << groomedFatJetsHandle->size() << ") than original fat jets ("
342  << fatJetsHandle->size() << "). Please check that the two jet collections belong to each other.";
343  }
344  }
345  edm::Handle<edm::ValueMap<float> > weightsHandle;
347  event.getByToken(token_weights, weightsHandle);
348 
350  unsigned int bsCovSrc[7] = {
351  0,
352  };
353  double sigmaZ = 0.0, beamWidth = 0.0;
354  switch (constraint) {
356  event.getByToken(token_BeamSpot, beamSpot);
357  bsCovSrc[3] = bsCovSrc[4] = bsCovSrc[5] = bsCovSrc[6] = 1;
358  sigmaZ = beamSpot->sigmaZ();
359  beamWidth = beamSpot->BeamWidthX();
360  break;
361 
363  event.getByToken(token_BeamSpot, beamSpot);
364  bsCovSrc[0] = bsCovSrc[1] = 2;
365  bsCovSrc[3] = bsCovSrc[4] = bsCovSrc[5] = 1;
366  sigmaZ = beamSpot->sigmaZ();
367  break;
368 
370  bsCovSrc[0] = bsCovSrc[1] = bsCovSrc[2] = 2;
371  break;
372 
373  case CONSTRAINT_BEAMSPOT:
375  event.getByToken(token_BeamSpot, beamSpot);
376  break;
377 
378  default:
379  /* nothing */;
380  }
381 
382  // ------------------------------------ SV clustering START --------------------------------------------
383  std::vector<std::vector<int> > clusteredSVs(trackIPTagInfos->size(), std::vector<int>());
384  if (useExternalSV && useSVClustering && !trackIPTagInfos->empty()) {
385  // vector of constituents for reclustering jets and "ghost" SVs
386  std::vector<fastjet::PseudoJet> fjInputs;
387  // loop over all input jets and collect all their constituents
388  if (useFatJets) {
389  for (edm::View<reco::Jet>::const_iterator it = fatJetsHandle->begin(); it != fatJetsHandle->end(); ++it) {
390  std::vector<edm::Ptr<reco::Candidate> > constituents = it->getJetConstituents();
391  std::vector<edm::Ptr<reco::Candidate> >::const_iterator m;
392  for (m = constituents.begin(); m != constituents.end(); ++m) {
393  reco::CandidatePtr constit = *m;
394  if (constit->pt() == 0) {
395  edm::LogWarning("NullTransverseMomentum") << "dropping input candidate with pt=0";
396  continue;
397  }
398  if (it->isWeighted()) {
400  throw cms::Exception("MissingConstituentWeight")
401  << "TemplatedSecondaryVertexProducer: No weights (e.g. PUPPI) given for weighted jet collection"
402  << std::endl;
403  float w = (*weightsHandle)[constit];
404  fjInputs.push_back(
405  fastjet::PseudoJet(constit->px() * w, constit->py() * w, constit->pz() * w, constit->energy() * w));
406  } else {
407  fjInputs.push_back(fastjet::PseudoJet(constit->px(), constit->py(), constit->pz(), constit->energy()));
408  }
409  }
410  }
411  } else {
412  for (typename std::vector<IPTI>::const_iterator it = trackIPTagInfos->begin(); it != trackIPTagInfos->end();
413  ++it) {
414  std::vector<edm::Ptr<reco::Candidate> > constituents = it->jet()->getJetConstituents();
415  std::vector<edm::Ptr<reco::Candidate> >::const_iterator m;
416  for (m = constituents.begin(); m != constituents.end(); ++m) {
417  reco::CandidatePtr constit = *m;
418  if (constit->pt() == 0) {
419  edm::LogWarning("NullTransverseMomentum") << "dropping input candidate with pt=0";
420  continue;
421  }
422  if (it->jet()->isWeighted()) {
424  throw cms::Exception("MissingConstituentWeight")
425  << "TemplatedSecondaryVertexProducer: No weights (e.g. PUPPI) given for weighted jet collection"
426  << std::endl;
427  float w = (*weightsHandle)[constit];
428  fjInputs.push_back(
429  fastjet::PseudoJet(constit->px() * w, constit->py() * w, constit->pz() * w, constit->energy() * w));
430  } else {
431  fjInputs.push_back(fastjet::PseudoJet(constit->px(), constit->py(), constit->pz(), constit->energy()));
432  }
433  }
434  }
435  }
436  // insert "ghost" SVs in the vector of constituents
437  for (typename edm::View<VTX>::const_iterator it = extSecVertex->begin(); it != extSecVertex->end(); ++it) {
438  const reco::Vertex &pv = *(trackIPTagInfos->front().primaryVertex());
440  dir = dir.unit();
441  fastjet::PseudoJet p(
442  dir.x(), dir.y(), dir.z(), dir.mag()); // using SV flight direction so treating SV as massless
443  if (useSVMomentum)
444  p = fastjet::PseudoJet(it->p4().px(), it->p4().py(), it->p4().pz(), it->p4().energy());
445  p *= ghostRescaling; // rescale SV direction/momentum
446  p.set_user_info(new VertexInfo(it - extSecVertex->begin()));
447  fjInputs.push_back(p);
448  }
449 
450  // define jet clustering sequence
451  fjClusterSeq = std::make_shared<fastjet::ClusterSequence>(fjInputs, *fjJetDefinition);
452  // recluster jet constituents and inserted "ghosts"
453  std::vector<fastjet::PseudoJet> inclusiveJets = fastjet::sorted_by_pt(fjClusterSeq->inclusive_jets(jetPtMin));
454 
455  if (useFatJets) {
456  if (inclusiveJets.size() < fatJetsHandle->size())
457  edm::LogError("TooFewReclusteredJets")
458  << "There are fewer reclustered (" << inclusiveJets.size() << ") than original fat jets ("
459  << fatJetsHandle->size()
460  << "). Please check that the jet algorithm and jet size match those used for the original jet collection.";
461 
462  // match reclustered and original fat jets
463  std::vector<int> reclusteredIndices;
464  matchReclusteredJets<edm::View<reco::Jet> >(fatJetsHandle, inclusiveJets, reclusteredIndices, "fat");
465 
466  // match groomed and original fat jets
467  std::vector<int> groomedIndices;
468  if (useGroomedFatJets)
469  matchGroomedJets(fatJetsHandle, groomedFatJetsHandle, groomedIndices);
470 
471  // match subjets and original fat jets
472  std::vector<std::vector<int> > subjetIndices;
473  if (useGroomedFatJets)
474  matchSubjets(groomedIndices, groomedFatJetsHandle, trackIPTagInfos, subjetIndices);
475  else
476  matchSubjets(fatJetsHandle, trackIPTagInfos, subjetIndices);
477 
478  // collect clustered SVs
479  for (size_t i = 0; i < fatJetsHandle->size(); ++i) {
480  if (reclusteredIndices.at(i) < 0)
481  continue; // continue if matching reclustered to original jets failed
482 
483  if (fatJetsHandle->at(i).pt() == 0) // continue if the original jet has Pt=0
484  {
485  edm::LogWarning("NullTransverseMomentum")
486  << "The original fat jet " << i << " has Pt=0. This is not expected so the jet will be skipped.";
487  continue;
488  }
489 
490  if (subjetIndices.at(i).empty())
491  continue; // continue if the original jet does not have subjets assigned
492 
493  // since the "ghosts" are extremely soft, the configuration and ordering of the reclustered and original fat jets should in principle stay the same
494  if ((std::abs(inclusiveJets.at(reclusteredIndices.at(i)).pt() - fatJetsHandle->at(i).pt()) /
495  fatJetsHandle->at(i).pt()) > relPtTolerance) {
496  if (fatJetsHandle->at(i).pt() < 10.) // special handling for low-Pt jets (Pt<10 GeV)
497  edm::LogWarning("JetPtMismatchAtLowPt")
498  << "The reclustered and original fat jet " << i << " have different Pt's ("
499  << inclusiveJets.at(reclusteredIndices.at(i)).pt() << " vs " << fatJetsHandle->at(i).pt()
500  << " GeV, respectively).\n"
501  << "Please check that the jet algorithm and jet size match those used for the original fat jet "
502  "collection and also make sure the original fat jets are uncorrected. In addition, make sure you "
503  "are not using CaloJets which are presently not supported.\n"
504  << "Since the mismatch is at low Pt, it is ignored and only a warning is issued.\n"
505  << "\nIn extremely rare instances the mismatch could be caused by a difference in the machine "
506  "precision in which case make sure the original jet collection is produced and reclustering is "
507  "performed in the same job.";
508  else
509  edm::LogError("JetPtMismatch")
510  << "The reclustered and original fat jet " << i << " have different Pt's ("
511  << inclusiveJets.at(reclusteredIndices.at(i)).pt() << " vs " << fatJetsHandle->at(i).pt()
512  << " GeV, respectively).\n"
513  << "Please check that the jet algorithm and jet size match those used for the original fat jet "
514  "collection and also make sure the original fat jets are uncorrected. In addition, make sure you "
515  "are not using CaloJets which are presently not supported.\n"
516  << "\nIn extremely rare instances the mismatch could be caused by a difference in the machine "
517  "precision in which case make sure the original jet collection is produced and reclustering is "
518  "performed in the same job.";
519  }
520 
521  // get jet constituents
522  std::vector<fastjet::PseudoJet> constituents = inclusiveJets.at(reclusteredIndices.at(i)).constituents();
523 
524  std::vector<int> svIndices;
525  // loop over jet constituents and try to find "ghosts"
526  for (std::vector<fastjet::PseudoJet>::const_iterator it = constituents.begin(); it != constituents.end();
527  ++it) {
528  if (!it->has_user_info())
529  continue; // skip if not a "ghost"
530 
531  svIndices.push_back(it->user_info<VertexInfo>().vertexIndex());
532  }
533 
534  // loop over clustered SVs and assign them to different subjets based on smallest dR
535  for (size_t sv = 0; sv < svIndices.size(); ++sv) {
536  const reco::Vertex &pv = *(trackIPTagInfos->front().primaryVertex());
537  const VTX &extSV = (*extSecVertex)[svIndices.at(sv)];
539  dir = dir.unit();
540  fastjet::PseudoJet p(
541  dir.x(), dir.y(), dir.z(), dir.mag()); // using SV flight direction so treating SV as massless
542  if (useSVMomentum)
543  p = fastjet::PseudoJet(extSV.p4().px(), extSV.p4().py(), extSV.p4().pz(), extSV.p4().energy());
544 
545  std::vector<double> dR2toSubjets;
546 
547  for (size_t sj = 0; sj < subjetIndices.at(i).size(); ++sj)
548  dR2toSubjets.push_back(Geom::deltaR2(p.rapidity(),
549  p.phi_std(),
550  trackIPTagInfos->at(subjetIndices.at(i).at(sj)).jet()->rapidity(),
551  trackIPTagInfos->at(subjetIndices.at(i).at(sj)).jet()->phi()));
552 
553  // find the closest subjet
554  int closestSubjetIdx =
555  std::distance(dR2toSubjets.begin(), std::min_element(dR2toSubjets.begin(), dR2toSubjets.end()));
556 
557  clusteredSVs.at(subjetIndices.at(i).at(closestSubjetIdx)).push_back(svIndices.at(sv));
558  }
559  }
560  } else {
561  if (inclusiveJets.size() < trackIPTagInfos->size())
562  edm::LogError("TooFewReclusteredJets")
563  << "There are fewer reclustered (" << inclusiveJets.size() << ") than original jets ("
564  << trackIPTagInfos->size()
565  << "). Please check that the jet algorithm and jet size match those used for the original jet collection.";
566 
567  // match reclustered and original jets
568  std::vector<int> reclusteredIndices;
569  matchReclusteredJets<std::vector<IPTI> >(trackIPTagInfos, inclusiveJets, reclusteredIndices);
570 
571  // collect clustered SVs
572  for (size_t i = 0; i < trackIPTagInfos->size(); ++i) {
573  if (reclusteredIndices.at(i) < 0)
574  continue; // continue if matching reclustered to original jets failed
575 
576  if (trackIPTagInfos->at(i).jet()->pt() == 0) // continue if the original jet has Pt=0
577  {
578  edm::LogWarning("NullTransverseMomentum")
579  << "The original jet " << i << " has Pt=0. This is not expected so the jet will be skipped.";
580  continue;
581  }
582 
583  // since the "ghosts" are extremely soft, the configuration and ordering of the reclustered and original jets should in principle stay the same
584  if ((std::abs(inclusiveJets.at(reclusteredIndices.at(i)).pt() - trackIPTagInfos->at(i).jet()->pt()) /
585  trackIPTagInfos->at(i).jet()->pt()) > relPtTolerance) {
586  if (trackIPTagInfos->at(i).jet()->pt() < 10.) // special handling for low-Pt jets (Pt<10 GeV)
587  edm::LogWarning("JetPtMismatchAtLowPt")
588  << "The reclustered and original jet " << i << " have different Pt's ("
589  << inclusiveJets.at(reclusteredIndices.at(i)).pt() << " vs " << trackIPTagInfos->at(i).jet()->pt()
590  << " GeV, respectively).\n"
591  << "Please check that the jet algorithm and jet size match those used for the original jet collection "
592  "and also make sure the original jets are uncorrected. In addition, make sure you are not using "
593  "CaloJets which are presently not supported.\n"
594  << "Since the mismatch is at low Pt, it is ignored and only a warning is issued.\n"
595  << "\nIn extremely rare instances the mismatch could be caused by a difference in the machine "
596  "precision in which case make sure the original jet collection is produced and reclustering is "
597  "performed in the same job.";
598  else
599  edm::LogError("JetPtMismatch")
600  << "The reclustered and original jet " << i << " have different Pt's ("
601  << inclusiveJets.at(reclusteredIndices.at(i)).pt() << " vs " << trackIPTagInfos->at(i).jet()->pt()
602  << " GeV, respectively).\n"
603  << "Please check that the jet algorithm and jet size match those used for the original jet collection "
604  "and also make sure the original jets are uncorrected. In addition, make sure you are not using "
605  "CaloJets which are presently not supported.\n"
606  << "\nIn extremely rare instances the mismatch could be caused by a difference in the machine "
607  "precision in which case make sure the original jet collection is produced and reclustering is "
608  "performed in the same job.";
609  }
610 
611  // get jet constituents
612  std::vector<fastjet::PseudoJet> constituents = inclusiveJets.at(reclusteredIndices.at(i)).constituents();
613 
614  // loop over jet constituents and try to find "ghosts"
615  for (std::vector<fastjet::PseudoJet>::const_iterator it = constituents.begin(); it != constituents.end();
616  ++it) {
617  if (!it->has_user_info())
618  continue; // skip if not a "ghost"
619  // push back clustered SV indices
620  clusteredSVs.at(i).push_back(it->user_info<VertexInfo>().vertexIndex());
621  }
622  }
623  }
624  }
625  // case where fat jets are used to associate SVs to subjets but no SV clustering is performed
626  else if (useExternalSV && !useSVClustering && !trackIPTagInfos->empty() && useFatJets) {
627  // match groomed and original fat jets
628  std::vector<int> groomedIndices;
629  if (useGroomedFatJets)
630  matchGroomedJets(fatJetsHandle, groomedFatJetsHandle, groomedIndices);
631 
632  // match subjets and original fat jets
633  std::vector<std::vector<int> > subjetIndices;
634  if (useGroomedFatJets)
635  matchSubjets(groomedIndices, groomedFatJetsHandle, trackIPTagInfos, subjetIndices);
636  else
637  matchSubjets(fatJetsHandle, trackIPTagInfos, subjetIndices);
638 
639  // loop over fat jets
640  for (size_t i = 0; i < fatJetsHandle->size(); ++i) {
641  if (fatJetsHandle->at(i).pt() == 0) // continue if the original jet has Pt=0
642  {
643  edm::LogWarning("NullTransverseMomentum")
644  << "The original fat jet " << i << " has Pt=0. This is not expected so the jet will be skipped.";
645  continue;
646  }
647 
648  if (subjetIndices.at(i).empty())
649  continue; // continue if the original jet does not have subjets assigned
650 
651  // loop over SVs, associate them to fat jets based on dR cone and
652  // then assign them to the closets subjet in dR
653  for (typename edm::View<VTX>::const_iterator it = extSecVertex->begin(); it != extSecVertex->end(); ++it) {
654  size_t sv = (it - extSecVertex->begin());
655 
656  const reco::Vertex &pv = *(trackIPTagInfos->front().primaryVertex());
657  const VTX &extSV = (*extSecVertex)[sv];
659  GlobalVector jetDir(fatJetsHandle->at(i).px(), fatJetsHandle->at(i).py(), fatJetsHandle->at(i).pz());
660  // skip SVs outside the dR cone
661  if (Geom::deltaR2(dir, jetDir) > rParam * rParam) // here using the jet clustering rParam as a dR cut
662  continue;
663 
664  dir = dir.unit();
665  fastjet::PseudoJet p(
666  dir.x(), dir.y(), dir.z(), dir.mag()); // using SV flight direction so treating SV as massless
667  if (useSVMomentum)
668  p = fastjet::PseudoJet(extSV.p4().px(), extSV.p4().py(), extSV.p4().pz(), extSV.p4().energy());
669 
670  std::vector<double> dR2toSubjets;
671 
672  for (size_t sj = 0; sj < subjetIndices.at(i).size(); ++sj)
673  dR2toSubjets.push_back(Geom::deltaR2(p.rapidity(),
674  p.phi_std(),
675  trackIPTagInfos->at(subjetIndices.at(i).at(sj)).jet()->rapidity(),
676  trackIPTagInfos->at(subjetIndices.at(i).at(sj)).jet()->phi()));
677 
678  // find the closest subjet
679  int closestSubjetIdx =
680  std::distance(dR2toSubjets.begin(), std::min_element(dR2toSubjets.begin(), dR2toSubjets.end()));
681 
682  clusteredSVs.at(subjetIndices.at(i).at(closestSubjetIdx)).push_back(sv);
683  }
684  }
685  }
686  // ------------------------------------ SV clustering END ----------------------------------------------
687 
688  std::unique_ptr<ConfigurableVertexReconstructor> vertexReco;
689  std::unique_ptr<GhostTrackVertexFinder> vertexRecoGT;
690  if (useGhostTrack)
691  vertexRecoGT = std::make_unique<GhostTrackVertexFinder>(
692  vtxRecoPSet.getParameter<double>("maxFitChi2"),
693  vtxRecoPSet.getParameter<double>("mergeThreshold"),
694  vtxRecoPSet.getParameter<double>("primcut"),
695  vtxRecoPSet.getParameter<double>("seccut"),
697  else
698  vertexReco = std::make_unique<ConfigurableVertexReconstructor>(vtxRecoPSet);
699 
700  TransientTrackMap primariesMap;
701 
702  // result secondary vertices
703 
704  auto tagInfos = std::make_unique<Product>();
705 
706  for (typename std::vector<IPTI>::const_iterator iterJets = trackIPTagInfos->begin();
707  iterJets != trackIPTagInfos->end();
708  ++iterJets) {
709  TrackDataVector trackData;
710  // std::cout << "Jet " << iterJets-trackIPTagInfos->begin() << std::endl;
711 
712  const Vertex &pv = *iterJets->primaryVertex();
713 
714  std::set<TransientTrack> primaries;
716  for (Vertex::trackRef_iterator iter = pv.tracks_begin(); iter != pv.tracks_end(); ++iter) {
717  TransientTrackMap::iterator pos = primariesMap.lower_bound(iter->get());
718 
719  if (pos != primariesMap.end() && pos->first == iter->get())
720  primaries.insert(pos->second);
721  else {
722  TransientTrack track = trackBuilder->build(iter->castTo<TrackRef>());
723  primariesMap.insert(pos, std::make_pair(iter->get(), track));
724  primaries.insert(track);
725  }
726  }
727  }
728 
729  edm::RefToBase<Jet> jetRef = iterJets->jet();
730 
731  GlobalVector jetDir(jetRef->momentum().x(), jetRef->momentum().y(), jetRef->momentum().z());
732 
733  std::vector<std::size_t> indices = iterJets->sortedIndexes(sortCriterium);
734 
735  input_container trackRefs = iterJets->sortedTracks(indices);
736 
737  const std::vector<reco::btag::TrackIPData> &ipData = iterJets->impactParameterData();
738 
739  // build transient tracks used for vertex reconstruction
740 
741  std::vector<TransientTrack> fitTracks;
742  std::vector<GhostTrackState> gtStates;
743  std::unique_ptr<GhostTrackPrediction> gtPred;
744  if (useGhostTrack)
745  gtPred = std::make_unique<GhostTrackPrediction>(*iterJets->ghostTrack());
746 
747  for (unsigned int i = 0; i < indices.size(); i++) {
749 
750  const input_item &trackRef = trackRefs[i];
751 
752  trackData.push_back(IndexedTrackData());
753  trackData.back().first = indices[i];
754 
755  // select tracks for SV finder
756 
757  if (!trackSelector(
758  *reco::btag::toTrack(trackRef), ipData[indices[i]], *jetRef, RecoVertex::convertPos(pv.position()))) {
760  continue;
761  }
762 
763  TransientTrackMap::const_iterator pos = primariesMap.find(reco::btag::toTrack((trackRef)));
764  TransientTrack fitTrack;
765  if (pos != primariesMap.end()) {
766  primaries.erase(pos->second);
767  fitTrack = pos->second;
768  } else
769  fitTrack = trackBuilder->build(trackRef);
770  fitTracks.push_back(fitTrack);
771 
773 
774  if (useGhostTrack) {
775  GhostTrackState gtState(fitTrack);
776  GlobalPoint pos = ipData[indices[i]].closestToGhostTrack;
777  gtState.linearize(*gtPred, true, gtPred->lambda(pos));
778  gtState.setWeight(ipData[indices[i]].ghostTrackWeight);
779  gtStates.push_back(gtState);
780  }
781  }
782 
783  std::unique_ptr<GhostTrack> ghostTrack;
784  if (useGhostTrack)
785  ghostTrack = std::make_unique<GhostTrack>(
787  RecoVertex::convertPos(pv.position()),
788  RecoVertex::convertError(pv.error()),
789  GlobalVector(iterJets->ghostTrack()->px(), iterJets->ghostTrack()->py(), iterJets->ghostTrack()->pz()),
790  0.05),
791  *gtPred,
792  gtStates,
793  iterJets->ghostTrack()->chi2(),
794  iterJets->ghostTrack()->ndof());
795 
796  // perform actual vertex finding
797 
798  std::vector<VTX> extAssoCollection;
799  std::vector<TransientVertex> fittedSVs;
800  std::vector<SecondaryVertex> SVs;
801  if (!useExternalSV) {
802  switch (constraint) {
803  case CONSTRAINT_NONE:
804  if (useGhostTrack)
805  fittedSVs = vertexRecoGT->vertices(pv, *ghostTrack);
806  else
807  fittedSVs = vertexReco->vertices(fitTracks);
808  break;
809 
810  case CONSTRAINT_BEAMSPOT:
811  if (useGhostTrack)
812  fittedSVs = vertexRecoGT->vertices(pv, *beamSpot, *ghostTrack);
813  else
814  fittedSVs = vertexReco->vertices(fitTracks, *beamSpot);
815  break;
816 
821  for (unsigned int i = 0; i < 7; i++) {
822  unsigned int covSrc = bsCovSrc[i];
823  for (unsigned int j = 0; j < 7; j++) {
824  double v = 0.0;
825  if (!covSrc || bsCovSrc[j] != covSrc)
826  v = 0.0;
827  else if (covSrc == 1)
828  v = beamSpot->covariance(i, j);
829  else if (j < 3 && i < 3)
830  v = pv.covariance(i, j) * constraintScaling;
831  cov(i, j) = v;
832  }
833  }
834 
835  BeamSpot bs(pv.position(),
836  sigmaZ,
837  beamSpot.isValid() ? beamSpot->dxdz() : 0.,
838  beamSpot.isValid() ? beamSpot->dydz() : 0.,
839  beamWidth,
840  cov,
842 
843  if (useGhostTrack)
844  fittedSVs = vertexRecoGT->vertices(pv, bs, *ghostTrack);
845  else
846  fittedSVs = vertexReco->vertices(fitTracks, bs);
847  } break;
848 
850  std::vector<TransientTrack> primaries_(primaries.begin(), primaries.end());
851  if (useGhostTrack)
852  fittedSVs = vertexRecoGT->vertices(pv, *beamSpot, primaries_, *ghostTrack);
853  else
854  fittedSVs = vertexReco->vertices(primaries_, fitTracks, *beamSpot);
855  } break;
856  }
857  // build combined SV information and filter
858  SVBuilder svBuilder(pv, jetDir, withPVError, minTrackWeight);
859  std::remove_copy_if(boost::make_transform_iterator(fittedSVs.begin(), svBuilder),
860  boost::make_transform_iterator(fittedSVs.end(), svBuilder),
861  std::back_inserter(SVs),
862  SVFilter(vertexFilter, pv, jetDir));
863 
864  } else {
865  if (useSVClustering || useFatJets) {
866  size_t jetIdx = (iterJets - trackIPTagInfos->begin());
867 
868  for (size_t iExtSv = 0; iExtSv < clusteredSVs.at(jetIdx).size(); iExtSv++) {
869  const VTX &extVertex = (*extSecVertex)[clusteredSVs.at(jetIdx).at(iExtSv)];
870  if (extVertex.p4().M() < 0.3)
871  continue;
872  extAssoCollection.push_back(extVertex);
873  }
874  } else {
875  for (size_t iExtSv = 0; iExtSv < extSecVertex->size(); iExtSv++) {
876  const VTX &extVertex = (*extSecVertex)[iExtSv];
877  if (Geom::deltaR2((position(extVertex) - pv.position()), (extSVDeltaRToJet > 0) ? jetDir : -jetDir) >
879  extVertex.p4().M() < 0.3)
880  continue;
881  extAssoCollection.push_back(extVertex);
882  }
883  }
884  // build combined SV information and filter
885  SVBuilder svBuilder(pv, jetDir, withPVError, minTrackWeight);
886  std::remove_copy_if(boost::make_transform_iterator(extAssoCollection.begin(), svBuilder),
887  boost::make_transform_iterator(extAssoCollection.end(), svBuilder),
888  std::back_inserter(SVs),
889  SVFilter(vertexFilter, pv, jetDir));
890  }
891  // clean up now unneeded collections
892  gtPred.reset();
893  ghostTrack.reset();
894  gtStates.clear();
895  fitTracks.clear();
896  fittedSVs.clear();
897  extAssoCollection.clear();
898 
899  // sort SVs by importance
900 
901  std::vector<unsigned int> vtxIndices = vertexSorting(SVs);
902 
903  std::vector<typename TemplatedSecondaryVertexTagInfo<IPTI, VTX>::VertexData> svData;
904 
905  svData.resize(vtxIndices.size());
906  for (unsigned int idx = 0; idx < vtxIndices.size(); idx++) {
907  const SecondaryVertex &sv = SVs[vtxIndices[idx]];
908 
909  svData[idx].vertex = sv;
910  svData[idx].dist1d = sv.dist1d();
911  svData[idx].dist2d = sv.dist2d();
912  svData[idx].dist3d = sv.dist3d();
913  svData[idx].direction = flightDirection(pv, sv);
914  // mark tracks successfully used in vertex fit
915  markUsedTracks(trackData, trackRefs, sv, idx);
916  }
917 
918  // fill result into tag infos
919 
921  trackData,
922  svData,
923  SVs.size(),
925  }
926 
927  event.put(std::move(tagInfos));
928 }

References funct::abs(), pwdgSkimBPark_cfi::beamSpot, cms::cuda::bs, TransientTrackBuilder::build(), HLT_FULL_cff::constraint, RecoVertex::convertError(), RecoVertex::convertPos(), HLTMuonOfflineAnalyzer_cfi::deltaR2, DeadROC_duringRun::dir, HLT_FULL_cff::distance, reco::Candidate::energy(), HLT_FULL_cff::extSVDeltaRToJet, flightDirection(), getGhostTrackFitType(), edm::EventSetup::getHandle(), AK4PFJetsMCFlavourInfos_cfi::ghostRescaling, mps_fire::i, heavyIonCSV_trainingSettings::idx, dqmdumpme::indices, dqmiolumiharvest::j, metsig::jet, boostedTaus_cff::jetIdx, pdwgLeptonRecoSkim_cfi::jetPtMin, reco::GhostTrackState::linearize(), visualization-live-secondInstance_cfg::m, eostools::move(), AlCaHLTBitMon_ParallelJobs::p, position(), DiDispStaMuonMonitor_cfi::pt, reco::Candidate::pt(), MetAnalyzer::pv(), reco::Candidate::px(), reco::Candidate::py(), reco::Candidate::pz(), HLT_FULL_cff::rParam, reco::GhostTrackState::setWeight(), BeamSpotPI::sigmaZ, HLT_FULL_cff::sortCriterium, AlCaHLTBitMon_QueryRunRegistry::string, pfDeepBoostedJetPreprocessParams_cfi::sv, HLT_FULL_cff::tagInfos, reco::btag::toTrack(), HLT_FULL_cff::track, HLT_FULL_cff::trackIPTagInfos, MinBiasPDSkim_cfg::trackSelector, reco::Unknown, HLT_FULL_cff::useExternalSV, findQualityFiles::v, bVertexFilter_cfi::vertexFilter, HLT_FULL_cff::vertexReco, and w.

◆ toJet() [1/2]

template<class IPTI, class VTX>
const reco::Jet* TemplatedSecondaryVertexProducer< IPTI, VTX >::toJet ( const IPTI &  j)
inlineprivate

Definition at line 132 of file TemplatedSecondaryVertexProducer.cc.

132 { return &(*(j.jet())); }

References dqmiolumiharvest::j.

◆ toJet() [2/2]

template<class IPTI, class VTX>
const reco::Jet* TemplatedSecondaryVertexProducer< IPTI, VTX >::toJet ( const reco::Jet j)
inlineprivate

Member Data Documentation

◆ constraint

template<class IPTI, class VTX>
ConstraintType TemplatedSecondaryVertexProducer< IPTI, VTX >::constraint
private

◆ constraintScaling

template<class IPTI, class VTX>
double TemplatedSecondaryVertexProducer< IPTI, VTX >::constraintScaling
private

◆ extSVDeltaRToJet

template<class IPTI, class VTX>
double TemplatedSecondaryVertexProducer< IPTI, VTX >::extSVDeltaRToJet
private

◆ fjClusterSeq

template<class IPTI, class VTX>
ClusterSequencePtr TemplatedSecondaryVertexProducer< IPTI, VTX >::fjClusterSeq
private

Definition at line 173 of file TemplatedSecondaryVertexProducer.cc.

◆ fjJetDefinition

template<class IPTI, class VTX>
JetDefPtr TemplatedSecondaryVertexProducer< IPTI, VTX >::fjJetDefinition
private

◆ ghostRescaling

template<class IPTI, class VTX>
double TemplatedSecondaryVertexProducer< IPTI, VTX >::ghostRescaling
private

◆ jetAlgorithm

template<class IPTI, class VTX>
std::string TemplatedSecondaryVertexProducer< IPTI, VTX >::jetAlgorithm
private

◆ jetPtMin

template<class IPTI, class VTX>
double TemplatedSecondaryVertexProducer< IPTI, VTX >::jetPtMin
private

◆ minTrackWeight

template<class IPTI, class VTX>
double TemplatedSecondaryVertexProducer< IPTI, VTX >::minTrackWeight
private

◆ relPtTolerance

template<class IPTI, class VTX>
double TemplatedSecondaryVertexProducer< IPTI, VTX >::relPtTolerance
private

◆ rParam

template<class IPTI, class VTX>
double TemplatedSecondaryVertexProducer< IPTI, VTX >::rParam
private

◆ sortCriterium

template<class IPTI, class VTX>
reco::btag::SortCriteria TemplatedSecondaryVertexProducer< IPTI, VTX >::sortCriterium
private

Definition at line 146 of file TemplatedSecondaryVertexProducer.cc.

◆ token_BeamSpot

template<class IPTI, class VTX>
edm::EDGetTokenT<reco::BeamSpot> TemplatedSecondaryVertexProducer< IPTI, VTX >::token_BeamSpot
private

◆ token_extSVCollection

template<class IPTI, class VTX>
edm::EDGetTokenT<edm::View<VTX> > TemplatedSecondaryVertexProducer< IPTI, VTX >::token_extSVCollection
private

◆ token_fatJets

template<class IPTI, class VTX>
edm::EDGetTokenT<edm::View<reco::Jet> > TemplatedSecondaryVertexProducer< IPTI, VTX >::token_fatJets
private

◆ token_groomedFatJets

template<class IPTI, class VTX>
edm::EDGetTokenT<edm::View<reco::Jet> > TemplatedSecondaryVertexProducer< IPTI, VTX >::token_groomedFatJets
private

◆ token_trackBuilder

template<class IPTI, class VTX>
edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> TemplatedSecondaryVertexProducer< IPTI, VTX >::token_trackBuilder
private

◆ token_trackIPTagInfo

template<class IPTI, class VTX>
edm::EDGetTokenT<std::vector<IPTI> > TemplatedSecondaryVertexProducer< IPTI, VTX >::token_trackIPTagInfo
private

◆ token_weights

template<class IPTI, class VTX>
edm::EDGetTokenT<edm::ValueMap<float> > TemplatedSecondaryVertexProducer< IPTI, VTX >::token_weights
private

◆ trackSelector

template<class IPTI, class VTX>
TrackSelector TemplatedSecondaryVertexProducer< IPTI, VTX >::trackSelector
private

Definition at line 147 of file TemplatedSecondaryVertexProducer.cc.

◆ useExternalSV

template<class IPTI, class VTX>
bool TemplatedSecondaryVertexProducer< IPTI, VTX >::useExternalSV
private

◆ useFatJets

template<class IPTI, class VTX>
bool TemplatedSecondaryVertexProducer< IPTI, VTX >::useFatJets
private

◆ useGhostTrack

template<class IPTI, class VTX>
bool TemplatedSecondaryVertexProducer< IPTI, VTX >::useGhostTrack
private

Definition at line 151 of file TemplatedSecondaryVertexProducer.cc.

◆ useGroomedFatJets

template<class IPTI, class VTX>
bool TemplatedSecondaryVertexProducer< IPTI, VTX >::useGroomedFatJets
private

◆ useSVClustering

template<class IPTI, class VTX>
bool TemplatedSecondaryVertexProducer< IPTI, VTX >::useSVClustering
private

◆ useSVMomentum

template<class IPTI, class VTX>
bool TemplatedSecondaryVertexProducer< IPTI, VTX >::useSVMomentum
private

◆ vertexFilter

template<class IPTI, class VTX>
VertexFilter TemplatedSecondaryVertexProducer< IPTI, VTX >::vertexFilter
private

Definition at line 154 of file TemplatedSecondaryVertexProducer.cc.

◆ vertexSorting

template<class IPTI, class VTX>
VertexSorting<SecondaryVertex> TemplatedSecondaryVertexProducer< IPTI, VTX >::vertexSorting
private

Definition at line 155 of file TemplatedSecondaryVertexProducer.cc.

◆ vtxRecoPSet

template<class IPTI, class VTX>
edm::ParameterSet TemplatedSecondaryVertexProducer< IPTI, VTX >::vtxRecoPSet
private

Definition at line 150 of file TemplatedSecondaryVertexProducer.cc.

◆ withPVError

template<class IPTI, class VTX>
bool TemplatedSecondaryVertexProducer< IPTI, VTX >::withPVError
private
Vector3DBase
Definition: Vector3DBase.h:8
reco::Candidate::energy
virtual double energy() const =0
energy
reco::Vertex::trackRef_iterator
std::vector< TrackBaseRef >::const_iterator trackRef_iterator
The iteratator for the vector<TrackRef>
Definition: Vertex.h:38
TemplatedSecondaryVertexProducer::useFatJets
bool useFatJets
Definition: TemplatedSecondaryVertexProducer.cc:166
TemplatedSecondaryVertexProducer::token_weights
edm::EDGetTokenT< edm::ValueMap< float > > token_weights
Definition: TemplatedSecondaryVertexProducer.cc:170
flightDirection
GlobalVector flightDirection(const reco::Vertex &pv, const reco::Vertex &sv)
Definition: TemplatedSecondaryVertexProducer.cc:92
mps_fire.i
i
Definition: mps_fire.py:428
edm::ESInputTag
Definition: ESInputTag.h:87
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11724
HLT_FULL_cff.tagInfos
tagInfos
Definition: HLT_FULL_cff.py:53022
TemplatedSecondaryVertexProducer::constraintScaling
double constraintScaling
Definition: TemplatedSecondaryVertexProducer.cc:149
TemplatedSecondaryVertexProducer::minTrackWeight
double minTrackWeight
Definition: TemplatedSecondaryVertexProducer.cc:153
TemplatedSecondaryVertexProducer::vertexFilter
VertexFilter vertexFilter
Definition: TemplatedSecondaryVertexProducer.cc:154
BeamSpotPI::sigmaZ
Definition: BeamSpotPayloadInspectorHelper.h:36
TemplatedSecondaryVertexProducer::useExternalSV
bool useExternalSV
Definition: TemplatedSecondaryVertexProducer.cc:156
edm::RefToBase::key
size_t key() const
Definition: RefToBase.h:219
pat::Jet::subjets
pat::JetPtrCollection const & subjets(unsigned int index=0) const
Access to subjet list.
HiggsMonitoring_cfi.vertexSelection
vertexSelection
Definition: HiggsMonitoring_cfi.py:107
TemplatedSecondaryVertexProducer::toJet
const reco::Jet * toJet(const reco::Jet &j)
Definition: TemplatedSecondaryVertexProducer.cc:131
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
TemplatedSecondaryVertexProducer::markUsedTracks
void markUsedTracks(TrackDataVector &trackData, const input_container &trackRefs, const SecondaryVertex &sv, size_t idx)
CalibrationSummaryClient_cfi.params
params
Definition: CalibrationSummaryClient_cfi.py:14
reco::btag::toTrack
const reco::Track * toTrack(const reco::TrackBaseRef &t)
Definition: IPTagInfo.h:24
TemplatedSecondaryVertexProducer::trackSelector
TrackSelector trackSelector
Definition: TemplatedSecondaryVertexProducer.cc:147
HLT_FULL_cff.vertexCuts
vertexCuts
Definition: HLT_FULL_cff.py:52035
pos
Definition: PixelAliasList.h:18
reco::TemplatedSecondaryVertexTagInfo
Definition: TemplatedSecondaryVertexTagInfo.h:47
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89301
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
reco::Candidate::pt
virtual double pt() const =0
transverse momentum
edm::EDGetTokenT::isUninitialized
constexpr bool isUninitialized() const noexcept
Definition: EDGetToken.h:99
reco::Unknown
Definition: MuonSimInfo.h:32
TemplatedSecondaryVertexProducer::useGroomedFatJets
bool useGroomedFatJets
Definition: TemplatedSecondaryVertexProducer.cc:167
singleTopDQM_cfi.jets
jets
Definition: singleTopDQM_cfi.py:42
GlobalVector
Global3DVector GlobalVector
Definition: GlobalVector.h:10
position
const math::XYZPoint & position(const reco::Vertex &sv)
Definition: TemplatedSecondaryVertexProducer.cc:98
findQualityFiles.v
v
Definition: findQualityFiles.py:179
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
TemplatedSecondaryVertexProducer::token_groomedFatJets
edm::EDGetTokenT< edm::View< reco::Jet > > token_groomedFatJets
Definition: TemplatedSecondaryVertexProducer.cc:169
edm::Handle
Definition: AssociativeIterator.h:50
HLT_FULL_cff.trackSelection
trackSelection
Definition: HLT_FULL_cff.py:6735
TemplatedSecondaryVertexProducer::token_BeamSpot
edm::EDGetTokenT< reco::BeamSpot > token_BeamSpot
Definition: TemplatedSecondaryVertexProducer.cc:144
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
TemplatedSecondaryVertexProducer::getConstraintType
static ConstraintType getConstraintType(const std::string &name)
Definition: TemplatedSecondaryVertexProducer.cc:207
edm::Ref< TrackCollection >
reco::GhostTrackState
Definition: GhostTrackState.h:21
heavyIonCSV_trainingSettings.idx
idx
Definition: heavyIonCSV_trainingSettings.py:5
TemplatedSecondaryVertexProducer::extSVDeltaRToJet
double extSVDeltaRToJet
Definition: TemplatedSecondaryVertexProducer.cc:157
reco::btag::IndexedTrackData
std::pair< unsigned int, TrackData > IndexedTrackData
Definition: TemplatedSecondaryVertexTagInfo.h:43
TemplatedSecondaryVertexProducer::input_item
IPTI::input_container::value_type input_item
Definition: TemplatedSecondaryVertexProducer.cc:110
TemplatedSecondaryVertexProducer::matchSubjets
void matchSubjets(const std::vector< int > &groomedIndices, const edm::Handle< edm::View< reco::Jet > > &groomedJets, const edm::Handle< std::vector< IPTI > > &subjets, std::vector< std::vector< int > > &matchedIndices)
Definition: TemplatedSecondaryVertexProducer.cc:1125
TemplatedSecondaryVertexProducer::token_trackBuilder
edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > token_trackBuilder
Definition: TemplatedSecondaryVertexProducer.cc:171
TemplatedSecondaryVertexProducer::vtxRecoPSet
edm::ParameterSet vtxRecoPSet
Definition: TemplatedSecondaryVertexProducer.cc:150
reco::Candidate::pz
virtual double pz() const =0
z coordinate of momentum vector
alignCSCRings.s
s
Definition: alignCSCRings.py:92
cms::cuda::bs
bs
Definition: HistoContainer.h:76
pat::Jet
Analysis-level calorimeter jet class.
Definition: Jet.h:77
boostedTaus_cff.jetIdx
jetIdx
Definition: boostedTaus_cff.py:27
TemplatedSecondaryVertexProducer::sortCriterium
reco::btag::SortCriteria sortCriterium
Definition: TemplatedSecondaryVertexProducer.cc:146
w
const double w
Definition: UKUtility.cc:23
visualization-live-secondInstance_cfg.m
m
Definition: visualization-live-secondInstance_cfg.py:79
TemplatedSecondaryVertexProducer::CONSTRAINT_BEAMSPOT
Definition: TemplatedSecondaryVertexProducer.cc:136
HLT_FULL_cff.trackIPTagInfos
trackIPTagInfos
Definition: HLT_FULL_cff.py:52061
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
pixelCPEforGPU::Status
SiPixelHitStatus Status
Definition: pixelCPEforGPU.h:17
pfDeepBoostedJetPreprocessParams_cfi.sv
sv
Definition: pfDeepBoostedJetPreprocessParams_cfi.py:352
reco::BeamSpot
Definition: BeamSpot.h:21
TemplatedSecondaryVertexProducer::token_trackIPTagInfo
edm::EDGetTokenT< std::vector< IPTI > > token_trackIPTagInfo
Definition: TemplatedSecondaryVertexProducer.cc:145
edm::ESHandle< TransientTrackBuilder >
TemplatedSecondaryVertexProducer::useSVMomentum
bool useSVMomentum
Definition: TemplatedSecondaryVertexProducer.cc:160
TemplatedSecondaryVertexProducer::CONSTRAINT_PV_ERROR_SCALED
Definition: TemplatedSecondaryVertexProducer.cc:139
reco::TemplatedSecondaryVertexTagInfo::IndexedTrackData
reco::btag::IndexedTrackData IndexedTrackData
Definition: TemplatedSecondaryVertexTagInfo.h:50
Point3DBase< float, GlobalTag >
TemplatedSecondaryVertexProducer::rParam
double rParam
Definition: TemplatedSecondaryVertexProducer.cc:162
edm::RefToBase::get
value_type const * get() const
Definition: RefToBase.h:209
TemplatedSecondaryVertexProducer::fjClusterSeq
ClusterSequencePtr fjClusterSeq
Definition: TemplatedSecondaryVertexProducer.cc:173
reco::Candidate::py
virtual double py() const =0
y coordinate of momentum vector
pat::PATObject::originalObjectRef
const edm::Ptr< reco::Candidate > & originalObjectRef() const
reference to original object. Returns a null reference if not available
Definition: PATObject.h:537
pat::Jet::subjetCollectionNames
std::vector< std::string > const & subjetCollectionNames() const
Subjet collection names.
Definition: Jet.h:566
TemplatedSecondaryVertexProducer::ghostRescaling
double ghostRescaling
Definition: TemplatedSecondaryVertexProducer.cc:164
edm::ParameterSet
Definition: ParameterSet.h:47
TemplatedSecondaryVertexProducer::useGhostTrack
bool useGhostTrack
Definition: TemplatedSecondaryVertexProducer.cc:151
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
RecoVertex::convertError
reco::Vertex::Error convertError(const GlobalError &ge)
Definition: ConvertError.h:8
TemplatedSecondaryVertexProducer::constraint
ConstraintType constraint
Definition: TemplatedSecondaryVertexProducer.cc:148
TemplatedSecondaryVertexProducer::input_container
IPTI::input_container input_container
Definition: TemplatedSecondaryVertexProducer.cc:109
type
type
Definition: SiPixelVCal_PayloadInspector.cc:39
TemplatedSecondaryVertexProducer::vertexSorting
VertexSorting< SecondaryVertex > vertexSorting
Definition: TemplatedSecondaryVertexProducer.cc:155
HLT_FULL_cff.v0Filter
v0Filter
Definition: HLT_FULL_cff.py:52043
TemplatedSecondaryVertexProducer::CONSTRAINT_PV_BEAMSPOT_SIZE
Definition: TemplatedSecondaryVertexProducer.cc:137
TemplatedSecondaryVertexProducer::withPVError
bool withPVError
Definition: TemplatedSecondaryVertexProducer.cc:152
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
TemplatedSecondaryVertexProducer::useSVClustering
bool useSVClustering
Definition: TemplatedSecondaryVertexProducer.cc:159
edm::EventSetup::getHandle
ESHandle< T > getHandle(const ESGetToken< T, R > &iToken) const
Definition: EventSetup.h:155
reco::BeamSpot::CovarianceMatrix
math::Error< dimension >::type CovarianceMatrix
Definition: BeamSpot.h:29
TemplatedSecondaryVertexProducer::jetAlgorithm
std::string jetAlgorithm
Definition: TemplatedSecondaryVertexProducer.cc:161
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
TemplatedSecondaryVertexProducer::relPtTolerance
double relPtTolerance
Definition: TemplatedSecondaryVertexProducer.cc:165
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HLT_FULL_cff.srcWeights
srcWeights
Definition: HLT_FULL_cff.py:8709
edm::Ptr< reco::Candidate >
edm::RefToBase::id
ProductID id() const
Definition: RefToBase.h:214
DDAxes::phi
TemplatedSecondaryVertexProducer::CONSTRAINT_PV_BS_Z_ERRORS_SCALED
Definition: TemplatedSecondaryVertexProducer.cc:138
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
TemplatedSecondaryVertexProducer::matchGroomedJets
void matchGroomedJets(const edm::Handle< edm::View< reco::Jet > > &jets, const edm::Handle< edm::View< reco::Jet > > &matchedJets, std::vector< int > &matchedIndices)
Definition: TemplatedSecondaryVertexProducer.cc:1076
eostools.move
def move(src, dest)
Definition: eostools.py:511
reco::TransientTrack
Definition: TransientTrack.h:19
TemplatedSecondaryVertexProducer::TrackDataVector
std::vector< reco::btag::IndexedTrackData > TrackDataVector
Definition: TemplatedSecondaryVertexProducer.cc:111
HLTMuonOfflineAnalyzer_cfi.deltaR2
deltaR2
Definition: HLTMuonOfflineAnalyzer_cfi.py:105
reco::Candidate::px
virtual double px() const =0
x coordinate of momentum vector
TemplatedSecondaryVertexProducer::token_fatJets
edm::EDGetTokenT< edm::View< reco::Jet > > token_fatJets
Definition: TemplatedSecondaryVertexProducer.cc:168
metsig::jet
Definition: SignAlgoResolutions.h:47
edm::ValueMap< float >
Exception
Definition: hltDiff.cc:245
HLT_FULL_cff.jetType
jetType
Definition: HLT_FULL_cff.py:8670
TemplatedSecondaryVertexProducer::token_extSVCollection
edm::EDGetTokenT< edm::View< VTX > > token_extSVCollection
Definition: TemplatedSecondaryVertexProducer.cc:158
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
edm::RefToBase< reco::Jet >
AlignmentPI::index
index
Definition: AlignmentPayloadInspectorHelper.h:46
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
RecoVertex::convertPos
reco::Vertex::Point convertPos(const GlobalPoint &p)
Definition: ConvertToFromReco.h:7
TransientTrackBuilder::build
reco::TransientTrack build(const reco::Track *p) const
Definition: TransientTrackBuilder.cc:20
reco::GhostTrackPrediction
Definition: GhostTrackPrediction.h:21
cms::Exception
Definition: Exception.h:70
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
TemplatedSecondaryVertexProducer::CONSTRAINT_NONE
Definition: TemplatedSecondaryVertexProducer.cc:135
HLT_FULL_cff.vertexReco
vertexReco
Definition: HLT_FULL_cff.py:51971
getGhostTrackFitType
static GhostTrackVertexFinder::FitType getGhostTrackFitType(const std::string &name)
Definition: TemplatedSecondaryVertexProducer.cc:226
dqmdumpme.indices
indices
Definition: dqmdumpme.py:50
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
TemplatedSecondaryVertexProducer::CONSTRAINT_PV_PRIMARIES_IN_FIT
Definition: TemplatedSecondaryVertexProducer.cc:140
event
Definition: event.py:1
TrackSorting::getCriterium
reco::btag::SortCriteria getCriterium(const std::string &name)
Definition: TrackSorting.cc:11
HLT_FULL_cff.distance
distance
Definition: HLT_FULL_cff.py:7746
TemplatedSecondaryVertexProducer::fjJetDefinition
JetDefPtr fjJetDefinition
Definition: TemplatedSecondaryVertexProducer.cc:174
edm::ConfigurationDescriptions::addDefault
void addDefault(ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:99
edm::Log
Definition: MessageLogger.h:70
edm::ParameterDescription
Definition: ParameterDescription.h:110
edm::InputTag
Definition: InputTag.h:15
reco::Vertex
Definition: Vertex.h:35
reco::TemplatedSecondaryVertex
Definition: TemplatedSecondaryVertex.h:11
g
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g
Definition: Activities.doc:4
TemplatedSecondaryVertexProducer::jetPtMin
double jetPtMin
Definition: TemplatedSecondaryVertexProducer.cc:163
DeadROC_duringRun.dir
dir
Definition: DeadROC_duringRun.py:23
pat::JetPtrCollection
std::vector< edm::Ptr< pat::Jet > > JetPtrCollection
Definition: Jet.h:75
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37