def get_intersection_point(buy_x_list, buy_y_list, sell_x_list, sell_y_list, time=None): #calculate intersection point f_buy = lambda x: interp(x, buy_x_list, buy_y_list) f_sell = lambda x: interp(x, sell_x_list, sell_y_list) intersect_x = fsolve(lambda x : f_sell(x) - f_buy(x), 10000) return intersect_x, f_buy(intersect_x)
def fit_data(file_name, usecols, title, out_name, threshold=0.99, out_dir=os.environ['OBER'] + '/doc/qc'): '''Fit a curve QC data and calculate a cutoff.''' # Load data data = np.loadtxt(file_name, skiprows=1, usecols=usecols, dtype=float) r, n, c = data[::2, 0], data[::2, 1], data[::2, 2] has_data = (n > 0) r, n, c = r[has_data], n[has_data], c[has_data] r = 1.0 - r / r[-1] # Convert no call count to call rate # Fit model f, p = fit_curve(r, n, c) g = lambda x: model(x, *p) - threshold cutoff = fsolve(g, 0.5) # Generate plot plot_data_and_model(r, c, f, cutoff, title) P.savefig('%s/%s.png' % (out_dir, out_name)) if cutoff >= 1: print '%-40s: don\'t use at all' % (title, ) else: print '%-40s: %.2f mean %.3f' % (title, cutoff, 1 - np.mean(c)) return r, n, c
def focus_to_grating(x,y,z,xv,yv,zv,ga=ga,gb=gb,grating_r0=grating_r0,grating_z0=grating_z0,torus=torus,toroid_c=toroid_c): """ Returns the time a vector must travel from the focal point to hit the grating Done by solving xfoc+xv*t = xg for all 3 positional arguments and the equation of the (spherical or toroidal) grating """ if torus: def fz(t): return (toroid_c + toroid_pm2*sqrt( (x+xv*t)**2 + (z+zv*t-grating_z0+toroid_pm2*toroid_c)**2 ) )**2 + (y+yv*t)**2 - grating_r0**2 #return (z+zv*t) - sqrt( grating_r0**2 + toroid_c**2 - (x+xv*t)**2 - (y+yv*t)**2 - 2*sqrt( grating_r0**2*toroid_c**2 - toroid_c**2 * (y+yv*t)**2 )) t = fsolve(fz,1.0,warning=False) #import pdb; pdb.set_trace() else: term1 = (2*gb**2*x*xv + 2*ga**2*y*yv + 2*ga**2*gb**2*z*zv - 2*ga**2*gb**2*grating_z0*zv) term2 = -1.0* sqrt((-2*gb**2*x*xv - 2*ga**2*y*yv - 2*ga**2*gb**2*z*zv + 2*ga**2*gb**2*grating_z0*zv)**2 - 4*(ga**2*gb**2*grating_r0**2 - gb**2*x**2 - ga**2*y**2 - ga**2*gb**2*z**2 + 2*ga**2*gb**2*z*grating_z0 - ga**2*gb**2*grating_z0**2)*(-gb**2*xv**2 - ga**2*yv**2 - ga**2*gb**2*zv**2)) term3 = 1.0/(2*(-gb**2*xv**2 - ga**2*yv**2 - ga**2*gb**2*zv**2)) #toroid_c = 0.0 #def fz(t): # return (toroid_c - sqrt( (x+xv*t)**2 + (z+zv*t-grating_z0)**2 ) )**2 + (y+yv*t)**2 - grating_r0**2 # #return (z+zv*t) + sqrt( grating_r0**2 - (x+xv*t)**2 - (y+yv*t)**2 + 2*sqrt( grating_r0**2 * (y+yv*t)**2 )) if isnan(term1) or isnan(term2) or isnan(term3): pdb.set_trace() #t1 = fsolve(fz,1.88,warning=False) #t2 = newton(fz,1.88,tol=1e-35) t = (term1+term2)*term3 #print t,t1,t2 #import pdb; pdb.set_trace() return t
def fsolve_fn(s, t): rout.start() ## rerr.start() res = minpack.fsolve(f, x0, args=(t,) + extrafargs, xtol=xtolval, maxfev=maxnumiter, fprime=fprime) rout.stop() ## warns = rout.stop() ## rerr.stop() return res
def fsolve_fn(s, t): with RedirectStdout(_logfile): res = minpack.fsolve(f, x0, args=(t, ) + extrafargs, xtol=xtolval, maxfev=maxnumiter, fprime=fprime) return res
def fsolve_fn(s, t): rout.start() ## rerr.start() res = minpack.fsolve(f, x0, args=(t, ) + extrafargs, xtol=xtolval, maxfev=maxnumiter, fprime=fprime) rout.stop() ## warns = rout.stop() ## rerr.stop() return res
def BEM(self): L = self.L R = self.R self.Ubem = np.zeros([L, 2]) self.Ubem[0] = self.Uzero for j in np.arange(L-1): self.Winc = np.sum(self.dWj[:, R * (j) : R * (j + 1)], axis=1) self.Winc = self.Winc.reshape([2, 1]) uj = self.Ubem[j,:].reshape([2, 1]) increment = fsolve(self.ai, uj, args=(j)).reshape([2, 1]) self.Ubem[j+1, :] = increment[:, 0] ubem = self.Ubem return ubem
def find_reference_sphere_radius(ip, pl): """Find the radius os the reference sphere that best fits the input data. This method assumes that the optical axis coincides with the z axis. This means that the center of the sphere, has coordinates (0,0,r). Parameters ---------- ip : list list of the points where the optical path is measured, that are being fitted. Each point is (XYZ) tuple. It can be also an array with a shape n,3 where n is the number of points. pl : list List of path lengths. pl[i] corresponds to the point ip[i]. Returns ------- float Reference sphere radius """ ipa = array(ip) pla = array(pl) n, t = ipa.shape # Find the point closest to the center of the aperture. rm = sqrt(dot(ipa[0], ipa[0])) im = 0 for i in range(n): if rm > sqrt(dot(ipa[i], ipa[i])): rm = sqrt(dot(ipa[i], ipa[i])) im = i #Make the OPL 0 at the center of the aperture pla = pla - pla[im] #Encontrar el radio de la esfera de mejor ajuste def F(z): dist = pla - (sqrt(ipa[:, 0]**2 + ipa[:, 1]**2 + (ipa[:, 2] - z)**2) - z) u = sqrt((dist**2).sum()) #print "*", u #u=dist[-1] #print u return u r = fsolve(F, -10.) return r
def find_reference_sphere_radius(ip, pl): """Find the radius os the reference sphere that best fits the input data. This method asumes that the optical axis coincides with the z axis. This means that the center of the sphere, has coordinates (0,0,r). Attributes: ip list of the points where the optical path is measured, that are being fitted. Each point is (XYZ) tuple. It can be also an array with a shape n,3 where n is the numbre of points. pl List of path lengths. pl[i] corresponds to the point ip[i]. """ ipa=array(ip) pla=array(pl) n, t=ipa.shape # Find the point closest to the center of the aperture. rm=sqrt(dot(ipa[0], ipa[0])) im=0 for i in range (n): if rm>sqrt(dot(ipa[i], ipa[i])): rm=sqrt(dot(ipa[i], ipa[i])) im=i #Make the OPL 0 at the center of the aperture pla=pla-pla[im] #Encontrar el radio de la esfera de mejor ajuste def F(z): dist=pla-(sqrt(ipa[:, 0]**2+ipa[:, 1]**2+(ipa[:, 2]-z)**2)-z) u=sqrt((dist**2).sum()) #print "*", u #u=dist[-1] #print u return u r=fsolve(F, -10.) return r
def find_steady_states(rates, sos_counts, ras, rasgap, rasgrp, guesses, output_dirname="output"): """ Solve for steady states. We start with the guesses obtained from solving the ODE to plot it. We then bootstrap to get all the intermediate points. """ print(guesses) last = None steady_states = [] for sos_mol in sos_counts: sos = Sos(num_molecules=sos_mol) reactions = Reactions(rates, sos.num_molecules, ras.num_molecules, rasgap.num_molecules, rasgrp.num_molecules) try: guess = guesses[sos_mol] except KeyError: guess = last steady_state_y = fsolve(dy_dt, guess, args=(0, reactions)) print("Steady Y: {}".format(steady_state_y)) last = steady_state_y steady_states.append(steady_state_y) # Steady states by starting Sos molecules steady_states = np.array(steady_states) plt.figure(figsize=[10, 8]) plt.plot(sos_counts, steady_states[:, 0], "o", label="SOS") plt.plot(sos_counts, steady_states[:, 1], "o", label="SOS-RasGTP") plt.plot(sos_counts, steady_states[:, 2], "o", label="RasGTP") plt.legend() plt.xlabel("Initial SOS Count") plt.ylabel("Steady State Count") title = "Das Minimal Model- Steady State RasGTP" dirname = os.path.join(output_dirname, "steady_states") if not os.path.exists(dirname): os.mkdir(dirname) plt.title(title) plt.savefig(os.path.join(dirname, title.replace(" ", "-") + ".png")) # plt.show() plt.close() return steady_states
def solve(self, graph): new_graph = deepcopy(graph) new_graph.ns_x_mesh.phi_old = deepcopy(graph.ns_x_mesh.phi) new_graph.ns_y_mesh.phi_old = deepcopy(graph.ns_y_mesh.phi) new_graph.pressure_mesh.phi_old = deepcopy(graph.pressure_mesh.phi) pressure_mesh = new_graph.pressure_mesh ns_x_mesh = new_graph.ns_x_mesh ns_y_mesh = new_graph.ns_y_mesh # Prepare initial guess X = _create_X(ns_x_mesh.phi, ns_y_mesh.phi, pressure_mesh.phi, new_graph) if PLOT_JACOBIAN: from lid_driven_cavity_problem.nonlinear_solver._utils import _plot_jacobian _plot_jacobian(new_graph, X) assert False, "Finished plotting Jacobian matrix. Program will be terminated (This is expected behavior)" X_, infodict, ier, mesg = fsolve(self._residual_f, X, args=(new_graph, ), full_output=True) if SHOW_SOLVER_DETAILS: logger.info("Number of function calls=%s" % (infodict['nfev'], )) if ier == 1: logger.info("Converged") else: logger.info("Diverged") logger.info(mesg) if not IGNORE_DIVERGED: if not ier == 1: raise SolverDivergedException() U, V, P = _recover_X(X_, new_graph) new_graph.ns_x_mesh.phi = U new_graph.ns_y_mesh.phi = V new_graph.pressure_mesh.phi = P return new_graph
def fit_data(file_name, usecols, title, out_name, threshold=0.99, out_dir=os.environ['OBER'] + '/doc/qc'): '''Fit a curve QC data and calculate a cutoff.''' # Load data data = np.loadtxt(file_name, skiprows=1, usecols=usecols, dtype=float) r, n, c = data[::2, 0], data[::2, 1], data[::2, 2] has_data = (n > 0) r, n, c = r[has_data], n[has_data], c[has_data] r = 1.0 - r / r[-1] # Convert no call count to call rate # Fit model f, p = fit_curve(r, n, c) g = lambda x: model(x, *p) - threshold cutoff = fsolve(g, 0.5) # Generate plot plot_data_and_model(r, c, f, cutoff, title) P.savefig('%s/%s.png' % (out_dir, out_name)) if cutoff >= 1: print '%-40s: don\'t use at all' % (title,) else: print '%-40s: %.2f mean %.3f' % (title, cutoff, 1 - np.mean(c)) return r, n, c
# Find fixed point of map def fp_residual(ic): x0 = ic[0] ## print "\nfp_residual: x0 = ", x0 v = return_map({'x': x0}) print v return v-ic[0] print "Finding fixed point of return map as function of initial condition" # Equally efficient alternatives to shoot for f.p. solution x0_guess = map_ics['x'] sol_pdc = minpack.fsolve(fp_residual, array([x0_guess]), xtol=1e-6) print "sol_pdc = ", sol_pdc traj,pts=getTraj({'y':0,'x':sol_pdc}, t1=10, termFlag=False) map.set(ics={'x':sol_pdc}) print "Initializing PyCont to follow y=0 crossing as parameter m varied:" pc=ContClass(map) pcargs=args(name='FPu', type='FP-C', freepars = ['m'], StepSize = 1e-1, MaxNumPoints = 30, # 40 causes IndexError in PyCont/BifPoint.py, line 149
def fp_beta_newton(b, x0): SLIP_map.set(pars={'beta': b}) x0['z'] = math.sin(b) x0['y'] = math.cos(b) x1 = pdc_map(x0) return x1['zdot'] - x0['zdot'] # Point icdict_pert = copy(icdict) icpt = Point({'coorddict': icdict_pert}) print("\nFinding fixed point of periodic map as a function of beta") # Equally efficient alternatives to shoot for f.p. solution beta_pdc = minpack.fsolve(fp_beta_fsolve, beta, args=(icpt, ), xtol=1e-4) ##beta_pdc = minpack.newton(fp_beta_newton, beta, args=(icpt,), tol=1e-4) beta_pdc_known = 1.21482619378 print("beta_pdc = ", beta_pdc) assert abs(beta_pdc - beta_pdc_known) < 1e-4, "beta_pdc was not found accurately" # update i.c. for new beta icdict_pert['z'] = math.sin(beta_pdc) icdict_pert['y'] = math.cos(beta_pdc) icdict_maps = copy(icdict_pert) icpt = Point({'coorddict': icdict_maps}) print("\nCalculating approximation to periodic maps") SLIP_map.set(pars={'beta': beta_pdc}) states = [icpt] for i in range(5):
def solwave_m1(c, n, d, M, dist = pi / 2., xtol = 1.e-12, verbose = False): """ Compute the collocation points and values for the general d-dimensional solitary wave equation with n > 1, and m=1 Inputs: c - soliton parameter, n - first nonlinearity, d - dimension, M - No. of points, [dist = pi/2] - distance from the x axis to the nearest singularity in the complex plane, [xtol = 1.e-12] - solver tolerance, [verbose=True/False] Outputs: r, f - collocation points and the soliton """ # Iterate in soliton parameter, if neccessary, to achieve a good # guess. This may be replaced with another algorithm if a better # initial guess for the 1D soliton is available. if verbose: print " iterating in c" # Initial value for delta c. This can be tuned as needed. delta_c = .5 * n / c # Loop will terminate if the delta c value gets too small, this may be # adjusted as needed delta_c_min = 1.e-6 c0 = n d0 = 1. while c0 < c and delta_c > delta_c_min: c1 = min([c0 + delta_c, c]) decay = sqrt(1. - n / c1) h = sqrt((pi * dist) / (decay * M)) r1 = sinc_eo.points(M, h) D2 = sinc_eo.D2_e(M, h) D1 = sinc_eo.D1_eo(M, h) D1_r = sinc_eo.D1_x_e(M, h) IN1 = sinc_eo.IN1_oe(M, h) params = {'c': c1, 'n': n, 'd': d0, 'D2': D2, 'D1': D1, 'D1_r': D1_r, 'IN': IN1} try: # uguess = spline(r0, u0, r1) uguess = sinc_eo.sincinterp_e(r0,u0,r1) except: uguess = 3. * (1. - n / c1) / cosh(.5 * decay * r1)**2 if verbose: print ' computing with c = ', c1 u1, infodict, ier, mesg = \ fsolve(lambda v: solwave_m1_eq(v,params), uguess, \ # fprime = lambda v:solwave_m1_eq_jac(v, params), \ xtol= xtol, full_output=1) if ier == 1 and np.max(np.abs(u1)) > 1.e-10: c0 = c1 u0 = u1 r0 = r1 else: if verbose: if np.max(np.abs(u1)) <= 1.e-8: print " converged to the zero solution, adjusteing delta_c" else: print " solver failed to converge, adjusting delta_c" print " solver err = ", ier delta_c = delta_c / 2. u = u0 r = r0 # Iterate in dimension, if neccessary if d > 1.: if verbose: print " iterating in d" delta_dim = (n - 1.) / 10. # Loop will terminate if the delta dim value gets too # small, this can be adjusted as desired delta_dim_min = 1.e-6 d0 = 1. u0 = u while d0 < d and delta_dim > delta_dim_min: d1 = min([d0 + delta_dim, d]) params['d'] = d1 if verbose: print ' computing with d = ', d1 u1, infodict, ier, mesg = \ fsolve(lambda v: solwave_m1_eq(v, params), u0, \ # fprime = lambda v:solwave_m1_eq_jac(v, params), xtol= xtol, full_output=1) if ier == 1 and np.max(np.abs(u1)) > 1.e-8: d0 = d1 u0 = u1 else: if verbose: if np.max(np.abs(u1)) <= 1.e-8: print " converged to the zero solution, adjusteing delta_dim" else: print " solver failed to converge, adjusting delta_dim" print " solver err = ", ier delta_dim = delta_dim / 2. u = u0 if d0 < d: print " Failed to converge to the soliton solution, last value of d =", d0 f = 0.0 else: f = 1. + u return r, f
def fsolve_fn(s, t): with RedirectStdout(_logfile): res = minpack.fsolve(f, x0, args=(t,)+extrafargs, xtol=xtolval, maxfev=maxnumiter, fprime=fprime) return res
def solwave_mck(c, d, M, dist = pi / 2., xtol = 1.e-12, verbose = False): """ Compute the collocation points and values for the d-dimensional McKenzie solitary wave equation. n=3, m=0. Inputs: c - soliton parameter, d - dimension, M - No. of points, [dist = pi/2] - distance from the x axis to the nearest singularity in the complex plane, [xtol = 1.e-12] - solver tolerance, [verbose=True/False] Outputs: r, f - collocation points and the soliton """ decay = sqrt(1. - 3. / c) h = sqrt((pi * dist) / (decay * M)) r = sinc_eo.points(M, h) u0 = magma1d.solwave_mck(r, c) - 1. d0 = 1. D2 = sinc_eo.D2_e(M, h) D1 = sinc_eo.D1_eo(M, h) D1_r = sinc_eo.D1_x_e(M, h) IN1 = sinc_eo.IN1_oe(M, h) params = {'c': c, 'd': d0, 'D2': D2, 'D1':D1, 'D1_r':D1_r, 'IN': IN1} if d < 2.: params['d'] = d u = fsolve(lambda v: solwave_mck_eq(v, params), u0, fprime = lambda v:solwave_mck_eq_jac(v, params), xtol= xtol) else: # Initial value for the delta dimension value. # This can be tuned as needed delta_dim = (d - 1.)/10. # Loop will terminate if the delta dim value gets too # small, this may be tunded as needed delta_dim_min = 1.e-6 d0 = 1. while d0 < d and delta_dim > delta_dim_min: d1 = min([d0 + delta_dim, d]) params['d'] = d1 if verbose: print ' computing with d = ', d1 u1, infodict, ier, mesg = \ fsolve(lambda v:solwave_mck_eq(v,params), u0, \ fprime =lambda v:solwave_mck_eq_jac(v, params), \ xtol= xtol, full_output=1) if ier == 1 and np.max(np.abs(u1)) > 1.e-8: d0 = d1 u0 = u1 else: if verbose: if np.max(np.abs(u1)) <= 1.e-8: print " converged to the zero solution, adjusteing delta_dim" else: print " solver failed to converge, adjusting delta_dim" print " solver err = ", ier delta_dim = delta_dim / 2. if verbose: jac = solwave_mck_eq_jac(u1, params) condnum = np.linalg.cond(jac) print " condition number = ", condnum u = u0 if d0 < d: print " Failed to converge to the soliton solution, last value of d =", d0 f = 0.0 else: f = 1. + u return r, f
m2 = 2150 delta_f2 = f0 * 1e9 / m2 L2 = 1e6 * c / (2 * n2 * delta_f2) def VCCL_threshold_static(x): k = 2 * pi / x[0] g1 = x[1] / 20000 g2 = g1 * L1 / L2 y1 = r1 * r2 * cmath.exp(2 * g1 * L1 + 2 * 1j * k * n1 * L1) y2 = r1 * r2 * cmath.exp(2 * g2 * L2 + 2 * 1j * k * n2 * L2) yc = C11 * y1 + C22 * y2 - (C11 * C22 - C12 * C21) * y1 * y2 - 1 yr = yc.real yi = yc.imag return [yr, yi] X = fsolve(VCCL_threshold_static, [lambda0, gain0]) # Calculate the effective "reflectivity" of the second cavity as seen by the first cavity, and vice versa wavelength = numpy.arange(1530, 1570, 0.0005) k = 2000 * pi / wavelength g1 = X[1] / 20000 g2 = g1 * L1 / L2 y2 = numpy.exp(2 * g2 * L2) * numpy.exp(2 * 1j * k * n2 * L2) eta2 = C11 + C12 * C21 * r1 * r2 * y2 / (1 - C22 * r1 * r2 * y2); ETA2 = (numpy.absolute(eta2)) ** 2; y1 = numpy.exp(2 * g1 * L1) * numpy.exp(2 * 1j * k * n1 * L1); eta1 = C22 + C12 * C21 * r1 * r2 * y1 / (1 - C11 * r1 * r2 * y1); ETA1 = (numpy.absolute(eta1)) ** 2; pyplot.figure() pyplot.plot(wavelength, ETA1, ':k', label='ETA1')
plt.savefig(fname) def error(f, x, y): return np.sum((f(x) - y)**2) plot_models(x, y, None, os.path.join(CHART_DIR, "1400_01_01.png")) fp1, res1, rank1, sv1, rcond1 = np.polyfit(x, y, 1, full=True) print("Parámetros del modelo fp1: %s" % fp1) print("Error del modelo fp1:", res1) f1 = sp.poly1d(fp1) fp2, res2, rank2, sv2, rcond2 = np.polyfit(x, y, 2, full=True) print("Parámetros del modelo fp2: %s" % fp2) print("Error del modelo fp2:", res2) f2 = sp.poly1d(fp2) funcion_definitiva = sp.poly1d(np.polyfit(x, y, 5)) funcion_definitiva1 = sp.poly1d(np.polyfit(x, y, 6)) funcion_definitiva2 = sp.poly1d(np.polyfit(x, y, 10)) funcion_definitiva3 = sp.poly1d(np.polyfit(x, y, 20)) funcion_definitiva4 = sp.poly1d(np.polyfit(x, y, 25)) plot_models(x, y, [funcion_definitiva, funcion_definitiva1], os.path.join(CHART_DIR, "1400_01_02.png")) prediccion = fsolve(funcion_definitiva, x0=165) print('Esperamos encontrar 0 casos diarios el dia: ', prediccion)
return [yr, yi] I3 = numpy.arange(0, 0.8, 0.001) # 波长转换区电流(A) lambda1 = I3.copy() for ii in range(0, I3.size): a = C b = B c1 = A d = -I3[ii] / e / V3 D = [a, b, c1, d] NN3 = roots(D) for r in [0, 1, 2]: if (NN3[r].imag == 0) and (NN3[r] >= 0): N3 = NN3[r] delta_n3 = tau_p * dn_dN * N3 # the carrier-induced index change # Calculate threshold gains of various modes wl = numpy.arange(1, 10, 1) threshold_gain = numpy.arange(1, 10, 1) for m in range(m1 - 4, m1 + 5): lmd = 1e6 * c / (m * delta_f1) X1 = fsolve(VCCL_threshold_dynamic, [lmd, 0.95 * gain0]) wl[m - m1 + 4] = X1[0] * 1000 threshold_gain[m - m1 + 4] = X1[1] lambda1[ii] = wl[threshold_gain.argmin()] pyplot.figure() pyplot.plot(I3[0:I3.size-2], lambda1[0:I3.size-2], ':k+') pyplot.xlabel('$Wavelength switching section current (A)$') pyplot.ylabel('$laser wavelength (nm)$') pyplot.show()
def redise(p0, x, y): a, b = p0 return (y - (a * x + b)) data = sp.genfromtxt("web_traffic.tsv", "\t") y = data[:, 1] x = data[:, 0] x_clean = x[np.where(y > -1)] y_clean = y[np.where(y > -1)] rs1 = leastsq(redise, [0, 0], args=(x_clean, y_clean)) rs2 = polyfit(x_clean, y_clean, 2, full=True) rs5 = polyfit(x_clean, y_clean, 25, full=True) y_predit1 = rs1[0][0] * x_clean + rs1[0][1] y_predit2 = sp.poly1d(rs2[0]) y_predit5 = sp.poly1d(rs5[0]) print y_predit2 result = fsolve(y_predit2 - 10000, 0) print result pt.plot(x_clean, y_clean, '.') pt.plot(x_clean, y_predit1, '-', label="predit1") pt.plot(x_clean, y_predit2(x_clean), '-', label="predit2") pt.plot(x_clean, y_predit5(x_clean), '-', label='predit5') pt.legend() pt.show()
def fp_beta_newton(b, x0): SLIP_map.set(pars={'beta': b}) x0['z'] = math.sin(b) x0['y'] = math.cos(b) x1 = pdc_map(x0) return x1['zdot']-x0['zdot'] # Point icdict_pert = copy(icdict) icpt = Point({'coorddict': icdict_pert}) print "\nFinding fixed point of periodic map as a function of beta" # Equally efficient alternatives to shoot for f.p. solution beta_pdc = minpack.fsolve(fp_beta_fsolve, beta, args=(icpt,), xtol=1e-4) ##beta_pdc = minpack.newton(fp_beta_newton, beta, args=(icpt,), tol=1e-4) beta_pdc_known = 1.21482619378 print "beta_pdc = ", beta_pdc assert abs(beta_pdc-beta_pdc_known)<1e-4, "beta_pdc was not found accurately" # update i.c. for new beta icdict_pert['z'] = math.sin(beta_pdc) icdict_pert['y'] = math.cos(beta_pdc) icdict_maps = copy(icdict_pert) icpt = Point({'coorddict': icdict_maps}) print "\nCalculating approximation to periodic maps" SLIP_map.set(pars={'beta': beta_pdc}) states = [icpt] for i in range(5): states.append(pdc_map(states[-1]))
# Find fixed point of map def fp_residual(ic): x0 = ic[0] ## print "\nfp_residual: x0 = ", x0 v = return_map({'x': x0}) print v return v - ic[0] print "Finding fixed point of return map as function of initial condition" # Equally efficient alternatives to shoot for f.p. solution x0_guess = map_ics['x'] sol_pdc = minpack.fsolve(fp_residual, array([x0_guess]), xtol=1e-6) print "sol_pdc = ", sol_pdc traj, pts = getTraj({'y': 0, 'x': sol_pdc}, t1=10, termFlag=False) map.set(ics={'x': sol_pdc}) print "Initializing PyCont to follow y=0 crossing as parameter m varied:" pc = ContClass(map) pcargs = args( name='FPu', type='FP-C', freepars=['m'], StepSize=1e-1, MaxNumPoints=30, # 40 causes IndexError in PyCont/BifPoint.py, line 149