- #1

- 1,496

- 2

Rotordynamics is the dynamic study of rotating shafts systems. Typically, the focus of said analysis regards obtaining values known as critical speeds. This reference will describe the process which an ANSYS 12 user can model and find the critical speed values by performing a modal analysis.

Specifically, the critical speed is the theoretical angular velocity which self-excites the natural frequency of a rotating object. When designing rotor systems, it is important to identify these areas such that minimum time is spent accelerating through these zones.

In ANSYS, the user has several options for element types. The easiest is simply SOLID elements. For example, the standard

**SOLID185**and

**SOLID186**element types can now (with v12) be used for rotordynamic analyses.

I find it useful to often times do coupled analyses. Since stiffness properties can often times change greatly with temperature, thermal analysis is sometimes required before the dynamic analysis. For this reason, coupled field elements can be very useful. The 3D solid versions are

**SOLID226**and

**SOLID227**.

The last of the SOLID elements that I've used are the new general axisymmetric solids. These are

**SOLID272**and

**SOLID273**. These are pretty neat elements because they operate in the nodal coordinate system rather than the element coordinate system. This means that while an axisymmetric model is ran, non-axisymmetric loads and boundary conditions can be easily applied.

You typically want to stay away from standard axisymmetric elements because they are just that, axisymmetric. You can't really predict a bending mode using these because radial deflections must be the same circumferentially.

With that said, this tutorial here will use the general axisymmetric elements because they require some additional commands, so I might as well show them.

With rotordynamic analyses, there are two more components that are typically involved: bearings and disks. In the world of turbomachinery, we really don't want, or even need to model the disk blades. We would need a 3D model, and use coupling, and things would get messy. So, we model them as idealized disks, with mass and moment of inertia properties. To model these, we will use

**MASS21**elements.

For bearings, typically one would use

**COMBIN14**1D longitudinal elements, however, the recent addition of

**COMBI214**elements will make the job a little easier.

Enough talk, let's start coding. This is an example that I have from a complete shaft assembly. I will assume that you have a model made of lines, with the following line components.

- ballbearingline

- rollerbearingline

- compressor_blades

- turbine_blades

Now let's set some fake properties for the bearings and disks.

Code:

```
k_ball = 75000.
k_roller = 20000.
comp_mass = 0.500
comp_Iyy = 0.750
turbine_mass = 0.400
turbine_Iyy = 0.600
small = 1.e-8
```

Let's define the elements

Code:

```
ET,1,272
KEYOPT,1,2,12
ET,2,214
KEYOPT,2,2,2
R,2,k_ball
R,3,k_roller
ET,4,21
KEYOPT,4,1,0
KEYOPT,4,3,0
R,4,small,small
R,5,comp_mass,comp_Iyy
R,6,turbine_mass,turbine_Iyy
```

Let's explain these a little. The keyopt for the 272 specifies how many "nodal planes" there will be. When you use these elements, you actually mesh a 2D region with nodes and elements. You then generate n nodal planes for which there are nodes only. Obviously the greater the nodal planes, the more accuracy you'll get.

The keyopt for the 214 tells the program that the element lies in the XZ plane. For this run, I have the geometry such that it is Y-axial. Another very nice feature with general axisymmetric elements: You can specify the axis in ANY direction. Out of habit though, I have it y-axial here.

For the

**MASS21**elements, the first keyopt says to interpret the real constants as masses and moments of inertia. You can alternately specify volumes and moments of inertias, but this requires a material definition. The second keyopt says that we only want UX,UY,and ROTZ as degrees of freedom. I have then defined three real sets corresponding to the compressor disk, the turbine disk, and a small value, which we will see the reasoning behind soon (100% necessary). Note that the real constants are actually wrong here, it requires 3 masses and 3 I values for that keyopt...still needed though.

My next step is to simply mesh

Code:

```
AL,ALL
AESIZE,ALL,0.05
AMESH,ALL
```

Code:

```
SECTYPE,1,AXIS
SECDATA,1, 0,0,0, 0,1,0
NAXIS,GEN,AUTO
```

If you plot your nodes, you will now see a circular array of nodes, but only one single plane of elements. That means were on the right track. I like to have a component for my "master" plane of nodes, so:

Code:

```
NSEL,S,LOC,Z,0.0,0.0
NSEL,R,LOC,X,0.0,10000.0
CM,masternodes,NODE
```

OK, so the next thing we'll do is place the bearings. These bearings require two nodes. We want one node to be connected to the shaft, and the other fixed. So the plan is to find the location of the line component, and place two coincident nodes at the axial center of the line, on the axis. We will then fix one of the nodes and couple the other node to the line element. Let's see what it looks like.

Code:

```
CMSEL,S,ballbearingline
NSLL
CM,ballbearingnode,NODE
*GET,ball_min,NODE,0,MNLOC,Y
*GET,ball_max,NODE,0,MXLOC,Y
ball_cent = (ball_min + ball_max) / 2.0
N,99999,0.0,ball_cent,0.0
N,99998,0.0,ball_cent,0.0
TYPE,2
REAL,2
E,99998,99999
NSEL,S,NODE,,99999
CM,ball_contact,NODE
NSEL,S,NODE,,99998
CM,ball_fixed ,NODE
```

The

**COMBI214**only have two degrees of freedom, UX, and UZ. We want to couple the

**COMBI214**elements to the SOLID272 though, which have 6 DOFs. In order to do this, we place a small

**MASS21**element on the ends of the springs to give them the additional degrees of freedom. If you don't do this, the coupling won't work!

Code:

```
!--Apply MASS21 element on end of COMBIN14
TYPE,4
REAL,4
E,99999
E,99997
```

We then use

**CERIG**commands to define a rigid region between the end node of the COMBI214 spring and the bearing locations.

Code:

```
!--Define the rigid region
CMSEL,S,rollerbearingnode
NSEL,A,NODE,,99997
CERIG,99997,ALL,UXYZ
```

The next thing is to add the blades in the form of

**MASS21**elements. This is pretty identical to the bearings, with the obvious exception that we are not fixing the node. It would be helpful to have the centroid of the blades as a variable, and then create the node there, e.g.

Code:

```
N,99989,0.0,centroid,0.0
TYPE,5
REAL,5
E,99989
CMSEL,S,comp-od-line
NSEL,A,NODE,,99989
CERIG,99989,ALL,UXYZ
```

So, here we created the node, attached the element to it, and then created a rigid region between the element and disk OD. Let's get to solving.

Here's what I used for my last run.

Code:

```
/SOLU
ANTYPE,MODAL
OMEGA,,0.,,OFF
CORIOLIS,ON,,,ON
modopt,qrdamp,13,,,on
betad,1.e-5
mxpand,13,,,yes
solve
omega,,1000.0,,OFF
solve
finish
! *** campbell diagram
/post1
plcamp
prcamp,,1,rpm
finish
```

First, in order to get the critical speeds, we solve with no rotation. The

**CORIOLIS**command turns on the necessary gyroscopic effects.

**MODOPT**is a required command that tells which solver to use; 13 is the number of modes to find. We then added a small beta damping for stability. The

**MXPAND**command expands the modes so that we can actually see them.

From there, you solve, and then change the rotating frequency and solve again. With two data points, you can now get a campbell diagram. PLCAMP prints the campbell results to the output file (which I like) and PRCAMP plots it. The 1 indicates that you want a 1x slope (typical) and I want my units to be in RPM.

I have used both ANSYS and what I'll call analytical-style solvers (e.g. Dyrobes) which use cones and cylinders to solve analytically, and both have their pros and cons. With a program like Dyrobes, the modeling is long and time-consuming as you need to take a "organic" line and break it up into straight edged cones. In addition to that, "real" geometry effects are negated as the program only sees your rotor as a series of masses and moments of inertias. Thin sections and other effects are unknown to it.

On the other hand, the bearing modeling is far more powerful and more simple. Some of the bearing effects could be duplicated in ANSYS, but with much effort. Conversely, while ANSYS might not be up to snuff with the bearing modeling, it more than makes up in design iteration of shaft modeling. Once your setup file is creating, making changes to a geometry simply involves changing the model and making sure component names stay defined. Changing geometry in Dyrobes essentially involves recreating the entire thing.

So while they both have their pros and cons, I can typically save a lot of time by modeling using ANSYS. Most importantly is the accuracy though. I did several benchmarks between the two systems. I started with very simplified models and got progressively more complex. The simple models were extremely close in results (1-2%). As the geometries got more complex, they started to diverge, with the final shaft model being having about 7% error between the two.

I would tend to believe the ANSYS in this case because there were areas which should have been less stiff, but as noted before, the analytical model just couldn't "see" them. So, based on this, I definitely think that ANSYS is a tool that can and should be used for rotordynamics, and hopefully with this little tutorial you can try some things out and probably get pretty lost and frustrated.

*Note about*

If you want to incorporate struts or other things like that, you can model the struts as beam elements, and then use CERIG commands using the beam endpoints as the master node. Good luck!

**SOLID272**elements. These elements only have 3 DOFS, translations. So, if you would like to combine non-axisymmetric features, there are a couple things you can do. First, you cannot simply mesh the objects line-to-line. Let's assume that you have some gussets or braces that you'd like to incorporate. You have 6 braces, so you define 6 nodal planes. You must first copy the area, such that the braces no longer share nodes/lines with the 272 elements. Then simply use CPINTF commands to sew the areas together. If you simply mesh it all together, you'll run into errors.If you want to incorporate struts or other things like that, you can model the struts as beam elements, and then use CERIG commands using the beam endpoints as the master node. Good luck!