Dane Sabo
04125fe837
M .task/backlog.data M .task/completed.data M .task/pending.data M .task/undo.data M Class_Work/nuce2101/exam2/latex/main.aux M Class_Work/nuce2101/exam2/latex/main.fdb_latexmk M Class_Work/nuce2101/exam2/latex/main.fls M Class_Work/nuce2101/exam2/latex/main.log
211 lines
8.7 KiB
Python
211 lines
8.7 KiB
Python
import numpy as np
|
|
|
|
# Two-group cross-section data
|
|
cross_sections = {
|
|
'fast': {
|
|
'D': 1.4, # Diffusion constant [cm]
|
|
'Sigma_a': 0.010, # Absorption [cm^-1]
|
|
'Sigma_s': 0.050, # Scattering from fast to thermal [cm^-1]
|
|
'nu_Sigma_f': 0.000, # Neutrons per fission times fission cross section [cm^-1]
|
|
'chi': 1, # Neutron group distribution (fission spectrum)
|
|
'v': 1.8e7, # Average group velocity [cm/sec]
|
|
},
|
|
'thermal': {
|
|
'D': 0.35, # Diffusion constant [cm]
|
|
'Sigma_a': 0.080, # Absorption [cm^-1]
|
|
'Sigma_s': 0.0, # Scattering from thermal to fast [cm^-1]
|
|
'nu_Sigma_f': 0.125, # Neutrons per fission times fission cross section [cm^-1]
|
|
'chi': 0, # Neutron group distribution (fission spectrum)
|
|
'v': 2.2e5, # Average group velocity [cm/sec]
|
|
},
|
|
'scattering': {
|
|
'fast_to_thermal': 0.050, # Sigma_s^(1->2) [cm^-1]
|
|
'thermal_to_fast': 0.0, # Sigma_s^(2->1) [cm^-1]
|
|
}
|
|
}
|
|
|
|
# Easy access shortcuts
|
|
D_fast = cross_sections['fast']['D']
|
|
D_thermal = cross_sections['thermal']['D']
|
|
Sigma_a_fast = cross_sections['fast']['Sigma_a']
|
|
Sigma_a_thermal = cross_sections['thermal']['Sigma_a']
|
|
Sigma_s_fast = cross_sections['fast']['Sigma_s'] # Scattering from fast to thermal
|
|
Sigma_s_thermal = cross_sections['thermal']['Sigma_s'] # Scattering from thermal to fast
|
|
nu_Sigma_f_fast = cross_sections['fast']['nu_Sigma_f']
|
|
nu_Sigma_f_thermal = cross_sections['thermal']['nu_Sigma_f']
|
|
chi_fast = cross_sections['fast']['chi']
|
|
chi_thermal = cross_sections['thermal']['chi']
|
|
v_fast = cross_sections['fast']['v']
|
|
v_thermal = cross_sections['thermal']['v']
|
|
|
|
print("Two-Group Cross-Section Data Loaded")
|
|
print(f"Fast Group: D={D_fast} cm, Sigma_a={Sigma_a_fast} cm^-1, v={v_fast:.2e} cm/s")
|
|
print(f"Thermal Group: D={D_thermal} cm, Sigma_a={Sigma_a_thermal} cm^-1, v={v_thermal:.2e} cm/s")
|
|
|
|
# Problem 2A: Calculate k_inf using Four-Factor Formula
|
|
# k_inf = epsilon * p * f * eta
|
|
# where:
|
|
# epsilon = fast fission factor (neutrons from fast fission per thermal fission)
|
|
# p = resonance escape probability (fraction of fast neutrons reaching thermal)
|
|
# f = thermal utilization factor (thermal neutrons absorbed in fuel vs total)
|
|
# eta = reproduction factor (neutrons produced per thermal neutron absorbed in fuel)
|
|
|
|
# Fast fission factor: epsilon = 1 (no fast fissions since nu_Sigma_f_fast = 0)
|
|
epsilon = 1.0
|
|
|
|
# Resonance escape probability: fraction of fast neutrons that scatter to thermal
|
|
# p = Sigma_s_fast / (Sigma_a_fast + Sigma_s_fast)
|
|
p = Sigma_s_fast / (Sigma_a_fast + Sigma_s_fast)
|
|
|
|
# Thermal utilization factor: f = 1 (single-region, all absorptions in "fuel")
|
|
f = 1.0
|
|
|
|
# Reproduction factor: eta = nu*Sigma_f / Sigma_a (thermal group)
|
|
eta = nu_Sigma_f_thermal / Sigma_a_thermal
|
|
|
|
# Four-Factor Formula
|
|
k_inf = epsilon * p * f * eta
|
|
|
|
print(f"\n=== Problem 2A: k_infinity (Four-Factor Formula) ===")
|
|
print(f"epsilon (fast fission factor) = {epsilon:.4f}")
|
|
print(f"p (resonance escape probability) = {p:.4f}")
|
|
print(f"f (thermal utilization) = {f:.4f}")
|
|
print(f"eta (reproduction factor) = {eta:.4f}")
|
|
print(f"k_inf = epsilon * p * f * eta = {k_inf:.4f}")
|
|
|
|
# Problem 2B: Calculate diffusion lengths
|
|
import sympy as sm
|
|
|
|
# Define buckling as a symbol
|
|
B_squared = sm.Symbol('B^2', positive=True)
|
|
|
|
# Calculate diffusion lengths
|
|
# L^2_fast = D_fast / Sigma_total_fast
|
|
# where Sigma_total_fast = Sigma_a_fast + Sigma_s_fast (removal from fast group)
|
|
Sigma_total_fast = Sigma_a_fast + Sigma_s_fast
|
|
L_squared_fast = D_fast / Sigma_total_fast
|
|
|
|
# L^2_th = D_th / Sigma_a_th
|
|
L_squared_th = D_thermal / Sigma_a_thermal
|
|
|
|
print(f"\n=== Problem 2B: Diffusion Lengths ===")
|
|
print(f"L_fast = {np.sqrt(L_squared_fast):.3f} cm")
|
|
print(f"L_thermal = {np.sqrt(L_squared_th):.3f} cm")
|
|
print(f"\nL^2_fast = {L_squared_fast:.3f} cm^2")
|
|
print(f"L^2_thermal = {L_squared_th:.3f} cm^2")
|
|
|
|
# k_eff equation as function of buckling (for reference):
|
|
# k_eff = k_inf / [(L^2_fast * B^2 + 1)(L^2_th * B^2 + 1)]
|
|
# At criticality: k_eff = 1
|
|
k_eff_expr = k_inf / ((L_squared_fast * B_squared + 1) * (L_squared_th * B_squared + 1))
|
|
|
|
print(f"\nCriticality relation:")
|
|
print(f"k_eff = k_inf / [(L^2_fast * B^2 + 1)(L^2_thermal * B^2 + 1)]")
|
|
print(f"k_eff = {k_inf:.4f} / [({L_squared_fast:.3f}*B^2 + 1)({L_squared_th:.3f}*B^2 + 1)]")
|
|
|
|
# Problem 2C: Geometric buckling for rectangular solid
|
|
print(f"\n=== Problem 2C: Geometric Buckling ===")
|
|
print(f"For a rectangular solid with dimensions L_x, L_y, L_z")
|
|
print(f"with flux going to zero at the boundaries (bare reactor):")
|
|
print(f"\nB^2 = (pi/L_x)^2 + (pi/L_y)^2 + (pi/L_z)^2")
|
|
print(f"\nThis is the geometric buckling for the fundamental mode.")
|
|
|
|
# Example calculation with symbolic dimensions
|
|
L_x, L_y, L_z = sm.symbols('L_x L_y L_z', positive=True)
|
|
B_squared_geometric = (sm.pi / L_x)**2 + (sm.pi / L_y)**2 + (sm.pi / L_z)**2
|
|
print(f"\nSymbolic expression:")
|
|
print(f"B^2 = {B_squared_geometric}")
|
|
|
|
# Problem 2D: Critical height of trough
|
|
print(f"\n=== Problem 2D: Critical Height of Trough ===")
|
|
print(f"Given: Width L_x = 150 cm, Length L_y = 200 cm")
|
|
print(f"Find: Height L_z for criticality (k_eff = 1)")
|
|
|
|
# Given dimensions
|
|
L_x_val = 150 # cm
|
|
L_y_val = 200 # cm
|
|
|
|
# At criticality: k_eff = 1 = k_inf / [(L²_fast * B² + 1)(L²_thermal * B² + 1)]
|
|
# Rearranging: (L²_fast * B² + 1)(L²_thermal * B² + 1) = k_inf
|
|
# where: B² = (π/L_x)² + (π/L_y)² + (π/L_z)²
|
|
|
|
# Define L_z as unknown
|
|
L_z_sym = sm.Symbol('L_z', positive=True)
|
|
|
|
# Buckling with known dimensions and unknown height
|
|
B_sq = (sm.pi / L_x_val)**2 + (sm.pi / L_y_val)**2 + (sm.pi / L_z_sym)**2
|
|
|
|
# Criticality equation: k_inf = (L²_fast * B² + 1)(L²_thermal * B² + 1)
|
|
criticality_eq = (L_squared_fast * B_sq + 1) * (L_squared_th * B_sq + 1) - k_inf
|
|
|
|
# Solve for L_z
|
|
L_z_solutions = sm.solve(criticality_eq, L_z_sym)
|
|
|
|
# Filter for positive real solutions
|
|
L_z_critical = None
|
|
for sol in L_z_solutions:
|
|
if sol.is_real and sol > 0:
|
|
L_z_critical = float(sol)
|
|
break
|
|
|
|
if L_z_critical:
|
|
print(f"\nCritical height L_z = {L_z_critical:.2f} cm")
|
|
|
|
# Verify by calculating k_eff
|
|
B_sq_check = (np.pi / L_x_val)**2 + (np.pi / L_y_val)**2 + (np.pi / L_z_critical)**2
|
|
k_eff_check = k_inf / ((L_squared_fast * B_sq_check + 1) * (L_squared_th * B_sq_check + 1))
|
|
print(f"\nVerification: k_eff = {k_eff_check:.6f} (should be 1.0)")
|
|
print(f"Geometric buckling B^2 = {B_sq_check:.6f} cm^-2")
|
|
else:
|
|
print("No positive real solution found!")
|
|
|
|
# Problem 2E: Prompt criticality
|
|
print(f"\n=== Problem 2E: Prompt Critical Height ===")
|
|
BETA = 640e-5 # Delayed neutron fraction
|
|
print(f"Beta (delayed neutron fraction) = {BETA:.6f}")
|
|
|
|
# Prompt criticality occurs when k_eff = 1/(1-beta)
|
|
k_eff_prompt = 1 / (1 - BETA)
|
|
print(f"Prompt critical k_eff = 1/(1-beta) = {k_eff_prompt:.6f}")
|
|
|
|
# Solve for height at prompt criticality
|
|
# k_eff_prompt = k_inf / [(L²_fast * B² + 1)(L²_thermal * B² + 1)]
|
|
# Rearranging: (L²_fast * B² + 1)(L²_thermal * B² + 1) = k_inf / k_eff_prompt
|
|
|
|
L_z_prompt_sym = sm.Symbol('L_z_prompt', positive=True)
|
|
B_sq_prompt = (sm.pi / L_x_val)**2 + (sm.pi / L_y_val)**2 + (sm.pi / L_z_prompt_sym)**2
|
|
|
|
prompt_crit_eq = (L_squared_fast * B_sq_prompt + 1) * (L_squared_th * B_sq_prompt + 1) - k_inf / k_eff_prompt
|
|
|
|
L_z_prompt_solutions = sm.solve(prompt_crit_eq, L_z_prompt_sym)
|
|
|
|
# Filter for positive real solutions
|
|
L_z_prompt = None
|
|
for sol in L_z_prompt_solutions:
|
|
if sol.is_real and sol > 0:
|
|
L_z_prompt = float(sol)
|
|
break
|
|
|
|
if L_z_prompt:
|
|
print(f"\nPrompt critical height L_z = {L_z_prompt:.2f} cm")
|
|
|
|
# Verify
|
|
B_sq_prompt_check = (np.pi / L_x_val)**2 + (np.pi / L_y_val)**2 + (np.pi / L_z_prompt)**2
|
|
k_eff_prompt_check = k_inf / ((L_squared_fast * B_sq_prompt_check + 1) * (L_squared_th * B_sq_prompt_check + 1))
|
|
print(f"\nVerification: k_eff = {k_eff_prompt_check:.6f}")
|
|
print(f"Difference from delayed critical: {L_z_prompt - L_z_critical:.2f} cm")
|
|
else:
|
|
print("No positive real solution found!")
|
|
|
|
# Problem 2F: Effect of people near trough
|
|
print(f"\n=== Problem 2F: Effect of People Near Trough ===")
|
|
print(f"If flux is not zero at edges and people are nearby:")
|
|
print(f" - People act as neutron reflectors/scatterers (water in human body)")
|
|
print(f" - This reduces neutron leakage from the trough")
|
|
print(f" - Reduced leakage → system becomes MORE reactive")
|
|
print(f" - To achieve criticality, LESS fissile material is needed")
|
|
print(f"\nConclusion: Critical height would DECREASE")
|
|
print(f" The actual critical height with people nearby < {L_z_critical:.2f} cm (bare reactor)")
|
|
print(f" This is a SAFETY CONCERN - human reflection can inadvertently make")
|
|
print(f" systems critical at lower liquid levels than calculated!")
|