LArRotationalTransformationPlugin class. More...

#include "LArRotationalTransformationPlugin.h"

Inheritance diagram for lar_content::LArRotationalTransformationPlugin:

Public Member Functions
	LArRotationalTransformationPlugin ()
	Default constructor. More...

virtual double	UVtoW (const double u, const double v) const

virtual double	VWtoU (const double v, const double w) const

virtual double	WUtoV (const double w, const double u) const

virtual double	UVtoY (const double u, const double v) const

virtual double	UVtoZ (const double u, const double v) const

virtual double	UWtoY (const double u, const double w) const

virtual double	UWtoZ (const double u, const double w) const

virtual double	VWtoY (const double v, const double w) const

virtual double	VWtoZ (const double v, const double w) const

virtual double	YZtoU (const double y, const double z) const

virtual double	YZtoV (const double y, const double z) const

virtual double	YZtoW (const double y, const double z) const

virtual void	GetMinChiSquaredYZ (const double u, const double v, const double w, const double sigmaU, const double sigmaV, const double sigmaW, double &y, double &z, double &chiSquared) const

virtual void	GetMinChiSquaredYZ (const double u, const double v, const double w, const double sigmaU, const double sigmaV, const double sigmaW, const double uFit, const double vFit, const double wFit, const double sigmaFit, double &y, double &z, double &chiSquared) const

Private Member Functions
pandora::StatusCode	Initialize ()

pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Private Attributes
double	m_thetaU
	inclination of U wires (radians) More...

double	m_thetaV
	inclination of V wires (radians) More...

double	m_thetaW
	inclination of W wires (radians) More...

double	m_sinU
	sin(thetaU) More...

double	m_sinV
	sin(thetaV) More...

double	m_sinW
	sin(thetaW) More...

double	m_cosU
	cos(thetaU) More...

double	m_cosV
	cos(thetaV) More...

double	m_cosW
	cos(thetaW) More...

double	m_sinVminusU
	sin(thetaV - thetaU) More...

double	m_sinWminusV
	sin(thetaW - thetaV) More...

double	m_sinUminusW
	sin(thetaU - thetaW) More...

double	m_maxAngularDiscrepancyU
	Maximum allowed difference between u wire angles between LArTPCs. More...

double	m_maxAngularDiscrepancyV
	Maximum allowed difference between v wire angles between LArTPCs. More...

double	m_maxAngularDiscrepancyW
	Maximum allowed difference between w wire angles between LArTPCs. More...

double	m_maxSigmaDiscrepancy
	Maximum allowed difference between like wire sigma values between LArTPCs. More...

Detailed Description

LArRotationalTransformationPlugin class.

Definition at line 19 of file LArRotationalTransformationPlugin.h.

Constructor & Destructor Documentation

lar_content::LArRotationalTransformationPlugin::LArRotationalTransformationPlugin ( )

Default constructor.

Definition at line 28 of file LArRotationalTransformationPlugin.cc.

                                                                      :
     m_thetaU(0.),
     m_thetaV(0.),
     m_thetaW(0.),
     m_sinU(0.),
     m_sinV(0.),
     m_sinW(0.),
     m_cosU(0.),
     m_cosV(0.),
     m_cosW(0.),
     m_sinVminusU(0.),
     m_sinWminusV(0.),
     m_sinUminusW(0.),
     m_maxAngularDiscrepancyU(0.03),
     m_maxAngularDiscrepancyV(0.03),
     m_maxAngularDiscrepancyW(0.03),
     m_maxSigmaDiscrepancy(0.01)
 {
 }

Member Function Documentation

void lar_content::LArRotationalTransformationPlugin::GetMinChiSquaredYZ	(	const double	u,
		const double	v,
		const double	w,
		const double	sigmaU,
		const double	sigmaV,
		const double	sigmaW,
		double &	y,
		double &	z,
		double &	chiSquared
	)		const

virtual

Definition at line 134 of file LArRotationalTransformationPlugin.cc.

References m_cosU, m_cosV, m_cosW, m_sinU, m_sinV, m_sinW, YZtoU(), YZtoV(), and YZtoW().

 {
     const double sigmaU2(sigmaU * sigmaU), sigmaV2(sigmaV * sigmaV), sigmaW2(sigmaW * sigmaW);
 
     // Obtain expression for chi2, differentiate wrt y and z, set both results to zero and solve simultaneously. Here just paste-in result.
     y = (sigmaW2 * v * m_cosU * m_cosV * m_sinU - sigmaW2 * u * m_cosV * m_cosV * m_sinU + sigmaV2 * w * m_cosU * m_cosW * m_sinU -
             sigmaV2 * u * m_cosW * m_cosW * m_sinU - sigmaW2 * v * m_cosU * m_cosU * m_sinV + sigmaW2 * u * m_cosU * m_cosV * m_sinV +
             sigmaU2 * w * m_cosV * m_cosW * m_sinV - sigmaU2 * v * m_cosW * m_cosW * m_sinV - sigmaV2 * w * m_cosU * m_cosU * m_sinW -
             sigmaU2 * w * m_cosV * m_cosV * m_sinW + sigmaV2 * u * m_cosU * m_cosW * m_sinW + sigmaU2 * v * m_cosV * m_cosW * m_sinW) /
         (sigmaW2 * m_cosV * m_cosV * m_sinU * m_sinU + sigmaV2 * m_cosW * m_cosW * m_sinU * m_sinU - 2. * sigmaW2 * m_cosU * m_cosV * m_sinU * m_sinV +
             sigmaW2 * m_cosU * m_cosU * m_sinV * m_sinV + sigmaU2 * m_cosW * m_cosW * m_sinV * m_sinV -
             2. * sigmaV2 * m_cosU * m_cosW * m_sinU * m_sinW - 2. * sigmaU2 * m_cosV * m_cosW * m_sinV * m_sinW +
             sigmaV2 * m_cosU * m_cosU * m_sinW * m_sinW + sigmaU2 * m_cosV * m_cosV * m_sinW * m_sinW);
 
     z = (sigmaW2 * v * m_cosV * m_sinU * m_sinU + sigmaV2 * w * m_cosW * m_sinU * m_sinU - sigmaW2 * v * m_cosU * m_sinU * m_sinV -
             sigmaW2 * u * m_cosV * m_sinU * m_sinV + sigmaW2 * u * m_cosU * m_sinV * m_sinV + sigmaU2 * w * m_cosW * m_sinV * m_sinV -
             sigmaV2 * w * m_cosU * m_sinU * m_sinW - sigmaV2 * u * m_cosW * m_sinU * m_sinW - sigmaU2 * w * m_cosV * m_sinV * m_sinW -
             sigmaU2 * v * m_cosW * m_sinV * m_sinW + sigmaV2 * u * m_cosU * m_sinW * m_sinW + sigmaU2 * v * m_cosV * m_sinW * m_sinW) /
         (sigmaW2 * m_cosV * m_cosV * m_sinU * m_sinU + sigmaV2 * m_cosW * m_cosW * m_sinU * m_sinU - 2. * sigmaW2 * m_cosU * m_cosV * m_sinU * m_sinV +
             sigmaW2 * m_cosU * m_cosU * m_sinV * m_sinV + sigmaU2 * m_cosW * m_cosW * m_sinV * m_sinV -
             2. * sigmaV2 * m_cosU * m_cosW * m_sinU * m_sinW - 2. * sigmaU2 * m_cosV * m_cosW * m_sinV * m_sinW +
             sigmaV2 * m_cosU * m_cosU * m_sinW * m_sinW + sigmaU2 * m_cosV * m_cosV * m_sinW * m_sinW);
 
     const double deltaU(u - LArRotationalTransformationPlugin::YZtoU(y, z));
     const double deltaV(v - LArRotationalTransformationPlugin::YZtoV(y, z));
     const double deltaW(w - LArRotationalTransformationPlugin::YZtoW(y, z));
     chiSquared = ((deltaU * deltaU) / sigmaU2) + ((deltaV * deltaV) / sigmaV2) + ((deltaW * deltaW) / sigmaW2);
 }

void lar_content::LArRotationalTransformationPlugin::GetMinChiSquaredYZ	(	const double	u,
		const double	v,
		const double	w,
		const double	sigmaU,
		const double	sigmaV,
		const double	sigmaW,
		const double	uFit,
		const double	vFit,
		const double	wFit,
		const double	sigmaFit,
		double &	y,
		double &	z,
		double &	chiSquared
	)		const

virtual

Definition at line 166 of file LArRotationalTransformationPlugin.cc.

References m_cosU, m_cosV, m_cosW, m_sinU, m_sinV, m_sinW, YZtoU(), YZtoV(), and YZtoW().

 {
     const double sigmaU2(sigmaU * sigmaU), sigmaV2(sigmaV * sigmaV), sigmaW2(sigmaW * sigmaW), sigmaFit2(sigmaFit * sigmaFit);
 
     // Obtain expression for chi2, differentiate wrt y and z, set both results to zero and solve simultaneously. Here just paste-in result.
     y = (vFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosV * m_sinU + vFit * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosV * m_sinU +
             sigmaU2 * sigmaW2 * sigmaFit2 * v * m_cosU * m_cosV * m_sinU + sigmaW2 * sigmaFit2 * sigmaFit2 * v * m_cosU * m_cosV * m_sinU -
             uFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosV * m_sinU - uFit * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosV * m_sinU -
             sigmaV2 * sigmaW2 * sigmaFit2 * u * m_cosV * m_cosV * m_sinU - sigmaW2 * sigmaFit2 * sigmaFit2 * u * m_cosV * m_cosV * m_sinU +
             wFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosW * m_sinU + wFit * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosW * m_sinU +
             sigmaU2 * sigmaV2 * sigmaFit2 * w * m_cosU * m_cosW * m_sinU + sigmaV2 * sigmaFit2 * sigmaFit2 * w * m_cosU * m_cosW * m_sinU -
             uFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_cosW * m_sinU - uFit * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosW * m_cosW * m_sinU -
             sigmaV2 * sigmaW2 * sigmaFit2 * u * m_cosW * m_cosW * m_sinU - sigmaV2 * sigmaFit2 * sigmaFit2 * u * m_cosW * m_cosW * m_sinU -
             vFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosU * m_sinV - vFit * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosU * m_sinV -
             sigmaU2 * sigmaW2 * sigmaFit2 * v * m_cosU * m_cosU * m_sinV - sigmaW2 * sigmaFit2 * sigmaFit2 * v * m_cosU * m_cosU * m_sinV +
             uFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosV * m_sinV + uFit * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosV * m_sinV +
             sigmaV2 * sigmaW2 * sigmaFit2 * u * m_cosU * m_cosV * m_sinV + sigmaW2 * sigmaFit2 * sigmaFit2 * u * m_cosU * m_cosV * m_sinV +
             wFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosW * m_sinV + wFit * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosW * m_sinV +
             sigmaU2 * sigmaV2 * sigmaFit2 * w * m_cosV * m_cosW * m_sinV + sigmaU2 * sigmaFit2 * sigmaFit2 * w * m_cosV * m_cosW * m_sinV -
             vFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_cosW * m_sinV - vFit * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosW * m_cosW * m_sinV -
             sigmaU2 * sigmaW2 * sigmaFit2 * v * m_cosW * m_cosW * m_sinV - sigmaU2 * sigmaFit2 * sigmaFit2 * v * m_cosW * m_cosW * m_sinV -
             wFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosU * m_sinW - wFit * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosU * m_sinW -
             sigmaU2 * sigmaV2 * sigmaFit2 * w * m_cosU * m_cosU * m_sinW - sigmaV2 * sigmaFit2 * sigmaFit2 * w * m_cosU * m_cosU * m_sinW -
             wFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosV * m_sinW - wFit * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosV * m_sinW -
             sigmaU2 * sigmaV2 * sigmaFit2 * w * m_cosV * m_cosV * m_sinW - sigmaU2 * sigmaFit2 * sigmaFit2 * w * m_cosV * m_cosV * m_sinW +
             uFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosW * m_sinW + uFit * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosU * m_cosW * m_sinW +
             sigmaV2 * sigmaW2 * sigmaFit2 * u * m_cosU * m_cosW * m_sinW + sigmaV2 * sigmaFit2 * sigmaFit2 * u * m_cosU * m_cosW * m_sinW +
             vFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosW * m_sinW + vFit * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosV * m_cosW * m_sinW +
             sigmaU2 * sigmaW2 * sigmaFit2 * v * m_cosV * m_cosW * m_sinW + sigmaU2 * sigmaFit2 * sigmaFit2 * v * m_cosV * m_cosW * m_sinW) /
         (sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosV * m_sinU * m_sinU + sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosV * m_sinU * m_sinU +
             sigmaV2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosV * m_sinU * m_sinU + sigmaW2 * sigmaFit2 * sigmaFit2 * m_cosV * m_cosV * m_sinU * m_sinU +
             sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_cosW * m_sinU * m_sinU + sigmaU2 * sigmaV2 * sigmaFit2 * m_cosW * m_cosW * m_sinU * m_sinU +
             sigmaV2 * sigmaW2 * sigmaFit2 * m_cosW * m_cosW * m_sinU * m_sinU + sigmaV2 * sigmaFit2 * sigmaFit2 * m_cosW * m_cosW * m_sinU * m_sinU -
             2. * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosV * m_sinU * m_sinV - 2. * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosV * m_sinU * m_sinV -
             2. * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosV * m_sinU * m_sinV -
             2. * sigmaW2 * sigmaFit2 * sigmaFit2 * m_cosU * m_cosV * m_sinU * m_sinV + sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosU * m_sinV * m_sinV +
             sigmaU2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosU * m_sinV * m_sinV + sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosU * m_sinV * m_sinV +
             sigmaW2 * sigmaFit2 * sigmaFit2 * m_cosU * m_cosU * m_sinV * m_sinV + sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_cosW * m_sinV * m_sinV +
             sigmaU2 * sigmaV2 * sigmaFit2 * m_cosW * m_cosW * m_sinV * m_sinV + sigmaU2 * sigmaW2 * sigmaFit2 * m_cosW * m_cosW * m_sinV * m_sinV +
             sigmaU2 * sigmaFit2 * sigmaFit2 * m_cosW * m_cosW * m_sinV * m_sinV - 2. * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosW * m_sinU * m_sinW -
             2. * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosU * m_cosW * m_sinU * m_sinW - 2. * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosW * m_sinU * m_sinW -
             2. * sigmaV2 * sigmaFit2 * sigmaFit2 * m_cosU * m_cosW * m_sinU * m_sinW -
             2. * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosW * m_sinV * m_sinW - 2. * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosV * m_cosW * m_sinV * m_sinW -
             2. * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosW * m_sinV * m_sinW -
             2. * sigmaU2 * sigmaFit2 * sigmaFit2 * m_cosV * m_cosW * m_sinV * m_sinW +
             sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosU * m_sinW * m_sinW + sigmaU2 * sigmaV2 * sigmaFit2 * m_cosU * m_cosU * m_sinW * m_sinW +
             sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosU * m_sinW * m_sinW + sigmaV2 * sigmaFit2 * sigmaFit2 * m_cosU * m_cosU * m_sinW * m_sinW +
             sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosV * m_sinW * m_sinW + sigmaU2 * sigmaV2 * sigmaFit2 * m_cosV * m_cosV * m_sinW * m_sinW +
             sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosV * m_sinW * m_sinW + sigmaU2 * sigmaFit2 * sigmaFit2 * m_cosV * m_cosV * m_sinW * m_sinW);
 
     z = (vFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_sinU * m_sinU + vFit * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosV * m_sinU * m_sinU +
             sigmaU2 * sigmaW2 * sigmaFit2 * v * m_cosV * m_sinU * m_sinU + sigmaW2 * sigmaFit2 * sigmaFit2 * v * m_cosV * m_sinU * m_sinU +
             wFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_sinU * m_sinU + wFit * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosW * m_sinU * m_sinU +
             sigmaU2 * sigmaV2 * sigmaFit2 * w * m_cosW * m_sinU * m_sinU + sigmaV2 * sigmaFit2 * sigmaFit2 * w * m_cosW * m_sinU * m_sinU -
             vFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_sinU * m_sinV - vFit * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_sinU * m_sinV -
             sigmaU2 * sigmaW2 * sigmaFit2 * v * m_cosU * m_sinU * m_sinV - sigmaW2 * sigmaFit2 * sigmaFit2 * v * m_cosU * m_sinU * m_sinV -
             uFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_sinU * m_sinV - uFit * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_sinU * m_sinV -
             sigmaV2 * sigmaW2 * sigmaFit2 * u * m_cosV * m_sinU * m_sinV - sigmaW2 * sigmaFit2 * sigmaFit2 * u * m_cosV * m_sinU * m_sinV +
             uFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_sinV * m_sinV + uFit * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosU * m_sinV * m_sinV +
             sigmaV2 * sigmaW2 * sigmaFit2 * u * m_cosU * m_sinV * m_sinV + sigmaW2 * sigmaFit2 * sigmaFit2 * u * m_cosU * m_sinV * m_sinV +
             wFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_sinV * m_sinV + wFit * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosW * m_sinV * m_sinV +
             sigmaU2 * sigmaV2 * sigmaFit2 * w * m_cosW * m_sinV * m_sinV + sigmaU2 * sigmaFit2 * sigmaFit2 * w * m_cosW * m_sinV * m_sinV -
             wFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_sinU * m_sinW - wFit * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_sinU * m_sinW -
             sigmaU2 * sigmaV2 * sigmaFit2 * w * m_cosU * m_sinU * m_sinW - sigmaV2 * sigmaFit2 * sigmaFit2 * w * m_cosU * m_sinU * m_sinW -
             uFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_sinU * m_sinW - uFit * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosW * m_sinU * m_sinW -
             sigmaV2 * sigmaW2 * sigmaFit2 * u * m_cosW * m_sinU * m_sinW - sigmaV2 * sigmaFit2 * sigmaFit2 * u * m_cosW * m_sinU * m_sinW -
             wFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_sinV * m_sinW - wFit * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_sinV * m_sinW -
             sigmaU2 * sigmaV2 * sigmaFit2 * w * m_cosV * m_sinV * m_sinW - sigmaU2 * sigmaFit2 * sigmaFit2 * w * m_cosV * m_sinV * m_sinW -
             vFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_sinV * m_sinW - vFit * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosW * m_sinV * m_sinW -
             sigmaU2 * sigmaW2 * sigmaFit2 * v * m_cosW * m_sinV * m_sinW - sigmaU2 * sigmaFit2 * sigmaFit2 * v * m_cosW * m_sinV * m_sinW +
             uFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_sinW * m_sinW + uFit * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosU * m_sinW * m_sinW +
             sigmaV2 * sigmaW2 * sigmaFit2 * u * m_cosU * m_sinW * m_sinW + sigmaV2 * sigmaFit2 * sigmaFit2 * u * m_cosU * m_sinW * m_sinW +
             vFit * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_sinW * m_sinW + vFit * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosV * m_sinW * m_sinW +
             sigmaU2 * sigmaW2 * sigmaFit2 * v * m_cosV * m_sinW * m_sinW + sigmaU2 * sigmaFit2 * sigmaFit2 * v * m_cosV * m_sinW * m_sinW) /
         (sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosV * m_sinU * m_sinU + sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosV * m_sinU * m_sinU +
             sigmaV2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosV * m_sinU * m_sinU + sigmaW2 * sigmaFit2 * sigmaFit2 * m_cosV * m_cosV * m_sinU * m_sinU +
             sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_cosW * m_sinU * m_sinU + sigmaU2 * sigmaV2 * sigmaFit2 * m_cosW * m_cosW * m_sinU * m_sinU +
             sigmaV2 * sigmaW2 * sigmaFit2 * m_cosW * m_cosW * m_sinU * m_sinU + sigmaV2 * sigmaFit2 * sigmaFit2 * m_cosW * m_cosW * m_sinU * m_sinU -
             2. * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosV * m_sinU * m_sinV - 2. * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosV * m_sinU * m_sinV -
             2. * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosV * m_sinU * m_sinV -
             2. * sigmaW2 * sigmaFit2 * sigmaFit2 * m_cosU * m_cosV * m_sinU * m_sinV + sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosU * m_sinV * m_sinV +
             sigmaU2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosU * m_sinV * m_sinV + sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosU * m_sinV * m_sinV +
             sigmaW2 * sigmaFit2 * sigmaFit2 * m_cosU * m_cosU * m_sinV * m_sinV + sigmaU2 * sigmaV2 * sigmaW2 * m_cosW * m_cosW * m_sinV * m_sinV +
             sigmaU2 * sigmaV2 * sigmaFit2 * m_cosW * m_cosW * m_sinV * m_sinV + sigmaU2 * sigmaW2 * sigmaFit2 * m_cosW * m_cosW * m_sinV * m_sinV +
             sigmaU2 * sigmaFit2 * sigmaFit2 * m_cosW * m_cosW * m_sinV * m_sinV - 2. * sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosW * m_sinU * m_sinW -
             2. * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosU * m_cosW * m_sinU * m_sinW - 2. * sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosW * m_sinU * m_sinW -
             2. * sigmaV2 * sigmaFit2 * sigmaFit2 * m_cosU * m_cosW * m_sinU * m_sinW -
             2. * sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosW * m_sinV * m_sinW - 2. * sigmaU2 * sigmaV2 * sigmaFit2 * m_cosV * m_cosW * m_sinV * m_sinW -
             2. * sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosW * m_sinV * m_sinW -
             2. * sigmaU2 * sigmaFit2 * sigmaFit2 * m_cosV * m_cosW * m_sinV * m_sinW +
             sigmaU2 * sigmaV2 * sigmaW2 * m_cosU * m_cosU * m_sinW * m_sinW + sigmaU2 * sigmaV2 * sigmaFit2 * m_cosU * m_cosU * m_sinW * m_sinW +
             sigmaV2 * sigmaW2 * sigmaFit2 * m_cosU * m_cosU * m_sinW * m_sinW + sigmaV2 * sigmaFit2 * sigmaFit2 * m_cosU * m_cosU * m_sinW * m_sinW +
             sigmaU2 * sigmaV2 * sigmaW2 * m_cosV * m_cosV * m_sinW * m_sinW + sigmaU2 * sigmaV2 * sigmaFit2 * m_cosV * m_cosV * m_sinW * m_sinW +
             sigmaU2 * sigmaW2 * sigmaFit2 * m_cosV * m_cosV * m_sinW * m_sinW + sigmaU2 * sigmaFit2 * sigmaFit2 * m_cosV * m_cosV * m_sinW * m_sinW);
 
     const double outputU(LArRotationalTransformationPlugin::YZtoU(y, z));
     const double outputV(LArRotationalTransformationPlugin::YZtoV(y, z));
     const double outputW(LArRotationalTransformationPlugin::YZtoW(y, z));
 
     const double deltaU(u - outputU), deltaV(v - outputV), deltaW(w - outputW);
     const double deltaUFit(uFit - outputU), deltaVFit(vFit - outputV), deltaWFit(wFit - outputW);
 
     chiSquared = ((deltaU * deltaU) / sigmaU2) + ((deltaV * deltaV) / sigmaV2) + ((deltaW * deltaW) / sigmaW2) +
         ((deltaUFit * deltaUFit) / sigmaFit2) + ((deltaVFit * deltaVFit) / sigmaFit2) + ((deltaWFit * deltaWFit) / sigmaFit2);
 }

StatusCode lar_content::LArRotationalTransformationPlugin::Initialize ( )

private

Definition at line 275 of file LArRotationalTransformationPlugin.cc.

References m_cosU, m_cosV, m_cosW, m_maxAngularDiscrepancyU, m_maxAngularDiscrepancyV, m_maxAngularDiscrepancyW, m_maxSigmaDiscrepancy, m_sinU, m_sinUminusW, m_sinV, m_sinVminusU, m_sinW, m_sinWminusV, m_thetaU, m_thetaV, and m_thetaW.

 {
     const LArTPCMap &larTPCMap(this->GetPandora().GetGeometry()->GetLArTPCMap());
 
     if (larTPCMap.empty())
     {
         std::cout << "LArRotationalTransformationPlugin::Initialize - LArTPC description not registered with Pandora as required " << std::endl;
         return STATUS_CODE_NOT_INITIALIZED;
     }
 
     const LArTPC *const pFirstLArTPC(larTPCMap.begin()->second);
     m_thetaU = pFirstLArTPC->GetWireAngleU();
     m_thetaV = pFirstLArTPC->GetWireAngleV();
     m_thetaW = pFirstLArTPC->GetWireAngleW();
     const double sigmaUVW(pFirstLArTPC->GetSigmaUVW());
 
     m_sinU = std::sin(m_thetaU);
     m_sinV = std::sin(m_thetaV);
     m_sinW = std::sin(m_thetaW);
     m_cosU = std::cos(m_thetaU);
     m_cosV = std::cos(m_thetaV);
     m_cosW = std::cos(m_thetaW);
 
     m_sinVminusU = std::sin(m_thetaV - m_thetaU);
     m_sinWminusV = std::sin(m_thetaW - m_thetaV);
     m_sinUminusW = std::sin(m_thetaU - m_thetaW);
 
     if ((std::fabs(m_sinVminusU) < std::numeric_limits<double>::epsilon()) ||
         (std::fabs(m_sinWminusV) < std::numeric_limits<double>::epsilon()) || (std::fabs(m_sinUminusW) < std::numeric_limits<double>::epsilon()))
     {
         std::cout << "LArRotationalTransformationPlugin::Initialize - Equal wire angles; Plugin does not support provided LArTPC configurations. "
                   << std::endl;
         return STATUS_CODE_INVALID_PARAMETER;
     }
 
     for (const LArTPCMap::value_type &mapEntry : larTPCMap)
     {
         const LArTPC *const pLArTPC(mapEntry.second);
 
         if ((std::fabs(m_thetaU - pLArTPC->GetWireAngleU()) > m_maxAngularDiscrepancyU) ||
             (std::fabs(m_thetaV - pLArTPC->GetWireAngleV()) > m_maxAngularDiscrepancyV) ||
             (std::fabs(m_thetaW - pLArTPC->GetWireAngleW()) > m_maxAngularDiscrepancyW) ||
             (std::fabs(sigmaUVW - pLArTPC->GetSigmaUVW()) > m_maxSigmaDiscrepancy))
         {
             std::cout << "LArRotationalTransformationPlugin::Initialize - Dissimilar drift volumes; Plugin does not support provided LArTPC configurations. "
                       << std::endl;
             return STATUS_CODE_INVALID_PARAMETER;
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

pandora::StatusCode lar_content::LArRotationalTransformationPlugin::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 330 of file LArRotationalTransformationPlugin.cc.

References m_maxAngularDiscrepancyU, m_maxAngularDiscrepancyV, m_maxAngularDiscrepancyW, and m_maxSigmaDiscrepancy.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxAngularDiscrepancyU", m_maxAngularDiscrepancyU));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxAngularDiscrepancyV", m_maxAngularDiscrepancyV));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxAngularDiscrepancyW", m_maxAngularDiscrepancyW));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxSigmaDiscrepancy", m_maxSigmaDiscrepancy));
 
     return STATUS_CODE_SUCCESS;
 }

double lar_content::LArRotationalTransformationPlugin::UVtoW	(	const double	u,
		const double	v
	)		const

virtual

Definition at line 50 of file LArRotationalTransformationPlugin.cc.

References m_sinUminusW, m_sinVminusU, and m_sinWminusV.

 {
     return (-1. * (u * m_sinWminusV + v * m_sinUminusW) / m_sinVminusU);
 }

double lar_content::LArRotationalTransformationPlugin::UVtoY	(	const double	u,
		const double	v
	)		const

virtual

Definition at line 71 of file LArRotationalTransformationPlugin.cc.

References m_cosU, m_cosV, and m_sinVminusU.

 {
     return ((u * m_cosV - v * m_cosU) / m_sinVminusU);
 }

double lar_content::LArRotationalTransformationPlugin::UVtoZ	(	const double	u,
		const double	v
	)		const

virtual

Definition at line 78 of file LArRotationalTransformationPlugin.cc.

References m_sinU, m_sinV, and m_sinVminusU.

 {
     return ((u * m_sinV - v * m_sinU) / m_sinVminusU);
 }

double lar_content::LArRotationalTransformationPlugin::UWtoY	(	const double	u,
		const double	w
	)		const

virtual

Definition at line 85 of file LArRotationalTransformationPlugin.cc.

References m_cosU, m_cosW, and m_sinUminusW.

 {
     return ((w * m_cosU - u * m_cosW) / m_sinUminusW);
 }

double lar_content::LArRotationalTransformationPlugin::UWtoZ	(	const double	u,
		const double	w
	)		const

virtual

Definition at line 92 of file LArRotationalTransformationPlugin.cc.

References m_sinU, m_sinUminusW, and m_sinW.

 {
     return ((w * m_sinU - u * m_sinW) / m_sinUminusW);
 }

double lar_content::LArRotationalTransformationPlugin::VWtoU	(	const double	v,
		const double	w
	)		const

virtual

Definition at line 57 of file LArRotationalTransformationPlugin.cc.

References m_sinUminusW, m_sinVminusU, and m_sinWminusV.

 {
     return (-1. * (v * m_sinUminusW + w * m_sinVminusU) / m_sinWminusV);
 }

double lar_content::LArRotationalTransformationPlugin::VWtoY	(	const double	v,
		const double	w
	)		const

virtual

Definition at line 99 of file LArRotationalTransformationPlugin.cc.

References m_cosV, m_cosW, and m_sinWminusV.

 {
     return ((v * m_cosW - w * m_cosV) / m_sinWminusV);
 }

double lar_content::LArRotationalTransformationPlugin::VWtoZ	(	const double	v,
		const double	w
	)		const

virtual

Definition at line 106 of file LArRotationalTransformationPlugin.cc.

References m_sinV, m_sinW, and m_sinWminusV.

 {
     return ((v * m_sinW - w * m_sinV) / m_sinWminusV);
 }

double lar_content::LArRotationalTransformationPlugin::WUtoV	(	const double	w,
		const double	u
	)		const

virtual

Definition at line 64 of file LArRotationalTransformationPlugin.cc.

References m_sinUminusW, m_sinVminusU, and m_sinWminusV.

 {
     return (-1. * (u * m_sinWminusV + w * m_sinVminusU) / m_sinUminusW);
 }

double lar_content::LArRotationalTransformationPlugin::YZtoU	(	const double	y,
		const double	z
	)		const

virtual

Definition at line 113 of file LArRotationalTransformationPlugin.cc.

References m_cosU, and m_sinU.

Referenced by GetMinChiSquaredYZ().

 {
     return (z * m_cosU - y * m_sinU);
 }

double lar_content::LArRotationalTransformationPlugin::YZtoV	(	const double	y,
		const double	z
	)		const

virtual

Definition at line 120 of file LArRotationalTransformationPlugin.cc.

References m_cosV, and m_sinV.

Referenced by GetMinChiSquaredYZ().

 {
     return (z * m_cosV - y * m_sinV);
 }

double lar_content::LArRotationalTransformationPlugin::YZtoW	(	const double	y,
		const double	z
	)		const

virtual

Definition at line 127 of file LArRotationalTransformationPlugin.cc.

References m_cosW, and m_sinW.

Referenced by GetMinChiSquaredYZ().

 {
     return (z * m_cosW - y * m_sinW);
 }

Member Data Documentation

double lar_content::LArRotationalTransformationPlugin::m_cosU

private

cos(thetaU)

Definition at line 58 of file LArRotationalTransformationPlugin.h.

Referenced by GetMinChiSquaredYZ(), Initialize(), UVtoY(), UWtoY(), and YZtoU().

double lar_content::LArRotationalTransformationPlugin::m_cosV

private

cos(thetaV)

Definition at line 59 of file LArRotationalTransformationPlugin.h.

Referenced by GetMinChiSquaredYZ(), Initialize(), UVtoY(), VWtoY(), and YZtoV().

double lar_content::LArRotationalTransformationPlugin::m_cosW

private

cos(thetaW)

Definition at line 60 of file LArRotationalTransformationPlugin.h.

Referenced by GetMinChiSquaredYZ(), Initialize(), UWtoY(), VWtoY(), and YZtoW().

double lar_content::LArRotationalTransformationPlugin::m_maxAngularDiscrepancyU

private

Maximum allowed difference between u wire angles between LArTPCs.

Definition at line 65 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize(), and ReadSettings().

double lar_content::LArRotationalTransformationPlugin::m_maxAngularDiscrepancyV

private

Maximum allowed difference between v wire angles between LArTPCs.

Definition at line 66 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize(), and ReadSettings().

double lar_content::LArRotationalTransformationPlugin::m_maxAngularDiscrepancyW

private

Maximum allowed difference between w wire angles between LArTPCs.

Definition at line 67 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize(), and ReadSettings().

double lar_content::LArRotationalTransformationPlugin::m_maxSigmaDiscrepancy

private

Maximum allowed difference between like wire sigma values between LArTPCs.

Definition at line 68 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize(), and ReadSettings().

double lar_content::LArRotationalTransformationPlugin::m_sinU

private

sin(thetaU)

Definition at line 55 of file LArRotationalTransformationPlugin.h.

Referenced by GetMinChiSquaredYZ(), Initialize(), UVtoZ(), UWtoZ(), and YZtoU().

double lar_content::LArRotationalTransformationPlugin::m_sinUminusW

private

sin(thetaU - thetaW)

Definition at line 63 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize(), UVtoW(), UWtoY(), UWtoZ(), VWtoU(), and WUtoV().

double lar_content::LArRotationalTransformationPlugin::m_sinV

private

sin(thetaV)

Definition at line 56 of file LArRotationalTransformationPlugin.h.

Referenced by GetMinChiSquaredYZ(), Initialize(), UVtoZ(), VWtoZ(), and YZtoV().

double lar_content::LArRotationalTransformationPlugin::m_sinVminusU

private

sin(thetaV - thetaU)

Definition at line 61 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize(), UVtoW(), UVtoY(), UVtoZ(), VWtoU(), and WUtoV().

double lar_content::LArRotationalTransformationPlugin::m_sinW

private

sin(thetaW)

Definition at line 57 of file LArRotationalTransformationPlugin.h.

Referenced by GetMinChiSquaredYZ(), Initialize(), UWtoZ(), VWtoZ(), and YZtoW().

double lar_content::LArRotationalTransformationPlugin::m_sinWminusV

private

sin(thetaW - thetaV)

Definition at line 62 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize(), UVtoW(), VWtoU(), VWtoY(), VWtoZ(), and WUtoV().

double lar_content::LArRotationalTransformationPlugin::m_thetaU

private

inclination of U wires (radians)

Definition at line 51 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize().

double lar_content::LArRotationalTransformationPlugin::m_thetaV

private

inclination of V wires (radians)

Definition at line 52 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize().

double lar_content::LArRotationalTransformationPlugin::m_thetaW

private

inclination of W wires (radians)

Definition at line 53 of file LArRotationalTransformationPlugin.h.

Referenced by Initialize().

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

larpandoracontent/v04_08_01/source/larpandoracontent/LArPlugins/LArRotationalTransformationPlugin.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArPlugins/LArRotationalTransformationPlugin.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation