def test_calculate_trajectory_iterator_RuntimeWarning_kerr(): t = 0. M = 1e25 a = 0. x_vec = np.array([306., np.pi / 2, np.pi / 2]) v_vec = np.array([0., 0.01, 10.]) mk_cov = Kerr(coords="BL", M=M, a=a) x_4vec = four_position(t, x_vec) mk_cov_mat = mk_cov.metric_covariant(x_4vec) init_vec = stacked_vec(mk_cov_mat, t, x_vec, v_vec, time_like=True) end_lambda = 1. stepsize = 0.4e-6 OdeMethodKwargs = {"stepsize": stepsize} geod = Geodesic(metric=mk_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=stepsize, return_cartesian=False) with warnings.catch_warnings(record=True) as w: it = geod.calculate_trajectory_iterator( OdeMethodKwargs=OdeMethodKwargs, ) for _, _ in zip(range(1000), it): pass assert len(w) >= 1
def test_compare_calculate_trajectory_iterator_cartesian_kerrnewman( test_input): t, a, Q, q, end_lambda, step_size = test_input M = 2e24 x_vec = np.array([1e6, 1e6, 20.5]) v_vec = np.array([1e4, 1e4, -30.]) mkn_cov = KerrNewman(coords="BL", M=M, a=a, Q=Q, q=q) x_4vec = four_position(t, x_vec) mkn_cov_mat = mkn_cov.metric_covariant(x_4vec) init_vec = stacked_vec(mkn_cov_mat, t, x_vec, v_vec, time_like=True) OdeMethodKwargs = {"stepsize": step_size} return_cartesian = True geod = Geodesic(metric=mkn_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=step_size, return_cartesian=return_cartesian) traj = geod.trajectory traj_iter = geod.calculate_trajectory_iterator( OdeMethodKwargs=OdeMethodKwargs, return_cartesian=return_cartesian) traj_iter_list = list() for _, val in zip(range(20), traj_iter): traj_iter_list.append(val[1]) traj_iter_arr = np.array(traj_iter_list) assert_allclose(traj[:20], traj_iter_arr)
def test_Geodesics_repr_returns_members(dummy_data): body, t, _, end_lambda, stepsize = dummy_data geo = Geodesic(body, time=t, end_lambda=end_lambda, step_size=stepsize) assert ( geo.__repr__() == "body name= (obj) , metric=(Schwarzschild) , parent name=(attractor) , parent mass=(6e+24 kg)" )
def test_calculate_trajectory_iterator_kerr(x_vec, v_vec, t, M, a, end_lambda, step_size, OdeMethodKwargs, return_cartesian): mk_cov = Kerr(coords="BL", M=M, a=a) x_4vec = four_position(t, x_vec) mk_cov_mat = mk_cov.metric_covariant(x_4vec) init_vec = stacked_vec(mk_cov_mat, t, x_vec, v_vec, time_like=True) geod = Geodesic(metric=mk_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=step_size, return_cartesian=return_cartesian) traj = geod.trajectory traj_iter = geod.calculate_trajectory_iterator( OdeMethodKwargs=OdeMethodKwargs, return_cartesian=return_cartesian) traj_iter_list = list() for _, val in zip(range(50), traj_iter): traj_iter_list.append(val[1]) traj_iter_arr = np.array(traj_iter_list) assert_allclose(traj[:50, :], traj_iter_arr, rtol=1e-10)
def test_calculate_trajectory_iterator_RuntimeWarning_kerrnewman(): M = 0.5 * 5.972e24 a = 0. Q = 0. q = 0. t = 0. x_vec = np.array([306, np.pi / 2, np.pi / 2]) v_vec = np.array([0., 0.01, 10.]) mkn_cov = KerrNewman(coords="BL", M=M, a=a, Q=Q, q=q) x_4vec = four_position(t, x_vec) mkn_cov_mat = mkn_cov.metric_covariant(x_4vec) init_vec = stacked_vec(mkn_cov_mat, t, x_vec, v_vec, time_like=True) end_lambda = 200. step_size = 0.4e-6 OdeMethodKwargs = {"stepsize": step_size} geod = Geodesic(metric=mkn_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=step_size) with warnings.catch_warnings(record=True) as w: it = geod.calculate_trajectory_iterator( OdeMethodKwargs=OdeMethodKwargs, ) for _, _ in zip(range(1000), it): pass assert len(w) >= 1
def test_calculate_trajectory_kerr(x_vec, v_vec, t, M, a, end_lambda, step_size): mk_cov = Kerr(coords="BL", M=M, a=a) x_4vec = four_position(t, x_vec) mk_cov_mat = mk_cov.metric_covariant(x_4vec) init_vec = stacked_vec(mk_cov_mat, t, x_vec, v_vec, time_like=True) geod = Geodesic(metric=mk_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=step_size, return_cartesian=False) ans = geod.trajectory testarray = list() for i in ans: x = i[:4] g = mk_cov.metric_covariant(x) testarray.append(g[0][0] * (i[4]**2) + g[1][1] * (i[5]**2) + g[2][2] * (i[6]**2) + g[3][3] * (i[7]**2) + 2 * g[0][3] * i[4] * i[7]) testarray = np.array(testarray, dtype=float) assert_allclose(testarray, 1., 1e-4)
def test_str_repr(): """ Tests, if the ``__str__`` and ``__repr__`` messages match """ t = 0. M = 1e25 x_vec = np.array([306., np.pi / 2, np.pi / 2]) v_vec = np.array([0., 0.01, 10.]) ms_cov = Schwarzschild(M=M) x_4vec = four_position(t, x_vec) ms_cov_mat = ms_cov.metric_covariant(x_4vec) init_vec = stacked_vec(ms_cov_mat, t, x_vec, v_vec, time_like=True) end_lambda = 1. step_size = 0.4e-6 geod = Geodesic(metric=ms_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=step_size) assert str(geod) == repr(geod)
def test_calculate_trajectory2_schwarzschild(): # based on the revolution of earth around sun # data from https://en.wikipedia.org/wiki/Earth%27s_orbit t = 0. M = 1.989e30 distance_at_perihelion = 147.10e9 speed_at_perihelion = 30290 angular_vel = (speed_at_perihelion / distance_at_perihelion) x_vec = np.array([distance_at_perihelion, np.pi / 2, 0]) v_vec = np.array([0.0, 0.0, angular_vel]) ms_cov = Schwarzschild(M=M) x_4vec = four_position(t, x_vec) ms_cov_mat = ms_cov.metric_covariant(x_4vec) init_vec = stacked_vec(ms_cov_mat, t, x_vec, v_vec, time_like=True) end_lambda = 3.154e7 geod = Geodesic(metric=ms_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=end_lambda / 2e3, return_cartesian=False) ans = geod.trajectory # velocity should be 29.29 km/s at aphelion(where r is max) i = np.argmax(ans[:, 1]) # index where radial distance is max v_aphelion = (((ans[i][1] * ans[i][7]) * (u.m / u.s)).to(u.km / u.s)).value assert_allclose(v_aphelion, 29.29, rtol=0.01)
def perihelion(): """ An example to showcase the usage of the various modules in ``einsteinpy.metric``. \ Here, we assume a Schwarzschild spacetime and obtain & plot the apsidal precession of \ test particle orbit in it. Returns ------- geod: ~einsteinpy.geodesic.Geodesic Geodesic defining test particle trajectory """ M = 6e24 # Mass t = 10000 # Coordinate Time (has no effect in this case - Schwarzschild) x_vec = np.array([130.0, np.pi / 2, -np.pi / 8]) # 3-Pos v_vec = np.array([0.0, 0.0, 1900.0]) # 3-Vel # Schwarzschild Metric Object ms_cov = Schwarzschild(M=M) # Getting Position 4-Vector x_4vec = four_position(t, x_vec) # Calculating Schwarzschild Metric at x_4vec ms_cov_mat = ms_cov.metric_covariant(x_4vec) # Getting stacked (Length-8) initial vector, containing 4-Pos and 4-Vel init_vec = stacked_vec(ms_cov_mat, t, x_vec, v_vec, time_like=True) # Calculating Geodesic geod = Geodesic(metric=ms_cov, init_vec=init_vec, end_lambda=0.002, step_size=5e-8) return geod
def test_calculate_trajectory1_kerrnewman(): # This needs more investigation # the test particle should not move as gravitational & electromagnetic forces are balanced t = 0. M = 0.5 * 5.972e24 a = 0. Q = 11604461683.91822052001953125 q = _G * M / _Cc r = 1e6 end_lambda = 1000.0 step_size = 0.5 x_vec = np.array([r, 0.5 * np.pi, 0.]) v_vec = np.array([0., 0., 0.]) mkn_cov = KerrNewman(coords="BL", M=M, a=a, Q=Q, q=q) x_4vec = four_position(t, x_vec) mkn_cov_mat = mkn_cov.metric_covariant(x_4vec) init_vec = stacked_vec(mkn_cov_mat, t, x_vec, v_vec, time_like=True) geod = Geodesic(metric=mkn_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=step_size, return_cartesian=False) ans = geod.trajectory assert_allclose(ans[0][1], ans[-1][1], 1e-2)
def test_Geodesics_has_trajectory(dummy_data): metric, init_vec, end_lambda, step_size = dummy_data geo = Geodesic(metric=metric, init_vec=init_vec, end_lambda=end_lambda, step_size=step_size) assert isinstance(geo.trajectory, np.ndarray)
def test_order_NotImplementedError(): with pytest.raises(NotImplementedError): geod = Geodesic( metric="Kerr", metric_params=(0.9,), position=[2.15, np.pi / 2, 0.], momentum=[0., 0., 1.5], time_like=True, steps=4, delta=0.5, order=5 )
def test_runtime_warning2(): with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") geod = Geodesic( metric="Kerr", metric_params=(0.9,), position=[2.15, np.pi / 2, 0.], momentum=[0., 0., 1.5], time_like=True, steps=4, delta=0.5, omega=0.01 # Stable integration ) assert len(w) == 0
def perihelion(): Attractor = Body(name="BH", mass=6e24 * u.kg, parent=None) sph_obj = SphericalDifferential( 130 * u.m, np.pi / 2 * u.rad, -np.pi / 8 * u.rad, 0 * u.m / u.s, 0 * u.rad / u.s, 1900 * u.rad / u.s, ) Object = Body(differential=sph_obj, parent=Attractor) geodesic = Geodesic(body=Object, time=0 * u.s, end_lambda=0.002, step_size=5e-8) return geodesic
def dummy_data(): M = 6e24 t = 0. x_vec = np.array([130.0, np.pi / 2, -np.pi / 8]) v_vec = np.array([0.0, 0.0, 1900.0]) ms_cov = Schwarzschild(M=M) x_4vec = four_position(t, x_vec) ms_cov_mat = ms_cov.metric_covariant(x_4vec) init_vec = stacked_vec(ms_cov_mat, t, x_vec, v_vec, time_like=True) end_lambda = 0.002 step_size = 5e-8 geod = Geodesic(metric=ms_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=step_size) return geod
def dummy_data(): obj = SphericalDifferential( 130 * u.m, np.pi / 2 * u.rad, -np.pi / 8 * u.rad, 0 * u.m / u.s, 0 * u.rad / u.s, 1900 * u.rad / u.s, ) att = Body(name="attractor", mass=6e24 * u.kg, parent=None) b1 = Body(name="obj", differential=obj, parent=att) t = 0 * u.s start_lambda = 0.0 end_lambda = 0.002 step_size = 5e-8 geo = Geodesic(b1, time=t, end_lambda=end_lambda, step_size=step_size) return geo
def test_runtime_warning_python(dummy_time_python): q0, p0, a, end_lambda, step_size, julia = dummy_time_python with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") geod = Geodesic(position=q0, momentum=p0, a=a, end_lambda=end_lambda, step_size=step_size, time_like=True, return_cartesian=True, julia=julia) assert len(w) == 1 # 1 warning to be shown assert issubclass(w[-1].category, RuntimeWarning)
def test_runtime_warning1(): with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") geod = Geodesic( metric="Kerr", metric_params=(0.9,), position=[2.15, np.pi / 2, 0.], momentum=[0., 0., 1.5], time_like=True, steps=4, delta=0.5, omega=1. # Unstable integration ) assert len(w) == 2 # 2 warnings to be shown assert issubclass(w[-1].category, RuntimeWarning)
def test_calculate_trajectory0_kerrnewman(): # Based on the revolution of earth around sun # Data from https://en.wikipedia.org/wiki/Earth%27s_orbit # Initialized with cartesian coordinates # Function returning cartesian coordinates t = 0. M = 1.989e30 a = 0. Q = 0. q = 0. distance_at_perihelion = 147.10e9 speed_at_perihelion = 30290 x_sph = CartesianConversion(distance_at_perihelion / np.sqrt(2), distance_at_perihelion / np.sqrt(2), 0., -speed_at_perihelion / np.sqrt(2), speed_at_perihelion / np.sqrt(2), 0.).convert_spherical() x_vec = x_sph[:3] v_vec = x_sph[3:] mkn_cov = KerrNewman(coords="BL", M=M, a=a, Q=Q, q=q) x_4vec = four_position(t, x_vec) mkn_cov_mat = mkn_cov.metric_covariant(x_4vec) init_vec = stacked_vec(mkn_cov_mat, t, x_vec, v_vec, time_like=True) end_lambda = 3.154e7 geod = Geodesic( metric=mkn_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=end_lambda / 1.5e3, ) ans = geod.trajectory # velocity should be 29.29 km/s at aphelion(where r is max) R = np.sqrt(ans[:, 1]**2 + ans[:, 2]**2 + ans[:, 3]**2) i = np.argmax(R) # index where radial distance is max v_aphelion = ((np.sqrt(ans[i, 5]**2 + ans[i, 6]**2 + ans[i, 7]**2) * (u.m / u.s)).to(u.km / u.s)).value assert_allclose(v_aphelion, 29.29, rtol=0.01)
def Plot(Attractor, sph_obj, simLength=0.002): '''Plots with given attractor and bodies. Note: increasing simLength gives longer simulation but takes longer to load''' plt.close() obj = StaticGeodesicPlotter() #Adding the body to the attractor Object = Body(differential=sph_obj, parent=Attractor) #Define geometry i.e. Schwarzschild geodesic = Geodesic(body=Object, time=startTime * u.s, end_lambda=simLength, step_size=sSize) #Plotting the trajectory obj.plot(geodesic) plt.title("Plot of Orbit") #Plot Visuals fig = plt.gcf() fig.canvas.set_window_title("Plot of Orbit") plt.show()
def test_higher_order_traits(order): geod = Geodesic( metric="Kerr", metric_params=(0.5,), position=[4., np.pi / 2, 0.], momentum=[0., 0., 2.], time_like=False, steps=10, delta=0.5, order=order, return_cartesian=False, suppress_warnings=True ) L = geod.momentum[-1] theta = geod.position[2] assert_allclose(geod.trajectory[1][:, -1], L, atol=1e-4, rtol=1e-4) assert_allclose(geod.trajectory[1][:, 2], theta, atol=1e-6, rtol=1e-6)
def dummy_geod(): q0 = [2.5, np.pi / 2, 0.] p0 = [0., -0.2, -2.] a = 0.9 end_lambda = 1. step_size = 0.05 time_like = False return_cartesian = True julia = False geod = Geodesic(position=q0, momentum=p0, a=a, end_lambda=end_lambda, step_size=step_size, time_like=time_like, return_cartesian=return_cartesian, julia=julia) return geod
def test_calculate_trajectory3_schwarzschild(): # same test as with test_calculate_trajectory2_schwarzschild(), # but initialized with cartesian coordinates # and function returning cartesian coordinates t = 0. M = 1.989e30 distance_at_perihelion = 147.10e9 speed_at_perihelion = 30290 x_sph = CartesianConversion(distance_at_perihelion / np.sqrt(2), distance_at_perihelion / np.sqrt(2), 0., -speed_at_perihelion / np.sqrt(2), speed_at_perihelion / np.sqrt(2), 0.).convert_spherical() x_vec = x_sph[:3] v_vec = x_sph[3:] ms_cov = Schwarzschild(M=M) x_4vec = four_position(t, x_vec) ms_cov_mat = ms_cov.metric_covariant(x_4vec) init_vec = stacked_vec(ms_cov_mat, t, x_vec, v_vec, time_like=True) end_lambda = 3.154e7 geod = Geodesic( metric=ms_cov, init_vec=init_vec, end_lambda=end_lambda, step_size=end_lambda / 2e3, ) ans = geod.trajectory # velocity should be 29.29 km/s at aphelion(where r is max) R = np.sqrt(ans[:, 1]**2 + ans[:, 2]**2 + ans[:, 3]**2) i = np.argmax(R) # index where radial distance is max v_aphelion = ((np.sqrt(ans[i, 5]**2 + ans[i, 6]**2 + ans[i, 7]**2) * (u.m / u.s)).to(u.km / u.s)).value assert_allclose(v_aphelion, 29.29, rtol=0.01)
def test_calculate_trajectory_kerr_Geodesic(bl, M, a, end_lambda, step_size): mk = Kerr(coords=bl, M=M, a=a) geod = Geodesic(time_like=True, metric=mk, coords=bl, end_lambda=end_lambda, step_size=step_size, return_cartesian=False) ans = geod.trajectory testarray = list() for i in ans: x = i[:4] g = mk.metric_covariant(x) testarray.append(g[0][0] * (i[4]**2) + g[1][1] * (i[5]**2) + g[2][2] * (i[6]**2) + g[3][3] * (i[7]**2) + 2 * g[0][3] * i[4] * i[7]) testarray = np.array(testarray) assert_allclose(testarray, _c**2, 1e-8)
def run(planet): ''' Defining Variables and Objects ''' grav_constant = 6.67430e-20 * u.km**3 / (u.kg * u.s**2) # km3 kg-1 s-2 bodies_list = ['sun', 'mercury', 'venus', 'earth', 'moon'] all_bodies_list = [ 'sun', 'mercury', 'venus', 'earth', 'moon', 'mars', 'jupiter', 'saturn', 'uranus', 'neptune' ] radius = { 'sun': 696340 * u.km, 'mercury': 2439.5 * u.km, 'venus': 6052 * u.km, 'earth': 6371 * u.km, 'moon': 3389.5 * u.km, 'mars': 3389.5 * u.km, 'jupiter': 142984 / 2 * u.km, 'saturn': 120536 / 2 * u.km, 'uranus': 51118 / 2 * u.km, 'neptune': 49528 / 2 * u.km } aphelion = { 'sun': 0 * u.km, 'mercury': 69.8e6 * u.km, 'venus': 108.9e6 * u.km, 'earth': 152.1e6 * u.km, 'moon': 0.406e6 * u.km, 'mars': 249.2e6 * u.km, 'jupiter': 816.6e6 * u.km, 'saturn': 1514.5e6 * u.km, 'uranus': 3003.6e6 * u.km, 'neptune': 4545.7e6 * u.km } perihelion = { 'sun': 0 * u.km, 'mercury': 46.0e6 * u.km, 'venus': 107.5e6 * u.km, 'earth': 147.1e6 * u.km, 'moon': 0.363e6 * u.km, 'mars': 206.6e6 * u.km, 'jupiter': 740.5e6 * u.km, 'saturn': 1352.6e6 * u.km, 'uranus': 2741.3e6 * u.km, 'neptune': 4444.5e6 * u.km } mass = { 'sun': 1.989e30 * u.kg, 'mercury': 0.33e24 * u.kg, 'venus': 4.87e24 * u.kg, 'earth': 5.972e24 * u.kg, 'moon': 7.34767309e22 * u.kg, 'mars': 6.39e23 * u.kg, 'jupiter': 1898e24 * u.kg, 'saturn': 568e24 * u.kg, 'uranus': 86.8e24 * u.kg, 'neptune': 103e24 * u.kg } distances_value = {} speed_at_perihelion = {} omega = {} for body in bodies_list: distances_value[body] = [0 * u.km, perihelion[body], 0 * u.km] if body != 'sun': speed_at_perihelion[body] = np.sqrt(grav_constant * mass['sun'] / perihelion[body]) omega[body] = (u.rad * speed_at_perihelion[body]) / perihelion[body] ''' Spherical Differentiation Objects and Body Objects ''' # args(name=str, mass=kg, R(radius)=units, differential=coordinates of body, # a=spin factor, q=charge, is_attractor=True/False, parent=who's the parent body) sd_obj = {} body_obj = {} for object in bodies_list: if object != 'sun': sd_obj[object] = SphericalDifferential( perihelion[object], np.pi / 2 * u.rad, np.pi * u.rad, 0 * u.km / u.s, 0 * u.rad / u.s, omega[object]) body_obj[object] = Body(name=object, mass=mass[object], differential=sd_obj[object], parent=body_obj['sun']) elif object == 'sun': body_obj[object] = Body(name="sun", mass=mass[object], parent=None) elif object == 'moon': body_obj[object] = Body(name=object, mass=mass[object], differential=sd_obj[object], parent=body_obj['earth']) ''' Calculating Trajectory ''' # Set for a year (in seconds) end_lambda = { 'earth': ((1 * u.year).to(u.s)).value, 'moon': ((1 / 12 * u.year).to(u.s)).value } # Choosing stepsize for ODE solver to be 5 minutes stepsize = { 'earth': ((5 * u.min).to(u.s)).value, 'moon': ((5 / 12 * u.min).to(u.s)).value } ''' Trajectory to Cartesian ''' def get_schwarz(): schwarz_obj = {} schwarz_ans = {} for object in bodies_list: if object != 'sun': schwarz_obj[object] = Schwarzschild.from_coords( sd_obj[object], mass['sun']) schwarz_ans[object] = schwarz_obj[object].calculate_trajectory( end_lambda=end_lambda['earth'], OdeMethodKwargs={"stepsize": stepsize['earth']}, return_cartesian=True) return schwarz_obj, schwarz_ans ''' Calculating Distance ''' # # At Aphelion - r should be 152.1e6 km # r = np.sqrt(np.square(ans[1][:, 1]) + np.square(ans[1][:, 2])) # i = np.argmax(r) # print((r[i] * u.m).to(u.km)) # # speed should be 29.29 km/s # print(((ans[1][i][6]) * u.m / u.s).to(u.km / u.s)) # # eccentricity should be 0.0167 # xlist, ylist = ans[1][:, 1], ans[1][:, 2] # i = np.argmax(ylist) # x, y = xlist[i], ylist[i] # eccentricity = x / (np.sqrt(x ** 2 + y ** 2)) # print(eccentricity) ''' Animating ''' geodesic = {} plotter = {} for object in bodies_list: if object != 'sun': if object == 'moon': geodesic[object] = Geodesic(body=body_obj[object], time=0 * u.s, end_lambda=end_lambda['moon'], step_size=stepsize['moon']) geodesic[object] = Geodesic(body=body_obj[object], time=0 * u.s, end_lambda=end_lambda['earth'], step_size=stepsize['earth']) sgp = StaticGeodesicPlotter() sgp.animate( geodesic[planet], interval=5 ) # Objects currently limited to ['sun', 'mercury', 'venus', 'earth', 'moon'] sgp.show()
def test_Geodesics_has_trajectory(dummy_data): body, t, _, end_lambda, stepsize = dummy_data geo = Geodesic(body, time=t, end_lambda=end_lambda, step_size=stepsize) assert isinstance(geo.trajectory, np.ndarray)
def test_Geodesics_conserves_the_attractor(dummy_data): body, t, _, end_lambda, stepsize = dummy_data geo = Geodesic(body, time=t, end_lambda=end_lambda, step_size=stepsize) assert geo.attractor == body.parent
# ans = sph_obj.calculate_trajectory(end_lambda=end_tau, OdeMethodKwargs={"stepsize": step_size}, return_cartesian=True) ''' Bodies - Can define the attractor and the corresponding revolving bodies Plotting and geodesic calculation is easier ''' # defining some bodies: spin_factor = 0.3 * u.m attractor = Body(name='BH', mass=1.989e30 * u.kg, a=spin_factor) bl_obj = BoyerLindquistDifferential(50e5 * u.km, np.pi/2 * u.rad, np.pi * u.rad, 0 * u.km / u.s, 0 * u.rad / u.s, 0 * u.rad / u.s, spin_factor) particle = Body(differential=bl_obj, parent=attractor) geodesic = Geodesic(body=particle, end_lambda=((1 * u.year).to(u.s)).value / 930, step_size=((0.02 * u.min).to(u.s)).value, metric=Kerr) geodesic.trajectory # returns the trajectory values # Plotting the trajectory values obj = GeodesicPlotter() obj.plot(geodesic) obj.show() ''' Symbolic Calculations - Currently SchwarzschildMetric() cannot be called from package: einsteinpy.symbolic ''' # m = SchwarzschildMetric() # ch = ChristoffelSymbols.from_metric(m) # print(ch[1, 2, :])
import numpy as np import sympy from astropy import units as u ''' Variables ''' attractor = Body(name="BH", mass=6e24 * u.kg, parent=None) sph_obj = SphericalDifferential(130 * u.m, np.pi/2 * u.rad, -np.pi/8 * u.rad, 0 * u.m / u.s, 0 * u.rad / u.s, 1900 * u.rad / u.s) object = Body(differential=sph_obj, parent=attractor) geodesic = Geodesic(body=object, time=0 * u.s, end_lambda=0.002, step_size=5e-8) ''' Plotting Animation ''' obj = StaticGeodesicPlotter() obj.animate(geodesic, interval=10) obj.show()