def kerr_time_velocity(pos_vec, vel_vec, mass, a):
"""
Velocity of coordinate time wrt proper metric
Parameters
----------
pos_vector : ~numpy.array
Vector with r, theta, phi components in SI units
vel_vector : ~numpy.array
Vector with velocities of r, theta, phi components in SI units
mass : ~astropy.units.kg
Mass of the body
a : float
Any constant
Returns
-------
~astropy.units.one
Velocity of time
"""
_scr = utils.schwarzschild_radius(mass).value
g = metric(constant.c.value, pos_vec[0], pos_vec[1], _scr, a)
A = g[0, 0]
B = 2 * g[0, 3]
C = (g[1, 1] * (vel_vec[0]**2) + g[2, 2] * (vel_vec[1]**2) + g[3, 3] *
(vel_vec[2]**2) - 1)
D = (B**2) - (4 * A * C)
vt = (B + np.sqrt(D)) / (2 * A)
return vt * u.one
def _draw_attractor(self):
radius = schwarzschild_radius(self.mass)
if self.attractor_radius_scale == -1.0:
minrad_nooverlap = self.mindist(self.__xarr[0], self.__yarr[0])
for i in range(0, len(self.__xarr)):
minrad_nooverlap = min(
minrad_nooverlap,
self.mindist(self.__xarr[i], self.__yarr[i]))
xlen = max(self.__xarr) - min(self.__xarr)
ylen = max(self.__yarr) - min(self.__yarr)
minlen_plot = min(xlen, ylen)
mulitplier = minlen_plot / (12 * radius)
min_radius = radius * mulitplier
radius = min(min_radius, minrad_nooverlap)
self.get_curr_plot_radius = radius
self.ax.add_patch(
mpl.patches.Circle((0, 0),
radius,
lw=0,
color=self.attractor_color))
else:
radius = radius * self.attractor_radius_scale
self.get_curr_plot_radius = radius
self.ax.add_patch(
mpl.patches.Circle((0, 0),
radius.value,
lw=0,
color=self.attractor_color))
def test_calculate_trajectory(
pos_vec, vel_vec, time, M, a, start_lambda, end_lambda, OdeMethodKwargs
):
_scr = schwarzschild_radius(M).value
obj = Kerr.from_BL(pos_vec, vel_vec, time, M, a)
ans = obj.calculate_trajectory(
start_lambda=start_lambda,
end_lambda=end_lambda,
OdeMethodKwargs=OdeMethodKwargs,
)
ans = ans[1]
testarray = list()
for ansi in ans:
g = kerr_utils.metric(_c, ansi[1], ansi[2], _scr, a)
tmp = (
g[0][0] * (ansi[4] ** 2)
+ g[1][1] * (ansi[5] ** 2)
+ g[2][2] * (ansi[6] ** 2)
+ g[3][3] * (ansi[7] ** 2)
+ 2 * g[0][3] * ansi[4] * ansi[7]
)
testarray.append(tmp)
testarray = np.array(testarray, dtype=float)
comparearray = np.ones(shape=ans[:, 4].shape, dtype=float)
assert_allclose(testarray, comparearray, 1e-4)
def test_radius_ergosphere_for_nonrotating_case():
M = 5e27
a = 0.0
_scr = utils.schwarzschild_radius(M * u.kg).value
a1 = kerr_utils.radius_ergosphere(_scr, a, np.pi / 5)
a2 = kerr_utils.radius_ergosphere(_scr, a, np.pi / 5, "Spherical")
assert_allclose(a1, a2, rtol=0.0, atol=1e-5)
assert_allclose(a1[0], _scr, rtol=0.0, atol=1e-5)
def test_event_horizon_for_nonrotating_case():
M = 5e27
a = 0.0
_scr = utils.schwarzschild_radius(M * u.kg).value
a1 = kerr_utils.event_horizon(_scr, a, np.pi / 4)
a2 = kerr_utils.event_horizon(_scr, a, np.pi / 4, "Spherical")
assert_allclose(a1, a2, rtol=0.0, atol=1e-5)
assert_allclose(a1[0], _scr, rtol=0.0, atol=1e-5)
def __init__(self, pos_vec, vel_vec, time, M):
self.M = M
self.pos_vec = pos_vec
self.vel_vec = vel_vec
self.time = time
self.time_vel = time_velocity(pos_vec, vel_vec, M)
self.initial_vec = np.hstack(
(self.time.value, self.pos_vec, self.time_vel.value, self.vel_vec))
self.schwarzschild_r = schwarzschild_radius(M)
def __init__(self, sph_coords, M, time):
self.M = M
self.input_coords = sph_coords
self.time = time
pos_vec, vel_vec = (
self.input_coords.si_values()[:3],
self.input_coords.si_values()[3:],
)
time_vel = schwarzschild_utils.time_velocity(pos_vec, vel_vec, M)
self.initial_vec = np.hstack(
(self.time.value, pos_vec, time_vel.value, vel_vec))
self.scr = schwarzschild_radius(M)
def __init__(self, pos_vec, vel_vec, q, time, M, a, Q):
self.M = M
self.a = a
self.Q = Q
self.q = q
self.pos_vec = pos_vec
self.vel_vec = vel_vec
self.time = time
self.time_vel = kerrnewman_utils.kerrnewman_time_velocity(
self.pos_vec, self.vel_vec, self.M, self.a, Q)
self.initial_vec = np.hstack(
(self.time.value, self.pos_vec, self.time_vel.value, self.vel_vec))
self.schwarzschild_r = schwarzschild_radius(M)
def __init__(self, bl_coords, M, time):
self.input_coords = bl_coords
self.M = M
self.a = self.input_coords.a.to(u.m)
self.time = time
pos_vec, vel_vec = (
self.input_coords.si_values()[:3],
self.input_coords.si_values()[3:],
)
time_vel = kerr_utils.kerr_time_velocity(pos_vec, vel_vec, self.M,
self.a.value)
self.initial_vec = np.hstack(
(self.time.value, pos_vec, time_vel.value, vel_vec))
self.scr = schwarzschild_radius(M)
def __init__(self, bl_coords, q, M, Q, time):
self.input_coords = bl_coords
self.name = "KerrNewman"
self.M = M
self.a = self.input_coords.a.to(u.m)
self.Q = Q
self.q = q
pos_vec, vel_vec = (
self.input_coords.si_values()[:3],
self.input_coords.si_values()[3:],
)
self.time = time
time_vel = kerrnewman_utils.kerrnewman_time_velocity(
pos_vec, vel_vec, self.M, self.a.value, Q)
self.initial_vec = np.hstack(
(self.time.value, pos_vec, time_vel.value, vel_vec))
self.scr = schwarzschild_radius(M)
def test_calculate_trajectory(pos_vec, vel_vec, time, M, start_lambda,
end_lambda, OdeMethodKwargs):
cl = Schwarzschild.from_spherical(pos_vec, vel_vec, time, M)
ans = cl.calculate_trajectory(
start_lambda=start_lambda,
end_lambda=end_lambda,
OdeMethodKwargs=OdeMethodKwargs,
)
_c, _scr = constant.c.value, schwarzschild_radius(M).value
ans = ans[1]
testarray = list()
for i in ans:
g = schwarzschild_utils.metric(_c, i[1], i[2], _scr)
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))
testarray = np.array(testarray, dtype=float)
comparearray = np.ones(shape=ans[:, 4].shape, dtype=float)
assert_allclose(testarray, comparearray, 1e-4)
def test_calculate_trajectory(
pos_vec, vel_vec, time, M, start_lambda, end_lambda, OdeMethodKwargs
):
cl = Schwarzschild.from_spherical(pos_vec, vel_vec, time, M)
ans = cl.calculate_trajectory(
start_lambda=start_lambda,
end_lambda=end_lambda,
OdeMethodKwargs=OdeMethodKwargs,
)
_c, _scr = constant.c.value, schwarzschild_radius(M).value
ans = ans[1]
testarray = (
(1 - (_scr / ans[:, 1])) * np.square(ans[:, 4])
- (np.square(ans[:, 5])) / ((1 - (_scr / ans[:, 1])) * (_c ** 2))
- np.square(ans[:, 1] / _c)
* (np.square(ans[:, 6]) + np.square(np.sin(ans[:, 2])) * np.square(ans[:, 7]))
)
comparearray = np.ones(shape=ans[:, 4].shape, dtype=float)
assert_allclose(testarray, comparearray, 1e-4)
def test_scaled_spin_factor():
a = 0.8
M = 5e24 * u.kg
a1 = kerr_utils.scaled_spin_factor(a, M.value)
a2 = utils.schwarzschild_radius(M).value * a * 0.5
assert_allclose(a2, a1, rtol=1e-9)
get_ipython().system('ls')
# In[ ]:
# In[ ]:
import numpy as np
import astropy.units as u
import matplotlib.pyplot as plt
from einsteinpy.utils import kerr_utils, schwarzschild_radius
from einsteinpy.utils import bl_coord_transforms
# In[ ]:
M = 4e30
scr = schwarzschild_radius(M * u.kg).value
# for nearly maximally rotating black hole
a1 = 0.499999 * scr
# for ordinary black hole
a2 = 0.3 * scr
# In[ ]:
ergo1, ergo2, hori1, hori2 = list(), list(), list(), list()
thetas = np.linspace(0, np.pi, 720)
for t in thetas:
ergo1.append(kerr_utils.radius_ergosphere(M, a1, t, "Spherical"))
ergo2.append(kerr_utils.radius_ergosphere(M, a2, t, "Spherical"))
hori1.append(kerr_utils.event_horizon(M, a1, t, "Spherical"))
hori2.append(kerr_utils.event_horizon(M, a2, t, "Spherical"))
ergo1, ergo2, hori1, hori2 = np.array(ergo1), np.array(ergo2), np.array(
def _draw_attractor(self, min_radius=10 * u.km):
radius = max(schwarzschild_radius(self.mass) * 10000, min_radius.to(u.km))
color = "#ffcc00"
self.ax.add_patch(mpl.patches.Circle((0, 0), radius.value, lw=0, color=color))
'''
REF : https://docs.einsteinpy.org/en/stable/
'''
import numpy as np
import sympy
from astropy import units as u
import matplotlib.pyplot as plt
from einsteinpy.utils import kerr_utils, schwarzschild_radius
'''
Variables
'''
M = 4e30
scr = schwarzschild_radius(M * u.kg).value # calculates radius based on M
# for a near maximally rotating BH
a1 = 0.499999 * scr
# for an ordinary BH
a2 = 0.3 * scr
'''
Calculating Ergosphere and Event Horizon (spherical coords)
'''
ergo1, ergo2, hori1, hori2 = list(), list(), list(), list()
thetas = np.linspace(0, np.pi, 720)
for angle in thetas:
ergo1.append(kerr_utils.radius_ergosphere(M, a1, angle, "Spherical"))
ergo2.append(kerr_utils.radius_ergosphere(M, a2, angle, "Spherical"))
hori1.append(kerr_utils.event_horizon(M, a1, angle, "Spherical"))
hori2.append(kerr_utils.event_horizon(M, a2, angle, "Spherical"))
