File size: 6,677 Bytes
a0589da |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 |
import numpy as np
import pandas as pd
import json
import os
# Constants
c = 299792458 # Speed of light in m/s
E_mc2 = c**2 # Mass-energy equivalence in J/kg
TSR = E_mc2 / (1.38e-23) # Temperature to Speed Ratio in K/m/s
alpha = 1.0 # Proportional constant for TSR
Q = 2 ** (1 / 12) # Fractal structure parameter
dark_energy_density = 5.96e-27 # Density of dark energy in kg/m^3
dark_matter_density = 2.25e-27 # Density of dark matter in kg/m^3
collision_distance = 1e-10 # Distance for collision detection
Hubble_constant = 70.0 # km/s/Mpc (approximation)
Hubble_constant_SI = Hubble_constant * 1000 / 3.086e22 # Convert to SI units (s^-1)
# Initial conditions
temperature_initial = 1.0 # Planck temperature in K
particle_density_initial = 5.16e96 # Planck density in kg/m^3
particle_speed_initial = c # Initially at the speed of light
# Simulation time
t_planck = 5.39e-44 # Planck time in s
t_simulation = t_planck * 1e5 # Shorter timescale for simulation
# Quark masses (in GeV) - used for initial mass values and comparison
quark_masses = {
"up": 2.3e-3,
"down": 4.8e-3,
"charm": 1.28,
"strange": 0.095,
"top": 173.0,
"bottom": 4.18,
"electron": 5.11e-4,
"muon": 1.05e-1,
"tau": 1.78,
"photon": 0,
}
# Conversion factor from GeV to J
GeV_to_J = 1.60217662e-10
# Simulation setup
num_steps = int(t_simulation / t_planck)
# Tunneling probabilities to investigate
tunneling_probabilities = np.arange(99.1, 100.0, 0.1) # Exclude 1.0
# Create a directory to store the data
data_dir = "big_bang_simulation_data"
os.makedirs(data_dir, exist_ok=True)
# Functions to incorporate relativistic effects and collisions
def relativistic_energy(particle_speed, particle_mass):
epsilon = 1e-15 # A small value to avoid division by zero
return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
def relativistic_momentum(particle_speed, particle_mass):
epsilon = 1e-15 # A small value to avoid division by zero
return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
def update_speed(current_speed, current_temperature, particle_mass):
"""Update the speed of a particle based on temperature and mass."""
rel_momentum = relativistic_momentum(current_speed, particle_mass)
epsilon = 1e-15 # A small value to avoid division by zero
return c * np.sqrt(1 - (rel_momentum / (rel_momentum + dark_energy_density + epsilon)) ** 2)
def check_collision(particle_speeds, collision_distance):
epsilon = 1e-15 # A small value to avoid invalid subtraction
for j in range(len(particle_speeds)):
for k in range(j+1, len(particle_speeds)):
if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
return True, j, k
return False, -1, -1
def handle_collision(particle_speeds, particle_masses, idx1, idx2):
"""Handle a collision between two particles."""
p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
# Calculate velocities after collision using conservation of momentum
total_momentum = p1 + p2
total_mass = particle_masses[idx1] + particle_masses[idx2]
v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
particle_speeds[idx1], particle_speeds[idx2] = v1_new, v2_new
# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
for tunneling_probability in tunneling_probabilities:
print(f"Simulating for tunneling probability: {tunneling_probability}")
# Initialize arrays for simulation
particle_speeds = np.zeros((len(quark_masses), num_steps)) # 2D array for speeds
particle_temperatures = np.zeros((len(quark_masses), num_steps)) # 2D array for temperatures
particle_masses_evolution = np.zeros((len(quark_masses), num_steps)) # 2D array for mass evolution
tunneling_steps = np.zeros((len(quark_masses), num_steps), dtype=bool) # 2D array for tunneling steps
# Create an array of masses for each quark
particle_masses = np.array([mass * GeV_to_J for mass in quark_masses.values()])
for j, (quark, mass) in enumerate(quark_masses.items()):
particle_masses_evolution[j, 0] = particle_masses[j] # Initialize mass
for i in range(1, num_steps):
particle_speeds[j, i] = update_speed(
particle_speeds[j, i - 1],
particle_temperatures[j, i - 1],
particle_masses[j]
)
# Apply tunneling effect
if np.random.rand() < tunneling_probability:
particle_speeds[j, i] = particle_speeds[j, 0]
tunneling_steps[j, i] = True
particle_temperatures[j, i] = alpha * particle_speeds[j, i] ** 2 # Apply TSR equation
# Update mass based on energy conversion
energy_diff = relativistic_energy(particle_speeds[j, i], particle_masses[j]) - relativistic_energy(particle_speeds[j, i - 1], particle_masses[j])
particle_masses_evolution[j, i] = particle_masses_evolution[j, i - 1] + energy_diff / c**2
# Apply expansion of the universe
particle_speeds[j, i] *= 1 - Hubble_constant_SI * t_planck
particle_temperatures[j, i] *= 1 - Hubble_constant_SI * t_planck
# Check for collisions and handle them
collision, idx1, idx2 = check_collision(particle_speeds[:, i], collision_distance)
if collision:
handle_collision(particle_speeds[:, i], particle_masses, idx1, idx2)
# Print calculated masses at the end of the simulation
print(f"Calculated masses at the end of the simulation (Tunneling Probability: {tunneling_probability}):")
for j, quark in enumerate(quark_masses.keys()):
print(f"{quark}: {particle_masses_evolution[j, -1] / GeV_to_J:.4e} GeV")
# Save data to JSON file
data_filename = os.path.join(data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json")
data = {
"tunneling_probability": tunneling_probability,
"particle_masses_evolution": particle_masses_evolution.tolist(),
"particle_speeds": particle_speeds.tolist(),
"particle_temperatures": particle_temperatures.tolist(),
"tunneling_steps": tunneling_steps.tolist()
}
with open(data_filename, "w") as f:
json.dump(data, f)
|