Tutorial - Static and Modal Analyzes#

This is the second part of a basic tutorial on how to use ROSS (rotordynamics open-source software), a Python library for rotordynamic analysis. In this tutorial, you will learn how to run several rotordynamic analyzes with your rotor model.

To get results, we always have to use one of the .run_ methods available for a rotor object. These methods will return objects that store the analysis results and that also have plot methods available. These methods will use the plotly library to make graphs common to a rotordynamic analysis.

Rotor model#

First, let’s recover the rotor model built in the previous tutorial.

import ross as rs
import numpy as np

# uncomment the lines below if you are having problems with plots not showing
# import plotly.io as pio
# pio.renderers.default = "notebook"
rotor3 = rs.compressor_example()
node_increment = 5
rotor3.plot_rotor(nodes=node_increment)

Rotor Analyses#

In the last tutorial we have learnt how to create a rotor model with Rotor class. Now, we’ll use the same class to run the simulation. There’re some methods, most of them with the prefix run_ you can use to run the rotordynamics analyses.

For Most of the methods, you can use the command .plot() to display a graphical visualization of the results (e.g run_campbel().plot(), run_modal().plot_mode_3d(mode)).

ROSS offers the following analyses:

  • Static analysis

  • Modal analysis

  • Campbell Diagram

Plotly library#

ROSS uses Plotly for plotting results. All the figures can be stored and manipulated following Plotly API.

The following sections presents the results and how to return the Plotly Figures.

1.1 Static Analysis#

This method runs the static analysis for the rotor. It calculate the static deformation due the gravity effects (shaft and disks weight). It also returns the bending moment and shearing force on each node, and you can return a free-body-diagram representation for the rotor, with the self weight, disks weight and reaction forces on bearings displayed.

1.1.1 Running static analysis#

To run the simulation, use the .run_static() method. You can define a variable to store the results.

Storing the results, it’s possible to return the following arrays:

  • disk_forces_nodal

  • disk_forces_tag

  • bearing_forces_nodal

  • bearing_forces_tag

  • disp_y

  • Vx

  • Bm

static = rotor3.run_static()

Returning forces#

Disk forces#

  • .disk_forces_nodal: Returns a dictionaty expliciting the node where the disk is located and the force value.

  • .disk_forces_tag: Returns a dictionaty expliciting the the disk tag is located and the force value.

Bearing forces#

  • .bearing_forces_nodal: Returns a dictionaty expliciting the node where the bearing is located and the force value.

  • .bearing_forces_tag: Returns a dictionaty expliciting the the bearing tag is located and the force value.

print("Disk forces - nodes")
print(rotor3.disk_forces_nodal)
print("")
print("Disk forces - tags")
print(rotor3.disk_forces_tag)

print("")
print("Bearing forces - nodes")
print(rotor3.bearing_forces_nodal)
print("")
print("Bearing forces - tags")
print(rotor3.bearing_forces_tag)
Disk forces - nodes
{'node_3': 148.2741036647235, 'node_20': 67.76283441291268, 'node_23': 67.95896417966495, 'node_26': 68.15509394641724, 'node_29': 68.44928859654566, 'node_32': 68.0570290630411, 'node_35': 68.25315882979338}

Disk forces - tags
{'Disk 0': 148.2741036647235, 'Disk 1': 67.76283441291268, 'Disk 2': 67.95896417966495, 'Disk 3': 68.15509394641724, 'Disk 4': 68.44928859654566, 'Disk 5': 68.0570290630411, 'Disk 6': 68.25315882979338}

Bearing forces - nodes
{'node_7': 1216.2827567759402, 'node_48': 1204.6514712814594}

Bearing forces - tags
{'Bearing 0': 1216.2827567759402, 'Bearing 1': 1204.6514712814594}

Other attributes from static analysis#

  • .Vx: Shearing force array

  • .Bm: Bending moment array

  • .deformation Displacement in Y direction

1.1.2 Plotting results#

With results stored, you can use some methods to plot the results. Currently, there’re four plots you can retrieve from static analysis:

  • .plot_free_body_diagram()

  • .plot_deformation()

  • .plot_shearing_force()

  • .plot_bending_moment()

Plotting free-body-diagram#

static.plot_free_body_diagram()

Plotting deformation#

static.plot_deformation()

Plotting shearing force diagram#

static.plot_shearing_force()

Plotting bending moment diagram#

static.plot_bending_moment()

1.3 Campbell Diagram#

Also called “whirl speed map” in rotordynamics, ROSS calculate and plots the modes’ damped eigenvalues and the logarithmic decrement as a function of rotor speed.

To run the Campbell Diagram, use the command .run_campbell(). The user must input an array of speeds, which will be iterated to calculate each point on the graph.

This method returns the damped natural frequencies, logarithmic decrement and the whirl values (values indicating the whirl direction: backward or forward).

1.3.1 Running campbell diagram#

In this example the whirl speed map is calculated for a speed range from 0 to 1000 rad/s (~9550 RPM).

Storing the results, it’s possible to return the following arrays:

  • wd

  • log_dec

  • whirl_values

Each value in these arrays is calculated for each speed value in speed_range

samples = 31
speed_range = np.linspace(315, 1150, samples)

campbell = rotor3.run_campbell(speed_range)
/home/jguarato/Documents/GitHub/ROSS_Code/ross/ross/rotor_assembly.py:1289: UserWarning:

Extrapolating bearing coefficients. Be careful when post-processing the results.
# results for each frequency
frequency_index = 0
print(campbell.wd[:, frequency_index])
[   0.            0.            0.            0.            0.
    0.            0.            0.            0.          587.93352191
  800.7163722   947.50369439 1010.24341262 1009.42909453 1008.74707767
 1008.20525922 1007.80837754 1007.55801029 1007.45256545 1007.48784109
 1007.65818165 1007.95784534 1008.38073528 1008.92053742 1009.57067638
 1010.32433485 1011.17479229 1012.11554892 1013.14033565 1014.24319497
 1015.4185505 ]
# results for each frequency
frequency_index = 1
print(campbell.log_dec[:, frequency_index])
[        inf         inf         inf         inf         inf         inf
         inf         inf 29.36930087 16.14606431 12.335636   10.335638
  0.96214499  0.94182873  0.92084129  0.89929148  0.87728384  0.85492261
  0.83230254  0.8095054   0.78659599  0.76361997  0.74061411  0.71760875
  0.69463111  0.67170592  0.64885303  0.626088    0.60342198  0.58086266
  0.55841546]

1.3.2 Plotting results#

Now that the results are stored, use .plot() method to display the Campbell Diagram plot.

For the Campbell Diagram, you can plot more than one harmonic. As default, the plot display only the 1x speed option. Input a list with more harmonics to display it at the graph.

campbell.plot(harmonics=[0.5, 1])