def tan(self): if type(self) == Dual: return Dual(pl.tan(self.fun), self.der/(pl.cos(self.fun)**2)) elif type(self) == Taylor: return sin(self)/cos(self) else: return pl.tan(self)
def D(c,f,X): ''' The derived elastica energy as in sharon E= a**2 etc. ''' # either c or f can be an array! not both # c: current bar orientation # f: flanker orientation # x: relative flanker distance and position orientation x = X[0] y = X[1] ## 'Affinity' D # D = Ba^2 + Bb^2 -BaBb # Here Ba is the angle of the flanker with the line connecting it with the center # and Bb is the reverse for the center # See figure 5 in Leung & Malik (1998) for intuitive figure # flanker positional angles theta = pl.arctan2(x,y) # if theta > pi/2: theta-=pi # if theta < -pi/2: theta+=pi # B values normalized within -pi to pi Ba = pl.arctan(pl.tan(0.5*(-f+theta)))*2 Bb = pl.arctan(pl.tan(0.5*(c-theta)))*2 D = 4*(Ba**2 + Bb**2 - Ba*Bb) return D
def cot(self): if type(self) == Dual: return Dual(1./pl.tan(self.fun), -1.*self.der/(pl.sin(self.fun)**2)) elif type(self) == Taylor: return cos(self)/sin(self) else: return 1./pl.tan(self)
def csc(self): if type(self) == Dual: return Dual(1./pl.sin(self.fun), -1.*self.der/(pl.tan(self.fun)*pl.sin(self.fun))) elif type(self) == Taylor: return 1./sin(self) else: return 1./pl.sin(self)
def sec(self): if type(self) == Dual: return Dual(1./pl.cos(self.fun), self.der*pl.tan(self.fun)/pl.cos(self.fun)) elif type(self) == Taylor: return 1./cos(self) else: return 1./pl.cos(self)
def __init__(self, fc, dt): ita = 1./pl.tan(pl.pi*fc*dt) q = pl.sqrt(2) self.b = [1./(1+q*ita+ita*ita)] self.b.append(2*self.b[0]) self.b.append(self.b[0]) self.a = [2*(ita*ita - 1)*self.b[0], -(1-q*ita+ita*ita)*self.b[0]] self.reset()
def plot_jp_tmax_surf(mu,c,phi,pmax,smax,ks): # @brief tau max based on varying slip rate, normal pressure s_dot = py.arange(0,smax,smax/100.) prange = py.arange(0,pmax,pmax/100.) kap = 1-py.exp(-s_dot/ks) # kappa TMAX = py.zeros((len(kap),len(prange))) tphi = py.tan(phi) # keep tan(phi) handy for k_i in range(0,len(kap)): k_tmp = kap[k_i] for p_j in range(0,len(prange)): p_tmp = prange[p_j] TMAX[k_i][p_j] = k_tmp*(c+p_tmp*tphi) + (1-k_tmp)*p_tmp*mu fig = plt.figure() ax = fig.add_subplot(121) # should be ok to plot the surface S, P = py.meshgrid(s_dot, prange) CS = plt.contour(S,P,TMAX,8,colors='k',linewidths=1.5) plt.clabel(CS,inlne=1,fontsize=16) img = plt.imshow(TMAX, interpolation='bilinear', origin='lower', cmap=cm.jet,extent=(min(s_dot),max(s_dot),min(prange),max(prange))) CBI = plt.colorbar(img, orientation='vertical',shrink=0.8) CBI.set_label(r'$\tau ,max $[psi]') ax.set_title(r'$\tau ,max = f(\sigma,\kappa), ks=%.2f $'%ks) ax.set_xlabel('slip rate [in/sec]') ax.set_ylabel(r'$\sigma_z $',size=24) # use twice ks, re-calc what's necessary, then replot ks2 = ks * 2 kap2 = 1-py.exp(-s_dot/ks2) TMAX2 = py.zeros((len(kap2),len(prange))) # tphi = py.tan(phi) # keep tan(phi) handy for k_i in range(0,len(kap2)): k2_tmp = kap2[k_i] for p_j in range(0,len(prange)): p_tmp = prange[p_j] TMAX2[k_i][p_j] = k2_tmp*(c+p_tmp*tphi) + (1-k2_tmp)*p_tmp*mu #fig = plt.figure() ax = fig.add_subplot(122) # should be ok to plot the surface # S, P = py.meshgrid(s_dot, prange) CS2 = plt.contour(S,P,TMAX2,8,colors='k',linewidths=1.5) plt.clabel(CS2,inlne=1,fontsize=16) img2 = plt.imshow(TMAX2, interpolation='bilinear', origin='lower', cmap=cm.jet,extent=(min(s_dot),max(s_dot),min(prange),max(prange))) CBI2 = plt.colorbar(img2, orientation='vertical',shrink=0.8) CBI2.set_label(r'$\tau ,max $[psi]') ax.set_title(r'$\tau ,max = f(\sigma,\kappa), ks=%.2f $'%ks2) ax.set_xlabel('slip rate [in/sec]') ax.set_ylabel(r'$\sigma_z $',size=24)
def __init__(self, fc, dt): ita = 1. / pl.tan(pl.pi * fc * dt) q = pl.sqrt(2) self.b = [1. / (1 + q * ita + ita * ita)] self.b.append(2 * self.b[0]) self.b.append(self.b[0]) self.a = [ 2 * (ita * ita - 1) * self.b[0], -(1 - q * ita + ita * ita) * self.b[0] ] self.reset()
def main(): # 3. Create a list A of 600 random numbers bound between (0:10) A = [random.random_integers(0, 10) for i in range(600)] print("\033[1mList A: \n\033[0m", A) # 4. Create an array B with with 500 elements bound in the range [-3*pi:2*pi] B = plb.linspace(-3 * plb.pi, 2 * plb.pi, 500, endpoint=True) print("\n\033[1mArray B: \n \033[0m", B) # 7. Return the result from the function to C C = functionOverwriter(A) print("\n\033[1mC: \033[0m", type(C)) print(C) # 8. Cast C as an array C = array(C) print("\n\033[1mC: \033[0m", type(C)) print(C) # 9. Add C to B (think of C as noise) and record the result in D D = B + C[:B.size] print("\n\033[1mD: \033[0m", D) # 10. Create a figure, give it a title and specify your own size and dpi plb.figure(figsize=(10, 6), dpi=120) plb.title("Sin(D)") # 11. Plot the sin of D, in the (2,1,1) location of the figure plb.subplot(2, 1, 1) plb.plot(plb.sin(D), color="r", label="Sin") # 12. Overlay a plot of cos using D, with different color, thickness and type of line plb.plot(plb.cos(D), color="b", linewidth=2, linestyle="-.", label="Cos") # 13. Create some space on top and bottom of the plot (on the y axis) and show the grid plb.ylim(min(plb.cos(D)) - .5, max(plb.cos(D)) + .5) plb.grid() # 14. Specify the following: title, Y-axis label and legend to fit in the best way plb.title("Sin(D) and Cos(D)") plb.legend() plb.ylabel("Y-axis") plb.legend(loc="upper right") # 15. Plot the tan of D, in location (2,1,2) with grid showing, X-axis label, Y-axis label # and legend on top right plb.subplot(2, 1, 2) plb.plot(plb.tan(D), color="g", label="Tan") plb.ylabel("Y-axis") plb.xlabel("X-axis") plb.legend(loc="upper right") plb.show()
def checkFOV(self, aOther_Pt): #Get Angle (in Radians) Limits (and their Slopes) nAngView = pylab.deg2rad(25) if self.nHeading == '-': return False aThis_Pt, aOther_Pt = list(self.aPos), list(aOther_Pt) nRad1, nRad2 = self.nHeading + nAngView, self.nHeading - nAngView nSlope1, nSlope2, nMaxSlope = pylab.tan(nRad1), pylab.tan(nRad2), 10000 # @UnusedVariable aThis_Pt[1], aOther_Pt[1] = self.nFrm_Height - aThis_Pt[ 1], self.nFrm_Height - aOther_Pt[1] aOther_Pt[0], b = (aOther_Pt[0] - aThis_Pt[0]), aThis_Pt[1] nOtherX, nOtherY = aOther_Pt[0], aOther_Pt[1] # #Avoid Multiplications where the Slope is close to Infinite # if abs(nSlope1) >= nMaxSlope: # y2 = nSlope2*nOtherX + b; # if nRad2 < pylab.pi/2.0: return (nOtherX>=0) and (nOtherY>=y2); # else: return (nOtherX<=0) and (nOtherY<=y2); # if abs(nSlope2) >= nMaxSlope: # y1 = nSlope1*nOtherX + b; # if nRad1 > (3*pylab.pi)/2.0: return (nOtherX>=0) and (nOtherY<=y1); # else: return (nOtherX<=0) and (nOtherY>=y1); #Check position of AngViews y1 = nSlope1 * nOtherX + b y2 = nSlope2 * nOtherX + b nUpLeft, nDownLeft = pylab.pi / 2.0, (3 * pylab.pi) / 2.0 bAngView1_Left = (nRad1 > nUpLeft) and (nRad1 < nDownLeft) #AngView1 on Left Side bAngView2_Left = (nRad2 > nUpLeft) and (nRad2 < nDownLeft) #AngView2 on Left Side bBothLeft = (bAngView1_Left) and (bAngView2_Left) bBothRight = (bAngView1_Left == False) and (bAngView2_Left == False) bBothUp = (bAngView1_Left) and (bAngView2_Left == False) bBothDown = (bAngView1_Left == False) and (bAngView2_Left) if bBothLeft and (nOtherY >= y1) and (nOtherY <= y2): return True if bBothRight and (nOtherY <= y1) and (nOtherY >= y2): return True if bBothUp and (nOtherY >= y1) and (nOtherY >= y2): return True if bBothDown and (nOtherY <= y1) and (nOtherY <= y2): return True return False
def findE(self,c,f,X): ''' find E, the approximated sharon energy Inputss ---------- - c: current bar orientation, relative to the vertical (can be double or array, if array D returns an array of D values) - f: flanker orientation, relative to the vertical (double) - X: flanker position, relative to the current bar (x,y) So, as examples... findE(0,0,[0,1]) would be two vertical bars, positioned vertically in a line. findE(pi/2,pi/2,[1,0]) would be two horizontal bars, positioned horizontally in a line. ''' # define x and y x = X[0] y = X[1] # flanker positional angle theta = pl.arctan2(x,y) # find and return D Ba = pl.arctan(tan(0.5*(-f+theta)))*2 Bb = pl.arctan(tan(0.5*(c-theta)))*2 return 4*(Ba**2 + Bb**2 - Ba*Bb)
def get_bursts(spikes, total_neurons, time_max, verbose=True): print 'Extracting bursts.' activity_hist, bins = calculate_activity_histogram(spikes, total_neurons, bin=1.) # NB: BINS IN SECONDS! s_activity_hist = sorted(activity_hist, reverse=True) # Angle of touching line angle = pylab.pi * 3. / 4. s_activity_hist_deriv = smooth_data(ND(bins, s_activity_hist), 20) cutter = s_activity_hist[ index_approx(s_activity_hist_deriv, pylab.tan(angle))] if verbose: print 'Burst threshold found at %f' % cutter s_activity_hist = [i if i > cutter else 0 for i in activity_hist] s_activity_hist = smooth_data(s_activity_hist, 20) bursts_indices_start = [] bursts_indices_end = [] for i in xrange(len(s_activity_hist)-1): if s_activity_hist[i+1] > 0 and s_activity_hist[i] == 0: bursts_indices_start.append(i+1) if s_activity_hist[i+1] == 0 and s_activity_hist[i] > 0: bursts_indices_end.append(i) if bins[bursts_indices_end[0]] < bins[bursts_indices_start[0]]: bursts_indices_end.pop(0) if bins[bursts_indices_end[-1]] < bins[bursts_indices_start[-1]]: bursts_indices_end.pop(-1) bursts_indices = [] for i in xrange(len(bursts_indices_start)): activity_hist_buf = activity_hist[bursts_indices_start[i]: bursts_indices_end[i]] bursts_indices.append( bursts_indices_start[i] + activity_hist_buf.index( max(activity_hist_buf))) return (bins, activity_hist, [{'max': bursts_indices[i], 'start': bursts_indices_start[i], 'end': bursts_indices_end[i]} for i in xrange(len(bursts_indices))])
def tau_a(p, mu, c, phi, j, k): tS = 1 - py.exp(-j / k) t1 = c * p * py.tan(phi) t2 = mu * p t_out = min(t1, t2) * tS return t_out
def tau_max_soil(p, c, phi): return c + p * py.tan(phi)
def plot_jp_tmax_surf(mu, c, phi, pmax, smax, ks): # @brief tau max based on varying slip rate, normal pressure s_dot = py.arange(0, smax, smax / 100.) prange = py.arange(0, pmax, pmax / 100.) kap = 1 - py.exp(-s_dot / ks) # kappa TMAX = py.zeros((len(kap), len(prange))) tphi = py.tan(phi) # keep tan(phi) handy for k_i in range(0, len(kap)): k_tmp = kap[k_i] for p_j in range(0, len(prange)): p_tmp = prange[p_j] TMAX[k_i][p_j] = k_tmp * (c + p_tmp * tphi) + (1 - k_tmp) * p_tmp * mu fig = plt.figure() ax = fig.add_subplot(121) # should be ok to plot the surface S, P = py.meshgrid(s_dot, prange) CS = plt.contour(S, P, TMAX, 8, colors='k', linewidths=1.5) plt.clabel(CS, inlne=1, fontsize=16) img = plt.imshow(TMAX, interpolation='bilinear', origin='lower', cmap=cm.jet, extent=(min(s_dot), max(s_dot), min(prange), max(prange))) CBI = plt.colorbar(img, orientation='vertical', shrink=0.8) CBI.set_label(r'$\tau ,max $[psi]') ax.set_title(r'$\tau ,max = f(\sigma,\kappa), ks=%.2f $' % ks) ax.set_xlabel('slip rate [in/sec]') ax.set_ylabel(r'$\sigma_z $', size=24) # use twice ks, re-calc what's necessary, then replot ks2 = ks * 2 kap2 = 1 - py.exp(-s_dot / ks2) TMAX2 = py.zeros((len(kap2), len(prange))) # tphi = py.tan(phi) # keep tan(phi) handy for k_i in range(0, len(kap2)): k2_tmp = kap2[k_i] for p_j in range(0, len(prange)): p_tmp = prange[p_j] TMAX2[k_i][p_j] = k2_tmp * (c + p_tmp * tphi) + ( 1 - k2_tmp) * p_tmp * mu #fig = plt.figure() ax = fig.add_subplot(122) # should be ok to plot the surface # S, P = py.meshgrid(s_dot, prange) CS2 = plt.contour(S, P, TMAX2, 8, colors='k', linewidths=1.5) plt.clabel(CS2, inlne=1, fontsize=16) img2 = plt.imshow(TMAX2, interpolation='bilinear', origin='lower', cmap=cm.jet, extent=(min(s_dot), max(s_dot), min(prange), max(prange))) CBI2 = plt.colorbar(img2, orientation='vertical', shrink=0.8) CBI2.set_label(r'$\tau ,max $[psi]') ax.set_title(r'$\tau ,max = f(\sigma,\kappa), ks=%.2f $' % ks2) ax.set_xlabel('slip rate [in/sec]') ax.set_ylabel(r'$\sigma_z $', size=24)
def eval(self,values,x): values[0] = - x[0] * tan(alpha) \ - 1000.0 \ + 500.0 * sin(2*pi*x[0]/L) * sin(2*pi*x[1]/L)
def tau_a(p,mu,c,phi,j,k): tS = 1 - py.exp(-j/k) t1 = c*p*py.tan(phi) t2 = mu*p t_out = min(t1,t2)*tS return t_out
def stereoplot(strike, dip, filename): # Here is the stereonet plotting section bigr = 1.2 phid = pylab.arange(2, 90, 2) # Angular range for phir = phid * pylab.pi / 180 omegad = 90 - phid omegar = pylab.pi / 2 - phir # Set up for plotting great circles with centers along # positive x-axis x1 = bigr * pylab.tan(phir) y1 = pylab.zeros(pylab.size(x1)) r1 = bigr / pylab.cos(phir) theta1ad = (180 - 80) * pylab.ones(pylab.size(x1)) theta1ar = theta1ad * pylab.pi / 180 theta1bd = (180 + 80) * pylab.ones(pylab.size(x1)) theta1br = theta1bd * pylab.pi / 180 # Set up for plotting great circles # with centers along the negative x-axis x2 = -1 * x1 y2 = y1 r2 = r1 theta2ad = -80 * pylab.ones(pylab.size(x2)) theta2ar = theta2ad * pylab.pi / 180 theta2bd = 80 * pylab.ones(pylab.size(x2)) theta2br = theta2bd * pylab.pi / 180 # Set up for plotting small circles # with centers along the positive y-axis y3 = bigr / pylab.sin(omegar) x3 = pylab.zeros(pylab.size(y3)) r3 = bigr / pylab.tan(omegar) theta3ad = 3 * 90 - omegad theta3ar = 3 * pylab.pi / 2 - omegar theta3bd = 3 * 90 + omegad theta3br = 3 * pylab.pi / 2 + omegar # Set up for plotting small circles # with centers along the negative y-axis y4 = -1 * y3 x4 = x3 r4 = r3 theta4ad = 90 - omegad theta4ar = pylab.pi / 2 - omegar theta4bd = 90 + omegad theta4br = pylab.pi / 2 + omegar # Group all x, y, r, and theta information for great cricles phi = pylab.append(phid, phid, 0) x = pylab.append(x1, x2, 0) y = pylab.append(y1, y2, 0) r = pylab.append(r1, r2) thetaad = pylab.append(theta1ad, theta2ad, 0) thetaar = pylab.append(theta1ar, theta2ar, 0) thetabd = pylab.append(theta1bd, theta2bd, 0) thetabr = pylab.append(theta1br, theta2br, 0) # Plot portions of all great circles that lie inside the # primitive circle, with thick lines (1 pt.) at 10 degree increments for i in range(0, len(x)): thd = pylab.arange(thetaad[i], thetabd[i] + 1, 1) thr = pylab.arange(thetaar[i], thetabr[i] + pylab.pi / 180, pylab.pi / 180) xunit = x[i] + r[i] * pylab.cos(pylab.radians(thd)) yunit = y[i] + r[i] * pylab.sin(pylab.radians(thd)) # p = pylab.plot(xunit,yunit,'b',lw=.5) #commented out to remove small verticle lines pylab.hold(True) # Now "blank out" the portions of the great circle cyclographic traces # within 10 degrees of the poles of the primitive circle. rr = bigr / pylab.tan(80 * pylab.pi / 180) ang1 = pylab.arange(0, pylab.pi + pylab.pi / 180, pylab.pi / 180) xx = pylab.zeros(pylab.size(ang1)) + rr * pylab.cos(ang1) yy = bigr / pylab.cos(10 * pylab.pi / 180) * pylab.ones(pylab.size(ang1)) - rr * pylab.sin(ang1) p = pylab.fill(xx, yy, 'w') yy = -bigr / pylab.cos(10 * pylab.pi / 180) * pylab.ones(pylab.size(ang1)) + rr * pylab.sin(ang1) p = pylab.fill(xx, yy, 'w') for i in range(1, len(x)): thd = pylab.arange(thetaad[i], thetabd[i] + 1, 1) thr = pylab.arange(thetaar[i], thetabr[i] + pylab.pi / 180, pylab.pi / 180) xunit = x[i] + r[i] * pylab.cos(pylab.radians(thd)) yunit = y[i] + r[i] * pylab.sin(pylab.radians(thd)) if pylab.mod(phi[i], 10) == 0: p = pylab.plot(xunit, yunit, 'b', lw=1) angg = thetaad[i] pylab.hold(True) # Now "blank out" the portions of the great circle cyclographic traces # within 2 degrees of the poles of the primitive circle. rr = bigr / pylab.tan(88 * pylab.pi / 180) ang1 = pylab.arange(0, pylab.pi + pylab.pi / 180, pylab.pi / 180) xx = pylab.zeros(pylab.size(ang1)) + rr * pylab.cos(ang1) yy = bigr / pylab.cos(2 * pylab.pi / 180) * pylab.ones(pylab.size(ang1)) - rr * pylab.sin(ang1) p = pylab.fill(xx, yy, 'w') yy = -bigr / pylab.cos(2 * pylab.pi / 180) * pylab.ones(pylab.size(ang1)) + rr * pylab.sin(ang1) p = pylab.fill(xx, yy, 'w') # Group all x, y, r, and theta information for small circles phi = pylab.append(phid, phid, 0) x = pylab.append(x3, x4, 0) y = pylab.append(y3, y4, 0) r = pylab.append(r3, r4) thetaad = pylab.append(theta3ad, theta4ad, 0) thetaar = pylab.append(theta3ar, theta4ar, 0) thetabd = pylab.append(theta3bd, theta4bd, 0) thetabr = pylab.append(theta3br, theta4br, 0) # Plot primitive circle thd = pylab.arange(0, 360 + 1, 1) thr = pylab.arange(0, 2 * pylab.pi + pylab.pi / 180, pylab.pi / 180) xunit = bigr * pylab.cos(pylab.radians(thd)) yunit = bigr * pylab.sin(pylab.radians(thd)) p = pylab.plot(xunit, yunit) pylab.hold(True) # Plot portions of all small circles that lie inside the # primitive circle, with thick lines (1 pt.) at 10 degree increments for i in range(0, len(x)): thd = pylab.arange(thetaad[i], thetabd[i] + 1, 1) thr = pylab.arange(thetaar[i], thetabr[i] + pylab.pi / 180, pylab.pi / 180) xunit = x[i] + r[i] * pylab.cos(pylab.radians(thd)) yunit = y[i] + r[i] * pylab.sin(pylab.radians(thd)) blug = pylab.mod(thetaad[i], 10) if pylab.mod(phi[i], 10) == 0: p = pylab.plot(xunit, yunit, 'b', lw=1) angg = thetaad[i] # else: #Commented out to remove the small horizontal lines # p = pylab.plot(xunit,yunit,'b',lw=0.5) pylab.hold(True) # Draw thick north-south and east-west diameters xunit = [-bigr, bigr] yunit = [0, 0] p = pylab.plot(xunit, yunit, 'b', lw=1) pylab.hold(True) xunit = [0, 0] yunit = [-bigr, bigr] p = pylab.plot(xunit, yunit, 'b', lw=1) pylab.hold(True) ''' This is the plotting part''' trend1 = strike plunge1 = pylab.absolute(dip) # num = leng(lines1(:,1)); trendr1 = [foo * pylab.pi / 180 for foo in trend1] plunger1 = [foo * pylab.pi / 180 for foo in plunge1] rho1 = [bigr * pylab.tan(pylab.pi / 4 - ((foo) / 2)) for foo in plunger1] # polarb plots ccl from 3:00, so convert to cl from 12:00 # pylab.polar(pylab.pi/2-trendr1,rho1,'o') pylab.plot(9000, 90000, 'o', markerfacecolor="b", label='Positive Dip') pylab.plot(9000, 90000, 'o', markerfacecolor="w", label='Negative Dip') pylab.legend(loc=1) for n in range(0, len(strike)): if dip[n] > 0: pylab.plot(rho1[n] * pylab.cos(pylab.pi / 2 - trendr1[n]), rho1[n] * pylab.sin(pylab.pi / 2 - trendr1[n]), 'o', markerfacecolor="b", label='Positive Dip') else: pylab.plot(rho1[n] * pylab.cos(pylab.pi / 2 - trendr1[n]), rho1[n] * pylab.sin(pylab.pi / 2 - trendr1[n]), 'o', markerfacecolor="w", label='Negative Dip') '''above is self''' pylab.axis([-bigr, bigr, -bigr, bigr])
def tau_d2(th,th_m,th1,th2,r,b,n,k1,k2,c,K,phi,slip): j_disp = jdriven(th,th1,r,slip) if( j_disp < 0): j_disp = -j_disp tau_out = (c+sig_2(th,th_m,th1,th2,r,b,n,k1,k2)*py.tan(phi))*(1.0-py.exp(-j_disp/K)) return tau_out
plb.plot(D, plb.cos(D), color="blue", linewidth=2, linestyle="--") #13. Create some space on top and bottom of the plot (on the y axis) and show the grid plb.ylim(plb.sin(D).min() - 2, plb.sin(D).max() + 2) plb.grid() #14. Specify the following: Title, Y-axis label and legend to fit in the best way plb.legend(loc='lower right') plb.ylabel('amplitude', fontsize=10) plb.title('sin and cos') #15. Plot the tan of D, in location (2,1,2) with grid showing, X-axis label, Y-axis label # and legend on top right plb.subplot(2,1,2) plb.plot(D, plb.tan(D)) plb.grid() plb.xlabel('period', fontsize=10) plb.ylabel('amplitude', fontsize=10, ) plb.legend(loc='upper right') #16. Organize your code: use each line from this HW as a comment line before coding each step #17. Save these steps in a .py file and email it to me before next class. I will run it! plb.show() """ LECTURE ADVANCED PLOTTING """
def tau_t2(th,th0,th1,th2,r,b,n,k1,k2,c,K,phi,slip): j_disp = j2(th,th0,r,slip) if j_disp < 0: j_disp = -j_disp tau_out = (c+ sig_2(th,th0,th1,th2,r,b,n,k1,k2,)*py.tan(phi))*(1.0-py.exp(-j_disp/K) ) return tau_out
def contactAngleFunc(th0, i, phi): out = py.tan(degToRad(45.0)-phi/2.0) - (py.cos(th0) - (1.0/(1.0+i)) ) / py.sin(th0) return out
""" a blade with inclination angle from the vertical of beta Input: beta: angle from vertical Return: [Fp, Fn, Ft] the total, normal and tangent components of the blade force """ return (gamma*nPhi*z**2)/2.0 + 2.*c*py.sqrt(nPhi)*z + nPhi*gamma*sur*z def Ft_blade(z,nPhi,c,gamma,sur,beta) # default font size font = {'size' : 15} plt.rc('font', **font) # n_phi = tan(pi/4 + [0,pi/8])^2 nphi = py.tan(py.pi/4.+py.arange(0,py.pi/8.,py.pi/64.))**2 py.plot(py.arange(0,py.pi/4,py.pi/32.),nphi) py.xlabel(r'$\phi$ [rad]') py.ylabel(r'N$\phi$') py.grid(True) # soil properties gamma = 100./(12.**3.) # soil unit weight [lb/in3] c = 2.9 # cohesion, [psi] # variables to plot. b and Z can vary a lot, from 0 to ~1 foot # range of phi, nphi is smaller b = py.arange(1.0,10.0,0.2) # blade width [in] Z = py.arange(1.0,10.0,0.2) # blade depth [in] phi = py.arange(0,py.pi/4.,py.pi/128.) # internal friction angle nphi = py.tan(py.pi/4.+phi/2.0)**2 # flow value
def tau_b(p, mu, c, phi, j, k, kappa): tS = 1 - py.exp(-j / k) t1 = c * p * py.tan(phi) t2 = mu * p t_out = (kappa * t1 + (1 - kappa) * t2) * tS return t_out
import pylab pylab.figure() pylab.hold(True) I = pylab.arange(6) pylab.plot(I, pylab.sin(I), lw=4) pylab.plot(I, pylab.cos(I), lw=2) pylab.plot(I, pylab.tan(I), lw=1) pylab.show()
C = func_a_update() C = asarray(C) D = B + C[0:500] plb.figure(figsize=(10, 6), dpi=120) plb.subplot(2, 1, 1) plb.title('Plot of sin, cos functions') plb.plot(D, plb.sin(D), color="blue", linewidth=1.5, linestyle='-', label="sin") plb.hold(True) plb.plot(D, plb.cos(D), color="red", linewidth=1.2, linestyle='-.', label="cos") plb.grid() plb.ylabel('Y-Axis') plb.legend(loc="lower right") plb.subplot(2, 1, 2) plb.title('Plot for tan functions') plb.plot(D, plb.tan(D), color="red", linewidth=1.5, linestyle='-', label="tan") plb.xlabel('X-axis') plb.ylabel('Y-axis') plb.grid() plb.legend(loc="upper right") plb.show()
def setDiscGeo(geo, Type='Sanden', r2=0.001, **kwargs): """ Sets the discharge geometry for the compressor based on the arguments. Also sets the radius of the wall that contains the scroll set Arguments: geo : geoVals class class containing the scroll compressor geometry Type : string Type of discharge geometry, options are ['Sanden'],'2Arc','ArcLineArc' r2 : float or string Either the radius of the smaller arc as a float or 'PMP' for perfect meshing If Type is 'Sanden', this value is ignored Keyword Arguments: ======== ====================================================================== Value Description ======== ====================================================================== r1 the radius of the large arc for the arc-line-arc solution type ======== ====================================================================== """ #Recalculate the orbiting radius geo.ro = geo.rb * (pi - geo.phi_i0 + geo.phi_o0) if Type == 'Sanden': geo.x0_wall = 0.0 geo.y0_wall = 0.0 geo.r_wall = 0.065 setDiscGeo(geo, Type='ArcLineArc', r2=0.003178893902, r1=0.008796248080) elif Type == '2Arc': (x_is, y_is) = common_scroll_geo.coords_inv(geo.phi_is, geo, 0, 'fi') (x_os, y_os) = common_scroll_geo.coords_inv(geo.phi_os, geo, 0, 'fo') (nx_is, ny_is) = common_scroll_geo.coords_norm(geo.phi_is, geo, 0, 'fi') (nx_os, ny_os) = common_scroll_geo.coords_norm(geo.phi_os, geo, 0, 'fo') dx = x_is - x_os dy = y_is - y_os r2max = 0 a = cos(geo.phi_os - geo.phi_is) + 1.0 b = geo.ro * a - dx * (sin(geo.phi_os) - sin(geo.phi_is)) + dy * ( cos(geo.phi_os) - cos(geo.phi_is)) c = 1.0 / 2.0 * (2.0 * dx * sin(geo.phi_is) * geo.ro - 2.0 * dy * cos(geo.phi_is) * geo.ro - dy**2 - dx**2) if abs((geo.phi_os + pi) - geo.phi_is) < 1e-8: r2max = -c / b elif geo.phi_os - (geo.phi_is - pi) > 1e-12: r2max = (-b + sqrt(b**2 - 4.0 * a * c)) / (2.0 * a) else: print('error with starting angles phi_os %.16f phi_is-pi %.16f' % (geo.phi_os, geo.phi_is - pi)) if type(r2) is not float and r2 == 'PMP': r2 = r2max if r2 > r2max: print('r2 is too large, max value is : %0.5f' % (r2max)) xarc2 = x_os + nx_os * r2 yarc2 = y_os + ny_os * r2 r1 = ((1.0 / 2 * dy**2 + 1.0 / 2 * dx**2 + r2 * dx * sin(geo.phi_os) - r2 * dy * cos(geo.phi_os)) / (r2 * cos(geo.phi_os - geo.phi_is) + dx * sin(geo.phi_is) - dy * cos(geo.phi_is) + r2)) ## Negative sign since you want the outward pointing unit normal vector xarc1 = x_is - nx_is * r1 yarc1 = y_is - ny_is * r1 geo.xa_arc2 = xarc2 geo.ya_arc2 = yarc2 geo.ra_arc2 = r2 geo.t1_arc2 = math.atan2(yarc1 - yarc2, xarc1 - xarc2) geo.t2_arc2 = math.atan2(y_os - yarc2, x_os - xarc2) while geo.t2_arc2 < geo.t1_arc2: geo.t2_arc2 = geo.t2_arc2 + 2.0 * pi geo.xa_arc1 = xarc1 geo.ya_arc1 = yarc1 geo.ra_arc1 = r1 geo.t2_arc1 = math.atan2(y_is - yarc1, x_is - xarc1) geo.t1_arc1 = math.atan2(yarc2 - yarc1, xarc2 - xarc1) while geo.t2_arc1 < geo.t1_arc1: geo.t2_arc1 = geo.t2_arc1 + 2.0 * pi """ line given by y=m*t+b with one element at the intersection point with b=0, m=y/t """ geo.b_line = 0.0 geo.t1_line = xarc2 + r2 * cos(geo.t1_arc2) geo.t2_line = geo.t1_line geo.m_line = (yarc2 + r2 * sin(geo.t1_arc2)) / geo.t1_line """ Fit the wall to the chamber """ geo.x0_wall = geo.ro / 2.0 * cos(geo.phi_ie - pi / 2 - pi) geo.y0_wall = geo.ro / 2.0 * sin(geo.phi_ie - pi / 2 - pi) (x, y) = common_scroll_geo.coords_inv(geo.phi_ie, geo, pi, 'fo') geo.r_wall = 1.03 * sqrt((geo.x0_wall - x)**2 + (geo.y0_wall - y)**2) elif Type == 'ArcLineArc': (x_is, y_is) = common_scroll_geo.coords_inv(geo.phi_is, geo, 0, 'fi') (x_os, y_os) = common_scroll_geo.coords_inv(geo.phi_os, geo, 0, 'fo') (nx_is, ny_is) = common_scroll_geo.coords_norm(geo.phi_is, geo, 0, 'fi') (nx_os, ny_os) = common_scroll_geo.coords_norm(geo.phi_os, geo, 0, 'fo') dx = x_is - x_os dy = y_is - y_os r2max = 0 a = cos(geo.phi_os - geo.phi_is) + 1.0 b = geo.ro * a - dx * (sin(geo.phi_os) - sin(geo.phi_is)) + dy * ( cos(geo.phi_os) - cos(geo.phi_is)) c = 1.0 / 2.0 * (2.0 * dx * sin(geo.phi_is) * geo.ro - 2.0 * dy * cos(geo.phi_is) * geo.ro - dy**2 - dx**2) if geo.phi_os - (geo.phi_is - pi) > 1e-12: r2max = (-b + sqrt(b**2 - 4.0 * a * c)) / (2.0 * a) elif geo.phi_os - (geo.phi_is - pi) < 1e-12: r2max = -c / b else: print('error with starting angles phi_os %.16f phi_is-pi %.16f' % (geo.phi_os, geo.phi_is - pi)) if type(r2) is not float and r2 == 'PMP': r2 = r2max if r2 > r2max: print('r2 is too large, max value is : %0.5f' % (r2max)) xarc2 = x_os + nx_os * r2 yarc2 = y_os + ny_os * r2 if 'r1' not in kwargs: r1 = r2 + geo.ro else: r1 = kwargs['r1'] ## Negative sign since you want the outward pointing unit normal vector xarc1 = x_is - nx_is * r1 yarc1 = y_is - ny_is * r1 geo.xa_arc2 = xarc2 geo.ya_arc2 = yarc2 geo.ra_arc2 = r2 geo.t2_arc2 = math.atan2(y_os - yarc2, x_os - xarc2) geo.xa_arc1 = xarc1 geo.ya_arc1 = yarc1 geo.ra_arc1 = r1 geo.t2_arc1 = math.atan2(y_is - yarc1, x_is - xarc1) alpha = math.atan2(yarc2 - yarc1, xarc2 - xarc1) d = sqrt((yarc2 - yarc1)**2 + (xarc2 - xarc1)**2) beta = math.acos((r1 + r2) / d) L = sqrt(d**2 - (r1 + r2)**2) t1 = alpha + beta (xint, yint) = (xarc1 + r1 * cos(t1) + L * sin(t1), yarc1 + r1 * sin(t1) - L * cos(t1)) t2 = math.atan2(yint - yarc2, xint - xarc2) geo.t1_arc1 = t1 # (geo.t1_arc1,geo.t2_arc1)=sortAnglesCW(geo.t1_arc1,geo.t2_arc1) geo.t1_arc2 = t2 # (geo.t1_arc2,geo.t2_arc2)=sortAnglesCCW(geo.t1_arc2,geo.t2_arc2) while geo.t2_arc2 < geo.t1_arc2: geo.t2_arc2 = geo.t2_arc2 + 2.0 * pi while geo.t2_arc1 < geo.t1_arc1: geo.t2_arc1 = geo.t2_arc1 + 2.0 * pi """ line given by y=m*t+b with one element at the intersection point with b=0, m=y/t """ geo.m_line = -1 / tan(t1) geo.t1_line = xarc1 + r1 * cos(geo.t1_arc1) geo.t2_line = xarc2 + r2 * cos(geo.t1_arc2) geo.b_line = yarc1 + r1 * sin(t1) - geo.m_line * geo.t1_line """ Fit the wall to the chamber """ geo.x0_wall = geo.ro / 2.0 * cos(geo.phi_ie - pi / 2 - pi) geo.y0_wall = geo.ro / 2.0 * sin(geo.phi_ie - pi / 2 - pi) (x, y) = common_scroll_geo.coords_inv(geo.phi_ie, geo, pi, 'fo') geo.r_wall = 1.03 * sqrt((geo.x0_wall - x)**2 + (geo.y0_wall - y)**2) # f=pylab.Figure # pylab.plot(x_os,y_os,'o') # x=geo.xa_arc1+geo.ra_arc1*cos(np.linspace(geo.t1_arc1,geo.t2_arc1,100)) # y=geo.ya_arc1+geo.ra_arc1*sin(np.linspace(geo.t1_arc1,geo.t2_arc1,100)) # pylab.plot(x,y) # x=geo.xa_arc2+geo.ra_arc2*cos(np.linspace(geo.t1_arc2,geo.t2_arc2,100)) # y=geo.ya_arc2+geo.ra_arc2*sin(np.linspace(geo.t1_arc2,geo.t2_arc2,100)) # pylab.plot(x,y) # x=np.linspace(geo.t1_line,geo.t2_line,100) # y=geo.m_line*x+geo.b_line # pylab.plot(x,y) # pylab.plot(xint,yint,'^') # pylab.show() else: print('Type not understood:', Type)
def tau_b(p,mu,c,phi,j,k,kappa): tS = 1 - py.exp(-j/k) t1 = c*p*py.tan(phi) t2 = mu*p t_out = (kappa*t1 + (1-kappa)*t2)*tS return t_out
def tau_max_soil(p,c,phi): return c + p*py.tan(phi)
def tau_bek(th,th1,r,b,n,k1,k2,coh,phi,K,slip): j_disp = jdriven(th,th1,r,slip) tau_out = (coh +sig_bek(th,th1,r,b,n,k1,k2) *py.tan(phi) ) *(1.0 -py.exp(-j_disp /K) ) return tau_out
def eval(self,values,x): values[0] = -x[0]*tan(alpha) - 1000.0
def setDiscGeo(geo,Type='Sanden',r2=0.001,**kwargs): """ Sets the discharge geometry for the compressor based on the arguments. Also sets the radius of the wall that contains the scroll set Arguments: geo : geoVals class class containing the scroll compressor geometry Type : string Type of discharge geometry, options are ['Sanden'],'2Arc','ArcLineArc' r2 : float or string Either the radius of the smaller arc as a float or 'PMP' for perfect meshing If Type is 'Sanden', this value is ignored Keyword Arguments: ======== ====================================================================== Value Description ======== ====================================================================== r1 the radius of the large arc for the arc-line-arc solution type ======== ====================================================================== """ #Recalculate the orbiting radius geo.ro=geo.rb*(pi-geo.phi_i0+geo.phi_o0) if Type == 'Sanden': geo.x0_wall=0.0 geo.y0_wall=0.0 geo.r_wall=0.065 setDiscGeo(geo,Type='ArcLineArc',r2=0.003178893902,r1=0.008796248080) elif Type == '2Arc': (x_is,y_is) = common_scroll_geo.coords_inv(geo.phi_is,geo,0,'fi') (x_os,y_os) = common_scroll_geo.coords_inv(geo.phi_os,geo,0,'fo') (nx_is,ny_is) = common_scroll_geo.coords_norm(geo.phi_is,geo,0,'fi') (nx_os,ny_os) = common_scroll_geo.coords_norm(geo.phi_os,geo,0,'fo') dx=x_is-x_os dy=y_is-y_os r2max=0 a=cos(geo.phi_os-geo.phi_is)+1.0 b=geo.ro*a-dx*(sin(geo.phi_os)-sin(geo.phi_is))+dy*(cos(geo.phi_os)-cos(geo.phi_is)) c=1.0/2.0*(2.0*dx*sin(geo.phi_is)*geo.ro-2.0*dy*cos(geo.phi_is)*geo.ro-dy**2-dx**2) if abs((geo.phi_os+pi)-geo.phi_is) < 1e-8: r2max=-c/b elif geo.phi_os-(geo.phi_is-pi)>1e-12: r2max=(-b+sqrt(b**2-4.0*a*c))/(2.0*a) else: print('error with starting angles phi_os %.16f phi_is-pi %.16f' %(geo.phi_os,geo.phi_is-pi)) if type(r2) is not float and r2=='PMP': r2=r2max if r2>r2max: print('r2 is too large, max value is : %0.5f' %(r2max)) xarc2 = x_os+nx_os*r2 yarc2 = y_os+ny_os*r2 r1=((1.0/2*dy**2+1.0/2*dx**2+r2*dx*sin(geo.phi_os)-r2*dy*cos(geo.phi_os)) /(r2*cos(geo.phi_os-geo.phi_is)+dx*sin(geo.phi_is)-dy*cos(geo.phi_is)+r2)) ## Negative sign since you want the outward pointing unit normal vector xarc1 = x_is-nx_is*r1 yarc1 = y_is-ny_is*r1 geo.xa_arc2=xarc2 geo.ya_arc2=yarc2 geo.ra_arc2=r2 geo.t1_arc2=math.atan2(yarc1-yarc2,xarc1-xarc2) geo.t2_arc2=math.atan2(y_os-yarc2,x_os-xarc2) while geo.t2_arc2<geo.t1_arc2: geo.t2_arc2=geo.t2_arc2+2.0*pi; geo.xa_arc1=xarc1 geo.ya_arc1=yarc1 geo.ra_arc1=r1 geo.t2_arc1=math.atan2(y_is-yarc1,x_is-xarc1) geo.t1_arc1=math.atan2(yarc2-yarc1,xarc2-xarc1) while geo.t2_arc1<geo.t1_arc1: geo.t2_arc1=geo.t2_arc1+2.0*pi; """ line given by y=m*t+b with one element at the intersection point with b=0, m=y/t """ geo.b_line=0.0 geo.t1_line=xarc2+r2*cos(geo.t1_arc2) geo.t2_line=geo.t1_line geo.m_line=(yarc2+r2*sin(geo.t1_arc2))/geo.t1_line """ Fit the wall to the chamber """ geo.x0_wall=geo.ro/2.0*cos(geo.phi_ie-pi/2-pi) geo.y0_wall=geo.ro/2.0*sin(geo.phi_ie-pi/2-pi) (x,y)=common_scroll_geo.coords_inv(geo.phi_ie,geo,pi,'fo') geo.r_wall=1.03*sqrt((geo.x0_wall-x)**2+(geo.y0_wall-y)**2) elif Type=='ArcLineArc': (x_is,y_is) = common_scroll_geo.coords_inv(geo.phi_is,geo,0,'fi') (x_os,y_os) = common_scroll_geo.coords_inv(geo.phi_os,geo,0,'fo') (nx_is,ny_is) = common_scroll_geo.coords_norm(geo.phi_is,geo,0,'fi') (nx_os,ny_os) = common_scroll_geo.coords_norm(geo.phi_os,geo,0,'fo') dx=x_is-x_os dy=y_is-y_os r2max=0 a=cos(geo.phi_os-geo.phi_is)+1.0 b=geo.ro*a-dx*(sin(geo.phi_os)-sin(geo.phi_is))+dy*(cos(geo.phi_os)-cos(geo.phi_is)) c=1.0/2.0*(2.0*dx*sin(geo.phi_is)*geo.ro-2.0*dy*cos(geo.phi_is)*geo.ro-dy**2-dx**2) if geo.phi_os-(geo.phi_is-pi)>1e-12: r2max=(-b+sqrt(b**2-4.0*a*c))/(2.0*a) elif geo.phi_os-(geo.phi_is-pi)<1e-12: r2max=-c/b else: print('error with starting angles phi_os %.16f phi_is-pi %.16f' %(geo.phi_os,geo.phi_is-pi)) if type(r2) is not float and r2=='PMP': r2=r2max if r2>r2max: print('r2 is too large, max value is : %0.5f' %(r2max)) xarc2 = x_os+nx_os*r2 yarc2 = y_os+ny_os*r2 if 'r1' not in kwargs: r1=r2+geo.ro else: r1=kwargs['r1'] ## Negative sign since you want the outward pointing unit normal vector xarc1 = x_is-nx_is*r1 yarc1 = y_is-ny_is*r1 geo.xa_arc2=xarc2 geo.ya_arc2=yarc2 geo.ra_arc2=r2 geo.t2_arc2=math.atan2(y_os-yarc2,x_os-xarc2) geo.xa_arc1=xarc1 geo.ya_arc1=yarc1 geo.ra_arc1=r1 geo.t2_arc1=math.atan2(y_is-yarc1,x_is-xarc1) alpha=math.atan2(yarc2-yarc1,xarc2-xarc1) d=sqrt((yarc2-yarc1)**2+(xarc2-xarc1)**2) beta=math.acos((r1+r2)/d) L=sqrt(d**2-(r1+r2)**2) t1=alpha+beta (xint,yint)=(xarc1+r1*cos(t1)+L*sin(t1),yarc1+r1*sin(t1)-L*cos(t1)) t2=math.atan2(yint-yarc2,xint-xarc2) geo.t1_arc1=t1 # (geo.t1_arc1,geo.t2_arc1)=sortAnglesCW(geo.t1_arc1,geo.t2_arc1) geo.t1_arc2=t2 # (geo.t1_arc2,geo.t2_arc2)=sortAnglesCCW(geo.t1_arc2,geo.t2_arc2) while geo.t2_arc2<geo.t1_arc2: geo.t2_arc2=geo.t2_arc2+2.0*pi; while geo.t2_arc1<geo.t1_arc1: geo.t2_arc1=geo.t2_arc1+2.0*pi; """ line given by y=m*t+b with one element at the intersection point with b=0, m=y/t """ geo.m_line=-1/tan(t1) geo.t1_line=xarc1+r1*cos(geo.t1_arc1) geo.t2_line=xarc2+r2*cos(geo.t1_arc2) geo.b_line=yarc1+r1*sin(t1)-geo.m_line*geo.t1_line """ Fit the wall to the chamber """ geo.x0_wall=geo.ro/2.0*cos(geo.phi_ie-pi/2-pi) geo.y0_wall=geo.ro/2.0*sin(geo.phi_ie-pi/2-pi) (x,y)=common_scroll_geo.coords_inv(geo.phi_ie,geo,pi,'fo') geo.r_wall=1.03*sqrt((geo.x0_wall-x)**2+(geo.y0_wall-y)**2) # f=pylab.Figure # pylab.plot(x_os,y_os,'o') # x=geo.xa_arc1+geo.ra_arc1*cos(np.linspace(geo.t1_arc1,geo.t2_arc1,100)) # y=geo.ya_arc1+geo.ra_arc1*sin(np.linspace(geo.t1_arc1,geo.t2_arc1,100)) # pylab.plot(x,y) # x=geo.xa_arc2+geo.ra_arc2*cos(np.linspace(geo.t1_arc2,geo.t2_arc2,100)) # y=geo.ya_arc2+geo.ra_arc2*sin(np.linspace(geo.t1_arc2,geo.t2_arc2,100)) # pylab.plot(x,y) # x=np.linspace(geo.t1_line,geo.t2_line,100) # y=geo.m_line*x+geo.b_line # pylab.plot(x,y) # pylab.plot(xint,yint,'^') # pylab.show() else: print('Type not understood:',Type)
def lambert(r1vec,r2vec,tf,m,muC): # original documentation: # ············································· # # This routine implements a new algorithm that solves Lambert's problem. The # algorithm has two major characteristics that makes it favorable to other # existing ones. # # 1) It describes the generic orbit solution of the boundary condition # problem through the variable X=log(1+cos(alpha/2)). By doing so the # graph of the time of flight become defined in the entire real axis and # resembles a straight line. Convergence is granted within few iterations # for all the possible geometries (except, of course, when the transfer # angle is zero). When multiple revolutions are considered the variable is # X=tan(cos(alpha/2)*pi/2). # # 2) Once the orbit has been determined in the plane, this routine # evaluates the velocity vectors at the two points in a way that is not # singular for the transfer angle approaching to pi (Lagrange coefficient # based methods are numerically not well suited for this purpose). # # As a result Lambert's problem is solved (with multiple revolutions # being accounted for) with the same computational effort for all # possible geometries. The case of near 180 transfers is also solved # efficiently. # # We note here that even when the transfer angle is exactly equal to pi # the algorithm does solve the problem in the plane (it finds X), but it # is not able to evaluate the plane in which the orbit lies. A solution # to this would be to provide the direction of the plane containing the # transfer orbit from outside. This has not been implemented in this # routine since such a direction would depend on which application the # transfer is going to be used in. # # please report bugs to [email protected] # # adjusted documentation: # ······················· # # By default, the short-way solution is computed. The long way solution # may be requested by giving a negative value to the corresponding # time-of-flight [tf]. # # For problems with |m| > 0, there are generally two solutions. By # default, the right branch solution will be returned. The left branch # may be requested by giving a negative value to the corresponding # number of complete revolutions [m]. # Authors # .·`·.·`·.·`·.·`·.·`·.·`·.·`·.·`·.·`·.·`·.·`·.·`·.·`·.·`·.·`·. # Name : Dr. Dario Izzo # E-mail : [email protected] # Affiliation: ESA / Advanced Concepts Team (ACT) # Made readible and optimized for speed by Rody P.S. Oldenhuis # Code available in MGA.M on http://www.esa.int/gsp/ACT/inf/op/globopt.htm # last edited 12/Dec/2009 # ADJUSTED FOR EML-COMPILATION 24/Dec/2009 # initial values tol = 1e-12 bad = False days = 1 # work with non-dimensional units r1 = norm(r1vec) #sqrt(r1vec*r1vec.'); r1vec = r1vec/r1; r1vec = r1vec / r1 r2vec = r2vec / r1 V = sqrt(muC/r1) T = r1/V tf= tf*days/T # also transform to seconds # relevant geometry parameters (non dimensional) mr2vec = norm(r2vec) # make 100# sure it's in (-1 <= dth <= +1) dth = arccos( max(-1, min(1, (r1vec.dot(r2vec)/mr2vec)))) # decide whether to use the left or right branch (for multi-revolution # problems), and the long- or short way leftbranch = sign(m) longway = sign(tf) m = abs(m) tf = abs(tf) if (longway < 0): dth = 2*pi - dth # derived quantities c = sqrt(1.0 + mr2vec**2 - 2*mr2vec*cos(dth)) # non-dimensional chord s = (1.0 + mr2vec + c)/2.0 # non-dimensional semi-perimeter a_min = s/2.0 # minimum energy ellipse semi major axis Lambda = sqrt(mr2vec)*cos(dth/2.0)/s # lambda parameter (from BATTIN's book) crossprd = cross(r1vec,r2vec) mcr = norm(crossprd) # magnitues thereof nrmunit = crossprd/mcr # unit vector thereof # Initial values # ························································· # ELMEX requires this variable to be declared OUTSIDE the IF-statement logt = log(tf); # avoid re-computing the same value # single revolution (1 solution) if (m == 0): # initial values inn1 = -0.5233 # first initial guess inn2 = +0.5233 # second initial guess x1 = log(1 + inn1)# transformed first initial guess x2 = log(1 + inn2)# transformed first second guess # multiple revolutions (0, 1 or 2 solutions) # the returned soltuion depends on the sign of [m] else: # select initial values if (leftbranch < 0): inn1 = -0.5234 # first initial guess, left branch inn2 = -0.2234 # second initial guess, left branch else: inn1 = +0.7234 # first initial guess, right branch inn2 = +0.5234 # second initial guess, right branch x1 = tan(inn1*pi/2)# transformed first initial guess x2 = tan(inn2*pi/2)# transformed first second guess # since (inn1, inn2) < 0, initial estimate is always ellipse xx = array([inn1, inn2]) aa = a_min/(1 - xx**2) bbeta = longway * 2*arcsin(sqrt((s-c)/2./aa)) # make 100.4% sure it's in (-1 <= xx <= +1) if xx[0] > 1: xx[0] = 1 if xx[0] < -1: xx[0] = -1 if xx[1] > 1: xx[1] = 1 if xx[1] < -1: xx[1] = -1 aalfa = 2*arccos( xx ) # evaluate the time of flight via Lagrange expression y12 = aa*sqrt(aa)*((aalfa - sin(aalfa)) - (bbeta-sin(bbeta)) + 2*pi*m) # initial estimates for y if m == 0: y1 = log(y12[0]) - logt y2 = log(y12[1]) - logt else: y1 = y12[0] - tf y2 = y12[1] - tf # Solve for x # ························································· # Newton-Raphson iterations # NOTE - the number of iterations will go to infinity in case # m > 0 and there is no solution. Start the other routine in # that case err = 1e99 iterations = 0 xnew = 0 while (err > tol): # increment number of iterations iterations += 1 # new x xnew = (x1*y2 - y1*x2) / (y2-y1); # copy-pasted code (for performance) if m == 0: x = exp(xnew) - 1 else: x = arctan(xnew)*2/pi a = a_min/(1 - x**2); if (x < 1): # ellipse beta = longway * 2*arcsin(sqrt((s-c)/2/a)) # make 100.4% sure it's in (-1 <= xx <= +1) alfa = 2*arccos( max(-1, min(1, x)) ) else: # hyperbola alfa = 2*arccosh(x); beta = longway * 2*arcsinh(sqrt((s-c)/(-2*a))) # evaluate the time of flight via Lagrange expression if (a > 0): tof = a*sqrt(a)*((alfa - sin(alfa)) - (beta-sin(beta)) + 2*pi*m) else: tof = -a*sqrt(-a)*((sinh(alfa) - alfa) - (sinh(beta) - beta)) # new value of y if m ==0: ynew = log(tof) - logt else: ynew = tof - tf # save previous and current values for the next iterarion # (prevents getting stuck between two values) x1 = x2; x2 = xnew; y1 = y2; y2 = ynew; # update error err = abs(x1 - xnew); # escape clause if (iterations > 15): bad = True break # If the Newton-Raphson scheme failed, try to solve the problem # with the other Lambert targeter. if bad: # NOTE: use the original, UN-normalized quantities #[V1, V2, extremal_distances, exitflag] = ... # lambert_high_LancasterBlanchard(r1vec*r1, r2vec*r1, longway*tf*T, leftbranch*m, muC); print "FAILZ0r" return # convert converged value of x if m==0: x = exp(xnew) - 1 else: x = arctan(xnew)*2/pi #{ # The solution has been evaluated in terms of log(x+1) or tan(x*pi/2), we # now need the conic. As for transfer angles near to pi the Lagrange- # coefficients technique goes singular (dg approaches a zero/zero that is # numerically bad) we here use a different technique for those cases. When # the transfer angle is exactly equal to pi, then the ih unit vector is not # determined. The remaining equations, though, are still valid. #} # Solution for the semi-major axis a = a_min/(1-x**2); # Calculate psi if (x < 1): # ellipse beta = longway * 2*arcsin(sqrt((s-c)/2/a)) # make 100.4# sure it's in (-1 <= xx <= +1) alfa = 2*arccos( max(-1, min(1, x)) ) psi = (alfa-beta)/2 eta2 = 2*a*sin(psi)**2/s eta = sqrt(eta2); else: # hyperbola beta = longway * 2*arcsinh(sqrt((c-s)/2/a)) alfa = 2*arccosh(x) psi = (alfa-beta)/2 eta2 = -2*a*sinh(psi)**2/s eta = sqrt(eta2) # unit of the normalized normal vector ih = longway * nrmunit; # unit vector for normalized [r2vec] r2n = r2vec/mr2vec; # cross-products # don't use cross() (emlmex() would try to compile it, and this way it # also does not create any additional overhead) #crsprd1 = [ih(2)*r1vec(3)-ih(3)*r1vec(2),... # ih(3)*r1vec(1)-ih(1)*r1vec(3),... # ih(1)*r1vec(2)-ih(2)*r1vec(1)]; crsprd1 = cross(ih,r1vec) #crsprd2 = [ih(2)*r2n(3)-ih(3)*r2n(2),... # ih(3)*r2n(1)-ih(1)*r2n(3),... # ih(1)*r2n(2)-ih(2)*r2n(1)]; crsprd2 = cross(ih,r2n) # radial and tangential directions for departure velocity Vr1 = 1/eta/sqrt(a_min) * (2*Lambda*a_min - Lambda - x*eta) Vt1 = sqrt(mr2vec/a_min/eta2 * sin(dth/2)**2) # radial and tangential directions for arrival velocity Vt2 = Vt1/mr2vec Vr2 = (Vt1 - Vt2)/tan(dth/2) - Vr1 # terminal velocities V1 = (Vr1*r1vec + Vt1*crsprd1)*V V2 = (Vr2*r2n + Vt2*crsprd2)*V # exitflag #exitflag = 1 # (success) #print "V1:",V1 #print "V2:",V2 return V1,V2
def lecture_5_exercise(): # Work with only these imports: from numpy import matrix, array, random, min, max import pylab as plb print('''\n only using imports: from numpy import matrix, array, random, min, max import pylab as plb\n''') print('Part #1: Create the Data\n') # Create a list A of 600 random numbers bound between [0:10) a = list(random.random(600) * 10) print('Create a list A of 600 random numbers bound between [0:10):\n{0}\n'. format(a)) # Create an array B with with 500 elements bound in the range [-3*pi:2*pi] b = plb.linspace(3 * plb.pi, 2 * plb.pi, 500, endpoint=True) print( 'Create an array B with with 500 elements bound in the range [-3*pi:2*pi]:\n{0}\n' .format(b)) # Using if, for or while, create a func4on that overwrites every element in A that falls outside of the interval [2:9) print('''\n Using if, for or while, create a func4on that overwrites every element in A that falls outside of the interval [2:9) overwrite that element with the average between the smallest and largest element in A Normalize each list element to be bound between [0:0.1] def replace_values(x): avg = (min(x) + max(x)) / 2 for i in x: if i < 2 or i > 9: x[i] = avg x = [(float(y)/max(x) * 0.1) for y in x] return x\n''') def replace_values(x): for index, val in enumerate(x, start=0): if val < 2 or val > 9: # overwrite that element with the average between the smallest and largest element in A x[index] = (min(x) + max(x)) / 2 # Normalize each list element to be bound between [0:0.1] x[index] = x[index] / 10 return x # Return the result from the function to C c = replace_values(a) print('Return the result from the function to C:\n{0}\n'.format(c)) # Cast C as an array c = array(c) print('Cast C as an array\n') print('Type of c: {0}'.format(type(c))) # Add C to B (think of C as noise) and record the result in D d = c[0:len(b)] + b print( 'Add C to B (think of C as noise) and record the result in D:\n{0}\n'. format(d)) print('Part #2: Plotting\n') # Create a figure, give it a title and specify your own size and dpi fig = plb.figure(figsize=(6, 5), dpi=160) fig.canvas.set_window_title('Lecture 5 Class Exercise') # Plot the sin of D, in the (2,1,1) location of the figure plb.subplot(2, 1, 1) plb.plot(d, plb.sin(d), color="green", linewidth=.5, linestyle='-', label='sin curve') # Overlay a plot of cos using D, with different color, thickness and type of line plb.plot(d, plb.cos(d), color="grey", linewidth=.5, linestyle="--", label='cos line') # Create some space on top and bottom of the plot (on the y axis) and show the grid plb.ylim(plb.sin(d).min() - 1, plb.sin(d).max() + 1) plb.grid() # Specify the following: Title, Y-axis label and legend to fit in the best way plb.legend(loc='upper right') plb.ylabel('Fig 1', fontsize=10) plb.title('D sin & cos') # Plot the tan of D, in location (2,1,2) with grid showing, X-axis label, Y-axis label # and legend on top right plb.subplot(2, 1, 2) plb.plot(d, plb.tan(d), color='cyan', linewidth=0.5, label='tan line') plb.grid() plb.xlabel('label for x axis', fontsize=8) plb.ylabel( 'Fig 2', fontsize=9, ) plb.legend(loc='upper left') # Organize your code: use each line from this HW as a comment line before coding each step # Save these steps in a .py file and email it to me before next class. I will run it! plb.show()
def eval(self,values,x): values[0] = -x[0]*pylab.tan(alpha)
# 3 = metal, 4 = firm, 5 = medium, 6 = soft nuVect = py.array([3.0, 4.0, 5.0, 6.0]) Fvect = py.array([1650./4.0, 0.0, 1650]) platesize = 137.5 # p0 = Fz/platesize # minimum sum_stress to consider the contribution of cerruti as a percent of the sum min_sum_stress_cutoff = 2.0 # in this case, p0 = 12 psi # set the plotting limits. Think of [r,z] as [x,y], ... rlim = py.array([0.2,12.]) zlim = py.array([1.0,12.0]) # z is positive down in VTTI rz_rez = 0.2 # grid dim of SMASH R = py.arange(rlim[0],rlim[1]+rz_rez,rz_rez) Z = py.arange(zlim[0],zlim[1]+rz_rez,rz_rez) Rm,Zm = py.meshgrid(R,Z) # get a meshgrid rep of R,Z angDeg = 45 * py.pi/180.0 # cone angle off the horizontal, in degrees slope = py.tan(angDeg) for i in range(0, len(nuVect)): # current value of Frolich paramter, nu nu = nuVect[i] # Compute sigma_z for boussinesq and Cerruti BousMat = BC.get_BousPlateMat(Fvect,R,Z,nu,platesize,slope) # Question: is sigma_z negative when cos(theta) for the applied # surface force, H, is > pi [rad] ??? CerrMat = BC.get_CerrMat(Fvect,R,Z,platesize,slope) # figure out what sign Cerr. is to be, and superimpose # with bous superPosMat = BousMat + CerrMat # cerruti as a percent of the total stress. Note, avoid entries # with zero total stress cerrPercentMat = py.zeros((len(Z),len(R))) for row in range(0,len(Z)):
def eval(self,values,x): values[0] = -x[0]*pylab.tan(alpha) - 1000.0 + 500.0*pylab.sin(2*pylab.pi*x[0]/L)*pylab.sin(2*pylab.pi*x[1]/L)
ax = fig.add_subplot(1, 1, 1) # An Axes object is what you see as a plot. ax.plot(x, y) # Axes commands are what you use for plotting ax.set_title("More general way") # and decorating the plot. Many Axes commands ax.set_xlabel("x") # with `set_*` have a counterpart in the ax.set_ylabel("y") # pyplot namespace (e.g. `set_title`, `title`) plt.show() ### Third way: pylab # Less standard, so less recommended. Can be convenient though. del x, y # clear data variables from earlier; they will soon be born again import pylab as pl # matplotlib + numpy in one namespace # This is the same as the first example, but it is a bit more MATLAB-y because # all the numpy and plotting commands are available under pylab (pl). x = pl.linspace(0, 4 * pl.pi, 101) y = pl.tan(x) pl.plot(x, y) pl.title("pylab") pl.xlabel("x") pl.ylabel("y") pl.show() print("foo")
color='blue', linewidth=2.5, linestyle='--', label='cos') # Create some space on top and boZom of the plot (on the y axis) and show the grid plb.ylim(-1.5, 1.5) plb.grid() # Specify the following: title, Y-axis label and legend to fit in the best way plb.legend(loc='best') # Plot the tan of D, in location (2,1,2) with grid showing, X-axis label, Y-axis label and legend on top right plb.subplot(2, 1, 2) plb.plot(D, plb.tan(D), color='red', linewidth=1.5, linestyle='-.', label='tan') plb.xlabel('X Axis', fontsize=9, position=(0.65, 0), rotation=6, color='gray', alpha=0.75) plb.ylabel('Y Axis', fontsize=9, position=(0, 0.75), color='gray', alpha=0.75) plb.legend(loc='upper right') plb.grid() plb.show()
import pylab pylab.figure() pylab.hold(True) I = pylab.arange(6) pylab.plot(I,pylab.sin(I),lw=4) pylab.plot(I,pylab.cos(I), lw=2) pylab.plot(I,pylab.tan(I), lw=1) pylab.show()
return my_list C = array(my_overwrite(A)) # print(C) D = B + C[:500] # print(D) # fig = plb.figure() fig, axes = plb.subplots(nrows=2, ncols=1, figsize=(6, 4), dpi=100) axes[0].plot(plb.sin(D), color='red', lw=3, ls=' -- ', label='Sin of D') axes[0].plot(plb.cos(D), color='blue', lw=2, ls='-.', label='Cos of D') axes[0].grid() axes[0].set_ylabel('Y Axis') axes[0].set_xlabel('X Axis') axes[0].set_title('Signals') axes[0].legend(loc=0) axes[1].plot(plb.tan(D), label='Tan') axes[1].grid() axes[1].set_xlabel('X Axis') axes[1].set_ylabel('Y Axis') axes[1].legend(loc=0) print("Show me the Figure\n") plb.show()