#include <CurvedPatRec.h>

Inheritance diagram for MuonCalib::CurvedPatRec:

Collaboration diagram for MuonCalib::CurvedPatRec:

Public Types
using	MdtHitVec = MuonCalibSegment::MdtHitVec

using	MdtHitPtr = MuonCalibSegment::MdtHitPtr

typedef std::vector< unsigned int >	HitSelection

Public Member Functions
	CurvedPatRec ()
	Default constructor: road width of 0.5 mm is used. More...

	CurvedPatRec (const double road_width)
	Constructor: user defined road width [mm] for pattern recognition. More...

double	roadWidth () const
	get the road width used in the pattern recognition [mm] More...

void	setRoadWidth (const double r_road_width)
	set the road width [mm] 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...

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

bool	fit (MuonCalibSegment &r_segment, HitSelection r_selection) const
	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, CurvedLine &curved_track) const

void	printLevel (int)

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
Amg::Vector3D	getHitPoint (const MdtHitPtr &hit, const MTStraightLine &straight_track) const

std::vector< Amg::Vector3D >	getHitPoints (const MdtHitVec &track_hits, const MTStraightLine &straight_track) const

std::vector< Amg::Vector3D >	getHitPoints (const MdtHitVec &track_hits, const CurvedLine &curved_track) const

Private Attributes
double	m_road_width {0.5}

double	m_time_out {10}

Detailed Description

Definition at line 35 of file CurvedPatRec.h.

Member Typedef Documentation

◆ HitSelection

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

inherited

Definition at line 32 of file IMdtSegmentFitter.h.

◆ MdtHitPtr

using MuonCalib::CurvedPatRec::MdtHitPtr = MuonCalibSegment::MdtHitPtr

Definition at line 38 of file CurvedPatRec.h.

◆ MdtHitVec

using MuonCalib::CurvedPatRec::MdtHitVec = MuonCalibSegment::MdtHitVec

Definition at line 37 of file CurvedPatRec.h.

Constructor & Destructor Documentation

◆ CurvedPatRec() [1/2]

CurvedPatRec::CurvedPatRec ( )

default

Default constructor: road width of 0.5 mm is used.

◆ CurvedPatRec() [2/2]

CurvedPatRec::CurvedPatRec ( const double road_width )

Constructor: user defined road width [mm] for pattern recognition.

Definition at line 18 of file CurvedPatRec.cxx.

18 { m_road_width = road_width; }

Member Function Documentation

◆ fit() [1/3]

bool CurvedPatRec::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

Implements MuonCalib::IMdtSegmentFitter.

Definition at line 23 of file CurvedPatRec.cxx.

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

◆ fit() [2/3]

bool CurvedPatRec::fit	(	MuonCalibSegment &	r_segment,
		HitSelection	r_selection
	)		const

virtual

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 radii are only approximate

Implements MuonCalib::IMdtSegmentFitter.

Definition at line 29 of file CurvedPatRec.cxx.

                                                                                   {
     CurvedLine curved_track;
     return fit(r_segment, r_selection, curved_track);
 }

◆ fit() [3/3]

bool CurvedPatRec::fit	(	MuonCalibSegment &	r_segment,
		HitSelection	r_selection,
		CurvedLine &	curved_track
	)		const

Definition at line 33 of file CurvedPatRec.cxx.

                                                                                                             {
     // VARIABLES //
     std::unique_ptr<StraightPatRec> sfitter = std::make_unique<StraightPatRec>();
     time_t start, end;  // start and end times (needed for time-out)
     double diff;        // difference of start and end time (needed for time-out)
     Combination combination;
     std::vector<unsigned int> hit_index;  // hit indices for a given combination
     unsigned int try_nb_hits;             // try to find a segment with try_nb_hits hits
     bool segment_found(false);            // flag indicating the a segment has been found
     MdtHitVec cand_track_hits;            // vector of the track hits
                                           // found so far
     CurvedLine aux_line;                  // memory for reconstructed curved lines
     Amg::Vector3D null(0.0, 0.0, 0.0);
     Amg::Vector3D xhat(1.0, 0.0, 0.0);
     std::vector<Amg::Vector3D> points;  // hit points for the track fit
     MdtHitVec loc_track_hits;           // track hit store
  
     // RESETS //
     time(&start);
  
     // CHECK SIZE OF THE SELECTION VECTOR //
  
     if (r_selection.size() != r_segment.mdtHitsOnTrack()) {
         throw std::runtime_error(
             Form("File: %s, Line: %d\nCurvedPatRec::fit - Size of selection vector does not match the number of hits on track!", __FILE__,
                  __LINE__));
     }
  
     // PREPARATORY WORK //
  
     // perform a straight track fit to get an estimate of the incidence angle //
     Amg::Vector3D est_dir(0.0, 0.0, 1.0);
     sfitter->setRoadWidth(2.0 * m_road_width);
     sfitter->setTimeOut(0.5 * m_time_out);
     MTStraightLine track;
     if (sfitter->fit(r_segment, r_selection, track)) { est_dir = track.directionVector(); }
  
     // store track hits //
     unsigned int k = 0;
     for (const MuonCalibSegment::MdtHitPtr &hit : r_segment.mdtHOT()) {
         if (r_selection[k] == 0 && hit->sigmaDriftRadius() < 100) { loc_track_hits.push_back(hit); };
         ++k;
     }
  
     // return, if there are too few hits //
     if (loc_track_hits.size() < 4) { return false; }
     // PATTERN RECOGNITION //
  
     // try to find a segment with as many hits on it as possible //
     try_nb_hits = loc_track_hits.size();
  
     MdtHitVec stored_track_hits;
     double chi2 = -1.;
  
     while (!segment_found && try_nb_hits > 3) {
         // loop over the combinations //
         combination.setNewParameters(loc_track_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) {
                 MsgStream log(Athena::getMessageSvc(), "CurvedPatRec");
                 log << MSG::WARNING << "Class CurvedPatRec, method fit: time-out for track finding after " << m_time_out << " seconds!"
                     << endmsg;
                 return false;
             }
  
             // analyse the hit combination //
             if (cb == 0) {
                 combination.currentCombination(hit_index);
             } else {
                 combination.nextCombination(hit_index);
             }
             MdtHitVec track_hits;
             for (unsigned int k = 0; k < try_nb_hits; ++k) { track_hits.push_back(loc_track_hits[hit_index[k] - 1]); }
  
             // find candidates //
             CurvedCandidateFinder finder(track_hits);
             const std::vector<CurvedLine> candidates(finder.getCandidates(m_road_width, est_dir));
             if (candidates.empty()) { continue; }
  
             segment_found = true;
  
             for (const auto & candidate : candidates) {
                 std::vector<Amg::Vector3D> errors(track_hits.size());
                 for (unsigned int k = 0; k < errors.size(); k++) {
                     if (track_hits[k]->sigmaDriftRadius() > 0.0) {
                         errors[k] = Amg::Vector3D(1.0, track_hits[k]->sigmaDriftRadius(), 0.0);
                     } else {
                         errors[k] = Amg::Vector3D(1.0, 1.0, 0.0);
                     }
                 }
  
                 // get hit points //
                 points = getHitPoints(track_hits, candidate);
  
                 // fit a curved line through the points //
                 aux_line = CurvedLine(points, errors);
  
                 // calculate chi^2 //
                 double tmp_chi2(0.0);
                 for (auto & track_hit : track_hits) {
                     MTStraightLine tang(curved_track.getTangent((track_hit->localPosition()).z()));
                     MTStraightLine wire(Amg::Vector3D(0.0, track_hit->localPosition().y(), track_hit->localPosition().z()), xhat,
                                         null, null);
                     double d(std::abs(tang.signDistFrom(wire)));
                     if (track_hit->sigma2DriftRadius() != 0) {
                         tmp_chi2 = tmp_chi2 + std::pow(d - track_hit->driftRadius(), 2) / track_hit->sigma2DriftRadius();
                     } else {
                         tmp_chi2 = tmp_chi2 + std::pow(d - track_hit->driftRadius(), 2) / 0.01;
                     }
                 }
  
                 // compare chi^2 with chi^2 values found so far //
                 if (chi2 < 0 || tmp_chi2 < chi2) {
                     chi2 = tmp_chi2;
                     curved_track = aux_line;
                     // store the track hits //
                     stored_track_hits = track_hits;
                 }
             }
         }
  
         try_nb_hits = try_nb_hits - 1;
     }
  
     if (!segment_found) { return false; }
  
     // SECOND REFINED CURVED FIT //
  
     // get hit points //
     points = getHitPoints(stored_track_hits, curved_track);
     std::vector<Amg::Vector3D> errors(stored_track_hits.size());
     for (unsigned int k = 0; k < errors.size(); k++) {
         if (stored_track_hits[k]->sigmaDriftRadius() > 0.0) {
             errors[k] = Amg::Vector3D(1.0, stored_track_hits[k]->sigmaDriftRadius(), 0.0);
         } else {
             errors[k] = Amg::Vector3D(1.0, 1.0, 0.0);
         }
     }
  
     // fit a curved line through the points //
     curved_track = CurvedLine(points, errors);
  
     // CALCULATE CHI^2 //
  
     chi2 = 0.0;
     for (auto & stored_track_hit : stored_track_hits) {
         MTStraightLine tang(curved_track.getTangent((stored_track_hit->localPosition()).z()));
         MTStraightLine wire(Amg::Vector3D(0.0, stored_track_hit->localPosition().y(), stored_track_hit->localPosition().z()), xhat,
                             null, null);
         double d(std::abs(tang.signDistFrom(wire)));
         if (stored_track_hit->sigma2DriftRadius() != 0) {
             chi2 += std::pow(d - stored_track_hit->driftRadius(), 2) / stored_track_hit->sigma2DriftRadius();
         } else {
             chi2 += std::pow(d - stored_track_hit->driftRadius(), 2) / 0.01;
         }
     }
  
     // UPDATE HIT RESIDUALS //
  
     for (const MdtHitPtr& hit : r_segment.mdtHOT()) {
         Amg::Vector3D pos(0.0, hit->localPosition().y(), hit->localPosition().z());
         MTStraightLine aux_line(pos, xhat, null, null);
  
         MTStraightLine tang(curved_track.getTangent(pos.z()));
  
         double dist(tang.signDistFrom(aux_line));  // track distance
         double dist_err(1.0);                      // unknown error of the track distance
         hit->setDistanceToTrack(dist, dist_err);
     }
  
     if (std::isnan(chi2)) { chi2 = 1.0e6; }
  
     // UPDATE SEGMENT POSITION, DIRECTION, CHI^2 //
  
     MTStraightLine tangent(curved_track.getTangent((r_segment.position()).z()));
     r_segment.set(chi2 / (stored_track_hits.size() - 3), tangent.positionVector(), tangent.directionVector());
     curved_track.setChi2(chi2);
     curved_track.setNumberOfTrackHits(stored_track_hits.size());
     curved_track.setUsedHits(stored_track_hits);
     return true;
 }

◆ getHitPoint()

Amg::Vector3D CurvedPatRec::getHitPoint	(	const MdtHitPtr &	hit,
		const MTStraightLine &	straight_track
	)		const

private

Definition at line 236 of file CurvedPatRec.cxx.

                                                                                                       {
     // CALCULATE HIT POINT //
  
     Amg::Vector3D point = straight_track.positionVector() +
                           (straight_track.directionVector().unit().dot(hit->localPosition() - straight_track.positionVector())) *
                               straight_track.directionVector().unit();
     Amg::Vector3D point_2 = hit->localPosition() + hit->driftRadius() * (point - hit->localPosition()).unit();
  
     return point_2;
 }

◆ getHitPoints() [1/2]

std::vector< Amg::Vector3D > CurvedPatRec::getHitPoints	(	const MdtHitVec &	track_hits,
		const CurvedLine &	curved_track
	)		const

private

Definition at line 269 of file CurvedPatRec.cxx.

                                                                                                                    {
     // VARIABLES //
  
     std::vector<Amg::Vector3D> hit_vec;
  
     // FILL HIT VECTOR //
  
     for (const auto & track_hit : track_hits) {
         hit_vec.emplace_back(getHitPoint(track_hit, curved_track.getTangent((track_hit->localPosition()).z())));
     }
  
     // RETURN THE HIT VECTOR //
  
     return hit_vec;
 }

◆ getHitPoints() [2/2]

std::vector< Amg::Vector3D > CurvedPatRec::getHitPoints	(	const MdtHitVec &	track_hits,
		const MTStraightLine &	straight_track
	)		const

private

Definition at line 249 of file CurvedPatRec.cxx.

                                                                                                                          {
     // VARIABLES //
  
     std::vector<Amg::Vector3D> hit_vec;
  
     // FILL HIT VECTOR //
  
     for (const auto & track_hit : track_hits) { hit_vec.emplace_back(getHitPoint(track_hit, straight_track)); }
  
     // RETURN THE HIT VECTOR //
  
     return hit_vec;
 }

◆ printLevel()

void MuonCalib::CurvedPatRec::printLevel ( int )

inlinevirtual

Implements MuonCalib::IMdtSegmentFitter.

Definition at line 87 of file CurvedPatRec.h.

87 {};

◆ RefineSegmentFlag()

bool MuonCalib::IMdtPatRecFitter::RefineSegmentFlag ( ) const

inlineinherited

get refine segment flag

Definition at line 37 of file IMdtPatRecFitter.h.

37 { return m_refine_segment; }

◆ refit()

bool MuonCalib::IMdtPatRecFitter::refit ( ) const

inlineinherited

return refit flag

Definition at line 43 of file IMdtPatRecFitter.h.

43 { return m_refit; }

◆ roadWidth()

double CurvedPatRec::roadWidth ( ) const

get the road width used in the pattern recognition [mm]

Definition at line 20 of file CurvedPatRec.cxx.

20 { return m_road_width; }

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

34 { m_refine_segment = flag; }

◆ setRoadWidth()

void CurvedPatRec::setRoadWidth ( const double r_road_width )

virtual

set the road width [mm] for the pattern recognition = r_road_width

Implements MuonCalib::IMdtPatRecFitter.

Definition at line 21 of file CurvedPatRec.cxx.

21 { m_road_width = r_road_width; }

◆ setTimeOut()

void CurvedPatRec::setTimeOut ( const double time_out )

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

Definition at line 22 of file CurvedPatRec.cxx.

22 { m_time_out = time_out; }

◆ switchOffRefit()

void MuonCalib::IMdtPatRecFitter::switchOffRefit ( )

inlineinherited

Definition at line 41 of file IMdtPatRecFitter.h.

41 { 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.

40 { m_refit = true; }

Member Data Documentation

◆ 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::CurvedPatRec::m_road_width {0.5}

private

Definition at line 99 of file CurvedPatRec.h.

◆ m_time_out

double MuonCalib::CurvedPatRec::m_time_out {10}

private

Definition at line 100 of file CurvedPatRec.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

◆ MdtHitPtr

◆ MdtHitVec

Constructor & Destructor Documentation

◆ CurvedPatRec() [1/2]

◆ CurvedPatRec() [2/2]

Member Function Documentation

◆ fit() [1/3]

◆ fit() [2/3]

◆ fit() [3/3]

◆ getHitPoint()

◆ getHitPoints() [1/2]

◆ getHitPoints() [2/2]

◆ printLevel()

◆ RefineSegmentFlag()

◆ refit()

◆ roadWidth()

◆ SetRefineSegmentFlag()

◆ setRoadWidth()

◆ setTimeOut()

◆ switchOffRefit()

◆ switchOnRefit()

Member Data Documentation

◆ m_refine_segment

◆ m_refit

◆ m_road_width

◆ m_time_out