Гравитация.

gemini

Код (Text):

1.  
2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.animation as animation
5. from IPython.display import HTML
6.  
7. # ============================================================
8. # 1. ОБЩИЕ ПАРАМЕТРЫ СИСТЕМЫ
9. # ============================================================
10. G = 1.0
11. M = 1.0
12. c_rel = 6.0         # Скорость света для ОТО (1PN)
13. c_delay = 8.0       # Скорость поля для задержки
14. dt = 0.0008
15. steps = 35000
16. frames_count = 250
17. steps_per_frame = steps // frames_count
18.  
19. # Начальные условия (небольшой эксцентриситет для наглядности)
20. r0 = 1.0
21. e = 0.15
22. v0 = np.sqrt(G * M * (1 + e) / (r0 * (1 - e)))
23.  
24. init_pos = np.array([r0 * (1 - e), 0.0])
25. init_vel = np.array([0.0, v0])
26.  
27. # ============================================================
28. # 2. ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ УСКОРЕНИЙ
29. # ============================================================
30.  
31. # Модель 1: ОТО (1PN)
32. def accel_oto(pos, vel):
33.     r = np.linalg.norm(pos)
34.     v2 = np.dot(vel, vel)
35.     rv = np.dot(pos, vel)
36.     a_N = -G * M * pos / r**3
37.     factor = (4 * G * M / r - v2) / c_rel**2
38.     v_factor = 4 * rv / c_rel**2
39.     return a_N * (1 + factor) + (G * M / r**3) * v_factor * vel
40.  
41. # Модель 2: Классический Ньютон
42. def accel_newton(pos):
43.     r = np.linalg.norm(pos)
44.     return -G * M * pos / r**3
45.  
46. # Модель 3: Наивная Задержка
47. def accel_delay(pos, vel):
48.     r = np.linalg.norm(pos)
49.     delay = r / c_delay
50.     retarded_center = -vel * delay
51.     dr = retarded_center - pos
52.     r_ret = np.linalg.norm(dr)
53.     return G * M * dr / r_ret**3
54.  
55. # ============================================================
56. # 3. РАСЧЕТ ТРАЕКТОРИЙ
57. # ============================================================
58.  
59. # --- 1. ОТО (1PN) ---
60. traj_oto = [init_pos.copy()]
61. p, v = init_pos.copy(), init_vel.copy()
62. for _ in range(1, steps):
63.     # RK4
64.     k1_v = accel_oto(p, v); k1_p = v
65.     k2_v = accel_oto(p + 0.5*dt*k1_p, v + 0.5*dt*k1_v); k2_p = v + 0.5*dt*k1_v
66.     k3_v = accel_oto(p + 0.5*dt*k2_p, v + 0.5*dt*k2_v); k3_p = v + 0.5*dt*k2_v
67.     k4_v = accel_oto(p + dt*k3_p, v + dt*k3_v); k4_p = v + dt*k3_v
68.     p += (dt/6) * (k1_p + 2*k2_p + 2*k3_p + k4_p)
69.     v += (dt/6) * (k1_v + 2*k2_v + 2*k3_v + k4_v)
70.     traj_oto.append(p.copy())
71.  
72. # --- 2. Ньютон ---
73. traj_newton = [init_pos.copy()]
74. p, v = init_pos.copy(), init_vel.copy()
75. for _ in range(1, steps):
76.     a = accel_newton(p)
77.     v += a * dt
78.     p += v * dt
79.     traj_newton.append(p.copy())
80.  
81. # --- 3. Задержка ---
82. traj_delay = [init_pos.copy()]
83. p, v = init_pos.copy(), init_vel.copy()
84. for _ in range(1, steps):
85.     a = accel_delay(p, v)
86.     v += a * dt
87.     p += v * dt
88.     traj_delay.append(p.copy())
89.  
90. # --- 4. Квантованная гравитация ---
91. traj_quant = [init_pos.copy()]
92. p, v = init_pos.copy(), init_vel.copy()
93.  
94. # Параметры квантования
95. p_quantum = 0.0003     # Квант приращения импульса (дискретность)
96. t_quantum_steps = 15   # Шагов между квантовыми актами взаимодействия
97. acc_buffer = np.zeros(2)
98.  
99. for step in range(1, steps):
100.     a = accel_newton(p)
101.     acc_buffer += a * dt
102.  
103.     # Взаимодействие происходит порциями
104.     if step % t_quantum_steps == 0:
105.         # Дискретизация приращения импульса/скорости
106.         v_inc = np.round(acc_buffer / p_quantum) * p_quantum
107.         v += v_inc
108.         acc_buffer = np.zeros(2)
109.  
110.     p += v * dt
111.     traj_quant.append(p.copy())
112.  
113. traj_oto = np.array(traj_oto)
114. traj_newton = np.array(traj_newton)
115. traj_delay = np.array(traj_delay)
116. traj_quant = np.array(traj_quant)
117.  
118. # ============================================================
119. # 4. ОТРИСОВКА И АНИМАЦИЯ
120. # ============================================================
121. fig, axs = plt.subplots(2, 2, figsize=(10, 10), dpi=100)
122. fig.patch.set_facecolor('#0d1117')
123.  
124. titles = ['1. ОТО (1PN: Розетка)', '2. Ньютон (Идеальный эллипс)',
125.           '3. Задержка (Разгон / Срыв)', '4. Квант (Дискретный хаос)']
126. colors = ['#58a6ff', '#3fb950', '#ff7b72', '#d2a8ff']
127. trajs = [traj_oto, traj_newton, traj_delay, traj_quant]
128.  
129. lines, planets = [], []
130.  
131. for ax, title, color in zip(axs.flat, titles, colors):
132.     ax.set_facecolor('#0d1117')
133.     ax.set_xlim(-1.8, 1.8)
134.     ax.set_ylim(-1.8, 1.8)
135.     ax.set_aspect('equal')
136.     ax.grid(True, color='#21262d', linestyle='--')
137.     ax.set_title(title, color=color, fontsize=11, fontweight='bold')
138.  
139.     line, = ax.plot([], [], color=color, lw=1.0, alpha=0.8)
140.     ax.scatter([0], [0], color='#f2cc60', s=120, zorder=5) # Звезда
141.     planet = ax.scatter([], [], color='white', s=40, zorder=6)
142.  
143.     lines.append(line)
144.     planets.append(planet)
145.  
146. def update(frame):
147.     idx = (frame + 1) * steps_per_frame
148.     for line, planet, traj in zip(lines, planets, trajs):
149.         line.set_data(traj[:idx, 0], traj[:idx, 1])
150.         planet.set_offsets([traj[idx-1, 0], traj[idx-1, 1]])
151.     return lines + planets
152.  
153. anim = animation.FuncAnimation(
154.     fig, update, frames=frames_count, blit=True, interval=40
155. )
156.  
157. plt.tight_layout()
158. plt.close()
159.  
160. # Вывод видео в Jupyter/Colab
161. HTML(anim.to_html5_video())

Матан что он генерит я не понимаю

--- Сообщение объединено, 6 сен 2026 ---

Как это работает:

- это эльфийское, матем попроще.

Это разложеник в Тейлор дающее силовые поправки, которые накапливаются:

 

Искал по ТО, нашел этот материал Метафизика, МГУ Ю. С. Владимиров

Там много упоминается Пуанкаре.

Автор мыслит матем понятиями прошлого века, такая подача совершенно не понятна. Алгебра это зло..

После выжимки получается это реляционная физика, как ттр. Только он не видет связей(граф), а тащит алгебру для описания сову на глобус.

Может кому то интересно, на разбор нужно много времени.

 

Эффект Джанибекова

Код (Text):

1. import numpy as np
2. import matplotlib.pyplot as plt
3. from matplotlib.animation import FuncAnimation
4. from IPython.display import HTML
5. from scipy.spatial.transform import Rotation as R
6.  
7. # ==========================================
8. # 1. ГЕОМЕТРИЯ И МАССЫ (Абсолютно твердое тело)
9. # ==========================================
10. # Начальные положения 4 точек Т-образной гайки
11. init_positions = np.array([
12.     [0.0,  0.0, 0.0],  # 0: Центр
13.     [0.0, -0.25, 0.0], # 1: Левое крыло
14.     [0.0,  0.25, 0.0], # 2: Правое крыло
15.     [0.35, 0.0, 0.0]   # 3: Хвост (штырь)
16. ])
17.  
18. masses = np.array([4.0, 1.0, 1.0, 1.5])
19. total_mass = np.sum(masses)
20.  
21. # Сдвигаем начальные координаты, чтобы центр масс был строго в (0,0,0)
22. cm_init = np.sum(init_positions * masses[:, None], axis=0) / total_mass
23. init_positions -= cm_init
24.  
25. # Функция для вычисления тензора инерции
26. def get_inertia_tensor(pos):
27.     I = np.zeros((3, 3))
28.     for i in range(len(masses)):
29.         r = pos[i]
30.         I += masses[i] * (np.dot(r, r) * np.eye(3) - np.outer(r, r))
31.     return I
32.  
33. # Начальный вектор момента импульса L (он СТРОГО сохраняется в пространстве!)
34. w0 = np.array([0.15, 6.0, 0.0]) # Вращение вокруг Y + малое возмущение по X
35. L = get_inertia_tensor(init_positions) @ w0
36.  
37. # Настройки симуляции
38. dt = 0.001
39. steps = 16000
40. skip = 50
41.  
42. positions = init_positions.copy()
43. history = []
44.  
45. # ==========================================
46. # 2. ЧЕСТНЫЙ ИНЕРЦИОННЫЙ ШАГ НЬЮТОНА (БЕЗ ДЕФОРМАЦИИ)
47. # ==========================================
48. for step in range(steps):
49.     I = get_inertia_tensor(positions)
50.     I_inv = np.linalg.inv(I)
51.    
52.     # Находим текущую угловую скорость из неизменного L
53.     w = I_inv @ L
54.    
55.     # Строгое вращение без изменения расстояний через матрицу поворота
56.     rot_vector = w * dt
57.     rot = R.from_rotvec(rot_vector)
58.     positions = rot.apply(positions)
59.        
60.     if step % skip == 0:
61.         history.append(positions.copy())
62.  
63. # ==========================================
64. # 3. ВИЗУАЛИЗАЦИЯ ИДЕАЛЬНОГО КУВЫРКА
65. # ==========================================
66. fig = plt.figure(figsize=(6, 6))
67. ax = fig.add_subplot(111, projection='3d')
68.  
69. # Фиксируем куб, чтобы убрать иллюзию смещения
70. ax.set_xlim([-0.4, 0.4])
71. ax.set_ylim([-0.4, 0.4])
72. ax.set_zlim([-0.4, 0.4])
73. ax.set_title("Эффект Джанибекова из элементарных масс")
74. ax.view_init(elev=20, azim=55)
75.  
76. # Создаем объекты линий с пустыми массивами нужной формы
77. line_bar, = ax.plot(np.array([]), np.array([]), np.array([]), 'b-o', lw=4, markersize=6)
78. line_tail, = ax.plot(np.array([]), np.array([]), np.array([]), 'r-o', lw=5, markersize=6)
79. center_dot, = ax.plot(np.array([0.0]), np.array([0.0]), np.array([0.0]), 'go', markersize=10)
80.  
81. def update(frame):
82.     pos = history[frame]
83.    
84.     # Синяя перекладина: Лево (1) -> Центр (0) -> Право (2)
85.     bx = np.array([pos[1, 0], pos[0, 0], pos[2, 0]], dtype=float)
86.     by = np.array([pos[1, 1], pos[0, 1], pos[2, 1]], dtype=float)
87.     bz = np.array([pos[1, 2], pos[0, 2], pos[2, 2]], dtype=float)
88.    
89.     line_bar.set_data(bx, by)
90.     line_bar.set_3d_properties(bz)
91.    
92.     # Красный штырь: Центр (0) -> Хвост (3)
93.     tx = np.array([pos[0, 0], pos[3, 0]], dtype=float)
94.     ty = np.array([pos[0, 1], pos[3, 1]], dtype=float)
95.     tz = np.array([pos[0, 2], pos[3, 2]], dtype=float)
96.    
97.     line_tail.set_data(tx, ty)
98.     line_tail.set_3d_properties(tz)
99.    
100.     # Центр масс строго в нуле
101.     center_dot.set_data(np.array([0.0]), np.array([0.0]))
102.     center_dot.set_3d_properties(np.array([0.0]))
103.    
104.     return line_bar, line_tail, center_dot
105.  
106. # Запускаем анимацию (blit=False для стабильности в Jupyter/Colab)
107. anim = FuncAnimation(fig, update, frames=len(history), interval=30, blit=False)
108. plt.close()
109.  
110. HTML(anim.to_html5_video())
111.  

К теме инерциоидов, на симуляции падает вертикально. Но это ничего не доказывает. Боковая сила возникает при наличии веса.

Код (Text):

1. import numpy as np
2. import matplotlib.pyplot as plt
3. from matplotlib.animation import FuncAnimation
4. from IPython.display import HTML
5. from scipy.spatial.transform import Rotation as R
6.  
7. # ==========================================
8. # 1. ГЕОМЕТРИЯ, МАССЫ И МЯГКАЯ ГРАВИТАЦИЯ
9. # ==========================================
10. init_positions = np.array([
11.     [0.0,  0.0, 0.0],  # 0: Центр
12.     [0.0, -0.25, 0.0], # 1: Левое крыло
13.     [0.0,  0.25, 0.0], # 2: Правое крыло
14.     [0.35, 0.0, 0.0]   # 3: Хвост (штырь)
15. ])
16.  
17. masses = np.array([4.0, 1.0, 1.0, 1.5])
18. total_mass = np.sum(masses)
19.  
20. # Центрируем начальное тело строго в локальный ноль
21. cm_init = np.sum(init_positions * masses[:, None], axis=0) / total_mass
22. init_positions -= cm_init
23.  
24. def get_inertia_tensor(pos):
25.     I = np.zeros((3, 3))
26.     for i in range(len(masses)):
27.         r = pos[i]
28.         I += masses[i] * (np.dot(r, r) * np.eye(3) - np.outer(r, r))
29.     return I
30.  
31. # Начальное вращение вокруг Y + возмущение по X
32. w0 = np.array([0.15, 6.0, 0.0])
33. L = get_inertia_tensor(init_positions) @ w0
34.  
35. # Ускорение падения (сделали еще меньше, чтобы падало дольше)
36. g_acc = np.array([0.0, 0.0, -0.06])
37.  
38. # Увеличенные настройки времени для долгого полета
39. dt = 0.001
40. steps = 40000     # Увеличили число шагов в 2.5 раза
41. skip = 80         # Скорректировали шаг кадров
42.  
43. positions = init_positions.copy()
44. cm_position = np.array([0.0, 0.0, 0.3]) # Стартуем повыше
45. cm_velocity = np.array([0.0, 0.0, 0.0])
46.  
47. history_pts = []
48. history_cm = []
49.  
50. # ==========================================
51. # 2. РАСЧЕТ ДЛИТЕЛЬНОГО ПАДЕНИЯ
52. # ==========================================
53. for step in range(steps):
54.     I = get_inertia_tensor(positions)
55.     w = np.linalg.inv(I) @ L
56.     rot = R.from_rotvec(w * dt)
57.     positions = rot.apply(positions)
58.    
59.     # Падение центра масс
60.     cm_velocity += g_acc * dt
61.     cm_position += cm_velocity * dt
62.    
63.     if step % skip == 0:
64.         world_positions = positions + cm_position
65.         history_pts.append(world_positions.copy())
66.         history_cm.append(cm_position.copy())
67.  
68. # ==========================================
69. # 3. ВИЗУАЛИЗАЦИЯ (ВЫТЯНУТЫЙ КУБ ПО ОСИ Z)
70. # ==========================================
71. fig = plt.figure(figsize=(6, 7))
72. ax = fig.add_subplot(111, projection='3d')
73.  
74. # Вытянули ось Z вниз, чтобы гайка не вылетала
75. ax.set_xlim([-0.4, 0.4])
76. ax.set_ylim([-0.4, 0.4])
77. ax.set_zlim([-1.2, 0.4])
78. ax.set_title("Затяжное падение с эффектом Джанибекова")
79. ax.view_init(elev=15, azim=45)
80.  
81. line_bar, = ax.plot([], [], [], 'b-o', lw=4, markersize=6)
82. line_tail, = ax.plot([], [], [], 'r-o', lw=5, markersize=6)
83. center_dot, = ax.plot([], [], [], 'go', markersize=10)
84.  
85. def update(frame):
86.     pos = history_pts[frame]
87.     cm = history_cm[frame]
88.    
89.     # Синяя перекладина: явные плоские списки координат по осям
90.     bx = [pos[1,0], pos[0,0], pos[2,0]]
91.     by = [pos[1,1], pos[0,1], pos[2,1]]
92.     bz = [pos[1,2], pos[0,2], pos[2,2]]
93.    
94.     line_bar.set_data(bx, by)
95.     line_bar.set_3d_properties(bz)
96.    
97.     # Красный штырь
98.     tx = [pos[0,0], pos[3,0]]
99.     ty = [pos[0,1], pos[3,1]]
100.     tz = [pos[0,2], pos[3,2]]
101.    
102.     line_tail.set_data(tx, ty)
103.     line_tail.set_3d_properties(tz)
104.    
105.     # Зеленый падающий центр масс
106.     center_dot.set_data([cm[0]], [cm[1]])
107.     center_dot.set_3d_properties([cm[2]])
108.    
109.     return line_bar, line_tail, center_dot
110.  
111. anim = FuncAnimation(fig, update, frames=len(history_pts), interval=25, blit=False)
112. plt.close()
113.  
114. HTML(anim.to_html5_video())
115.