Ver3.5 ๐ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ์ ๋ฌผ๋ฆฌ ๋ชจ๋ธ ์์ ํด๋ถ์ฝ๋๋ก ์ฐ์ฃผ๋ฅผ ๊ตฌํํ๋ ๊ฐ๋ฐ์์ ๋ธ๋ํ ํํ๊ธฐ

๐ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ์ ๋ฌผ๋ฆฌ ๋ชจ๋ธ ์์ ํด๋ถ
์ฝ๋๋ก ์ฐ์ฃผ๋ฅผ ๊ตฌํํ๋ ๊ฐ๋ฐ์์ ๋ธ๋ํ ํํ๊ธฐ
์ผ๋ฐ์๋์ฑ์ด๋ก ๋ถํฐ ๊ด์ ์ถ์ ๊น์ง โ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ ๋ค์ ์จ๊ฒจ์ง ์ง์ง ๋ฌผ๋ฆฌํ๊ณผ ์๊ณ ๋ฆฌ์ฆ
์ผ, ์์งํ ๋งํด๋ด. ๐ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ ์์ ๋ณด๋ฉด์ "์ด๊ฑฐ ์ด๋ป๊ฒ ๋ง๋ ๊ฑฐ์ง?" ํ ๋ฒ์ฏค ๊ถ๊ธํ์ง ์์์ด? ์ํ ์ธํฐ์คํ ๋ผ์์ ๊ฐ๋ฅด๊ฐํ์(Gargantua) ๋ธ๋ํ ์ฅ๋ฉด ๋์์ ๋ ์ ์ธ๊ณ ๋ฌผ๋ฆฌํ์๋ค์ด๋ ๊ฐ๋ฐ์๋ค์ด ๋์์ ์ ๋ฒ๋ ธ์์. ๊ทธ ์ฅ๋ฉด ํ๋ ๋ง๋๋ ๋ฐ ์ค์ ๋ก ๋ ธ๋ฒจ์๊ธ ๋ฌผ๋ฆฌ ๋ฐฉ์ ์์ด ๋ค์ด๊ฐ๊ฑฐ๋ .
์ค๋์ ๊ทธ ๋น๋ฐ์ ์์ ํ ๊น๋ฐ๋ ค๋ณผ ๊ฑฐ์ผ. ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ๊ฐ ์ด๋ค ๋ฌผ๋ฆฌ ๋ชจ๋ธ์ ์ฐ๋์ง, ์์์ ์ด๋ป๊ฒ ์๊ฒผ๋์ง, ์ค์ ์ฝ๋๋ก ์ด๋ป๊ฒ ๊ตฌํํ๋์ง โ ์น๊ตฌํํ ์ค๋ช ํ๋ฏ์ด ์ญ ํ์ด๋ณผ๊ฒ. ๋ฌผ๋ฆฌ ์ ๊ณต์๊ฐ ์๋์ด๋ ๊ด์ฐฎ์. ๊ฐ๋ฐ์ ๋ง์ธ๋๋ก ์ ๊ทผํ๋ฉด ์ถฉ๋ถํ ์ดํดํ ์ ์์ด! ๐ช
โก ์ผ๋ฐ์๋์ฑ์ด๋ก ์ ์ธก์ง์ ๋ฐฉ์ ์ (๊ฒ๋จน์ง ๋ง!)
โข ๊ด์ ์ถ์ (Ray Tracing) ์๊ณ ๋ฆฌ์ฆ์ ํต์ฌ
โฃ ์ค๋ ฅ ๋ ์ฆ ํจ๊ณผ ๊ตฌํ ๋ฐฉ๋ฒ
โค ๊ฐ์ฐฉ์๋ฐ(Accretion Disk) ์๊ฐํ ๋ฌผ๋ฆฌ ๋ชจ๋ธ
โฅ ์ค์ ์๋ฎฌ๋ ์ดํฐ ์ฝ๋ ๊ตฌ์กฐ์ ์ต์ ํ ํ
๐ญ 1. ๋ธ๋ํ์ ๊ธฐ๋ณธ ๋ฌผ๋ฆฌ โ ์๋ฎฌ๋ ์ดํฐ์ ์ถ๋ฐ์
๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ๋ฅผ ๋ง๋ค๋ ค๋ฉด ์ ์ผ ๋จผ์ "๋ธ๋ํ์ด ์ํ์ ์ผ๋ก ์ด๋ป๊ฒ ์๊ฒผ๋"๋ฅผ ์์์ผ ํด. ์ฌ๊ธฐ์ ๋ฑ์ฅํ๋ ๊ฒ ๋ฐ๋ก ์๋ฐ๋ฅด์ธ ์คํธ ํด(Schwarzschild Solution)์ผ.
๐ ์๋ฐ๋ฅด์ธ ์คํธ ๋ฐ์ง๋ฆ (Rs)
1916๋ ์นด๋ฅผ ์๋ฐ๋ฅด์ธ ์คํธ๊ฐ ์์ธ์ํ์ธ์ ์ฅ ๋ฐฉ์ ์์ ํ์ด์ ๊ตฌํ ํด์ผ. ์ง๋ M์ธ ์ฒ์ฒด๊ฐ ๋ธ๋ํ์ด ๋๋ ค๋ฉด ๋ฐ์ง๋ฆ์ด ์ผ๋ง ์ดํ๋ก ์์ถ๋์ด์ผ ํ๋์ง๋ฅผ ์๋ ค์ค.
G = 6.674 ร 10โปยนยน mยณ/(kgยทsยฒ) [์ค๋ ฅ ์์] c = 3 ร 10โธ m/s [๋น์ ์๋] M = ๋ธ๋ํ์ ์ง๋ (kg)
ํ์ ์ง๋(์ฝ 2ร10ยณโฐ kg)์ผ๋ก ๊ณ์ฐํ๋ฉด Rs โ 3km์ผ. ํ์์ ๋ฐ์ง๋ฆ 3km์ง๋ฆฌ ๊ณต์ผ๋ก ์์ถํ๋ฉด ๋ธ๋ํ์ด ๋๋ค๋ ๋ป! ๐คฏ ์๋ฎฌ๋ ์ดํฐ์์๋ ์ด Rs ๊ฐ์ด ๋ชจ๋ ๋ฌผ๋ฆฌ ๊ณ์ฐ์ ๊ธฐ์ค ๋จ์๊ฐ ๋ผ.
๐ ์๋ฐ๋ฅด์ธ ์คํธ ๊ณ๋ ํ ์ (Metric Tensor)
๋ธ๋ํ ์ฃผ๋ณ์ ์๊ณต๊ฐ์ด ์ด๋ป๊ฒ ํ์ด์๋์ง๋ฅผ ํํํ๋ ๊ฒ ๊ณ๋ ํ ์(metric tensor)์ผ. ์๋ฐ๋ฅด์ธ ์คํธ ๋ธ๋ํ(ํ์ ์๋ ๋ธ๋ํ)์ ์๊ณต๊ฐ ๊ฐ๊ฒฉ์ ์ด๋ ๊ฒ ์จ:
dฮฉยฒ = dฮธยฒ + sinยฒฮธ dฯยฒ [๊ตฌ๋ฉด ๊ฐ๋ ์ฑ๋ถ]
์ด๊ฒ ๋ญ ์๋ฆฌ๋๊ณ ? ์ฝ๊ฒ ๋งํ๋ฉด "๋ธ๋ํ ๊ทผ์ฒ์์๋ ์๊ฐ์ด ๋๋ ค์ง๊ณ , ๊ณต๊ฐ์ด ๋์ด๋๋ค"๋ ๊ฑธ ์์์ผ๋ก ํํํ ๊ฑฐ์ผ. r์ด Rs์ ๊ฐ๊น์์ง์๋ก (1-Rs/r) ํญ์ด 0์ ๊ฐ๊น์์ง๋ฉด์ ์๊ฐ์ด ๋ฌดํํ ๋๋ ค์ง๋ ๊ฑฐ ๋ณด์ด์ง? ์ด๊ฒ ๋ฐ๋ก ์๋ฎฌ๋ ์ดํฐ์์ ์ค๋ ฅ ์ ์ํธ์ด(Gravitational Redshift)๋ฅผ ๊ตฌํํ ๋ ์ฐ๋ ํต์ฌ ๊ณต์์ด์ผ.
๐ช๏ธ ์ปค ๊ณ๋ (Kerr Metric) โ ํ์ ํ๋ ๋ธ๋ํ
์ค์ ๋ธ๋ํ์ ๊ฑฐ์ ๋ค ํ์ ํด. ์ธํฐ์คํ ๋ผ์ ๊ฐ๋ฅด๊ฐํ์๋ ์์ฒญ๋๊ฒ ๋น ๋ฅด๊ฒ ํ์ ํ๋ ์ปค ๋ธ๋ํ(Kerr Black Hole)์ด์ผ. ์ปค ๊ณ๋์ ์๋ฐ๋ฅด์ธ ์คํธ๋ณด๋ค ํจ์ฌ ๋ณต์กํด:
ฯยฒ = rยฒ + aยฒcosยฒฮธ ฮ = rยฒ - rRs + aยฒ a = J/(Mc) [๋น๊ฐ์ด๋๋, ์คํ ํ๋ผ๋ฏธํฐ]
์ฌ๊ธฐ์ a๊ฐ ๋ธ๋ํ์ ์คํ์ ๋ํ๋ด. a=0์ด๋ฉด ์๋ฐ๋ฅด์ธ ์คํธ, a=M์ด๋ฉด ์ต๋ ์คํ ์ปค ๋ธ๋ํ์ด์ผ. ์ dtdฯ ๊ต์ฐจํญ์ด ๋ฐ๋ก ์ขํ๊ณ ๋๋ฆผ(Frame Dragging) ํจ๊ณผ๋ฅผ ๋ง๋ค์ด๋ด๋ ๊ฑฐ์ผ โ ๋ธ๋ํ์ด ์ฃผ๋ณ ์๊ณต๊ฐ์ ๊ฐ์ด ๋๊ณ ๋์๊ฐ๋ ํ์!
๐ก 2. ์ธก์ง์ ๋ฐฉ์ ์ โ ๋น์ด ๊ฐ๋ ๊ธธ์ ๊ณ์ฐํ๋ค
๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ์ ํต์ฌ์ "๋น์ด ๋ธ๋ํ ์ฃผ๋ณ์์ ์ด๋ป๊ฒ ํ์ด๊ฐ๋๊ฐ"๋ฅผ ๊ณ์ฐํ๋ ๊ฑฐ์ผ. ์ผ๋ฐ์๋์ฑ์ด๋ก ์์ ๋น์ ์ธก์ง์ (Geodesic)์ ๋ฐ๋ผ ์ด๋ํด โ ํ์ด์ง ์๊ณต๊ฐ์์์ "์ต๋จ ๊ฒฝ๋ก"์ผ.
โก ์ธก์ง์ ๋ฐฉ์ ์ (Geodesic Equation)
ฮแต_ฮฑฮฒ : ํฌ๋ฆฌ์คํ ํ ๊ธฐํธ (Christoffel Symbol) ฮป : ์ํ ๋งค๊ฐ๋ณ์ (๋น์ ๊ฒฝ์ฐ ๊ณ ์ ์๊ฐ ๋์ ์ฌ์ฉ) xแต : ์๊ณต๊ฐ ์ขํ (t, r, ฮธ, ฯ)
๋ฌด์์ ๋ณด์ด์ง๋ง ์ฌ์ค ์ด๊ฑด "๊ฐ์๋ = ์๊ณต๊ฐ ๊ณก๋ฅ ร ์๋ยฒ" ํํ์ผ. ํฌ๋ฆฌ์คํ ํ ๊ธฐํธ ฮ๊ฐ ์๊ณต๊ฐ์ด ์ผ๋ง๋ ํ์ด์๋์ง๋ฅผ ๋ํ๋ด๊ณ , ๊ทธ๊ฒ ๋น์ ๊ฒฝ๋ก๋ฅผ ๋ฐ๊พธ๋ ๊ฑฐ์ผ.
๐ข ์๋ฐ๋ฅด์ธ ์คํธ ์๊ณต๊ฐ์์์ ๋น ๊ฒฝ๋ก ๋ฐฉ์ ์
์๋ฐ๋ฅด์ธ ์คํธ ๋ธ๋ํ์์ ๋น์ ๊ฒฝ๋ก๋ ๋์นญ์ฑ ๋๋ถ์ ํจ์ฌ ๋จ์ํด์ ธ. ์ ๋๋ฉด(ฮธ=ฯ/2)์์์ ๋น ๊ฒฝ๋ก๋ ์ด๋ ๊ฒ ํํ๋ผ:
dฯ/dฮป = L/rยฒ dt/dฮป = E/(1 - Rs/r)
E : ์๋์ง ๋ณด์กด๋ (๋จ์ ์ง๋๋น) L : ๊ฐ์ด๋๋ ๋ณด์กด๋ (๋จ์ ์ง๋๋น) b = L/E : ์ถฉ๊ฒฉ ๋งค๊ฐ๋ณ์ (Impact Parameter)
์ฌ๊ธฐ์ ์ถฉ๊ฒฉ ๋งค๊ฐ๋ณ์ b๊ฐ ์์ฒญ ์ค์ํด. b๊ฐ ์๊ณ๊ฐ b_c = 3โ3/2 ร Rs ๋ณด๋ค ์์ผ๋ฉด ๋น์ด ๋ธ๋ํ๋ก ๋นจ๋ ค๋ค์ด๊ฐ๊ณ , ํฌ๋ฉด ํ์ด์ ํ์ถํด. ์ด ์๊ณ๊ฐ์ด ๋ฐ๋ก ๊ด์๊ตฌ(Photon Sphere)๋ฅผ ๊ฒฐ์ ํ๋ ๊ฑฐ์ผ!
b = b_c โ ๊ด์๊ตฌ์์ ์์ํ ๊ณต์ (๋ถ์์ ๊ถค๋) ๐
b > b_c โ ํ์ด์ ํ์ถ (์ค๋ ฅ ๋ ์ฆ ํจ๊ณผ) ๐
๐งฎ ์์น ์ ๋ถ โ ์ค์ ์ฝ๋์์ ์ด๋ป๊ฒ ๊ณ์ฐํ๋?
์ธก์ง์ ๋ฐฉ์ ์์ ํด์์ ์ผ๋ก ํ๊ธฐ ์ด๋ ค์ด ๊ฒฝ์ฐ(ํนํ ์ปค ๋ธ๋ํ)์๋ ์์น ์ ๋ถ(Numerical Integration)์ ์จ. ๊ฐ์ฅ ๋ง์ด ์ฐ๋ ๋ฐฉ๋ฒ์ด ๋ฃฝ๊ฒ-์ฟ ํ 4์ฐจ ๋ฐฉ๋ฒ(RK4)์ด์ผ:
# Python ์คํ์ผ ์์ฌ์ฝ๋ โ RK4๋ก ์ธก์ง์ ๊ณ์ฐ
def geodesic_rk4(state, dlambda, metric_params):
"""
state = [t, r, theta, phi, dt/dl, dr/dl, dtheta/dl, dphi/dl]
"""
k1 = geodesic_derivatives(state, metric_params)
k2 = geodesic_derivatives(state + 0.5*dlambda*k1, metric_params)
k3 = geodesic_derivatives(state + 0.5*dlambda*k2, metric_params)
k4 = geodesic_derivatives(state + dlambda*k3, metric_params)
return state + (dlambda/6.0) * (k1 + 2*k2 + 2*k3 + k4)
def geodesic_derivatives(state, params):
r, theta = state[1], state[2]
Rs = params['schwarzschild_radius']
# ํฌ๋ฆฌ์คํ ํ ๊ธฐํธ ๊ณ์ฐ
Gamma = compute_christoffel(r, theta, Rs)
# dยฒxแต/dฮปยฒ = -ฮแต_ฮฑฮฒ (dxแต
/dฮป)(dx^ฮฒ/dฮป)
acceleration = -sum_christoffel_terms(Gamma, state[4:])
return concatenate(state[4:], acceleration)
๐จ 3. ๊ด์ ์ถ์ (Ray Tracing) โ ํฝ์ ํ๋ํ๋๊ฐ ๋ฌผ๋ฆฌ ๊ณ์ฐ
๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ์ ๋ ๋๋ง ํต์ฌ์ ์ญ๋ฐฉํฅ ๊ด์ ์ถ์ (Backward Ray Tracing)์ด์ผ. ์ "์ญ๋ฐฉํฅ"์ด๋๊ณ ? ๊ด์์์ ์นด๋ฉ๋ผ๋ก ์ค๋ ๋น์ ์ถ์ ํ๋ฉด ๋๋ถ๋ถ์ ๊ด์ ์ด ์นด๋ฉ๋ผ์ ์ ๋ฟ์์ ๋นํจ์จ์ ์ด๊ฑฐ๋ . ๊ทธ๋์ ์นด๋ฉ๋ผ ํฝ์ ์์ ๊ด์ ์ ์ด์ ์ด๋์ ์๋์ง ์ญ์ถ์ ํ๋ ๊ฑฐ์ผ!
๐ฅ๏ธ ๋ ๋๋ง ํ์ดํ๋ผ์ธ
ํ๋ฉด์ ๊ฐ ํฝ์ ์ขํ๋ฅผ ์นด๋ฉ๋ผ ์์ผ๊ฐ(FOV)์ ๋ง์ถฐ 3D ๋ฐฉํฅ ๋ฒกํฐ๋ก ๋ณํ. ์ด๋ ์นด๋ฉ๋ผ์ ์์น์ ๋ธ๋ํ๊น์ง์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ ๋ คํด์ ์ด๊ธฐ ์กฐ๊ฑด ์ค์ .
๊ฐ ๊ด์ ์ ๋ํด RK4 ๋ฑ์ ๋ฐฉ๋ฒ์ผ๋ก ์ธก์ง์ ๋ฐฉ์ ์์ ์ ๋ถ. ๊ด์ ์ด ๋ธ๋ํ์ ํฌํ๋๊ฑฐ๋, ์ถฉ๋ถํ ๋ฉ๋ฆฌ ํ์ถํ๊ฑฐ๋, ๊ฐ์ฐฉ์๋ฐ์ ๋ฟ์ ๋๊น์ง ๋ฐ๋ณต.
r < Rs โ ๋ธ๋ํ ํฌํ (๊ฒ์ ํฝ์ )
r > r_max โ ๋ฐฐ๊ฒฝ ํ๋ ์ํ๋ง
๊ฐ์ฐฉ์๋ฐ ๊ต์ฐจ โ ์๋ฐ ์์ ๊ณ์ฐ
๋ํ๋ฌ ํธ์ด, ์ค๋ ฅ ์ ์ํธ์ด, ๋น ์ง์ค(Beaming) ํจ๊ณผ๋ฅผ ์ ์ฉํด์ ์ต์ข ํฝ์ ์์ ๊ฒฐ์ .
HDR ํค ๋งคํ, ๊ธ๋ก์ฐ ํจ๊ณผ, ์์์ฐจ ๋ฑ์ ์ ์ฉํด์ ์ต์ข ์ด๋ฏธ์ง ์์ฑ.
โ๏ธ ์ค์ ๊ตฌํ ์ฝ๋ ๊ตฌ์กฐ
# ๋ธ๋ํ ๊ด์ ์ถ์ ๊ธฐ ํต์ฌ ๊ตฌ์กฐ (Python/NumPy ์คํ์ผ)
class BlackHoleRayTracer:
def __init__(self, mass, spin=0.0, camera_distance=50.0):
self.Rs = 2 * mass # ์๋ฐ๋ฅด์ธ ์คํธ ๋ฐ์ง๋ฆ (์์ฐ๋จ์)
self.a = spin # ์คํ ํ๋ผ๋ฏธํฐ (0 ~ mass)
self.cam_r = camera_distance
def render_pixel(self, pixel_x, pixel_y, image_width, image_height):
# 1. ํฝ์
โ ๊ด์ ์ด๊ธฐ ์กฐ๊ฑด
ray = self.pixel_to_ray(pixel_x, pixel_y, image_width, image_height)
# 2. ์ธก์ง์ ์ถ์
result = self.trace_geodesic(ray)
# 3. ์์ ๊ฒฐ์
color = self.compute_color(result)
return color
def trace_geodesic(self, ray_state, max_steps=10000):
state = ray_state.copy()
dlambda = -0.1 # ์ญ๋ฐฉํฅ ์ถ์ (์์)
for step in range(max_steps):
r = state[1]
# ์ข
๋ฃ ์กฐ๊ฑด ์ฒดํฌ
if r < 1.05 * self.Rs:
return {'type': 'captured', 'state': state}
if r > 500 * self.Rs:
return {'type': 'escaped', 'state': state}
if self.hits_accretion_disk(state):
return {'type': 'disk', 'state': state}
# ์ ์ํ ์คํ
ํฌ๊ธฐ (๋ธ๋ํ ๊ทผ์ฒ์์ ๋ ์๊ฒ)
dlambda = self.adaptive_step(r, dlambda)
# RK4 ์ ๋ถ
state = self.rk4_step(state, dlambda)
return {'type': 'max_steps', 'state': state}
def adaptive_step(self, r, dlambda_base):
# ๋ธ๋ํ์ ๊ฐ๊น์ธ์๋ก ์คํ
ํฌ๊ธฐ ์ค์
proximity = r / self.Rs
return dlambda_base * min(1.0, (proximity - 1.0) / 5.0)
๐ฎ 4. ์ค๋ ฅ ๋ ์ฆ ํจ๊ณผ โ ๋น์ด ํ์ด์ง๋ ๋ง๋ฒ
๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ์์ ๊ฐ์ฅ ์๊ฐ์ ์ผ๋ก ์ํฉํธ ์๋ ๋ถ๋ถ์ด ๋ฐ๋ก ์ค๋ ฅ ๋ ์ฆ(Gravitational Lensing)์ผ. ๋ธ๋ํ ๋ค์ ์๋ ๋ณ์ด ๋ธ๋ํ ์ฃผ๋ณ์ ๋ง ํํ๋ก ๋ณด์ด๋ ํ์ โ ์ด๊ฒ ์์ธ์ํ์ธ ๋ง(Einstein Ring)์ด์ผ!
๐ซ ์์ธ์ํ์ธ ๋ง ๋ฐ์ง๋ฆ
D_L : ๊ด์ธก์ โ ๋ ์ฆ(๋ธ๋ํ) ๊ฑฐ๋ฆฌ D_S : ๊ด์ธก์ โ ๊ด์(๋ณ) ๊ฑฐ๋ฆฌ D_LS : ๋ ์ฆ(๋ธ๋ํ) โ ๊ด์(๋ณ) ๊ฑฐ๋ฆฌ
์ด ๊ณต์์ ์ฝํ ์ค๋ ฅ ๋ ์ฆ ๊ทผ์ฌ์ผ. ๋ธ๋ํ์ฒ๋ผ ๊ฐํ ์ค๋ ฅ์ฅ์์๋ ๊ฐํ ์ค๋ ฅ ๋ ์ฆ(Strong Gravitational Lensing) ํจ๊ณผ๋ฅผ ์จ์ผ ํด. ์ด๋๋ ๋น์ด ๋ธ๋ํ์ ์ฌ๋ฌ ๋ฐํด ๋๊ณ ๋์ค๋ ๊ณ ์ฐจ ์ด๋ฏธ์ง(Higher-order Images)๋ ์๊ฒจ!
๐ ๋ํ๋ฌ ํจ๊ณผ์ ๋น ์ง์ค (Relativistic Beaming)
๊ฐ์ฐฉ์๋ฐ์ด ํ์ ํ๋ฉด์ ๊ด์ธก์ ์ชฝ์ผ๋ก ๋ค๊ฐ์ค๋ ๋ถ๋ถ์ ๋ฐ์์ง๊ณ (์ฒญ์ํธ์ด), ๋ฉ์ด์ง๋ ๋ถ๋ถ์ ์ด๋์์ ธ(์ ์ํธ์ด). ์ด๊ฒ ์๋๋ก ์ ๋ํ๋ฌ ํจ๊ณผ์ผ. ์๋ฎฌ๋ ์ดํฐ์์ ์ด๊ฑธ ๊ตฌํํ๋ ๊ณต์:
์ ์ํธ์ด ์ธ์: 1 + z = (g_tt + 2g_tฯ ฮฉ + g_ฯฯ ฮฉยฒ)^(1/2) / (1 + bยทฮฉ)
ฮฉ : ์๋ฐ์ ๊ฐ์๋ b : ์ถฉ๊ฒฉ ๋งค๊ฐ๋ณ์
๊ทธ๋ฆฌ๊ณ ๋น ์ง์ค(Beaming) ํจ๊ณผ๋ก ์ธํด ๊ด์ธก๋๋ ๋ฐ๊ธฐ๋:
์ด 4์ ๊ณฑ ์ธ์๊ฐ ์์ฒญ ์ค์ํด! ๊ฐ์ฐฉ์๋ฐ์์ ๊ด์ธก์ ์ชฝ์ผ๋ก ์ค๋ ๋ถ๋ถ์ด ๋ฐ๋์ชฝ๋ณด๋ค ํจ์ฌ ๋ฐ๊ฒ ๋ณด์ด๋ ์ด์ ๊ฐ ๋ฐ๋ก ์ด๊ฑฐ์ผ. ์ธํฐ์คํ ๋ผ์์ ๊ฐ์ฐฉ์๋ฐ์ด ๋น๋์นญ์ ์ผ๋ก ๋ฐ๊ฒ ๋ณด์ด๋ ๊ฒ๋ ์ด ํจ๊ณผ ๋๋ฌธ์ด์ผ! ๐
๐ฅ 5. ๊ฐ์ฐฉ์๋ฐ ๋ฌผ๋ฆฌ ๋ชจ๋ธ โ ๋ธ๋ํ์ ๋น๋๋ ๊ณ ๋ฆฌ
๋ธ๋ํ ์์ฒด๋ ๊ฒ์ ์ด์ง๋ง, ์ฃผ๋ณ์ ๊ฐ์ฐฉ์๋ฐ(Accretion Disk)์ด ์์ฒญ๋ ๋น์ ๋ด. ๋ฌผ์ง์ด ๋ธ๋ํ๋ก ๋จ์ด์ง๋ฉด์ ๋ง์ฐฐ๋ก ๊ฐ์ด๋์ด ์๋ฐฑ๋ง ๋๊น์ง ์ฌ๋ผ๊ฐ๊ฑฐ๋ . ์ด๊ฑธ ์๋ฎฌ๋ ์ดํฐ์์ ์ด๋ป๊ฒ ํํํ๋๊ณ ?
๐ก๏ธ ์๋ฐ ์จ๋ ๋ถํฌ ๋ชจ๋ธ
๊ฐ์ฅ ๋ง์ด ์ฐ๋ ๋ชจ๋ธ์ด ๋ ธ๋น์ฝํ-์ ๋ชจ๋ธ(Novikov-Thorne Model)์ด์ผ. ์๋ฐ์ ๊ฐ ๋ฐ์ง๋ฆ์์์ ์จ๋๋ฅผ ์ด๋ ๊ฒ ๊ณ์ฐํด:
f(r) = 1 - โ(r_ISCO/r) [๊ฒฝ๊ณ ์กฐ๊ฑด ํจ์] r_ISCO : ์ต๋ด๊ฐ ์์ ์ํ ๊ถค๋ ๋ฐ์ง๋ฆ = 6GM/cยฒ (์๋ฐ๋ฅด์ธ ์คํธ ๋ธ๋ํ) = 1.24GM/cยฒ (์ต๋ ์คํ ์ปค ๋ธ๋ํ)
ISCO(Innermost Stable Circular Orbit)๋ ์๋ฐ์ ๋ด๋ถ ๊ฒฝ๊ณ์ผ. ์ด ์์ชฝ์ผ๋ก๋ ์์ ์ ์ธ ์ํ ๊ถค๋๊ฐ ์์ด์ ๋ฌผ์ง์ด ๋ธ๋ํ๋ก ๋น ๋ฅด๊ฒ ๋จ์ด์ ธ. ์๋ฐ๋ฅด์ธ ์คํธ ๋ธ๋ํ์์๋ Rs์ 3๋ฐฐ, ์ต๋ ์คํ ์ปค ๋ธ๋ํ์์๋ Rs์ ์ฝ 0.62๋ฐฐ์ผ.
๐จ ํ์ฒด ๋ณต์ฌ โ ํฝ์ ์์ ๋ณํ
์จ๋๋ฅผ ์๋ฉด ํ๋ํฌ ํ์ฒด ๋ณต์ฌ ๋ฒ์น์ผ๋ก ์คํํธ๋ผ์ ๊ณ์ฐํ๊ณ , ์ด๊ฑธ RGB ์์์ผ๋ก ๋ณํํด:
def temperature_to_rgb(T_kelvin):
"""
ํ์ฒด ๋ณต์ฌ ์จ๋๋ฅผ RGB ์์์ผ๋ก ๋ณํ
(CIE ์ ์ผ์น ํจ์ ์ฌ์ฉ)
"""
# ํ๋ํฌ ํจ์๋ก ์คํํธ๋ผ ๊ณ์ฐ
wavelengths = np.linspace(380e-9, 780e-9, 400) # ๊ฐ์๊ด์ ๋ฒ์
h = 6.626e-34 # ํ๋ํฌ ์์
c = 3e8 # ๋น์ ์๋
k = 1.38e-23 # ๋ณผ์ธ ๋ง ์์
# B(ฮป, T) = 2hcยฒ/ฮปโต ร 1/(exp(hc/ฮปkT) - 1)
spectrum = (2 * h * c**2 / wavelengths**5) / \
(np.exp(h*c / (wavelengths * k * T_kelvin)) - 1)
# CIE XYZ ์ ์ผ์น ํจ์๋ก ๋ณํ
XYZ = spectrum_to_XYZ(spectrum, wavelengths)
# XYZ โ sRGB ๋ณํ (๊ฐ๋ง ๋ณด์ ํฌํจ)
RGB = XYZ_to_sRGB(XYZ)
return np.clip(RGB, 0, 1)
# ๊ฐ์ฐฉ์๋ฐ ์์ ์์:
# T = 10,000K โ ํ๋๋น ํฐ์
# T = 5,000K โ ๋
ธ๋๋น ํฐ์
# T = 3,000K โ ์ฃผํฉ๋น
# T = 1,000K โ ๋ถ์๋น (์๋ฐ ์ธ๊ณฝ)
๐จ ์๋ฐ ๋ฐ๋ ๋ฐ ๋ถํฌ๋ช ๋ ๋ชจ๋ธ
๋ ์ ๊ตํ ์๋ฎฌ๋ ์ดํฐ๋ ์๋ฐ์ ๋ฐ๋ ๋ถํฌ์ ๊ดํ์ ๋๊ป(Optical Depth)๋ ๊ณ ๋ คํด. ์๋ฐ์ด ์์ ํ ๋ถํฌ๋ช ํ๋ฉด ํ๋ฉด๋ง ๋ณด์ด๊ณ , ๋ฐํฌ๋ช ํ๋ฉด ๋ด๋ถ ๊ตฌ์กฐ๋ ๋ณด์ฌ. ์ด๊ฑธ ๋ฐฉ์ฌ ์ ๋ฌ ๋ฐฉ์ ์(Radiative Transfer Equation)์ผ๋ก ๊ณ์ฐํด:
I_ฮฝ : ํน์ ์ฃผํ์์์์ ๋ณต์ฌ ๊ฐ๋ ฮบ_ฮฝ : ํก์ ๊ณ์ j_ฮฝ : ๋ฐฉ์ถ ๊ณ์ ฯ : ๋ฐ๋ s : ๊ด์ ๊ฒฝ๋ก ๊ธธ์ด
โก 6. ์ค์ ์๋ฎฌ๋ ์ดํฐ ๊ตฌํ โ ์ต์ ํ์ ์ค์ฉ์ ํ
์ด๋ก ์ ์๊ฒ ๋๋ฐ, ์ค์ ๋ก ๋ง๋ค๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น? ๐ค ์ฌ๊ธฐ์๋ถํฐ๋ ์ง์ง ๊ฐ๋ฐ์ ๊ด์ ์์ ์๊ธฐํด๋ณผ๊ฒ.
๐๏ธ ์ฑ๋ฅ ์ต์ ํ ์ ๋ต
| ์ต์ ํ ๊ธฐ๋ฒ | ํจ๊ณผ | ๊ตฌํ ๋์ด๋ |
|---|---|---|
| GPU ๋ณ๋ ฌํ (CUDA/OpenCL) | 100~1000๋ฐฐ ์๋ ํฅ์ | โญโญโญโญ |
| ์ ์ํ ์คํ ํฌ๊ธฐ (RK45) | ์ ํ๋ ์ ์งํ๋ฉฐ ์คํ ์ ๊ฐ์ | โญโญโญ |
| ๋ฃฉ์ ํ ์ด๋ธ (LUT) | ๋ฐ๋ณต ๊ณ์ฐ ์บ์ฑ์ผ๋ก 2~5๋ฐฐ ํฅ์ | โญโญ |
| ๋์นญ์ฑ ํ์ฉ | ์๋ฐ๋ฅด์ธ ์คํธ์ ๊ตฌ๋ฉด ๋์นญ์ผ๋ก ๊ณ์ฐ๋ ์ ๋ฐ | โญโญ |
| ํด๋ฐํ ๋์ ๋ฐฉ๋ฒ | ์๋์ง ๋ณด์กด ์๋ ๋ณด์ฅ, ์ฅ๊ธฐ ์์ ์ฑ | โญโญโญโญ |
| ๋ฉํฐ ํด์๋ ๋ ๋๋ง | ๋น ๋ฅธ ํ๋ฆฌ๋ทฐ ํ ๊ณ ํด์๋ ๋ ๋๋ง | โญโญ |
๐ง ํด๋ฐํ ๋์ ๋ฐฉ๋ฒ โ ๋ ์์ ์ ์ธ ์ ๋ถ
RK4 ๋์ ํด๋ฐํ ๋์ ๋ฐฉ๋ฒ(Hamiltonian Formulation)์ ์ฐ๋ฉด ์๋์ง ๋ณด์กด์ด ์๋์ผ๋ก ๋ณด์ฅ๋ผ. ์ธก์ง์ ๋ฐฉ์ ์์ ํด๋ฐํ ๋์ ํํ๋ก ์ฐ๋ฉด:
dxแต/dฮป = โH/โp_ฮผ dp_ฮผ/dฮป = -โH/โxแต
p_ฮผ : ๊ณต๋ณ 4-์ด๋๋ g^ฮผฮฝ : ์ญ ๊ณ๋ ํ ์
์ด ํํ๋ก ์ฐ๋ฉด ์ฌํ๋ ํฑ ์ ๋ถ๊ธฐ(Symplectic Integrator)๋ฅผ ์ธ ์ ์์ด. ์ฌํ๋ ํฑ ์ ๋ถ๊ธฐ๋ ์๋์ง๋ฅผ ์ฅ๊ธฐ๊ฐ ๋ณด์กดํ๋ ํน์ฑ์ด ์์ด์ ๊ธด ๊ถค๋ ๊ณ์ฐ์ ํจ์ฌ ์ ๋ฆฌํด.
๐ ์คํ์์ค ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ๋ค
๐ BlackHoleViz โ Python ๊ธฐ๋ฐ ๊ต์ก์ฉ ์๋ฎฌ๋ ์ดํฐ
โก GRay2 โ GPU ๊ฐ์ ์ผ๋ฐ์๋๋ก ์ ๊ด์ ์ถ์ ๊ธฐ
๐ฌ BHOSS โ ๋ธ๋ํ ๊ทธ๋ฆผ์ ์๋ฎฌ๋ ์ด์ ์ฝ๋
๐ฌ ipole โ EHT(์ฌ๊ฑด ์งํ์ ๋ง์๊ฒฝ) ํ์ด ์ฌ์ฉํ ์ฝ๋
๐ธ EHT์ M87* ๋ธ๋ํ ์ด๋ฏธ์ง์ ์๋ฎฌ๋ ์ดํฐ
2019๋ ์ธ๋ฅ ์ต์ด๋ก ๋ธ๋ํ ์ฌ์ง์ ์ฐ์ ์ฌ๊ฑด ์งํ์ ๋ง์๊ฒฝ(Event Horizon Telescope, EHT) ํ๋ ์๋ฎฌ๋ ์ดํฐ๋ฅผ ์์ฒญ ๋ง์ด ํ์ฉํ์ด. ๊ด์ธก ๋ฐ์ดํฐ๋ฅผ ํด์ํ๊ธฐ ์ํด ์์ฒ ๊ฐ์ง ๋ธ๋ํ ๋ชจ๋ธ์ ์๋ฎฌ๋ ์ด์ ํ๊ณ ๋น๊ตํ๊ฑฐ๋ .
M87* ๋ธ๋ํ(์ง๋ โ 65์ต ํ์ ์ง๋, ๊ฑฐ๋ฆฌ โ 5500๋ง ๊ด๋ )์ ์ด๋ฏธ์ง์์ ๋ณด์ด๋ ๋ฐ์ ๋ง๊ณผ ์ด๋์ด ๊ทธ๋ฆผ์๊ฐ ๋ฐ๋ก ์๋ฎฌ๋ ์ดํฐ๋ก ์์ธกํ ๊ฒ๊ณผ ์ ํํ ์ผ์นํ์ด. ์ด๊ฒ ์ผ๋ฐ์๋์ฑ์ด๋ก ์ ๊ฐ๋ ฅํ ๊ฒ์ฆ์ด๊ธฐ๋ ํด! ๐
๐งฌ 7. ๊ณ ๊ธ ๋ฌผ๋ฆฌ ํจ๊ณผ โ ๋ ํ์ค์ ์ธ ์๋ฎฌ๋ ์ดํฐ๋ฅผ ์ํด
๐ GRMHD โ ์๊ธฐ์ ์ฒด์ญํ๊น์ง ํฌํจํ ์๋ฎฌ๋ ์ด์
์ง์ง ์ฐ๊ตฌ์ฉ ์๋ฎฌ๋ ์ดํฐ๋ ๋จ์ํ ๊ด์ ์ถ์ ์ ๋์ด์ ์ผ๋ฐ์๋๋ก ์ ์๊ธฐ์ ์ฒด์ญํ(GRMHD: General Relativistic Magnetohydrodynamics)๊น์ง ํฌํจํด. ๊ฐ์ฐฉ์๋ฐ์ ๋ฌผ์ง์ด ์๊ธฐ์ฅ๊ณผ ์ด๋ป๊ฒ ์ํธ์์ฉํ๋์ง, ์ ํธ(Jet)๊ฐ ์ด๋ป๊ฒ ํ์ฑ๋๋์ง๋ฅผ ๊ณ์ฐํ๋ ๊ฑฐ์ผ.
T^ฮผฮฝ = (ฯ + u + p + bยฒ)u^ฮผu^ฮฝ + (p + bยฒ/2)g^ฮผฮฝ - b^ฮผb^ฮฝ [์๋์ง-์ด๋๋ ํ ์ (์ ์ฒด + ์๊ธฐ์ฅ)]
์ด๋ฐ GRMHD ์๋ฎฌ๋ ์ด์ ์ HARM, KORAL, BHAC ๊ฐ์ ์ ๋ฌธ ์ฝ๋๋ก ์ํผ์ปดํจํฐ์์ ๋๋ ค. ํ ๋ฒ ์๋ฎฌ๋ ์ด์ ์ ์๋ฐฑ๋ง CPU ์๊ฐ์ด ๋ค๊ธฐ๋ ํด!
๐ก๏ธ ํธํน ๋ณต์ฌ (Hawking Radiation)
์คํฐ๋ธ ํธํน์ด 1974๋ ์ ์์ธกํ ํธํน ๋ณต์ฌ๋ ๋ธ๋ํ์ด ์์ ํจ๊ณผ๋ก ์ธํด ์ด๋ณต์ฌ๋ฅผ ๋ฐฉ์ถํ๋ค๋ ์ด๋ก ์ด์ผ. ํธํน ์จ๋๋:
โ = 1.055 ร 10โปยณโด Jยทs [ํ์ฐ ํ๋ํฌ ์์] k_B = 1.38 ร 10โปยฒยณ J/K [๋ณผ์ธ ๋ง ์์]
ํ์ ์ง๋ ๋ธ๋ํ์ ํธํน ์จ๋๋ ์ฝ 6ร10โปโธ K์ผ. ์ฐ์ฃผ ๋ฐฐ๊ฒฝ ๋ณต์ฌ(2.7K)๋ณด๋ค ํจ์ฌ ๋ฎ์์ ์ค์ ๋ก๋ ๊ด์ธก์ด ๋ถ๊ฐ๋ฅํด. ํ์ง๋ง ์ํ ๋ธ๋ํ์ด๋ ์์ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ์์๋ ์ด ํจ๊ณผ๋ฅผ ํฌํจํ๊ธฐ๋ ํด.
โฐ ์๊ฐ ์ง์ฐ ํจ๊ณผ (Time Dilation)
๋ธ๋ํ ๊ทผ์ฒ์์๋ ์๊ฐ์ด ๋๋ ค์ ธ. ์ด๊ฑธ ์๋ฎฌ๋ ์ดํฐ์์ ์๊ฐํํ๋ฉด ์ ๋ง ์ธ์์ ์ธ ํจ๊ณผ๊ฐ ๋์:
r = 1.5 Rs ์์: ์๊ฐ์ด ์ฝ 1.73๋ฐฐ ๋๋ ค์ง r = 1.1 Rs ์์: ์๊ฐ์ด ์ฝ 3.32๋ฐฐ ๋๋ ค์ง r โ Rs ์์: ์๊ฐ์ด ๋ฌดํํ ๋๋ ค์ง (์ธ๋ถ ๊ด์ธก์ ๊ธฐ์ค)
๐ ๏ธ 8. ๊ฐ๋ฐ ํ๊ฒฝ๊ณผ ๋๊ตฌ โ ์ง์ ๋ง๋ค์ด๋ณด๊ณ ์ถ๋ค๋ฉด
๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ ์ง์ ๋ง๋ค์ด๋ณด๊ณ ์ถ์ด? ๐ ์ง์ ์ฅ๋ฒฝ์ด ๋์ ๋ณด์ด์ง๋ง, ๋จ๊ณ๋ณ๋ก ์ ๊ทผํ๋ฉด ์ถฉ๋ถํ ๊ฐ๋ฅํด!
๐ Python์ผ๋ก ์์ํ๋ ๊ฐ๋จํ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ
# ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp
# ์๋ฐ๋ฅด์ธ ์คํธ ๋ธ๋ํ ๊ด์ ์ถ์ (2D ๋จ์ํ ๋ฒ์ )
def schwarzschild_geodesic(lambda_param, state, Rs=1.0):
"""
state = [r, phi, dr/dl, dphi/dl]
์์ฐ๋จ์: G=c=M=1, Rs=2
"""
r, phi, dr, dphi = state
# ํฌ๋ฆฌ์คํ ํ ๊ธฐํธ์์ ์ ๋๋ ๊ฐ์๋
d2r = r * dphi**2 * (1 - Rs/r) - (Rs/(2*r**2)) * (dr**2/(1-Rs/r) - r**2*dphi**2)
d2phi = -2 * dr * dphi / r
return [dr, dphi, d2r, d2phi]
def trace_ray(b_impact, Rs=2.0, r_start=50.0):
"""
์ถฉ๊ฒฉ ๋งค๊ฐ๋ณ์ b๋ก ๊ด์ ์ถ์
"""
# ์ด๊ธฐ ์กฐ๊ฑด (๋ฌดํ๋์์ ์ค๋ ๊ด์ )
r0 = r_start
phi0 = 0.0
dphi0 = 1.0 / r0**2 # L/rยฒ (L=1๋ก ์ ๊ทํ)
dr0 = -np.sqrt(1 - (1 - Rs/r0) / b_impact**2 * r0**2)
state0 = [r0, phi0, dr0, dphi0]
# ์ ๋ถ (์ด๋ฒคํธ: ๋ธ๋ํ ํฌํ ๋๋ ํ์ถ)
def captured(l, s, Rs): return s[0] - 1.05*Rs
captured.terminal = True
captured.direction = -1
sol = solve_ivp(
schwarzschild_geodesic,
[0, 1000],
state0,
args=(Rs,),
events=captured,
max_step=0.5,
rtol=1e-8
)
return sol
# ์ฌ๋ฌ ์ถฉ๊ฒฉ ๋งค๊ฐ๋ณ์๋ก ๊ด์ ์ถ์
Rs = 2.0
b_critical = 3*np.sqrt(3)/2 * Rs # โ 5.196
fig, ax = plt.subplots(1, 1, figsize=(10, 10), facecolor='black')
ax.set_facecolor('black')
# ๋ธ๋ํ ๊ทธ๋ฆฌ๊ธฐ
circle = plt.Circle((0, 0), Rs/2, color='black',
linewidth=2, edgecolor='#4a90d9')
ax.add_patch(circle)
# ๋ค์ํ b๊ฐ์ผ๋ก ๊ด์ ์ถ์
for b in np.linspace(b_critical*0.8, b_critical*3, 20):
sol = trace_ray(b, Rs)
x = sol.y[0] * np.cos(sol.y[1])
y = sol.y[0] * np.sin(sol.y[1])
color = '#ef4444' if sol.t_events[0].size > 0 else '#a78bfa'
ax.plot(x, y, color=color, alpha=0.6, linewidth=0.8)
plt.show()
๐ ๋ค์ ๋จ๊ณ โ ๋ ๋ฐ์ ์ํค๋ ค๋ฉด
2D์์ 3D๋ก ํ์ฅํ๊ณ , ์ค์ ํฝ์ ๋ ๋๋ง ํ์ดํ๋ผ์ธ ๊ตฌํ. OpenGL์ด๋ Vulkan ์ฌ์ฉ ์ถ์ฒ.
CUDA (NVIDIA) ๋๋ Metal (Apple)๋ก ํฝ์ ๋ณ ๋ณ๋ ฌ ๊ณ์ฐ. PyTorch๋ JAX๋ก GPU ๊ณ์ฐ์ ์ฝ๊ฒ ์์ํ ์ ์์ด.
์๋ฐ๋ฅด์ธ ์คํธ์์ ์ปค ๊ณ๋์ผ๋ก ์ ๊ทธ๋ ์ด๋. ์คํ ํ๋ผ๋ฏธํฐ a๋ฅผ ์ถ๊ฐํ๊ณ ํฌ๋ฆฌ์คํ ํ ๊ธฐํธ๋ฅผ ์ฌ๊ณ์ฐ.
๋ ธ๋น์ฝํ-์ ์จ๋ ๋ชจ๋ธ๋ก ์๋ฐ ์์ ๊ณ์ฐ, ๋ํ๋ฌ/๋น ์ง์ค ํจ๊ณผ ์ ์ฉ.
WebGL/Three.js๋ก ์น ๊ธฐ๋ฐ ์ค์๊ฐ ์๋ฎฌ๋ ์ดํฐ ๊ตฌํ. ์ฌ์ฉ์๊ฐ ๋ธ๋ํ ํ๋ผ๋ฏธํฐ๋ฅผ ์ค์๊ฐ์ผ๋ก ์กฐ์ ๊ฐ๋ฅ!
๐ฌ 9. ์ต์ ์ฐ๊ตฌ ํธ๋ ๋ โ ๋ธ๋ํ ์๋ฎฌ๋ ์ด์ ์ ๋ฏธ๋
๐ค ๋จธ์ ๋ฌ๋ + ๋ธ๋ํ ์๋ฎฌ๋ ์ด์
์ต๊ทผ์๋ ์ ๊ฒฝ๋ง(Neural Network)์ ๋ธ๋ํ ์๋ฎฌ๋ ์ด์ ์ ํ์ฉํ๋ ์ฐ๊ตฌ๊ฐ ํ๋ฐํด. ํฌ๊ฒ ๋ ๊ฐ์ง ๋ฐฉํฅ์ด์ผ:
๐ ์ค์๊ฐ ์น ๊ธฐ๋ฐ ์๋ฎฌ๋ ์ดํฐ
WebGL๊ณผ WebGPU์ ๋ฐ์ ์ผ๋ก ์ด์ ๋ธ๋ผ์ฐ์ ์์๋ ์ค์๊ฐ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ๊ฐ ๊ฐ๋ฅํด์ก์ด! Three.js + GLSL ์ ฐ์ด๋๋ก ๊ตฌํํ๋ฉด ๋ชจ๋ฐ์ผ์์๋ ๋์๊ฐ๋ ์ธํฐ๋ํฐ๋ธ ์๋ฎฌ๋ ์ดํฐ๋ฅผ ๋ง๋ค ์ ์์ด.
// GLSL ์
ฐ์ด๋ โ ์๋ฐ๋ฅด์ธ ์คํธ ๋ธ๋ํ ๊ด์ ์ถ์ (๋จ์ํ)
// fragment shader
uniform float Rs; // ์๋ฐ๋ฅด์ธ ์คํธ ๋ฐ์ง๋ฆ
uniform vec3 cameraPos; // ์นด๋ฉ๋ผ ์์น
uniform samplerCube skybox; // ๋ฐฐ๊ฒฝ ํ๋ ํ
์ค์ฒ
void main() {
vec3 rayDir = normalize(vRayDir);
vec3 pos = cameraPos;
// ์ธก์ง์ ์์น ์ ๋ถ (๋จ์ํ๋ ๋ฒ์ )
for(int i = 0; i < 256; i++) {
float r = length(pos);
// ๋ธ๋ํ ํฌํ ์ฒดํฌ
if(r < Rs * 1.05) {
gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
return;
}
// ์ค๋ ฅ ๊ฐ์๋ (๋ดํด ๊ทผ์ฌ + ์๋๋ก ์ ๋ณด์ )
vec3 gravity = -normalize(pos) * Rs / (2.0 * r * r);
// ๊ด์ ์
๋ฐ์ดํธ
rayDir += gravity * stepSize;
rayDir = normalize(rayDir);
pos += rayDir * stepSize;
}
// ๋ฐฐ๊ฒฝ ํ๋ ์ํ๋ง
gl_FragColor = texture(skybox, rayDir);
}
๐ญ ์ฐจ์ธ๋ EHT์ ์๋ฎฌ๋ ์ดํฐ
2030๋ ๋๋ฅผ ๋ชฉํ๋ก ํ๋ ์ฐจ์ธ๋ EHT(ngEHT)๋ ๋ ๋ง์ ๋ง์๊ฒฝ์ ์ถ๊ฐํด์ ๋ธ๋ํ ์ด๋ฏธ์ง์ ํด์๋๋ฅผ ํฌ๊ฒ ๋์ผ ๊ณํ์ด์ผ. ์ด๋ฅผ ์ํด ๋ ์ ๊ตํ GRMHD ์๋ฎฌ๋ ์ด์ ๊ณผ ๊ด์ ์ถ์ ์ฝ๋๊ฐ ํ์ํด. ํนํ ๋ธ๋ํ ๊ทธ๋ฆผ์์ ์๊ฐ ๋ณํ๋ฅผ ๊ด์ธกํ๊ธฐ ์ํ ์๋ฎฌ๋ ์ดํฐ ๊ฐ๋ฐ์ด ํ๋ฐํ ์งํ ์ค์ด์ผ.
๋ํ ์ค๋ ฅํ ๊ด์ธก์(LIGO, Virgo, KAGRA)์ ์ ํ ๋ง์๊ฒฝ ๋ฐ์ดํฐ๋ฅผ ๊ฒฐํฉํ ๋ฉํฐ๋ฉ์ ์ ์ฒ๋ฌธํ์์๋ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ๊ฐ ํต์ฌ ์ญํ ์ ํด. ๋ธ๋ํ ํฉ๋ณ ์๋ฎฌ๋ ์ด์ ์ ์์น์๋์ฑ์ด๋ก (Numerical Relativity)์ ์์ญ์ผ๋ก, ์์ธ์ํ์ธ ๋ฐฉ์ ์ ์์ฒด๋ฅผ ์์น์ ์ผ๋ก ํ์ด์ผ ํด์ ์์ฒญ๋ ๊ณ์ฐ ์์์ด ํ์ํด.
๐ 10. ํต์ฌ ์ ๋ฆฌ โ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ ๋ฌผ๋ฆฌ ๋ชจ๋ธ ์์ฝ
์, ์ฌ๊ธฐ๊น์ง ์์ผ๋ฉด ์ด์ ๋ธ๋ํ ์๋ฎฌ๋ ์ดํฐ๊ฐ ์ด๋ป๊ฒ ๋์๊ฐ๋์ง ๊ฝค ์ ์๊ฒ ๋์ ๊ฑฐ์ผ! ํต์ฌ๋ง ๋ค์ ์ ๋ฆฌํด๋ณผ๊ฒ:
| ๊ตฌ์ฑ ์์ | ํต์ฌ ๋ฌผ๋ฆฌ/์ํ | ๊ตฌํ ๋ฐฉ๋ฒ |
|---|---|---|
| ์๊ณต๊ฐ ๊ธฐํํ | ์๋ฐ๋ฅด์ธ ์คํธ/์ปค ๊ณ๋ ํ ์ | ํฌ๋ฆฌ์คํ ํ ๊ธฐํธ ๊ณ์ฐ |
| ๋น์ ๊ฒฝ๋ก | ์ธก์ง์ ๋ฐฉ์ ์ | RK4/RK45 ์์น ์ ๋ถ |
| ๋ ๋๋ง | ์ญ๋ฐฉํฅ ๊ด์ ์ถ์ | GPU ๋ณ๋ ฌํ (CUDA) |
| ์ค๋ ฅ ๋ ์ฆ | ์ถฉ๊ฒฉ ๋งค๊ฐ๋ณ์, ์์ธ์ํ์ธ ๋ง | ๊ด์ ์ข ๋ฃ ์กฐ๊ฑด ํ๋ณ |
| ๊ฐ์ฐฉ์๋ฐ | ๋ ธ๋น์ฝํ-์ ์จ๋ ๋ชจ๋ธ | ํ์ฒด ๋ณต์ฌ โ RGB ๋ณํ |
| ๋ํ๋ฌ ํจ๊ณผ | ์๋๋ก ์ ์ฃผํ์ ํธ์ด | 4์ ๊ณฑ ๋ฐ๊ธฐ ๋ณด์ |
| ์๊ฐ ์ง์ฐ | ์ค๋ ฅ ์ ์ํธ์ด ์ธ์ | ๊ณ๋ ํ ์ g_tt ์ฑ๋ถ |
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.