Rec::CombinedMuonTrackFitter Class Reference

#include <CombinedMuonTrackFitter.h>

Inheritance diagram for Rec::CombinedMuonTrackFitter:

Collaboration diagram for Rec::CombinedMuonTrackFitter:

Public Member Functions
virtual	~CombinedMuonTrackFitter ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Trk::Track &track, const Trk::RunOutlierRemoval runOutlier, const Trk::ParticleHypothesis particleHypothesis) const override

Protected Member Functions
std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Trk::MeasurementSet &measurementSet, const Trk::TrackParameters &perigeeStartValue, const Trk::RunOutlierRemoval runOutlier, const Trk::ParticleHypothesis particleHypothesis) const
	fit a set of MeasurementBase objects with starting value for perigeeParameters
std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Trk::Track &indetTrack, Trk::Track &extrapolatedTrack, const Trk::RunOutlierRemoval runOutlier, const Trk::ParticleHypothesis particleHypothesis) const
	combined muon fit
double	normalizedChi2 (const Trk::Track &track) const
bool	checkTrack (std::string_view txt, const Trk::Track *newTrack) const
unsigned int	countAEOTs (const Trk::Track &track, const std::string &txt) const
bool	loadMagneticField (const EventContext &ctx, MagField::AtlasFieldCache &field_cache) const

Protected Attributes
ToolHandle< Rec::IMuidCaloTrackStateOnSurface >	m_caloTSOS
ToolHandle< Muon::IMuonErrorOptimisationTool >	m_muonErrorOptimizer
PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer
ToolHandle< Rec::IMuonTrackQuery >	m_trackQuery
ToolHandle< Trk::ITrackSummaryTool >	m_trackSummary
ToolHandle< Trk::ITrkMaterialProviderTool >	m_materialUpdator
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
Gaudi::Property< double >	m_badFitChi2 {this, "BadFitChi2", 2.5}
Gaudi::Property< double >	m_zECToroid {this, "zECToroid", 10. * Gaudi::Units::meter}
Gaudi::Property< bool >	m_updateWithCaloTG {this, "UpdateWithCaloTG", false}
Gaudi::Property< bool >	m_useCaloTG {this, "UseCaloTG", false}
std::unique_ptr< const Trk::Volume >	m_indetVolume {nullptr}
std::unique_ptr< const Trk::Volume >	m_calorimeterVolume {nullptr}
std::unique_ptr< MessageHelper >	m_messageHelper {std::make_unique<MessageHelper>(*this, 50)}

Private Member Functions
bool	optimizeErrors (const EventContext &ctx, Trk::Track &track) const

Private Attributes
ToolHandle< Muon::IMuonTrackCleaner >	m_cleaner
ToolHandle< Trk::ITrackFitter >	m_fitter
ToolHandle< Trk::ITrackFitter >	m_fitterSL
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
ServiceHandle< Trk::ITrackingVolumesSvc >	m_trackingVolumesSvc {this, "TrackingVolumesSvc", "Trk::TrackingVolumesSvc/TrackingVolumesSvc"}
Gaudi::Property< bool >	m_allowCleanerVeto {this, "AllowCleanerVeto", true}
Gaudi::Property< unsigned >	m_maxWarnings
std::atomic_uint	m_countCombinedCleanerVeto {0}
std::atomic_uint	m_countExtensionCleanerVeto {0}
std::atomic_uint	m_countStandaloneCleanerVeto {0}

Detailed Description

Definition at line 43 of file CombinedMuonTrackFitter.h.

Constructor & Destructor Documentation

~CombinedMuonTrackFitter()

Rec::CombinedMuonTrackFitter::~CombinedMuonTrackFitter ( )

virtualdefault

Member Function Documentation

checkTrack()

bool Rec::CombinedMuonTrackFitter::checkTrack ( std::string_view txt, const Trk::Track * newTrack ) const

protected

Check that the combined track contains enough MS measurements

Definition at line 588 of file CombinedMuonTrackFitter.cxx.

                                                                                               {
        if (!newTrack) return false;
 
        const DataVector<const Trk::TrackParameters>* pars = newTrack->trackParameters();
        if (!pars || pars->empty() || !newTrack->fitQuality()) { return false; }
        DataVector<const Trk::TrackParameters>::const_iterator it = pars->end() -1;
 
        if ((*it)->position().dot((*it)->momentum()) < 0) {
            return false;
            ATH_MSG_DEBUG(txt <<" "<< __FILE__<<":"<<__LINE__<< " ALARM position " << (*it)->position() << " direction " << (*it)->momentum().unit());
        } else {
            ATH_MSG_DEBUG(txt <<" "<< __FILE__<<":"<<__LINE__<< " OK position " << (*it)->position() << " direction " << (*it)->momentum().unit());
        }
 
        for (const Trk::TrackParameters* par : *pars) {
            if (!par->covariance()) { continue; }
            if (!Amg::hasPositiveDiagElems(*par->covariance())) {
                ATH_MSG_DEBUG(txt<<" "<<__FILE__<<":"<<__LINE__<< "covariance matrix has negative diagonal element, killing track "
                              <<std::endl<<Amg::toString(*par->covariance()));
                return false;
            }
        }
        unsigned int numberMS{0}, numberMSPrec{0};
        Trk::TrackStates::const_reverse_iterator r = newTrack->trackStateOnSurfaces()->rbegin();
        Trk::TrackStates::const_reverse_iterator rEnd = newTrack->trackStateOnSurfaces()->rend();
        for (; r != rEnd; ++r) {
            const Trk::TrackStateOnSurface* tsos{*r};
            if (tsos->trackParameters() && m_calorimeterVolume->inside(tsos->trackParameters()->position())) break;
 
            if (tsos->measurementOnTrack()) {
                ++numberMS;
                const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(tsos->measurementOnTrack());
                numberMSPrec+= rot && !m_idHelperSvc->measuresPhi(rot->identify());
            }
        }
 
        ATH_MSG_VERBOSE( txt<< " "<<__FILE__<<":"<<__LINE__<<" "<< numberMS << "/"<< numberMSPrec<< " fitted MS measurements ");
         // reject with insufficient MS measurements
        if (numberMS < 5 || numberMSPrec < 3) {
            return false;
        }
 
        return true;
    }

countAEOTs()

unsigned int Rec::CombinedMuonTrackFitter::countAEOTs ( const Trk::Track & track, const std::string & txt ) const

protected

Definition at line 634 of file CombinedMuonTrackFitter.cxx.

                                                                                                      {
        const Trk::TrackStates* trackTSOS = track.trackStateOnSurfaces();
        unsigned int naeots = 0;
 
    if (!trackTSOS){
      ATH_MSG_ERROR("No trackStateOnSurfaces");
      return naeots;
    }
 
        for (const auto* m : *trackTSOS) {
      if (m && m->alignmentEffectsOnTrack()) naeots++;
        }
 
        ATH_MSG_DEBUG(" count AEOTs " << txt << " " << naeots);
 
        // add VEBOSE for checking TSOS order
 
 
        int tsos{0}, nperigee{0};
        for ( const Trk::TrackStateOnSurface* it : *trackTSOS) {
            tsos++;
 
            if (it->type(Trk::TrackStateOnSurface::Perigee)) {
                ATH_MSG_DEBUG("perigee");
                nperigee++;
            }
 
            if (it->trackParameters()) {
                ATH_MSG_VERBOSE(" check tsos " << tsos << " TSOS tp "
                                               << " r " << it->trackParameters()->position().perp() << " z "
                                               << it->trackParameters()->position().z() << " momentum "
                                               << it->trackParameters()->momentum().mag());
            } else if (it->measurementOnTrack()) {
                ATH_MSG_VERBOSE(" check tsos " << tsos << " TSOS mst "
                                               << " r " << it->measurementOnTrack()->associatedSurface().center().perp() << " z "
                                               << it->measurementOnTrack()->associatedSurface().center().z());
            } else if (it->materialEffectsOnTrack()) {
                ATH_MSG_VERBOSE(" check tsos " << tsos << " TSOS mat "
                                               << " r "
                                               << it->materialEffectsOnTrack()->associatedSurface().globalReferencePoint().perp()
                                               << " z " << it->materialEffectsOnTrack()->associatedSurface().globalReferencePoint().z());
            } else {
                ATH_MSG_VERBOSE(" check tsos other than above " << tsos);
            }
        }
 
        ATH_MSG_VERBOSE(" track with number of TSOS perigees " << nperigee);
 
        return naeots;
    }

finalize()

StatusCode Rec::CombinedMuonTrackFitter::finalize ( )

overridevirtual

Reimplemented in Rec::CombinedMuonTrackBuilder.

Definition at line 139 of file CombinedMuonTrackFitter.cxx.

                                                 {
        ATH_MSG_INFO("Finalizing CombinedMuonTrackFitter:"
                        << m_countStandaloneCleanerVeto << " standalone fits with cleaner veto" << endmsg << "     "
                        << m_countExtensionCleanerVeto << " extension fits with cleaner veto" << endmsg << "     "
                        << m_countCombinedCleanerVeto << " combined fits with cleaner veto");
        // // summarize WARNINGs
        m_messageHelper->printSummary();
        return StatusCode::SUCCESS;
    }

fit() [1/3]

std::unique_ptr< Trk::Track > Rec::CombinedMuonTrackFitter::fit ( const EventContext & ctx, const Trk::MeasurementSet & measurementSet, const Trk::TrackParameters & perigeeStartValue, const Trk::RunOutlierRemoval runOutlier, const Trk::ParticleHypothesis particleHypothesis ) const

protected

fit a set of MeasurementBase objects with starting value for perigeeParameters

Definition at line 317 of file CombinedMuonTrackFitter.cxx.

                                                                                                                    {
        // check valid particleHypothesis
        if (particleHypothesis != Trk::muon && particleHypothesis != Trk::nonInteracting) {
            // invalid particle hypothesis
            std::stringstream ss;
            ss << particleHypothesis;
            m_messageHelper->printWarning(31, ss.str());
            return nullptr;
        }
 
        // select straightLine fitter when magnets downstream of leading measurement are off
        MagField::AtlasFieldCache fieldCache;
        // Get field cache object
        if (!loadMagneticField(ctx, fieldCache)) return nullptr;
 
        const Trk::ITrackFitter* fitter = m_fitter.get();
        if (!fieldCache.toroidOn() || std::abs(perigeeStartValue.position().z()) > m_zECToroid) {
            fitter = m_fitterSL.get();
            ATH_MSG_VERBOSE(" fit (track refit method): select SL fitter ");
        }
 
        // redo ROTs:  ID, CROT and MDT specific treatments
        // if (m_redoRots) redoRots(track);
 
        // calo association (if relevant)
 
        // create Perigee if starting parameters given for a different surface type
        std::unique_ptr<Trk::TrackParameters> perigee = perigeeStartValue.uniqueClone();
        std::unique_ptr<Trk::PerigeeSurface> perigeeSurface;
 
        if (perigee->surfaceType() != Trk::SurfaceType::Perigee) {
            Amg::Vector3D origin(perigeeStartValue.position());
            perigeeSurface = std::make_unique<Trk::PerigeeSurface>(origin);
 
            perigee = std::make_unique<Trk::Perigee>(perigeeStartValue.position(), perigeeStartValue.momentum(), perigeeStartValue.charge(),
                                                     *perigeeSurface);
        }
 
        // FIT
        std::unique_ptr<Trk::Track> fittedTrack(fitter->fit(ctx, measurementSet, *perigee, false, particleHypothesis));
 
        if (!checkTrack("fitInterface2", fittedTrack.get())) { return nullptr; }
 
        // eventually this whole tool will use unique_ptrs
        // in the meantime, this allows the MuonErrorOptimisationTool and MuonRefitTool to use them
 
        // track cleaning
        if (runOutlier) {
            // fit with optimized spectrometer errors
 
            if (!m_muonErrorOptimizer.empty() && !fittedTrack->info().trackProperties(Trk::TrackInfo::StraightTrack) &&
                optimizeErrors(ctx, *fittedTrack)) {
                ATH_MSG_VERBOSE(" perform spectrometer error optimization after cleaning ");
                std::unique_ptr<Trk::Track> optimizedTrack = m_muonErrorOptimizer->optimiseErrors(*fittedTrack, ctx);
                if (checkTrack("fitInterface2Opt", optimizedTrack.get())) {
                    fittedTrack.swap(optimizedTrack);
                    if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " fit mstSet scaled errors Track ");
                }
 
            }
 
            // chi2 before clean
            double chi2Before = normalizedChi2(*fittedTrack);
 
            // muon cleaner
            ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<<" perform track cleaning... ");
 
            if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " fit mstSet before cleaning ");
 
            std::unique_ptr<Trk::Track> cleanTrack = m_cleaner->clean(*fittedTrack, ctx);
 
            if (msgLevel(MSG::DEBUG)) countAEOTs(*cleanTrack, " fit mstSet clean Track ");
 
            if (!checkTrack("fitInterface2Cleaner", cleanTrack.get())) { cleanTrack.reset(); }
 
            if (!cleanTrack) {
                if (m_allowCleanerVeto && chi2Before > m_badFitChi2) {
                    ATH_MSG_DEBUG(" cleaner veto B");
                    ++m_countExtensionCleanerVeto;
                    fittedTrack.reset();
                } else {
                    ATH_MSG_DEBUG(" keep original extension track despite cleaner veto ");
                }
            } else if (!(*cleanTrack->perigeeParameters() == *fittedTrack->perigeeParameters())) {
                double chi2After = normalizedChi2(*cleanTrack);
                if (chi2After < m_badFitChi2 || chi2After < chi2Before) {
                    ATH_MSG_VERBOSE(" found and removed spectrometer outlier(s) ");
                    fittedTrack.swap(cleanTrack);
                } else {
                    ATH_MSG_VERBOSE(" keep original track despite cleaning ");
                }
            }
 
            // FIXME: provide indet cleaner
            ATH_MSG_VERBOSE(" Finished cleaning");
        }
        // have to use release until the whole code uses unique_ptr
        return fittedTrack;
    }

fit() [2/3]

std::unique_ptr< Trk::Track > Rec::CombinedMuonTrackFitter::fit ( const EventContext & ctx, const Trk::Track & indetTrack, Trk::Track & extrapolatedTrack, const Trk::RunOutlierRemoval runOutlier, const Trk::ParticleHypothesis particleHypothesis ) const

protected

combined muon fit

Definition at line 421 of file CombinedMuonTrackFitter.cxx.

                                                                                                                    {
        // check valid particleHypothesis
        if (particleHypothesis != Trk::muon && particleHypothesis != Trk::nonInteracting) {
            // invalid particle hypothesis
            std::stringstream ss;
            ss << particleHypothesis;
            m_messageHelper->printWarning(32, ss.str());
            return nullptr;
        }
 
        // select straightLine fitter when solenoid and toroid are off
        const Trk::ITrackFitter* fitter = m_fitter.get();
        MagField::AtlasFieldCache fieldCache;
        // Get field cache object
        if (!loadMagneticField(ctx, fieldCache)) return nullptr;
 
        if (!fieldCache.toroidOn() && !fieldCache.solenoidOn()) {
            fitter = m_fitterSL.get();
            ATH_MSG_VERBOSE(" fit (combined muon fit method): select SL fitter ");
        }
 
        // redo ROTs:  ID, CROT and MDT specific treatments
 
        // calo association (for now just WARN if missing)
        if (particleHypothesis == Trk::muon && !m_trackQuery->isCaloAssociated(extrapolatedTrack, ctx)) {
            // combined muon track is missing the TSOS's describing calorimeter association
            m_messageHelper->printWarning(33);
        }
 
        // Updates the calo TSOS with the ones from TG+corrections
        if (m_updateWithCaloTG && !m_useCaloTG && particleHypothesis == Trk::muon) {
            ATH_MSG_VERBOSE("Updating Calorimeter TSOS in Muon Combined Fit ...");
            m_materialUpdator->updateCaloTSOS(indetTrack, extrapolatedTrack);
        }
 
        // FIT
        ATH_MSG_VERBOSE(" perform combined fit... " << std::endl
                                                    << m_printer->print(indetTrack) << std::endl
                                                    << m_printer->print(extrapolatedTrack));
 
        std::unique_ptr<Trk::Track> fittedTrack(fitter->fit(ctx, indetTrack, extrapolatedTrack, false, particleHypothesis));
 
        if (!fittedTrack) return nullptr;
        // track cleaning
        if (runOutlier) {
            // fit with optimized spectrometer errors
 
            if (!m_muonErrorOptimizer.empty() && !fittedTrack->info().trackProperties(Trk::TrackInfo::StraightTrack) &&
                optimizeErrors(ctx, *fittedTrack)) {
                ATH_MSG_VERBOSE(" perform spectrometer error optimization after cleaning ");
                std::unique_ptr<Trk::Track> optimizedTrack = m_muonErrorOptimizer->optimiseErrors(*fittedTrack, ctx);
                if (checkTrack("Error opt", optimizedTrack.get()) &&
                    normalizedChi2(*optimizedTrack) < normalizedChi2(*fittedTrack)) {
                    fittedTrack.swap(optimizedTrack);
                    if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " cbfit scaled errors Track ");
                }
            }
 
            // chi2 before clean
            double chi2Before = normalizedChi2(*fittedTrack);
 
            // muon cleaner
            ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<<" perform track cleaning... " << m_printer->print(*fittedTrack) << std::endl
                                                          << m_printer->printStations(*fittedTrack));
 
            if (msgLevel(MSG::DEBUG)) { countAEOTs(*fittedTrack, " cb before clean Track "); }
            std::unique_ptr<Trk::Track> cleanTrack = m_cleaner->clean(*fittedTrack, ctx);
        if (cleanTrack && msgLevel(MSG::DEBUG)) { countAEOTs(*cleanTrack, " cb after clean Track "); }
 
            if (!cleanTrack) {
                if (m_allowCleanerVeto && chi2Before > m_badFitChi2) {
                    ATH_MSG_DEBUG("cleaner veto C "<<chi2Before<<" Cut: "<<m_badFitChi2);
                    ++m_countCombinedCleanerVeto;
                    fittedTrack.reset();
                } else {
                    ATH_MSG_DEBUG(" keep original combined track despite cleaner veto ");
                }
            } else if (!(*cleanTrack->perigeeParameters() == *fittedTrack->perigeeParameters())) {
                double chi2After = normalizedChi2(*cleanTrack);
                if (chi2After < m_badFitChi2 || chi2After < chi2Before) {
                    ATH_MSG_VERBOSE(" found and removed spectrometer outlier(s) ");
                    fittedTrack.swap(cleanTrack);
                } else {
                    ATH_MSG_VERBOSE(" keep original track despite cleaning ");
                }
            }
 
            // FIXME: provide indet cleaner
            ATH_MSG_VERBOSE(" finished cleaning");
        }
        // have to use release until the whole code uses unique_ptr
        return fittedTrack;
    }

fit() [3/3]

std::unique_ptr< Trk::Track > Rec::CombinedMuonTrackFitter::fit ( const EventContext & ctx, const Trk::Track & track, const Trk::RunOutlierRemoval runOutlier, const Trk::ParticleHypothesis particleHypothesis ) const

overridevirtual

Definition at line 148 of file CombinedMuonTrackFitter.cxx.

                                                                                                                    {
        ATH_MSG_VERBOSE(" fit() " << m_printer->print(track) << std::endl
                                  << m_printer->printMeasurements(track) << std::endl
                                  << m_printer->printStations(track));
        // check valid particleHypothesis
        if (particleHypothesis != Trk::muon && particleHypothesis != Trk::nonInteracting) {
            // invalid particle hypothesis
            std::stringstream ss;
            ss << particleHypothesis;
            m_messageHelper->printWarning(29, ss.str());
            return nullptr;
        }
 
        // check if combined or subsystem track
        bool isCombined = m_trackQuery->isCombined(track, ctx);
        // select straightLine fitter when magnets downstream of leading measurement are off
        const Trk::ITrackFitter* fitter = m_fitter.get();
        MagField::AtlasFieldCache fieldCache;
        // Get field cache object
 
        if (!loadMagneticField(ctx, fieldCache)) return nullptr;
 
        if (!fieldCache.toroidOn() && !(isCombined && fieldCache.solenoidOn())) {
            fitter = m_fitterSL.get();
            ATH_MSG_VERBOSE(" fit (track refit method): select SL fitter ");
        }
 
        // redo ROTs:  ID, CROT and MDT specific treatments
        // if (m_redoRots) redoRots(track);
 
        // perform fit after ensuring calo is associated for combined tracks
        // calo association for combined tracks (WARN if missing from input)
        std::unique_ptr<Trk::Track> fittedTrack = std::make_unique<Trk::Track>(track);
        if (isCombined && particleHypothesis == Trk::muon && !m_trackQuery->isCaloAssociated(*fittedTrack, ctx)) {
            // about to add the TSOS's describing calorimeter association to a combined muon;
            ATH_MSG_VERBOSE( "fit:: about to add the TSOS's describing calorimeter association to a combined muon" );
 
            auto combinedTSOS = std::make_unique<Trk::TrackStates>();
 
            combinedTSOS->reserve(fittedTrack->trackStateOnSurfaces()->size() + 3);
            bool caloAssociated = false;
 
            // run-2 schema, update default eloss with parametrised value
            if (m_useCaloTG) {
                ATH_MSG_VERBOSE("Updating Calorimeter TSOS in Muon Combined (re)Fit ...");
                m_materialUpdator->updateCaloTSOS(*fittedTrack);
                caloAssociated = true;
            }
 
            for (const Trk::TrackStateOnSurface* in_tsos : *fittedTrack->trackStateOnSurfaces()) {
                if (caloAssociated) {
                    combinedTSOS->push_back(in_tsos->clone());
                } else if ((in_tsos->measurementOnTrack() && m_indetVolume->inside(in_tsos->measurementOnTrack()->globalPosition())) ||
                           (in_tsos->trackParameters() && m_indetVolume->inside(in_tsos->trackParameters()->position()))) {
                    combinedTSOS->push_back(in_tsos->clone());
                } else {
                    std::unique_ptr<const Trk::TrackStateOnSurface> tsos = m_caloTSOS->innerTSOS(ctx, *fittedTrack->perigeeParameters());
                    if (tsos) {
                        combinedTSOS->push_back(std::move(tsos));
                        const Trk::TrackParameters* parameters = combinedTSOS->back()->trackParameters();
                        if (in_tsos->type(Trk::TrackStateOnSurface::CaloDeposit)) {
                            combinedTSOS->push_back(in_tsos->clone());
                            tsos = m_caloTSOS->outerTSOS(ctx, *parameters);
                            if (tsos) combinedTSOS->push_back(std::move(tsos));
                        } else {
                            tsos = m_caloTSOS->middleTSOS(ctx, *parameters);
                            if (tsos) combinedTSOS->push_back(std::move(tsos));
                            tsos = m_caloTSOS->outerTSOS(ctx, *parameters);
                            if (tsos) combinedTSOS->push_back(std::move(tsos));
                            combinedTSOS->push_back(in_tsos->clone());
                        }
                    }
                    caloAssociated = true;
                }
            }
 
            std::unique_ptr<Trk::Track> combinedTrack = std::make_unique<Trk::Track>(fittedTrack->info(), std::move(combinedTSOS), nullptr);
 
            if (msgLevel(MSG::DEBUG)) countAEOTs(*combinedTrack, " combinedTrack track before fit ");
 
            caloAssociated = m_trackQuery->isCaloAssociated(*combinedTrack, ctx);
 
            // Updates the calo TSOS with the ones from TG+corrections
            if (m_updateWithCaloTG && !m_useCaloTG && particleHypothesis == Trk::muon) {
                ATH_MSG_VERBOSE("Updating Calorimeter TSOS in Muon Combined (re)Fit ...");
                m_materialUpdator->updateCaloTSOS(*combinedTrack);
            }
            // FIT
            fittedTrack = fitter->fit(ctx, *combinedTrack, false, particleHypothesis);
        } else {
            // Updates the calo TSOS with the ones from TG+corrections
            if (m_updateWithCaloTG && !m_useCaloTG && particleHypothesis == Trk::muon) {
                ATH_MSG_VERBOSE("Updating Calorimeter TSOS in Muon Standalone Fit ...");
                m_materialUpdator->updateCaloTSOS(*fittedTrack);
            }
 
            // FIT
            fittedTrack = fitter->fit(ctx, *fittedTrack, false, particleHypothesis);
        }
 
        // quit if fit has failed
        if (!fittedTrack) return nullptr;
 
 
        if (!checkTrack("fitInterface1", fittedTrack.get())) return nullptr;
 
 
        // eventually this whole tool will use unique_ptrs
        // in the meantime, this allows the MuonErrorOptimisationTool and MuonRefitTool to use them
        // track cleaning
        if (runOutlier) {
            // fit with optimized spectrometer errors
 
            const double chi2BeforeOptimizer = normalizedChi2(*fittedTrack);
            if (!m_muonErrorOptimizer.empty() && !fittedTrack->info().trackProperties(Trk::TrackInfo::StraightTrack) &&
                optimizeErrors(ctx, *fittedTrack)) {
                ATH_MSG_VERBOSE(" perform spectrometer error optimization after cleaning ");
                std::unique_ptr<Trk::Track> optimizedTrack = m_muonErrorOptimizer->optimiseErrors(*fittedTrack, ctx);
                if (checkTrack("fitInterface1Opt", optimizedTrack.get()) && chi2BeforeOptimizer > normalizedChi2(*optimizedTrack)) {
                    fittedTrack.swap(optimizedTrack);
                    if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " re fit scaled errors Track ");
                }
            }
 
            // chi2 before clean
            const double chi2Before = normalizedChi2(*fittedTrack);
 
            // muon cleaner
            ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<<" perform track cleaning... " << m_printer->print(*fittedTrack) << std::endl
                                                          << m_printer->printStations(*fittedTrack));
 
            if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " refit: fitted track before cleaning ");
 
            std::unique_ptr<Trk::Track> cleanTrack = m_cleaner->clean(*fittedTrack, ctx);
 
            if (msgLevel(MSG::DEBUG)) countAEOTs(*cleanTrack, " refit: after cleaning");
 
            if (!checkTrack("fitInterface1Cleaner", cleanTrack.get())) { cleanTrack.reset(); }
 
            if (!cleanTrack) {
                if (m_allowCleanerVeto && chi2Before > m_badFitChi2) {
                    ATH_MSG_DEBUG(" cleaner veto A "<<chi2Before<<" "<<m_badFitChi2<<" "<<m_printer->printMeasurements(*fittedTrack) );
                    ++m_countStandaloneCleanerVeto;
                    fittedTrack.reset();
                } else {
                    ATH_MSG_DEBUG(" keep original standalone track despite cleaner veto ");
                }
            } else if (!(*cleanTrack->perigeeParameters() == *fittedTrack->perigeeParameters())) {
                double chi2After = normalizedChi2(*cleanTrack);
 
                if (chi2After < m_badFitChi2 || chi2After < chi2Before) {
                    ATH_MSG_VERBOSE(" found and removed spectrometer outlier(s) ");
                    fittedTrack.swap(cleanTrack);
                } else {
                    ATH_MSG_VERBOSE(" keep original track despite cleaning ");
                }
            }
 
            // FIXME: provide indet cleaner
            if (fittedTrack) {
                ATH_MSG_VERBOSE(" finished track cleaning... " << m_printer->print(*fittedTrack) << std::endl
                                                               << m_printer->printStations(*fittedTrack));
            }
        }
        return fittedTrack;
    }

initialize()

StatusCode Rec::CombinedMuonTrackFitter::initialize ( )

overridevirtual

Reimplemented in Rec::CombinedMuonTrackBuilder.

Definition at line 50 of file CombinedMuonTrackFitter.cxx.

                                                   {
        ATH_MSG_DEBUG("Initializing CombinedMuonTrackFitter.");
        ATH_MSG_DEBUG(" with options: ");
 
        if (m_allowCleanerVeto) ATH_MSG_DEBUG(" AllowCleanerVeto");
        if (!m_muonErrorOptimizer.empty()) ATH_MSG_DEBUG(" ErrorOptimisation");
 
        // fill WARNING messages
        m_messageHelper->setMaxNumberOfMessagesPrinted(m_maxWarnings);
        m_messageHelper->setMessage(0, "combinedFit:: missing MeasuredPerigee for indet track");
        m_messageHelper->setMessage(1, "combinedFit:: fail with MS removed by cleaner");
        m_messageHelper->setMessage(2, "combinedFit:: fail with perigee outside indet");
        m_messageHelper->setMessage(3, "combinedFit:: fail with missing caloEnergy");
        m_messageHelper->setMessage(4, "combinedFit:: final combined track lost, this should not happen");
        m_messageHelper->setMessage(5, "indetExtension:: reject with insufficient MS measurements");
        m_messageHelper->setMessage(6, "standaloneFit:: input vertex fails dynamic_cast");
        m_messageHelper->setMessage(7, "standaloneFit:: missing MeasuredPerigee for spectrometer track");
        m_messageHelper->setMessage(8, "standaloneFit:: missing TrackParameters on prefit");
        m_messageHelper->setMessage(9, "standaloneFit:: prefit fails parameter extrapolation to calo");
        m_messageHelper->setMessage(10, "standaloneFit:: extrapolated track missing TrackParameters at calo scatterer");
        m_messageHelper->setMessage(11, "standaloneFit:: final track lost, this should not happen");
        m_messageHelper->setMessage(12, "standaloneFit:: fail as calo incorrectly described");
        m_messageHelper->setMessage(13, "standaloneRefit:: fail track as no TSOS with type CaloDeposit");
        m_messageHelper->setMessage(14, "standaloneRefit:: no inner material");
        m_messageHelper->setMessage(15, "standaloneRefit:: no inner parameters");
        m_messageHelper->setMessage(16, "standaloneRefit:: innerScattering dynamic_cast failed");
        m_messageHelper->setMessage(17, "standaloneRefit:: no TSOS of type CaloDeposit found");
        m_messageHelper->setMessage(18, "standaloneRefit:: no inner scattering TSOS found");
        m_messageHelper->setMessage(19, "standaloneRefit:: no middle material");
        m_messageHelper->setMessage(20, "standaloneRefit:: no middle parameters");
        m_messageHelper->setMessage(21, "standaloneRefit:: no CaloDeposit TSOS found");
        m_messageHelper->setMessage(22, "standaloneRefit:: no outer material");
        m_messageHelper->setMessage(23, "standaloneRefit:: no outer parameters");
        m_messageHelper->setMessage(24, "standaloneRefit:: outerScattering dynamic_cast failed");
        m_messageHelper->setMessage(25, "standaloneRefit:: no outerScattering or CaloDeposit TSOS found");
        m_messageHelper->setMessage(26, "standaloneRefit:: failed propagation to innerTSOS");
        m_messageHelper->setMessage(27, "standaloneRefit:: failed propagation to middleTSOS");
        m_messageHelper->setMessage(28, "standaloneRefit:: fail as calo incorrectly described");
        m_messageHelper->setMessage(29, "fit:: particle hypothesis must be 0 or 2 (nonInteracting or muon). Requested: ");
        m_messageHelper->setMessage(30, "fit:: about to add the TSOS's describing calorimeter association to a combined muon");
        m_messageHelper->setMessage(31, "fit:: particle hypothesis must be 0 or 2 (nonInteracting or muon). Requested: ");
        m_messageHelper->setMessage(32, "fit:: particle hypothesis must be 0 or 2 (nonInteracting or muon). Requested: ");
        m_messageHelper->setMessage(33, "fit:: combined muon track is missing the TSOS's describing calorimeter association");
        m_messageHelper->setMessage(34, "appendSelectedTSOS:: skip duplicate measurement ");
        m_messageHelper->setMessage(35, "caloEnergyParameters:: muonTrack without caloEnergy association");
        m_messageHelper->setMessage(36, "caloEnergyParameters:: combinedTrack without caloEnergy association");
        m_messageHelper->setMessage(37, "createMuonTrack:: should never happen: FSR caloEnergy delete");
        m_messageHelper->setMessage(38, "createSpectrometerTSOS:: missing MeasuredPerigee for spectrometer track");
        m_messageHelper->setMessage(39, "createSpectrometerTSOS:: skip unrecognized TSOS without TrackParameters. Type: ");
        m_messageHelper->setMessage(40, "createSpectrometerTSOS:: skip duplicate measurement on same Surface. Type: ");
        m_messageHelper->setMessage(41, "entrancePerigee:: missing TrackingGeometrySvc - no perigee will be added at MS entrance");
        m_messageHelper->setMessage(42, "extrapolatedParameters:: missing MeasuredPerigee for spectrometer track");
        m_messageHelper->setMessage(43, "extrapolatedParameters:: missing spectrometer parameters on spectrometer track");
        m_messageHelper->setMessage(44, "final track lost, this should not happen");
        m_messageHelper->setMessage(45, "momentumUpdate:: update failed, keeping original value");
        m_messageHelper->setMessage(46, "reallocateMaterial:: null perigeeStartValue");
        m_messageHelper->setMessage(47, "reallocateMaterial:: refit fails");
        m_messageHelper->setMessage(48, "standaloneFit:: insufficient measurements on input spectrometer track");
        m_messageHelper->setMessage(49, "standaloneFit:: inconsistent TSOS on input spectrometer track");
 
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
        ATH_MSG_DEBUG("Setup handle for key " << m_fieldCacheCondObjInputKey);
        ATH_CHECK(m_muonErrorOptimizer.retrieve(DisableTool{m_muonErrorOptimizer.empty()}));
 
        ATH_CHECK(m_caloTSOS.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_caloTSOS);
        ATH_CHECK(m_cleaner.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_cleaner);
 
        ATH_CHECK(m_fitter.retrieve());
        ATH_CHECK(m_fitterSL.retrieve());
        ATH_CHECK(m_idHelperSvc.retrieve());
 
        ATH_CHECK(m_trackingVolumesSvc.retrieve());
        ATH_MSG_DEBUG("Retrieved Svc " << m_trackingVolumesSvc);
        m_calorimeterVolume = std::make_unique<Trk::Volume>(m_trackingVolumesSvc->volume(Trk::ITrackingVolumesSvc::MuonSpectrometerEntryLayer));
        m_indetVolume = std::make_unique<Trk::Volume>(m_trackingVolumesSvc->volume(Trk::ITrackingVolumesSvc::CalorimeterEntryLayer));
 
        ATH_CHECK(m_trackQuery.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_trackQuery);
        ATH_CHECK(m_trackSummary.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_trackSummary);
        ATH_CHECK(m_materialUpdator.retrieve());
        ATH_MSG_DEBUG("Retrieved tool " << m_materialUpdator);
 
        return StatusCode::SUCCESS;
    }

loadMagneticField()

bool Rec::CombinedMuonTrackFitter::loadMagneticField ( const EventContext & ctx, MagField::AtlasFieldCache & field_cache ) const

protected

Definition at line 531 of file CombinedMuonTrackFitter.cxx.

                                                                                                                      {
        SG::ReadCondHandle<AtlasFieldCacheCondObj> fieldCondObj{m_fieldCacheCondObjInputKey, ctx};
        if (!fieldCondObj.isValid()) {
            ATH_MSG_ERROR("Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
            return false;
        }
        fieldCondObj->getInitializedCache(fieldCache);
        return true;
    }

normalizedChi2()

double Rec::CombinedMuonTrackFitter::normalizedChi2 ( const Trk::Track & track ) const

protected

Definition at line 518 of file CombinedMuonTrackFitter.cxx.

                                                                              {
        double chi2 = 999999.;
        if (track.fitQuality()) {
            if (track.fitQuality()->numberDoF()) {
                chi2 = track.fitQuality()->chiSquared() / track.fitQuality()->doubleNumberDoF();
            } else {
                chi2 = m_badFitChi2;
            }
        }
 
        return chi2;
    }

optimizeErrors()

bool Rec::CombinedMuonTrackFitter::optimizeErrors ( const EventContext & ctx, Trk::Track & track ) const

private

Definition at line 540 of file CombinedMuonTrackFitter.cxx.

                                                                                               {
        const Trk::MuonTrackSummary* muonSummary = nullptr;
        const Trk::TrackSummary* summary = track.trackSummary();
 
        if (summary) {
            muonSummary = summary->muonTrackSummary();
        } else {
            m_trackSummary->updateTrack(ctx, track);
            summary = track.trackSummary();
            muonSummary = summary->muonTrackSummary();
        }
 
        if (!muonSummary) return false;
 
 
        unsigned int optimize{0},nBarrel{0}, nEndcap{0}, nSmall{0}, nLarge{0};
 
        for (const Trk::MuonTrackSummary::ChamberHitSummary& summary : muonSummary->chamberHitSummary()) {
            const Identifier& id = summary.chamberId();
            bool isMdt = m_idHelperSvc->isMdt(id);
            if (!isMdt) continue;
 
            using namespace Muon::MuonStationIndex;
 
            const ChIndex chIdx = m_idHelperSvc->chamberIndex(id);
            const bool isSmall = m_idHelperSvc->isSmallChamber(id);
            nBarrel += isBarrel(chIdx);
            nEndcap += !isBarrel(chIdx);
            nSmall+= isSmall;
            nLarge += !isSmall;
 
            if (chIdx == ChIndex::BIS &&
                std::abs(m_idHelperSvc->stationEta(id)) > 6) {
                optimize = 2;
            } else if (chIdx == ChIndex::BEE) {
                optimize = 1;
            }
        }
 
        if (nBarrel > 0 && nEndcap > 0) { optimize += 10; }
 
        if (nSmall > 0 && nLarge > 0) { optimize += 100; }
 
        if (optimize > 0) { ATH_MSG_DEBUG(" OptimizeErrors with value " << optimize); }
 
        return optimize > 0;
    }

Member Data Documentation

m_allowCleanerVeto

Gaudi::Property<bool> Rec::CombinedMuonTrackFitter::m_allowCleanerVeto {this, "AllowCleanerVeto", true}

private

Definition at line 139 of file CombinedMuonTrackFitter.h.

{this, "AllowCleanerVeto", true};       

m_badFitChi2

Gaudi::Property<double> Rec::CombinedMuonTrackFitter::m_badFitChi2 {this, "BadFitChi2", 2.5}

protected

Definition at line 144 of file CombinedMuonTrackFitter.h.

{this, "BadFitChi2", 2.5};       

m_calorimeterVolume

std::unique_ptr<const Trk::Volume> Rec::CombinedMuonTrackFitter::m_calorimeterVolume {nullptr}

protected

Definition at line 152 of file CombinedMuonTrackFitter.h.

{nullptr};

m_caloTSOS

ToolHandle<Rec::IMuidCaloTrackStateOnSurface> Rec::CombinedMuonTrackFitter::m_caloTSOS

protected

Initial value:

{
            this,
            "CaloTSOS",
            "",
        }

Definition at line 99 of file CombinedMuonTrackFitter.h.

                                                              {
            this,
            "CaloTSOS",
            "",
        };       

m_cleaner

ToolHandle<Muon::IMuonTrackCleaner> Rec::CombinedMuonTrackFitter::m_cleaner

private

Initial value:

{
            this,
            "Cleaner",
            "Muon::MuonTrackCleaner/MuidTrackCleaner",
        }

Definition at line 82 of file CombinedMuonTrackFitter.h.

                                                   {
            this,
            "Cleaner",
            "Muon::MuonTrackCleaner/MuidTrackCleaner",
        };       

m_countCombinedCleanerVeto

std::atomic_uint Rec::CombinedMuonTrackFitter::m_countCombinedCleanerVeto {0}

mutableprivate

Definition at line 158 of file CombinedMuonTrackFitter.h.

{0};

m_countExtensionCleanerVeto

std::atomic_uint Rec::CombinedMuonTrackFitter::m_countExtensionCleanerVeto {0}

mutableprivate

Definition at line 159 of file CombinedMuonTrackFitter.h.

{0};

m_countStandaloneCleanerVeto

std::atomic_uint Rec::CombinedMuonTrackFitter::m_countStandaloneCleanerVeto {0}

mutableprivate

Definition at line 160 of file CombinedMuonTrackFitter.h.

{0};

m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> Rec::CombinedMuonTrackFitter::m_fieldCacheCondObjInputKey

private

Initial value:

{this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                                  "Name of the Magnetic Field conditions object key"}

Definition at line 133 of file CombinedMuonTrackFitter.h.

                                                                               {this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                                  "Name of the Magnetic Field conditions object key"};

m_fitter

ToolHandle<Trk::ITrackFitter> Rec::CombinedMuonTrackFitter::m_fitter

private

Initial value:

{
            this,
            "Fitter",
            "Trk::iPatFitter/iPatFitter",
        }

Definition at line 87 of file CombinedMuonTrackFitter.h.

                                            {
            this,
            "Fitter",
            "Trk::iPatFitter/iPatFitter",
        };  // curved track fitter

m_fitterSL

ToolHandle<Trk::ITrackFitter> Rec::CombinedMuonTrackFitter::m_fitterSL

private

Initial value:

{
            this,
            "SLFitter",
            "Trk::iPatFitter/iPatSLFitter",
        }

Definition at line 92 of file CombinedMuonTrackFitter.h.

                                              {
            this,
            "SLFitter",
            "Trk::iPatFitter/iPatSLFitter",
        };  // straight line fitter

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Rec::CombinedMuonTrackFitter::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

protected

Definition at line 129 of file CombinedMuonTrackFitter.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_indetVolume

std::unique_ptr<const Trk::Volume> Rec::CombinedMuonTrackFitter::m_indetVolume {nullptr}

protected

Definition at line 151 of file CombinedMuonTrackFitter.h.

{nullptr};

m_materialUpdator

ToolHandle<Trk::ITrkMaterialProviderTool> Rec::CombinedMuonTrackFitter::m_materialUpdator

protected

Initial value:

{
            this,
            "CaloMaterialProvider",
            "",
        }

Definition at line 124 of file CombinedMuonTrackFitter.h.

                                                                 {
            this,
            "CaloMaterialProvider",
            "",
        };

m_maxWarnings

Gaudi::Property<unsigned> Rec::CombinedMuonTrackFitter::m_maxWarnings

private

Initial value:

{this, "MaxNumberOfWarnings", 10,
                                                "Maximum number of permitted WARNING messages per message type."}

Definition at line 140 of file CombinedMuonTrackFitter.h.

                                             {this, "MaxNumberOfWarnings", 10,
                                                "Maximum number of permitted WARNING messages per message type."};

m_messageHelper

std::unique_ptr<MessageHelper> Rec::CombinedMuonTrackFitter::m_messageHelper {std::make_unique<MessageHelper>(*this, 50)}

protected

Definition at line 155 of file CombinedMuonTrackFitter.h.

{std::make_unique<MessageHelper>(*this, 50)};

m_muonErrorOptimizer

ToolHandle<Muon::IMuonErrorOptimisationTool> Rec::CombinedMuonTrackFitter::m_muonErrorOptimizer

protected

Initial value:

{
            this,
            "MuonErrorOptimizer",
            "",
        }

Definition at line 104 of file CombinedMuonTrackFitter.h.

                                                                       {
            this,
            "MuonErrorOptimizer",
            "",
        };

m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> Rec::CombinedMuonTrackFitter::m_printer

protected

Initial value:

{
            this,
            "Printer",
            "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
        }

Definition at line 109 of file CombinedMuonTrackFitter.h.

                                                          {
            this,
            "Printer",
            "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
        };

m_trackingVolumesSvc

ServiceHandle<Trk::ITrackingVolumesSvc> Rec::CombinedMuonTrackFitter::m_trackingVolumesSvc {this, "TrackingVolumesSvc", "Trk::TrackingVolumesSvc/TrackingVolumesSvc"}

private

Definition at line 136 of file CombinedMuonTrackFitter.h.

{this, "TrackingVolumesSvc", "Trk::TrackingVolumesSvc/TrackingVolumesSvc"};

m_trackQuery

ToolHandle<Rec::IMuonTrackQuery> Rec::CombinedMuonTrackFitter::m_trackQuery

protected

Initial value:

{
            this,
            "TrackQuery",
            "Rec::MuonTrackQuery/MuonTrackQuery",
        }

Definition at line 114 of file CombinedMuonTrackFitter.h.

                                                   {
            this,
            "TrackQuery",
            "Rec::MuonTrackQuery/MuonTrackQuery",
        };

m_trackSummary

ToolHandle<Trk::ITrackSummaryTool> Rec::CombinedMuonTrackFitter::m_trackSummary

protected

Initial value:

{
            this,
            "TrackSummaryTool",
            "Trk::TrackSummaryTool/MuidTrackSummaryTool",
        }

Definition at line 119 of file CombinedMuonTrackFitter.h.

                                                       {
            this,
            "TrackSummaryTool",
            "Trk::TrackSummaryTool/MuidTrackSummaryTool",
        };

m_updateWithCaloTG

Gaudi::Property<bool> Rec::CombinedMuonTrackFitter::m_updateWithCaloTG {this, "UpdateWithCaloTG", false}

protected

Definition at line 147 of file CombinedMuonTrackFitter.h.

{this, "UpdateWithCaloTG", false};

m_useCaloTG

Gaudi::Property<bool> Rec::CombinedMuonTrackFitter::m_useCaloTG {this, "UseCaloTG", false}

protected

Definition at line 148 of file CombinedMuonTrackFitter.h.

{this, "UseCaloTG", false};

m_zECToroid

Gaudi::Property<double> Rec::CombinedMuonTrackFitter::m_zECToroid {this, "zECToroid", 10. * Gaudi::Units::meter}

protected

Definition at line 146 of file CombinedMuonTrackFitter.h.

{this, "zECToroid", 10. * Gaudi::Units::meter};

---

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

• CombinedMuonTrackFitter.h
• CombinedMuonTrackFitter.cxx