def fgrad_y_psi(self, y, psi, return_covar_chain=False): """ gradient of f w.r.t to y and psi returns: NxIx3 tensor of partial derivatives """ # 1. exponentiate the a and b (positive!) mpsi = psi.copy() mpsi[:, 0:2] = SP.exp(mpsi[:, 0:2]) w, s, r, d = self.fgrad_y(y, psi, return_precalc=True) gradients = SP.zeros((y.shape[0], len(mpsi), 3)) for i in range(len(mpsi)): a, b, c = mpsi[i] gradients[:, i, 0] = a * (b * (1.0 / SP.cosh(s[i]))**2).flatten() gradients[:, i, 1] = b * (a * (1 - 2 * s[i] * r[i]) * (1.0 / SP.cosh(s[i]))**2).flatten() gradients[:, i, 2] = (-2 * a * (b**2) * r[i] * ((1.0 / SP.cosh(s[i]))**2)).flatten() covar_grad_chain = SP.zeros((y.shape[0], len(mpsi), 3)) import numpy as NP for i in range(len(mpsi)): a, b, c = mpsi[i] covar_grad_chain[:, i, 0] = a * (r[i]) covar_grad_chain[:, i, 1] = b * (a * (c + y[:, 0]) * (1.0 / SP.cosh(s[i]))**2) covar_grad_chain[:, i, 2] = a * b * ((1.0 / SP.cosh(s[i]))**2).flatten() if return_covar_chain: return gradients, covar_grad_chain return gradients
def backward_pass(self, a1L, a1R, a2L, a2LR, a2R, a3, z1Lb, z1LRb, z1Rb, z2b, xLb, xRb, t): # Third Layer if self.k == 2 : r3= -t*self.sigmoid(-t*a3) else : r3 = a3 - t grad3=sp.dot(r3,z2b.T) # Second Layer r3w3T = sp.dot(self.w3[:,:-1].T, r3) r2L=r3w3T*a2LR*self.sigmoid(a2R)*self.divsigmoid(a2L) r2R=r3w3T*a2LR*self.sigmoid(a2L)*self.divsigmoid(a2R) r2LR=r3w3T*self.sigmoid(a2L)*self.sigmoid(a2R) grad2L = sp.dot(r2L, z1Lb.T) grad2LR = sp.dot(r2LR, z1LRb.T) grad2R = sp.dot(r2R, z1Rb.T) # First Layer r1L = sp.power(1.0/sp.cosh(a1L),2)*(sp.dot(self.w2l[:,:-1].T, r2L)+sp.dot(self.w2lr[:,:self.H1].T, r2LR)) r1R = sp.power(1.0/sp.cosh(a1R),2)*(sp.dot(self.w2r[:,:-1].T, r2R)+sp.dot(self.w2lr[:,self.H1:-1].T, r2LR)) grad1L = sp.dot(r1L, xLb.T) grad1R = sp.dot(r1R, xRb.T) return grad3, grad2L, grad2LR, grad2R, grad1L, grad1R
def const(mode, W, K, R1): # return 0.6 const_val_r = (W * required_xi(mode, K) / (constB_dash(mode, W, K, R1)*sc.cosh(m0(W)*K) + constC_dash(mode, W, K, R1)*sc.sinh(m0(W)*K))) const_val_l = (W * required_xi(mode, K) / (constB_dash(mode, W, K, R1)*sc.cosh(m0(W)*-K) + constC_dash(mode, W, K, R1)*sc.sinh(m0(W)*-K))) return min(const_val_r, const_val_l)
def fgrad_y_psi(self, y, psi, return_covar_chain = False): """ gradient of f w.r.t to y and psi returns: NxIx3 tensor of partial derivatives """ # 1. exponentiate the a and b (positive!) mpsi = psi.copy() mpsi[:,0:2] = SP.exp(mpsi[:,0:2]) w, s, r, d = self.fgrad_y(y, psi, return_precalc = True) gradients = SP.zeros((y.shape[0], len(mpsi), 3)) for i in range(len(mpsi)): a,b,c = mpsi[i] gradients[:,i,0] = a*(b*(1.0/SP.cosh(s[i]))**2).flatten() gradients[:,i,1] = b*(a*(1-2*s[i]*r[i])*(1.0/SP.cosh(s[i]))**2).flatten() gradients[:,i,2] = (-2*a*(b**2)*r[i]*((1.0/SP.cosh(s[i]))**2)).flatten() covar_grad_chain = SP.zeros((y.shape[0], len(mpsi), 3)) import numpy as NP for i in range(len(mpsi)): a,b,c = mpsi[i] covar_grad_chain[:, i, 0] = a*(r[i]) covar_grad_chain[:, i, 1] = b*(a*(c+y[:,0])*(1.0/SP.cosh(s[i]))**2) covar_grad_chain[:, i, 2] = a*b*((1.0/SP.cosh(s[i]))**2).flatten() if return_covar_chain: return gradients, covar_grad_chain return gradients
def v(mode, x, W, K, M_A): if np.real(x) < -K: return A(mode, W, M_A) * (sc.cosh(m1(W) * x) + sc.sinh(m1(W) * x)) elif np.abs(np.real(x)) <= K: return B(mode, W, M_A) * sc.cosh(m0(W, M_A) * x) + C( mode, W, M_A) * sc.sinh(m0(W, M_A) * x) elif np.real(x) > K: return D(mode, W, M_A) * (sc.cosh(m2(W) * x) - sc.sinh(m2(W) * x))
def Analiticna(t, ksi): #analitična rešitev enačbe G-B A = [] for j in range(len(t)): A.append(-2 * sc.log(sc.cosh(ksi * (1 - 2. * t[j])) / sc.cosh(ksi))) return A
def approx( h = 1.0E-3 ) : # print( "testing Runge-Kutta methods on the catenary" ) print(h, end="\t") x0 = 0.0 x1 = 1.0 mu = 2.0 s0 = array( [ 1.0 / mu, 0.0 ] ) p = s0 x = x0 def cat( p ) : return array( [ p[1], mu * sqrt( 1.0 + p[1] * p[1] ) ] ) while x + h < x1 : p = runge_kutta21( cat, p, h ) x += h p = runge_kutta21( cat, p, x1 - x ) x = x1 # print( "h = ", h ) # print( "final value = ", p ) expected = array( [ cosh( mu * x1 ) / mu, sinh( mu * x1 ) ] ) error = p - expected print(error, end="\t" ) x0 = 0.0 x1 = 1.0 mu = 2.0 s0 = array( [ 1.0 / mu, 0.0 ] ) p = s0 x = x0 while x + h < x1 : p = runge_kutta1( cat, p, h ) x += h p = runge_kutta1( cat, p, x1 - x ) x = x1 # print( "h = ", h ) # print( "final value = ", p ) expected = array( [ cosh( mu * x1 ) / mu, sinh( mu * x1 ) ] ) error = p - expected print(error, end="\t" ) x0 = 0.0 x1 = 1.0 mu = 2.0 s0 = array( [ 1.0 / mu, 0.0 ] ) p = s0 x = x0 while x + h < x1 : p = runge_kutta41( cat, p, h ) x += h p = runge_kutta41( cat, p, x1 - x ) x = x1 # print( "h = ", h ) # print( "final value = ", p ) expected = array( [ cosh( mu * x1 ) / mu, sinh( mu * x1 ) ] ) error = p - expected print( error )
def xixhat_boundary(mode, W, K, R1, boundary='r'): if 'alfven' in mode: xixhat = 0. else: if boundary == 'r' or boundary == 'right': xixhat = (1j / W) * (constB(mode, W, K, R1)*sc.cosh(m0(W)*K) + constC(mode, W, K, R1)*sc.sinh(m0(W)*K)) if boundary == 'l' or boundary == 'left': xixhat = (1j / W) * (constB(mode, W, K, R1)*sc.cosh(m0(W)*-K) + constC(mode, W, K, R1)*sc.sinh(m0(W)*-K)) return xixhat
def Analiticna(N, ksi): #analitična rešitev enačbe G-B a = 0 b = 1 h = (b - a) * 1.0 / N A = [] for j in range(0, N + 1): A.append(-2 * sc.log(sc.cosh(ksi * (1 - 2.0 * j * h)) / sc.cosh(ksi))) return A
def double_tanh_warp(x, n, lcore, lmid, ledge, la, lb, xa, xb): r"""Implements a sum-of-tanh warping function and its derivative. .. math:: l = a\tanh\frac{x-x_a}{l_a} + b\tanh\frac{x-x_b}{l_b} Parameters ---------- x : float or array of float Locations to evaluate the function at. n : int Derivative order to take. Used for ALL of the points. lcore : float Core length scale. lmid : float Intermediate length scale. ledge : float Edge length scale. la : positive float Transition of first tanh. lb : positive float Transition of second tanh. xa : float Transition of first tanh. xb : float Transition of second tanh. Returns ------- l : float or array Warped length scale at the given locations. Raises ------ NotImplementedError If `n` > 1. """ a, b, c = scipy.dot([[-0.5, 0, 0.5], [0, 0.5, -0.5], [0.5, 0.5, 0]], [[lcore], [ledge], [lmid]]) a = a[0] b = b[0] c = c[0] if n == 0: return a * scipy.tanh((x - xa) / la) + b * scipy.tanh( (x - xb) / lb) + c elif n == 1: return (a / la * (scipy.cosh( (x - xa) / la))**(-2.0) + b / lb * (scipy.cosh( (x - xb) / lb))**(-2.0)) else: raise NotImplementedError( "Only derivatives up to order 1 are supported!")
def double_tanh_warp(x, n, lcore, lmid, ledge, la, lb, xa, xb): r"""Implements a sum-of-tanh warping function and its derivative. .. math:: l = a\tanh\frac{x-x_a}{l_a} + b\tanh\frac{x-x_b}{l_b} Parameters ---------- x : float or array of float Locations to evaluate the function at. n : int Derivative order to take. Used for ALL of the points. lcore : float Core length scale. lmid : float Intermediate length scale. ledge : float Edge length scale. la : positive float Transition of first tanh. lb : positive float Transition of second tanh. xa : float Transition of first tanh. xb : float Transition of second tanh. Returns ------- l : float or array Warped length scale at the given locations. Raises ------ NotImplementedError If `n` > 1. """ a, b, c = scipy.dot([[-0.5, 0, 0.5], [0, 0.5, -0.5], [0.5, 0.5, 0]], [[lcore], [ledge], [lmid]]) a = a[0] b = b[0] c = c[0] if n == 0: return a * scipy.tanh((x - xa) / la) + b * scipy.tanh((x - xb) / lb) + c elif n == 1: return (a / la * (scipy.cosh((x - xa) / la))**(-2.0) + b / lb * (scipy.cosh((x - xb) / lb))**(-2.0)) else: raise NotImplementedError("Only derivatives up to order 1 are supported!")
def uv_to_Rz(u,v,delta=1.): """ NAME: uv_to_Rz PURPOSE: calculate R and z from prolate confocal u and v coordinates INPUT: u - confocal u v - confocal v delta= focus OUTPUT: (R,z) HISTORY: 2012-11-27 - Written - Bovy (IAS) """ R= delta*sc.sinh(u)*sc.sin(v) z= delta*sc.cosh(u)*sc.cos(v) return (R,z)
def cal_2D(c0, sigma_, what="Delta_cos", z=1, add_MD=False): # c0 should use mol/m^3 sigma = -sigma_ psi_L = -2 * const.k * T / z / const.e * scipy.arcsinh( sigma / scipy.sqrt(8 * c0 * const.N_A * eps_w * const.k * T)) psi_2D = psi_L - sigma / C_H A = scipy.sqrt(2 * z**2 * const.e**2 * eps_w * c0 * const.N_A / const.k / T) B = z * const.e * psi_L / (2 * const.k * T) C_L = A * scipy.cosh(B) l_D = scipy.sqrt(eps_w * const.k * T / (2 * z**2 * const.e**2 * c0 * const.N_A)) Delta_Phi_el = -sigma**2 / (2 * C_H) - sigma**2 / (C_L + eps_w / l_D) if add_MD is True: n = sigma_ / (const.e * 10**13 * 10**4) Delta_Phi_MD = f_MD(n) Delta_Phi_el += Delta_Phi_MD Delta_cos = -Delta_Phi_el / gamma_w # Classical value # C = scipy.sqrt(32*const.k**3*T**3*eps_w*c0*const.N_A/z**2/const.e**2) # Delta_Phi_el = -sigma**2/(2*C_H) - C*(scipy.cosh(B)-1) # Delta_cos = -Delta_Phi_el/gamma_w # Classical value # sigma = scipy.sqrt(8*c0*const.N_A*eps_w*const.k*T)*scipy.sinh(z*const.e*psi_L/2/const.k/T) # C = scipy.sqrt(32*const.k**3*T**3*eps_w*c0*const.N_A/z**2/const.e**2) # Delta_Phi_el = -sigma**2/(2*C_H) - C*(scipy.cosh(B)-1) # Delta_cos = -Delta_Phi_el/gamma_w if what is "Delta_Phi_el": return Delta_Phi_el elif what is "Delta_cos": return Delta_cos
def f(self,x,t): N = len(x)/2 xdot = pl.array([]) # modulus the x for periodicity. x[N:2*N]= x[N:2*N]%self.d # HERE ---->> 1Dify for i in range(N): temp = 0.0 for j in range(N): if i == j: continue #repulsive x interparticle force of j on i temp += self.qq*(x[N+i]-x[N+j])/(pl.sqrt((x[N+i]-x[N+j])**2)**3) # All of the forces coming from the 'same' paricle but from other 'cells' due to the # periodic contrains can be wraped up in a sum that converges to an aswer that can # be expressed in terms of polygamma functions (se pg 92 of notebook). temp += self.qq*(polygamma(1,(self.d+x[N+i]-x[N+j])/self.d)-polygamma(1,1.0-((x[N+i]-x[N+j])/self.d)))/(self.d**2) # EC x force on particle i for a in range(2): temp+=self.As[i]*pl.sin(x[N+i]-a*pl.pi)*pl.cos(t-a*pl.pi)/(pl.cosh(1.0)-pl.cos(x[N+i]-a*pl.pi)) temp -= self.beta*x[i] xdot = pl.append(xdot,temp) for i in range(N): xdot = pl.append(xdot,x[i]) return xdot
def log_d_pois_like_trunc_5(d,s1,s2,a,p): """double poisson w max 5 goals""" #dp = np.sign(d)*np.power(np.abs(d),p) dp = 1.5*np.arctan(d) #print(dp) return ( log(a)*(s1+s2)+dp*(s1-s2) - 2*a*cosh(dp) -gammaln(s1+1) - gammaln(s2+1) -log(gammaincc(6,a*exp(-dp))*gammaincc(6,a*exp(dp)) ) )
def cosh(ent): """Polymorphic cosh function that adapts to either a numeric or symbolic string input.""" if isinstance(ent,str): return symstr('cosh('+ent+')') else: return scipy.cosh(ent)
def mtanh_profile(X, n, x0, delta, alpha, h, b): """Profile used with the mtanh function to fit profiles, suitable for use with :py:class:`MeanFunction`. Only supports univariate data! Parameters ---------- X : array, (`M`, 1) The points to evaluate at. n : array, (1,) The order of derivative to compute. Only up to first derivatives are supported. x0 : float Pedestal center delta : float Pedestal halfwidth alpha : float Core slope h : float Pedestal height b : float Pedestal foot """ X = X[:, 0] z = (x0 - X) / delta if n[0] == 0: return (h + b) / 2.0 + (h - b) * mtanh(alpha, z) / 2.0 elif n[0] == 1: return -(h - b) / (2.0 * delta) * (1 + alpha / 4.0 * (1 + 2 * z + scipy.exp(2 * z))) / ( scipy.cosh(z))**2 else: raise NotImplementedError( "Derivatives of order greater than 1 are not supported!")
def __init__(self, eta, beta, L, no_angles, no_pulses, order=5): self.mod_K = SourceModule(RADON_KERNEL.format(order, no_angles, no_pulses)) self.K_gpu = self.mod_K.get_function("K_l") self.mod_reduction = SourceModule(REDUCTION_KERNEL) self.reduction_gpu = self.mod_reduction.get_function("reduction") self.eta = eta self.gamma = gamma(eta) self.beta = beta self.L = L self.h = calc_h(L, beta, eta) drv.memcpy_htod(self.mod_K.get_global("rsq4pi")[0], scipy.array([1./sqrt(4.*pi)], dtype=scipy.float32)) drv.memcpy_htod(self.mod_K.get_global("sqeta")[0], scipy.array([sqrt(self.eta)], dtype=scipy.float32)) drv.memcpy_htod(self.mod_K.get_global("h")[0], scipy.array([self.h], dtype=scipy.float32)) drv.memcpy_htod(self.mod_K.get_global("four_pi_gamma")[0], scipy.array([4.*pi*self.gamma], dtype=scipy.float32)) y = sqrt(self.gamma)/self.h drv.memcpy_htod(self.mod_K.get_global("y")[0], scipy.array([y], dtype=scipy.float32)) n = scipy.arange(1, order+1, dtype=scipy.float32) n2 = n**2 ex = exp(-n2/4.) pre_s2 = ex*cosh(n*y) pre_s3 = ex*n*sinh(n*y) drv.memcpy_htod(self.mod_K.get_global("n2")[0], n2) drv.memcpy_htod(self.mod_K.get_global("pre_s1")[0], ex) drv.memcpy_htod(self.mod_K.get_global("pre_s2")[0], pre_s2) drv.memcpy_htod(self.mod_K.get_global("pre_s3")[0], pre_s3)
def soliton(x, t, theta): """ One soliton solution of the sine-Gordon equation: u_{tt} - u_{xx} + sin(u) = 0 with soliton rapidity theta """ z = cosh(theta) * x - sinh(theta) * t return 4 * arctan(exp(z))
def vz_pert(mode, x, z, t, W, K, R1): vz_hat_vals = np.zeros((len(x), len(z)), dtype=complex) vz_vals = np.zeros((len(x), len(z)), dtype=complex) for i in range(len(x)): for j in range(len(z)): def func(r): return [r[0] - x[i] + xix(mode, r[0], r[1], t, W, K, R1), r[1] - z[j] + xiz(mode, r[0], r[1], t, W, K, R1)] sol = np.real(fsolve(func, [x[i],z[j]], xtol=1e-03)) if abs(sol[0]) <= K: vz_hat_vals[i,j] = (1j * c0**2 / (c0**2 - W**2)) * m0(W)*(constB(mode, W, K, R1)*sc.sinh(m0(W)*sol[0]) + constC(mode, W, K, R1)*sc.cosh(m0(W)*sol[0])) elif sol[0] < -K: vz_hat_vals[i,j] = (1j * c1(R1)**2 / (c1(R1)**2 - W**2)) * m1(W, R1)*constA(mode, W, K, R1)*(sc.sinh(m1(W, R1)*sol[0]) + sc.cosh(m1(W, R1)*sol[0])) elif sol[0] > K: vz_hat_vals[i,j] = (1j * c2**2 / (c2**2 - W**2)) * m2(W)*constD(mode, W, K, R1)*(sc.sinh(m2(W)*sol[0]) - sc.cosh(m2(W)*sol[0])) vz_vals[i,j] = vz_hat_vals[i,j] * np.exp(1j*(z[j]-t)) return vz_vals
def rho_hat(mode, x, W, K, R1): truth = np.array(np.abs(x) <= K*np.ones(len(x))) indices = np.where(truth == True) rho_hatfunction = np.zeros(len(x), dtype=complex) for i in indices: rho_hatfunction[i] = m0(W)*(constB(mode, W, K, R1)*sc.sinh(m0(W)*x[i]) + constC(mode, W, K, R1)*sc.cosh(m0(W)*x[i])) * lamb00(W) / (c0**2 * m00(W)) # if mode in slow_surf_mode_options + slow_body_1_mode_options + slow_body_2_mode_options: # rho_hatfunction[i] = -rho_hatfunction[i] truth2 = np.array(x < -K*np.ones(len(x))) indices2 = np.where(truth2 == True) for i in indices2: rho_hatfunction[i] = constA(mode, W, K, R1)*(sc.sinh(m1(W, R1)*x[i]) + sc.cosh(m1(W, R1)*x[i])) * lamb1(W, R1) / c1(R1)**2 truth3 = np.array(x > K*np.ones(len(x))) indices3 = np.where(truth3 == True) for i in indices3: rho_hatfunction[i] = constD(mode, W, K, R1)*(sc.sinh(m2(W)*x[i]) - sc.cosh(m2(W)*x[i])) * lamb2(W) / c2**2 return rho_hatfunction
def f(self,xarr,t): temp = 0.0 for i in range(2): temp+=pl.sin(self.k*xarr[2]-i*pl.pi)*pl.cos(self.w*t-i*pl.pi)/(pl.cosh(self.k*xarr[3])-pl.cos(self.k*xarr[2]-i*pl.pi)) temp = temp*self.coef temp -= self.drg*xarr[0] x0dot = temp x1dot = 0.0 x2dot = xarr[0] x3dot = 0.0 return [x0dot,x1dot,x2dot,x3dot]
def bzhat(mode, x, z, t, W, K, R1): if 'alfven' in mode: bzhat_function = np.zeros(len(x), dtype=complex) else: truth = np.array((x <= (K + xix_boundary(mode, z, t, W, K, R1, boundary='r'))*np.ones(len(x))) & (x >= (-K + xix_boundary(mode, z, t, W, K, R1, boundary='l'))*np.ones(len(x)))) indices = np.where(truth == True) bzhat_function = np.zeros(len(x), dtype=complex) for i in indices: bzhat_function[i] = (-1j*B0/W)*m0(W)*(constB(mode, W, K, R1)*sc.sinh(m0(W)*x[i]) + constC(mode, W, K, R1)*sc.cosh(m0(W)*x[i])) return bzhat_function
def vzhat(mode, x, W, K, R1): if 'alfven' in mode: vzhat_function = np.zeros_like(x) else: if type(x) == float or type(x) == np.float64: if np.abs(x) <= K: vzhat_function = (1j * c0**2 / (c0**2 - W**2)) * m0(W)*(constB(mode, W, K, R1)*sc.sinh(m0(W)*x) + constC(mode, W, K, R1)*sc.cosh(m0(W)*x)) elif x < -K: vzhat_function = (1j * c1(R1)**2 / (c1(R1)**2 - W**2)) * m1(W, R1)*constA(mode, W, K, R1)*(sc.sinh(m1(W, R1)*x) + sc.cosh(m1(W, R1)*x)) elif x > K: vzhat_function = (1j * c2**2 / (c2**2 - W**2)) * m2(W)*constD(mode, W, K, R1)*(sc.sinh(m2(W)*x) - sc.cosh(m2(W)*x)) else: truth = np.array(np.abs(x) <= K*np.ones(len(x))) indices = np.where(truth == True) vzhat_function = np.zeros(len(x), dtype=complex) for i in indices: vzhat_function[i] = (1j * c0**2 / (c0**2 - W**2)) * m0(W)*(constB(mode, W, K, R1)*sc.sinh(m0(W)*x[i]) + constC(mode, W, K, R1)*sc.cosh(m0(W)*x[i])) truth2 = np.array(x < -K*np.ones(len(x))) indices2 = np.where(truth2 == True) for i in indices2: vzhat_function[i] = (1j * c1(R1)**2 / (c1(R1)**2 - W**2)) * m1(W, R1)*constA(mode, W, K, R1)*(sc.sinh(m1(W, R1)*x[i]) + sc.cosh(m1(W, R1)*x[i])) truth3 = np.array(x > K*np.ones(len(x))) indices3 = np.where(truth3 == True) for i in indices3: vzhat_function[i] = (1j * c2**2 / (c2**2 - W**2)) * m2(W)*constD(mode, W, K, R1)*(sc.sinh(m2(W)*x[i]) - sc.cosh(m2(W)*x[i])) return vzhat_function
def make_phi_hyper(n): """make phi n th expression n must be n<=4 :param n: :return: phi """ x = symbols('x') kl = make_kl(n + 1) k = kl / l phi = sym.sinh(k * x) + sym.sin(k * x) + \ (sp.sin(kl) - sp.sinh(kl)) / (sp.cosh(kl) - sp.cos(kl)) * (sym.cosh(k * x) + sym.cos(k * x)) return phi
def f(self,x,t): # for now masses just = 1.0 # the 4.0 only works for 2D N = len(x)/4 xdot = pl.array([]) # modulus the y component to keep periodicity right. x[3*N:4*N]= x[3*N:4*N]%self.yd # x too if self.x_periodic: x[2*N:3*N]= x[2*N:3*N]%self.xd for i in range(N): temp = 0.0 for j in range(N): if i == j: continue #repulsive x interparticle force of j on i temp += self.qq*(x[2*N+i]-x[2*N+j])/(pl.sqrt((x[2*N+i]-x[2*N+j])**2+(x[3*N+i]-x[3*N+j])**2)**3) # if periodic in x we are going to need to include all the wrap around forces if self.x_periodic: #repulsive y interparticle force of j on i temp += self.qq*(x[2*N+i]-x[2*N+j])/(pl.sqrt((x[2*N+i]-x[2*N+j])**2+(x[3*N+i]-x[3*N+j])**2)**3) for gama in range(self.order): temp += -self.qq*(gama*self.xd-(x[2*N+i]-x[2*N+j]))/(pl.sqrt((gama*self.xd-(x[2*N+i]-x[2*N+j]))**2+(x[3*N+i]-x[3*N+j])**2)**3) temp += self.qq* (gama*self.xd+(x[2*N+i]-x[2*N+j]))/(pl.sqrt((gama*self.xd+(x[2*N+i]-x[2*N+j]))**2+(x[3*N+i]-x[3*N+j])**2)**3) # EC x force on particle i # surface set to 1.0 for a in range(2): temp+=self.As[i]*pl.sin(x[2*N+i]-a*pl.pi)*pl.cos(t-a*pl.pi)/(pl.cosh(1.0)-pl.cos(x[2*N+i]-a*pl.pi)) temp -= self.beta*x[i] xdot = pl.append(xdot,temp) for i in range(N): temp = 0.0 for j in range(N): if i == j: continue #repulsive y interparticle force of j on i temp += self.qq*(x[3*N+i]-x[3*N+j])/(pl.sqrt((x[2*N+i]-x[2*N+j])**2+(x[3*N+i]-x[3*N+j])**2)**3) # force from same particle but in other direction becasue of periodic boundar # conditions for gama in range(self.order): temp += -self.qq*(gama*self.yd-(x[3*N+i]-x[3*N+j]))/(pl.sqrt((gama*self.yd-(x[3*N+i]-x[3*N+j]))**2+(x[2*N+i]-x[2*N+j])**2)**3) temp += self.qq* (gama*self.yd+(x[3*N+i]-x[3*N+j]))/(pl.sqrt((gama*self.yd+(x[3*N+i]-x[3*N+j]))**2+(x[2*N+i]-x[2*N+j])**2)**3) temp -= self.beta*x[N+i] xdot = pl.append(xdot,temp) for i in range(N): xdot = pl.append(xdot,x[i]) for i in range(N): xdot = pl.append(xdot,x[N+i]) return xdot
def f(self,x,t): # the 4.0 only works for 2D N = len(x)/4 xdot = pl.array([]) print('x is: '+str(x)) for i in range(N): temp = 0.0 for j in range(N): if i == j: continue #repulsive x interparticle force of j on i temp += self.qq*(x[2*N+i]-x[2*N+j])/(pl.sqrt((x[2*N+i]-x[2*N+j])**2+(x[3*N+i]-x[3*N+j])**2)**3) # EC x force on particle i temp += self.A*(pl.cos(t))*(-2*(pl.cosh(self.d-x[3*N+i]) + pl.cosh(x[3*N+i]))*(pl.cos(x[2*N+i])**2 - pl.cosh(self.d-x[3*N+i])*pl.cosh(x[3*N+i]))*pl.sin(x[2*N+i]))/((pl.cos(x[2*N+i]) - pl.cosh(self.d-x[3*N+i]))*(pl.cos(x[2*N+i]) + pl.cosh(self.d - x[3*N+i]))*(pl.cos(x[2*N+i]) - pl.cosh(x[3*N+i]))*(pl.cos(x[2*N+i]) + pl.cosh(x[3*N+i]))) -self.beta*x[i] xdot = pl.append(xdot,temp) for i in range(N): temp = 0.0 for j in range(N): if i == j: continue #repulsive y interparticle force of j on i temp += self.qq*(x[3*N+i]-x[3*N+j])/(pl.sqrt((x[2*N+i]-x[2*N+j])**2+(x[3*N+i]-x[3*N+j])**2)**3) # EC y force on particle i temp += self.A*(pl.cos(t))*(2*pl.cos(x[2*N+i])*(pl.sinh(self.d - x[3*N+i]) - pl.sinh(x[3*N+i]))*(-pl.sin(x[2*N+i])**2 + pl.sinh(self.d - x[3*N+i])*pl.sinh(x[3*N+i])))/((pl.cos(x[2*N+i]) - pl.cosh(self.d - x[3*N+i]))*(pl.cos(x[2*N+i]) + pl.cosh(self.d - x[3*N+i]))*(pl.cos(x[2*N+i]) - pl.cosh(x[3*N+i]))*(pl.cos(x[2*N+i]) + pl.cosh(x[3*N+i])))-self.beta*x[N+i] # quadropole restoring force to center of electric curtains temp += -self.quadA*(pl.cos(50.0*t)+1.0)*(x[3*N+i]-self.d/2.0) xdot = pl.append(xdot,temp) for i in range(N): xdot = pl.append(xdot,x[i]) for i in range(N): xdot = pl.append(xdot,x[N+i]) print('len xdot is: '+str(len(xdot))) print('xdot is: '+str(xdot)) return xdot
def make_kl(n): """calculate coshx*cosx=1 (radian) using periodicity of cosx :param n:nth answer :return: """ product = [ abs(sp.cosh(x) * sp.cos(x) - 1) for x in np.arange(n * np.pi, (n + 1 / 2) * np.pi, 0.001) ] index = product.index(min(product)) kl = n * np.pi + 0.001 * index return kl
def rho_pert(mode, x, z, t, W, K, R1): rho_hat_vals = np.zeros((len(x), len(z)), dtype=complex) rho_vals = np.zeros((len(x), len(z)), dtype=complex) for i in range(len(x)): for j in range(len(z)): def func(r): return [r[0] - x[i] + xix(mode, r[0], r[1], t, W, K, R1), r[1] - z[j] + xiz(mode, r[0], r[1], t, W, K, R1)] sol = np.real(fsolve(func, [x[i],z[j]], xtol=1e-03)) if abs(sol[0]) <= K: rho_hat_vals[i,j] = m0(W)*(constB(mode, W, K, R1)*sc.sinh(m0(W)*sol[0]) + constC(mode, W, K, R1)*sc.cosh(m0(W)*sol[0])) * lamb00(W) / (c0**2 * m00(W)) # if mode in slow_surf_mode_options + slow_body_1_mode_options + slow_body_2_mode_options: # rho_hat_vals[i,j] = -rho_hat_vals[i,j] elif sol[0] < -K: rho_hat_vals[i,j] = constA(mode, W, K, R1)*(sc.sinh(m1(W, R1)*sol[0]) + sc.cosh(m1(W, R1)*sol[0])) * lamb1(W, R1) / c1(R1)**2 elif sol[0] > K: rho_hat_vals[i,j] = constD(mode, W, K, R1)*(sc.sinh(m2(W)*sol[0]) - sc.cosh(m2(W)*sol[0])) * lamb2(W) / c2**2 rho_vals[i,j] = rho_hat_vals[i,j] * np.exp(1j*(z[j]-t)) return rho_vals
def test(h = 5.0E-6): x0 = 0.0 x1 = 1.0 mu = 2.0 s0 = array( [ 1.0 / mu, 0.0 ] ) p = s0 x = x0 def cat( p ) : return array( [ p[1], mu * sqrt( 1.0 + p[1] * p[1] ) ] ) while x + h < x1 : p = runge_kutta41( cat, p, h ) x += h p = runge_kutta41( cat, p, x1 - x ) x = x1 expected = array( [ cosh( mu * x1 ) / mu, sinh( mu * x1 ) ] ) error = p - expected
def breather(x, t, v, w, x0, xi=-pi / 2): xi += pi / 2 # to keep with Fig.17 of "Breaking integrability at the boundary" W = sqrt(1 - w**2) g = 1 / sqrt(1 - v**2) Sin = sin(w * g * (t - v * (x - x0)) + xi) Cosh = cosh(W * g * (x - x0 - v * t)) u = 4 * arctan2(W * Sin / w, Cosh) Cos = cos(w * g * (t - v * (x - x0)) + xi) Tanh = tanh(W * g * (x - x0 - v * t)) N = v * W**2 * Sin * Tanh + w * W * Cos D = (W * Sin / Cosh)**2 + w**2 ut = 4 * w * g / Cosh * N / D return {'u': u, 'ut': ut}
def K(self, Q, P, angles, quadratures): no_angles, no_pulses = quadratures.shape L = no_angles*no_pulses h = calc_h(L, self.beta, self.eta) y = sqrt(self.gamma)/h n = arange(1, self.order+1, dtype=float32) n2 = n**2 pre_s1 = exp(-n2/4.) pre_s2 = pre_s1*cosh(n*y) pre_s3 = pre_s1*n*sinh(n*y) phix = scipy.vstack([scipy.tile(angles, (no_pulses, 1)).T.ravel(), quadratures.ravel()]).T QP = scipy.vstack([Q, P]).T Kp = partial(K, self.eta, self.gamma, h, y, n2, pre_s1, pre_s2, pre_s3, QP) W = scipy.zeros_like(Q, dtype=float32) for Wp in self.pool.imap(Kp, scipy.array_split(phix, 2*self.no_procs, axis=0), chunksize=1): W += scipy.sum(Wp, axis=0) return W/L
def __init__(self, eta, beta, L, angles, no_pulses, order=5): self.order = order self.angles = angles self.eta = eta self.gamma = gamma(eta) self.beta = beta self.L = L self.h = calc_h(L, beta, eta) self.rsq4pi = 1. / sqrt(4. * pi) self.sqeta = sqrt(self.eta) self.four_pi_gamma = 4. * pi * self.gamma self.y = sqrt(self.gamma) / self.h n = scipy.arange(1, order + 1, dtype=scipy.float32) self.n2 = n**2 self.pre_s1 = exp(-self.n2 / 4.) self.pre_s2 = self.pre_s1 * cosh(n * self.y) self.pre_s3 = self.pre_s1 * n * sinh(n * self.y) self.cos_phi = cos(angles) self.sin_phi = sin(angles)
def K(eta, h, Q, P, phix, order=5): g = gamma(eta) y = sqrt(g)/h phi = phix[:,0] X = phix[:,1]/sqrt(eta) Z = (outer(cos(phi), Q) + outer(sin(phi), P) - X[:,None])/h Zy = Z/y Zy2 = Zy**2 n = arange(1, order+1) n2 = n**2 f_denom = 1./(n2 + Zy2[:,:,None]) v = Zy*sin(Z)*dot(f_denom, exp(-n2/4.)*n*sinh(n*y)) cosZ = cos(Z) v += Zy2*(dot(f_denom, exp(-n2/4.)) - cosZ*dot(f_denom, exp(-n2/4.)*cosh(n*y))) del f_denom v /= sqrt(pi) v += cosZ*(exp(y**2)-1./(2.*sqrt(pi)))+(1./(2.*sqrt(pi))-1.) v /= 4.*pi*g return v
def sommerfeldIntegral(funct,x,a,bs=1.0,Ns=10,Nmax=1e4,tol=1e-6,maxLoops=100,additParams=()): ''' Same as sommerfeldIntegralM but does not handle array inputs (x must be a scalar) ''' logging.getLogger(__name__) N=Ns b=bs Sp = 1e10 while 1: h = 1.0/N*scipy.log(1.05*scipy.sqrt(2.0)*N) n = scipy.arange(-N,N+1) An = scipy.cosh(n*h)*scipy.exp(-scipy.power(scipy.sinh(n*h),2.0)) inval = 0.5*(b+a)+0.5*(b-a)*scipy.special.erf(scipy.sinh(n*h)) f=funct(inval,additParams)*scipy.exp(-1.0j*x*inval) S = h*(b-a)/scipy.sqrt(pi)*scipy.sum(An*f) ds = scipy.absolute(S-Sp)/scipy.absolute(Sp) if ds<tol: flag=1 break # abort if N is getting too large if N>Nmax or loop>maxLoops: logger.error('Max N or Max loops reached; aborting') flag = -1 break Sp = S*1.0 N = N*2 b = b*1.5 return S, flag
def generate(self, t): """ :param Dvector t: Temporal domain array :return: Array of complex values. *Unit:* :math:`\sqrt{W}` :rtype: Cvector Generate an array of complex values representing a Sech pulse. """ if len(t) < 8: raise OutOfRangeError("Require temporal array with at least 8 values") # Assume t[0] = t_0 and t[-1] = t_0 + t_range - dt, # with dt = t[1] - t[0] t_range = t[-1] - t[0] + (t[1] - t[0]) t_normalised = (t - self.position * t_range) / self.width time = t_normalised * t_normalised phase = self.initial_phase phase -= 2.0 * pi * self.offset_nu * t + 0.5 * self.C * time return sqrt(self.peak_power) * exp(1j * phase) / cosh(t_normalised)
def tanh_warp(x, n, l1, l2, lw, x0): r"""Implements a tanh warping function and its derivative. .. math:: l = \frac{l_1 + l_2}{2} - \frac{l_1 - l_2}{2}\tanh\frac{x-x_0}{l_w} Parameters ---------- x : float or array of float Locations to evaluate the function at. n : int Derivative order to take. Used for ALL of the points. l1 : positive float Left saturation value. l2 : positive float Right saturation value. lw : positive float Transition width. x0 : float Transition location. Returns ------- l : float or array Warped length scale at the given locations. Raises ------ NotImplementedError If `n` > 1. """ if n == 0: return (l1 + l2) / 2.0 - (l1 - l2) / 2.0 * scipy.tanh((x - x0) / lw) elif n == 1: return -(l1 - l2) / (2.0 * lw) * (scipy.cosh((x - x0) / lw))**(-2.0) else: raise NotImplementedError( "Only derivatives up to order 1 are supported!" )
def tanh_warp(x, n, l1, l2, lw, x0): r"""Implements a tanh warping function and its derivative. .. math:: l = \frac{l_1 + l_2}{2} - \frac{l_1 - l_2}{2}\tanh\frac{x-x_0}{l_w} Parameters ---------- x : float or array of float Locations to evaluate the function at. n : int Derivative order to take. Used for ALL of the points. l1 : positive float Left saturation value. l2 : positive float Right saturation value. lw : positive float Transition width. x0 : float Transition location. Returns ------- l : float or array Warped length scale at the given locations. Raises ------ NotImplementedError If `n` > 1. """ if n == 0: return (l1 + l2) / 2.0 - (l1 - l2) / 2.0 * scipy.tanh((x - x0) / lw) elif n == 1: return -(l1 - l2) / (2.0 * lw) * (scipy.cosh((x - x0) / lw))**(-2.0) else: raise NotImplementedError( "Only derivatives up to order 1 are supported!")
def generate(self, t): """ :param Dvector t: Temporal domain array :return: Array of complex values. *Unit:* :math:`\sqrt{W}` :rtype: Cvector Generate an array of complex values representing a Sech pulse. """ if len(t) < 8: raise OutOfRangeError( "Require temporal array with at least 8 values") # Assume t[0] = t_0 and t[-1] = t_0 + t_range - dt, # with dt = t[1] - t[0] t_range = t[-1] - t[0] + (t[1] - t[0]) t_normalised = (t - self.position * t_range) / self.width time = t_normalised * t_normalised phase = self.initial_phase phase -= 2.0 * pi * self.offset_nu * t + 0.5 * self.C * time return sqrt(self.peak_power) * exp(1j * phase) / cosh(t_normalised)
def __call__(self, domain, field): """ :param object domain: A domain :param object field: Current field :return: Field after modification by Sech :rtype: Object """ self.field = field t_normalised = (domain.t - self.position * domain.window_t) / self.width time = t_normalised * t_normalised phase = self.initial_phase phase -= 2.0 * pi * self.offset_nu * domain.t + 0.5 * self.C * time magnitude = sqrt(self.peak_power) / cosh(t_normalised) if domain.channels > 1: self.field[self.channel] += magnitude * exp(1j * phase) else: self.field += magnitude * exp(1j * phase) return self.field
def __call__(self, domain, field): """ :param object domain: A domain :param object field: Current field :return: Field after modification by Sech :rtype: Object """ self.field = field t_normalised = \ (domain.t - self.position * domain.window_t) / self.width time = t_normalised * t_normalised phase = self.initial_phase phase -= 2.0 * pi * self.offset_nu * domain.t + 0.5 * self.C * time magnitude = sqrt(self.peak_power) / cosh(t_normalised) if domain.channels > 1: self.field[self.channel] += magnitude * exp(1j * phase) else: self.field += magnitude * exp(1j * phase) return self.field
def __init__(self, eta, beta, L, no_angles, no_pulses, order=5): self.mod_K = SourceModule( RADON_KERNEL.format(order, no_angles, no_pulses)) self.K_gpu = self.mod_K.get_function("K_l") self.mod_reduction = SourceModule(REDUCTION_KERNEL) self.reduction_gpu = self.mod_reduction.get_function("reduction") self.eta = eta self.gamma = gamma(eta) self.beta = beta self.L = L self.h = calc_h(L, beta, eta) drv.memcpy_htod( self.mod_K.get_global("rsq4pi")[0], scipy.array([1. / sqrt(4. * pi)], dtype=scipy.float32)) drv.memcpy_htod( self.mod_K.get_global("sqeta")[0], scipy.array([sqrt(self.eta)], dtype=scipy.float32)) drv.memcpy_htod( self.mod_K.get_global("h")[0], scipy.array([self.h], dtype=scipy.float32)) drv.memcpy_htod( self.mod_K.get_global("four_pi_gamma")[0], scipy.array([4. * pi * self.gamma], dtype=scipy.float32)) y = sqrt(self.gamma) / self.h drv.memcpy_htod( self.mod_K.get_global("y")[0], scipy.array([y], dtype=scipy.float32)) n = scipy.arange(1, order + 1, dtype=scipy.float32) n2 = n**2 ex = exp(-n2 / 4.) pre_s2 = ex * cosh(n * y) pre_s3 = ex * n * sinh(n * y) drv.memcpy_htod(self.mod_K.get_global("n2")[0], n2) drv.memcpy_htod(self.mod_K.get_global("pre_s1")[0], ex) drv.memcpy_htod(self.mod_K.get_global("pre_s2")[0], pre_s2) drv.memcpy_htod(self.mod_K.get_global("pre_s3")[0], pre_s3)
def CpIG(self, T): [C1, C2, C3, C4, C5] = self.constCp cp = C1 cp += C2*((C3/T)/sc.sinh(C3/T))**2 cp += C4*((C5/T)/sc.cosh(C5/T))**2 return cp
def new_sym_bode0(s,ucv): kbase=ucv[0] cbase=ucv[1] kj1=ucv[2] cj1=ucv[3] Kact=ucv[4] tauact=ucv[5] kj2=ucv[6] cj2=ucv[7] gainbode0=ucv[8] mubeam=5.7281 EIbeam=339134.5276 Lbeam=4.6482 rl0=0.0902 Ll0=0.3302 ml0=16.032 Il0=0.19 rl1=0.06145 Ll1=0.1969 ml1=5.0264 Il1=0.027 rl2=0.1077 Ll2=0.4001 ml2=5.5799 Il2=0.0728 abeam=Lbeam**2/EIbeam betabeam=(-1*s**2*Lbeam**4*mubeam/EIbeam)**(0.25) c1beam=0.5*cos(betabeam)+0.5*cosh(betabeam) c2beam=-sin(betabeam)+sinh(betabeam) c3beam=cos(betabeam)-cosh(betabeam) c4beam=sin(betabeam)+sinh(betabeam) a_1 = s**2 a_2 = betabeam**2 a_3 = 1/a_2 a_4 = -0.5*abeam*a_3*c3beam a_5 = 1/betabeam a_6 = 1/(cbase*s+kbase) a_7 = 0.5*a_5*c4beam*Lbeam*a_6 a_8 = a_7+a_4 a_9 = 1/s a_10 = Ll2-rl2 a_11 = Il2*a_1-ml2*a_10*rl2*a_1 a_12 = 1/betabeam**3 a_13 = -0.5*abeam*a_12*c2beam*Lbeam*ml0*a_1 a_14 = -0.5*abeam*a_12*c2beam*Lbeam a_15 = 0.5*abeam*a_3*c3beam*Ll0 a_16 = a_15+a_14 a_17 = a_16*ml1*a_1 a_18 = 0.5*abeam*a_3*c3beam*ml0*rl0*a_1 a_19 = 0.5*abeam*a_3*c3beam a_20 = 1/(cj1*s+kj1) a_21 = -0.5*a_5*c4beam*Lbeam a_22 = -c1beam*Ll0 a_23 = Ll0-rl0 a_24 = 0.5*abeam*a_12*c2beam*Lbeam*ml0*a_23*a_1 a_25 = Il0*a_1-ml0*a_23*rl0*a_1 a_26 = 0.5*abeam*a_3*c3beam*a_25 a_27 = a_20*(a_26+a_24+a_22+a_21) a_28 = a_27+a_19 a_29 = ml1*rl1*a_1*a_28 a_30 = Ll1*a_28+a_15+a_14 a_31 = 1/(cj2*s+kj2) a_32 = Ll1-rl1 a_33 = -a_16*ml1*a_32*a_1 a_34 = a_18+a_13+c1beam a_35 = -Ll1*a_34 a_36 = Il1*a_1-ml1*a_32*rl1*a_1 a_37 = a_36*a_28 a_38 = a_31*(a_37+a_26+a_35+a_33+a_24+a_22+a_21)+a_27+a_19 a_39 = ml2*rl2*a_1*a_38+ml2*a_1*a_30+a_29+a_18+a_17+a_13+c1beam a_40 = a_29+a_18+a_17+a_13+c1beam a_41 = 1/Lbeam a_42 = 1/abeam a_43 = 0.5*abeam*a_5*c4beam*a_41 a_44 = c1beam*a_6 a_45 = a_44+a_43 a_46 = Ll0*a_45 a_47 = a_46+a_7+a_4 a_48 = 0.5*a_42*betabeam*c2beam*Lbeam*a_6 a_49 = a_25*a_45 a_50 = -0.5*betabeam*c2beam*a_41 a_51 = 0.5*a_42*a_2*c3beam*a_6 a_52 = -Ll0*(a_51+a_50) a_53 = -ml0*a_23*a_1*a_8 a_54 = a_20*(a_53+a_52+a_49+a_48+c1beam) a_55 = a_54+a_44+a_43 a_56 = Ll1*a_55+a_46+a_7+a_4 a_57 = -ml1*a_32*a_1*a_47 a_58 = ml0*rl0*a_1*a_45 a_59 = ml0*a_1*a_8 a_60 = -Ll1*(a_59+a_58+a_51+a_50) a_61 = a_36*a_55 a_62 = a_31*(a_61+a_60+a_57+a_53+a_52+a_49+a_48+c1beam)+a_54+a_44+ \ a_43 a_63 = -ml2*rl2*a_1*a_62-ml2*a_1*a_56-ml1*rl1*a_1*a_55-ml1*a_1*a_47 \ -ml0*a_1*a_8-ml0*rl0*a_1*a_45-0.5*a_42*a_2*c3beam*a_6+0.5*betabeam \ *c2beam*a_41 a_64 = a_11*a_62-Ll2*(ml1*rl1*a_1*a_55+ml1*a_1*a_47+a_59+a_58+a_51 \ +a_50)-ml2*a_10*a_1*a_56+a_61+a_60+a_57+a_53+a_52+a_49+a_48+c1beam a_65 = 1/(a_39*a_64+(a_11*a_38-Ll2*a_40-ml2*a_10*a_1*a_30+a_37+a_26 \ +a_35+a_33+a_24+a_22+a_21)*a_63) a_66 = 1/(tauact+s) bode = gainbode0*a_1*(a_8*(-Kact*ml2*rl2*s*(-a_11*a_38+Ll2*a_40+ \ ml2*a_10*a_1*a_30-a_36*a_28-0.5*abeam*a_3*c3beam*a_25+Ll1*a_34+ \ a_16*ml1*a_32*a_1-0.5*abeam*a_12*c2beam*Lbeam*ml0*a_23*a_1+c1beam \ *Ll0+0.5*a_5*c4beam*Lbeam)*a_65*tauact*a_66-Kact*a_9*a_11*a_39 \ *a_65*tauact*a_66)-0.5*abeam*a_12*c2beam*Lbeam*(-Kact*ml2*rl2* \ s*a_64*a_65*tauact*a_66-Kact*a_9*a_11*a_63*a_65*tauact*a_66)) return bode
def mtanh_profile(X, n, x0, delta, alpha, h, b): """Profile used with the mtanh function to fit profiles, suitable for use with :py:class:`MeanFunction`. Only supports univariate data! Parameters ---------- X : array, (`M`, 1) The points to evaluate at. n : array, (1,) The order of derivative to compute. Only up to first derivatives are supported. x0 : float Pedestal center delta : float Pedestal halfwidth alpha : float Core slope h : float Pedestal height b : float Pedestal foot """ X = X[:, 0] z = (x0 - X) / delta if n[0] == 0: return (h + b) / 2.0 + (h - b) * mtanh(alpha, z) / 2.0 elif n[0] == 1: return -(h - b) / (2.0 * delta) * (1 + alpha / 4.0 * (1 + 2 * z + scipy.exp(2 * z))) / (scipy.cosh(z))**2 else: raise NotImplementedError("Derivatives of order greater than 1 are not supported!")
evect = rand(3) evect += 0.5 - 1 evect = evect * 10 ivect = evect + myvect tmmevect = array(map(mysys.FindEig, ivect * 1.0j)) for q, cureig in enumerate(tmmevect): print("TMM eig %d= " % (q + 1) + str(cureig[1])) errors = myvect - tmmevect[:, 1] perrors = abs(errors / myvect * 100.0) print("max. percent error (Analytic-TMM)=" + str(max(perrors))) beta = (myvect ** 2 * mu / EI) ** 0.25 beta2 = (tmmevect[:, 1] ** 2 * mu / EI) ** 0.25 test = cos(beta * L) * cosh(beta * L) + 1 test2 = cos(beta2 * L) * cosh(beta2 * L) + 1 xvect = arange(0, 1.01, 0.01) xvect = xvect * L for n, cureig, curbeta in zip(range(len(tmmevect)), tmmevect, beta): curAY = (sin(curbeta * L) - sinh(curbeta * L)) * (sin(curbeta * xvect) - sinh(curbeta * xvect)) + ( cos(curbeta * L) + cosh(curbeta * L) ) * (cos(curbeta * xvect) - cosh(curbeta * xvect)) mind = argmax(abs(curAY)) mymax = curAY[mind] curAY = curAY * 0.2 / mymax disps, angles, modedict = mysys.FindModeShape(cureig) disps = real(disps)[:, 0] mind2 = argmax(abs(disps)) mymax2 = disps[mind2] disps = disps * 0.2 / mymax2
evect=rand(3) evect+=0.5-1 evect=evect*10 ivect=evect+myvect tmmevect=array(map(mysys.FindEig,ivect*1.0j)) for q,cureig in enumerate(tmmevect): print('TMM eig %d= '%(q+1)+str(cureig[1])) errors=myvect-tmmevect[:,1] perrors=abs(errors/myvect*100.) print('max. percent error (Analytic-TMM)='+str(max(perrors))) beta=(myvect**2*mu/EI)**0.25 beta2=(tmmevect[:,1]**2*mu/EI)**0.25 test=cos(beta*L)*cosh(beta*L)+1 test2=cos(beta2*L)*cosh(beta2*L)+1 xvect=arange(0,1.01,0.01) xvect=xvect*L for n,cureig,curbeta in zip(range(len(tmmevect)),tmmevect,beta): curAY=(sin(curbeta*L)-sinh(curbeta*L))*(sin(curbeta*xvect)-sinh(curbeta*xvect))+(cos(curbeta*L)+cosh(curbeta*L))*(cos(curbeta*xvect)-cosh(curbeta*xvect)) mind=argmax(abs(curAY)) mymax=curAY[mind] curAY=curAY*0.2/mymax disps,angles,modedict=mysys.FindModeShape(cureig) disps=real(disps)[:,0] mind2=argmax(abs(disps)) mymax2=disps[mind2] disps=disps*0.2/mymax2 mymesh=mysys.CreateMesh() myx=mymesh[:,0]
# Using own data file to extract the input state. input = workspace["states"][-1, :] background = workspace["background"] delta = workspace["delta"] pump = workspace["pump"] loss = workspace["loss"] filename = ( filename + "delta=%.2f_pump=%.2E_loss=%.2E_mint=%.2f_maxt_%.2f_nt=%d_dt=%.2E.npz" % (delta, pump, loss, args.mint, args.maxt, args.nt, args.dt)) absorber = (1000 * (1/s.cosh((x - x.min()) / 8.0) + 1/s.cosh((x - x.max()) / 8.0))) absorber[abs(x) < 64] = 0 t = s.linspace(args.mint, args.maxt, args.nt) states = ccgnlse.integrate( t, x, input, args.dt, [-delta, 0.0, -1.0], 1.0, potential, pump, loss, absorber, background) workspace = {}
def Bodes(s, params): GthNum = Gth.Gth.num(s) GthDen = Gth.Gth.den(s) if type(params) == dict: params = SFLR_TMM.SFLR_params(**params) EI = params.EI L1 = params.L L2 = params.L2 mu = params.mu c_beam = params.c_beam if c_beam > 0.0: EI = EI*(1.0+c_beam*s) ## beta = pow((-1*s*s*L**4*mu/EI),0.25) ## d1 = 0.5*(cos(beta)+cosh(beta)) ## d2 = 0.5*(sinh(beta)-sin(beta)) ## d3 = 0.5*(cosh(beta)-cos(beta)) ## d4 = 0.5*(sin(beta)+sinh(beta)) beta1 = pow((-1*s*s*L1**4*mu/EI),0.25) d1_1 = 0.5*(cos(beta1)+cosh(beta1)) d2_1 = 0.5*(sinh(beta1)-sin(beta1)) d3_1 = 0.5*(cosh(beta1)-cos(beta1)) d4_1 = 0.5*(sin(beta1)+sinh(beta1)) beta2 = pow((-1*s*s*L2**4*mu/EI),0.25) d1_2 = 0.5*(cos(beta2)+cosh(beta2)) d2_2 = 0.5*(sinh(beta2)-sin(beta2)) d3_2 = 0.5*(cosh(beta2)-cos(beta2)) d4_2 = 0.5*(sin(beta2)+sinh(beta2)) a_m = params.a_m a_L = params.a_L a_I = params.a_I a_r = params.a_r b_m = params.b_m b_L = params.b_L b_I = params.b_I b_r = params.b_r k_spring = params.k_spring c_spring = params.c_spring k_clamp = params.k_clamp c_clamp = params.c_clamp K_act = params.K_act tau = params.tau a_gain = params.a_gain p_act1 = params.p_act1 p_act2 = params.p_act2 z_act = params.z_act H = params.H I = 1.0j enc_gain = 180.0/pi*1024.0/360.0 #-------------------------------- a_1 = s**2 a_2 = 1/GthDen a_3 = sqrt(p_act1**2+4*pi**2) a_4 = 1/s a_5 = 1/(s+p_act1) a_6 = 1/(a_2*GthNum*K_act*a_3*a_4*a_5*H+1.0E+0) a_7 = 1.0E+0*a_2*GthNum*K_act*a_3*a_4*a_5*a_6 a_8 = 1/(c_spring*s+k_spring) a_9 = beta1**3 a_10 = L1**3 a_11 = 1/a_10 a_12 = beta1**2 a_13 = 1/(c_clamp*s+k_clamp) a_14 = a_1*b_I-b_m*b_r*a_1*(b_L-b_r) a_15 = a_2*GthNum*K_act*a_3*a_4*a_5*a_13*a_14*a_6+a_7 a_16 = L1**2 a_17 = 1/a_16 a_18 = 1/L1 a_19 = -1.0E+0*beta1*d2_1*a_2*GthNum*K_act*a_3*a_4*a_5*a_14*a_6*a_18 \ -a_12*d3_1*EI*a_15*a_17-1.0E+0*a_9*d4_1*a_2*GthNum*K_act*a_3* \ a_4*a_5*b_L*EI*a_6*a_11+1.0E+0*b_m*b_r*d1_1*a_2*GthNum*K_act*a_3 \ *s*a_5*a_6 a_20 = 1/beta1 a_21 = 1/EI a_22 = 1/a_12 a_23 = -1.0E+0*a_22*b_m*b_r*d3_1*a_2*GthNum*K_act*a_3*s*a_5*a_21*a_6 \ *a_16+1.0E+0*a_20*d4_1*a_2*GthNum*K_act*a_3*a_4*a_5*a_14*a_21 \ *a_6*L1+1.0E+0*beta1*d2_1*a_2*GthNum*K_act*a_3*a_4*a_5*b_L*a_6* \ a_18+d1_1*a_15 a_24 = 1/a_9 a_25 = -1.0E+0*a_24*b_m*b_r*d2_1*a_2*GthNum*K_act*a_3*s*a_5*a_21*a_6 \ *a_10+1.0E+0*a_22*d3_1*a_2*GthNum*K_act*a_3*a_4*a_5*a_14*a_21 \ *a_6*a_16+a_20*d4_1*a_15*L1+1.0E+0*d1_1*a_2*GthNum*K_act*a_3*a_4 \ *a_5*b_L*a_6 a_26 = a_m*a_1*a_25+a_m*a_r*a_1*a_23+1.0E+0*a_19 a_27 = beta2**3 a_28 = a_L*a_23 a_29 = 1.0E+0*a_25 a_30 = a_29+a_28 a_31 = 1/L2**3 a_32 = beta2**2 a_33 = 1/L2**2 a_34 = a_L-a_r a_35 = a_1*a_I-a_m*a_r*a_1*a_34 a_36 = -a_m*a_1*a_34*a_25+a_35*a_23+1.0E+0*(-1.0E+0*a_20*b_m*b_r*d4_1 \ *a_2*GthNum*K_act*a_3*s*a_5*a_6*L1+beta1*d2_1*EI*a_15*a_18+1.0E+0 \ *a_12*d3_1*a_2*GthNum*K_act*a_3*a_4*a_5*b_L*EI*a_6*a_17+1.0E+0 \ *d1_1*a_2*GthNum*K_act*a_3*a_4*a_5*a_14*a_6)-a_L*a_19 a_37 = 1/L2 a_38 = beta2*d2_2*a_36*a_37+1.0E+0*a_32*d3_2*EI*a_23*a_33+a_27*d4_2 \ *EI*a_30*a_31-d1_2*a_26 a_39 = 1.0E+0*beta1*d2_1*b_L*a_18+a_12*d3_1*a_13*b_L*EI*a_17+1.0E+0 \ *d1_1 a_40 = -1.0E+0*a_22*d3_1*a_21*a_16-1.0E+0*a_20*d4_1*b_L*a_21*L1-d1_1 \ *a_13*b_L a_41 = -1.0E+0*a_24*d2_1*a_21*a_10-1.0E+0*a_22*d3_1*b_L*a_21*a_16- \ a_20*d4_1*a_13*b_L*L1 a_42 = -a_m*a_1*a_34*a_41+a_35*a_40+1.0E+0*(-1.0E+0*a_20*d4_1*L1-beta1 \ *d2_1*a_13*b_L*EI*a_18-1.0E+0*d1_1*b_L)-a_L*a_39 a_43 = 1.0E+0*a_41+a_L*a_40 a_44 = 1/beta2 a_45 = a_m*a_1*a_41+a_m*a_r*a_1*a_40+1.0E+0*a_39 a_46 = a_8*a_14*a_6+1.0E+0 a_47 = a_13*a_46+1.0E+0*a_8*a_6 a_48 = -1.0E+0*beta1*d2_1*a_46*a_18-a_12*d3_1*EI*a_47*a_17-1.0E+0* \ a_9*d4_1*a_8*b_L*EI*a_6*a_11+1.0E+0*b_m*b_r*d1_1*a_1*a_8*a_6 a_49 = -1.0E+0*a_22*b_m*b_r*d3_1*a_1*a_8*a_21*a_6*a_16+1.0E+0*a_20 \ *d4_1*a_21*a_46*L1+1.0E+0*beta1*d2_1*a_8*b_L*a_6*a_18+d1_1*a_47 a_50 = -1.0E+0*a_24*b_m*b_r*d2_1*a_1*a_8*a_21*a_6*a_10+1.0E+0*a_22 \ *d3_1*a_21*a_46*a_16+a_20*d4_1*a_47*L1+1.0E+0*d1_1*a_8*b_L*a_6 a_51 = a_m*a_1*a_50+a_m*a_r*a_1*a_49+1.0E+0*a_48 a_52 = 1.0E+0*a_50+a_L*a_49 a_53 = -a_m*a_1*a_34*a_50+a_35*a_49+1.0E+0*(-1.0E+0*a_20*b_m*b_r*d4_1 \ *a_1*a_8*a_6*L1+beta1*d2_1*EI*a_47*a_18+1.0E+0*a_12*d3_1*a_8 \ *b_L*EI*a_6*a_17+1.0E+0*d1_1*a_46)-a_L*a_48 a_54 = beta2*d2_2*a_53*a_37+1.0E+0*a_32*d3_2*EI*a_49*a_33+a_27*d4_2 \ *EI*a_52*a_31-d1_2*a_51 a_55 = -beta2*d2_2*a_42*a_37-1.0E+0*a_32*d3_2*EI*a_40*a_33-a_27*d4_2 \ *EI*a_43*a_31+d1_2*a_45 a_56 = -a_44*d4_2*a_51*L2+1.0E+0*beta2*d2_2*EI*a_49*a_37+a_32*d3_2 \ *EI*a_52*a_33+d1_2*a_53 a_57 = 1/(a_55*a_56+a_54*(-a_44*d4_2*a_45*L2+1.0E+0*beta2*d2_2*EI* \ a_40*a_37+a_32*d3_2*EI*a_43*a_33+d1_2*a_42)) a_58 = a_44*d4_2*a_26*L2-1.0E+0*beta2*d2_2*EI*a_23*a_37-a_32*d3_2* \ EI*a_30*a_33-d1_2*a_36 a_59 = a_55*a_58*a_57+a_38*(a_44*d4_2*a_45*L2-1.0E+0*beta2*d2_2*EI \ *a_40*a_37-a_32*d3_2*EI*a_43*a_33-d1_2*a_42)*a_57 RESULT = a_gain*a_1*(a_43*(a_38*a_56*a_57+a_54*a_58*a_57)+a_52*a_59 \ +a_29+a_28)/(enc_gain*(1.0E+0*a_8*a_6*a_59+a_7)) return RESULT
leg_width(lg,8.) plt.xlim(0.,3.) plt.savefig('figs/speeds',bbox_inches='tight',transparent=True) # # vertical structure of most unstable wave # z = np.linspace(0.,1.,100) sigma8 = grate(k,8.) ikmax = sigma8.argmax() mu = mu[ikmax] co = sp.cosh(mu*z) si = sp.sinh(mu*z) cr,ci = .5,ci[ikmax] c2 = cr**2 + ci**2 co = sp.cosh(mu*z) si = sp.sinh(mu*z) phi_r = co - (cr/(mu*c2))*si phi_i = (ci/(mu*c2))*si phi_abs = np.sqrt( phi_r**2 + phi_i**2 ) phi_phase = np.zeros(z.size) for i in range(z.size): phi_phase[i] = sp.math.atan2( phi_i[i],phi_r[i] )
def euler_beam_modes(n=10, bctype=2, beamparams=sp.array((7.31e10, 1 / 12 * 0.03 * .015 ** 3, 2747, .015 * 0.03, 0.4)), npoints=2001): """ %VTB6_3 Natural frequencies and mass normalized mode shape for an Euler- % Bernoulli beam with a chosen boundary condition. % [w,x,U]=VTB6_3(n,bctype,bmpar,npoints) will return the nth natural % frequency (w) and mode shape (U) of an Euler-Bernoulli beam. % If n is a vector, return the coresponding mode shapes and natural % frequencies. % With no output arguments the modes are ploted. % If only one mode is requested, and there are no output arguments, the % mode shape is animated. % The boundary condition is defined as follows: % % bctype = 1 free-free % bctype = 2 clamped-free % bctype = 3 clamped-pinned % bctype = 4 clamped-sliding % bctype = 5 clamped-clamped % bctype = 6 pinned-pinned % % The beam parameters are input through the vector bmpar: % bmpar = [E I rho A L]; % where the variable names are consistent with Section 6.5 of the % text. % %% Example: 20 cm long aluminum beam with h=1.5 cm, b=3 cm %% Animate the 4th mode for free-free boundary conditions % E=7.31e10; % I=1/12*.03*.015^3; % rho=2747; % A=.015*.03; % L=0.2; % vtb6_3(4,1,[E I rho A L]); % % Copyright Joseph C. Slater, 2007 % Engineering Vibration Toolbox """ E = beamparams[0] I = beamparams[1] rho = beamparams[2] A = beamparams[3] L = beamparams[4] if isinstance(n, int): ln = n n = sp.arange(n) + 1 else: ln = len(n) # len=[0:(1/(npoints-1)):1]'; %Normalized length of the beam len = sp.linspace(0, 1, npoints) x = len * L # Determine natural frequencies and mode shapes depending on the # boundary condition. # Mass simplification. The following was arange_(1,length_(n)).reshape(-1) mode_num_range = sp.arange(0, ln) Bnl = sp.empty(ln) w = sp.empty(ln) U = sp.empty([npoints, ln]) if bctype == 1: desc = 'Free-Free ' Bnllow = sp.array((0, 0, 4.73004074486, 7.8532046241, 10.995607838, 14.1371654913, 17.2787596574)) for i in mode_num_range: if n[i] > 7: Bnl[i] = (2 * n[i] - 3) * sp.pi / 2 else: Bnl[i] = Bnllow[i] for i in mode_num_range: if n[i] == 1: w[i] = 0 U[:, i] = 1 + len * 0 elif n[i] == 2: w[i] = 0 U[:, i] = len - 0.5 else: sig = (sp.cosh(Bnl[i]) - sp.cos(Bnl[i])) / \ (sp.sinh(Bnl[i]) - sp.sin(Bnl[i])) w[i] = (Bnl[i] ** 2) * sp.sqrt(E * I / (rho * A * L ** 4)) b = Bnl[i] * len U[:, i] = sp.cosh(b) + sp.cos(b) - sig * \ (sp.sinh(b) + sp.sin(b)) elif bctype == 2: desc = 'Clamped-Free ' Bnllow = sp.array((1.88, 4.69, 7.85, 10.99, 14.14)) for i in mode_num_range: if n[i] > 4: Bnl[i] = (2 * n[i] - 1) * sp.pi / 2 else: Bnl[i] = Bnllow[i] for i in mode_num_range: sig = (sp.sinh(Bnl[i]) - sp.sin(Bnl[i])) / \ (sp.cosh(Bnl[i]) - sp.cos(Bnl[i])) w[i] = (Bnl[i] ** 2) * sp.sqrt(E * I / (rho * A * L ** 4)) b = Bnl[i] * len # plt.plot(x,(sp.cosh(b) - sp.cos(b) - sig * (sp.sinh(b) - sp.sin(b)))) U[:, i] = sp.cosh(b) - sp.cos(b) - sig * (sp.sinh(b) - sp.sin(b)) elif bctype == 3: desc = 'Clamped-Pinned ' Bnllow = sp.array((3.93, 7.07, 10.21, 13.35, 16.49)) for i in mode_num_range: if n[i] > 4: Bnl[i] = (4 * n[i] + 1) * sp.pi / 4 else: Bnl[i] = Bnllow[i] for i in mode_num_range: sig = (sp.cosh(Bnl[i]) - sp.cos(Bnl[i])) / \ (sp.sinh(Bnl[i]) - sp.sin(Bnl[i])) w[i] = (Bnl[i] ** 2) * sp.sqrt(E * I / (rho * A * L ** 4)) b = Bnl[i] * len U[:, i] = sp.cosh(b) - sp.cos(b) - sig * (sp.sinh(b) - sp.sin(b)) elif bctype == 4: desc = 'Clamped-Sliding ' Bnllow = sp.array((2.37, 5.5, 8.64, 11.78, 14.92)) for i in mode_num_range: if n[i] > 4: Bnl[i] = (4 * n[i] - 1) * sp.pi / 4 else: Bnl[i] = Bnllow[i] for i in mode_num_range: sig = (sp.sinh(Bnl[i]) + sp.sin(Bnl[i])) / \ (sp.cosh(Bnl[i]) - sp.cos(Bnl[i])) w[i] = (Bnl[i] ** 2) * sp.sqrt(E * I / (rho * A * L ** 4)) b = Bnl[i] * len U[:, i] = sp.cosh(b) - sp.cos(b) - sig * (sp.sinh(b) - sp.sin(b)) elif bctype == 5: desc = 'Clamped-Clamped ' Bnllow = sp.array((4.73, 7.85, 11, 14.14, 17.28)) for i in mode_num_range: if n[i] > 4: Bnl[i] = (2 * n[i] + 1) * sp.pi / 2 else: Bnl[i] = Bnllow[i] for i in mode_num_range: sig = (sp.cosh(Bnl[i]) - sp.cos(Bnl[i])) / \ (sp.sinh(Bnl[i]) - sp.sin(Bnl[i])) w[i] = (Bnl[i] ** 2) * sp.sqrt(E * I / (rho * A * L ** 4)) b = Bnl[i] * len U[:, i] = sp.cosh(b) - sp.cos(b) - sig * (sp.sinh(b) - sp.sin(b)) elif bctype == 6: desc = 'Pinned-Pinned ' for i in mode_num_range: Bnl[i] = n[i] * sp.pi w[i] = (Bnl[i] ** 2) * sp.sqrt(E * I / (rho * A * L ** 4)) U[:, i] = sp.sin(Bnl[i] * len) # Mass Normalization of mode shapes for i in mode_num_range: U[:, i] = U[:, i] / sp.sqrt(sp.dot(U[:, i], U[:, i]) * rho * A * L) """ ppause=0 x=len * L if nargout == 0: if length_(n) != 1: for i in arange_(1,length_(n)).reshape(-1): plot_(x,U[:,i]) axis_([0,L,min_(min_(U)),max_(max_(U))]) figure_(gcf) title_([desc,char(' '),char('Mode '),int2str_(i),char(' Natural Frequency = '),num2str_(w[i]),char(' rad/s')]) ylabel_(char('Modal Amplitude')) xlabel_(char('Length along bar - x')) grid_(char('on')) disp_(char('Press return to continue')) pause else: nsteps=50 clf step=2 * pi / (nsteps) i=arange_(0,(2 * pi - step),step) hold_(char('off')) handle=uicontrol_(char('style'),char('pushbutton'),char('units'),char('normal'),char('backgroundcolor'),char('red'),char('position'),[0.94,0.94,0.05,0.05],char('String'),char('Stop'),char('callback'),char('global stopstop;stopstop=1;')) handle2=uicontrol_(char('style'),char('pushbutton'),char('units'),char('normal'),char('backgroundcolor'),char('yellow'),char('position'),[0.94,0.87,0.05,0.05],char('String'),char('Pause'),char('callback'),char('global ppause;ppause=1;')) handle3=uicontrol_(char('style'),char('pushbutton'),char('units'),char('normal'),char('backgroundcolor'),char('green'),char('position'),[0.94,0.8,0.05,0.05],char('String'),char('Resume'),char('callback'),char('global ppause;ppause=0;')) stopstop=0 bb=0 while stopstop == 0 and bb < 100: bb=bb + 1 for ii in [i].reshape(-1): while ppause == 1: pause_(0.01) if stopstop == 1: delete_(handle) delete_(handle2) delete_(handle3) return w,x,U plot_(x,U[:,1] * sp.cos(ii)) axis_([0,L,- max_(abs_(U)),max_(abs_(U))]) grid_(char('on')) figure_(gcf) title_([desc,char(' '),char('Mode '),int2str_(n),char(' \\omega_n = '),num2str_(w[1]),char(' rad/s')]) ylabel_(char('Modal Amplitude')) xlabel_(char('Length along bar - x')) drawnow clear_(char('stopstop')) delete_(handle) delete_(handle2) delete_(handle3) """ return w, x, U
def f(self,xarr,t): temp1 = 0.0 temp2 = 0.0 # RIGHT NOW WE ARE LOOKING AT THE SQUARE WAVE VERSION. TO GO BACK TO NORMAL JUST REPLACE # SELF.SQUAREWAVE WITH PL.COS. !!!!!!!!!!!!!!!!!!!!!!!!! for i in range(2): temp1+=pl.sin(self.k*xarr[2]-i*pl.pi)*self.square_wave(self.w*t-i*pl.pi)/(pl.cosh(self.k*(self.surf+abs(xarr[3]-self.surf)))-pl.cos(self.k*xarr[2]-i*pl.pi)) temp1 = temp1*self.coef temp1 -= self.drg*xarr[0] x0dot = temp1 for i in range(2): temp2+=pl.sign(xarr[3]-self.surf)*pl.sinh(self.k*(self.surf+abs(xarr[3]-self.surf)))*self.square_wave(self.w*t-i*pl.pi)/(pl.cosh(self.k*(self.surf+abs(xarr[3]-self.surf)))-pl.cos(self.k*xarr[2]-i*pl.pi)) temp2 = temp2*self.coef temp2 -= self.drg*xarr[1] temp2 -= pl.sign(xarr[3]-self.surf)*self.g x1dot = temp2 x2dot = xarr[0] x3dot = xarr[1] return [x0dot,x1dot,x2dot,x3dot]
def Bodes(s, params): mynum = squeeze(Gth.Gth.num) myden = squeeze(Gth.Gth.den) try: GthNum = mynum(s) GthDen = myden(s) except: mynum = poly1d(mynum) myden = poly1d(myden) GthNum = mynum(s) GthDen = myden(s) if type(params) == dict: params = SFLR_TMM.SFLR_params(**params) EI = params.EI L1 = params.L L2 = params.L2 mu = params.mu c_beam = params.c_beam if c_beam > 0.0: EI = EI*(1.0+c_beam*s) ## beta = pow((-1*s*s*L**4*mu/EI),0.25) ## d1 = 0.5*(cos(beta)+cosh(beta)) ## d2 = 0.5*(sinh(beta)-sin(beta)) ## d3 = 0.5*(cosh(beta)-cos(beta)) ## d4 = 0.5*(sin(beta)+sinh(beta)) beta1 = pow((-1*s*s*L1**4*mu/EI),0.25) d1_1 = 0.5*(cos(beta1)+cosh(beta1)) d2_1 = 0.5*(sinh(beta1)-sin(beta1)) d3_1 = 0.5*(cosh(beta1)-cos(beta1)) d4_1 = 0.5*(sin(beta1)+sinh(beta1)) beta2 = pow((-1*s*s*L2**4*mu/EI),0.25) d1_2 = 0.5*(cos(beta2)+cosh(beta2)) d2_2 = 0.5*(sinh(beta2)-sin(beta2)) d3_2 = 0.5*(cosh(beta2)-cos(beta2)) d4_2 = 0.5*(sin(beta2)+sinh(beta2)) a_m = params.a_m a_L = params.a_L a_I = params.a_I a_r = params.a_r b_m = params.b_m b_L = params.b_L b_I = params.b_I b_r = params.b_r k_spring = params.k_spring c_spring = params.c_spring k_clamp = params.k_clamp c_clamp = params.c_clamp K_act = params.K_act tau = params.tau a_gain = params.a_gain p_act1 = params.p_act1 p_act2 = params.p_act2 z_act = params.z_act H = params.H I = 1.0j enc_gain = 180.0/pi*1024.0/360.0 #-------------------------------- a_1 = s**2 a_2 = 1/GthDen a_3 = sqrt(p_act1**2+4*pi**2) a_4 = 1/s a_5 = 1/(s+p_act1) a_6 = 1/(a_2*GthNum*K_act*a_3*a_4*a_5*H+1.0E+0) a_7 = 1/(c_clamp*s+k_clamp) a_8 = a_1*b_I-b_m*b_r*a_1*(b_L-b_r) a_9 = a_2*GthNum*K_act*a_3*a_4*a_5*a_7*a_8*a_6+1.0E+0*a_2*GthNum*K_act \ *a_3*a_4*a_5*a_6 a_10 = 1/L1 a_11 = 1/beta1 a_12 = 1/EI a_13 = beta1**2 a_14 = 1/a_13 a_15 = L1**2 a_16 = -1.0E+0*a_14*b_m*b_r*d3_1*a_2*GthNum*K_act*a_3*s*a_5*a_12*a_6 \ *a_15+1.0E+0*a_11*d4_1*a_2*GthNum*K_act*a_3*a_4*a_5*a_8*a_12* \ a_6*L1+1.0E+0*beta1*d2_1*a_2*GthNum*K_act*a_3*a_4*a_5*b_L*a_6*a_10 \ +d1_1*a_9 a_17 = a_L*a_16 a_18 = beta1**3 a_19 = 1/a_18 a_20 = L1**3 a_21 = -1.0E+0*a_19*b_m*b_r*d2_1*a_2*GthNum*K_act*a_3*s*a_5*a_12*a_6 \ *a_20+1.0E+0*a_14*d3_1*a_2*GthNum*K_act*a_3*a_4*a_5*a_8*a_12* \ a_6*a_15+a_11*d4_1*a_9*L1+1.0E+0*d1_1*a_2*GthNum*K_act*a_3*a_4* \ a_5*b_L*a_6 a_22 = 1.0E+0*a_21 a_23 = 1/(c_spring*s+k_spring) a_24 = a_23*a_8*a_6+1.0E+0 a_25 = a_7*a_24+1.0E+0*a_23*a_6 a_26 = -1.0E+0*a_14*b_m*b_r*d3_1*a_1*a_23*a_12*a_6*a_15+1.0E+0*a_11 \ *d4_1*a_12*a_24*L1+1.0E+0*beta1*d2_1*a_23*b_L*a_6*a_10+d1_1*a_25 a_27 = -1.0E+0*a_19*b_m*b_r*d2_1*a_1*a_23*a_12*a_6*a_20+1.0E+0*a_14 \ *d3_1*a_12*a_24*a_15+a_11*d4_1*a_25*L1+1.0E+0*d1_1*a_23*b_L*a_6 a_28 = 1.0E+0*a_27+a_L*a_26 a_29 = 1/a_20 a_30 = 1/a_15 a_31 = -1.0E+0*beta1*d2_1*a_2*GthNum*K_act*a_3*a_4*a_5*a_8*a_6*a_10 \ -a_13*d3_1*EI*a_9*a_30-1.0E+0*a_18*d4_1*a_2*GthNum*K_act*a_3*a_4 \ *a_5*b_L*EI*a_6*a_29+1.0E+0*b_m*b_r*d1_1*a_2*GthNum*K_act*a_3 \ *s*a_5*a_6 a_32 = a_m*a_1*a_21+a_m*a_r*a_1*a_16+1.0E+0*a_31 a_33 = beta2**3 a_34 = a_22+a_17 a_35 = 1/L2**3 a_36 = beta2**2 a_37 = 1/L2**2 a_38 = a_L-a_r a_39 = a_1*a_I-a_m*a_r*a_1*a_38 a_40 = -a_m*a_1*a_38*a_21+a_39*a_16+1.0E+0*(-1.0E+0*a_11*b_m*b_r*d4_1 \ *a_2*GthNum*K_act*a_3*s*a_5*a_6*L1+beta1*d2_1*EI*a_9*a_10+1.0E+0 \ *a_13*d3_1*a_2*GthNum*K_act*a_3*a_4*a_5*b_L*EI*a_6*a_30+1.0E+0 \ *d1_1*a_2*GthNum*K_act*a_3*a_4*a_5*a_8*a_6)-a_L*a_31 a_41 = 1/L2 a_42 = beta2*d2_2*a_40*a_41+1.0E+0*a_36*d3_2*EI*a_16*a_37+a_33*d4_2 \ *EI*a_34*a_35-d1_2*a_32 a_43 = 1.0E+0*beta1*d2_1*b_L*a_10+a_13*d3_1*a_7*b_L*EI*a_30+1.0E+0 \ *d1_1 a_44 = -1.0E+0*a_14*d3_1*a_12*a_15-1.0E+0*a_11*d4_1*b_L*a_12*L1-d1_1 \ *a_7*b_L a_45 = -1.0E+0*a_19*d2_1*a_12*a_20-1.0E+0*a_14*d3_1*b_L*a_12*a_15- \ a_11*d4_1*a_7*b_L*L1 a_46 = -a_m*a_1*a_38*a_45+a_39*a_44+1.0E+0*(-1.0E+0*a_11*d4_1*L1-beta1 \ *d2_1*a_7*b_L*EI*a_10-1.0E+0*d1_1*b_L)-a_L*a_43 a_47 = 1.0E+0*a_45+a_L*a_44 a_48 = 1/beta2 a_49 = a_m*a_1*a_45+a_m*a_r*a_1*a_44+1.0E+0*a_43 a_50 = -1.0E+0*beta1*d2_1*a_24*a_10-a_13*d3_1*EI*a_25*a_30-1.0E+0* \ a_18*d4_1*a_23*b_L*EI*a_6*a_29+1.0E+0*b_m*b_r*d1_1*a_1*a_23*a_6 a_51 = a_m*a_1*a_27+a_m*a_r*a_1*a_26+1.0E+0*a_50 a_52 = -a_m*a_1*a_38*a_27+a_39*a_26+1.0E+0*(-1.0E+0*a_11*b_m*b_r*d4_1 \ *a_1*a_23*a_6*L1+beta1*d2_1*EI*a_25*a_10+1.0E+0*a_13*d3_1*a_23 \ *b_L*EI*a_6*a_30+1.0E+0*d1_1*a_24)-a_L*a_50 a_53 = beta2*d2_2*a_52*a_41+1.0E+0*a_36*d3_2*EI*a_26*a_37+a_33*d4_2 \ *EI*a_28*a_35-d1_2*a_51 a_54 = -beta2*d2_2*a_46*a_41-1.0E+0*a_36*d3_2*EI*a_44*a_37-a_33*d4_2 \ *EI*a_47*a_35+d1_2*a_49 a_55 = -a_48*d4_2*a_51*L2+1.0E+0*beta2*d2_2*EI*a_26*a_41+a_36*d3_2 \ *EI*a_28*a_37+d1_2*a_52 a_56 = 1/(a_54*a_55+a_53*(-a_48*d4_2*a_49*L2+1.0E+0*beta2*d2_2*EI* \ a_44*a_41+a_36*d3_2*EI*a_47*a_37+d1_2*a_46)) a_57 = a_48*d4_2*a_32*L2-1.0E+0*beta2*d2_2*EI*a_16*a_41-a_36*d3_2* \ EI*a_34*a_37-d1_2*a_40 RESULT = a_gain*a_1*(a_47*(a_42*a_55*a_56+a_53*a_57*a_56)+a_28*(a_54 \ *a_57*a_56+a_42*(a_48*d4_2*a_49*L2-1.0E+0*beta2*d2_2*EI*a_44* \ a_41-a_36*d3_2*EI*a_47*a_37-d1_2*a_46)*a_56)+a_22+a_17) return RESULT
def log_2_pois_like(d,a,s1,s2): #taken out the max_score limit for now dp = np.sign(d)*np.power(np.abs(d),1.5) return ( log(a)*(s1+s2)+dp*(5+s2-s1) -2*a*cosh(dp) - gammaln(s1+1) - gammaln(s2+1) )
def f(self,xarr,t): x0dot = self.A*(pl.cos(t)+0.2)*(-2*(pl.cosh(self.d-xarr[3]) + pl.cosh(xarr[3]))*(pl.cos(xarr[2])**2 - pl.cosh(self.d-xarr[3])*pl.cosh(xarr[3]))*pl.sin(xarr[2]))/((pl.cos(xarr[2]) - pl.cosh(self.d-xarr[3]))*(pl.cos(xarr[2]) + pl.cosh(self.d - xarr[3]))*(pl.cos(xarr[2]) - pl.cosh(xarr[3]))*(pl.cos(xarr[2]) + pl.cosh(xarr[3])))- self.beta*xarr[0] x1dot = self.A*(pl.cos(t)+0.2)*(2*pl.cos(xarr[2])*(pl.sinh(self.d - xarr[3]) - pl.sinh(xarr[3]))*(-pl.sin(xarr[2])**2 + pl.sinh(self.d - xarr[3])*pl.sinh(xarr[3])))/((pl.cos(xarr[2]) - pl.cosh(self.d - xarr[3]))*(pl.cos(xarr[2]) + pl.cosh(self.d - xarr[3]))*(pl.cos(xarr[2]) - pl.cosh(xarr[3]))*(pl.cos(xarr[2]) + pl.cosh(xarr[3])))- self.beta*xarr[1] x2dot = xarr[0] x3dot = xarr[1] return [x0dot,x1dot,x2dot,x3dot]
def f(self,x,t): # the 4.0 only works for 2D N = len(x)/4 xdot = pl.array([]) # modulus the x component to keep periodicity right. x[2*N:3*N]= x[2*N:3*N]%self.diameter for i in range(N): temp = 0.0 for j in range(N): if i == j: continue #repulsive x interparticle force of j on i temp += self.qq*(x[2*N+i]-x[2*N+j])/(pl.sqrt((x[2*N+i]-x[2*N+j])**2+(x[3*N+i]-x[3*N+j])**2)**3) # force from same particle but in other direction becasue of periodic boundar # conditions temp += -self.qq*(self.diameter-(x[2*N+i]-x[2*N+j]))/(pl.sqrt((self.diameter-(x[2*N+i]-x[2*N+j]))**2+(x[3*N+i]-x[3*N+j])**2)**3) # could do this forever but for now just include one more of force going around in # same direction as first. draw a diagam if you need to temp += self.qq*(self.diameter+(x[2*N+i]-x[2*N+j]))/(pl.sqrt((self.diameter+(x[2*N+i]-x[2*N+j]))**2+(x[3*N+i]-x[3*N+j])**2)**3) # EC x force on particle i temp += self.A*(self.square_wave(t))*(-2*(pl.cosh(self.d-x[3*N+i]) + \ pl.cosh(x[3*N+i]))*(pl.cos(x[2*N+i])**2 - \ pl.cosh(self.d-x[3*N+i])*pl.cosh(x[3*N+i]))*pl.sin(x[2*N+i]))/((pl.cos(x[2*N+i])\ - pl.cosh(self.d-x[3*N+i]))*(pl.cos(x[2*N+i]) + pl.cosh(self.d - \ x[3*N+i]))*(pl.cos(x[2*N+i]) - pl.cosh(x[3*N+i]))*(pl.cos(x[2*N+i]) + \ pl.cosh(x[3*N+i]))) - self.beta*x[i] xdot = pl.append(xdot,temp) for i in range(N): temp = 0.0 for j in range(N): if i == j: continue #repulsive y interparticle force of j on i temp += self.qq*(x[3*N+i]-x[3*N+j])/(pl.sqrt((x[2*N+i]-x[2*N+j])**2+(x[3*N+i]-x[3*N+j])**2)**3) # force from same particle but in other direction becasue of periodic boundar # conditions temp += self.qq*(x[3*N+i]-x[3*N+j])/(pl.sqrt((self.diameter-(x[2*N+i]-x[2*N+j]))**2+(x[3*N+i]-x[3*N+j])**2)**3) # EC y force on particle i temp += self.A*(self.square_wave(t))*(2*pl.cos(x[2*N+i])*(pl.sinh(self.d - x[3*N+i]) - \ pl.sinh(x[3*N+i]))*(-pl.sin(x[2*N+i])**2 + pl.sinh(self.d - \ x[3*N+i])*pl.sinh(x[3*N+i])))/((pl.cos(x[2*N+i]) - pl.cosh(self.d - \ x[3*N+i]))*(pl.cos(x[2*N+i]) + pl.cosh(self.d - x[3*N+i]))*(pl.cos(x[2*N+i]) \ - pl.cosh(x[3*N+i]))*(pl.cos(x[2*N+i]) + \ pl.cosh(x[3*N+i])))-self.beta*x[N+i] # quadropole restoring force to center of electric curtains temp += -self.quadA*(pl.cos(200.0*t)+0.1)*(x[3*N+i]-self.d/2.0) xdot = pl.append(xdot,temp) for i in range(N): xdot = pl.append(xdot,x[i]) for i in range(N): xdot = pl.append(xdot,x[N+i]) return xdot
def tanh_grad(X): return 1 / np.square(np.cosh(X))