FPGATrackSimKeyLayerTool Class Reference

#include <FPGATrackSimKeyLayerTool.h>

Collaboration diagram for FPGATrackSimKeyLayerTool:

Classes
struct	KeyLyrPars
struct	rotatedConfig

Public Member Functions
	FPGATrackSimKeyLayerTool (double r1, double r2)
	FPGATrackSimKeyLayerTool ()
std::pair< double, double >	getXY (double r, double phi) const
std::pair< double, double >	getRotationAngles (const std::pair< double, double > &xy1, const std::pair< double, double > &xy2) const
std::pair< double, double >	rotateXY (const std::pair< double, double > &xy, const std::pair< double, double > &ang) const
rotatedConfig	getRotatedConfig (const KeyLyrPars &keypars) const
std::pair< double, double >	getRotatedHit (const std::pair< double, double > &rotang, const FPGATrackSimHit *hit) const
KeyLyrPars	trackParsToKeyPars (const FPGATrackSimTrackPars &pars) const
FPGATrackSimTrackPars	keyParsToTrackPars (const KeyLyrPars &keypars) const
double	zExpected (const KeyLyrPars &keypars, double r) const
double	xExpected (const KeyLyrPars &keypars, const FPGATrackSimHit *hit) const
double	xmForHit (const KeyLyrPars &keypars, const FPGATrackSimHit *hit) const
double	deltaX (const KeyLyrPars &keypars, const FPGATrackSimHit *hit) const
double	R1 () const
double	R2 () const
void	setR1 (const double r1)
void	setR2 (const double r2)

Private Attributes
double	m_R1 {}
double	m_R2 {}

Detailed Description

Definition at line 46 of file FPGATrackSimKeyLayerTool.h.

Constructor & Destructor Documentation

FPGATrackSimKeyLayerTool() [1/2]

FPGATrackSimKeyLayerTool::FPGATrackSimKeyLayerTool ( double  r1, double  r2  )

inline

Definition at line 49 of file FPGATrackSimKeyLayerTool.h.

: m_R1(r1), m_R2(r2) {}

FPGATrackSimKeyLayerTool() [2/2]

FPGATrackSimKeyLayerTool::FPGATrackSimKeyLayerTool ( )

inline

Definition at line 50 of file FPGATrackSimKeyLayerTool.h.

{} // NOTE r1 and r2 must be set before using class

Member Function Documentation

deltaX()

double FPGATrackSimKeyLayerTool::deltaX	(	const KeyLyrPars &	keypars,
		const FPGATrackSimHit *	hit
	)		const

Definition at line 156 of file FPGATrackSimKeyLayerTool.cxx.

{
    auto rotated_coords = getRotatedConfig(keypars);
 
    auto rotang = rotated_coords.rotang;
 
    auto xyhp = getRotatedHit(rotang, hit);
 
    double xh = xyhp.first-rotated_coords.xy1p.first;
 
    return xh - xExpected(keypars,hit);
}

getRotatedConfig()

FPGATrackSimKeyLayerTool::rotatedConfig FPGATrackSimKeyLayerTool::getRotatedConfig

(

const KeyLyrPars &

keypars

)

const

Definition at line 32 of file FPGATrackSimKeyLayerTool.cxx.

{    
    rotatedConfig result;
 
    auto xy1 = getXY(m_R1, keypars.phi1);
    auto xy2 = getXY(m_R2, keypars.phi2);
 
    result.rotang = getRotationAngles(xy1, xy2);
    result.xy1p = rotateXY(xy1, result.rotang);
    result.xy2p = rotateXY(xy2, result.rotang);
    result.y = result.xy2p.second - result.xy1p.second;
 
    return result;
}

getRotatedHit()

std::pair< double, double > FPGATrackSimKeyLayerTool::getRotatedHit	(	const std::pair< double, double > &	rotang,
		const FPGATrackSimHit *	hit
	)		const

Definition at line 47 of file FPGATrackSimKeyLayerTool.cxx.

{
    auto xyh = getXY(hit->getR(), hit->getGPhi());
    return rotateXY(xyh, rotang);
}

getRotationAngles()

std::pair< double, double > FPGATrackSimKeyLayerTool::getRotationAngles	(	const std::pair< double, double > &	xy1,
		const std::pair< double, double > &	xy2
	)		const

Definition at line 16 of file FPGATrackSimKeyLayerTool.cxx.

{
    double dr12x = xy2.first - xy1.first;
    double dr12y = xy2.second - xy1.second;
    double dr12mag = std::hypot(dr12x, dr12y);
    double cos_rot = dr12y / dr12mag;
    double sin_rot = -dr12x / dr12mag;
    return std::pair<double, double>(cos_rot, sin_rot);
}

getXY()

std::pair< double, double > FPGATrackSimKeyLayerTool::getXY	(	double	r,
		double	phi
	)		const

Definition at line 11 of file FPGATrackSimKeyLayerTool.cxx.

{
    return std::pair<double, double>(r * cos(phi), r * sin(phi));
}

keyParsToTrackPars()

FPGATrackSimTrackPars FPGATrackSimKeyLayerTool::keyParsToTrackPars

(

const KeyLyrPars &

keypars

)

const

Definition at line 79 of file FPGATrackSimKeyLayerTool.cxx.

{
 
    FPGATrackSimTrackPars pars;
    pars[FPGATrackSimTrackPars::IZ0] = (keypars.z1 * m_R2 - keypars.z2 * m_R1) / (m_R2 - m_R1);
    pars[FPGATrackSimTrackPars::IETA] = FPGATrackSimBinUtil::GeomHelpers::EtaFromTheta(std::atan2(m_R2 - m_R1, keypars.z2 - keypars.z1));
 
    // This is the exact math which is a bit messy
    // if you want the math contact lipeles@sas.upenn.edu
 
    double xm = keypars.xm;
 
    auto rotated_coords = getRotatedConfig(keypars);
    auto xy1p = rotated_coords.xy1p;
    auto rotang = rotated_coords.rotang;
    auto y = rotated_coords.y;
 
    // reverse rotation
    auto revang = rotang;
    revang.second = -rotang.second;
 
    if (xm != 0)
    {
        double Rinv = 2 * xm / (xm * xm + (y / 2) * (y / 2));
        double d = (y * y / 4.0 - xm * xm) / (2.0 * xm);
        double sign = (xm > 0) - (xm < 0);
 
        pars[FPGATrackSimTrackPars::IHIP] = -1 * Rinv / (2.0 * FPGATrackSimBinUtil::GeomHelpers::CurvatureConstant);
 
        std::pair<double, double> xycp(-d + xy1p.first, y / 2.0 + xy1p.second);
 
        pars[FPGATrackSimTrackPars::ID0] = -1 * sign * (std::abs(1 / Rinv) - std::hypot(xycp.first, xycp.second));
 
        auto xyc = rotateXY(xycp, revang);
 
        pars[FPGATrackSimTrackPars::IPHI] = std::atan2(sign * -xyc.first, sign * xyc.second);
    }
    else
    {
        pars[FPGATrackSimTrackPars::IHIP] = 0.0;
        pars[FPGATrackSimTrackPars::ID0] = -1 * xy1p.first;
        pars[FPGATrackSimTrackPars::IPHI] = std::atan2(rotang.first, -rotang.second);
    }
 
    return pars;
}

R1()

double FPGATrackSimKeyLayerTool::R1 ( ) const

inline

Definition at line 103 of file FPGATrackSimKeyLayerTool.h.

{return m_R1;}

R2()

double FPGATrackSimKeyLayerTool::R2 ( ) const

inline

Definition at line 104 of file FPGATrackSimKeyLayerTool.h.

{return m_R2;}

rotateXY()

std::pair< double, double > FPGATrackSimKeyLayerTool::rotateXY	(	const std::pair< double, double > &	xy,
		const std::pair< double, double > &	ang
	)		const

Definition at line 26 of file FPGATrackSimKeyLayerTool.cxx.

{
    return std::pair<double, double>(xy.first * ang.first + xy.second * ang.second,
                                     -xy.first * ang.second + xy.second * ang.first);
}

setR1()

void FPGATrackSimKeyLayerTool::setR1 ( const double  r1 )

inline

Definition at line 105 of file FPGATrackSimKeyLayerTool.h.

{m_R1=r1;}

setR2()

void FPGATrackSimKeyLayerTool::setR2 ( const double  r2 )

inline

Definition at line 106 of file FPGATrackSimKeyLayerTool.h.

{m_R2=r2;}

trackParsToKeyPars()

FPGATrackSimKeyLayerTool::KeyLyrPars FPGATrackSimKeyLayerTool::trackParsToKeyPars

(

const FPGATrackSimTrackPars &

pars

)

const

Definition at line 53 of file FPGATrackSimKeyLayerTool.cxx.

{
    KeyLyrPars retv;
    retv.z1 = FPGATrackSimBinUtil::GeomHelpers::zFromPars(m_R1, pars);
    retv.z2 = FPGATrackSimBinUtil::GeomHelpers::zFromPars(m_R2, pars);
    retv.phi1 = FPGATrackSimBinUtil::GeomHelpers::phiFromPars(m_R1, pars);
    retv.phi2 = FPGATrackSimBinUtil::GeomHelpers::phiFromPars(m_R2, pars);
 
    double Rinv = pars[FPGATrackSimTrackPars::IHIP] * (2.0 * FPGATrackSimBinUtil::GeomHelpers::CurvatureConstant);
    if (Rinv != 0)
    {
        double R = 1 / Rinv;
        auto xy1 = getXY(m_R1, retv.phi1);
        auto xy2 = getXY(m_R2, retv.phi2);
        double ysqr = (xy2.first - xy1.first) * (xy2.first - xy1.first) + (xy2.second - xy1.second) * (xy2.second - xy1.second);
        double sign = (R > 0) - (R < 0);
        retv.xm = -1 * sign * (std::abs(R) - sqrt(R * R - ysqr / 4.0));
    }
    else
    {
        retv.xm = 0;
    }
 
    return retv;
}

xExpected()

double FPGATrackSimKeyLayerTool::xExpected	(	const KeyLyrPars &	keypars,
		const FPGATrackSimHit *	hit
	)		const

Definition at line 170 of file FPGATrackSimKeyLayerTool.cxx.

{
    auto rotated_coords = getRotatedConfig(keypars);
 
    auto rotang = rotated_coords.rotang;
    auto y = rotated_coords.y;
 
    auto xyhp = getRotatedHit(rotang, hit);
 
    double yh = xyhp.second-rotated_coords.xy1p.second;
 
    return keypars.xm * (keypars.xm * keypars.xm + yh * (y - yh)) / (keypars.xm * keypars.xm + (y / 2) * (y / 2));
}

xmForHit()

double FPGATrackSimKeyLayerTool::xmForHit	(	const KeyLyrPars &	keypars,
		const FPGATrackSimHit *	hit
	)		const

Definition at line 132 of file FPGATrackSimKeyLayerTool.cxx.

{
    auto rotated_coords = getRotatedConfig(keypars);
    auto xy1p = rotated_coords.xy1p;
    auto rotang = rotated_coords.rotang;
    auto y = rotated_coords.y;
 
    auto xyhp = getRotatedHit(rotang, hit);
    double xh = xyhp.first - xy1p.first;
    double yh = xyhp.second - xy1p.second;
 
    // use taylor expanded xm calculation
    double sign = ((yh > 0) && (yh < y)) ? 1 : -1;
    if ((std::abs(yh) < std::abs(xh)) || (std::abs(y - yh) < std::abs(xh)))
    {
        return ((xh > 0) ? 1 : -1) * 100000;
    }
 
    double xm_taylor = sign * y * y / (y * y - 4 * xh * xh - 4 * (yh - y / 2.0) * (yh - y / 2.0)) * xh;
 
    return xm_taylor;
}

zExpected()

double FPGATrackSimKeyLayerTool::zExpected	(	const KeyLyrPars &	keypars,
		double	r
	)		const

Definition at line 126 of file FPGATrackSimKeyLayerTool.cxx.

{
    return (keypars.z2 - keypars.z1) / (m_R2 - m_R1) * (r - m_R1) + keypars.z1;
}

Member Data Documentation

m_R1

double FPGATrackSimKeyLayerTool::m_R1 {}

private

Definition at line 109 of file FPGATrackSimKeyLayerTool.h.

m_R2

double FPGATrackSimKeyLayerTool::m_R2 {}

private

Definition at line 110 of file FPGATrackSimKeyLayerTool.h.

---

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

• FPGATrackSimKeyLayerTool.h
• FPGATrackSimKeyLayerTool.cxx