예제 #1
0
def mesh( A, D, SA ):
    """Compute a number of values for the overall wire mesh.

    :param A: Center-to-center distance across mesh opening (in)
    :param D: Wire diameter (in)
    :param SA: Screen area (ft²)
    :returns: dict with computed values.
        -   WV Wire Volume per cell
        -   N number of cells
        -   TV total volume
        -   FA windvane area
    """
    results= AttrDict( A=A, D=D, SA=SA )

    # Mesh Description
    results.CA=3.464*(A/2)**2 # Cell Area
    LS=1.155*A/2 # Length of Side
    WL=3*LS # Wire Length
    LSO=1.155*(A-D)/2
    results.OA=3.464*((A-D)/2)**2    # Open Area
    results.WA = results.CA - results.OA # Wire Area

    # Materials Description
    results.WV=WL*math.pi*(D/2)**2
    results.N=SA/results.CA*144
    results.TV=results.WV*results.N
    results.FF=results.WA/results.CA
    results.FA=SA*results.FF

    return results
예제 #2
0
def freq_wavelength( **kw ):
    """A kind of **Solver** for frequency-wavelength problems in Standard units
    of meters and Hertz.

    :param f: Frequency in Hz
    :param l: Wavelength in m
    :returns: dict with both values
    """
    c= 299792.458
    args= AttrDict( kw )
    if 'f' in args:
        args.l= 1000*c/args.f
    elif 'l' in args:
        args.f = c/(args.l/1000)
    else:
        raise NoSolutionError( "Insufficient Data: {0!r}".format(args) )
    return args
예제 #3
0
def design_final( shape, **args ):
    """Given a shape (Square or Circle),
    and some parameters, final design.

    :param V: target volume
    :param N: given angle
    :param D: given size or diameter
    :param M: hopper height, larger than the minimum
    :returns: dict with design parameters added.
    """
    args= AttrDict( args )
    def height_from_h( H ):
        args.H = H
        shape.height( args )
        return args.K - args.M
    args.H = bisection( height_from_h, args.M, args.H-1 )
    return args
예제 #4
0
def design_hopper( shape, **args ):
    """Given a shape (Square or Circle),
    and some parameters, initial design with
    minimum height, H, for the hopper.

    :param V: target volume
    :param N: given angle
    :param D: given size or diameter
    :returns: dict with design parameters added.
    """
    args= AttrDict( args )
    def hopper_vol_from_h( H ):
        args.H = H
        shape.volume( args )
        return args.V - args.V_H
    # In principle, we should develop a rational upper limit.
    # The overall volume, though, is a good estimator for the
    # upper bound.
    args.H = bisection( hopper_vol_from_h, 0, args.V )
    return args
예제 #5
0
def involute( radius, phi=None ):
    """Compute involute dimensions given radius
    and optional angle phi.

    :param radius: Radius of circle
    :param phi: optional angle in radians.
    :returns: dictionary with numerous values for the
        involute.

        -   radius, given
        -   diameter, :math:`2 \\times r`
        -   baseline, :math:`\\pi \\times r`
        -   involute circumference

        If Phi is provided

        -   phi, given
        -   C_X, C_Y, location of point C on the involate at angle phi
        -   CO length of the line from origin to C
        -   CE length of the line from circumference to C
        -   OCE the angle at C (on involute) between O and E (on circumference)
        -   COE the angle at O between C (on involute) and E (on circumference)
    """
    args = AttrDict()
    args.radius= radius
    args.diameter = 2*args.radius
    args.baseline = math.pi*args.radius
    args.involute = args.radius*math.pi**2/2

    if phi is not None:
        args.phi= phi
        args.C_X= args.radius*(math.sin(phi)-phi*math.cos(phi))
        args.C_Y= args.radius*(math.cos(phi)-phi*math.sin(phi))
        args.CO= math.sqrt( args.C_X**2 + args.C_Y**2 )
        try:
            args.CE= math.sqrt( args.CO**2 - args.radius**2 )
        except ValueError as e:
            print( "{0} computing sqrt({CO:7.3f}**2-{radius:7.3f}**2)".format(e,**args) )
            args.CE = args.COE = args.OCE = float("NaN")
            return args
        args.OCE = math.atan2( args.radius, args.CE )
        args.COE = math.pi/2-args.OCE

    return args