FPGATrackSimGenScanKeyLyrHelper Class Reference

#include <FPGATrackSimGenScanBinning.h>

Collaboration diagram for FPGATrackSimGenScanKeyLyrHelper:

Classes
struct	KeyLyrPars
struct	rotatedConfig

Public Member Functions
	FPGATrackSimGenScanKeyLyrHelper (double r1, double r2)
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 (KeyLyrPars keypars, double r) const
double	xExpected (KeyLyrPars keypars, const FPGATrackSimHit *hit) const
double	xmForHit (KeyLyrPars keypars, const FPGATrackSimHit *hit) const
double	deltaX (KeyLyrPars keypars, const FPGATrackSimHit *hit) const
double	R1 () const
double	R2 () const

Private Attributes
double	m_R1
double	m_R2

Detailed Description

Definition at line 313 of file FPGATrackSimGenScanBinning.h.

Constructor & Destructor Documentation

FPGATrackSimGenScanKeyLyrHelper()

FPGATrackSimGenScanKeyLyrHelper::FPGATrackSimGenScanKeyLyrHelper ( double  r1, double  r2  )

inline

Definition at line 316 of file FPGATrackSimGenScanBinning.h.

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

Member Function Documentation

deltaX()

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

Definition at line 363 of file FPGATrackSimGenScanBinning.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()

FPGATrackSimGenScanKeyLyrHelper::rotatedConfig FPGATrackSimGenScanKeyLyrHelper::getRotatedConfig

(

const KeyLyrPars &

keypars

)

const

Definition at line 239 of file FPGATrackSimGenScanBinning.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 > FPGATrackSimGenScanKeyLyrHelper::getRotatedHit	(	const std::pair< double, double > &	rotang,
		const FPGATrackSimHit *	hit
	)		const

Definition at line 254 of file FPGATrackSimGenScanBinning.cxx.

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

getRotationAngles()

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

Definition at line 223 of file FPGATrackSimGenScanBinning.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 > FPGATrackSimGenScanKeyLyrHelper::getXY	(	double	r,
		double	phi
	)		const

Definition at line 218 of file FPGATrackSimGenScanBinning.cxx.

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

keyParsToTrackPars()

FPGATrackSimTrackPars FPGATrackSimGenScanKeyLyrHelper::keyParsToTrackPars

(

const KeyLyrPars &

keypars

)

const

Definition at line 286 of file FPGATrackSimGenScanBinning.cxx.

{
 
    FPGATrackSimTrackPars pars;
    pars[FPGATrackSimTrackPars::IZ0] = (keypars.z1 * m_R2 - keypars.z2 * m_R1) / (m_R2 - m_R1);
    pars[FPGATrackSimTrackPars::IETA] = FPGATrackSimGenScanGeomHelpers::EtaFromTheta(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 * FPGATrackSimGenScanGeomHelpers::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] = atan2(sign * -xyc.first, sign * xyc.second);
    }
    else
    {
        pars[FPGATrackSimTrackPars::IHIP] = 0.0;
        pars[FPGATrackSimTrackPars::ID0] = -1 * xy1p.first;
        pars[FPGATrackSimTrackPars::IPHI] = atan2(rotang.first, -rotang.second);
    }
 
    return pars;
}

R1()

double FPGATrackSimGenScanKeyLyrHelper::R1 ( ) const

inline

Definition at line 366 of file FPGATrackSimGenScanBinning.h.

{return m_R1;}

R2()

double FPGATrackSimGenScanKeyLyrHelper::R2 ( ) const

inline

Definition at line 367 of file FPGATrackSimGenScanBinning.h.

{return m_R2;}

rotateXY()

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

Definition at line 233 of file FPGATrackSimGenScanBinning.cxx.

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

trackParsToKeyPars()

FPGATrackSimGenScanKeyLyrHelper::KeyLyrPars FPGATrackSimGenScanKeyLyrHelper::trackParsToKeyPars

(

const FPGATrackSimTrackPars &

pars

)

const

Definition at line 260 of file FPGATrackSimGenScanBinning.cxx.

{
    KeyLyrPars retv;
    retv.z1 = FPGATrackSimGenScanGeomHelpers::zFromPars(m_R1, pars);
    retv.z2 = FPGATrackSimGenScanGeomHelpers::zFromPars(m_R2, pars);
    retv.phi1 = FPGATrackSimGenScanGeomHelpers::phiFromPars(m_R1, pars);
    retv.phi2 = FPGATrackSimGenScanGeomHelpers::phiFromPars(m_R2, pars);
 
    double Rinv = pars[FPGATrackSimTrackPars::IHIP] * (2.0 * FPGATrackSimGenScanGeomHelpers::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 FPGATrackSimGenScanKeyLyrHelper::xExpected	(	KeyLyrPars	keypars,
		const FPGATrackSimHit *	hit
	)		const

Definition at line 377 of file FPGATrackSimGenScanBinning.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 FPGATrackSimGenScanKeyLyrHelper::xmForHit	(	KeyLyrPars	keypars,
		const FPGATrackSimHit *	hit
	)		const

Definition at line 339 of file FPGATrackSimGenScanBinning.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 FPGATrackSimGenScanKeyLyrHelper::zExpected	(	KeyLyrPars	keypars,
		double	r
	)		const

Definition at line 333 of file FPGATrackSimGenScanBinning.cxx.

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

Member Data Documentation

m_R1

double FPGATrackSimGenScanKeyLyrHelper::m_R1

private

Definition at line 370 of file FPGATrackSimGenScanBinning.h.

m_R2

double FPGATrackSimGenScanKeyLyrHelper::m_R2

private

Definition at line 371 of file FPGATrackSimGenScanBinning.h.

---

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

• FPGATrackSimGenScanBinning.h
• FPGATrackSimGenScanBinning.cxx