Muon::MuonSegmentInOverlapResolvingTool Class Reference

tool to match segments More...

#include <MuonSegmentInOverlapResolvingTool.h>

Inheritance diagram for Muon::MuonSegmentInOverlapResolvingTool:

Collaboration diagram for Muon::MuonSegmentInOverlapResolvingTool:

Public Types
typedef std::vector< const Trk::MeasurementBase * >	MeasVec
typedef MeasVec::iterator	MeasIt
typedef MeasVec::const_iterator	MeasCit

Public Member Functions
	MuonSegmentInOverlapResolvingTool (const std::string &, const std::string &, const IInterface *)
	constructor
virtual	~MuonSegmentInOverlapResolvingTool ()
	destructor
StatusCode	initialize ()
	AlgTool initilize.
SegmentMatchResult	matchResult (const EventContext &ctx, const MuonSegment &seg1, const MuonSegment &seg2) const
	performance match and return result
SegmentPositionMatchResult	bestPositionAlongTubeMatch (const MuonSegment &seg1, const MuonSegment &seg2, const Amg::Vector3D &segDir1Min) const
	calculate the position along a tube direction of the first segment that results in the smallest position residual in the precision plane of the second segment given the segment direction for segment 1 in global coordinates
SegmentPhiMatchResult	bestPhiMatch (const MuonSegment &seg1, const MuonSegment &seg2) const
	calculate the angle phi for which the angular residual in the precision plane of the second segment is zero
SegmentPhiMatchResult	bestPhiMatchAnalytic (const MuonSegment &seg1, const MuonSegment &seg2) const
	calculate the angle phi for which the angular residual in the precision plane of the second segment is zero
Amg::Vector3D	updateSegmentDirection (const MuonSegment &seg, double phi) const
	recalculate the segment direction give a new angle phi, keeps the angle in the precision plane fixed
SegmentGeometrySummary	segmentGeometrySummary (const MuonSegment &seg) const
	calculate geometrical information for a segment
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	access to tool interface

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
double	checkPhiHitConsistency (const EventContext &ctx, const Muon::MuonSegment &segment, SegmentPhiMatchResult &phiMatchResult, SegmentPositionMatchResult &matchResult) const
	compare phi hits with segment parameters, return average pull of the phi hits
Amg::Vector3D	estimateSegmentDirection (const MuonSegment &seg1, const MuonSegment &seg2, double &phi, double &stereoangle) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
ServiceHandle< IMuonEDMHelperSvc >	m_edmHelperSvc
	EDM Helper tool.
PublicToolHandle< MuonEDMPrinterTool >	m_printer
	EDM printer tool.
ToolHandle< Trk::IPropagator >	m_propagator
ToolHandle< Trk::IResidualPullCalculator >	m_pullCalculator
Trk::MagneticFieldProperties	m_magFieldProperties
	magnetic field properties
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

tool to match segments

Definition at line 41 of file MuonSegmentInOverlapResolvingTool.h.

Member Typedef Documentation

MeasCit

typedef MeasVec::const_iterator Muon::IMuonSegmentInOverlapResolvingTool::MeasCit

inherited

Definition at line 34 of file IMuonSegmentInOverlapResolvingTool.h.

MeasIt

typedef MeasVec::iterator Muon::IMuonSegmentInOverlapResolvingTool::MeasIt

inherited

Definition at line 33 of file IMuonSegmentInOverlapResolvingTool.h.

MeasVec

typedef std::vector<const Trk::MeasurementBase*> Muon::IMuonSegmentInOverlapResolvingTool::MeasVec

inherited

Definition at line 32 of file IMuonSegmentInOverlapResolvingTool.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuonSegmentInOverlapResolvingTool()

Muon::MuonSegmentInOverlapResolvingTool::MuonSegmentInOverlapResolvingTool	(	const std::string &	ty,
		const std::string &	na,
		const IInterface *	pa )

constructor

Definition at line 20 of file MuonSegmentInOverlapResolvingTool.cxx.

    : AthAlgTool(ty, na, pa), m_magFieldProperties(Trk::NoField)
{
    declareInterface<IMuonSegmentInOverlapResolvingTool>(this);
}

~MuonSegmentInOverlapResolvingTool()

virtual Muon::MuonSegmentInOverlapResolvingTool::~MuonSegmentInOverlapResolvingTool ( )

inlinevirtual

destructor

Definition at line 47 of file MuonSegmentInOverlapResolvingTool.h.

{};

Member Function Documentation

bestPhiMatch()

MuonSegmentInOverlapResolvingTool::SegmentPhiMatchResult Muon::MuonSegmentInOverlapResolvingTool::bestPhiMatch ( const MuonSegment & seg1, const MuonSegment & seg2 ) const

virtual

calculate the angle phi for which the angular residual in the precision plane of the second segment is zero

Implements Muon::IMuonSegmentInOverlapResolvingTool.

Definition at line 275 of file MuonSegmentInOverlapResolvingTool.cxx.

{
 
    unsigned int nbins = 11;
    // unsigned int bestBin = 0;
    double scanRange = 1.;
    double scanStep  = scanRange / (nbins - 1);
    double phiStart  = seg1.globalDirection().phi() - 0.5 * scanRange;
 
    double              dthetaMin  = 1e9;
    Amg::Vector3D       segDir1Min = seg1.globalDirection();
    Trk::LocalDirection segLocDir2;
    seg2.associatedSurface().globalToLocalDirection(seg2.globalDirection(), segLocDir2);
    for (unsigned int i = 0; i < nbins; ++i) {
        double              phi     = phiStart + scanStep * i;
        Amg::Vector3D       segDir1 = updateSegmentDirection(seg1, phi);
        Trk::LocalDirection segLocDir12;
        seg2.associatedSurface().globalToLocalDirection(segDir1, segLocDir12);
        double dyz = std::abs(segLocDir12.angleYZ() - segLocDir2.angleYZ());
        if (dyz < dthetaMin) {
            dthetaMin  = dyz;
            segDir1Min = segDir1;
            // bestBin = i;
        }
    }
    return {segDir1Min, updateSegmentDirection(seg2, segDir1Min.phi()), dthetaMin};
}

bestPhiMatchAnalytic()

MuonSegmentInOverlapResolvingTool::SegmentPhiMatchResult Muon::MuonSegmentInOverlapResolvingTool::bestPhiMatchAnalytic	(	const MuonSegment &	seg1,
		const MuonSegment &	seg2 ) const

calculate the angle phi for which the angular residual in the precision plane of the second segment is zero

Definition at line 194 of file MuonSegmentInOverlapResolvingTool.cxx.

{
 
    //
    //    From two segments the direction and position of the segments are determined
    //                           assuming a straight line
    //
    //    if a stereoangle is present one can determine: phi and x local for both segments
    //
 
    // bool check = false;
 
    //           Confusing  use of objects:
    //  Trk::GlobalDirection can and will hold a 3D LOCAL direction
    //  Trk::GlobalPositionn can and will hold a 3D LOCAL position
    //  This is needed because otherwise the Amg::Transform3D DOES NOT know
    //             whether it transforms a position or a direction
    //
    const Amg::Transform3D& gToGlobal1 = seg1.associatedSurface().transform();
    const Amg::Transform3D& gToGlobal2 = seg2.associatedSurface().transform();
    Amg::Transform3D        gToLocal1  = seg1.associatedSurface().transform().inverse();
    // Amg::Transform3D gToLocal2 = seg2.associatedSurface().transform().inverse();
    //
    const Amg::Vector3D& gDir1 = seg1.globalDirection();
    const Amg::Vector3D& gDir2 = seg2.globalDirection();
    // Confusing but  Amg::Vector3D can hold a 3D local direction
    Amg::Vector3D lDir1 = gToLocal1.linear() * gDir1;
    // Amg::Vector3D lDir2 = gToLocal2.linear()*gDir2;
    // segment 2 local direction in frame of segment 1
    Amg::Vector3D lDir12 = gToLocal1.linear() * gDir2;
    // Amg::Vector3D lDir21 = gToLocal2.linear()*gDir1;
 
    Amg::Vector3D segLocDiro(1., 0., 0.);
    // orthogonal vector to segment 2 in local frame of segment 1
    Amg::Vector3D lDiro12 = gToLocal1.linear() * (gToGlobal2.linear() * segLocDiro);
    // orthogonal vector to segment 1in local frame of segment 2
    // Amg::Vector3D lDiro21 = gToLocal2.linear()*(gToGlobal1.linear()*segLocDiro);
 
    // stereoangle = acos(lDiro12.x());
 
    //  We have the following equations for segment 2 in local frame of segment 1
    //      dx1  = free
    //      dy1  = lDir1.y()    =   a * lDir12.y() + b * lDiro12.y()
    //      dz1  = lDir1.z()    =   a * lDir12.z() + b * lDiro12.z()
 
    double b   = lDir1.y() * lDir12.z() - lDir1.z() * lDir12.y();
    double a   = lDir1.y() * lDiro12.z() - lDir1.z() * lDiro12.y();
    double dxn = lDir12.x();
    double dyn = lDir12.y();
    double dzn = lDir12.z();
    if (std::abs(a) > 1e-2) {
        dxn = lDir12.x() - b * lDiro12.x() / a;
        dyn = lDir12.y() - b * lDiro12.y() / a;
        dzn = lDir12.z() - b * lDiro12.z() / a;
    }
    double norm = std::hypot(dxn, dyn, dzn);
    if (norm < 1e-6) {
        ATH_MSG_DEBUG(" Unexpected normalisation " << norm);
        norm = 1e-6;
    }
    if (dxn * lDir1.x() + dyn * lDir1.y() + dzn * lDir1.z() < 0) norm = -norm;
    dxn = dxn / norm;
    dyn = dyn / norm;
    dzn = dzn / norm;
 
    // The final result for the direction of the two segments
 
    // New Local direction of segment 1
    Amg::Vector3D lDirn1(dxn, dyn, dzn);
    // Global direction of both segments
    Amg::Vector3D       segDir1Min = gToGlobal1.linear() * lDirn1;
    const Amg::Vector3D&       segDir2Min = segDir1Min;  // updateSegmentDirection(seg2,segDir1Min.phi());
    Trk::LocalDirection segLocDir1;
    seg2.associatedSurface().globalToLocalDirection(segDir1Min, segLocDir1);
    Trk::LocalDirection segLocDir2;
    seg2.associatedSurface().globalToLocalDirection(segDir2Min, segLocDir2);
    double dyz = std::abs(segLocDir1.angleYZ() - segLocDir2.angleYZ());
    return {segDir1Min, segDir2Min, dyz};
}

bestPositionAlongTubeMatch()

MuonSegmentInOverlapResolvingTool::SegmentPositionMatchResult Muon::MuonSegmentInOverlapResolvingTool::bestPositionAlongTubeMatch ( const MuonSegment & seg1, const MuonSegment & seg2, const Amg::Vector3D & segDir1Min ) const

virtual

calculate the position along a tube direction of the first segment that results in the smallest position residual in the precision plane of the second segment given the segment direction for segment 1 in global coordinates

Implements Muon::IMuonSegmentInOverlapResolvingTool.

Definition at line 305 of file MuonSegmentInOverlapResolvingTool.cxx.

{
    bool goodMatch = true;
 
    // get geomtry summary for segment
    SegmentGeometrySummary segmentGeometry  = segmentGeometrySummary(seg1);
    SegmentGeometrySummary segmentGeometry2 = segmentGeometrySummary(seg2);
 
    int    nbins    = 2;
    double tubeStep = segmentGeometry.hvPosInSegFrame - segmentGeometry.roPosInSegFrame;
 
    double posStep = tubeStep / (nbins - 1);
 
    double resfirst{1e9}, reslast{1e9}, posfirst{1e9}, poslast{1e9};
    double locy     = seg1.localParameters().contains(Trk::locY) ? seg1.localParameters()[Trk::locY] : 0.;
 
    for (int j = 0; j < nbins; ++j) {
        double distToRO = segmentGeometry.roPosInSegFrame + posStep * j;
 
        // create local position
        Amg::Vector2D lpos(distToRO, locy);
 
        // segment reference surface
        const Trk::PlaneSurface& segmentSurface = seg2.associatedSurface();
 
        // get global position
        Amg::Vector3D gpos;
        seg1.associatedSurface().localToGlobal(lpos, segDir1Min, gpos);
 
        // calculate intersection
        Trk::Intersection intersect = segmentSurface.straightLineIntersection(gpos, segDir1Min, false, false);
        if (!intersect.valid || !segmentSurface.globalToLocal(intersect.position, segDir1Min, lpos)) {
            //      if( !intersect.valid || !segmentSurface.globalToLocal(intersect.intersection,segDir1Min,lpos) ){
            ATH_MSG_WARNING(" Intersect with surface  position " << Amg::toString(gpos) << " direction: phi "
                                                                 << segDir1Min.phi() << " theta "
                                                                 << segDir1Min.theta());
        } else {
 
            // now we have the prediction of the track in the segment frame, lets look at residuals
            double resy = lpos[Trk::locY] - seg2.localParameters()[Trk::locY];
 
            if (j == 0) {
                resfirst = resy;
                posfirst = distToRO;
            }
            if (j == nbins - 1) {
                reslast = resy;
                poslast = distToRO;
            }
        }
    }
 
    double distPosMin2{1e9}, distPosInTube2{1e9}, distPosMin{1e9}, distPosInTube{1e9}, resyMin{1e9};
    Amg::Vector3D segPos(0., 0., 0.);
    double        rangeCut = 1e5;
    if (resfirst < rangeCut && reslast < rangeCut && posfirst < rangeCut && poslast < rangeCut) {
        double resDif = reslast - resfirst;
        double posDif = poslast - posfirst;
        if (std::abs(resDif) < 1e-6) {
            ATH_MSG_DEBUG("  Unexpected residual difference " << resDif);
            resDif = resDif < 0. ? -1e-6 : 1e-6;
        }
        if (std::abs(posDif) < 1e-6) {
            ATH_MSG_DEBUG("  Unexpected position difference " << posDif);
            posDif = posDif < 0. ? -1e-6 : 1e-6;
        }
        distPosMin    = posfirst - resfirst / (resDif) * (posDif);
        distPosInTube = segmentGeometry.positionInsideTube(distPosMin);
        resyMin       = resfirst + (resDif) * (distPosInTube - posfirst) / (posDif);
 
        double locx = distPosInTube;
        double locy = seg1.localParameters().contains(Trk::locY) ? seg1.localParameters()[Trk::locY] : 0.;
 
        // create local position
        Amg::Vector2D lpos(locx, locy);
 
        // segment reference surface
        const Trk::PlaneSurface& segmentSurface = seg2.associatedSurface();
 
        // get global position
        Amg::Vector3D gpos;
        seg1.associatedSurface().localToGlobal(lpos, segDir1Min, gpos);
        segPos = gpos;
 
        // calculate intersection
        Trk::Intersection intersect = segmentSurface.straightLineIntersection(gpos, segDir1Min, false, false);
        if (!intersect.valid) {
            ATH_MSG_WARNING(" Intersect with surface  position " << Amg::toString(gpos) << " direction: phi "
                                                                 << segDir1Min.phi() << " theta "
                                                                 << segDir1Min.theta());
            goodMatch = false;
        } else {
            Amg::Vector3D locExSeg2 = segmentGeometry2.globalToSeg * intersect.position;
            distPosMin2             = locExSeg2.x();
            distPosInTube2          = segmentGeometry2.positionInsideTube(distPosMin2);
        }
 
    } else {
        goodMatch = false;
    }
 
    return {distPosMin, distPosInTube, segmentGeometry.shortestChannelLength, distPosMin2,
                                      distPosInTube2, segmentGeometry2.shortestChannelLength, resyMin, goodMatch,
                                      segPos};
}

checkPhiHitConsistency()

double Muon::MuonSegmentInOverlapResolvingTool::checkPhiHitConsistency ( const EventContext & ctx, const Muon::MuonSegment & segment, SegmentPhiMatchResult & phiMatchResult, SegmentPositionMatchResult & matchResult ) const

private

compare phi hits with segment parameters, return average pull of the phi hits

Definition at line 492 of file MuonSegmentInOverlapResolvingTool.cxx.

{
 
    // calculate average pull of phi measurements
    unsigned int nphiMeas    = 0;
    double       averagePull = 0.;
 
    // calculate segment AtaPlane
    // SegmentGeometrySummary geometry = segmentGeometrySummary( segment );
    double        locx = posMatchResult.positionInTube1;
    double        locy = segment.localParameters().contains(Trk::locY) ? segment.localParameters()[Trk::locY] : 0.;
    Trk::AtaPlane segPars(locx, locy, phiMatchResult.segmentDirection1.phi(), phiMatchResult.segmentDirection1.theta(),
                          0., segment.associatedSurface());
 
    // loop over hits and calculate residuals for phi hits
    for (const Trk::MeasurementBase* meas : segment.containedMeasurements()) {
 
        Identifier id = m_edmHelperSvc->getIdentifier(*meas);
        if (!id.is_valid() || !m_idHelperSvc->measuresPhi(id)) continue;
 
        // predict onto segment surface
        const Trk::Surface& measSurf = meas->associatedSurface();
 
        // propagate station parameters to segment
        std::unique_ptr<const Trk::TrackParameters> exPars {
            m_propagator->propagate(
              ctx,
              segPars,
              measSurf,
              Trk::anyDirection,
              false,
              m_magFieldProperties)};
        if (!exPars) {
            ATH_MSG_WARNING("  Failed to propagate parameter to segment surface" << std::endl
                                                                                 << " pars "
                                                                                 << m_printer->print(segPars));
            continue;
        }
 
        std::optional<Trk::ResidualPull> resPull { m_pullCalculator->residualPull(meas, exPars.get(), Trk::ResidualPull::Unbiased)};
        if (!resPull) {
            ATH_MSG_DEBUG(" calculation of residual/pull failed !!!!! ");
            continue;
        }
 
        // sanity check
        if (resPull->pull().size() != 1) {
            ATH_MSG_WARNING(" ResidualPull with empty pull vector for channel " << m_idHelperSvc->toString(id));
            continue;
        }
        const double pull = resPull->pull().front();
        averagePull += pull;
        ++nphiMeas;
 
    }
    if (nphiMeas != 0) averagePull /= nphiMeas;
    return averagePull;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

estimateSegmentDirection()

Amg::Vector3D Muon::MuonSegmentInOverlapResolvingTool::estimateSegmentDirection ( const MuonSegment & seg1, const MuonSegment & seg2, double & phi, double & stereoangle ) const

private

Definition at line 69 of file MuonSegmentInOverlapResolvingTool.cxx.

{
    //
    //    From two segments the direction and position of the segments are determined
    //                           assuming a straight line
    //
    //    if a stereoangle is present one can determine: phi and x local for both segments
    //
 
    //     bool check = false;
 
    //           Confusing  use of objects:
    //  This is needed because otherwise the Transform3D DOES NOT know
    //             whether it transforms a position or a direction
    //
    const Amg::Transform3D& gToGlobal1 = seg1.associatedSurface().transform();
    const Amg::Transform3D& gToGlobal2 = seg2.associatedSurface().transform();
    Amg::Transform3D        gToLocal1  = seg1.associatedSurface().transform().inverse();
    Amg::Transform3D        gToLocal2  = seg2.associatedSurface().transform().inverse();
    //
    const Amg::Vector3D& gDir1 = seg1.globalDirection();
    const Amg::Vector3D& gDir2 = seg2.globalDirection();
    // Confusing but  Amg::Vector3D can hold a 3D local direction
    Amg::Vector3D lDir1 = gToLocal1.linear() * gDir1;
    // Amg::Vector3D lDir2 = gToLocal2.linear()*gDir2;
    // segment 2 local direction in frame of segment 1
    Amg::Vector3D lDir12 = gToLocal1.linear() * gDir2;
    // Amg::Vector3D lDir21 = gToLocal2.linear()*gDir1;
 
    Amg::Vector3D segLocDiro(1., 0., 0.);
    // orthogonal vector to segment 2 in local frame of segment 1
    Amg::Vector3D lDiro12 = gToLocal1.linear() * (gToGlobal2.linear() * segLocDiro);
    // orthogonal vector to segment 1in local frame of segment 2
    Amg::Vector3D lDiro21 = gToLocal2.linear() * (gToGlobal1.linear() * segLocDiro);
 
    stereoangle = std::acos(lDiro12.x());
 
    //  We have the following equations for segment 2 in local frame of segment 1
    //      dx1  = free
    //      dy1  = lDir1.y()    =   a * lDir12.y() + b * lDiro12.y()
    //      dz1  = lDir1.z()    =   a * lDir12.z() + b * lDiro12.z()
 
    double b   = lDir1.y() * lDir12.z() - lDir1.z() * lDir12.y();
    double a   = lDir1.y() * lDiro12.z() - lDir1.z() * lDiro12.y();
    double dxn = lDir12.x();
    double dyn = lDir12.y();
    double dzn = lDir12.z();
    if (std::abs(a) > 1e-2) {
        dxn = lDir12.x() - b * lDiro12.x() / a;
        dyn = lDir12.y() - b * lDiro12.y() / a;
        dzn = lDir12.z() - b * lDiro12.z() / a;
    }
    double norm = std::hypot(dxn, dyn, dzn);
    if (norm < 1e-6) {
        ATH_MSG_DEBUG(" Unexpected normalisation " << norm);
        norm = 1e-6;
    }
    if (dxn * lDir1.x() + dyn * lDir1.y() + dzn * lDir1.z() < 0) norm = -norm;
    dxn = dxn / norm;
    dyn = dyn / norm;
    dzn = dzn / norm;
 
    // The final result for the direction of the two segments
 
    // New Local direction of segment 1
    Amg::Vector3D lDirn1(dxn, dyn, dzn);
    // Global direction of both segments
    Amg::Vector3D gDirn = gToGlobal1.linear() * lDirn1;
    // New Local direction of segment 2
    Amg::Vector3D lDirn2 = gToLocal2.linear() * gDirn;
    phi                  = gDirn.phi();
    double theta         = gDirn.theta();
 
    const Amg::Vector3D& gPos1 = seg1.globalPosition();
    // Confusing but  Amg::Vector3D can hold a 3D local position
    Amg::Vector3D lPos1  = gToLocal1 * gPos1;
    Amg::Vector3D lPos21 = gToLocal2 * gPos1;
    const Amg::Vector3D& gPos2  = seg2.globalPosition();
    Amg::Vector3D lPos12 = gToLocal1 * gPos2;
    Amg::Vector3D lPos2  = gToLocal2 * gPos2;
    // In local frame of segment 2 shift segment 1 to obtain zero residual
    double res21   = (lPos2.y() - lPos21.y()) * lDirn2.z() - (lPos2.z() - lPos21.z()) * lDirn2.y();
    double localx1 = 0.;
    double step    = (lDiro21.y() * lDirn2.z() - lDiro21.z() * lDirn2.y());
    if (std::abs(step) > 1e-5) {
        localx1 = res21 / step;
    }
    ATH_MSG_DEBUG(" localx1 " << localx1 << " res21 " << res21 << " step " << step);
 
    // Result: New local and global position of segment 1
    Amg::Vector3D lPosn1(lPos1.x() + localx1, lPos1.y(), lPos1.z());
    Amg::Vector3D gPosn1 = gToGlobal1 * lPosn1;
    // In local frame of segment 1 shift segment 2 to obtain zero residual
    double res12   = (lPos1.y() - lPos12.y()) * lDirn1.z() - (lPos1.z() - lPos12.z()) * lDirn1.y();
    step           = (lDiro12.y() * lDirn1.z() - lDiro12.z() * lDirn1.y());
    double localx2 = 0.;
    if (std::abs(step) > 1e-5) {
        localx2 = res12 / step;
    }
    ATH_MSG_DEBUG(" localx2 " << localx2 << " res12 " << res12 << " step " << step);
 
    // Result: New local and global position of segment 2
    Amg::Vector3D lPosn2(lPos2.x() + localx2, lPos2.y(), lPos2.z());
    Amg::Vector3D gPosn2 = gToGlobal2 * lPosn2;
    ATH_MSG_DEBUG(" segment 1 local position "
                  << lPos1 << " new " << lPosn1 << std::endl
                  << " segment 1 global position " << gPos1 << " new " << gPosn1 << std::endl
                  << " segment 2 local position " << lPos2 << " new " << lPosn2 << std::endl
                  << " segment 2 global position " << gPos2 << " new " << gPosn2);
 
    // This gives the direction from the position of the segments
    Amg::Vector3D gDirPos = gPosn2 - gPosn1;
    if (gDir1.x() * gDirPos.x() + gDir1.y() * gDirPos.y() + gDir1.z() * gDirPos.z() < 0) {
        gDirPos = -gPosn2 + gPosn1;
    }
    double dtheta = theta - gDirPos.theta();
    double dphi   = phi - gDirPos.phi();
    ATH_MSG_DEBUG(" theta " << theta << " gDirPos theta " << gDirPos.theta() << " dtheta " << dtheta << " phi " << phi
                            << " gDirPos phi " << gDirPos.phi() << " dphi " << dphi);
    return gDirn;
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

initialize()

StatusCode Muon::MuonSegmentInOverlapResolvingTool::initialize

(

)

AlgTool initilize.

Definition at line 28 of file MuonSegmentInOverlapResolvingTool.cxx.

{
    ATH_CHECK(AthAlgTool::initialize());
 
    ATH_CHECK(m_edmHelperSvc.retrieve());
    ATH_CHECK(m_printer.retrieve());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_propagator.retrieve());
    ATH_CHECK(m_pullCalculator.retrieve());
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & Muon::IMuonSegmentInOverlapResolvingTool::interfaceID ( )

inlinestaticinherited

access to tool interface

Definition at line 150 of file IMuonSegmentInOverlapResolvingTool.h.

                                                {
            static const InterfaceID IID_IMuonSegmentInOverlapResolvingTool("Muon::IMuonSegmentInOverlapResolvingTool", 1, 0);
            return IID_IMuonSegmentInOverlapResolvingTool;
        }

matchResult()

MuonSegmentInOverlapResolvingTool::SegmentMatchResult Muon::MuonSegmentInOverlapResolvingTool::matchResult ( const EventContext & ctx, const MuonSegment & seg1, const MuonSegment & seg2 ) const

virtual

performance match and return result

Implements Muon::IMuonSegmentInOverlapResolvingTool.

Definition at line 456 of file MuonSegmentInOverlapResolvingTool.cxx.

{
 
    ATH_MSG_DEBUG(" First segment  " << m_printer->print(seg1) << std::endl
                                     << " Second segment " << m_printer->print(seg2));
    SegmentMatchResult result = SegmentMatchResult();
 
    // calculate the phi angle that matches the two local segment angles
    result.phiResult = bestPhiMatchAnalytic(seg1, seg2);
 
    // calculate the position along the tube that minimizes the position residual for both segments
    result.segmentResult1 = bestPositionAlongTubeMatch(seg1, seg2, result.phiResult.segmentDirection1);
    result.segmentResult2 = bestPositionAlongTubeMatch(seg2, seg1, result.phiResult.segmentDirection2);
 
    // calculate the average pull of the phi hits on the segments with the new parameters
    result.averagePhiHitPullSegment1 = checkPhiHitConsistency(ctx, seg1, result.phiResult, result.segmentResult1);
    result.averagePhiHitPullSegment2 = checkPhiHitConsistency(ctx, seg2, result.phiResult, result.segmentResult2);
 
    if (result.segmentResult1.goodMatch && result.segmentResult2.goodMatch) {
 
        // calculate vector connecting the two new segment positions
        Amg::Vector3D difPos = result.segmentResult2.segmentPosition - result.segmentResult1.segmentPosition;
 
        // check if vectors are pointing in the same direction, else flip
        if (result.phiResult.segmentDirection1.y() * difPos.y() < 0.) {
            difPos *= -1.;
        }
 
        // calculate difference in angle between phi from phi match and the two new segment positions
        result.angularDifferencePhi = difPos.deltaPhi(result.phiResult.segmentDirection1);
    }
    return result;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

segmentGeometrySummary()

MuonSegmentInOverlapResolvingTool::SegmentGeometrySummary Muon::MuonSegmentInOverlapResolvingTool::segmentGeometrySummary ( const MuonSegment & seg ) const

virtual

calculate geometrical information for a segment

Implements Muon::IMuonSegmentInOverlapResolvingTool.

Definition at line 414 of file MuonSegmentInOverlapResolvingTool.cxx.

{
 
    SegmentGeometrySummary summary;
    // loop over hits
    Identifier                       tubeId1;
    const MuonGM::MdtReadoutElement* detEl           = nullptr;
    double                           shortestTubeLen = 1e9;
    Amg::Vector3D                    roPos;
    Amg::Vector3D                    tubeCenter;
    bool                             hasMdt  = false;
    for (const Trk::MeasurementBase* meas :seg.containedMeasurements()) {
 
        const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(meas);
        if (mdt) {
            hasMdt                    = true;
            const Identifier& id      = mdt->identify();
            int               layer   = m_idHelperSvc->mdtIdHelper().tubeLayer(id);
            int               tube    = m_idHelperSvc->mdtIdHelper().tube(id);
            double            tubelen = mdt->prepRawData()->detectorElement()->getActiveTubeLength(layer, tube);
            if (tubelen < shortestTubeLen) {
                shortestTubeLen = tubelen;
                roPos           = mdt->prepRawData()->detectorElement()->ROPos(id);
                tubeCenter      = mdt->prepRawData()->detectorElement()->surface(id).center();
                detEl           = mdt->prepRawData()->detectorElement();
                tubeId1         = id;
            }
        }
    }
    summary.detEl                 = detEl;
    summary.hasMdt                = hasMdt;
    summary.segToGlobal           = seg.associatedSurface().transform();
    summary.globalToSeg           = summary.segToGlobal.inverse();
    summary.roPosInSegFrame       = (summary.globalToSeg * roPos).x();
    double distTubeCenterFromRO   = (summary.globalToSeg * tubeCenter).x() - summary.roPosInSegFrame;
    summary.hvPosInSegFrame       = summary.roPosInSegFrame + 2 * distTubeCenterFromRO;
    summary.shortestChannelLength = std::abs(2 * distTubeCenterFromRO);
 
    return summary;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateSegmentDirection()

Amg::Vector3D Muon::MuonSegmentInOverlapResolvingTool::updateSegmentDirection ( const MuonSegment & seg, double phi ) const

virtual

recalculate the segment direction give a new angle phi, keeps the angle in the precision plane fixed

Implements Muon::IMuonSegmentInOverlapResolvingTool.

Definition at line 42 of file MuonSegmentInOverlapResolvingTool.cxx.

{
 
    Amg::Transform3D gToStation = seg.associatedSurface().transform().inverse();
    Amg::Vector3D    phiDir(1., 0., 0.);
    Amg::setThetaPhi(phiDir, seg.globalDirection().theta(), phi);
    Amg::Vector3D lphiDir = gToStation.linear() * phiDir;
    Amg::Vector3D lsegDir = gToStation.linear() * seg.globalDirection();
    double        road_dz = lphiDir.z();
    double        seg_dy  = lsegDir.y();
    double        seg_dz  = lsegDir.z();
    if (road_dz * seg_dz < 0) {
        seg_dy *= -1.;
        seg_dz *= -1.;
    }
    if (std::abs(seg_dz) < 1e-6) {
        seg_dz = 1e-6;
        ATH_MSG_DEBUG(" Unexpected local direction of segment " << lsegDir);
    }
    double scale = road_dz / seg_dz;
    seg_dy *= scale;
    Amg::Vector3D locDir(lphiDir.x(), seg_dy, road_dz);
    Amg::Vector3D gDir = seg.associatedSurface().transform().linear() * locDir;
    return gDir;
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_edmHelperSvc

ServiceHandle<IMuonEDMHelperSvc> Muon::MuonSegmentInOverlapResolvingTool::m_edmHelperSvc

private

Initial value:

{
        this,
        "edmHelper",
        "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
        "Handle to the service providing the IMuonEDMHelperSvc interface",
    }

EDM Helper tool.

Definition at line 88 of file MuonSegmentInOverlapResolvingTool.h.

                                                   {
        this,
        "edmHelper",
        "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
        "Handle to the service providing the IMuonEDMHelperSvc interface",
    };  

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonSegmentInOverlapResolvingTool::m_idHelperSvc

private

Initial value:

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

Definition at line 83 of file MuonSegmentInOverlapResolvingTool.h.

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

m_magFieldProperties

Trk::MagneticFieldProperties Muon::MuonSegmentInOverlapResolvingTool::m_magFieldProperties

private

magnetic field properties

Definition at line 111 of file MuonSegmentInOverlapResolvingTool.h.

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuonSegmentInOverlapResolvingTool::m_printer

private

Initial value:

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

EDM printer tool.

Definition at line 95 of file MuonSegmentInOverlapResolvingTool.h.

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

m_propagator

ToolHandle<Trk::IPropagator> Muon::MuonSegmentInOverlapResolvingTool::m_propagator

private

Initial value:

{
        this,
        "AtlasRungeKuttaPropagator",
        "Trk::RungeKuttaPropagator/AtlasRungeKuttaPropagator",
    }

Definition at line 100 of file MuonSegmentInOverlapResolvingTool.h.

                                           {
        this,
        "AtlasRungeKuttaPropagator",
        "Trk::RungeKuttaPropagator/AtlasRungeKuttaPropagator",
    };

m_pullCalculator

ToolHandle<Trk::IResidualPullCalculator> Muon::MuonSegmentInOverlapResolvingTool::m_pullCalculator

private

Initial value:

{
        this,
        "ResidualPullCalculator",
        "Trk::ResidualPullCalculator/ResidualPullCalculator",
    }

Definition at line 105 of file MuonSegmentInOverlapResolvingTool.h.

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

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• MuonSegmentInOverlapResolvingTool.h
• MuonSegmentInOverlapResolvingTool.cxx