#include <GlobalTrackQualityProducer.h>

Inheritance diagram for GlobalTrackQualityProducer:

Public Member Functions
	GlobalTrackQualityProducer (const edm::ParameterSet &iConfig)

	~GlobalTrackQualityProducer () 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 EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
virtual std::pair< double, double >	kink (Trajectory &muon) const

virtual std::pair< double, double >	newChi2 (Trajectory &muon) const

void	produce (edm::Event &, const edm::EventSetup &) override

virtual double	trackProbability (Trajectory &track) const

Additional Inherited Members
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

Detailed Description

Definition at line 28 of file GlobalTrackQualityProducer.h.

Constructor & Destructor Documentation

◆ GlobalTrackQualityProducer()

GlobalTrackQualityProducer::GlobalTrackQualityProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 27 of file GlobalTrackQualityProducer.cc.

References Chi2MeasurementEstimator_cfi::Chi2MeasurementEstimator, edm::ParameterSet::getParameter(), glbMuonsToken, GlobalMuonRefitter_cff::GlobalMuonRefitter, HLT_2023v12_cff::GlobalMuonTrackMatcher, inputCollection_, inputLinksCollection_, linkCollectionToken, beam_dqm_sourceclient-live_cfg::maxChi2, MuonServiceProxy_cff::MuonServiceProxy, HLTSiStripMonitoring_cff::nSigma, theEstimator, theGlbMatcher, theGlbRefitter, and theService.

     : inputCollection_(iConfig.getParameter<edm::InputTag>("InputCollection")),
       inputLinksCollection_(iConfig.getParameter<edm::InputTag>("InputLinksCollection")),
       tTopoToken_(esConsumes()),
       theService(nullptr),
       theGlbRefitter(nullptr),
       theGlbMatcher(nullptr) {
   // service parameters
   edm::ParameterSet serviceParameters = iConfig.getParameter<edm::ParameterSet>("ServiceParameters");
   theService = new MuonServiceProxy(serviceParameters, consumesCollector());
 
   // TrackRefitter parameters
   edm::ConsumesCollector iC = consumesCollector();
   edm::ParameterSet refitterParameters = iConfig.getParameter<edm::ParameterSet>("RefitterParameters");
   theGlbRefitter = new GlobalMuonRefitter(refitterParameters, theService, iC);
 
   edm::ParameterSet trackMatcherPSet = iConfig.getParameter<edm::ParameterSet>("GlobalMuonTrackMatcher");
   theGlbMatcher = new GlobalMuonTrackMatcher(trackMatcherPSet, theService);
 
   double maxChi2 = iConfig.getParameter<double>("MaxChi2");
   double nSigma = iConfig.getParameter<double>("nSigma");
   theEstimator = new Chi2MeasurementEstimator(maxChi2, nSigma);
 
   glbMuonsToken = consumes<reco::TrackCollection>(inputCollection_);
   linkCollectionToken = consumes<reco::MuonTrackLinksCollection>(inputLinksCollection_);
 
   produces<edm::ValueMap<reco::MuonQuality>>();
 }

◆ ~GlobalTrackQualityProducer()

GlobalTrackQualityProducer::~GlobalTrackQualityProducer ( )

override

Definition at line 56 of file GlobalTrackQualityProducer.cc.

References theEstimator, theGlbMatcher, theGlbRefitter, and theService.

                                                         {
   if (theService)
     delete theService;
   if (theGlbRefitter)
     delete theGlbRefitter;
   if (theGlbMatcher)
     delete theGlbMatcher;
   if (theEstimator)
     delete theEstimator;
 }

Member Function Documentation

◆ fillDescriptions()

void GlobalTrackQualityProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 318 of file GlobalTrackQualityProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, edm::ParameterSetDescription::setAllowAnything(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                             {
   edm::ParameterSetDescription desc;
   {
     edm::ParameterSetDescription psd1;
     psd1.setAllowAnything();
     desc.add<edm::ParameterSetDescription>("ServiceParameters", psd1);
   }
   {
     edm::ParameterSetDescription psd1;
     psd1.setAllowAnything();
     desc.add<edm::ParameterSetDescription>("GlobalMuonTrackMatcher", psd1);
   }
   desc.add<edm::InputTag>("InputCollection", edm::InputTag("globalMuons"));
   desc.add<edm::InputTag>("InputLinksCollection", edm::InputTag("globalMuons"));
   desc.add<std::string>("BaseLabel", "GLB");
   {
     edm::ParameterSetDescription descGlbMuonRefitter;
     descGlbMuonRefitter.setAllowAnything();
     descGlbMuonRefitter.add<edm::InputTag>("DTRecSegmentLabel", edm::InputTag("dt1DRecHits"));
     descGlbMuonRefitter.add<edm::InputTag>("CSCRecSegmentLabel", edm::InputTag("csc2DRecHits"));
     descGlbMuonRefitter.add<edm::InputTag>("GEMRecHitLabel", edm::InputTag("gemRecHits"));
     descGlbMuonRefitter.add<edm::InputTag>("ME0RecHitLabel", edm::InputTag("me0Segments"));
     descGlbMuonRefitter.add<edm::InputTag>("RPCRecSegmentLabel", edm::InputTag("rpcRecHits"));
 
     descGlbMuonRefitter.add<std::string>("Fitter", "KFFitterForRefitInsideOut");
     descGlbMuonRefitter.add<std::string>("Smoother", "KFSmootherForRefitInsideOut");
     descGlbMuonRefitter.add<std::string>("Propagator", "SmartPropagatorAnyRK");
     descGlbMuonRefitter.add<std::string>("TrackerRecHitBuilder", "WithAngleAndTemplate");
     descGlbMuonRefitter.add<std::string>("MuonRecHitBuilder", "MuonRecHitBuilder");
     descGlbMuonRefitter.add<bool>("DoPredictionsOnly", false);
     descGlbMuonRefitter.add<std::string>("RefitDirection", "insideOut");
     descGlbMuonRefitter.add<bool>("PropDirForCosmics", false);
     descGlbMuonRefitter.add<bool>("RefitRPCHits", true);
 
     descGlbMuonRefitter.add<std::vector<int>>("DYTthrs", {10, 10});
     descGlbMuonRefitter.add<int>("DYTselector", 1);
     descGlbMuonRefitter.add<bool>("DYTupdator", false);
     descGlbMuonRefitter.add<bool>("DYTuseAPE", false);
     descGlbMuonRefitter.add<bool>("DYTuseThrsParametrization", true);
     {
       edm::ParameterSetDescription descDYTthrs;
       descDYTthrs.add<std::vector<double>>("eta0p8", {1, -0.919853, 0.990742});
       descDYTthrs.add<std::vector<double>>("eta1p2", {1, -0.897354, 0.987738});
       descDYTthrs.add<std::vector<double>>("eta2p0", {4, -0.986855, 0.998516});
       descDYTthrs.add<std::vector<double>>("eta2p2", {1, -0.940342, 0.992955});
       descDYTthrs.add<std::vector<double>>("eta2p4", {1, -0.947633, 0.993762});
       descGlbMuonRefitter.add<edm::ParameterSetDescription>("DYTthrsParameters", descDYTthrs);
     }
 
     descGlbMuonRefitter.add<int>("SkipStation", -1);
     descGlbMuonRefitter.add<int>("TrackerSkipSystem", -1);
     descGlbMuonRefitter.add<int>("TrackerSkipSection", -1);
     descGlbMuonRefitter.add<bool>("RefitFlag", true);
 
     desc.add<edm::ParameterSetDescription>("RefitterParameters", descGlbMuonRefitter);
   }
   desc.add<double>("nSigma", 3.0);
   desc.add<double>("MaxChi2", 100000.0);
 
   descriptions.add("globalTrackQualityProducer", desc);
 }

◆ kink()

std::pair< double, double > GlobalTrackQualityProducer::kink ( Trajectory & muon ) const

privatevirtual

Definition at line 183 of file GlobalTrackQualityProducer.cc.

References change_name::diff, relativeConstraints::error, TrajectoryStateOnSurface::globalPosition(), edm::isNotFinite(), TrajectoryStateOnSurface::isValid(), visualization-live-secondInstance_cfg::m, M_PI, convertSQLiteXML::ok, PV3DBase< T, PVType, FrameType >::phi(), GlobalErrorBase< T, ErrorWeightType >::phierr(), mps_fire::result, alignCSCRings::s, AlCaHLTBitMon_QueryRunRegistry::string, and DetId::Tracker.

Referenced by produce().

                                                                                {
   const std::string theCategory = "Muon|RecoMuon|GlobalTrackQualityProducer";
 
   using namespace std;
   using namespace edm;
   using namespace reco;
 
   double result = 0.0;
   double resultGlb = 0.0;
 
   typedef TransientTrackingRecHit::ConstRecHitPointer ConstRecHitPointer;
   typedef ConstRecHitPointer RecHit;
   typedef std::vector<TrajectoryMeasurement>::const_iterator TMI;
 
   vector<TrajectoryMeasurement> meas = muon.measurements();
 
   for (TMI m = meas.begin(); m != meas.end(); m++) {
     TransientTrackingRecHit::ConstRecHitPointer hit = m->recHit();
 
     //not used    double estimate = 0.0;
 
     RecHit rhit = (*m).recHit();
     bool ok = false;
     if (rhit->isValid()) {
       if (DetId::Tracker == rhit->geographicalId().det())
         ok = true;
     }
 
     //if ( !ok ) continue;
 
     const TrajectoryStateOnSurface& tsos = (*m).predictedState();
 
     if (tsos.isValid() && rhit->isValid() && rhit->hit()->isValid() &&
         !edm::isNotFinite(rhit->localPositionError().xx())     //this is paranoia induced by reported case
         && !edm::isNotFinite(rhit->localPositionError().xy())  //it's better to track down the origin of bad numbers
         && !edm::isNotFinite(rhit->localPositionError().yy())) {
       double phi1 = tsos.globalPosition().phi();
       if (phi1 < 0)
         phi1 = 2 * M_PI + phi1;
 
       double phi2 = rhit->globalPosition().phi();
       if (phi2 < 0)
         phi2 = 2 * M_PI + phi2;
 
       double diff = fabs(phi1 - phi2);
       if (diff > M_PI)
         diff = 2 * M_PI - diff;
 
       GlobalPoint hitPos = rhit->globalPosition();
 
       GlobalError hitErr = rhit->globalPositionError();
       //LogDebug(theCategory)<<"hitPos " << hitPos;
       double error = hitErr.phierr(hitPos);  // error squared
 
       double s = (error > 0.0) ? (diff * diff) / error : (diff * diff);
 
       if (ok)
         result += s;
       resultGlb += s;
     }
   }
 
   return std::pair<double, double>(result, resultGlb);
 }

◆ newChi2()

std::pair< double, double > GlobalTrackQualityProducer::newChi2 ( Trajectory & muon ) const

privatevirtual

Definition at line 248 of file GlobalTrackQualityProducer.cc.

References MeasurementEstimator::estimate(), TrajectoryStateOnSurface::isValid(), visualization-live-secondInstance_cfg::m, DetId::Muon, AlCaHLTBitMon_QueryRunRegistry::string, theEstimator, and DetId::Tracker.

Referenced by produce().

                                                                                   {
   const std::string theCategory = "Muon|RecoMuon|GlobalTrackQualityProducer";
 
   using namespace std;
   using namespace edm;
   using namespace reco;
 
   double muChi2 = 0.0;
   double tkChi2 = 0.0;
   unsigned int muNdof = 0;
   unsigned int tkNdof = 0;
 
   typedef TransientTrackingRecHit::ConstRecHitPointer ConstRecHitPointer;
   typedef ConstRecHitPointer RecHit;
   typedef vector<TrajectoryMeasurement>::const_iterator TMI;
 
   vector<TrajectoryMeasurement> meas = muon.measurements();
 
   for (TMI m = meas.begin(); m != meas.end(); m++) {
     TransientTrackingRecHit::ConstRecHitPointer hit = m->recHit();
     const TrajectoryStateOnSurface& uptsos = (*m).updatedState();
     // FIXME FIXME CLONE!!!
     // TrackingRecHit::RecHitPointer preciseHit = hit->clone(uptsos);
     const auto& preciseHit = hit;
     double estimate = 0.0;
     if (preciseHit->isValid() && uptsos.isValid()) {
       estimate = theEstimator->estimate(uptsos, *preciseHit).second;
     }
 
     //LogTrace(theCategory) << "estimate " << estimate << " TM.est " << m->estimate();
     //UNUSED:    double tkDiff = 0.0;
     //UNUSED:    double staDiff = 0.0;
     if (hit->isValid() && (hit->geographicalId().det()) == DetId::Tracker) {
       tkChi2 += estimate;
       //UNUSED:      tkDiff = estimate - m->estimate();
       tkNdof += hit->dimension();
     }
     if (hit->isValid() && (hit->geographicalId().det()) == DetId::Muon) {
       muChi2 += estimate;
       //UNUSED      staDiff = estimate - m->estimate();
       muNdof += hit->dimension();
     }
   }
 
   //For tkNdof < 6, should a large number or something else
   // be used instead of just tkChi2 directly?
   if (tkNdof > 5) {
     tkChi2 /= (tkNdof - 5.);
   }
 
   //For muNdof < 6, should a large number or something else
   // be used instead of just muChi2 directly?
   if (muNdof > 5) {
     muChi2 /= (muNdof - 5.);
   }
 
   return std::pair<double, double>(tkChi2, muChi2);
 }

◆ produce()

void GlobalTrackQualityProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 67 of file GlobalTrackQualityProducer.cc.

                                                                                       {
   const std::string theCategory = "Muon|RecoMuon|GlobalTrackQualityProducer";
 
   theService->update(iSetup);
 
   theGlbRefitter->setEvent(iEvent);
 
   theGlbRefitter->setServices(theService->eventSetup());
 
   // Take the GLB muon container(s)
   edm::Handle<reco::TrackCollection> glbMuons;
   iEvent.getByToken(glbMuonsToken, glbMuons);
 
   edm::Handle<reco::MuonTrackLinksCollection> linkCollectionHandle;
   iEvent.getByToken(linkCollectionToken, linkCollectionHandle);
 
   //Retrieve tracker topology from geometry
   const TrackerTopology* tTopo = &iSetup.getData(tTopoToken_);
 
   // reserve some space
   std::vector<reco::MuonQuality> valuesQual;
   valuesQual.reserve(glbMuons->size());
 
   int trackIndex = 0;
   for (reco::TrackCollection::const_iterator track = glbMuons->begin(); track != glbMuons->end();
        ++track, ++trackIndex) {
     reco::TrackRef glbRef(glbMuons, trackIndex);
     reco::TrackRef staTrack = reco::TrackRef();
 
     std::vector<Trajectory> refitted = theGlbRefitter->refit(*track, 1, tTopo);
 
     LogTrace(theCategory) << "GLBQual N refitted " << refitted.size();
 
     std::pair<double, double> thisKink;
     double relative_muon_chi2 = 0.0;
     double relative_tracker_chi2 = 0.0;
     double glbTrackProbability = 0.0;
     if (!refitted.empty()) {
       thisKink = kink(refitted.front());
       std::pair<double, double> chi = newChi2(refitted.front());
       relative_muon_chi2 = chi.second;    //normalized inside to /sum(muHits.dimension)
       relative_tracker_chi2 = chi.first;  //normalized inside to /sum(tkHits.dimension)
       glbTrackProbability = trackProbability(refitted.front());
     }
 
     LogTrace(theCategory) << "GLBQual: Kink " << thisKink.first << " " << thisKink.second;
     LogTrace(theCategory) << "GLBQual: Rel Chi2 " << relative_tracker_chi2 << " " << relative_muon_chi2;
     LogTrace(theCategory) << "GLBQual: trackProbability " << glbTrackProbability;
 
     // Fill the STA-TK match information
     float chi2, d, dist, Rpos;
     chi2 = d = dist = Rpos = -1.0;
     bool passTight = false;
     typedef MuonTrajectoryBuilder::TrackCand TrackCand;
     if (linkCollectionHandle.isValid()) {
       for (reco::MuonTrackLinksCollection::const_iterator links = linkCollectionHandle->begin();
            links != linkCollectionHandle->end();
            ++links) {
         if (links->trackerTrack().isNull() || links->standAloneTrack().isNull() || links->globalTrack().isNull()) {
           edm::LogWarning(theCategory) << "Global muon links to constituent tracks are invalid. There should be no "
                                           "such object. Muon is skipped.";
           continue;
         }
         if (links->globalTrack() == glbRef) {
           staTrack = !links->standAloneTrack().isNull() ? links->standAloneTrack() : reco::TrackRef();
           TrackCand staCand = TrackCand((Trajectory*)nullptr, links->standAloneTrack());
           TrackCand tkCand = TrackCand((Trajectory*)nullptr, links->trackerTrack());
           chi2 = theGlbMatcher->match(staCand, tkCand, 0, 0);
           d = theGlbMatcher->match(staCand, tkCand, 1, 0);
           Rpos = theGlbMatcher->match(staCand, tkCand, 2, 0);
           dist = theGlbMatcher->match(staCand, tkCand, 3, 0);
           passTight = theGlbMatcher->matchTight(staCand, tkCand);
         }
       }
     }
 
     if (!staTrack.isNull())
       LogTrace(theCategory) << "GLBQual: Used UpdatedAtVtx : "
                             << (iEvent.getStableProvenance(staTrack.id()).productInstanceName() ==
                                 std::string("UpdatedAtVtx"));
 
     float maxFloat01 =
         std::numeric_limits<float>::max() * 0.1;  // a better solution would be to use float above .. m/be not
     reco::MuonQuality muQual;
     if (!staTrack.isNull())
       muQual.updatedSta =
           iEvent.getStableProvenance(staTrack.id()).productInstanceName() == std::string("UpdatedAtVtx");
     muQual.trkKink = thisKink.first > maxFloat01 ? maxFloat01 : thisKink.first;
     muQual.glbKink = thisKink.second > maxFloat01 ? maxFloat01 : thisKink.second;
     muQual.trkRelChi2 = relative_tracker_chi2 > maxFloat01 ? maxFloat01 : relative_tracker_chi2;
     muQual.staRelChi2 = relative_muon_chi2 > maxFloat01 ? maxFloat01 : relative_muon_chi2;
     muQual.tightMatch = passTight;
     muQual.chi2LocalPosition = dist;
     muQual.chi2LocalMomentum = chi2;
     muQual.localDistance = d;
     muQual.globalDeltaEtaPhi = Rpos;
     muQual.glbTrackProbability = glbTrackProbability;
     valuesQual.push_back(muQual);
   }
 
   /*
   for(int i = 0; i < valuesTkRelChi2.size(); i++) {
     LogTrace(theCategory)<<"value " << valuesTkRelChi2[i] ;
   }
   */
 
   // create and fill value maps
   auto outQual = std::make_unique<edm::ValueMap<reco::MuonQuality>>();
   edm::ValueMap<reco::MuonQuality>::Filler fillerQual(*outQual);
   fillerQual.insert(glbMuons, valuesQual.begin(), valuesQual.end());
   fillerQual.fill();
 
   // put value map into event
   iEvent.put(std::move(outQual));
 }

◆ trackProbability()

double GlobalTrackQualityProducer::trackProbability ( Trajectory & track ) const

privatevirtual

Definition at line 310 of file GlobalTrackQualityProducer.cc.

References LnChiSquaredProbability(), and HLT_2023v12_cff::track.

Referenced by produce().

                                                                            {
   if (track.ndof() > 0 && track.chiSquared() > 0) {
     return -LnChiSquaredProbability(track.chiSquared(), track.ndof());
   } else {
     return 0.0;
   }
 }

Member Data Documentation

◆ glbMuonsToken

edm::EDGetTokenT<reco::TrackCollection> GlobalTrackQualityProducer::glbMuonsToken

private

Definition at line 45 of file GlobalTrackQualityProducer.h.

Referenced by GlobalTrackQualityProducer(), and produce().

◆ inputCollection_

edm::InputTag GlobalTrackQualityProducer::inputCollection_

private

Definition at line 43 of file GlobalTrackQualityProducer.h.

Referenced by GlobalTrackQualityProducer().

◆ inputLinksCollection_

edm::InputTag GlobalTrackQualityProducer::inputLinksCollection_

private

Definition at line 44 of file GlobalTrackQualityProducer.h.

Referenced by GlobalTrackQualityProducer().

◆ linkCollectionToken

edm::EDGetTokenT<reco::MuonTrackLinksCollection> GlobalTrackQualityProducer::linkCollectionToken

private

Definition at line 46 of file GlobalTrackQualityProducer.h.

Referenced by GlobalTrackQualityProducer(), and produce().

◆ theEstimator

MeasurementEstimator* GlobalTrackQualityProducer::theEstimator

private

Definition at line 51 of file GlobalTrackQualityProducer.h.

Referenced by GlobalTrackQualityProducer(), newChi2(), and ~GlobalTrackQualityProducer().

◆ theGlbMatcher

GlobalMuonTrackMatcher* GlobalTrackQualityProducer::theGlbMatcher

private

Definition at line 50 of file GlobalTrackQualityProducer.h.

Referenced by GlobalTrackQualityProducer(), produce(), and ~GlobalTrackQualityProducer().

◆ theGlbRefitter

GlobalMuonRefitter* GlobalTrackQualityProducer::theGlbRefitter

private

Definition at line 49 of file GlobalTrackQualityProducer.h.

Referenced by GlobalTrackQualityProducer(), produce(), and ~GlobalTrackQualityProducer().

◆ theService

MuonServiceProxy* GlobalTrackQualityProducer::theService

private

Definition at line 48 of file GlobalTrackQualityProducer.h.

Referenced by GlobalTrackQualityProducer(), produce(), and ~GlobalTrackQualityProducer().

◆ tTopoToken_

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> GlobalTrackQualityProducer::tTopoToken_

private

Definition at line 47 of file GlobalTrackQualityProducer.h.

Referenced by produce().

Private Attributes
edm::EDGetTokenT< reco::TrackCollection >	glbMuonsToken

edm::InputTag	inputCollection_

edm::InputTag	inputLinksCollection_

edm::EDGetTokenT< reco::MuonTrackLinksCollection >	linkCollectionToken

MeasurementEstimator *	theEstimator

GlobalMuonTrackMatcher *	theGlbMatcher

GlobalMuonRefitter *	theGlbRefitter

MuonServiceProxy *	theService

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	tTopoToken_

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GlobalTrackQualityProducer()

◆ ~GlobalTrackQualityProducer()

Member Function Documentation

◆ fillDescriptions()

◆ kink()

◆ newChi2()

◆ produce()

◆ trackProbability()

Member Data Documentation

◆ glbMuonsToken

◆ inputCollection_

◆ inputLinksCollection_

◆ linkCollectionToken

◆ theEstimator

◆ theGlbMatcher

◆ theGlbRefitter

◆ theService

◆ tTopoToken_