Man, oh man — 2017 is going to be one for the record books! My wife and I recently had the 3rd and FINAL installment of the Parker clan. A healthy Elijah James Parker was born 2 minutes shy of the stroke of midnight on March 18th.

Around the same time, just to make things interesting, I made a job transition to FCA (Fiat Chrysler Automotive). We had an amicable departure at GM and certainly no hard feelings on either side. There was an opportunity for a prime seat in the heart of FCA powertrain that I couldn’t pass up. As of March 27th, I am your Sr. Global Bearing Specialist for FCA. My seat is officially in transmissions, but I am an available resource for any area. Fortunately, we are going to continue business as usual with the blog; I just need to add one of these:

“*The views expressed in this blog are my personal views and they do not represent the views or opinions of FCA in any way*.”

Ok, now that you have an earful about me, as the title would suggest, let’s talk about the exciting world of reducing duty cycles. I was hoping inspiration was going to strike at the 11th hour for the title, but I guess it wasn’t meant to be. Regardless, there probably are 50 ways to reduce a duty cycle. If I were a landscaper, obviously this would be, “There must be 50 ways to leaf your louver.”

Reducing a duty cycle is a very niche skill and for reasons that are beyond me, people get territorial and emotional about sharing their methods. Maybe it’s because they spent hours hammering out the calculations and they think their method is a mathematical secret; or it could be that in the process they made it so cumbersome, they couldn’t re-create it if they tried. I’m not sure. Either way — we will cover a couple of simple methods to get you started off on the right foot. And then you can make your own and become grouchy when people ask you about it — if so inclined. This is a simple method, but the explanation can get a little chatty, so we will cover one method in this posting and then follow up with the other a little later.

There are numerous reasons to have a reduced duty cycle of maybe 10-20 steps. First, it makes software analysis much easier when dealing with a few load cases compared with hundreds or thousands. Secondly, any bench test will require a reasonably simple duty cycle as, most likely, someone will need to manually program the test parameters. Finally, when numerous people are analyzing the system, internally or suppliers, everyone is working to the same set of data.

Typically, there are three duty cycle reduction steps that can occur. The first will start with the vehicle or test stand where millions of data collection points are taken and dumped into a cvs file. From there, an analyst takes the millions of data points and reduces them down to a couple thousand points — usually via rainflow counting software (*Ed.’s note: Rainflow counting is a method for determining the number* *of fatigue cycles present in a load-time history. A fatigue cycle is the loading and unloading of a part; with enough repeated cycles a part will weaken and eventually fail.*) — and format it into what is often called a “spectrum” or “spectra.” This is usually a speed x torque x cycle count type of spreadsheet. Still, this is far too many load cases to be running while you are going through dozens — or hundreds — of iterations in the process of designing a new application. Most modern software can handle thousands of load cases, but your quick point and click analysis goes from a few seconds to several minutes. So, if you believe in the Palmer-Miner rule, you can condense this down further into an easy 10-20 step duty cycle while retaining the same amount of fatigue damage.

(Figure 1: *SMT-MASTA 7.6* Spectra Input Tool)

What you are trying to do will ultimately decide how you should reduce the duty cycle. If you are trying to make a dyno schedule based on the spectrum, then a time-based cycle might be the right answer. Many test labs like a 100-hour test because it fits conveniently into an M-F schedule. Others may want more cycles at lower torque and others want more torque and fewer cycles. The right answer is — it just depends. The most important thing to keep in mind when reducing the duty cycle is that you don’t reduce it so far that you change failure modes. For instance, in bearings, this would mean that you change from a typical long-term subsurface fatigue to a surface-based fatigue due to low oil film and high loads. Just keep in mind that your reduction is a purely fictional tool to aid with analysis or testing, so if your analysis doesn’t look right or you fail something on test, don’t immediately panic. You may have simply reduced the duty cycle too far. There are ways for checking this which we will discuss later.

For our first example, we will use a technique which I coin the *Torque Ratio* method. Just a point for clarity, in my applications, torque is always directly related to the load on the bearing, so any changes I make with the torque will be applied proportionately to the bearing. We start by breaking the duty cycle into bins. We are going to take these bins and assign one torque to represent the entire bin. For instance, the Sample Duty Cycle shown in Figure 2 would represent the 100-500 torque range and 330 – 730 speed range. There could be numerous other bins with the same torque range at higher speeds, and we could have the same speed range with higher torques. This is just one bin which will be represented by one torque, one speed and a calculated number of cycles to represent the same amount of damage.

(Figure 2: Sample Duty Cycle)

We always start with the governing equation that is used to calculate the fatigue of the original part. For ball bearings we will use:

Where:

*L*_{10} is the calculated life in terms of millions of cycles;

*C* is the bearing load rating;

*P* is the applied load;

Exponent 3 would be the slope beta *b* of the SN curve.

For the first method, let’s say we want to take all 5 steps and combine them into a single-step duty cycle that would have the same amount of calculated damage on the components. (I like to say this out loud to myself to get started.) What (*x*) do I need to do to my cycles (*L*_{10}) if I change my load (*P*_{2})?

(Figure 3: Duty Cycle – Spectra Format)

In plain English, this means that you can set your second torque to whatever you want if you multiply your cycles by:

Let’s see if this really works. Taking our sample duty cycle, we’ll just use a concept bearing as a placeholder with a fictitious 100N load rating to calculate our damage. As a refresher, our damage is simply the number of required cycles divided by L_{10}. No exponents, it is a simple ratio usually expressed as a percentage.

(Figure 4: Duty cycle with L_{10} and % damage)

Our original duty cycle with added L_{10} and % damage is shown in Figure 4. Now we will say we want to evaluate this entire duty cycle at 250 (units are irrelevant if you stay consistent).

Now look at Figure 5 where we took the same duty cycle and replaced the torque with 250. In the New Cycles column, we simply set up the formula to grab the old cycles (1000, 800…200), multiply by:

(Figure 5: Duty cycle with new torque/cycles)

Or in our specific case:

which yields our new cycle count. Finally, the most important step is to check yourself. In this case, % Damage makes for an easy count and we see both duty cycles line up to 2 decimal points of damage.

Note that the RPM is not part of our basic L_{10} calculation and is at your discretion. I have done weighted average, mean, straight average, it depends on the test. I will throw this out as a final note of caution; I have done this many times and **always** use multiple points of double checking my work because it’s very easy to mix up a couple of numbers, an exponent, etc. I almost always find a mistake somewhere and getting in the habit of checking your damage against both cycles will prevent a small mistake turning into a big mistake. I recommend setting up checks for every block and entire duty cycle. Next time we will cover how to do this but retain your original number of cycles and solve for torque along with some clues to see if you compressed your duty cycle too far or if you can compress it further.