#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. More...

	StraightPatRec (const double &r_road_width)
	Constructor: user-defined road width for pattern recognition. More...

double	roadWidth () const
	get the final track in the local co-ordinate frame, i.e. More...

void	setRoadWidth (const double &r_road_width)
	set the road width for the pattern recognition = r_road_width More...

void	setTimeOut (const double &time_out)
	set the time-out for the track finding to time_out (in seconds) More...

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[. More...

bool	fit (MuonCalibSegment &r_segment, HitSelection r_selection) const
	fit subset of the hits. More...

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 More...

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 More...

bool	RefineSegmentFlag () const
	get refine segment flag More...

void	switchOnRefit ()
	switch on/off chi^2 refit after hit selection More...

void	switchOffRefit ()

bool	refit () const
	return refit flag More...

Protected Attributes
bool	m_refine_segment
	flags More...

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 289 of file StraightPatRec.cxx.

                                                           {
     // select all hits //
     HitSelection selection(r_segment.mdtHitsOnTrack(), 0);
  
     // call the other fit function //
     return fit(r_segment, 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 296 of file StraightPatRec.cxx.

296 { 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 297 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 300 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 304 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 154 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 24 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 29 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.

83 {}

◆ RefineSegmentFlag()

bool MuonCalib::IMdtPatRecFitter::RefineSegmentFlag ( ) const

inlineinherited

get refine segment flag

Definition at line 38 of file IMdtPatRecFitter.h.

38 { return m_refine_segment; }

◆ refit()

bool MuonCalib::IMdtPatRecFitter::refit ( ) const

inlineinherited

return refit flag

Definition at line 44 of file IMdtPatRecFitter.h.

44 { 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 277 of file StraightPatRec.cxx.

277 { return m_road_width; }

◆ setFixSelection()

void StraightPatRec::setFixSelection ( bool fix_sel )

Definition at line 288 of file StraightPatRec.cxx.

288 { 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 35 of file IMdtPatRecFitter.h.

35 { 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 279 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 283 of file StraightPatRec.cxx.

                                                       {
     m_time_out = time_out;
     return;
 }

◆ switchOffRefit()

void MuonCalib::IMdtPatRecFitter::switchOffRefit ( )

inlineinherited

Definition at line 42 of file IMdtPatRecFitter.h.

42 { m_refit = false; }

◆ switchOnRefit()

void MuonCalib::IMdtPatRecFitter::switchOnRefit ( )

inlineinherited

switch on/off chi^2 refit after hit selection

Definition at line 41 of file IMdtPatRecFitter.h.

41 { 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 67 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 50 of file IMdtPatRecFitter.h.

◆ m_refit

bool MuonCalib::IMdtPatRecFitter::m_refit

protectedinherited

Definition at line 51 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:

Public Types

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ HitSelection

Constructor & Destructor Documentation

◆ StraightPatRec() [1/2]

◆ StraightPatRec() [2/2]

Member Function Documentation

◆ fit() [1/3]

◆ fit() [2/3]

◆ fit() [3/3]

◆ fitCallByReference() [1/2]

◆ fitCallByReference() [2/2]

◆ fitCandidate()

◆ init() [1/2]

◆ init() [2/2]

◆ printLevel()

◆ RefineSegmentFlag()

◆ refit()

◆ roadWidth()

◆ setFixSelection()

◆ SetRefineSegmentFlag()

◆ setRoadWidth()

◆ setTimeOut()

◆ switchOffRefit()

◆ switchOnRefit()

◆ tangent()

Member Data Documentation

◆ m_fix_selection

◆ m_r_max

◆ m_refine_segment

◆ m_refit

◆ m_road_width

◆ m_time_out