1. Limited time only! Sign up for a free 30min personal tutor trial with Chegg Tutors
    Dismiss Notice
Dismiss Notice
Join Physics Forums Today!
The friendliest, high quality science and math community on the planet! Everyone who loves science is here!

I Trajectory with minimum acceleration

  1. Dec 21, 2017 #1
    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 :)
     
  2. jcsd
  3. Dec 21, 2017 #2

    sophiecentaur

    User Avatar
    Science Advisor
    Gold Member
    2017 Award

    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.
     
  4. Dec 21, 2017 #3
    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.
     
  5. Dec 21, 2017 #4

    anorlunda

    Staff: Mentor

    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
     
  6. Dec 21, 2017 #5
    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.
     
  7. Dec 21, 2017 #6

    anorlunda

    Staff: Mentor

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

    Don't forget Pelton Wheels.
     
  8. Dec 21, 2017 #7

    sophiecentaur

    User Avatar
    Science Advisor
    Gold Member
    2017 Award

    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.
     
  9. Dec 21, 2017 #8

    anorlunda

    Staff: Mentor

    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.
     
  10. Dec 21, 2017 #9

    cjl

    User Avatar

    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.
     
  11. Dec 21, 2017 #10
    Didn't have those in mind. I'm not an expert on Pelton wheels but the design of those looks more straightforward to me.

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

    That's why pumps usually have lower efficiencies than turbines. I'm obviously unlucky to be in the pump industry :)
     
  12. Dec 27, 2017 #11
    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:
    Code (Python):
    # -*- 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, ...
     

    Attached Files:

  13. Dec 27, 2017 #12

    Nidum

    User Avatar
    Science Advisor
    Gold Member

    Why do you say that ? It is certainly not true in my experience .
     
    Last edited: Dec 27, 2017
  14. Dec 27, 2017 #13
    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.
     
Share this great discussion with others via Reddit, Google+, Twitter, or Facebook

Have something to add?
Draft saved Draft deleted



Loading...