MuonCalib::StraightPatRec Class Reference

#include <StraightPatRec.h>

Inheritance diagram for MuonCalib::StraightPatRec:

Collaboration diagram for MuonCalib::StraightPatRec:

Public Types
typedef std::vector< unsigned int >	HitSelection

Public Member Functions
	StraightPatRec ()
	Default constructor: road width for pattern recognition = 0.5 mm.
	StraightPatRec (const double r_road_width)
	Constructor: user-defined road width for pattern recognition.
double	roadWidth () const
	get the final track in the local co-ordinate frame, i.e.
void	setRoadWidth (const double r_road_width)
	set the road width for the pattern recognition = r_road_width
void	setTimeOut (const double time_out)
	set the time-out for the track finding to time_out (in seconds)
void	setFixSelection (bool fix_sel)
bool	fit (MuonCalibSegment &r_segment) const
	reconstruction of the track using all hits in the segment "r_segment", returns true in case of success; the algorithm overwrites the track radii, the track position, track direction, and chi^2 per degrees of freedom; warning: the errors of the track radii are only approximate reconstruction of the track using only those hits in r_segment for which the r_selection[.
bool	fit (MuonCalibSegment &r_segment, HitSelection r_selection) const
	fit subset of the hits.
bool	fit (MuonCalibSegment &r_segment, HitSelection r_selection, MTStraightLine &line_track) const
	the CurvedPatRec class relies on the first place on information cached in the MSStraightLine
void	printLevel (int)
bool	fitCallByReference (MuonCalibSegment &r_segment, HitSelection &r_selection, MTStraightLine &line_track) const
bool	fitCallByReference (MuonCalibSegment &r_segment, HitSelection &r_selection) const
void	SetRefineSegmentFlag (const bool flag)
	number of hits selected for track
bool	RefineSegmentFlag () const
	get refine segment flag
void	switchOnRefit ()
	switch on/off chi^2 refit after hit selection
void	switchOffRefit ()
bool	refit () const
	return refit flag

Protected Attributes
bool	m_refine_segment
	flags
bool	m_refit

Private Member Functions
void	init ()
void	init (const double r_road_width)
MTStraightLine	tangent (const Amg::Vector3D &r_w1, const double r_r1, const double r_sigma12, const Amg::Vector3D &r_w2, const double r_r2, const double r_sigma22, const int &r_case) const
MTStraightLine	fitCandidate (MuonCalibSegment &r_segment, const std::vector< unsigned int > &r_selection, const MTStraightLine &cand_line) const

Private Attributes
bool	m_fix_selection
double	m_r_max
double	m_road_width
double	m_time_out

Detailed Description

Definition at line 24 of file StraightPatRec.h.

Member Typedef Documentation

HitSelection

typedef std::vector<unsigned int> MuonCalib::IMdtSegmentFitter::HitSelection

inherited

Definition at line 32 of file IMdtSegmentFitter.h.

Constructor & Destructor Documentation

StraightPatRec() [1/2]

MuonCalib::StraightPatRec::StraightPatRec ( )

inline

Default constructor: road width for pattern recognition = 0.5 mm.

Definition at line 27 of file StraightPatRec.h.

StraightPatRec() [2/2]

MuonCalib::StraightPatRec::StraightPatRec ( const double r_road_width )

inline

Constructor: user-defined road width for pattern recognition.

Definition at line 30 of file StraightPatRec.h.

Member Function Documentation

fit() [1/3]

bool StraightPatRec::fit ( MuonCalibSegment & r_segment ) const

virtual

reconstruction of the track using all hits in the segment "r_segment", returns true in case of success; the algorithm overwrites the track radii, the track position, track direction, and chi^2 per degrees of freedom; warning: the errors of the track radii are only approximate reconstruction of the track using only those hits in r_segment for which the r_selection[.

] is 0, return true in case of success; the algorithm overwrites the track position, direction, and the chi^2 in r_segment; it updates the distances of all hits from the track, i.e. also of those hits which were rejected from the track reconstruction; warning : the errors of the track CLHEP::radii are only approximate

Implements MuonCalib::IMdtSegmentFitter.

Definition at line 288 of file StraightPatRec.cxx.

                                                          {
    // select all hits //
    HitSelection selection(r_segment.mdtHitsOnTrack(), 0);
 
    // call the other fit function //
    return fit(r_segment, std::move(selection));
}

fit() [2/3]

bool StraightPatRec::fit ( MuonCalibSegment & seg, HitSelection selection ) const

virtual

fit subset of the hits.

If the HitSelection vector contains a 0 for a given hit the hit is used else the hit is not included in the fit. The size of the HitSelection vector should be equal to the number of hits on track else no fit is performed.

Implements MuonCalib::IMdtSegmentFitter.

Definition at line 295 of file StraightPatRec.cxx.

{ return fitCallByReference(r_segment, r_selection); }

fit() [3/3]

bool StraightPatRec::fit	(	MuonCalibSegment &	r_segment,
		HitSelection	r_selection,
		MTStraightLine &	line_track ) const

the CurvedPatRec class relies on the first place on information cached in the MSStraightLine

Definition at line 296 of file StraightPatRec.cxx.

                                                                                                                {
    return fitCallByReference(r_segment, r_selection, line_track);
}

fitCallByReference() [1/2]

bool StraightPatRec::fitCallByReference	(	MuonCalibSegment &	r_segment,
		HitSelection &	r_selection ) const

Definition at line 299 of file StraightPatRec.cxx.

                                                                                                    {
    MTStraightLine fitted_track{};
    return fitCallByReference(r_segment, r_selection, fitted_track);
}

fitCallByReference() [2/2]

bool StraightPatRec::fitCallByReference	(	MuonCalibSegment &	r_segment,
		HitSelection &	r_selection,
		MTStraightLine &	line_track ) const

Definition at line 303 of file StraightPatRec.cxx.

                                                                                                                                  {
    // VARIABLES //
 
    time_t start, end;  // start and end time (needed for time-out)
    time(&start);
    double diff;  // difference of start and end time (needed for time-out)
    Combination combination;
 
    std::vector<unsigned int> hit_index;  // hit indices for given selection
    unsigned int try_nb_hits;             // try this given number of hits for the
                                          // segment reconstruction
 
    MuonCalibSegment::MdtHitVec selected_hits;
    std::vector<unsigned int> selected_hits_index;
 
    Amg::Vector3D w_min, w_max;     // wire with the minimum local z coordinate,
                                    // wire with the maximum local z coordinate
    double r_min, r_max{};          // corresponding drift CLHEP::radii
    double sigma2_min, sigma2_max;  // corresponding spatial resolution
 
    unsigned int counter1;  // auxiliary counter
 
    unsigned int nb_candidates(0);  // number of straight-track candidates
 
    MTStraightLine tangents[4];  // the four tangents to the drift circles of a
                                 // hit pair
    MTStraightLine aux_track;    // auxiliary track
    Amg::Vector3D null(0.0, 0.0, 0.0);
    Amg::Vector3D xhat(1.0, 0.0, 0.0);
 
    MTStraightLine initial_track(r_segment.position(), r_segment.direction(), null, null);
    // initial track stored in the segment
    Amg::Vector3D aux_pos, aux_dir;  // auxiliary position and direction vectors

    // RESET //
 
    if (r_segment.mdtHitsOnTrack() != r_selection.size()) {
        MsgStream log(Athena::getMessageSvc(), "StraightPatRec");
        log << MSG::WARNING
            << "fitCallByReference() - Vector with selected hits unequal to the number of hits on the segment! The user selection will "
               "be "
               "ignored!"
            << endmsg;
        r_selection.clear();
        r_selection.assign(r_segment.hitsOnTrack(), 0);
    }
 
    // Filling selected_hits vector
    for (unsigned int k = 0; k < r_segment.mdtHitsOnTrack(); k++) {
        if (!r_selection[k]) {
            selected_hits.push_back(r_segment.mdtHOT()[k]);
            selected_hits_index.push_back(k);
        }
    }

    // RETURN, IF THERE ARE LESS THAN 3 HITS, I.E. THE TRACK IS NOT UNIQUELY //
    // DEFINED BY THE HITS.                                                  //
 
    if (selected_hits.size() < 3) { return false; }

    // FIX POTENTIAL SECOND-COORDINATE PROBLEM OF THE INITIAL TRACK SEGMENT //
 
    if (r_segment.direction().z() == 0.0) {
        Amg::Vector3D dir(r_segment.direction().x(), r_segment.direction().y(), 1.0);
        initial_track = MTStraightLine(r_segment.position(), dir, null, null);
    }

    // TRACK RECONSTRUCTION //
    // try to find a segment with as many hits as selected initially //
 
    HitSelection final_selection(r_selection);
 
    try_nb_hits = selected_hits.size();
    //=============================================================================
    while (nb_candidates == 0) {
        //-----------------------------------------------------------------------------
        // Return in case of large amount of fake hits
        if (try_nb_hits < 5 && (selected_hits.size() - try_nb_hits) > 2) return false;
        // reset //
        double best_chi2ndf = -1.0;
        MTStraightLine best_aux_line(initial_track);
 
        // loop over all combinations //
        combination.setNewParameters(selected_hits.size(), try_nb_hits);
 
        //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
        for (unsigned int cb = 0; cb < combination.numberOfCombinations(); cb++) {
            //.............................................................................
 
            // time-out //
            time(&end);
            diff = difftime(end, start);
            if (diff > m_time_out) { return false; }
 
            // get the present hit combination //
            if (cb == 0) {
                combination.currentCombination(hit_index);
            } else {
                combination.nextCombination(hit_index);
            }
 
            // Current selection of hits
            HitSelection tmp_selection(r_selection);
            tmp_selection.assign(tmp_selection.size(), 1);
            for (unsigned int k = 0; k < try_nb_hits; k++) { tmp_selection[selected_hits_index[hit_index[k] - 1]] = 0; }
 
            // investigate the current combination //
            // find the wires with minimum and maximum local z //
            w_min = selected_hits[hit_index[0] - 1]->localPosition();
            w_max = selected_hits[hit_index[0] - 1]->localPosition();
            r_min = selected_hits[hit_index[0] - 1]->driftRadius();
            r_max = selected_hits[hit_index[0] - 1]->driftRadius();
            sigma2_min = selected_hits[hit_index[0] - 1]->sigma2DriftRadius();
            sigma2_max = selected_hits[hit_index[0] - 1]->sigma2DriftRadius();
            for (unsigned int k = 1; k < try_nb_hits; k++) {
                if (selected_hits[hit_index[k] - 1]->localPosition().z() < w_min.z()) {
                    w_min = selected_hits[hit_index[k] - 1]->localPosition();
                    r_min = selected_hits[hit_index[k] - 1]->driftRadius();
                    sigma2_min = selected_hits[hit_index[k] - 1]->sigma2DriftRadius();
                }
                if (selected_hits[hit_index[k] - 1]->localPosition().z() > w_max.z()) {
                    w_max = selected_hits[hit_index[k] - 1]->localPosition();
                    r_max = selected_hits[hit_index[k] - 1]->driftRadius();
                    sigma2_max = selected_hits[hit_index[k] - 1]->sigma2DriftRadius();
                }
            }
 
            // set the spatial resolution to 0.1 CLHEP::mm if it is 0 //
            if (sigma2_min == 0) { sigma2_min = 0.1; }
            if (sigma2_max == 0) { sigma2_max = 0.1; }
 
            // get the four segment candidates tangential to the outermost hits //
            for (unsigned int r_case = 1; r_case < 5; r_case++) {
                tangents[r_case - 1] = tangent(w_min, r_min, sigma2_min, w_max, r_max, sigma2_max, r_case);
            }
 
            // determine additional track points within the road width around //
            // the four tangents and determine a segment                      //
            for (unsigned int r_case = 1; r_case < 5; r_case++) {
                counter1 = 0;
                for (unsigned int n = 0; n < try_nb_hits; n++) {
                    MTStraightLine aux_line(selected_hits[hit_index[n] - 1]->localPosition(), xhat, null, null);
                    if (std::abs(std::abs(tangents[r_case - 1].signDistFrom(aux_line)) - selected_hits[hit_index[n] - 1]->driftRadius()) <=
                        m_road_width) {
                        counter1 = counter1 + 1;
                    }
                }
 
                // Used to fix initial configuration of hits
                if (m_fix_selection) counter1 = try_nb_hits;
                // perform a straight line fit for the candidate //
                if (counter1 == try_nb_hits) {
                    nb_candidates++;
                    aux_track = fitCandidate(r_segment, tmp_selection, tangents[r_case - 1]);
 
                    if ((best_chi2ndf == -1) || (best_chi2ndf > r_segment.chi2())) {
                        best_chi2ndf = r_segment.chi2();
                        best_aux_line = aux_track;
                        final_selection.assign(final_selection.size(), 1);
                        for (unsigned int j = 0; j < try_nb_hits; j++) { final_selection[selected_hits_index[hit_index[j] - 1]] = 0; }
                    }
                }
            }
            //.............................................................................
        }
        //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

        // MAKE THE FINAL STRAIGHT SEGMENT, IF POSSIBLE //
 
        MuonCalibSegment::MdtHitVec used_hits;
        if (nb_candidates > 0) {
            // store track hits, rewrite hit selection //
            for (unsigned int k = 0; k < r_selection.size(); k++) {
                r_selection[k] = final_selection[k];
                if (!final_selection[k]) { used_hits.push_back(r_segment.mdtHOT()[k]); }
            }
 
            // Final refit //
            fitted_track = fitCandidate(r_segment, final_selection, best_aux_line);
            fitted_track.setUsedHits(used_hits);
 
            if (m_refine_segment) { r_segment.refineMdtSelection(r_selection); }
 
        } else {
            try_nb_hits = try_nb_hits - 1;
            if (try_nb_hits < 3) { return false; }
        }
 
        //-----------------------------------------------------------------------------
    }
    //=============================================================================
 
    return fitted_track.chi2() > 0;
}

fitCandidate()

MTStraightLine StraightPatRec::fitCandidate ( MuonCalibSegment & r_segment, const std::vector< unsigned int > & r_selection, const MTStraightLine & cand_line ) const

private

Definition at line 153 of file StraightPatRec.cxx.

                                                                                   {
    // VARIABLES //
    Amg::Vector3D null(0.0, 0.0, 0.0);
    Amg::Vector3D xhat(1.0, 0.0, 0.0);
 
    unsigned int num_selected_hits(0);
    for (unsigned int k : r_selection) {
        if (!k) { num_selected_hits++; }
    }
    if (num_selected_hits < 3) return cand_line;
 
    Amg::Vector3D init_dir(r_segment.direction());
    Amg::Vector3D init_pos(r_segment.position());
    // SET THE CORRECT SIGNED TRACK DISTANCES //
 
    r_segment.set(r_segment.chi2(), cand_line.positionVector(), cand_line.directionVector());
 
    for (unsigned int k = 0; k < r_segment.mdtHitsOnTrack(); k++) {
        MTStraightLine aux_line(r_segment.mdtHOT()[k]->localPosition(), xhat, null, null);
        r_segment.mdtHOT()[k]->setDistanceToTrack(cand_line.signDistFrom(aux_line), r_segment.mdtHOT()[k]->sigmaDriftRadius());
    }

    // Analitical fit of linearized measurements (transformation to reference frame is used) //
    unsigned int NLC = 2;  // number of fit parameters
 
    // Normalization on z-direction
    Amg::Vector3D dir_norm(r_segment.direction().x() / r_segment.direction().z(), r_segment.direction().y() / r_segment.direction().z(),
                           1.0);
 
    Amg::Vector3D refTransl(r_segment.position());
    refTransl[0] = 0;
    Amg::Vector3D refDir(dir_norm);
    refDir[0] = 0;
    refDir = refDir.unit();
 
    // Rotation Matrix for Toewr_to_track transformation
 
    double rotAngle = Amg::angle(Amg::Vector3D::UnitZ(), refDir) * (refDir.y()) / std::abs(refDir.y());
    Amg::AngleAxis3D RotMatr(rotAngle, Amg::Vector3D::UnitX());       // Matrix for Track reference transformation
    Amg::AngleAxis3D RotMatr_inv(-rotAngle, Amg::Vector3D::UnitX());  // inverse
 
    Amg::VectorX alpha = Amg::VectorX(NLC);
    alpha.setZero();
    Amg::VectorX betha = Amg::VectorX(NLC);
    betha.setZero();
    Amg::MatrixX Gamma = Amg::MatrixX(NLC, NLC);
    Gamma.setZero();
    // vector to store hit positions
    std::vector<Amg::Vector3D> hit_position_track;
 
    for (unsigned int l = 0; l < r_segment.mdtHitsOnTrack(); l++) {
        // Transformation to track reference frame
        Amg::Vector3D WirPosLocal = r_segment.mdtHOT()[l]->localPosition();
        Amg::Vector3D WirPosTrack = WirPosLocal - refTransl;
        WirPosTrack = RotMatr * WirPosTrack;
        double signedDrifRadius =
            std::abs(r_segment.mdtHOT()[l]->driftRadius()) *
            (r_segment.mdtHOT()[l]->signedDistanceToTrack() / std::abs(r_segment.mdtHOT()[l]->signedDistanceToTrack()));
        Amg::Vector3D HitPosTrack = WirPosTrack;
        HitPosTrack[0] = HitPosTrack.y() + signedDrifRadius;
        HitPosTrack[1] = r_segment.mdtHOT()[l]->sigma2DriftRadius();  // trick to store hit resolution
 
        hit_position_track.push_back(HitPosTrack);
 
        Amg::VectorX delta = Amg::VectorX(NLC);
        delta.setZero();
        delta[0] = 1.0;
        delta[1] = HitPosTrack.z();
 
        if (!r_selection[l]) {
            double weight = 1.0 / (r_segment.mdtHOT()[l]->sigma2DriftRadius());
            Gamma += weight * delta * delta.transpose();
            betha += weight * HitPosTrack.y() * delta;
        }
    }
 
    // solution of linear system of equations
    Gamma = Gamma.inverse();
    alpha = Gamma * betha;
 
    double refit_chi2(0.0);
    for (unsigned int j = 0; j < hit_position_track.size(); j++) {
        double res = (alpha[0] + alpha[1] * hit_position_track[j].z() - hit_position_track[j].y());
        if (!r_selection[j]) refit_chi2 += res * res / hit_position_track[j].x();
    }
 
    // Backward transformation
    Amg::Vector3D seg_dir(0.0, alpha[1], 1.0);
    seg_dir = RotMatr_inv * seg_dir;
    seg_dir[1] = seg_dir.y() / seg_dir.z();
    seg_dir[0] = init_dir.x() / init_dir.z();
    seg_dir[2] = 1.0;
 
    Amg::Vector3D seg_pos(0.0, alpha[0], 0.0);
    seg_pos = RotMatr_inv * seg_pos;
    seg_pos = seg_pos + refTransl;
 
    seg_pos[1] = seg_pos.y() + seg_dir.y() * (init_pos.z() - seg_pos.z());
    seg_pos[0] = init_pos.x();
    seg_pos[2] = init_pos.z();
 
    // Rewriting segment
    r_segment.set(refit_chi2 / (num_selected_hits - 2), seg_pos, seg_dir);
 
    MTStraightLine aux_line(seg_pos, seg_dir, Amg::Vector3D(0.0, 0.0, 0.0), Amg::Vector3D(0.0, 0.0, 0.0));
 
    for (unsigned int k = 0; k < r_segment.mdtHitsOnTrack(); k++) {
        MTStraightLine aux_t(r_segment.mdtHOT()[k]->localPosition(), xhat, null, null);
        r_segment.mdtHOT()[k]->setDistanceToTrack(aux_line.signDistFrom(aux_t), r_segment.mdtHOT()[k]->sigmaDriftRadius());
    }
 
    aux_line.setNumberOfTrackHits(num_selected_hits);
    aux_line.setChi2(refit_chi2);
    return aux_line;
}

init() [1/2]

void StraightPatRec::init ( )

private

Definition at line 23 of file StraightPatRec.cxx.

                          {
    init(0.5 * CLHEP::mm);  // default road width = 0.5 CLHEP::mm
    return;
}

init() [2/2]

void StraightPatRec::init ( const double r_road_width )

private

Definition at line 28 of file StraightPatRec.cxx.

                                                   {
    //:::::::::::::::
    //:: VARIABLES ::
    //:::::::::::::::
 
    Amg::Vector3D null_vec(0.0, 0.0, 0.0);  // auxiliary 0 vector
 
    //::::::::::::::::::
    //:: SET TIME-OUT ::
    //::::::::::::::::::
 
    m_time_out = 10.0;
 
    //::::::::::::::::::::::::::::
    //:: SET THE MAXIMUM RADIUS ::
    //::::::::::::::::::::::::::::
 
    m_r_max = 15.0;
 
    //::::::::::::::::::::::::
    //:: SET THE ROAD WIDTH ::
    //::::::::::::::::::::::::
 
    m_road_width = r_road_width;
 
    //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    //:: INITIALIZE PRIVATE VARIABLES WHICH ARE ACCESSIBLE BY METHODS ::
    //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
    // m_nb_track_hits = 0;
    // m_chi2 = 0.0;
    // m_track = MTStraightLine(null_vec, null_vec, null_vec, null_vec);
 
    m_fix_selection = false;
 
    return;
}

printLevel()

void MuonCalib::StraightPatRec::printLevel ( int )

inlinevirtual

Implements MuonCalib::IMdtSegmentFitter.

Definition at line 83 of file StraightPatRec.h.

{}

RefineSegmentFlag()

bool MuonCalib::IMdtPatRecFitter::RefineSegmentFlag ( ) const

inlineinherited

get refine segment flag

Definition at line 37 of file IMdtPatRecFitter.h.

{ return m_refine_segment; }

refit()

bool MuonCalib::IMdtPatRecFitter::refit ( ) const

inlineinherited

return refit flag

Definition at line 43 of file IMdtPatRecFitter.h.

{ return m_refit; }

roadWidth()

double StraightPatRec::roadWidth

(

)

const

get the final track in the local co-ordinate frame, i.e.

z ^ o o o o o o | ... o o o o o ... o--> y o o o o o o x

Definition at line 276 of file StraightPatRec.cxx.

{ return m_road_width; }

setFixSelection()

void StraightPatRec::setFixSelection

(

bool

fix_sel

)

Definition at line 287 of file StraightPatRec.cxx.

{ m_fix_selection = fix_sel; }

SetRefineSegmentFlag()

void MuonCalib::IMdtPatRecFitter::SetRefineSegmentFlag ( const bool flag )

inlineinherited

number of hits selected for track

virtual unsigned int numberOfTrackHits() const = 0; get selected track hits virtual const std::vector<const MdtCalibHitBase *> &trackHits() const = 0; set refine segment flag

Parameters

flag	if true the hit selection is changed in the segment

Definition at line 34 of file IMdtPatRecFitter.h.

{ m_refine_segment = flag; }

setRoadWidth()

void StraightPatRec::setRoadWidth ( const double r_road_width )

virtual

set the road width for the pattern recognition = r_road_width

Implements MuonCalib::IMdtPatRecFitter.

Definition at line 278 of file StraightPatRec.cxx.

                                                           {
    m_road_width = std::abs(r_road_width);
    return;
}

setTimeOut()

void StraightPatRec::setTimeOut

(

const double

time_out

)

set the time-out for the track finding to time_out (in seconds)

Definition at line 282 of file StraightPatRec.cxx.

                                                     {
    m_time_out = time_out;
    return;
}

switchOffRefit()

void MuonCalib::IMdtPatRecFitter::switchOffRefit ( )

inlineinherited

Definition at line 41 of file IMdtPatRecFitter.h.

{ m_refit = false; }

switchOnRefit()

void MuonCalib::IMdtPatRecFitter::switchOnRefit ( )

inlineinherited

switch on/off chi^2 refit after hit selection

Definition at line 40 of file IMdtPatRecFitter.h.

{ m_refit = true; }

tangent()

MTStraightLine StraightPatRec::tangent ( const Amg::Vector3D & r_w1, const double r_r1, const double r_sigma12, const Amg::Vector3D & r_w2, const double r_r2, const double r_sigma22, const int & r_case ) const

private

Definition at line 66 of file StraightPatRec.cxx.

                                                                                                           {
    //:::::::::::::::
    //:: VARIABLES ::
    //:::::::::::::::
 
    double sinalpha;                                     // auxiliary sinus of an angle
    double cosalpha;                                     // auxiliary sinus of an angle
    Amg::Vector3D e2prime, e3prime;                      // auxiliary direction vectors
    MTStraightLine tang;                                 // tangent to drift circles of a hit pair
    Amg::Vector3D p1(0.0, 0.0, 0.0), p2(0.0, 0.0, 0.0);  // hit points defining a tangent
    Amg::Vector3D null_vec(0.0, 0.0, 0.0);               // auxiliary 0 vector
    double mx1 = 0, bx1 = 0, mx2 = 0, bx2 = 0;           // auxiliary track parameters
 
    //::::::::::::::::::::::::::::::::::::::::::::
    //:: CHECK WHETHER THE SELECTED CASE EXISTS ::
    //::::::::::::::::::::::::::::::::::::::::::::
 
    if (r_case < 1 || r_case > 4) {
        throw std::runtime_error(
            Form("File: %s, Line: %d\nStraightPatRec::tangent - Illegal case %i, must be 1,2,3, or 4.!", __FILE__, __LINE__, r_case));
    }
 
    //:::::::::::::::::::::::::::::::::::::
    //:: CALCULATE THE REQUESTED TANGENT ::
    //:::::::::::::::::::::::::::::::::::::
 
    // local coordinate axis vectors //
    e3prime = (r_w2 - r_w1).unit();
    e2prime = Amg::Vector3D(0.0, e3prime.z(), -e3prime.y());
 
    // case 1 and 2 //
    if (r_case == 1 || r_case == 2) {
        sinalpha = std::abs(r_r2 - r_r1) / (r_w2 - r_w1).mag();
        cosalpha = std::sqrt(1.0 - sinalpha * sinalpha);
 
        // case 1 //
        if (r_case == 1) {
            p1 = r_w1 + ((1 && r_r2 >= r_r1) - (1 && r_r2 < r_r1)) * r_r1 * (cosalpha * e2prime - sinalpha * e3prime);
            p2 = r_w2 + ((1 && r_r2 >= r_r1) - (1 && r_r2 < r_r1)) * r_r2 * (cosalpha * e2prime - sinalpha * e3prime);
        }
 
        // case 2 //
        if (r_case == 2) {
            p1 = r_w1 - ((1 && r_r2 >= r_r1) - (1 && r_r2 < r_r1)) * r_r1 * (cosalpha * e2prime + sinalpha * e3prime);
            p2 = r_w2 - ((1 && r_r2 >= r_r1) - (1 && r_r2 < r_r1)) * r_r2 * (cosalpha * e2prime + sinalpha * e3prime);
        }
    }
 
    // case 3 and 4 //
    if (r_case == 3 || r_case == 4) {
        sinalpha = (r_r1 + r_r2) / (r_w2 - r_w1).mag();
        cosalpha = std::sqrt(1.0 - sinalpha * sinalpha);
 
        // case 3 //
        if (r_case == 3) {
            p1 = r_w1 + r_r1 * (cosalpha * e2prime + sinalpha * e3prime);
            p2 = r_w2 - r_r2 * (cosalpha * e2prime + sinalpha * e3prime);
        }
 
        // case 4 //
        if (r_case == 4) {
            p1 = r_w1 - r_r1 * (cosalpha * e2prime - sinalpha * e3prime);
            p2 = r_w2 + r_r2 * (cosalpha * e2prime - sinalpha * e3prime);
        }
    }
 
    // calculation of the tangent and estimation of its errors //
    if ((p2 - p1).z() != 0.0) {
        tang = MTStraightLine(p1, p2 - p1, null_vec, null_vec);
    } else {
        Amg::Vector3D direction(p2 - p1);
        direction[2] = (1.0e-99);
        tang = MTStraightLine(p1, direction, null_vec, null_vec);
    }
    mx1 = tang.a_x1();
    bx2 = tang.b_x1();
    mx2 = tang.a_x2();
    bx2 = tang.b_x2();
    tang = MTStraightLine(mx1, bx1, mx2, bx2, 1.0, 1.0, std::sqrt(r_sigma12 + r_sigma22) / std::abs(p2.z() - p1.z()),
                          std::sqrt(r_sigma12 + p1.z() * p1.z() * (r_sigma12 + r_sigma22) / std::pow(p2.z() - p1.z(), 2)));
    // errors in mx1 and bx1 are arbitrary since they are
    // not used at a later stage.
 
    return tang;
}

Member Data Documentation

m_fix_selection

bool MuonCalib::StraightPatRec::m_fix_selection

private

Definition at line 97 of file StraightPatRec.h.

m_r_max

double MuonCalib::StraightPatRec::m_r_max

private

Definition at line 100 of file StraightPatRec.h.

m_refine_segment

bool MuonCalib::IMdtPatRecFitter::m_refine_segment

protectedinherited

flags

Definition at line 49 of file IMdtPatRecFitter.h.

m_refit

bool MuonCalib::IMdtPatRecFitter::m_refit

protectedinherited

Definition at line 50 of file IMdtPatRecFitter.h.

m_road_width

double MuonCalib::StraightPatRec::m_road_width

private

Definition at line 101 of file StraightPatRec.h.

m_time_out

double MuonCalib::StraightPatRec::m_time_out

private

Definition at line 102 of file StraightPatRec.h.

---

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

• StraightPatRec.h
• StraightPatRec.cxx