Reisa/2025AsianB
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

q3

Browse Source
This commit is contained in:
Spasol
2025-11-20 20:27:39 +08:00
parent a99694786a
commit c8609ca320
6 changed files with 3779 additions and 1233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

321
org/chatgpt2/q2_2.py Normal file
View File

@@ -0,0 +1,321 @@
import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import CubicSpline
from scipy.integrate import simpson
import os
# -----------------------------
# Configuration (Update File Path!)
# -----------------------------
DATA_FILE_PATH = "/Users/spasolreisa/IdeaProjects/asiaMath/data.txt" # Replace with your data.txt absolute path
THICKNESSES = [0.5, 1.0, 1.5, 2.0, 2.5, 3.0] # Expand thickness range for evaluation
T_AMBIENT = 300 # Ambient temperature (K)
SOLAR_IRRADIANCE = 1000 # AM1.5 solar irradiance (W/m²)
CONVECTION_COEFF = 10 # Convection coefficient (W/(m²K))
SIGMA = 5.67e-8 # Stefan-Boltzmann constant (W/(m²K⁴))
# -----------------------------
# 1. Fixed Data Parsing Function (Critical Fix for "wl" String Error)
# -----------------------------
def read_split_data(file_path):
"""Read and parse split-format data (wl+n followed by wl+k)"""
if not os.path.exists(file_path):
raise FileNotFoundError(f"File not found: {file_path}")
# Read all lines, skip empty lines and comments
with open(file_path, 'r', encoding='utf-8') as f:
lines = []
for line in f:
stripped = line.strip()
if stripped and not stripped.startswith('#'):
lines.append(stripped)
# Step 1: Identify all headers (lines containing "wl" and either "n" or "k")
header_indices = []
for i, line in enumerate(lines):
parts = line.split()
# Header must be exactly 2 parts: ["wl", "n"] or ["wl", "k"] (case-insensitive)
if len(parts) == 2 and parts[0].lower() == "wl" and parts[1].lower() in ["n", "k"]:
header_indices.append(i)
# Validate: Must have exactly 2 headers (one for n, one for k)
if len(header_indices) != 2:
raise ValueError(
f"Invalid number of headers! Expected 2 (wl+n and wl+k), found {len(header_indices)}.\nCheck data.txt format.")
# Step 2: Split data into n-block and k-block
n_header_idx = header_indices[0]
k_header_idx = header_indices[1]
# Ensure n-header comes before k-header
if n_header_idx > k_header_idx:
n_header_idx, k_header_idx = k_header_idx, n_header_idx
# Extract n data (between n-header and k-header)
n_lines = lines[n_header_idx + 1: k_header_idx]
# Extract k data (after k-header)
k_lines = lines[k_header_idx + 1:]
# Step 3: Parse n data (skip any invalid lines)
wl_n, n_list = [], []
for line in n_lines:
parts = line.split()
# Data line must have exactly 2 numeric parts
if len(parts) != 2:
continue # Skip lines with wrong column count
try:
wl_val = float(parts[0])
n_val = float(parts[1])
wl_n.append(wl_val)
n_list.append(n_val)
except ValueError:
continue # Skip non-numeric lines
# Step 4: Parse k data (skip any invalid lines)
wl_k, k_list = [], []
for line in k_lines:
parts = line.split()
if len(parts) != 2:
continue
try:
wl_val = float(parts[0])
k_val = float(parts[1])
wl_k.append(wl_val)
k_list.append(k_val)
except ValueError:
continue
# Validate: Must have at least 1 data point for n and k
if len(wl_n) == 0:
raise ValueError("No valid n data found! Check the format between wl+n and wl+k headers.")
if len(wl_k) == 0:
raise ValueError("No valid k data found! Check the format after wl+k header.")
# Convert to numpy arrays
wl_n, n_list = np.array(wl_n), np.array(n_list)
wl_k, k_list = np.array(wl_k), np.array(k_list)
# Align wavelengths (if n and k have different wavelength points)
if not np.allclose(wl_n, wl_k, rtol=1e-6):
print("Warning: Wavelengths for n and k do not match. Automatically aligning...")
# Use n's wavelengths as reference, interpolate k to match
k_list = np.interp(wl_n, np.sort(wl_k), k_list[np.argsort(wl_k)])
wl_k = wl_n # Sync k's wavelengths to n's
# Sort by wavelength (ascending) to avoid interpolation errors
sorted_idx = np.argsort(wl_n)
sorted_wl = wl_n[sorted_idx]
sorted_n = n_list[sorted_idx]
sorted_k = k_list[sorted_idx]
print(f"Data loaded successfully: {len(sorted_wl)} valid wavelength points")
print(f"Wavelength range: {sorted_wl.min():.2f}–{sorted_wl.max():.2f} μm")
return sorted_wl, sorted_n, sorted_k
# -----------------------------
# 2. Core Functions (Unchanged)
# -----------------------------
def planck_function(wl, T):
"""Planck's law: Blackbody radiation (W/(m³sr))"""
wl_m = wl * 1e-6 # Convert μm to m
c1 = 3.7418e8 # First radiation constant (Wμm⁴/m²)
c2 = 14388 # Second radiation constant (μmK)
return c1 / (wl_m ** 5 * (np.exp(c2 / (wl * T)) - 1))
def solar_spectrum_am15(wl):
"""AM1.5 global solar irradiance (W/(m²μm))"""
spectrum = np.zeros_like(wl)
mask = (wl >= 0.3) & (wl <= 2.5)
wl_masked = wl[mask]
# Empirical fit to AM1.5 data (valid for 0.3–2.5 μm)
spectrum[mask] = np.where(
wl_masked < 0.5, 800 + 400 * wl_masked,
np.where(wl_masked < 1.0, 1000 - 200 * (wl_masked - 0.5),
np.where(wl_masked < 1.5, 900 - 100 * (wl_masked - 1.0),
750 - 200 * (wl_masked - 1.5)))
)
return spectrum
def fresnel_reflectance(n1, k1, n2, k2):
"""Fresnel reflectance (normal incidence, complex refractive index)"""
m1, m2 = n1 + 1j * k1, n2 + 1j * k2
return np.abs((m1 - m2) / (m1 + m2)) ** 2
def thin_film_optical_properties(n_film, k_film, d, wl):
"""Calculate emissivity (ε), absorptivity (α), transmissivity (T) of thin film"""
R12 = fresnel_reflectance(1.0, 0.0, n_film, k_film) # Air→Film
R23 = fresnel_reflectance(n_film, k_film, 1.0, 0.0) # Film→Air
delta = 2 * np.pi * n_film * d / wl # Phase difference
alpha_abs = 4 * np.pi * k_film * d / wl # Absorption attenuation
# Total reflectance and transmissivity (multiple-beam interference)
R_total = (R12 + R23 * np.exp(-alpha_abs) + 2 * np.sqrt(R12 * R23 * np.exp(-alpha_abs)) * np.cos(2 * delta)) / \
(1 + R12 * R23 * np.exp(-alpha_abs) + 2 * np.sqrt(R12 * R23 * np.exp(-alpha_abs)) * np.cos(2 * delta))
T_total = (1 - R12) * (1 - R23) * np.exp(-alpha_abs) / \
(1 + R12 * R23 * np.exp(-alpha_abs) + 2 * np.sqrt(R12 * R23 * np.exp(-alpha_abs)) * np.cos(2 * delta))
alpha_total = 1 - R_total - T_total # Kirchhoff's law (α=ε for thermal equilibrium)
return alpha_total, R_total, T_total # α=ε for emissivity
# -----------------------------
# 3. Evaluation Model (Unchanged)
# -----------------------------
def evaluate_radiative_cooling(wl_all, n_all, k_all, thickness):
"""Calculate KPIs and comprehensive score for a given PDMS thickness"""
cs_n = CubicSpline(wl_all, n_all)
cs_k = CubicSpline(wl_all, k_all)
# KPI 1: Average Emissivity in 8–13 μm (weighted by Planck function)
wl_window = np.linspace(8, 13, 500)
# Check if data covers the window (otherwise use nearest values)
if wl_all.min() > 8 or wl_all.max() < 13:
print(f"Warning: Data does not fully cover 8–13 μm window. Extrapolating...")
n_window = cs_n(wl_window, extrapolate=True)
k_window = cs_k(wl_window, extrapolate=True)
else:
n_window = cs_n(wl_window)
k_window = cs_k(wl_window)
eps_window, _, _ = thin_film_optical_properties(n_window, k_window, thickness, wl_window)
planck = planck_function(wl_window, T_AMBIENT)
eps_avg = simpson(eps_window * planck, wl_window) / simpson(planck, wl_window)
# KPI 2: Average Solar Absorptivity in 0.3–2.5 μm (weighted by AM1.5)
wl_solar = np.linspace(0.3, 2.5, 500)
if wl_all.min() > 2.5 or wl_all.max() < 0.3:
print(f"Warning: Data does not cover solar spectrum (0.3–2.5 μm). Using default PDMS properties...")
n_solar = np.ones_like(wl_solar) * 1.4 # Typical PDMS n in solar range
k_solar = np.ones_like(wl_solar) * 1e-6 # Typical PDMS k in solar range
else:
n_solar = cs_n(wl_solar, extrapolate=True)
k_solar = cs_k(wl_solar, extrapolate=True)
alpha_solar, _, _ = thin_film_optical_properties(n_solar, k_solar, thickness, wl_solar)
solar_irr = solar_spectrum_am15(wl_solar)
alpha_avg = simpson(alpha_solar * solar_irr, wl_solar) / simpson(solar_irr, wl_solar)
# KPI 3: Maximum Cooling Temperature (ΔT_max)
def heat_flux(T_film):
planck_film = planck_function(wl_window, T_film)
eps_eff = simpson(eps_window * planck_film, wl_window) / simpson(planck_film, wl_window)
return SIGMA * eps_eff * T_film ** 4 - alpha_avg * SOLAR_IRRADIANCE - CONVECTION_COEFF * (T_film - T_AMBIENT)
# Newton-Raphson iteration (stable convergence)
T_film = T_AMBIENT - 10 # Initial guess
for _ in range(50):
q = heat_flux(T_film)
if abs(q) < 1e-3:
break
# Numerical derivative (more stable than analytical)
dq_dT = (heat_flux(T_film + 1e-4) - heat_flux(T_film - 1e-4)) / (2e-4)
T_film -= q / dq_dT
# Prevent unrealistic temperatures
if T_film < 200 or T_film > T_AMBIENT:
T_film = max(200, min(T_AMBIENT - 5, T_film))
delta_T = T_AMBIENT - T_film
# KPI 4: Cooling Efficiency Ratio (η_CR)
eta_cr = eps_avg / (alpha_avg + 0.01) # +0.01 to avoid division by zero
# Comprehensive Score (0–100)
score = 0.0
score += 40 * min(eps_avg, 1.0) # Cap at 1.0 (ideal emissivity)
score += 35 * (1 - min(alpha_avg, 1.0)) # Lower absorption = higher score
score += 15 * min(delta_T / 40, 1.0) # ΔT theoretical upper limit = 40K
score += 10 * min(eta_cr / 100, 1.0) # Cap at 100 (ideal ratio)
return {
"thickness": thickness,
"eps_8-13": eps_avg,
"alpha_0.3-2.5": alpha_avg,
"delta_T_max": delta_T,
"eta_cr": eta_cr,
"comprehensive_score": score
}
# -----------------------------
# 4. Main Execution (Unchanged)
# -----------------------------
if __name__ == "__main__":
try:
# Read data (fixed parsing logic)
wl_all, n_all, k_all = read_split_data(DATA_FILE_PATH)
print("\n" + "-" * 50 + "\n")
# Evaluate each thickness
results = []
for d in THICKNESSES:
res = evaluate_radiative_cooling(wl_all, n_all, k_all, d)
results.append(res)
print(f"Thickness: {d} μm")
print(f" - Avg Emissivity (8–13 μm): {res['eps_8-13']:.4f}")
print(f" - Avg Solar Absorptivity (0.3–2.5 μm): {res['alpha_0.3-2.5']:.4f}")
print(f" - Max Cooling Temperature: {res['delta_T_max']:.2f} K")
print(f" - Cooling Efficiency Ratio: {res['eta_cr']:.2f}")
print(f" - Comprehensive Score: {res['comprehensive_score']:.1f}/100\n")
# Convert results to numpy array for plotting
results_arr = np.array([[
res["thickness"], res["eps_8-13"], res["alpha_0.3-2.5"],
res["delta_T_max"], res["comprehensive_score"]
] for res in results])
# Plot KPIs vs Thickness
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
fig.suptitle("PDMS Thin Film Radiative Cooling Performance vs Thickness", fontsize=16, fontweight='bold')
# Emissivity (8–13 μm)
axes[0, 0].plot(results_arr[:, 0], results_arr[:, 1], 'o-', color='darkred', linewidth=2, markersize=6)
axes[0, 0].set_xlabel("Thickness (μm)", fontsize=12), axes[0, 0].set_ylabel("Avg Emissivity (8–13 μm)",
fontsize=12)
axes[0, 0].grid(True, alpha=0.3), axes[0, 0].set_ylim(0, 1.05)
# Solar Absorptivity (0.3–2.5 μm)
axes[0, 1].plot(results_arr[:, 0], results_arr[:, 2], 's-', color='darkblue', linewidth=2, markersize=6)
axes[0, 1].set_xlabel("Thickness (μm)", fontsize=12), axes[0, 1].set_ylabel(
"Avg Solar Absorptivity (0.3–2.5 μm)", fontsize=12)
axes[0, 1].grid(True, alpha=0.3), axes[0, 1].set_ylim(0, 0.5)
# Max Cooling Temperature
axes[1, 0].plot(results_arr[:, 0], results_arr[:, 3], '^-', color='darkgreen', linewidth=2, markersize=6)
axes[1, 0].set_xlabel("Thickness (μm)", fontsize=12), axes[1, 0].set_ylabel("Max Cooling Temperature (K)",
fontsize=12)
axes[1, 0].grid(True, alpha=0.3)
# Comprehensive Score
axes[1, 1].plot(results_arr[:, 0], results_arr[:, 4], 'd-', color='darkorange', linewidth=2, markersize=6)
axes[1, 1].set_xlabel("Thickness (μm)", fontsize=12), axes[1, 1].set_ylabel("Comprehensive Score (0–100)",
fontsize=12)
axes[1, 1].grid(True, alpha=0.3), axes[1, 1].set_ylim(0, 100)
plt.tight_layout()
plt.savefig("PDMS_radiative_cooling_evaluation.png", dpi=300, bbox_inches='tight')
plt.show()
# Highlight optimal thickness
optimal = max(results, key=lambda x: x["comprehensive_score"])
print("=" * 50)
print(f"Optimal PDMS Thickness: {optimal['thickness']} μm")
print(f"Best Comprehensive Score: {optimal['comprehensive_score']:.1f}/100")
print(
f"Key Performance: ε(8-13μm)={optimal['eps_8-13']:.4f}, α(0.3-2.5μm)={optimal['alpha_0.3-2.5']:.4f}, ΔT={optimal['delta_T_max']:.2f}K")
print("=" * 50)
except Exception as e:
print(f"\nError: {e}")
print("\nTroubleshooting Steps:")
print("1. Check data.txt format: Ensure it has exactly two headers (e.g., 'wl n' and 'wl k')")
print("2. Example valid format:")
print(" wl n")
print(" 0.40 1.41491")
print(" 0.41 1.41403")
print(" ...")
print(" wl k")
print(" 0.40 1.40E-06")
print(" 0.41 1.38E-06")
print("3. Ensure no extra 'wl' strings in data lines (only numbers)")
print("4. Use space or tab as separator (avoid commas)")