Trajectory with minimum acceleration

[kandelabr]

Currently design of turbomachinery (impellers/turbines) is more a form of art than an engineering process. One has to guess a bunch of parameters and check if they are right in much later stages of design.

I was thinking about designing the other way: we know the initial and the final velocity. The optimum trajectory is the one with the least acceleration in any direction. The shape of a turbine/impeller would then mimic the calculated trajectories.

My problem is that I have no idea where to start. Any suggestions?

Thanks :)

 

[sophiecentaur]

The optimum trajectory is the one with the least acceleration in any direction.

Is that a general principle? I can't see that it can be because 'optimum' must surely involve accelerations and distances (total Work). Minimal acceleration involves maximum distance which can involve more energy losses.

 

[kandelabr]

That's a good point.

Thinking about it now, there are two different extremes:

• The shortest path through impeller/turbine causes high accelerations/velocities and causes all kinds of turbulent losses. Blades are very short and the output angle is large.
• The longest path is the most gentle but causes friction losses. Blades resemble long spirals and outlet angles are very small.

It is well known what's the optimum output angle. Given that, one can define the minimum acceleration - constant as well.

 

[anorlunda]

You can certainly try. Success is limited by turbulent effects which can only be approximated in analysis.

The following Wikipedia article does a fair job of getting started with the analysis. The references at the bottom pink to more in depth sources. By the way, turbines and propellers are merely applications of airfoil design.

https://en.m.wikipedia.org/wiki/Airfoil

 

[kandelabr]

I'm not trying to avoid CFD. I just wish to update the current (decades old) design recipes to get rid of some empirical equations.

The airfoil approach can be used in propellers and axial/diagonal turbines with high flow and low head. High head, low flow are centrifugal machines and are calculated with velocity triangles/momentum equations...

The main objective is just to gather enough constraints to get a system of equations with a solution with as little made up parameters as possible. I have an idea, I'll keep you updated.

 

[anorlunda]

I wish you well. By all means, keep us posted.

High head, low flow are centrifugal machines

Don't forget Pelton Wheels.

 

[sophiecentaur]

I wish you well. By all means, keep us posted.Don't forget Pelton Wheels.

I came across one of those in a tiny Hydroelectric station up in the Pyrenees, a few years ago. The engineer showed me the old wartime (?) German manufacturer's plates. He said the generator had been running more or less continually since it was installed. The spare wheel was hanging on a wall. I think he was wearing on of the original blue overalls, too.

 

[anorlunda]

It just occurred to me that using the Lagrangian and the principle of least action might be a less tedious way to tackle this analysis problem.

 

[cjl]

That's a good point.

Thinking about it now, there are two different extremes:

• The shortest path through impeller/turbine causes high accelerations/velocities and causes all kinds of turbulent losses. Blades are very short and the output angle is large.

I'm not sure that turbulent losses necessarily follow from high accelerations and large turning angles - it depends on the situation. For turbines, the turning angle can be quite large while keeping turbulence low and flow attached thanks to the favorable pressure gradient across the turbine disk.

 

[kandelabr]

Don't forget Pelton Wheels.

Didn't have those in mind. I'm not an expert on Pelton wheels but the design of those looks more straightforward to me.

It just occurred to me that using the Lagrangian and the principle of least action might be a less tedious way to tackle this analysis problem.

That's the sort of keywords I've been lookng for :) I'll have a look. Thanks!

I'm not sure that turbulent losses necessarily follow from high accelerations and large turning angles - it depends on the situation. For turbines, the turning angle can be quite large while keeping turbulence low and flow attached thanks to the favorable pressure gradient across the turbine disk.

That's why pumps usually have lower efficiencies than turbines. I'm obviously unlucky to be in the pump industry :)

 

[kandelabr]

i managed to whip something up.
the procedure is fairly straightforward:

1. set inlet and outlet diameters. the former can be calculated directly, the latter can be corrected afterwards.
2. calculate inlet and outlet velocities based on flow and head requirements.
3. calculate acceleration components in axial, radial and circumferential directions. these are kept constant in rotating frame of reference.
4. draw trajectory points based on current velocity*timestep.
5. calculate outlet angle defined by relative and circumferential velocity
6. correct outlet diameters if the angle is not OK.

here's the python code:

# -*- coding: utf-8 -*-
"""
Spyder Editor

This is a temporary script file.
"""
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt

g = 9.81 # [m/s**2]

N = 15 # number of time steps

# pump (project) requirements
Q = 10.0/3600 # flow design (best efficiency) point [m^3/s]
H = 12.0 # required pump head [m]

# calculated from other data but fixed in this case
d_1 = 30.0e-3 # outer streamline
d_2 = 60.0e-3 # outer streamline

omegaM = 300.0 # rotational speed 'magnitude' [rad/s]
omega = np.array([omegaM, 0.0, 0.0]) # rotational vector

# 'guessed' parameters
eps_c2 = np.pi/8 # angle of outlet cone (not very important)
b_2 = 6.0e-3 # outlet width (very important for efficienct vs. curve stability)

# specific energy
y = g*H

# circumferential speed at the outlet
u_2 = omegaM*d_2/2

# magnitude of absolute velocity at the outlet
# can be calculated right away using Euler's turbine equation
c_u2 = y/u_2

# meridian velocity at the outlet;
# calculate from flow and outlet area (cone frustum)
A_2 = np.pi*(d_1 + d_2)*b_2/2
c_m2 = Q/A_2

# magnitude of outlet velocity
c_2M = np.sqrt(c_m2**2 + c_u2**2)

# acceleration components:
# radial: get the difference in velocity from required head
c_r2 = c_m2 * np.cos(eps_c2) # radial velocity at the outlet
a_r = c_r2**2/(d_2 - d_1) # acceleration from c_r1 = 0 to c_r2, from d_1 to d_2

# solve the quadratic equation and take the bigger result
t = np.max(np.roots(np.array([a_r/2, c_r2, -(d_2-d_1)/2])))

# circumferential acceleration
a_u = c_u2/t

# axial component
A_1 = np.pi*d_1**2/4 # inlet surface
c_a1 = Q/A_1 # inlet axial velocity
c_a2 = c_2M*np.sin(eps_c2) # out ax. velocity
a_a = (c_a2 - c_a1)/t # axial acceleration

# calculate trajectory points
delta_t = t/N # time step

a_a0 = np.array([a_a, 0, 0])
a_r0 = np.array([0, a_r, 0])
a_u0 = np.array([0, 0, a_u])

a_0 = a_a + a_r + a_u # initial acceleration

p = np.array([0, d_1/2, 0]) # initial position
q = p # initial position for relative trajectory

c = np.array([c_a1, 0, 0]) # initial absolute ...
u = np.cross(omega, p) # ... circumferential
w = c - d_1/2 * omega # ... relative velocity

phi = 0 # initial angle

def rot_x(phi): # rotation around x-axis
    return np.array([
                [1, 0, 0],
                [0, np.cos(phi), -np.sin(phi)],
                [0, np.sin(phi), np.cos(phi)],
            ])

# trace of absolute velocity
trajectory = []

# trace of relative velocity
blade = []

# acceleration vectors
acceleration = []

for i in range(N):
    # the movement in this timestep
    p = p + c*delta_t # absolute
    q = q + w*delta_t # relative
  
    # move to next time step > next angle
    phi += omegaM*delta_t
  
    # rotate circumferential and radial acceleration, magnitude stays the same;
    # axial acceleration stays the same
    a_u = rot_x(phi).dot(a_u0)
    a_r = rot_x(phi).dot(a_r0)
  
    # the new acceleration
    a = a_a + a_r + a_u
  
    c += a*delta_t
  
    u = np.cross(p, omega)
    w = c - u
  
    trajectory.append(p)
    blade.append(q)
    acceleration.append(np.linalg.norm(a))
  
    # check if we're already at the edge
    if np.sqrt(p[1]**2 + p[2]**2) > d_2/2:
        print "ending at: " + str(i)
        break# exit angle (beta_2)
# Kudos: https://stackoverflow.com/questions/2827393/
def unit_vector(vector):
    """ Returns the unit vector of the vector.  """
    return vector / np.linalg.norm(vector)

def angle_between(v1, v2):
    """ Returns the angle in radians between vectors 'v1' and 'v2'::

            >>> angle_between((1, 0, 0), (0, 1, 0))
            1.5707963267948966
            >>> angle_between((1, 0, 0), (1, 0, 0))
            0.0
            >>> angle_between((1, 0, 0), (-1, 0, 0))
            3.141592653589793
    """
    v1_u = unit_vector(v1)
    v2_u = unit_vector(v2)
    return np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))

# acc'rding to fusty books
# the exit angle doth be between 20 and 27 degrees
print 180-angle_between(w, u)*180/np.pi

###
### plot results
###
xs = []
ys = []
zs = []

Z = 5

plt.plot(acceleration)

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# maximum values in all three directions;
# matplotlib can't set equal axes in 3D
vmax = 0

for angle in np.linspace(0, 2*np.pi, Z+1)[:-1]:
  
    # plot absolute streamline
    #xs = []
    #ys = []
    #zs = []
  
    #for point in trajectory:
    #    p = rot_x(angle).dot(point)
    #    xs.append(p[0])
    #    ys.append(p[1])
    #    zs.append(p[2])
  
    #ax.scatter(xs, ys, zs)
    #plt.plot(ys, zs)

    # plot relative streamline (blade)
    xs = []
    ys = []
    zs = []
    for point in blade:
        p = rot_x(angle).dot(point)
      
        vmax = max([vmax, p[0], p[1], p[2]])
      
        xs.append(p[0])
        ys.append(p[1])
        zs.append(p[2])
      
    ax.scatter(xs, ys, zs)

# just push the limits (once more)
ax.scatter([-vmax, vmax], [-vmax, vmax], [-vmax, vmax])

ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')

that draws absolute/relative trajectories for outer streamline only and doesn't correct outlet diameter. to me, it looks very similar to the better designs I've come across so far. there's still some work to be done, like inner streamlines, blade thickness corrections, slip corrections, CFD, ...

 

[Nidum]

Currently design of turbomachinery (impellers/turbines) is more a form of art than an engineering process. One has to guess a bunch of parameters and check if they are right in much later stages of design.

Why do you say that ? It is certainly not true in my experience .

 

[kandelabr]

I stick to Gulich's Centrifugal pumps. The recipe there is really just a recipe. A few examples:

• angle of incidence at inlet should be slightly larger than the flow angle. how exactly, is up to you, but somewhere between 1-5 degrees.
• there are two cones in meridian cross-section, one at the inlet and the other at the outlet. at the inlet the cone angle should be between 30-45 degrees, at the outlet there's an empirical equation that doesn't work with smaller pumps.
• the whole meridian cross-section is largely undefined. Bezier curves are usually the way to go, but it's mostly about 'good-looks'.
• there are guidelines for axial length of impellers and outlet height but in my case those requirements are impossible to meet. out of all empirical equations the outlet height so far worked best but i always scaled it up a few percent.
• blades are usually slightly inclined at the outlet. how much is a mystery and only CFD can tell you if your choice was good.
• with Kaplan's method of blade development one can go linearly from beginning to the end but you could choose any curve. no one can tell you which curve is better.
• slip is again 'calculated' using some rough approximations that work with larger pumps but I'm not sure about smaller ones. the same goes with projected efficiency. number of blades has a huge effect on slip and the recommended number is around 5 to 7 but I've seen impellers with 7 to 11 with similar performance.

i know it's impossible to calculate everything with simple 1-d methods but i would at least like to get rid of as much of guessing as possible. one can do a parametric study of 3, maybe 4 parameters but not 30. even with 3 it would take ages for CFD to do its job.