Modifica di Transverse Hinge Axis (sezione)

===Mathematical Formalism: Localization Error of HA from Chord <math>s</math> and Sagitta <math>h</math>===

The script simulates the effect of noise on the measurement of the distance between a fixed point and a hinge axis (HA). A distribution of errors caused by noise added to the data is generated, and the 72nd percentile of these errors is analyzed.

The radius (<math>r</math>) is the radius of the circle on which the initial point lies, given by <math>r = 26.30</math> mm. The arc length <math>s</math> is the length of the arc on which the point moves, equal to <math>s = 12.02</math> mm. The angle <math>\alpha</math> is the angle corresponding to the arc, in radians, calculated as:

<math>\alpha = \frac{s}{r}</math>

'''<math>r_{\text{var}}</math>''': This is the distance of the starting point from the hinge axis, equal to <math>r_{\text{var}} = 26.30</math> mm. To calculate the start and end points, we proceed by calculating the point '''<math>p_{\text{start}}</math>''', located at a distance <math>r_{\text{var}}</math> along the <math>x</math>-axis:

<math>p_{\text{start}} = \begin{pmatrix} r_{\text{var}} \ 0 \end{pmatrix}</math>

The terminal point '''<math>p_{\text{end}}</math>''' is defined as the final point after the rotation of an angle <math>\alpha</math>, calculated as:

<math>p_{\text{end}} = \begin{pmatrix} r_{\text{var}} \cos(\alpha) \ r_{\text{var}} \sin(\alpha) \end{pmatrix}</math>

The length of the chord '''<math>s_{\text{ref}}</math>''' that connects the initial and final points is given by:

<math>s_{\text{ref}} = \sqrt{(p_{\text{end},x} - p_{\text{start},x})^2 + (p_{\text{end},y} - p_{\text{start},y})^2}</math>

The height of the arc (sagitta) '''<math>h_{\text{ref}}</math>''' is calculated as:

<math>h_{\text{ref}} = \frac{s_{\text{ref}}}{2} \tan\left(\frac{\alpha}{4}\right)</math>

At this point, Gaussian-distributed noise with a standard deviation of 0.01 mm is generated. The noise is added to the start and end points as follows:

<math>pn_{\text{start}} = p_{\text{start}} + noise_{\text{start}}</math>

<math>pn_{\text{end}} = p_{\text{end}} + noise_{\text{end}}</math>

This extends or shortens the chord '''<math>s</math>''' as follows:

<math>\sqrt{(pn_{end,x} - pn_{start,x})^2 + (pn_{end,y} - pn_{start,y})^2}</math>

While the noise on the sagitta '''<math>h_{\text{noise}}</math>''' is calculated as:

<math>h_{\text{noise}} = h_{\text{ref}} + \text{noise}</math>

Once the errors for the chord '''<math>s</math>''' and the sagitta '''<math>h</math>''' are calculated, we can compute the noisy radius '''<math>r_{\text{noise}}</math>''' by reusing the formula:

<math>r_{\text{noise}} = \frac{4 h_{\text{noise}}^2 + s^2}{8 h_{\text{noise}}}</math>

The difference between the radius calculated with noise and the original distance <math>r_{\text{var}}</math> is given by:

<math>\delta r_{\text{noise}} = \left| r_{\text{noise}} - r_{\text{var}} \right|</math>

At the 72nd percentile of the measurement error, this represents the value below which 72% of the observed errors fall.

====Python script: HA localization error from chord <math>s</math> and sagitta <math>h</math>====

<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt

# Constants
r = 90.7  # Radius in mm
s = 12.02  # Length of Arc in mm
alpha = s / r  # Angle in radians
r_var = 26.33  # Distance from the hinge axis in mm

# Calculate start and end points
p_start = np.array([r_var, 0])
p_end = np.array([r_var * np.cos(alpha), r_var * np.sin(alpha)])

# Calculate reference values
s_ref = np.sqrt((p_end[0] - p_start[0])**2 + (p_end[1] - p_start[1])**2)
h_ref = s_ref / 2 * np.tan(alpha / 4)
scale_noise = 0.01  # Reduced noise in mm
samples = 1000  # number of Gaussian samples
noise = scale_noise * np.random.randn(5, samples)

# Add noise to points
pn_start = np.array([p_start[0] + noise[0, :], p_start[1] + noise[1, :]])
pn_end = np.array([p_end[0] + noise[2, :], p_end[1] + noise[3, :]])

# Calculate length of the chord (s) and sagitta (height) (h_noise)
s = np.sqrt((pn_end[0, :] - pn_start[0, :])**2 + (pn_end[1, :] - pn_start[1, :])**2)
h_noise = h_ref + noise[4, :]
r_noise = (4 * h_noise**2 + s**2) / (8 * h_noise)
delta_r_noise = np.abs(r_noise - r_var)

# Calculate the 72nd quantile of the error
error_quantile_reduced_noise = np.quantile(delta_r_noise, 0.72)
print(f'Errore (72° percentile) con rumore ridotto: {error_quantile_reduced_noise:.2f} mm')

# Optional: Plot the distribution of errors
plt.hist(delta_r_noise, bins=30, edgecolor='k', alpha=0.7)
plt.axvline(error_quantile_reduced_noise, color='r', linestyle='dashed', linewidth=1)
plt.title('Distribuzione degli errori di misurazione')
plt.xlabel('Errore (mm)')
plt.ylabel('Frequenza')
plt.show()
</syntaxhighlight>