Programming & Simulation

# NIST SP 800-90B Implementation
from PIL import Image
import numpy as np
from collections import Counter
import math

def min_entropy_test(image_path):
    image = Image.open(image_path).convert('L')
    data = np.array(image).flatten()
    
    # Calculate Min-Entropy
    p_max = max(Counter(data).values()) / len(data)
    min_entropy = -math.log2(p_max)
    
    return min_entropy

def chi_square_test(data):
    observed = Counter(data)
    expected = len(data) / len(observed)
    chi_sq = sum((obs - expected)**2 / expected 
                 for obs in observed.values())
    return chi_sq

# Reproducibility Test (10 iterations)
for i in range(10):
    entropy = min_entropy_test(image_path)
    print(f"Iteration {i+1}: {entropy:.4f}")

# RSoft Data Automation Pipeline
import os
import re
import pandas as pd

def extract_number(filename):
    """Extract parameter from filename"""
    match = re.search(r'(\d+)_m6_absorption\.dat', 
                      filename)
    return int(match.group(1)) if match else -1

# Load and merge 50+ simulation files
path = '/simulation_results'
files = [f for f in os.listdir(path) 
         if f.endswith('.dat')]
files.sort(key=extract_number)

all_data = pd.DataFrame()

for file in files:
    data = pd.read_csv(f'{path}/{file}', 
                       skiprows=2, header=None)
    num = extract_number(file)
    all_data[f'Param_{num}'] = data.iloc[:, 0]

# Export to Excel
all_data.to_excel('merged_results.xlsx')

# SEM Image Particle Analysis
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Load and preprocess SEM image
image = cv2.imread('sem_image.tif', 0)
_, thresh = cv2.threshold(image, 127, 255, 
                          cv2.THRESH_BINARY)

# Morphological operations
kernel = np.ones((3,3), np.uint8)
opening = cv2.morphologyEx(thresh, 
                           cv2.MORPH_OPEN, kernel)

# Contour detection
contours, _ = cv2.findContours(opening, 
                               cv2.RETR_EXTERNAL,
                               cv2.CHAIN_APPROX_SIMPLE)

particle_sizes = []
for cnt in contours:
    if cv2.contourArea(cnt) > min_area:
        # Fit ellipse and calculate dimensions
        ellipse = cv2.fitEllipse(cnt)
        major_axis, minor_axis = ellipse[1]
        particle_sizes.append(major_axis)

print(f"Analyzed {len(particle_sizes)} particles")
plt.hist(particle_sizes, bins=50)

// Transfer Matrix Method in React
const calculateTMM = (layers, wavelength) => {
  let M = [[1, 0], [0, 1]]; // Identity matrix
  const n_air = 1.0;
  
  layers.forEach(layer => {
    const { material, thickness } = layer;
    const n = getRefractiveIndex(material, wavelength);
    
    // Phase shift
    const delta = (2 * Math.PI * n * thickness) / wavelength;
    
    // Characteristic matrix
    const cos_d = Math.cos(delta);
    const sin_d = Math.sin(delta);
    
    const M_layer = [
      [cos_d, sin_d / n],
      [n * sin_d, cos_d]
    ];
    
    M = matrixMultiply(M, M_layer);
  });
  
  // Calculate reflectance
  const r = calculateReflection(M, n_air, n_substrate);
  return Math.pow(Math.abs(r), 2) * 100;
};