def __compute_t_r(self,n_lobes,lobe_idx,H_in,Hr,d_eval,p4roots,lead_cf): from pyranha import math from mpmath import asin, sqrt, ellipf, mpf assert(n_lobes == 1 or n_lobes == 2) C = -lead_cf assert(C > 0) # First determine if we are integrating in the upper or lower plane. # NOTE: we don't care about eps, we are only interested in the sign. if (self.__F1 * math.sin(pt('h_\\ast'))).trim().evaluate(d_eval) > 0: sign = 1 else: sign = -1 if n_lobes == 2: assert(lobe_idx == 0 or lobe_idx == 1) r0,r1,r2,r3 = p4roots # k is the same in both cases. k = sqrt(((r3-r2)*(r1-r0))/((r3-r1)*(r2-r0))) if lobe_idx == 0: assert(Hr == r0) phi = asin(sqrt(((r3-r1)*(H_in-r0))/((r1-r0)*(r3-H_in)))) else: assert(Hr == r2) phi = asin(sqrt(((r3-r1)*(H_in-r2))/((H_in-r1)*(r3-r2)))) return -sign * mpf(2) / sqrt(C * (r3 - r1) * (r2 - r0)) * ellipf(phi,k**2) else: # TODO: single lobe case. assert(False) pass
def kepler_trig_expand(s): """ Transform trigonometric part of series s [sin(nM) and cos(nM)] to sum of items like cos(M)^k1 * sin(M)^k2, where n=k1+k2. - s is series of e and M, - n is number of terms. """ from math import ceil from pyranha.math import binomial, cos, sin, degree temp, e, M, ecosM, esinM = 0, epst('e'), epst('M'), epst('ecosM'), epst( 'esinM') n = degree(s).numerator s_list = s.list for i in range(len(s_list)): for j in range(n + 1): trig_cos, trig_sin = 0, 0 # calculate cos(nM): if s_list[i][1] == cos(j * M): for k in range(int(ceil(j / 2)) + 1): trig_cos = trig_cos + (-1)**k * binomial( j, 2 * k) * ecosM**(j - 2 * k) * esinM**(2 * k) * e**-j temp = temp + s_list[i][0] * trig_cos # calculate sin(nM): if s_list[i][1] == sin(j * M): for k in range(int(ceil((j - 1) / 2)) + 1): trig_sin = trig_sin + (-1)**k * binomial( j, 2 * k + 1) * ecosM**(j - 2 * k - 1) * esinM**(2 * k + 1) * e**-j temp = temp + s_list[i][0] * trig_sin if type(temp) != type(1): temp = temp.trim() return temp
def EE(e, M, order): """ Celestial mechanics classical expansion of E. """ from pyranha.math import sin from fractions import Fraction as F temp = M for k in range(1, order + 1): temp = temp + F(2, k) * besselJ(k, k * e, order) * sin(k * M) return temp
def sin_E(e, M, order): """ Celestial mechanics classical expansion of sinE. """ from pyranha.math import sin from fractions import Fraction as F temp = 0 for k in range(1, order + 2): temp = temp + F(1, k) * (besselJ(k - 1, k * e, order) + besselJ(k + 1, k * e, order)) * sin(k * M) return temp
def sin_f(e, M, order): """ Celestial mechanics classical expansion of sinf. """ from pyranha.math import sin from fractions import Fraction as F temp = 0 for k in range(1, order + 2): temp = temp + (besselJ(k - 1, k * e, order) - besselJ(k + 1, k * e, order)) * sin(k * M) temp = temp * binomial_exp(1, -e**2, F(1, 2), int(order / 2)) return temp.transform( lambda t: (t[0].filter(lambda u: u[1].degree(['e']) <= order), t[1]))
def rrr(q, n, deg): """ Calculation expansions for r and them powers. - n is maximum degree of variables. """ from pyranha.math import cos, sin from eps.keproc import binomial_exp, r_a deg_max, e_max = n / 2 + 1, n MM, LL, xx, yy, uu, vv, qq = [ epst(i + str(q)) for i in ('m', 'L', 'x', 'y', 'u', 'v', 'q') ] K0, ee, MA = epst('K0'), epst('e'), epst('M') S1 = epst('s' + str(q - 1)) if q != 1 else F(1, 1) S2 = epst('s' + str(q)) ################################################## temp2 = binomial_exp(epst(1), -epst('eps'), F(1, 2), deg_max) temp5 = LL**F(-1, 2) * temp2.subs('eps', F(1, 4) * LL**-1 * (xx**2 + yy**2)) ecospi = xx * temp5 esinpi = -yy * temp5 ################################################## ra = r_a(ee, MA, e_max) ra = kepler_trig_expand(ra) ra = ra.subs('e', ee**F(1, 2)) subs1 = ecospi * cos(qq) + esinpi * sin(qq) subs2 = ecospi * sin(qq) - esinpi * cos(qq) subs3 = LL**-1 * (xx**2 + yy**2) * (1 - F(1, 4) * LL**-1 * (xx**2 + yy**2)) ################################################## pt.set_auto_truncate_degree(F(n), ['x' + str(q), 'y' + str(q)]) ra = ra.subs('ecosM', subs1) ra = ra.subs('esinM', subs2) ra = ra.subs('e', subs3) ra = ra.trim() aa = (K0 * MM**2 * S1)**-1 * S2 * LL**2 ra_deg = (ra * aa)**deg pt.unset_auto_truncate_degree() return ra_deg.trim()
def one_r(p, n, deg): """ Calculation expansions for 1/r and their powers (deg). - n is maximum degree of variables. """ from pyranha.math import cos, sin from eps.keproc import binomial_exp, a_r deg_max, e_max = n / 2 + 1, n MM, LL, xx, yy, uu, vv, qq = [ epst(i + str(p)) for i in ('m', 'L', 'x', 'y', 'u', 'v', 'q') ] K0, ee, MA = epst('K0'), epst('e'), epst('M') S1 = epst('s' + str(p - 1)) if p != 1 else F(1, 1) S2 = epst('s' + str(p)) ######################################################################## temp2 = binomial_exp(epst(1), -epst('eps'), F(1, 2), deg_max) temp5 = LL**F(-1, 2) * temp2.subs('eps', F(1, 4) * LL**-1 * (xx**2 + yy**2)) ecospi = xx * temp5 esinpi = -yy * temp5 ######################################################################## ar = a_r(ee, MA, e_max) ar = kepler_trig_expand(ar) ar = ar.subs('e', ee**F(1, 2)) subs1 = ecospi * cos(qq) + esinpi * sin(qq) subs2 = ecospi * sin(qq) - esinpi * cos(qq) subs3 = LL**-1 * (xx**2 + yy**2) * (1 - F(1, 4) * LL**-1 * (xx**2 + yy**2)) ######################################################################## pt.set_auto_truncate_degree(F(n), ['x' + str(p), 'y' + str(p)]) ar = ar.subs('ecosM', subs1) ar = ar.subs('esinM', subs2) ar = ar.subs('e', subs3) ar = ar.trim() aa = (K0 * MM**2 * S1)**-1 * S2 * LL**2 ar_deg = (ar * aa**-1)**deg pt.unset_auto_truncate_degree() return ar_deg.trim()
def xyz(p, n): """ Calculation expansions for vector of x, y, z-coordinates. - n is maximum degree of variables. """ from pyranha.math import cos, sin from eps.keproc import binomial_exp, cos_E, sin_E deg_max, e_max = n / 2 + 1, n MM, LL, xx, yy, uu, vv, qq = [ epst(i + str(p)) for i in ('m', 'L', 'x', 'y', 'u', 'v', 'q') ] K0, ee, MA, ecosM, esinM = epst('K0'), epst('e'), epst('M'), epst( 'ecosM'), epst('esinM') S1 = epst('s' + str(p - 1)) if p != 1 else F(1, 1) S2 = epst('s' + str(p)) ################################################## temp1 = binomial_exp(epst(1), -epst('eps'), -1, deg_max) temp2 = binomial_exp(epst(1), -epst('eps'), F(1, 2), deg_max) temp3 = F(1, 4) * LL**-1 * temp1.subs('eps', F(1, 2) * LL**-1 * (xx**2 + yy**2)) temp5 = LL**F(-1, 2) * temp2.subs('eps', F(1, 4) * LL**-1 * (xx**2 + yy**2)) temp4 = LL**F(-1,2) * temp1.subs('eps', F(1,2)*LL**-1 * (xx**2 + yy**2)) * \ temp2.subs('eps', F(1,4)*LL**-1 * (2*(xx**2 + yy**2) + (uu**2 + vv**2))) cos2I = 1 - (uu**2 + vv**2) * temp3 sin2Icos2Om = (uu**2 - vv**2) * temp3 sin2Isin2Om = -2 * (uu * vv) * temp3 sinIsinOm = -vv * temp4 sinIcosOm = uu * temp4 ecospi = xx * temp5 esinpi = -yy * temp5 ################################################## temp = binomial_exp(epst(1), -ee**2, F(1, 2), e_max) sqrt1 = F(1, 2) * (1 + temp) sqrt2 = F(1, 2) * (1 - temp) cosEM1 = cos_E(ee, MA, e_max) * cos(MA) + sin_E(ee, MA, e_max) * sin(MA) cosEM2 = cos_E(ee, MA, e_max) * cos(MA) - sin_E(ee, MA, e_max) * sin(MA) sinEM1 = sin_E(ee, MA, e_max) * cos(MA) - cos_E(ee, MA, e_max) * sin(MA) sinEM2 = sin_E(ee, MA, e_max) * cos(MA) + cos_E(ee, MA, e_max) * sin(MA) cosEM1 = (sqrt1 * cosEM1).truncate_degree(e_max, ['e']) cosEM2 = (sqrt2 * cosEM2).truncate_degree(e_max, ['e']) sinEM1 = (sqrt1 * sinEM1).truncate_degree(e_max, ['e']) sinEM2 = (sqrt2 * sinEM2).truncate_degree(e_max, ['e']) cosEM1 = kepler_trig_expand(cosEM1) cosEM2 = kepler_trig_expand(cosEM2) sinEM1 = kepler_trig_expand(sinEM1) sinEM2 = kepler_trig_expand(sinEM2) X_a = -ecosM + cosEM1 + cosEM2 Y_a = esinM + sinEM1 - sinEM2 X_a = X_a.subs('e', ee**F(1, 2)) Y_a = Y_a.subs('e', ee**F(1, 2)) subs1 = ecospi * cos(qq) + esinpi * sin(qq) subs2 = ecospi * sin(qq) - esinpi * cos(qq) subs3 = LL**-1 * (xx**2 + yy**2) * (1 - F(1, 4) * LL**-1 * (xx**2 + yy**2)) ################################################## pt.set_auto_truncate_degree( F(n), ['x' + str(p), 'y' + str(p), 'u' + str(p), 'v' + str(p)]) X_a = X_a.subs('ecosM', subs1) X_a = X_a.subs('esinM', subs2) X_a = X_a.subs('e', subs3) Y_a = Y_a.subs('ecosM', subs1) Y_a = Y_a.subs('esinM', subs2) Y_a = Y_a.subs('e', subs3) aa = (K0 * MM**2 * S1)**-1 * S2 * LL**2 xa = aa * (X_a * (cos2I * cos(qq) + sin2Icos2Om * cos(qq) + sin2Isin2Om * sin(qq)) -\ Y_a * (cos2I * sin(qq) + sin2Icos2Om * sin(qq) - sin2Isin2Om * cos(qq))) ya = aa * (X_a * (cos2I * sin(qq) - sin2Icos2Om * sin(qq) + sin2Isin2Om * cos(qq)) +\ Y_a * (cos2I * cos(qq) - sin2Icos2Om * cos(qq) - sin2Isin2Om * sin(qq))) za = aa * (X_a * (sinIcosOm * sin(qq) - sinIsinOm * cos(qq)) +\ Y_a * (sinIcosOm * cos(qq) + sinIsinOm * sin(qq))) pt.unset_auto_truncate_degree() return [xa.trim(), ya.trim(), za.trim()]
def __init__(self,params = __default_params): from numpy import dot from mpmath import mpf from fractions import Fraction as Frac import sympy from IPython.parallel import Client # Set up constants. self.__eps_val = (1./mpf(299792458.))**2 self.__GG_val = mpf(6.673E-11) # Various variables. Gt,I1,GG,m2,L,r,a,v2,Gtxy,ht,Ht,Gxy,h,H,J2,g,G,f,e,E,eps,hs,Hts,Gtxys = [pt(name) for name in ['\\tilde{G}','\\mathcal{I}_1',\ '\\mathcal{G}','m_2','L','r','a','v2','\\tilde{G}_{xy}','\\tilde{h}','\\tilde{H}','G_{xy}','h','H','J_2','g','G','f','e','E',\ '\\varepsilon','h_\\ast','\\tilde{H}_\\ast','\\tilde{G}_{xy\\ast}']] # The unperturbed Hamiltonian. H0 = Gt**2 * I1 / 2 - GG**2 * m2**2 * L**-2 / 2 self.__HH0 = H0 # Pieces of the perturbed Hamiltonian. Gt_vec = [Gtxy * math.sin(ht),-Gtxy * math.cos(ht),Ht] J2_vec = [0,0,J2] r_vec = dot(celmec.orbitalR([math.cos(g),math.sin(g),H*G**-1,Gxy*G**-1,math.cos(h),math.sin(h)]),[r*math.cos(f),r*math.sin(f),0]) r_cross_v = [Gxy * math.sin(h),-Gxy * math.cos(h),H] H1 = -Frac(1,8) * v2 ** 2 - Frac(3,2) * v2 * GG * m2 * r ** -1 + Frac(1,2) * GG**2 * m2**2 * r**-2 +\ Frac(3,2) * GG * m2 * r**-3 * dot(Gt_vec,r_cross_v) + 2 * GG * r**-3 * dot(J2_vec,r_cross_v) +\ GG * r**-3 * (3 * dot(Gt_vec,r_vec) * dot(J2_vec,r_vec) * r**-2 - dot(Gt_vec,J2_vec)) H1 = H1.subs('v2',GG * m2 * (2 * r**-1 - a ** -1)).subs('a',L ** 2 * (GG * m2)**-1) # Verify formula in the paper. assert(-Frac(1,8)*GG**4*m2**4*L**-4+r**-1*2*GG**3*m2**3*L**-2-r**-2*3*GG**2*m2**2+GG*r**-3*(\ 2*J2*H+3*J2*Gxy**2*Ht*(G**-2)/2+3*m2*Ht*H/2-J2*Ht+(3*m2/2*Gtxy*Gxy-3*J2/2*H*Gxy*Gtxy*G**-2)*math.cos(ht-h)+\ 3*J2*(-Frac(1,2)*Gxy**2*Ht*G**-2*math.cos(2*f+2*g)-Frac(1,4)*Gxy*Gtxy*G**-1*(1-H*G**-1)*math.cos(2*f+2*g+ht-h)+\ Frac(1,4)*Gxy*Gtxy*G**-1*(1+H*G**-1)*math.cos(2*f+2*g-ht+h))) == H1) # Split the Hamiltonian in parts. A0 = H1.transform(lambda t: (t[0].filter(lambda t: t[1].degree(['r']) == 0),t[1])).filter(lambda t: t[1] == pt(1)).subs('r',pt(1)) A1 = H1.transform(lambda t: (t[0].filter(lambda t: t[1].degree(['r']) == -1),t[1])).filter(lambda t: t[1] == pt(1)).subs('r',pt(1)) A2 = H1.transform(lambda t: (t[0].filter(lambda t: t[1].degree(['r']) == -2),t[1])).filter(lambda t: t[1] == pt(1)).subs('r',pt(1)) A3a = H1.transform(lambda t: (t[0].filter(lambda t: t[1].degree(['r']) == -3),t[1])).filter(lambda t: t[1] == pt(1)).subs('r',pt(1)) A3b = H1.filter(lambda t: t[1] == math.cos(ht - h)).transform(lambda t: (t[0],pt(1))).subs('r',pt(1)) B0 = H1.filter(lambda t: t[1] == math.cos(2*f + 2*g)).transform(lambda t: (t[0],pt(1))).subs('r',pt(1)) B1 = H1.filter(lambda t: t[1] == math.cos(2*f + 2*g + ht - h)).transform(lambda t: (t[0],pt(1))).subs('r',pt(1)) B2 = H1.filter(lambda t: t[1] == math.cos(2*f + 2*g - ht + h)).transform(lambda t: (t[0],pt(1))).subs('r',pt(1)) # Make sure we got them right. assert(A0 + A1 * r**-1 + A2 * r**-2 + r**-3 * (A3a + A3b * math.cos(ht - h)) + r**-3 * (B0 * math.cos(2*f + 2*g) +\ B1 * math.cos(2*f + 2*g + ht - h) + B2 * math.cos(2*f + 2*g - ht + h)) == H1) # This is the integrand in f (without the part that is integrated in E). f_int = A2 * r**-2 + r**-3 * (A3a + A3b * math.cos(ht - h)) + r**-3 * (B0 * math.cos(2*f + 2*g) + B1 * math.cos(2*f + 2*g + ht - h) + B2 * math.cos(2*f + 2*g - ht + h)) # Change the integration variable to f (with the constant parts already taken out of the integral). f_int *= r**2 # Substitute the definition of 1/r in terms of f. f_int = f_int.subs('r',pt('rm1')**-1).subs('rm1',GG*m2*G**-2*(1+e*math.cos(f))) # This is the integrand in E. E_int = A1 * r**-1 # Change the integration variable to f. E_int *= r**2 # Change the integration variable to E. E_int *= L*G*r**-1*GG**-1*m2**-1 assert(E_int == A1*G*L*GG**-1*m2**-1) # K1. K1 = GG**2 * m2**2 * G**-1 * L**-3 * (f_int + E_int).filter(lambda t: t[1].t_degree(['f']) == 0) # K. K = K1 + A0 # The generator. chi = G**-1 * (E_int.integrate('E') + f_int.integrate('f')) - L**3 * GG**-2 * m2**-2 * K1.integrate('l') # Verifiy that chi satisfies the homological equation, yielding K. assert((math.pbracket(H0,chi,['L','G','H','\\tilde{G}','\\tilde{H}'],['l','g','h','\\tilde{g}','\\tilde{h}']) + H1)\ .subs('r',pt('rm1')**-1).subs('rm1',GG*m2*G**-2*(1+e*math.cos(f))) == K) # This is the complete Hamiltonian, with the two coordinates compressed into a single one. HHp = H0 + eps * K.subs('h',ht+hs).subs('\\tilde{H}',Hts-H).subs('\\tilde{G}_{xy}',Gtxys) # Record it as a member. self.__HHp = HHp # F0 and F1. F0 = HHp.filter(lambda t: t[1].t_degree(['h_\\ast']) == 0).transform(lambda t: (t[0].filter(lambda t: t[1].degree(['\\varepsilon']) == 1),t[1])).subs('\\varepsilon',pt(1)) F1 = HHp.filter(lambda t: t[1].t_degree(['h_\\ast']) == 1).transform(lambda t: (t[0].filter(lambda t: t[1].degree(['\\varepsilon']) == 1),t[1])).subs('\\varepsilon',pt(1)).subs('h_\\ast',pt(0)) assert(H0 + eps * F0 + eps * F1 * math.cos(pt('h_\\ast')) == H0 + eps * K.subs('h',ht+hs).subs('\\tilde{H}',Hts-H).subs('\\tilde{G}_{xy}',Gtxys)) self.__F0 = F0 self.__F1 = F1 # Quartic polynomial. f4H = (eps**2 * F1 ** 2 - (pt('\\mathcal{H}^\\prime') - H0 - eps * F0)**2)\ .ipow_subs('G_{xy}',2,G**2-H**2)\ .ipow_subs('\\tilde{G}_{xy\\ast}',2,Gt**2-(Hts-H)**2) a4 = f4H.transform(lambda t: (t[0].filter(lambda t: t[1].degree(['H']) == 0),t[1])) a3 = f4H.transform(lambda t: (t[0].filter(lambda t: t[1].degree(['H']) == 1),t[1])).subs('H',pt(1)) / 4 a2 = f4H.transform(lambda t: (t[0].filter(lambda t: t[1].degree(['H']) == 2),t[1])).subs('H',pt(1)) / 6 a1 = f4H.transform(lambda t: (t[0].filter(lambda t: t[1].degree(['H']) == 3),t[1])).subs('H',pt(1)) / 4 a0 = f4H.transform(lambda t: (t[0].filter(lambda t: t[1].degree(['H']) == 4),t[1])).subs('H',pt(1)) # NOTE: these are not the polynomial coefficient strictly speaking, they are normalised by 4, 6 and 4 # as shown above and in the assert below. self.__f4_cf = (a0,a1,a2,a3,a4) # Check we got them right. assert(a4+4*a3*H+6*a2*H**2+4*a1*H**3+a0*H**4 == f4H) # Store the coefficients - from high degree to low. self.__f4_coeffs = [t[0] * t[1].trim() for t in zip([1,4,6,4,1],self.__f4_cf)] # Derivatives of the quartic poly. f4Hp = math.partial(f4H,'H') f4Hpp = math.partial(f4Hp,'H') f4Hppp = math.partial(f4Hpp,'H') f4Hpppp = math.partial(f4Hppp,'H') # Check the derivatives for consistency. assert(f4Hp == 4*a3 + 12*a2*H + 12*a1*H**2 + 4*a0*H**3) assert(f4Hpp == 12*a2 + 24*a1*H + 12*a0*H**2) assert(f4Hppp == 24*a1 + 24*a0*H) assert(f4Hpppp == 24*a0) self.__f4 = [f4H, f4Hp, f4Hpp, f4Hppp, f4Hpppp] # Invariants for wp. g2 = a0*a4 - 4*a1*a3 + 3*a2**2 g3 = a0*a2*a4 + 2*a1*a2*a3 - (a2**3) - (a0*a3**2) - (a1**2*a4) self.__g2 = g2 self.__g3 = g3 # Solve the angles. # Extract cosine of h_s. #chs = sympy.solve((spin_gr_theory.__to_sympy(self.HHp.trim())-sympy.Symbol('\\mathcal{H}^\\prime')).replace(sympy.cos(sympy.Symbol('h_\\ast')),sympy.Symbol('chs')),sympy.Symbol('chs'))[0] #ipy_view = Client().load_balanced_view() #g_sol = ipy_view.apply_async(spin_gr_theory.__solve_g,chs,spin_gr_theory.__to_sympy(math.partial(self.HHp.trim(),'G'))) #hs_sol = ipy_view.apply_async(spin_gr_theory.__solve_hs,chs,spin_gr_theory.__to_sympy(math.partial(self.HHp.trim(),'H'))) #ht_sol = ipy_view.apply_async(spin_gr_theory.__solve_ht,chs,spin_gr_theory.__to_sympy(math.partial(self.HHp.trim(),'\\tilde{H}_\\ast'))) #self.__g_sol = g_sol.get() #self.__hs_sol = hs_sol.get() #self.__ht_sol = ht_sol.get() import pickle self.__g_sol = pickle.load(open('g_sol.pickle','rb')) self.__hs_sol = pickle.load(open('hs_sol.pickle','rb')) self.__ht_sol = pickle.load(open('ht_sol.pickle','rb')) # Set the parameters of the theory. self.__set_params(params) # Some sanity checks. HHp,G,L,H,GG,eps,m2,Hts,Gt,J2,hs,Gxy,Gtxys = [sympy.Symbol(s) for s in ['\\mathcal{H}^\\prime','G','L','H','\\mathcal{G}',\ '\\varepsilon','m_2','\\tilde{H}_\\ast','\\tilde{G}','J_2','h_\\ast','G_{xy}','\\tilde{G}_{xy\\ast}']] # Phi_g^4 going to zero in the equilibrium point. assert(self.g_sol[0][3][1].subs(HHp,spin_gr_theory.__to_sympy(self.HHp.ipow_subs('G_{xy}',2,pt('G')**2\ -pt('H')**2).subs('H',pt('G')**2*pt('m_2')*pt('J_2')**-1))).ratsimp() == 0) # Reduction to Einstein precession. simpl_HHp_ein = spin_gr_theory.__to_sympy(self.HHp.subs('J_2',0).subs('\\tilde{G}_{xy\\ast}',0).subs('\\tilde{H}_\\ast',pt('H'))\ .subs('\\tilde{G}',0)) ein_prec = sum([t[0]*t[1] for t in self.g_sol[0]]).subs('J_2',0).subs(Hts,H).subs(Gt,0)\ .subs(HHp,simpl_HHp_ein).ratsimp() assert(ein_prec == 3 * eps * GG**4 * m2**4/(G**2*L**3)) # Lense-Thirring precession for g. simpl_HHp_lt = spin_gr_theory.__to_sympy(self.HHp.subs('\\tilde{G}_{xy\\ast}',0).subs('\\tilde{H}_\\ast',pt('H'))\ .subs('\\tilde{G}',0)) lt_prec = sum([t[0]*t[1] for t in self.g_sol[0]]).subs(Hts,H).subs(Gt,0).subs(HHp,simpl_HHp_lt).ratsimp() assert(lt_prec == (eps * ((-6*H*J2*GG**4*m2**3)/(G**4*L**3)+3*GG**4*m2**4/(G**2*L**3))).ratsimp()) # Geodetic effect on g. simpl_HHp_ge = spin_gr_theory.__to_sympy(self.HHp.subs('J_2',0)).subs(sympy.cos(hs),-1).subs(Gxy,sympy.sqrt(G**2-H**2))\ .subs(Gtxys,sympy.sqrt(Gt**2-(Hts-H)**2)).subs(H,(Hts**2+G**2-Gt**2)/(2*Hts)) ge_g = sum([t[0]*t[1] for t in self.g_sol[0]]).subs(J2,0).subs(Gxy,sympy.sqrt(G**2-H**2))\ .subs(Gtxys,sympy.sqrt(Gt**2-(Hts-H)**2)).subs(H,(Hts**2+G**2-Gt**2)/(2*Hts)).subs(HHp,simpl_HHp_ge).ratsimp() assert(ge_g == (1 / (4*G**4*L**3) * (15*G**2*GG**4*eps*m2**4+9*GG**4*Gt**2*eps*m2**4-9*GG**4*Hts**2*eps*m2**4)).ratsimp()) # No precession in h for Einstein case. assert((sum([t[0]*t[1] for t in self.hs_sol[0]]) + sum([t[0]*t[1] for t in self.ht_sol[0]])).subs(HHp,simpl_HHp_ein)\ .subs('J_2',0).subs(Hts,H).ratsimp().subs(Gt,0) == 0) # h precession in LT. assert((sum([t[0]*t[1] for t in self.hs_sol[0]]) + sum([t[0]*t[1] for t in self.ht_sol[0]])).subs(HHp,simpl_HHp_lt)\ .subs(Hts,H).ratsimp().subs(Gt,0).ratsimp() == 2*eps*J2*GG**4*m2**3/(G**3*L**3)) # Geodetic effect for h and ht. assert((sum([t[0]*t[1] for t in self.hs_sol[0]]) + sum([t[0]*t[1] for t in self.ht_sol[0]])).subs(HHp,simpl_HHp_ge)\ .subs(J2,0).subs(H,(Hts**2+G**2-Gt**2)/(2*Hts)).ratsimp() == 3*GG**4*Hts*eps*m2**4/(2*G**3*L**3)) assert((sum([t[0]*t[1] for t in self.ht_sol[0]])).subs(HHp,simpl_HHp_ge)\ .subs(J2,0).subs(H,(Hts**2+G**2-Gt**2)/(2*Hts)).ratsimp() == 3*GG**4*Hts*eps*m2**4/(2*G**3*L**3))