391 lines
16 KiB
Python
391 lines
16 KiB
Python
# -----------------------------
|
|
# Question 2: Comprehensive Evaluation of PDMS Thin Film Radiative Cooling Performance
|
|
# -----------------------------
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
from scipy.integrate import simpson
|
|
from scipy.optimize import fsolve
|
|
import pandas as pd
|
|
|
|
from org.use.q1_2 import cs_n, cs_k
|
|
|
|
|
|
# Use previously defined core functions
|
|
# from first_question_core import read_split_data, make_strictly_increasing, thin_film_emissivity, cs_n, cs_k
|
|
|
|
# ==========================
|
|
# Improved Physical Parameters and Environmental Conditions
|
|
# ==========================
|
|
class EnvironmentalConditions:
|
|
"""Environmental conditions parameters class"""
|
|
|
|
def __init__(self):
|
|
# Basic environmental parameters
|
|
self.T_amb = 25 + 273.15 # Ambient temperature (K)
|
|
self.rh = 0.6 # Relative humidity (60%)
|
|
self.wind_speed = 1.0 # Wind speed (m/s)
|
|
self.cloud_cover = 0.1 # Cloud cover (0-1)
|
|
|
|
# Solar radiation parameters
|
|
self.G_sun_total = 1000 # Total solar irradiance (W/m²)
|
|
self.T_sun = 5778 # Sun surface temperature (K)
|
|
|
|
# Convective heat transfer coefficient (based on wind speed)
|
|
self.h_conv = 5 + 3.8 * self.wind_speed # Convective heat transfer coefficient (W/m²·K)
|
|
|
|
|
|
# ==========================
|
|
# Improved Radiation Models
|
|
# ==========================
|
|
def planck_blackbody(wl, T):
|
|
"""Planck blackbody spectral radiance (W/(m²·μm·sr))"""
|
|
h = 6.62607015e-34
|
|
c = 299792458
|
|
k = 1.380649e-23
|
|
wl_m = wl * 1e-6
|
|
|
|
numerator = 2 * h * c ** 2 / (wl_m ** 5)
|
|
denominator = np.exp(h * c / (wl_m * k * T)) - 1
|
|
return numerator / 1e6
|
|
|
|
|
|
def load_AM15_spectrum(wl):
|
|
"""Load standard AM1.5 solar spectrum (approximate implementation)"""
|
|
solar_spec = np.zeros_like(wl)
|
|
|
|
# Main characteristics of solar spectrum (simplified model)
|
|
mask_visible = (wl >= 0.3) & (wl <= 0.78)
|
|
mask_nir = (wl > 0.78) & (wl <= 2.5)
|
|
|
|
# Visible band (peak at 0.5μm)
|
|
if np.any(mask_visible):
|
|
wl_vis = wl[mask_visible]
|
|
solar_spec[mask_visible] = 1.0 * np.exp(-((wl_vis - 0.5) / 0.2) ** 2)
|
|
|
|
# Near-infrared band
|
|
if np.any(mask_nir):
|
|
wl_nir = wl[mask_nir]
|
|
solar_spec[mask_nir] = 0.7 * np.exp(-((wl_nir - 1.0) / 0.5) ** 2)
|
|
|
|
# Normalize to 1000 W/m²
|
|
total_power = simpson(solar_spec, wl)
|
|
solar_spec = solar_spec * 1000 / total_power
|
|
|
|
return solar_spec
|
|
|
|
|
|
def atmospheric_transmittance(wl, humidity=0.6):
|
|
"""Improved atmospheric transmittance model"""
|
|
tau = np.ones_like(wl)
|
|
|
|
# Atmospheric window 8-13μm (high transmittance with fluctuations)
|
|
window_mask = (wl >= 8) & (wl <= 13)
|
|
if np.any(window_mask):
|
|
wl_window = wl[window_mask]
|
|
# Fluctuations within the window, not fixed values
|
|
tau_window = 0.85 + 0.1 * np.sin(2 * np.pi * (wl_window - 8) / 2.5)
|
|
tau[window_mask] = np.clip(tau_window, 0.7, 0.95)
|
|
|
|
# Water vapor absorption bands
|
|
h2o_bands = [(5.5, 7.5, 0.3), (13.5, 16, 0.4), (16, 20, 0.2)]
|
|
for band_start, band_end, absorption in h2o_bands:
|
|
band_mask = (wl >= band_start) & (wl <= band_end)
|
|
if np.any(band_mask):
|
|
tau[band_mask] = tau[band_mask] * (1 - absorption * humidity)
|
|
|
|
# CO2 absorption band (15μm)
|
|
co2_mask = (wl >= 14) & (wl <= 16)
|
|
if np.any(co2_mask):
|
|
tau[co2_mask] = tau[co2_mask] * 0.3
|
|
|
|
# O3 absorption band (9.6μm)
|
|
o3_mask = (wl >= 9.3) & (wl <= 9.9)
|
|
if np.any(o3_mask):
|
|
tau[o3_mask] = tau[o3_mask] * 0.5
|
|
|
|
return tau
|
|
|
|
|
|
def atmospheric_downward_radiation(wl, T_atm, humidity=0.6):
|
|
"""Improved atmospheric downward radiation model"""
|
|
planck_atm = planck_blackbody(wl, T_atm)
|
|
tau_atm = atmospheric_transmittance(wl, humidity)
|
|
# Atmospheric emissivity = 1 - transmittance
|
|
epsilon_atm = 1 - tau_atm
|
|
return planck_atm * epsilon_atm
|
|
|
|
|
|
# ==========================
|
|
# Core Cooling Performance Evaluation
|
|
# ==========================
|
|
def calculate_comprehensive_cooling_metrics(d, env_conditions):
|
|
"""Comprehensive cooling performance evaluation"""
|
|
# Define calculation wavelength range
|
|
wl_calc = np.linspace(0.3, 20, 2000)
|
|
|
|
# Get material optical properties
|
|
n_film = cs_n(wl_calc)
|
|
k_film = cs_k(wl_calc)
|
|
epsilon = thin_film_emissivity(n_film, k_film, d, wl_calc)
|
|
alpha = epsilon # Kirchhoff's law
|
|
|
|
# Calculate energy components
|
|
# 1. Solar radiation absorption
|
|
solar_spec = load_AM15_spectrum(wl_calc)
|
|
P_sun = simpson(alpha * solar_spec, wl_calc)
|
|
|
|
# 2. Atmospheric radiation absorption
|
|
atm_spec = atmospheric_downward_radiation(wl_calc, env_conditions.T_amb, env_conditions.rh)
|
|
P_atm = simpson(alpha * atm_spec, wl_calc)
|
|
|
|
def radiative_cooling_power(T_film):
|
|
planck_film = planck_blackbody(wl_calc, T_film)
|
|
# 应该乘以立体角π（对半球积分），不是乘以π
|
|
return simpson(epsilon * planck_film, wl_calc) * np.pi
|
|
# 4. Initial net cooling power (T_film = T_amb)
|
|
P_rad_initial = radiative_cooling_power(env_conditions.T_amb)
|
|
P_net_initial = P_rad_initial - (P_sun + P_atm)
|
|
|
|
# 5. Solve equilibrium temperature
|
|
def net_power_balance(T_film):
|
|
P_rad = radiative_cooling_power(T_film) # 表面向外辐射
|
|
P_atm_absorb = P_atm # 大气辐射吸收（在环境温度下计算）
|
|
P_sun_absorb = P_sun # 太阳辐射吸收
|
|
P_conv = env_conditions.h_conv * (T_film - env_conditions.T_amb)
|
|
|
|
# 能量平衡：辐射冷却功率 = 吸收的大气辐射 + 吸收的太阳辐射 + 对流换热
|
|
return P_rad - P_atm_absorb - P_sun_absorb - P_conv
|
|
try:
|
|
T_eq = fsolve(net_power_balance, env_conditions.T_amb - 10)[0]
|
|
delta_T = T_eq - env_conditions.T_amb # Temperature change (K)
|
|
except:
|
|
T_eq = env_conditions.T_amb
|
|
delta_T = 0
|
|
|
|
# 6. Calculate maximum cooling power (at lower temperatures)
|
|
T_test = np.linspace(env_conditions.T_amb - 50, env_conditions.T_amb, 100)
|
|
P_net_values = [net_power_balance(T) for T in T_test]
|
|
P_cooling_max = max(P_net_values) if P_net_values else 0
|
|
|
|
# 7. Calculate atmospheric window utilization
|
|
wl_window = np.linspace(8, 13, 200)
|
|
epsilon_window = thin_film_emissivity(cs_n(wl_window), cs_k(wl_window), d, wl_window)
|
|
window_efficiency = np.mean(epsilon_window)
|
|
|
|
# 8. Solar reflectance (visible band)
|
|
wl_visible = np.linspace(0.38, 0.78, 100)
|
|
alpha_visible = thin_film_emissivity(cs_n(wl_visible), cs_k(wl_visible), d, wl_visible)
|
|
solar_reflectance = 1 - np.mean(alpha_visible)
|
|
|
|
return {
|
|
'Thickness_μm': d,
|
|
'Net_Cooling_Power_Wm2': P_net_initial,
|
|
'Max_Cooling_Power_Wm2': P_cooling_max,
|
|
'Equilibrium_Temp_C': T_eq - 273.15,
|
|
'Temperature_Reduction_C': delta_T,
|
|
'Solar_Absorption_Wm2': P_sun,
|
|
'Atmospheric_Absorption_Wm2': P_atm,
|
|
'Window_Efficiency': window_efficiency,
|
|
'Solar_Reflectance': solar_reflectance,
|
|
'Convection_Coefficient_Wm2K': env_conditions.h_conv
|
|
}
|
|
|
|
|
|
# ==========================
|
|
# Multi-Environment Analysis
|
|
# ==========================
|
|
def analyze_environmental_impact(d):
|
|
"""Analyze performance under different environmental conditions"""
|
|
environments = {
|
|
'Standard': EnvironmentalConditions(),
|
|
'High_Humidity': EnvironmentalConditions(),
|
|
'Windy': EnvironmentalConditions(),
|
|
'Cloudy': EnvironmentalConditions()
|
|
}
|
|
|
|
# Set different environmental parameters
|
|
environments['High_Humidity'].rh = 0.9
|
|
environments['Windy'].wind_speed = 5.0
|
|
environments['Windy'].h_conv = 5 + 3.8 * 5.0
|
|
environments['Cloudy'].cloud_cover = 0.8
|
|
environments['Cloudy'].G_sun_total = 200 # Reduced solar radiation on cloudy days
|
|
|
|
results = {}
|
|
for name, env in environments.items():
|
|
results[name] = calculate_comprehensive_cooling_metrics(d, env)
|
|
|
|
return results
|
|
|
|
|
|
# ==========================
|
|
# Main Execution
|
|
# ==========================
|
|
def main():
|
|
print("=== Question 2: Comprehensive Evaluation of PDMS Thin Film Radiative Cooling Performance ===")
|
|
|
|
# Define thickness range
|
|
thicknesses = [0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
|
|
env_std = EnvironmentalConditions()
|
|
|
|
# Calculate performance for all thicknesses
|
|
all_results = []
|
|
for d in thicknesses:
|
|
result = calculate_comprehensive_cooling_metrics(d, env_std)
|
|
all_results.append(result)
|
|
|
|
# Convert to DataFrame for analysis
|
|
df_results = pd.DataFrame(all_results)
|
|
|
|
# Output detailed results
|
|
print("\n=== Cooling Performance Comparison of Different PDMS Film Thicknesses ===")
|
|
print(df_results.round(3))
|
|
|
|
# Find optimal thickness
|
|
best_cooling_idx = df_results['Net_Cooling_Power_Wm2'].idxmax()
|
|
best_temp_idx = df_results['Temperature_Reduction_C'].idxmin()
|
|
|
|
best_cooling = df_results.iloc[best_cooling_idx]
|
|
best_temp = df_results.iloc[best_temp_idx]
|
|
|
|
print(f"\n=== Optimal Performance Analysis ===")
|
|
print(
|
|
f"Maximum net cooling power: {best_cooling['Thickness_μm']}μm, Power: {best_cooling['Net_Cooling_Power_Wm2']:.2f} W/m²")
|
|
print(
|
|
f"Lowest equilibrium temperature: {best_temp['Thickness_μm']}μm, Temperature: {best_temp['Equilibrium_Temp_C']:.2f}°C")
|
|
print(f"Maximum temperature reduction: {abs(best_temp['Temperature_Reduction_C']):.2f}°C")
|
|
|
|
# Environmental sensitivity analysis (using optimal thickness)
|
|
optimal_thickness = best_cooling['Thickness_μm']
|
|
print(f"\n=== Environmental Sensitivity Analysis (Thickness: {optimal_thickness}μm) ===")
|
|
env_results = analyze_environmental_impact(optimal_thickness)
|
|
|
|
for env_name, result in env_results.items():
|
|
print(f"{env_name}: Net cooling power = {result['Net_Cooling_Power_Wm2']:.2f} W/m², "
|
|
f"Equilibrium temperature = {result['Equilibrium_Temp_C']:.2f}°C")
|
|
|
|
# Visualize results
|
|
plot_comprehensive_results(df_results, env_results)
|
|
|
|
# Output technical recommendations
|
|
provide_technical_recommendations(df_results, env_results, optimal_thickness)
|
|
|
|
|
|
def plot_comprehensive_results(df_results, env_results):
|
|
"""Plot comprehensive results"""
|
|
fig, axes = plt.subplots(2, 3, figsize=(18, 12))
|
|
|
|
# Subplot 1: Net cooling power vs thickness
|
|
axes[0, 0].plot(df_results['Thickness_μm'], df_results['Net_Cooling_Power_Wm2'], 'o-', linewidth=3, markersize=8)
|
|
axes[0, 0].set_xlabel('Film Thickness (μm)')
|
|
axes[0, 0].set_ylabel('Net Cooling Power (W/m²)')
|
|
axes[0, 0].set_title('Net Cooling Power vs Thickness')
|
|
axes[0, 0].grid(True, alpha=0.3)
|
|
axes[0, 0].axhline(y=0, color='red', linestyle='--', alpha=0.7)
|
|
|
|
# Subplot 2: Equilibrium temperature vs thickness
|
|
axes[0, 1].plot(df_results['Thickness_μm'], df_results['Equilibrium_Temp_C'], 's-', linewidth=3, markersize=8,
|
|
color='orange')
|
|
axes[0, 1].set_xlabel('Film Thickness (μm)')
|
|
axes[0, 1].set_ylabel('Equilibrium Temperature (°C)')
|
|
axes[0, 1].set_title('Equilibrium Temperature vs Thickness')
|
|
axes[0, 1].grid(True, alpha=0.3)
|
|
axes[0, 1].axhline(y=25, color='red', linestyle='--', alpha=0.7, label='Ambient Temp')
|
|
|
|
# Subplot 3: Atmospheric window utilization
|
|
axes[0, 2].plot(df_results['Thickness_μm'], df_results['Window_Efficiency'], '^-', linewidth=3, markersize=8,
|
|
color='green')
|
|
axes[0, 2].set_xlabel('Film Thickness (μm)')
|
|
axes[0, 2].set_ylabel('Atmospheric Window Efficiency')
|
|
axes[0, 2].set_title('8-13μm Atmospheric Window Emissivity')
|
|
axes[0, 2].grid(True, alpha=0.3)
|
|
|
|
# Subplot 4: Solar reflectance
|
|
axes[1, 0].plot(df_results['Thickness_μm'], df_results['Solar_Reflectance'], 'd-', linewidth=3, markersize=8,
|
|
color='purple')
|
|
axes[1, 0].set_xlabel('Film Thickness (μm)')
|
|
axes[1, 0].set_ylabel('Visible Light Reflectance')
|
|
axes[1, 0].set_title('Solar Reflectance vs Thickness')
|
|
axes[1, 0].grid(True, alpha=0.3)
|
|
|
|
# Subplot 5: Environmental sensitivity
|
|
env_names = list(env_results.keys())
|
|
cooling_powers = [env_results[name]['Net_Cooling_Power_Wm2'] for name in env_names]
|
|
axes[1, 1].bar(env_names, cooling_powers, color=['blue', 'green', 'orange', 'red'], alpha=0.7)
|
|
axes[1, 1].set_ylabel('Net Cooling Power (W/m²)')
|
|
axes[1, 1].set_title('Cooling Performance under Different Conditions')
|
|
axes[1, 1].tick_params(axis='x', rotation=45)
|
|
axes[1, 1].axhline(y=0, color='black', linestyle='--', alpha=0.5)
|
|
|
|
# Subplot 6: Energy component breakdown (optimal thickness)
|
|
best_idx = df_results['Net_Cooling_Power_Wm2'].idxmax()
|
|
best_result = df_results.iloc[best_idx]
|
|
components = ['Radiative Cooling', 'Solar Absorption', 'Atmospheric Absorption']
|
|
values = [best_result['Net_Cooling_Power_Wm2'] + best_result['Solar_Absorption_Wm2'] + best_result[
|
|
'Atmospheric_Absorption_Wm2'],
|
|
-best_result['Solar_Absorption_Wm2'],
|
|
-best_result['Atmospheric_Absorption_Wm2']]
|
|
colors = ['green', 'red', 'orange']
|
|
axes[1, 2].bar(components, values, color=colors, alpha=0.7)
|
|
axes[1, 2].set_ylabel('Power (W/m²)')
|
|
axes[1, 2].set_title(f'Energy Balance Breakdown (Thickness: {best_result["Thickness_μm"]}μm)')
|
|
axes[1, 2].axhline(y=0, color='black', linestyle='-', alpha=0.8)
|
|
|
|
plt.tight_layout()
|
|
plt.savefig('PDMS_comprehensive_cooling_analysis.png', dpi=300, bbox_inches='tight')
|
|
plt.show()
|
|
|
|
|
|
def provide_technical_recommendations(df_results, env_results, optimal_thickness):
|
|
"""Provide detailed technical recommendations"""
|
|
print("\n" + "=" * 80)
|
|
print("=== Radiative Cooling Technology Development and Application Recommendations ===")
|
|
print("=" * 80)
|
|
|
|
best_result = df_results[df_results['Thickness_μm'] == optimal_thickness].iloc[0]
|
|
|
|
print("1. Optimal Thickness Selection:")
|
|
print(f" • Recommended thickness: {optimal_thickness} μm")
|
|
print(f" • Performance metrics: Net cooling power {best_result['Net_Cooling_Power_Wm2']:.2f} W/m², "
|
|
f"Equilibrium temperature {best_result['Equilibrium_Temp_C']:.2f} °C")
|
|
print(f" • Technical advantages: Atmospheric window efficiency {best_result['Window_Efficiency']:.3f}, "
|
|
f"Solar reflectance {best_result['Solar_Reflectance']:.3f}")
|
|
|
|
print("\n2. Environmental Adaptability Analysis:")
|
|
for env_name, result in env_results.items():
|
|
power = result['Net_Cooling_Power_Wm2']
|
|
temp = result['Equilibrium_Temp_C']
|
|
print(f" • {env_name}: Net power {power:.2f} W/m², Equilibrium temperature {temp:.2f} °C")
|
|
|
|
print("\n3. Technical Improvement Directions:")
|
|
print(
|
|
" • Optical performance optimization: Enhance 8-13μm emissivity through surface microstructure or nanoparticle doping")
|
|
print(" • Solar reflection enhancement: Add visible light reflection layers to reduce solar absorption")
|
|
print(" • Environmental robustness: Develop composite materials adaptable to high humidity and cloudy conditions")
|
|
|
|
print("\n4. Application Scenarios:")
|
|
print(
|
|
" • Building energy efficiency: Building facades, roof coatings, expected to reduce AC energy consumption by 15-25%")
|
|
print(" • Electronic device cooling: Server rooms, photovoltaic panel cooling")
|
|
print(" • Personal thermal management: Smart textiles, wearable devices")
|
|
print(" • Special applications: Cold chain logistics, agricultural greenhouse cooling")
|
|
|
|
print("\n5. Industrialization Development Path:")
|
|
print(" • Short-term (1-2 years): Optimize PDMS film fabrication process, reduce costs")
|
|
print(" • Medium-term (2-3 years): Develop multilayer composite structures, improve performance")
|
|
print(" • Long-term (3-5 years): Achieve integration of intelligent radiative cooling systems")
|
|
|
|
|
|
# ==========================
|
|
# Mock core functions for testing (replace with actual implementations)
|
|
# ==========================
|
|
def thin_film_emissivity(n_film, k_film, d, wl):
|
|
"""Mock implementation - replace with actual function"""
|
|
# Simplified implementation for testing
|
|
R = 0.1 # Approximate reflectance
|
|
alpha = 4 * np.pi * k_film * d / wl
|
|
T = np.exp(-alpha)
|
|
return 1 - R - T
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main() |