Rotor.run_unbalance_response(node, unbalance_magnitude, unbalance_phase, frequency=None, modes=None, cluster_points=False, num_modes=12, num_points=10, rtol=0.005)#

Unbalanced response for a mdof system.

This method returns the unbalanced response for a mdof system given magnitide and phase of the unbalance, the node where it’s applied and a frequency range.

Available plotting methods:

.plot() .plot_magnitude() .plot_phase() .plot_polar_bode() .plot_deflected_shape() .plot_bending_moment() .plot_deflected_shape_3d() .plot_deflected_shape_2d()

nodelist, int

Node where the unbalance is applied.

unbalance_magnitudelist, float, pint.Quantity

Unbalance magnitude (kg.m).

unbalance_phaselist, float, pint.Quantity

Unbalance phase (rad).

frequencylist, float, pint.Quantity

Array with the desired range of frequencies (rad/s).

modeslist, optional

Modes that will be used to calculate the frequency response (all modes will be used if a list is not given).

cluster_pointsbool, optional

boolean to activate the automatic frequency spacing method. If True, the method uses _clustering_points() to create an speed_range. Default is False

num_pointsint, optional

The number of points generated per critical speed. The method set the same number of points for slightly less and slightly higher than the natural circular frequency. It means there’ll be num_points greater and num_points smaller than a given critical speed. num_points may be between 2 and 12. Anything above this range defaults to 10 and anything below this range defaults to 4. The default is 10.


The number of eigenvalues and eigenvectors to be calculated using ARPACK. It also defines the range for the output array, since the method generates points only for the critical speed calculated by run_critical_speed(). Default is 12.

rtolfloat, optional

Tolerance (relative) for termination. Applied to scipy.optimize.newton to calculate the approximated critical speeds. Default is 0.005 (0.5%).


For more information on attributes and methods available see: ross.ForcedResponseResults


>>> import ross as rs
>>> rotor = rs.rotor_example()
>>> speed = np.linspace(0, 1000, 101)
>>> response = rotor.run_unbalance_response(node=3,
...                                         unbalance_magnitude=10.0,
...                                         unbalance_phase=0.0,
...                                         frequency=speed)

Return the response amplitude >>> abs(response.forced_resp) # doctest: +ELLIPSIS array([[0.00000000e+00, 5.06073311e-04, 2.10044826e-03, …

Return the response phase >>> np.angle(response.forced_resp) # doctest: +ELLIPSIS array([[ 0.00000000e+00, …

Using clustered points option. Set cluster_points=True and choose how many modes the method must search and how many points to add just before and after each critical speed.

>>> response2 = rotor.run_unbalance_response(
...     node=3, unbalance_magnitude=0.01, unbalance_phase=0.0, cluster_points=True, num_points=5
... )
>>> response2.speed_range.shape

plot unbalance response: >>> probe_node = 3 >>> probe_angle = np.pi / 2 >>> probe_tag = “my_probe” # optional >>> fig = response.plot(probe=[(probe_node, probe_angle, probe_tag)])

plot response for major or minor axis: >>> probe_node = 3 >>> probe_angle = “major” # for major axis >>> # probe_angle = “minor” # for minor axis >>> probe_tag = “my_probe” # optional >>> fig = response.plot(probe=[(probe_node, probe_angle, probe_tag)])

To plot velocity and acceleration responses, you must change amplitude_units from “[length]” units to “[length]/[time]” or “[length]/[time] ** 2” respectively Plotting velocity response >>> fig = response.plot( … probe=[(probe_node, probe_angle)], … amplitude_units=”m/s” … )

Plotting acceleration response >>> fig = response.plot( … probe=[(probe_node, probe_angle)], … amplitude_units=”m/s**2” … )

Plotting deflected shape configuration Speed value must be in speed_range. >>> value = 600 >>> fig = response.plot_deflected_shape(speed=value)