MuonR4::MdtSegmentFitter Class Reference

#include <MdtSegmentFitter.h>

Inheritance diagram for MuonR4::MdtSegmentFitter:

Collaboration diagram for MuonR4::MdtSegmentFitter:

Classes
struct	Config
struct	LineWithPartials
	Store the partial derivative of the line w.r.t. More...
struct	ResidualAuxillaries
	Helper struct carrying the space for all auxillary variables needed to calculate the residual from wire measurements. More...
struct	ResidualWithPartials
	Helper struct carrying the residual with its derivatives. More...

Public Types
using	ParamDefs = SegmentFit::ParamDefs
using	Parameters = SegmentFit::Parameters
using	HitType = std::unique_ptr< CalibratedSpacePoint >
using	HitVec = std::vector< HitType >

Public Member Functions
	MdtSegmentFitter (const std::string &name, Config &&config)
	Standard constructor. More...
SegmentFitResult	fitSegment (const EventContext &ctx, HitVec &&calibHits, const Parameters &startPars, const Amg::Transform3D &localToGlobal) const
void	calculateWireResiduals (const LineWithPartials &line, const CalibratedSpacePoint &spacePoint, ResidualWithPartials &residual) const
	Calculates the residuals together with the corresponding derivatives for a drift-circle measurement. More...
void	calculateStripResiduals (const LineWithPartials &line, const CalibratedSpacePoint &spacePoint, ResidualWithPartials &residual) const
	Calculates the residual together with hte correspdonding derivatives for strip measurements. More...
bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...
MsgStream &	msg () const
	The standard message stream. More...
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...
void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Static Public Member Functions
static void	updateLinePartials (const Parameters &fitPars, LineWithPartials &line)
	Updates the line parameters together with its first & second order partial derivatives. More...

Private Types
enum	UpdateStatus { UpdateStatus::allOkay = 0, UpdateStatus::outOfBounds = 1, UpdateStatus::noChange = 2 }
using	MeasCov_t = CalibratedSpacePoint::Covariance_t
	Updates the chi2, its Gradient & Hessian from the measurement residual. More...

Private Member Functions
bool	recalibrate (const EventContext &ctx, SegmentFitResult &fitResult) const
	Recalibrate the measurements participating in the fit & shift them into the centre-of gravity frame. More...
bool	updateHitSummary (SegmentFitResult &fitResult) const
	Brief updates the hit summary from the contributing hits. More...
void	updateDriftSigns (const Amg::Vector3D &segPos, const Amg::Vector3D &segDir, SegmentFitResult &fitRes) const
	Update the signs of the measurement. More...
void	updateDerivatives (const ResidualWithPartials &fitMeas, const MeasCov_t &measCovariance, AmgVector(5)&gradient, AmgSymMatrix(5)&hessian, double &chi2, int startPar) const
template<unsigned int nDim>
UpdateStatus	updateParameters (Parameters &currentPars, Parameters &previousPars, Parameters &currGrad, Parameters &prevGrad, const AmgSymMatrix(5)&hessian) const
	Update step of the segment parameters using the Hessian and the gradient. More...
template<unsigned int nDim>
void	blockCovariance (const AmgSymMatrix(5)&hessian, SegmentFit::Covariance &covariance) const
void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
Config	m_cfg {}
std::string	m_nm
	Message source name. More...
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Detailed Description

Definition at line 19 of file MdtSegmentFitter.h.

Member Typedef Documentation

HitType

using MuonR4::MdtSegmentFitter::HitType = std::unique_ptr<CalibratedSpacePoint>

Definition at line 23 of file MdtSegmentFitter.h.

HitVec

using MuonR4::MdtSegmentFitter::HitVec = std::vector<HitType>

Definition at line 24 of file MdtSegmentFitter.h.

MeasCov_t

using MuonR4::MdtSegmentFitter::MeasCov_t = CalibratedSpacePoint::Covariance_t

private

Updates the chi2, its Gradient & Hessian from the measurement residual.

Depending on whether the time needs to be taken into account or not the template parameter nDim is either 3 or 2, respectively.

Parameters

fitMeas	Residual of the prediction from the measurement together with its derivatives
measCovariance	Covariance matrix of the measurement
gradient	Reference to the gradient of the chi2 which is updated by the function
hessian	Reference to the Hessian matrix of the chi2 which is updated by the function
chi2	Reference to the chi2 value itself which is updated by the function
startPar	Number of the maximum fit parameter to consider

Definition at line 163 of file MdtSegmentFitter.h.

ParamDefs

using MuonR4::MdtSegmentFitter::ParamDefs = SegmentFit::ParamDefs

Definition at line 21 of file MdtSegmentFitter.h.

Parameters

using MuonR4::MdtSegmentFitter::Parameters = SegmentFit::Parameters

Definition at line 22 of file MdtSegmentFitter.h.

Member Enumeration Documentation

UpdateStatus

enum MuonR4::MdtSegmentFitter::UpdateStatus

strongprivate

Enumerator
allOkay
outOfBounds
noChange

Definition at line 172 of file MdtSegmentFitter.h.

                                   {
                allOkay = 0,
                outOfBounds = 1,
                noChange = 2,
            };

Constructor & Destructor Documentation

MdtSegmentFitter()

MuonR4::MdtSegmentFitter::MdtSegmentFitter	(	const std::string &	name,
		Config &&	config
	)

Standard constructor.

Parameters

name	Name to be printed in the messaging
config	Fit configuration parameters

Definition at line 51 of file MdtSegmentFitter.cxx.

                                                                            :
        AthMessaging{name},
        m_cfg{std::move(config)}{}

Member Function Documentation

blockCovariance()

template<unsigned int nDim>

void MuonR4::MdtSegmentFitter::blockCovariance ( const AmgSymMatrix(5)&  hessian, SegmentFit::Covariance &  covariance  ) const

private

Definition at line 606 of file MdtSegmentFitter.cxx.

                                                                                       {
 
            covariance.setIdentity();
            AmgSymMatrix(nDim) miniHessian = hessian.block<nDim, nDim>(0,0);
            if (std::abs(miniHessian.determinant()) <= detCutOff) {
                ATH_MSG_VERBOSE("Boeser mini hessian ("<<miniHessian.determinant()<<")\n"<<miniHessian<<"\n\n"<<hessian);
                return;
            }
            ATH_MSG_VERBOSE("Hessian matrix: \n"<<hessian<<",\nblock Hessian:\n"<<miniHessian<<",\n determinant: "<<miniHessian.determinant());
            covariance.block<nDim,nDim>(0,0) = miniHessian.inverse();
            ATH_MSG_VERBOSE("covariance: \n"<<covariance);
    }

calculateStripResiduals()

void MuonR4::MdtSegmentFitter::calculateStripResiduals	(	const LineWithPartials &	line,
		const CalibratedSpacePoint &	spacePoint,
		ResidualWithPartials &	residual
	)		const

Calculates the residual together with hte correspdonding derivatives for strip measurements.

The residual is calculated by a straight line propagation of the segment onto the plane & then taking the absolute disances in the [precision] & [non-precision direction]

Parameters

line	Current segment line together with the first & second order derivatives
spacePoint	Reference to the measurement to calculate the residual to
residual	Output residual object to save the actual residual and the derivatives

Update the residual accordingly

Definition at line 297 of file MdtSegmentFitter.cxx.

                                                                                         {
        
        
        const Amg::Vector3D& hitPos{hit.positionInChamber()};
        const Amg::Vector3D normal = hit.type() != xAOD::UncalibMeasType::Other 
                                   ? hit.spacePoint()->planeNormal() : Amg::Vector3D::UnitZ();
        const double planeOffSet = normal.dot(hitPos);
 
        const double normDot = normal.dot(line.dir); 
        if (std::abs(normDot) < std::numeric_limits<double>::epsilon()){
            residual.residual.setZero();
            for (Amg::Vector3D& deriv: residual.gradient) {
                deriv.setZero();
            }
            if (m_cfg.useSecOrderDeriv) {
                for (Amg::Vector3D& hessian : residual.hessian){
                    hessian.setZero();
                }
            }
            ATH_MSG_WARNING("The hit parallel with the segment line "<<Amg::toString(line.dir));
            return;
        }
        const double travelledDist = (planeOffSet - line.pos.dot(normal)) / normDot;
        
        const Amg::Vector3D planeIsect = line.pos + travelledDist * line.dir;
        residual.residual.block<2,1>(0,0) = (planeIsect - hitPos).block<2,1>(0,0);
 
        for (unsigned fitPar = 0; fitPar < line.gradient.size(); ++fitPar) {
            switch (fitPar) {
                case toInt(ParamDefs::phi):
                case toInt(ParamDefs::theta):{                
                    const double partialDist = - travelledDist / normDot * normal.dot(line.gradient[fitPar]);
                    residual.gradient[fitPar].block<2,1>(0,0) = (travelledDist * line.gradient[fitPar] + partialDist * line.dir).block<2,1>(0,0);
                    break;
                } case toInt(ParamDefs::y0):
                  case toInt(ParamDefs::x0): {
                    residual.gradient[fitPar].block<2,1>(0,0) = (line.gradient[fitPar] - line.gradient[fitPar].dot(normal) / normDot * line.dir).block<2,1>(0,0);
                    break;
                }
                default: {
                    break;
                }
            }
        }
        if (!m_cfg.useSecOrderDeriv) {
            return;
        }
        constexpr unsigned nLinePars = LineWithPartials::nPars;
        for (int param = toInt(ParamDefs::phi); param >=0; --param){
            for (int param1 = param; param1>=0; --param1) {
                const int lineIdx = vecIdxFromSymMat<nLinePars>(param, param1);
                const int resIdx = vecIdxFromSymMat<toInt(ParamDefs::nPars)>(param, param1);
                if ( (param == toInt(ParamDefs::theta) || param == toInt(ParamDefs::phi)) &&
                     (param1 == toInt(ParamDefs::theta) || param1 == toInt(ParamDefs::phi))) {
                    residual.hessian[resIdx].block<2,1>(0,0) =(
                        travelledDist * line.hessian[lineIdx] - travelledDist *(normal.dot(line.hessian[lineIdx])) / normDot * line.dir
                        - normal.dot(line.gradient[param1]) / normDot * residual.gradient[param]
                        - normal.dot(line.gradient[param]) / normDot * residual.gradient[param1]).block<2,1>(0,0);
                } else if (param == toInt(ParamDefs::theta) || param == toInt(ParamDefs::phi)) {
                    const double gradientDisplace = normal.dot(line.gradient[param1]);
                    if (gradientDisplace > std::numeric_limits<float>::epsilon()){
                        residual.hessian[resIdx].block<2,1>(0,0) = gradientDisplace*( normal.dot(line.gradient[param]) / std::pow(normDot,2)*line.dir
                                                                  - line.gradient[param] / normDot ).block<2,1>(0,0);
                    } else {
                        residual.hessian[resIdx].setZero();
                    }
                }    
            }
        }
    }

calculateWireResiduals()

void MuonR4::MdtSegmentFitter::calculateWireResiduals	(	const LineWithPartials &	line,
		const CalibratedSpacePoint &	spacePoint,
		ResidualWithPartials &	residual
	)		const

Calculates the residuals together with the corresponding derivatives for a drift-circle measurement.

The residual is calculated by projecting the hit into the plane perpendicular to the wire. If the hit is a twin-hit the distance along the wire is taken into account as well.

Parameters

line	Current segment line together with the first & second order derivatives
spacePoint	Reference to the measurement to calculate the residual to
residual	Output residual object to save the actual residual and the derivatives

Fetch the hit position & direction

Cache the scalar product & the lengths as they're appearing in the formulas below more often

Project the segment onto the plane

Calculate the distance from the two reference points

Distance from the segment line to the tube wire

If the tube is a twin-tube, the hit position is no longer arbitrary along the wire. Calculate the distance along the wire towards the point of closest approach.

Calculate the first derivative of the residual

No variation of the track parameters w.r.t. the time

Loop to include the second order derivatvies

Pure angular derivatives of the residual

Angular & Spatial mixed terms

Definition at line 167 of file MdtSegmentFitter.cxx.

                                                                                      {
        const Amg::Vector3D& hitPos{hit.positionInChamber()};
        const Amg::Vector3D& hitDir{hit.directionInChamber()};
        resObj.projIntoWirePlane = line.dir.dot(hitDir);
        resObj.projDirLenSq = 1. - resObj.projIntoWirePlane*resObj.projIntoWirePlane;
        if (resObj.projDirLenSq < std::numeric_limits<float>::epsilon()) {
            resObj.residual.setZero();
            for (Amg::Vector3D& grad : resObj.gradient){
                grad.setZero();
            }
            if (m_cfg.useSecOrderDeriv) {
                for (Amg::Vector3D& hess : resObj.hessian) {
                    hess.setZero();
                }
            }
            ATH_MSG_WARNING("Segment is parallel along the wire");
            return;
        }
        resObj.invProjLenSq = 1. / resObj.projDirLenSq;
        resObj.invProjLen = std::sqrt(resObj.invProjLenSq);
        resObj.projDir = (line.dir - resObj.projIntoWirePlane*hitDir) * resObj.invProjLen;
        const Amg::Vector3D hitMinSeg = hitPos - line.pos ;
        const double lineDist = resObj.projDir.cross(hitDir).dot(hitMinSeg);
        const double resVal = (lineDist - hit.driftRadius());
        resObj.residual = resVal * Amg::Vector3D::Unit(toInt(AxisDefs::eta));
        ATH_MSG_VERBOSE("Mdt drift radius: "<<hit.driftRadius()<<" distance: "<<lineDist<<";"
                        <<Amg::signedDistance(hitPos, hitDir, line.pos, line.dir)<<", residual: "<<resVal);
        if (hit.dimension() == 2) {
            resObj.residual[toInt(AxisDefs::phi)] = (hitMinSeg.dot(line.dir)*resObj.projIntoWirePlane - hitMinSeg.dot(hitDir)) * resObj.invProjLenSq;
        }
        constexpr unsigned nLinePars = LineWithPartials::nPars;
        for (const int param : {toInt(ParamDefs::y0), toInt(ParamDefs::x0), 
                                toInt(ParamDefs::theta), toInt(ParamDefs::phi)}) {
            if (!resObj.evalPhiPars && (param == toInt(ParamDefs::x0) || param == toInt(ParamDefs::phi))){
                continue;
            }
            switch (param) {
                case toInt(ParamDefs::theta):
                case toInt(ParamDefs::phi): {
                    resObj.partWirePlaneProj[param] = line.gradient[param].dot(hitDir);
                    resObj.partProjDir[param] = (line.gradient[param] - resObj.partWirePlaneProj[param]*hitDir) * resObj.invProjLen
                                       +  resObj.partWirePlaneProj[param]*resObj.projIntoWirePlane* resObj.projDir * resObj.invProjLenSq;
                    const double partialDist = resObj.partProjDir[param].cross(hitDir).dot(hitMinSeg);
 
                    resObj.gradient[param] =  partialDist * Amg::Vector3D::Unit(toInt(AxisDefs::eta));
                    if (hit.dimension() == 2) {
                        resObj.gradient[param][toInt(AxisDefs::phi)] = 
                            ( hitMinSeg.dot(line.gradient[param]) * resObj.projIntoWirePlane +
                              hitMinSeg.dot(line.dir)*resObj.partWirePlaneProj[param]) * resObj.invProjLenSq
                            +2.* resObj.residual[toInt(AxisDefs::phi)]*( resObj.projIntoWirePlane * resObj.partWirePlaneProj[param]) * resObj.invProjLenSq;
                    }
                    break;
                } case toInt(ParamDefs::y0):
                  case toInt(ParamDefs::x0): {
                        const double partialDist = - resObj.projDir.cross(hitDir).dot(line.gradient[param]);
                        resObj.gradient[param] =  partialDist * Amg::Vector3D::Unit(toInt(AxisDefs::eta));
                        if (hit.dimension() == 2) {
                            resObj.gradient[param][toInt(AxisDefs::phi)] = -(line.gradient[param].dot(line.dir) * resObj.projIntoWirePlane - 
                                                                                   line.gradient[param].dot(hitDir)) * resObj.invProjLenSq;
                        }
                        break;
                }
                default:
                    break;
            }
        }
        if (!m_cfg.useSecOrderDeriv) {
            return;
        }
        for (int param = toInt(ParamDefs::phi); param >=0; --param){
            if (!resObj.evalPhiPars && (param == toInt(ParamDefs::x0) || param == toInt(ParamDefs::phi))){
                continue;
            }
            for (int param1 = param; param1>=0; --param1) {
                if (!resObj.evalPhiPars && (param1 == toInt(ParamDefs::x0) || param1 == toInt(ParamDefs::phi))){
                    continue;
                }
                const int lineIdx = vecIdxFromSymMat<nLinePars>(param, param1);
                const int resIdx = vecIdxFromSymMat<toInt(ParamDefs::nPars)>(param, param1);
                if ( (param == toInt(ParamDefs::theta) || param == toInt(ParamDefs::phi)) &&
                     (param1 == toInt(ParamDefs::theta) || param1 == toInt(ParamDefs::phi))) {
                    
                    const double partSqLineProject = line.hessian[lineIdx].dot(hitDir);
                    const Amg::Vector3D projDirPartSq = (line.hessian[lineIdx] - partSqLineProject * hitDir) * resObj.invProjLen
                                                      + (resObj.partWirePlaneProj[param1] * resObj.projIntoWirePlane) * resObj.invProjLenSq * resObj.partProjDir[param]
                                                      + (resObj.partWirePlaneProj[param] * resObj.projIntoWirePlane) * resObj.invProjLenSq * resObj.partProjDir[param1]
                                                      + (partSqLineProject*resObj.projIntoWirePlane) * resObj.invProjLenSq * resObj.projDir
                                                      + (resObj.partWirePlaneProj[param1] * resObj.partWirePlaneProj[param]) * std::pow(resObj.invProjLenSq, 2) * resObj.projDir;
 
                    const double partialSqDist =  projDirPartSq.cross(hitDir).dot(hitMinSeg);
                    resObj.hessian[resIdx] = partialSqDist * Amg::Vector3D::Unit(toInt(AxisDefs::eta));
                     if (hit.dimension() == 2) {
                         const double partialSqAlongWire =2.*resObj.residual[toInt(AxisDefs::phi)]*resObj.projIntoWirePlane*partSqLineProject * resObj.invProjLenSq
                                                         +2.*resObj.residual[toInt(AxisDefs::phi)]*resObj.partWirePlaneProj[param]*resObj.partWirePlaneProj[param1]*resObj.invProjLenSq
                                                         +2.*resObj.gradient[param1][toInt(AxisDefs::phi)]*resObj.projIntoWirePlane*resObj.partWirePlaneProj[param]*resObj.invProjLenSq
                                                         +2.*resObj.gradient[param][toInt(AxisDefs::phi)]*resObj.projIntoWirePlane*resObj.partWirePlaneProj[param1]*resObj.invProjLenSq
                                                         + hitMinSeg.dot(line.hessian[lineIdx]) *resObj.projIntoWirePlane * resObj.invProjLenSq
                                                         + hitMinSeg.dot(line.dir)*partSqLineProject * resObj.invProjLenSq
                                                         + hitMinSeg.dot(line.gradient[param])*resObj.partWirePlaneProj[param1]*resObj.invProjLenSq
                                                         + hitMinSeg.dot(line.gradient[param1])*resObj.partWirePlaneProj[param]*resObj.invProjLenSq;
                         resObj.hessian[resIdx][toInt(AxisDefs::phi)] = partialSqAlongWire;
                     }
                }
                else if (param == toInt(ParamDefs::theta) || param == toInt(ParamDefs::phi)){
                    const double partialSqDist = - resObj.partProjDir[param].cross(hitDir).dot(line.gradient[param1]);    
                    resObj.hessian[resIdx] = partialSqDist * Amg::Vector3D::Unit(toInt(AxisDefs::eta));
                    if (hit.dimension() == 2) {
                        const double partialSqAlongWire = -(line.gradient[param1].dot(line.gradient[param])*resObj.projIntoWirePlane +
                                                            line.gradient[param1].dot(line.dir)*resObj.partWirePlaneProj[param]) * resObj.invProjLenSq
                                                        + 2.* resObj.gradient[param1][toInt(AxisDefs::phi)]*( resObj.projIntoWirePlane * resObj.partWirePlaneProj[param]) * resObj.invProjLenSq;
                        resObj.hessian[resIdx][toInt(AxisDefs::phi)] = partialSqAlongWire;
                    }
                }
            }
        }
    }

fitSegment()

SegmentFitResult MuonR4::MdtSegmentFitter::fitSegment	(	const EventContext &	ctx,
		HitVec &&	calibHits,
		const Parameters &	startPars,
		const Amg::Transform3D &	localToGlobal
	)		const

Cache of the partial derivatives of the line parameters w.r.t the fit parameters

Partials of the residual w.r.t. the fit parameters

Update the partial derivatives of the direction vector

First step calibrate the hits

Reset chi2

Loop over the hits to calculate the partial derivatives

If the time is fitted the drift radii need to be updated. That's properly only possible with recalibration

Time residual calculation

Loop over hits is done. Symmetrise the Hessian

Check whether the gradient is already sufficiently small

Pure eta segment fit

In the case that the time is fit & that there are no phi measurements -> compress matrix by swaping the time column with whaever the second column is... it's zero

Subtract 1 degree of freedom to take the time into account

Calculate the chi2 per measurement

Sort the measurements by ascending z

Update the covariance

Definition at line 371 of file MdtSegmentFitter.cxx.

                                                                                             {
 
        const Muon::IMuonIdHelperSvc* idHelperSvc{calibHits[0]->spacePoint()->msSector()->idHelperSvc()};
        using State = CalibratedSpacePoint::State;
 
        if (msgLvl(MSG::VERBOSE)) {
            std::stringstream hitStream{};
            const auto [startPos, startDir] = makeLine(startPars);
            for (const HitType& hit : calibHits) {
                hitStream<<"       **** "<<(hit->type() != xAOD::UncalibMeasType::Other ? idHelperSvc->toString(hit->spacePoint()->identify()): "beamspot" )
                         <<" position: "<<Amg::toString(hit->positionInChamber());
                if (hit->type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
                    hitStream<<", driftRadius: "<<SegmentFitHelpers::driftSign(startPos,startDir, *hit, msg())*hit->driftRadius() ;
                }
                hitStream<<", channel dir: "<<Amg::toString(hit->directionInChamber())<<std::endl;
            }
            ATH_MSG_VERBOSE("Start segment fit with parameters "<<toString(startPars)
                          <<", plane location: "<<Amg::toString(localToGlobal)<<std::endl<<hitStream.str());
 
        }
 
        SegmentFitResult fitResult{};
        fitResult.segmentPars = startPars;
        fitResult.timeFit = m_cfg.doTimeFit;
        fitResult.calibMeasurements = std::move(calibHits);
        if (!updateHitSummary(fitResult)) {
            ATH_MSG_WARNING("No valid segment seed parsed from the beginning");
            return fitResult;
        }
        if (!m_cfg.reCalibrate) {
            const auto [segPos, segDir] = makeLine(startPars);
            updateDriftSigns(segPos, segDir, fitResult);
        }
        Parameters gradient{AmgVector(5)::Zero()}, prevGrad{AmgVector(5)::Zero()}, prevPars{AmgVector(5)::Zero()};
        AmgSymMatrix(5) hessian{AmgSymMatrix(5)::Zero()};
 
        LineWithPartials segmentLine{};
        ResidualWithPartials residual{};
 
        unsigned int noChangeIter{0};
        while (fitResult.nIter++ < m_cfg.nMaxCalls) {
            ATH_MSG_DEBUG("Iteration: "<<fitResult.nIter<<" parameters: "<<toString(fitResult.segmentPars)<<", chi2: "<<fitResult.chi2);
            updateLinePartials(fitResult.segmentPars, segmentLine);
 
            if (m_cfg.reCalibrate && !recalibrate(ctx, fitResult)) {
                break;
            }
            fitResult.chi2 = 0;
            hessian.setZero();
            gradient.setZero();
 
            for (HitType& hit : fitResult.calibMeasurements) {
                if (hit->fitState() != State::Valid) {
                    continue;
                }
                const Amg::Vector3D& hitPos{hit->positionInChamber()};
                const Amg::Vector3D& hitDir{hit->directionInChamber()};
                ATH_MSG_DEBUG("Update chi2 from measurement "<<(hit->spacePoint() ? idHelperSvc->toString(hit->spacePoint()->identify())  
                                : "pseudo meas")<<" position: "<<Amg::toString(hitPos)<<" + "<<Amg::toString(hitDir));
 
                const int start = toInt(fitResult.nPhiMeas ? ParamDefs::phi : ParamDefs::theta);
                switch (hit->type()) {
                    case xAOD::UncalibMeasType::MdtDriftCircleType: {
                        const double dSign = (hit->driftRadius() > 0 ? 1. : -1.);
                        if (fitResult.timeFit && !m_cfg.reCalibrate && fitResult.nIter > 1) {
                            hit = m_cfg.calibrator->calibrate(ctx, *hit, segmentLine.pos, segmentLine.dir,
                                                              fitResult.segmentPars[toInt(ParamDefs::time)]);
                            hit->setDriftRadius(dSign*hit->driftRadius());
                        } 
                        calculateWireResiduals(segmentLine, *hit, residual);
 
                        if (!fitResult.timeFit) {
                            break;
                        }
                        residual.gradient[toInt(ParamDefs::time)] = dSign*m_cfg.calibrator->driftVelocity(ctx, *hit) * Amg::Vector3D::Unit(toInt(AxisDefs::eta));
                        if (m_cfg.useSecOrderDeriv) {
                            constexpr unsigned hessIdx = vecIdxFromSymMat<ResidualWithPartials::nPars>(toInt(ParamDefs::time), toInt(ParamDefs::time));
                            residual.hessian[hessIdx] = dSign*m_cfg.calibrator->driftAcceleration(ctx, *hit) * Amg::Vector3D::Unit(toInt(AxisDefs::eta));
                        }
                        break;
                    }
                    case xAOD::UncalibMeasType::RpcStripType:
                    case xAOD::UncalibMeasType::TgcStripType:
                    case xAOD::UncalibMeasType::sTgcStripType:
                    case xAOD::UncalibMeasType::MMClusterType: {
                        calculateStripResiduals(segmentLine, *hit, residual);
                        if (!fitResult.timeFit  || !hit->measuresTime()) {
                            break;
                        }
                        constexpr ParamDefs par = ParamDefs::time;
                        residual.gradient[toInt(par)] = -Amg::Vector3D::Unit(toInt(AxisDefs::t0));
                        const Amg::Vector3D planeIsect = residual.residual + hitPos;
                        const double totFlightDist = (localToGlobal * planeIsect).mag() * c_inv;
                        residual.residual[toInt(AxisDefs::t0)] = hit->time() - totFlightDist * c_inv - fitResult.segmentPars[toInt(ParamDefs::time)];
 
                        for (int p = start;  p >= 0; --p) {
                            residual.gradient[p][toInt(AxisDefs::t0)] = -residual.gradient[p].perp() * c_inv;
                            ATH_MSG_VERBOSE("Partial derivative of "<<idHelperSvc->toString(hit->spacePoint()->identify())
                                           <<" residual "<<Amg::toString(residual.residual)<<" "<<Amg::toString(multiply(inverse(hit->covariance()), residual.residual))
                                           <<" "<<std::endl<<toString(hit->covariance())<<std::endl<<" w.r.t "
                                           <<toString(static_cast<ParamDefs>(p))<<"="<<Amg::toString(residual.gradient[p]));
                        }
                        break;
                    } case xAOD::UncalibMeasType::Other: {
                        calculateStripResiduals(segmentLine, *hit, residual);
                        break;
                    } default: {
                        const auto &measurement = *hit->spacePoint()->primaryMeasurement();
                        ATH_MSG_WARNING("MdtSegmentFitter() - Unsupported measurment type" <<typeid(measurement).name());
                    }
                }
    
                ATH_MSG_VERBOSE("Update derivatives for hit "<< (hit->spacePoint() ? idHelperSvc->toString(hit->spacePoint()->identify()) : "beamspot"));
                updateDerivatives(residual, hit->covariance(), gradient, hessian, fitResult.chi2, 
                                  fitResult.timeFit && hit->measuresTime() ? toInt(ParamDefs::time) : start);
            }
 
            for (int k =1; k < 5 - (!fitResult.timeFit); ++k){
                for (int l = 0; l< k; ++l){
                    hessian(l,k) = hessian(k,l);
                }
            }
            if (gradient.mag() < m_cfg.tolerance) {
                fitResult.converged = true;
                ATH_MSG_VERBOSE("Fit converged after "<<fitResult.nIter<<" iterations with "<<fitResult.chi2);
                break;
            }
            ATH_MSG_VERBOSE("Chi2: "<<fitResult.chi2<<", gradient: "<<Amg::toString(gradient)<<"hessian: "<<std::endl<<hessian);
            UpdateStatus paramUpdate{UpdateStatus::outOfBounds};
            if (!fitResult.nPhiMeas && !fitResult.timeFit) {
                paramUpdate = updateParameters<2>(fitResult.segmentPars, prevPars, gradient, prevGrad, hessian); 
            } else if (!fitResult.nPhiMeas && fitResult.timeFit) {
                hessian.col(2).swap(hessian.col(toInt(ParamDefs::time)));
                hessian.row(2).swap(hessian.row(toInt(ParamDefs::time)));
                std::swap(gradient[2], gradient[toInt(ParamDefs::time)]);
                std::swap(fitResult.segmentPars[2], fitResult.segmentPars[toInt(ParamDefs::time)]);
 
                paramUpdate = updateParameters<3>(fitResult.segmentPars, prevPars, gradient, prevGrad, hessian); 
 
                std::swap(fitResult.segmentPars[2], fitResult.segmentPars[toInt(ParamDefs::time)]);
                hessian.col(2).swap(hessian.col(toInt(ParamDefs::time)));
                hessian.row(2).swap(hessian.row(toInt(ParamDefs::time)));
                std::swap(gradient[2], gradient[toInt(ParamDefs::time)]);
            } else if (fitResult.nPhiMeas && !fitResult.timeFit) {
                paramUpdate = updateParameters<4>(fitResult.segmentPars, prevPars, gradient, prevGrad, hessian); 
            } else if (fitResult.nPhiMeas && fitResult.timeFit) {
                paramUpdate = updateParameters<5>(fitResult.segmentPars, prevPars, gradient, prevGrad, hessian); 
            } 
            if  (paramUpdate == UpdateStatus::noChange) {
                if ((++noChangeIter) >= m_cfg.noMoveIter){
                    fitResult.converged = true;
                    break;
                }
            } else if (paramUpdate == UpdateStatus::allOkay) {
                noChangeIter = 0;
            } else if (paramUpdate == UpdateStatus::outOfBounds){
               return fitResult;
            }
        }
        
        fitResult.nDoF-=fitResult.timeFit;
        
        const auto [segPos, segDir] = fitResult.makeLine();
        fitResult.chi2 =0.;
        
        std::optional<double> toF = fitResult.timeFit ? std::make_optional<double>((localToGlobal * segPos).mag() * c_inv) : std::nullopt;
        std::ranges::stable_sort(fitResult.calibMeasurements, [](const HitType&a, const HitType& b){
                return a->positionInChamber().z() < b->positionInChamber().z();
        });
 
        /*** Remove the drift sign again */
        fitResult.chi2 =0.;
        for (const HitType& hit : fitResult.calibMeasurements) {
            hit->setDriftRadius(std::abs(hit->driftRadius()));
            fitResult.chi2 +=SegmentFitHelpers::chiSqTerm(segPos, segDir, fitResult.segmentPars[toInt(ParamDefs::time)], toF, *hit, msg());
        }
        if (!fitResult.nPhiMeas&& !fitResult.timeFit) {
            blockCovariance<2>(std::move(hessian), /* std::move(gradient), std::move(prevGrad), */ fitResult.segmentParErrs);
        }else if (!fitResult.nPhiMeas && fitResult.timeFit) {
            hessian.col(2).swap(hessian.col(toInt(ParamDefs::time)));
            hessian.row(2).swap(hessian.row(toInt(ParamDefs::time)));
            blockCovariance<3>(std::move(hessian),/* std::move(gradient), std::move(prevGrad), */ fitResult.segmentParErrs);
            fitResult.segmentParErrs.col(2).swap(fitResult.segmentParErrs.col(toInt(ParamDefs::time)));
            fitResult.segmentParErrs.row(2).swap(fitResult.segmentParErrs.row(toInt(ParamDefs::time)));
        } else if (fitResult.nPhiMeas) {
            blockCovariance<4>(std::move(hessian), /* std::move(gradient), std::move(prevGrad), */ fitResult.segmentParErrs);
        } else if (fitResult.nPhiMeas && fitResult.timeFit) {
            blockCovariance<5>(std::move(hessian),/* std::move(gradient), std::move(prevGrad), */ fitResult.segmentParErrs);
        }
        return fitResult;    
    }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  m_lvl = m_imsg ?
    static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
    MSG::INFO;
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level  lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (!m_initialized.test_and_set()) initMessaging();
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

recalibrate()

bool MuonR4::MdtSegmentFitter::recalibrate ( const EventContext &  ctx, SegmentFitResult &  fitResult  ) const

inlineprivate

Recalibrate the measurements participating in the fit & shift them into the centre-of gravity frame.

The parsed centerOfGravity position is updated to be the average measurement position weighted by the inverse covariance. Returns true if there're enough degrees of freedom left to fit

Parameters

ctx	EventContext to fetch the calibration constants
fitResult	Current fit state
centerOfGravity	Vector to save the center of gravity position later on.
invCov	Vector to cache the inverse covariances of the problem.

Switch off the time fit if too little degrees of freedom are left

Recalibrate the measurements

Definition at line 62 of file MdtSegmentFitter.cxx.

                                                                                {
        
        const auto [segPos, segDir] = makeLine(fitResult.segmentPars);
 
        fitResult.calibMeasurements = m_cfg.calibrator->calibrate(ctx, std::move(fitResult.calibMeasurements), segPos, segDir,
                                                                  fitResult.segmentPars[toInt(ParamDefs::time)]);
        if (!updateHitSummary(fitResult)){
            return false;
        }
        updateDriftSigns(segPos, segDir, fitResult);
        if (fitResult.timeFit && fitResult.nDoF <= 1) {
            fitResult.timeFit = false;
            ATH_MSG_DEBUG("Switch of the time fit because nDoF: "<<fitResult.nDoF);
            fitResult.segmentPars[toInt(ParamDefs::time)] = 0.;
            fitResult.calibMeasurements = m_cfg.calibrator->calibrate(ctx, std::move(fitResult.calibMeasurements), segPos, segDir,
                                                                      fitResult.segmentPars[toInt(ParamDefs::time)]);
        } else if (!fitResult.timeFit && m_cfg.doTimeFit) {
            ATH_MSG_DEBUG("Somehow a measurement is on the narrow ridge of validity. Let's try if the time can be fitted now ");
            fitResult.timeFit = true;
        }
 
        return true;
    }

setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

updateDerivatives()

void MuonR4::MdtSegmentFitter::updateDerivatives ( const ResidualWithPartials &  fitMeas, const MeasCov_t &  measCovariance, AmgVector(5)&  gradient, AmgSymMatrix(5)&  hessian, double &  chi2, int  startPar  ) const

private

Definition at line 584 of file MdtSegmentFitter.cxx.

                                                                               {
        const MeasCov_t invCov{inverse(covariance)};
        const Amg::Vector3D covRes = multiply(invCov, fitMeas.residual);
        chi2 += covRes.dot(fitMeas.residual);
        for (int p = startPar; p >=0 ; --p) {
            gradient[p] +=2.*covRes.dot(fitMeas.gradient[p]);
            for (int k=p; k>=0; --k) {
                hessian(p,k)+= 2.*contract(invCov, fitMeas.gradient[p], fitMeas.gradient[k]);
                if (m_cfg.useSecOrderDeriv) {
                    const int symMatIdx = vecIdxFromSymMat<ResidualWithPartials::nPars>(p,k);
                    hessian(p,k)+=contract(invCov, covRes, fitMeas.hessian[symMatIdx]);
                }
            }
        }
        ATH_MSG_VERBOSE("After derivative update --- chi2: "<<chi2<<"("<<covRes.dot(fitMeas.residual)<<"), gradient: "
                      <<toString(gradient)<<", Hessian:\n"<<hessian<<", measurement covariance\n"<<toString(invCov));
    }

updateDriftSigns()

void MuonR4::MdtSegmentFitter::updateDriftSigns ( const Amg::Vector3D &  segPos, const Amg::Vector3D &  segDir, SegmentFitResult &  fitRes  ) const

inlineprivate

Update the signs of the measurement.

Definition at line 55 of file MdtSegmentFitter.cxx.

                                                                                      {
        for (std::unique_ptr<CalibratedSpacePoint>& meas : fitResult.calibMeasurements) {
            meas->setDriftRadius(SegmentFitHelpers::driftSign(segPos,segDir, *meas, msg())*meas->driftRadius());
        }
    }

updateHitSummary()

bool MuonR4::MdtSegmentFitter::updateHitSummary ( SegmentFitResult &  fitResult ) const

inlineprivate

Brief updates the hit summary from the contributing hits.

Returns fals if there're too little valid hits.

Parameters

fitResult

Reference to the container containing all the measurements

Count the phi & time measurements measurements

Mdts are already counted in the measures eta category. Don't count them twice

Definition at line 89 of file MdtSegmentFitter.cxx.

                                                                                    {
         using State = CalibratedSpacePoint::State;
        fitResult.nPhiMeas = fitResult.nDoF = fitResult.nTimeMeas = 0;
        for (const HitType& hit : fitResult.calibMeasurements) {
            if (hit->fitState() != State::Valid){
                continue;
            }
 
            fitResult.nPhiMeas+= hit->measuresPhi();
            fitResult.nDoF+= hit->measuresPhi();
            fitResult.nDoF+= hit->measuresEta();
            fitResult.nPrecMeas+= (hit->type() == xAOD::UncalibMeasType::MdtDriftCircleType);
            fitResult.nDoF += (m_cfg.doTimeFit && hit->type() != xAOD::UncalibMeasType::MdtDriftCircleType && hit->measuresTime());
            fitResult.nTimeMeas+=hit->measuresTime();              
        }
        if (!fitResult.nDoF) {
            ATH_MSG_VERBOSE("Measurements rejected.");
            return false;
        }
        if (!fitResult.nPhiMeas) {
            ATH_MSG_VERBOSE("No phi measurements are left.");
            fitResult.segmentPars[toInt(ParamDefs::phi)] = 90. * Gaudi::Units::deg; 
            const double nHits = fitResult.calibMeasurements.size();
            double avgX{0.};
            std::ranges::for_each(fitResult.calibMeasurements,[&avgX, nHits](const HitType& hit) {
                return avgX += hit->positionInChamber().x() / nHits;
            });
            fitResult.segmentPars[toInt(ParamDefs::x0)] = avgX;
        }
 
        fitResult.nDoF = fitResult.nDoF - 2 - (fitResult.nPhiMeas > 0 ? 2 : 0);
 
        return true;
    }

updateLinePartials()

void MuonR4::MdtSegmentFitter::updateLinePartials ( const Parameters &  fitPars, LineWithPartials &  line  )

static

Updates the line parameters together with its first & second order partial derivatives.

Parameters

fitPars	Set of segment parameters in the current iteration
line	Reference to the line object to be updated

x_{0} cos (phi) sin (theta) segPos = y_{0} , segDir = sin (phi) sin (theta) 0 cos theta

d segDir cos (phi) cos(theta) dSegDir -sin(phi) sin (theta) -------—= sin (phi) cos(theta) -----— = cos(phi) sin (theta) dTheta - sin (theta) dPhi 0

Definition at line 125 of file MdtSegmentFitter.cxx.

                                                                      {
        
        line.pos[Amg::x] = params[toInt(ParamDefs::x0)];
        line.pos[Amg::y] = params[toInt(ParamDefs::y0)];
        line.dir = Amg::dirFromAngles(params[toInt(ParamDefs::phi)], 
                                      params[toInt(ParamDefs::theta)]);
        line.gradient[toInt(ParamDefs::x0)] = Amg::Vector3D::UnitX();
        line.gradient[toInt(ParamDefs::y0)] = Amg::Vector3D::UnitY();
        const CxxUtils::sincos theta{params[toInt(ParamDefs::theta)]},
                               phi{params[toInt(ParamDefs::phi)]};
        line.gradient[toInt(ParamDefs::theta)] = Amg::Vector3D{phi.cs*theta.cs, phi.sn*theta.cs, -theta.sn};
        line.gradient[toInt(ParamDefs::phi)]   =  Amg::Vector3D{-theta.sn *phi.sn, theta.sn*phi.cs, 0};
       /********************************************************************************* 
        *   Non-vanishing second order derivatives
        *       
        *    d^{2} segDir                 d^{2} segDir                    cos phi        
        *    ------------- = - segDir ,   ------------  = - sin(theta)    sin phi
        *    d^{2} theta                  d^{2} phi                          0
        * 
        *   d^{2} segDir                 -sin phi
        *   -------------  = cos(theta)   cos phi
        *    d theta dPhi                   0
        ************************************************************************************/
        constexpr unsigned nPars = LineWithPartials::nPars;
        constexpr int idxThetaSq = vecIdxFromSymMat<nPars>(toInt(ParamDefs::theta), toInt(ParamDefs::theta));
        constexpr int idxPhiSq = vecIdxFromSymMat<nPars>(toInt(ParamDefs::phi), toInt(ParamDefs::phi));
        constexpr int idxPhiTheta = vecIdxFromSymMat<nPars>(toInt(ParamDefs::theta), toInt(ParamDefs::phi));
        line.hessian[idxThetaSq] = - Amg::Vector3D{phi.cs*theta.sn,phi.sn*theta.sn, theta.cs};
        line.hessian[idxPhiSq] = -theta.sn * Amg::Vector3D{phi.cs, phi.sn, 0.};
        line.hessian[idxPhiTheta] = theta.cs * Amg::Vector3D{-phi.sn, phi.cs, 0.};
    }

updateParameters()

template<unsigned int nDim>

MdtSegmentFitter::UpdateStatus MuonR4::MdtSegmentFitter::updateParameters ( Parameters &  currentPars, Parameters &  previousPars, Parameters &  currGrad, Parameters &  prevGrad, const AmgSymMatrix(5)&  hessian  ) const

private

Update step of the segment parameters using the Hessian and the gradient.

If the Hessian is definite, the currentParameters are updated according to x_{n+1} = x_{n} - H_{n}^{1} * grad(x_{n}) Otherwise, the method of steepest descent is attempted.

Parameters

currentPars	Best segment estimator parameters
previousPars	Segment estimator parameters from the last iteration
currGrad	Gradient of the chi2 from this iteration
prevGrad	Gradient of the chi2 from the previous iteration
hessian	Hessian estimator

Check that all parameters remain within the parameter boundary window

Recall that for 3x3 the dimensions are [y0, theta, time]

Definition at line 622 of file MdtSegmentFitter.cxx.

                                                                                            {
            
            AmgSymMatrix(nDim) miniHessian = currentHessian.block<nDim, nDim>(0,0);
            ATH_MSG_DEBUG("Parameter update -- \ncurrenPars: "<<toString(currPars)<<", \ngradient: "<<toString(currGrad)
                          <<", hessian ("<<miniHessian.determinant()<<")"<<std::endl<<miniHessian);
 
            double changeMag{0.};
            if (std::abs(miniHessian.determinant()) > detCutOff) {
                prevPars.block<nDim,1>(0,0) = currPars.block<nDim,1>(0,0);
                // Update the parameters accrodingly to the hessian
                const AmgVector(nDim) updateMe =  miniHessian.inverse()* currGrad.block<nDim, 1>(0,0);
                changeMag = std::sqrt(updateMe.dot(updateMe));
                currPars.block<nDim,1>(0,0) -= updateMe;
                prevGrad.block<nDim,1>(0,0)  = currGrad.block<nDim,1>(0,0);
                ATH_MSG_DEBUG("Hessian inverse:\n"<<miniHessian.inverse()<<"\n\nUpdate the parameters by -"
                             <<Amg::toString(updateMe));
            } else {
                const AmgVector(nDim) gradDiff = (currGrad - prevGrad).block<nDim,1>(0,0);
                const double gradDiffMag = gradDiff.mag2();
                double denom = (gradDiffMag > std::numeric_limits<float>::epsilon() ? gradDiffMag : 1.); 
                const double gamma = std::abs((currPars - prevPars).block<nDim,1>(0,0).dot(gradDiff))
                                   / denom;
                ATH_MSG_VERBOSE("Hessian determinant invalid. Try deepest descent - \nprev parameters: "
                             <<toString(prevPars)<<",\nprevious gradient: "<<toString(prevGrad)<<", gamma: "<<gamma);
                prevPars.block<nDim, 1>(0,0) = currPars.block<nDim, 1>(0,0);
                currPars.block<nDim, 1>(0,0) -= gamma* currGrad.block<nDim, 1>(0,0);
                prevGrad.block<nDim, 1>(0,0) = currGrad.block<nDim,1>(0,0);
                changeMag = std::abs(gamma) *  currGrad.block<nDim, 1>(0,0).mag(); 
            }
            unsigned int nOutOfBound{0};
            for (unsigned int p = 0; p< nDim; ++p) {
                double& parValue{currPars[p]};
                if constexpr(nDim  == 3) {
                    if (p == 2) {
                        p = toInt(ParamDefs::time);
                    }
                }
                if (m_cfg.ranges[p][0] > parValue || m_cfg.ranges[p][1] < parValue) {
                    ATH_MSG_VERBOSE("The "<<p<<"-th parameter "<<toString(static_cast<ParamDefs>(p))<<" is out of range "<<parValue
                                    <<" allowed ["<<m_cfg.ranges[p][0]<<"-"<<m_cfg.ranges[p][1]<<"]");
                    ++nOutOfBound;
                    parValue = std::clamp(parValue, m_cfg.ranges[p][0], m_cfg.ranges[p][1]);
                }
 
            }
            if (nOutOfBound > m_cfg.nParsOutOfBounds){
                return UpdateStatus::outOfBounds;
            }
            if (changeMag <= m_cfg.tolerance) {
                return UpdateStatus::noChange;
            }
            return UpdateStatus::allOkay;
        }

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_cfg

Config MuonR4::MdtSegmentFitter::m_cfg {}

private

Definition at line 111 of file MdtSegmentFitter.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

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

• MdtSegmentFitter.h
• MdtSegmentFitter.cxx