dashdotrobot/bike-wheel-calc

Stress analysis of bicycle wheels implemented in Python using NumPy

bike-wheel-calc's Issues

Write documentation

Fix I11, I22, I33 once and for all

The original curved-beam FEM code used a different coordinate system:

• I11 = torsional constant (J)
• I22 = 2nd moment for lateral bending
• I33 = 2nd moment for radial bending

The thesis uses the following:

• J = torsion constant
• I_1 = 2nd moment for radial bending
• I_2 = 2nd moment for lateral bending

Update BicycleWheel, ModeMatrix, and BicycleWheelFEM to match the standards developed in my PhD thesis.

Calculate mass and inertia properties

Spoke and Rim should have a density property. BicycleWheel should be able to calculate its mass and rotational inertia.

Get T_c from generalized eigenvalue problem instead of line search

Instead of hunting for singular matrix configurations near T_c_theor, the buckling tension should be obtained from the generalized eigenvalue problem:

K_rim_matl + K_spk_matl + T_bar*(K_spk_matl - K_rim_matl) = 0

This should be considerably more robust than iteratively tuning T_bar until the condition number is maximized.

Constructor for Rim contains mutable default argument

A mutable literal (in this case, the empty dictionary {}) causes problems when used as the default argument. An object is created the first time the function is called, and then the same object is referenced thereafter.

Instead, use sec_params=None in the argument list and

if sec_params is None:
    self.sec_params = {}
else:
    self.sec_params = sec_params

Refactor curved-beam FEM code into sub-module

Create basic test suite

Make treatment of tension consistent

There are some examples in the thesis code where tension must be removed, and then re-applied. Functions which depend on tension (such as spoke stiffness or rim stiffness) should include a binary flag, tension=[True|False], and if tension=True the function should use the Spoke.tension property. Tension should always be "applied" to the wheel using BicycleWheel.apply_tension().

Make bikewheelcalc installable using setuptools

Perform some validation on BicycleWheel properties

Catch illegal values (like zero radius, negative stiffness, or hub offset outside the flange widths) and throw appropriate exceptions.

Merge stiffness calculation functions into mode_matrix, or remove

example_stand_on_spokes.py

Dear Matthew,

I got your code to run properly and find the results interesting.

In your example "example_stand_on_spokes.py"

What is the reasoning to add forces to node 1 and 35.

Wouldn't it be closer to "real world" to just put the force on node 0?

FYI, I'm interested in this is because I cannot find any quality reasoning for the spoke count in commercial available bicycle wheels and the information supplied by wheel builders. Wheel builders on their websites have this dropdown box to select front/rear wheel spoke count. Why choose 20/24, 24/28 or 28/32? If you are a heavier rider, put more spokes. Seems logical, but how much exactly? These are the kind of questions I like to find an answer to. Besides that, bicycle wheels are an amazingly complex mechanical structure. It's intriguing :-)

Regards

Bart

Move stiffness and buckling calculations out of mode_matrix.py

Allow different lacing pattern on DS and NDS

self is not defined

bike-wheel-calc/bikewheelcalc/theory.py

Line 108 in 6fc380c

ns = len(self.wheel.spokes)

Update README

Use curvature-corrected section properties

Section properties need to be scaled by a factor of Rs/Rc to account for the the difference in the path integral along the beam axis and centroidal axis, and the use of Rc as the average curvature across the section instead of Rs.

Section properties passed to the Rim constructor (and when accessed as rim.area, rim.I_rad, etc) are assumed to be the straight-beam properties. Therefore, rather than applying the correction in the Rim construction, correction will be applied whenever section properties are used so that the user can change y0 and have the results change in an expected fashion. Thus rims with the same extruded profile but different radii can be easily compared by simply changing R.

Sample files wont run

Extract from example_stand_on_spokes.py

import bikewheelcalc as bc
wheel.hub = wheel.Hub(diam1=0.04, width1=0.03)

produces: AttributeError: BicycleWheel instance has no attribute 'Hub'

corrected to:

wheel.hub = bc.Hub(diam1=0.04, width1=0.03)

Calculate spoke tightening influence functions

Upgrade to Python3 compatibility

Update K_rim terms to match new V_rim formulation

Code error | example_stiffness

Dear Dashdotrobot,

I came across your code and love the work. Currently I'm trying to fully understand the code, which is quite a challenge. I have completed by BSc. in aerospace engineering and an currently doing a Msc. I'm quite proficient in Matlab but Python is quite new for me. The examples are helpful but I can't get example_stiffness.py to run properly. I get an error:

Traceback (most recent call last):
File "\example_stiffness.py", line 46, in
fem = bc.BicycleWheelFEM(g, r_sec, s_sec)
File "C:\bikewheelfem.py", line 705, in init
offset = geom.lace_offset[e]
IndexError: index 0 is out of bounds for axis 0 with size 0

Could you indicate to as what the issue might be?

Thank you for sharing the code!

Best regards,

Matthijs

Update examples to work with new code

Geometric stiffness is overestimated for calculating moments

The current implementation overestimates the effective structural stiffness when the majority (or all) of the stiffness comes from tension stiffness. The current implementation uses T/L (1 - nn) as the geometric stiffness. The effective torsional stiffness of a planar wheel with radial spokes should be

k_tor = R^2 * ns * T_0*(1/L - 1/R)

The current implementation gives (approximately)

k_tor = R^2 * n_s * T_0*(1/L)

The moment about the wheel center exerted by a spoke is

m = (r_n) x (Tn)

The linearized moment increment has three terms:

dm_0 = r_n x (dT n_0 + T_0 dn) + dr_n x (T_0 n_0)

The first two terms are the original moment crossed with the force increment (given by the force-stiffness matrix). The third term is the spoke force in the prestressed configuration crossed with the increment in the moment arm. The increment in moment arm is exactly equal to du_n.

The solution is the following:

1. Derive the linearized force increment and moment increment (about wheel center)
2. Find an equivalent force/couple system with force increment located at S.
3. Calculate strain energy from dW = f_sdu_s + m_sd(omega)_s
4. As before, neglect terms in omega_s which depend on derivatives of u. (This should be more rigorously justified).

Remove "shebang" lines

Correctly calculate spoke offset vector with radial offset