Muon::RPC_ResidualPullCalculator Class Reference

RPC-specific tool to calculate hit residual and pull from a RIO_OnTrack/TrackParameter pair. More...

#include <RPC_ResidualPullCalculator.h>

Inheritance diagram for Muon::RPC_ResidualPullCalculator:

Collaboration diagram for Muon::RPC_ResidualPullCalculator:

Public Member Functions
virtual	~RPC_ResidualPullCalculator ()=default
virtual StatusCode	initialize () override
virtual std::optional< Trk::ResidualPull >	residualPull (const Trk::MeasurementBase *measurement, const Trk::TrackParameters *trkPar, const Trk::ResidualPull::ResidualType, const Trk::TrackState::MeasurementType) const override
	This function returns (creates!) a Trk::ResidualPull object, which contains the values of residual and pull for the given measurement and track state.
virtual std::array< double, 5 >	residuals (const Trk::MeasurementBase *measurement, const Trk::TrackParameters *trkPar, const Trk::ResidualPull::ResidualType, const Trk::TrackState::MeasurementType) const override
	This function is a light-weight version of the function above, designed for track fitters where speed is critical.

Static Private Member Functions
static double	calcPull (const double residual, const double locMesCov, const double locTrkCov, const Trk::ResidualPull::ResidualType &)
	internal structuring: common method to calculate the hit pull.

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Detailed Description

RPC-specific tool to calculate hit residual and pull from a RIO_OnTrack/TrackParameter pair.

Uses Muon-specific info to code the strip type (measuring phi/eta) in the 2nd coordinate of the residual.

Author

Wolfgang Liebig http://consult.cern.ch/xwho/people/54608

Definition at line 27 of file RPC_ResidualPullCalculator.h.

Constructor & Destructor Documentation

~RPC_ResidualPullCalculator()

virtual Muon::RPC_ResidualPullCalculator::~RPC_ResidualPullCalculator ( )

virtualdefault

Member Function Documentation

calcPull()

double Muon::RPC_ResidualPullCalculator::calcPull ( const double residual, const double locMesCov, const double locTrkCov, const Trk::ResidualPull::ResidualType & resType )

staticprivate

internal structuring: common method to calculate the hit pull.

calc pull in 1 dimension

Definition at line 113 of file RPC_ResidualPullCalculator.cxx.

                                                 {
 
    double ErrorSum(0.0);
    if (resType == Trk::ResidualPull::Unbiased) {
      if( locMesCov + locTrkCov > 0 ) ErrorSum = std::sqrt(locMesCov + locTrkCov);
    } else if (resType == Trk::ResidualPull::Biased) {
      if ((locMesCov - locTrkCov) < 0.) {
            return 0;
        }
        ErrorSum = std::sqrt(locMesCov - locTrkCov);
    } else ErrorSum = std::sqrt(locMesCov);
    if (ErrorSum != 0) return residual/ErrorSum;
    return 0;
}

initialize()

StatusCode Muon::RPC_ResidualPullCalculator::initialize ( )

overridevirtual

Definition at line 12 of file RPC_ResidualPullCalculator.cxx.

{
  ATH_CHECK(m_idHelperSvc.retrieve());
  ATH_MSG_DEBUG ("initialize() successful in " << name());
  return StatusCode::SUCCESS;
}

residualPull()

std::optional< Trk::ResidualPull > Muon::RPC_ResidualPullCalculator::residualPull ( const Trk::MeasurementBase * measurement, const Trk::TrackParameters * trkPar, const Trk::ResidualPull::ResidualType resType, const Trk::TrackState::MeasurementType  ) const

overridevirtual

This function returns (creates!) a Trk::ResidualPull object, which contains the values of residual and pull for the given measurement and track state.

The track state can be an unbiased one (which can be retrieved by the Trk::IUpdator), a biased one (which contains the measurement), or a truth state. The enum ResidualType must be set according to this, otherwise the pulls will be wrong. Residuals differ in all three cases; please be aware of this!

Definition at line 52 of file RPC_ResidualPullCalculator.cxx.

                                              {
 
  if (!trkPar || !measurement) {
    return std::nullopt;
  }
  Identifier ID = Trk::IdentifierExtractor::extract(measurement);
 
  if (!m_idHelperSvc->isRpc(ID)) {
    ATH_MSG_DEBUG ("Input problem measurement is not RPC but "
                  <<m_idHelperSvc->toString(ID));
    return std::nullopt; 
  }
 
  
  // if no covariance for the track parameters is given the pull calculation is not valid
  const AmgSymMatrix(5)* trkCov = trkPar->covariance();
 
  // calculate residual
  const auto & localParameters = measurement->localParameters();
  const std::size_t nParams = localParameters.dimension();
  std::vector<double> residual(nParams), pull(nParams);
    
  switch (nParams) {
    case 1: {
      residual[Trk::loc1] = localParameters[Trk::loc1]
                          - trkPar->parameters()[Trk::loc1];
      break;
    } case 2: {
      residual[Trk::loc1] = localParameters[Trk::loc1]
                          - trkPar->parameters()[Trk::loc1];
      residual[Trk::loc2] = localParameters[Trk::loc2]
                          - trkPar->parameters()[Trk::loc2];
      break;
    } default:
      ATH_MSG_WARNING ( "RPC ClusterOnTrack does not carry the expected "
                      << "LocalParameters structure!" );
      return std::nullopt;
    }
    
    // calculate pull
    for (std::size_t l = 0 ; l < residual.size(); ++l) {
        pull[l] = calcPull(residual[l], measurement->localCovariance()(l,l),
                            trkCov ? (*trkCov)(l,l) : 0., resType);
    }
 
    // create the Trk::ResidualPull.
    ATH_MSG_DEBUG ( "Calculating Pull for channel " << m_idHelperSvc->toString(ID) << " residual " << residual[Trk::loc1] << " pull " << pull[Trk::loc1] );
    return std::make_optional<Trk::ResidualPull>(std::move(residual), 
                                                 std::move(pull), 
                                                 trkCov != nullptr, 
                                                 resType, 1);
}

residuals()

std::array< double, 5 > Muon::RPC_ResidualPullCalculator::residuals ( const Trk::MeasurementBase * measurement, const Trk::TrackParameters * trkPar, const Trk::ResidualPull::ResidualType , const Trk::TrackState::MeasurementType  ) const

overridevirtual

This function is a light-weight version of the function above, designed for track fitters where speed is critical.

Definition at line 21 of file RPC_ResidualPullCalculator.cxx.

                                              {
  std::array<double, 5> residuals{};
  if (!trkPar || !measurement) return residuals;
  Identifier ID = Trk::IdentifierExtractor::extract(measurement);
 
  if( m_idHelperSvc->isRpc(ID) ) {
 
    if (measurement->localParameters().parameterKey() == 1) {
      // convention to be interpreted by TrkValTools: 2nd coordinate codes orientation of RPC
        residuals[Trk::loc1] = measurement->localParameters()[Trk::loc1]
          - trkPar->parameters()[Trk::loc1];
    } else {
      residuals[Trk::loc1] = measurement->localParameters()[Trk::loc1]
          - trkPar->parameters()[Trk::loc1];
      residuals[Trk::loc2] = measurement->localParameters()[Trk::loc2]
          - trkPar->parameters()[Trk::loc2];
    }
 
  } else {
    ATH_MSG_WARNING( "Input problem measurement is not RPC. "
                    <<m_idHelperSvc->toString(ID) );
    return residuals;
  }
  return residuals;
}

Member Data Documentation

m_idHelperSvc

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

private

Definition at line 62 of file RPC_ResidualPullCalculator.h.

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

---

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

• RPC_ResidualPullCalculator.h
• RPC_ResidualPullCalculator.cxx