+ + Figure 1: Global coordinate system of a spur gear pair (Yang et al., 2016). +
- Building the model;\n\n- Calculating the results.\nShaftElement, BearingElement and so on.\nAfter instantiating some elements, we can then use these to build a rotor.\nThis tutorial is about building your rotor model. First, you will learn how to create and assign materials, how to instantiate the elements which compose the rotor and how to convert units in ROSS with pint library. This means that every time we call a function, we can use pint.Quantity as an argument for values that have units. If we give a float to the function ROSS will consider SI units as default.\nIn the following topics, we will discuss the most relevant classes for a quick start on how to use ROSS."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "lEQa",
+ "code_hash": "416d79249402ed502d34bd67fc43d046",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "E (Young's Modulus), G_s (Shear\nModulus) ,Poisson (Poisson Coefficient), and the material\ndensity rho."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "SFPL",
+ "code_hash": "aaa378955f6d8e98c3c2d5b0fa1d9353",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "Note: Adding 3 arguments to the Material class raises an error."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "BYtC",
+ "code_hash": "7af55142d4531737d9a1164dd8d0a821",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "available_materials.toml.\nIt's possible to access the Material data from the file. With the file opened, you can:\n- modify the properties directly;\n\n- create new materials;\n[Materials.Steel]\nname = "Steel"\nrho = 7810\nE = 211000000000.0\nPoisson = 0.2992610837438423\nG_s = 81200000000.0\ncolor = "#525252"\nMaterial.use_material('name') method with the name of the material as a parameter."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "iLit",
+ "code_hash": "25f227091c53f5a0cff2616f45dc6d2f",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "ShaftElement allows you to create cylindrical and conical shaft elements. It means you can set differents outer and inner diameters for each element node.\nThere are some ways in which you can choose the parameters to model this element:\nrotary_inertia=False, shear_effects=False)rotary_inertia=True, shear_effects=True - used as default)n=None, the Rotor class will assign a value to the element when building a rotor model (see section 6).\nYou can also pass the same n value to several shaft elements in the same rotor model."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "ROlb",
+ "code_hash": "7b205f2c0cf9d4889047193a496ba7e0",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "idl and odl. So the other 2 (idr and odr) get the same values.\nNote: you can give all the 4 parameters, as long they match each other."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "TqIu",
+ "code_hash": "53aad3276637117d431daf76a0f47111",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "idl != idr and/or odl != odr."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "DnEU",
+ "code_hash": "b2b33ed63212fc9a5ec8155ac4beabc1",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": ".M(): returns the mass matrix.K(frequency): returns the stiffness matrix.C(frequency): returns the damping matrix.G(): returns the gyroscopic matrixfor loop or a list comprehension."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "ZBYS",
+ "code_hash": "58c1f80effc2cb979ab281251b8b4a2a",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "for loop or a list comprehension, coupled with Python's zip() method.\nWe create lists for each property, where each term refers to a single element:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "xXTn",
+ "code_hash": "f84afeeaff7392779cd039cb76b2c829",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": ".from_table() reads an Excel file created and converts it to a list of shaft elements.\nA header with the names of the columns is required. These names should match the names expected by the routine (usually the names of the parameters, but also similar ones). The program will read every row bellow the header until they end or it reaches a NaN, which means if the code reaches to an empty line, it stops iterating.\nAn example of Excel content can be found at ROSS GitHub repository at ross/tests/data/shaft_si.xls, spreadsheet \"Model\".\nYou can load it using the following code."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "AjVT",
+ "code_hash": "ad029076da0165a22afe208f0eda82a5",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "shaft_file = Path("shaft_si.xls")\nshaft = rs.ShaftElement.from_table(\n file=shaft_file, sheet_type="Model", sheet_name="Model"\n)\nCouplingElement class, a subclass of the ShaftElement class, designed to model the interaction between two rotor shafts. This element is implemented in a general form in ROSS. The coupling plays a crucial role in mechanical systems by transmitting forces, vibrations, and motion between rotating shafts. It is primarily characterized by adding stiffness, mass, and inertia to the system, which are essential for simulating the real-world behavior of coupled rotors.\nSteps:\nShaftElement class. Each shaft can have its own properties like material, length, and diameter.CouplingElement class to connect the two shafts by inserting the elements in a list following a certain order.DiskElement allows you to create disk elements, representing rotor equipments which can be considered only to add mass and inertia to the system, disregarding the stiffness.\nROSS offers 3 (three) ways to create a disk element:\nrs.DiskElement.from_geometry()) which you can use.\nROSS will take geometrical parameters (outer and inner diameters, and width) and convert them into mass and inertia data. Once again, considering the disk as a cylinder."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "urSm",
+ "code_hash": "0ab8877e0558b7c03e2979d7cdc0971f",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": ".from_table() reads an Excel file created and converts it to a list of disk elements. This method accepts only mass and inertia inputs.\nA header with the names of the columns is required. These names should match the names expected by the routine (usually the names of the parameters, but also similar ones). The program will read every row bellow the header until they end or it reaches a NaN, which means if the code reaches to an empty line, it stops iterating.\nYou can take advantage of the excel file used to assemble shaft elements, to assemble disk elements, just add a new spreadsheet to your Excel file and specify the correct sheet_name.\nAn example of Excel content can be found at diretory ross/tests/data/shaft_si.xls, spreadsheet \"More\"."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "xvXZ",
+ "code_hash": "9dfc1267c2969df4d24e6db14d498766",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "BearingElement: represents a general (journal) bearing element.SealElement: represents a general seal element.BallBearingElement: A bearing element for ball bearingsRollerBearingElement: A bearing element for roller bearings.MagneticBearingElement: A bearing element for magnetic bearings.param_to_coef: A bearing element for magnetic bearings from electromagnetic parametersPlainJournal: A cylindrical bearing element based on the pressure and temperature field in oil film.BearingElement class. It means, you can use the same methods and commands, set up to BearingElement, in the other classes."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "CLip",
+ "code_hash": "17790afd874f42e56a0f09b0099b46ef",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "n_link argument to introduce a link with other elements. Useful to add bearings in series or co-axial rotors."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "YECM",
+ "code_hash": "c81d9b12fb78b6ade848ab0dd918559b",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "frequency argument.\nThe next example shows how to instantiate a single bearing with constant coefficients:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "iXej",
+ "code_hash": "b93b8fd39819720950521305f2bb6451",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "ValueError is raised\nThe next example shows the instantiate of a bearing with odd parameters:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "vEBW",
+ "code_hash": "3e8e9819fb353c3bde084a1847f0b8f4",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "bearing_odd = rs.BearingElement( # odd dimensions\n n=0,\n kxx=np.array([0.5e6, 1.0e6, 2.5e6]),\n kyy=np.array([1.5e6, 2.0e6, 3.5e6]),\n cxx=np.array([0.5e3, 1.0e3, 1.5e3]),\n frequency=np.array([0, 1000, 2000, 3000])\n)\nn_link argument. This is very useful to simulate structures which support the machine, for example.\nn_link opens a new node to the rotor system, or it can be associated to another rotor node (useful in co-axial rotor models). Then, the new BearingElement node, is set equal to the n_link from the previous element."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "dxZZ",
+ "code_hash": "e13483069e2dd794ac13ef6ac429bfa2",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": ".plot() method.\nLet's return to the example done in 4.1.2 and check how SealElement class method have the exactly same arguments than BearingElement. The differences are found in some considerations when assembbling a full rotor model. For example, a SealElement won't generate reaction forces in a static analysis. So, even they are very similar when built, they have different roles in the model.\nLet's see an example:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "fCoF",
+ "code_hash": "9852215bc041a0991a07eaca03f07f60",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "MagneticBearingElement()\nSee the following reference for the electromagnetic parameters g0, i0, ag, nw, alpha:\nBook: Magnetic Bearings. Theory, Design, and Application to Rotating Machinery\nAuthors: Gerhard Schweitzer and Eric H. Maslen\nPage: 84-95\nFrom: \"Magnetic Bearings. Theory, Design, and Application to Rotating Machinery\"\nAuthors: Gerhard Schweitzer and Eric H. Maslen\nPage: 354\nLet's see an example:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "VCRE",
+ "code_hash": "b8f3af59ebd8f6a0c313db572906b8d2",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": ".from_table() reads an Excel file and converts it to a BearingElement instance. Differently from creating shaft or disk elements, this method creates only a single bearing element. To create a list of bearing elements, the user should open several spreadsheets in the Excel file and run a list comprehension loop appending each element to the list.\nA header with the names of the columns is required. These names should match the names expected by the routine (usually the names of the parameters, but also similar ones). The program will read every row below the header until they end or it reaches a NaN, which means if the code reaches an empty line, it stops iterating.\nn : int\n The node in which the bearing will be located in the rotor.\nfile: str\n Path to the file containing the bearing parameters.\nsheet_name: int or str, optional\n Position of the sheet in the file (starting from 0) or its name. If none is passed, it is\n assumed to be the first sheet in the file.\n.from_table() creates only a single bearing, let's see an example how to create multiple elements without typing the same command line multiple times.\nPointMass class creates a point mass element. This element can be used to link other elements in the analysis. The mass provided can be different on the x and y direction (e.g. different support inertia for x and y directions).\nPointMass also keeps the mass, stiffness, damping and gyroscopic matrices sizes consistence. When adding 2 bearing elements in series, it opens a new node with new degrees of freedom (DoF) (see section 4.1.3) and expands the stiffness and damping matrices. For this reason, it's necessary to add mass values to those DoF to match the matrices sizes.\nIf you input the argument m, the code automatically replicate the mass value for both directions \"x\" and \"y\".\nLet's see an example of creating point masses:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "rSYo",
+ "code_hash": "49d9486a8772ee22dd00af2299c06410",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "Rotor is the main class from ROSS. It takes as argument lists with all elements and assembles the mass, gyroscopic, damping and stiffness global matrices for the system. The object created has several methods that can be used to evaluate the dynamics of the model (they all start with the prefix .run_).\nTo use this class, you must input all the already instantiated elements in a list format.\nIf the shaft elements are not numbered, the class set a number for each one, according to the element's position in the list supplied to the rotor constructor.\nTo assemble the matrices, the Rotor class takes the local DoF's index from each element (element method .dof_mapping()) and calculate the global index"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "HuZB",
+ "code_hash": "17d5dd0bde5a46399900d8e8bf90fc5b",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "Rotor class."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "Ynfw",
+ "code_hash": "017dc9c5055217b295d610d73c3a8826",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": ".add_nodes():"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "uDnK",
+ "code_hash": "ea13886d68d71099a30932f5801549d9",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "n will refer, not to the element node, but to the section node. So if your model has 3 sections with 4 elements each, there're 4 section nodes and 13 element nodes.\nLet's repeat the rotor model from the last example, but using .from_section() class method, without the support."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "MIsd",
+ "code_hash": "59ff6b567ee25ebfd53a710a5def9f44",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": ".plot_rotor() method to create a plot.\nnodes argument is useful when your model has lots of nodes and the visualization of nodes label may be confusing. Set an increment to the plot nodes label\nROSS uses PLOTLY as main plotting library:\nWith the Plotly, you can hover the mouse icon over the shaft, disk and point mass elements to check some of their parameters."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "Lpqv",
+ "code_hash": "5aa7e913a8a5868dc3cb21355c0c3f2a",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "Let's visualize another rotor example with overlapping shaft elements:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "pCao",
+ "code_hash": "cd52ab3076288fdba7b0205cdc9f5f75",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": ".save(). This method saves the each element type and the rotor object in different .toml files.\nYou just need to input a name and the diretory, where it will be saved. If you don't input a file_path, the rotor model is saved inside the \"ross\" folder.\nTo save the rotor2 we can use:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "wlyU",
+ "code_hash": "c6b5dd82e31dc5f1e305122f03239f1b",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": ".load(). This method loads a previously saved rotor model.\nYou just need to input the file path to the method.\nNow, let's load the rotor2 we saved before:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "GrQN",
+ "code_hash": "9804f976f304d003676f64ad930be72b",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "CouplingElement class, which can also function as a lumped-element model.\nFor instance, a motor can be represented using a CouplingElement by specifying its stiffness, mass, and polar moment of inertia.\nHere's an example:"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "Ilkb",
+ "code_hash": "7d4b8f2dbd3d9a70ce26f91a627f0c90",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "CouplingElement is a type of ShaftElement, it must be inserted into the appropriate position within the shaft_elements array."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "mSxP",
+ "code_hash": "b897ed744e112b82be99ac205d9b3a35",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "Pint defines, operates and manipulates physical quantities: the product of a numerical value and a unit of measurement. It allows arithmetic operations between them and conversions from and to different units.\nWith Pint, it's possible to define units to every element type available in ROSS and manipulate the units when plotting graphs. ROSS takes the user-defined units and internally converts them to the International System (SI).\nImportant: It's not possible to manipulate units for attributes from any class. Attributes' values are always returned converted to SI. Only plot methods are able to manipulate the output unit."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "RCUM",
+ "code_hash": "6a361cfbcac8720d4c371bc5b8f25cd3",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "Pint requires a specific syntax to assign an unit to an argument.\nFirst of all, it's necessary to import a function called Q_ from ross.units. This function must be assigned to every variable that are desired to have units, followed by a tuple containing the magnitude and the unit (in string format).\nThe example below shows how to create a material using Pint, and how it is returned to the user."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "NBGo",
+ "code_hash": "0a020926a37f096001858f30143e7b89",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "Note: Taking a closer look to the output values, the material density is converted to the SI and it's returned this way to the user."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "ChmK",
+ "code_hash": "fa8bd17f9293537362aef0afdd6c76ff",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "The same syntax applies to elements instantiation, if units are desired. Besides, notice the output is displayed in SI units.\nPint with plots. But keep in mind ROSS will considers results values in the SI units.\nNote: If you input data using the Imperial System, for example, without using Pint, ROSS will consider it's in SI if you try to manipulate the units when plotting.\nLet's run a simple example of manipulating units for plotting."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "CFll",
+ "code_hash": "74acde19a770f699b4be4af1f9d3920a",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "Plotting with default options will bring graphs with SI units. X and Y axes representing the frequencies are set to rad/s"
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "viyg",
+ "code_hash": "c551e39faf2c387ff03a9fe3227cb67e",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/markdown": "Now, let's change the units to RPM.\nJust by adding frequency_units=\"rpm\" to plot method, you'll change the plot units."
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "Hbol",
+ "code_hash": "1d0db38904205bec4d6f6f6a1f6cec3e",
+ "outputs": [
+ {
+ "type": "data",
+ "data": {
+ "text/plain": ""
+ }
+ }
+ ],
+ "console": []
+ },
+ {
+ "id": "bkHC",
+ "code_hash": "37858a3cdb80f243220cb380984c95f7",
+ "outputs": [
+ {
+ "type": "error",
+ "ename": "exception",
+ "evalue": "No module named 'numpy'",
+ "traceback": []
+ }
+ ],
+ "console": [
+ {
+ "type": "stream",
+ "name": "stderr",
+ "text": "Traceback (most recent call last):\n File "/tmp/marimo_50761/__marimo__cell_bkHC_.py", line 3, in <module>\n import numpy as np\nModuleNotFoundError: No module named 'numpy'\n
+ 
+ 
+ 
+ 
+ 
+