Exemple #1
0
    def parametric_curve(s1, s2, f1, f2, res, math):
        ''' Creates a blob which is a parametric curve of the form f(x,y) = (g(t),h(t))

        s1, s2 donate the domain of the parameter, fx is the x component, fy is the y compenent
        '''
        curve = Blob()                  #New blob

        s1,s2 = float(s1), float(s2)

        domain = linspace(s1,s2,res)    # Domain of the parameterizing variable


        f1_func = lambda s: eval(math_parse(f1))  # We're gonna have a two part math here, in
        f2_func = lambda s: eval(math_parse(f2))  # addition to the usual to calculate x and y


        calc_charges = lambda x, y: eval (math_parse(str(math)))


        xs = f1_func(domain)
        ys = f2_func(domain)

        for x,y in zip(xs, ys):
            curve.add_point(Point(x,y))

        curve.math = calc_charges

        blobs.append(curve)
Exemple #2
0
    def rectangle(x0,y0,x1,y1,res,math):
        '''Create a rectangular blob of charge given coordinates which represent 
        diagonal corners.

        Params:
                res ->  Correlated with the 'resolution' of the rectangle. Larger
                        will lead to longer and finer calculations

                math -> Math is the string containing a Polish notation function
                        of X, Y (TODO: add T). It is parsed into a function
                        using mathparse.math_parse'''

        rect = Blob()                       ## Initialize a new Blob...

        x0, y0, x1, y1 = float(x0), float(y0), float(x1), float(y1)

        xs = linspace(x0,x1, res/(y1-y0))   ## Set up a vertical and horizontal line
        ys = linspace(y0,y1, res/(x1-x0))   ## of charges

        for x in xs:                        ## Basically set up a meshgrid of x and y
            for y in ys:                    ## TODO: Look into replacing with Meshgrid.

                rect.add_point(Point(x,y))  ## Add each point to the blob

        f = math_parse(str(math))           ## Parse the Polish notation into python
                                            ## syntax.

        rect.math = lambda x, y: eval(f)    ## Evaluate the python syntax string
                                            ## into an expression, and bind it to
                                            ## a function at the math method of
                                            ## our blob

        blobs.append(rect)                  ## Put it on the list for later flattening
Exemple #3
0
    def circle(x0,y0,radius,start_arc,end_arc,numpoints,math):
        """Create a circle of charge by using polar notation. Circle will have a start and stop end_arc
        given in degrees (for covinience)."""

        circle = Blob()                  ##Spiffy new blob

        x0, y0, start_arc, end_arc = float(x0), float(y0), float(start_arc), float(end_arc)

        theta = radians(linspace(start_arc,end_arc,numpoints)) #figure out our angles

        xs = radius*cos(theta)+x0                              #Build up our xs and ys
        ys = radius*sin(theta)+y0

        for x,y in zip(xs,ys):
            circle.add_point(Point(x,y))

        f = math_parse(str(math))                             #Parse some math for the charges
        circle.math = lambda x, y: eval(f)

        blobs.append(circle)                     #Stick into the main blob
Exemple #4
0
    def line(x0,y0,x1,y1,res,math):
        '''Create a linear blob given start and stop corridnates, a number of points
        on the line, and a math expression to be parsed by mathparse.math_parse.'''

        lin = Blob()                        ## Iniitialize a new blob

        x0, y0, x1, y1 = float(x0), float(y0), float(x1), float(y1)

        horizontal = linspace(x0,x1,res)    ## Make a line along x

        m = (y1-y0)/(x1-x0)                 ## Map horizontal onto the line
        b = y0- m*(x1-x0)                   ## using y-mx + b

        for x,y in zip(horizontal, (m*horizontal) + b):
            lin.add_point(Point(x,y))


        f = math_parse(str(math))                ## Parse and assign math to blob.math()
        lin.math = lambda x, y: eval(f)

        blobs.append(lin)                   ## Put it on the list for later flattening