Chapter 4: Properties and Characterization

import numpy as np
import matplotlib.pyplot as plt

def calculate_yield_strength(contributions):
    """
    Calculate total yield strength from individual contributions.

    Uses linear superposition (simplification; more complex models exist)

    Parameters:
    -----------
    contributions : dict
        Dictionary with strengthening mechanism names and values (MPa)

    Returns:
    --------
    float : Total yield strength (MPa)
    """
    total = sum(contributions.values())
    return total

def calculate_solid_solution_strength(elements, compositions, atomic_radii, shear_modulus=80e3):
    """
    Calculate solid solution strengthening for HEA.

    Parameters:
    -----------
    elements : list
        Element names
    compositions : array-like
        Mole fractions
    atomic_radii : array-like
        Atomic radii (Angstroms)
    shear_modulus : float
        Average shear modulus (MPa)

    Returns:
    --------
    float : Solid solution strengthening contribution (MPa)
    """
    x = np.array(compositions)
    r = np.array(atomic_radii)

    # Average radius
    r_avg = np.sum(x * r)

    # Size misfit parameter
    delta = np.sqrt(np.sum(x * (r/r_avg - 1)**2))

    # Strengthening (simplified Labusch model)
    A = 0.04  # Proportionality constant
    delta_sigma = A * shear_modulus * delta

    return delta_sigma

# Analysis for Cantor alloy
elements = ['Co', 'Cr', 'Fe', 'Mn', 'Ni']
compositions = [0.2, 0.2, 0.2, 0.2, 0.2]
radii = [1.252, 1.249, 1.241, 1.350, 1.246]  # Angstroms

ss_strength = calculate_solid_solution_strength(elements, compositions, radii)

# Contribution breakdown
contributions = {
    'Lattice friction': 45,       # Peierls stress
    'Solid solution': ss_strength,
    'Grain boundary (d=50μm)': 60, # Hall-Petch
    'Forest hardening': 20,        # Initial dislocation density
}

total_ys = calculate_yield_strength(contributions)

print("=== Yield Strength Analysis: Cantor Alloy ===")
print(f"\nStrengthening contributions:")
for mechanism, value in contributions.items():
    print(f"  {mechanism}: {value:.0f} MPa ({value/total_ys*100:.1f}%)")
print(f"\n  Total predicted yield strength: {total_ys:.0f} MPa")
print(f"  Experimental range: 200-250 MPa")

# Visualization: Ashby plot
fig, ax = plt.subplots(figsize=(10, 8))

# Material data (yield strength vs elongation)
materials = {
    'CoCrFeMnNi (annealed)': (225, 60),
    'CoCrFeMnNi (cold worked)': (900, 15),
    'AlCoCrFeNi (FCC)': (350, 35),
    'AlCoCrFeNi (BCC)': (600, 10),
    'AlCoCrFeNi₂.₁ (EHEA)': (800, 20),
    'WMoTaNb (RHEA)': (1100, 3),
    '316 SS': (250, 50),
    'Inconel 718': (1100, 20),
    'Ti-6Al-4V': (950, 14),
    '7075-T6 Al': (500, 10),
}

colors = {
    'CoCrFeMnNi': '#3498db',
    'AlCoCrFeNi': '#e74c3c',
    'EHEA': '#27ae60',
    'RHEA': '#9b59b6',
    'Conventional': '#95a5a6'
}

for name, (ys, elong) in materials.items():
    if 'CoCrFeMnNi' in name:
        c = colors['CoCrFeMnNi']
    elif 'AlCoCrFeNi' in name and 'EHEA' not in name:
        c = colors['AlCoCrFeNi']
    elif 'EHEA' in name:
        c = colors['EHEA']
    elif 'RHEA' in name or 'WMo' in name:
        c = colors['RHEA']
    else:
        c = colors['Conventional']

    ax.scatter(elong, ys, s=150, c=c, edgecolors='black', linewidth=1.5,
               label=name if name in ['CoCrFeMnNi (annealed)', 'AlCoCrFeNi₂.₁ (EHEA)',
                                       'WMoTaNb (RHEA)', '316 SS'] else '')
    ax.annotate(name, (elong, ys), textcoords="offset points",
                xytext=(5, 5), fontsize=8)

ax.set_xlabel('Elongation (%)', fontsize=12)
ax.set_ylabel('Yield Strength (MPa)', fontsize=12)
ax.set_title('Strength-Ductility Trade-off in HEAs vs Conventional Alloys', fontsize=14)
ax.legend(loc='upper right')
ax.grid(True, alpha=0.3)
ax.set_xlim(0, 70)
ax.set_ylim(0, 1300)

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def callaway_thermal_conductivity(T, theta_D, v_s, V_atom, mass_variance, strain_variance):
    """
    Calculate lattice thermal conductivity using simplified Callaway model.

    Parameters:
    -----------
    T : float or array
        Temperature (K)
    theta_D : float
        Debye temperature (K)
    v_s : float
        Sound velocity (m/s)
    V_atom : float
        Atomic volume (m³)
    mass_variance : float
        Mass fluctuation parameter
    strain_variance : float
        Strain fluctuation parameter

    Returns:
    --------
    float or array : Lattice thermal conductivity (W/m·K)
    """
    k_B = 1.381e-23  # Boltzmann constant
    hbar = 1.055e-34  # Reduced Planck constant

    # Phonon mean free path limited by point defects
    omega_D = k_B * theta_D / hbar

    # Scattering parameter (simplified)
    Gamma = mass_variance + strain_variance

    # Phonon mean free path
    l_ph = v_s / (Gamma * omega_D * (T/theta_D)**4)  # Simplified

    # Thermal conductivity (kinetic theory)
    C_v = 3 * k_B / V_atom  # Heat capacity per volume at high T
    kappa_L = (1/3) * C_v * v_s * l_ph

    return kappa_L

# Calculate mass variance for Cantor alloy
def mass_variance_parameter(elements, compositions, masses):
    """Calculate Klemens mass variance parameter."""
    x = np.array(compositions)
    M = np.array(masses)
    M_avg = np.sum(x * M)

    Gamma_M = np.sum(x * (1 - M/M_avg)**2)
    return Gamma_M

# Cantor alloy
elements = ['Co', 'Cr', 'Fe', 'Mn', 'Ni']
compositions = [0.2, 0.2, 0.2, 0.2, 0.2]
masses = [58.93, 52.00, 55.85, 54.94, 58.69]  # g/mol

Gamma_M = mass_variance_parameter(elements, compositions, masses)
print(f"Mass variance parameter for CoCrFeMnNi: {Gamma_M:.4f}")

# Compare thermal conductivity
fig, ax = plt.subplots(figsize=(10, 6))

T_range = np.linspace(100, 800, 50)

# Pure Ni (reference)
kappa_Ni = 90 * (300/T_range)**0.5  # Approximate

# Cantor alloy (experimental data approximation)
kappa_HEA = 12 + 0.008 * T_range  # Low, nearly T-independent

# HE carbide (very low)
kappa_HEC = 5 + 0.005 * T_range

ax.plot(T_range, kappa_Ni, 'b--', linewidth=2, label='Pure Ni')
ax.plot(T_range, kappa_HEA, 'r-', linewidth=2, label='CoCrFeMnNi HEA')
ax.plot(T_range, kappa_HEC, 'g-', linewidth=2, label='(TiZrHfNbTa)C HEC')

ax.set_xlabel('Temperature (K)', fontsize=12)
ax.set_ylabel('Thermal Conductivity (W/m·K)', fontsize=12)
ax.set_title('Thermal Conductivity Comparison', fontsize=14)
ax.legend()
ax.grid(True, alpha=0.3)
ax.set_xlim(100, 800)
ax.set_ylim(0, 100)

plt.tight_layout()
plt.show()

print("\n=== Thermal Conductivity Summary ===")
print("  Pure Ni at 300K: ~90 W/m·K")
print("  CoCrFeMnNi at 300K: ~12-15 W/m·K (>80% reduction)")
print("  HE carbides: ~5-10 W/m·K (ultra-low)")

import numpy as np
import matplotlib.pyplot as plt

def thermoelectric_figure_of_merit(S, sigma, kappa, T):
    """
    Calculate thermoelectric figure of merit ZT.

    Parameters:
    -----------
    S : float
        Seebeck coefficient (V/K)
    sigma : float
        Electrical conductivity (S/m)
    kappa : float
        Thermal conductivity (W/m·K)
    T : float
        Temperature (K)

    Returns:
    --------
    float : ZT value
    """
    return (S**2 * sigma * T) / kappa

# Compare thermoelectric properties
materials = {
    'Bi₂Te₃': {'S': 200e-6, 'sigma': 1e5, 'kappa': 1.5, 'T_opt': 350},
    'PbTe': {'S': 250e-6, 'sigma': 2e4, 'kappa': 2.0, 'T_opt': 600},
    'HE Half-Heusler': {'S': 180e-6, 'sigma': 5e4, 'kappa': 3.5, 'T_opt': 800},
    'HE Chalcogenide': {'S': 220e-6, 'sigma': 3e4, 'kappa': 0.8, 'T_opt': 500},
}

print("=== Thermoelectric Properties of HE Materials ===")
print(f"{'Material':<20} {'S (μV/K)':<12} {'σ (S/m)':<12} {'κ (W/mK)':<10} {'ZT':<8}")
print("-" * 65)

for name, props in materials.items():
    ZT = thermoelectric_figure_of_merit(props['S'], props['sigma'],
                                         props['kappa'], props['T_opt'])
    print(f"{name:<20} {props['S']*1e6:<12.0f} {props['sigma']:<12.0e} {props['kappa']:<10.1f} {ZT:<8.2f}")

# Visualization
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# ZT vs Temperature for different materials
ax1 = axes[0]
T_range = np.linspace(300, 1000, 100)

for name, props in materials.items():
    # Simplified temperature dependence
    ZT_T = thermoelectric_figure_of_merit(
        props['S'] * (T_range/props['T_opt'])**0.3,
        props['sigma'] * (props['T_opt']/T_range)**0.5,
        props['kappa'] * (T_range/300)**0.2,
        T_range
    )
    ax1.plot(T_range, ZT_T, linewidth=2, label=name)

ax1.axhline(y=1, color='gray', linestyle='--', alpha=0.7, label='ZT = 1 (benchmark)')
ax1.set_xlabel('Temperature (K)', fontsize=12)
ax1.set_ylabel('ZT', fontsize=12)
ax1.set_title('Thermoelectric Figure of Merit', fontsize=14)
ax1.legend(loc='upper left')
ax1.grid(True, alpha=0.3)
ax1.set_xlim(300, 1000)
ax1.set_ylim(0, 2)

# Benefit of HE approach: reduced thermal conductivity
ax2 = axes[1]
elements_kappa = {'Pb': 35, 'Te': 2.5, 'Bi': 8, 'Sb': 24, 'Se': 0.5}
he_kappa = 0.8

labels = list(elements_kappa.keys()) + ['HE\nChalcogenide']
values = list(elements_kappa.values()) + [he_kappa]
colors = ['#3498db']*len(elements_kappa) + ['#e74c3c']

bars = ax2.bar(labels, values, color=colors, edgecolor='black', linewidth=1)
ax2.set_ylabel('Thermal Conductivity (W/m·K)', fontsize=12)
ax2.set_title('Thermal Conductivity Reduction in HE Chalcogenides', fontsize=14)
ax2.grid(axis='y', alpha=0.3)

for bar, val in zip(bars, values):
    ax2.text(bar.get_x() + bar.get_width()/2, val + 0.5,
             f'{val:.1f}', ha='center', fontsize=10)

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def vegards_law_lattice_parameter(elements, compositions, lattice_params):
    """
    Estimate lattice parameter using Vegard's law.

    Parameters:
    -----------
    elements : list
        Element names
    compositions : array-like
        Mole fractions
    lattice_params : array-like
        Pure element lattice parameters (Angstroms)

    Returns:
    --------
    float : Estimated lattice parameter
    """
    x = np.array(compositions)
    a = np.array(lattice_params)
    return np.sum(x * a)

def bragg_angle(d_spacing, wavelength=1.5406):
    """
    Calculate 2theta from d-spacing using Bragg's law.

    Parameters:
    -----------
    d_spacing : float
        d-spacing in Angstroms
    wavelength : float
        X-ray wavelength (Cu Ka = 1.5406 A)

    Returns:
    --------
    float : 2theta in degrees
    """
    if d_spacing < wavelength / 2:
        return None
    sin_theta = wavelength / (2 * d_spacing)
    theta = np.arcsin(sin_theta)
    return 2 * np.degrees(theta)

def fcc_d_spacings(a):
    """Calculate d-spacings for FCC reflections."""
    reflections = {
        '111': np.sqrt(3),
        '200': 2,
        '220': np.sqrt(8),
        '311': np.sqrt(11),
        '222': np.sqrt(12),
    }
    return {hkl: a / np.sqrt(h2kl2) for hkl, h2kl2 in reflections.items()}

# Simulate XRD pattern for Cantor alloy
# FCC lattice parameters for pure elements
elements = ['Co', 'Cr', 'Fe', 'Mn', 'Ni']
compositions = [0.2, 0.2, 0.2, 0.2, 0.2]
# FCC lattice parameters (some elements are not FCC, use estimates)
lattice_params = [3.544, 3.68, 3.59, 3.86, 3.524]  # Angstroms (approximate)

a_predicted = vegards_law_lattice_parameter(elements, compositions, lattice_params)
a_experimental = 3.59  # Experimental value for CoCrFeMnNi

print("=== XRD Analysis: Cantor Alloy ===")
print(f"Vegard's law prediction: a = {a_predicted:.3f} Å")
print(f"Experimental value: a = {a_experimental:.3f} Å")
print(f"Deviation: {(a_experimental - a_predicted)/a_predicted * 100:.1f}%")

# Calculate peak positions
d_spacings = fcc_d_spacings(a_experimental)
print("\nFCC reflection positions (Cu Kα):")
for hkl, d in d_spacings.items():
    two_theta = bragg_angle(d)
    if two_theta:
        print(f"  ({hkl}): d = {d:.3f} Å, 2θ = {two_theta:.2f}°")

# Simulate XRD pattern
fig, ax = plt.subplots(figsize=(12, 5))

two_theta_range = np.linspace(30, 100, 1000)
intensity = np.zeros_like(two_theta_range)

# Add peaks with pseudo-Voigt profile
peak_intensities = {'111': 100, '200': 45, '220': 25, '311': 30, '222': 10}

def pseudo_voigt(x, x0, fwhm, intensity, eta=0.5):
    """Pseudo-Voigt peak profile."""
    gaussian = np.exp(-4 * np.log(2) * ((x - x0) / fwhm)**2)
    lorentzian = 1 / (1 + 4 * ((x - x0) / fwhm)**2)
    return intensity * (eta * lorentzian + (1 - eta) * gaussian)

for hkl, d in d_spacings.items():
    two_theta = bragg_angle(d)
    if two_theta and 30 <= two_theta <= 100:
        # Broader peaks for HEA due to lattice distortion
        fwhm = 0.5  # Degrees (broader than pure metal)
        intensity += pseudo_voigt(two_theta_range, two_theta, fwhm,
                                   peak_intensities[hkl])
        ax.annotate(f'({hkl})', (two_theta, peak_intensities[hkl] + 5),
                   ha='center', fontsize=10)

ax.plot(two_theta_range, intensity, 'b-', linewidth=1.5)
ax.fill_between(two_theta_range, intensity, alpha=0.3)

ax.set_xlabel('2θ (degrees)', fontsize=12)
ax.set_ylabel('Intensity (a.u.)', fontsize=12)
ax.set_title('Simulated XRD Pattern: CoCrFeMnNi (FCC)', fontsize=14)
ax.set_xlim(30, 100)
ax.set_ylim(0, 120)
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# Demonstrate ML-based property prediction concept
# (Simplified example - real ML models require extensive training data)

def featurize_hea(elements, compositions, element_features):
    """
    Create feature vector for HEA composition.

    Parameters:
    -----------
    elements : list
        Element symbols
    compositions : array-like
        Mole fractions
    element_features : dict
        Dictionary of element properties

    Returns:
    --------
    array : Feature vector
    """
    x = np.array(compositions)

    features = []

    # Weighted averages
    for prop in ['VEC', 'radius', 'Tm', 'electronegativity']:
        values = np.array([element_features[el][prop] for el in elements])
        features.append(np.sum(x * values))  # Mean
        features.append(np.sqrt(np.sum(x * (values - np.sum(x * values))**2)))  # Std

    # Configurational entropy
    x_nz = x[x > 0]
    S_conf = -np.sum(x_nz * np.log(x_nz))
    features.append(S_conf)

    # Number of elements
    features.append(len(elements))

    return np.array(features)

# Element database
element_features = {
    'Co': {'VEC': 9, 'radius': 1.252, 'Tm': 1768, 'electronegativity': 1.88},
    'Cr': {'VEC': 6, 'radius': 1.249, 'Tm': 2180, 'electronegativity': 1.66},
    'Fe': {'VEC': 8, 'radius': 1.241, 'Tm': 1811, 'electronegativity': 1.83},
    'Mn': {'VEC': 7, 'radius': 1.350, 'Tm': 1519, 'electronegativity': 1.55},
    'Ni': {'VEC': 10, 'radius': 1.246, 'Tm': 1728, 'electronegativity': 1.91},
    'Al': {'VEC': 3, 'radius': 1.432, 'Tm': 933, 'electronegativity': 1.61},
    'Ti': {'VEC': 4, 'radius': 1.462, 'Tm': 1941, 'electronegativity': 1.54},
    'Cu': {'VEC': 11, 'radius': 1.278, 'Tm': 1358, 'electronegativity': 1.90},
}

# Example compositions
compositions_list = [
    (['Co', 'Cr', 'Fe', 'Mn', 'Ni'], [0.2, 0.2, 0.2, 0.2, 0.2], 'CoCrFeMnNi'),
    (['Al', 'Co', 'Cr', 'Fe', 'Ni'], [0.1, 0.225, 0.225, 0.225, 0.225], 'Al₀.₅CoCrFeNi'),
    (['Co', 'Cr', 'Fe', 'Ni'], [0.25, 0.25, 0.25, 0.25], 'CoCrFeNi'),
]

print("=== ML Feature Extraction for HEAs ===")
print("\nFeatures: [VEC_avg, VEC_std, r_avg, r_std, Tm_avg, Tm_std, chi_avg, chi_std, S_conf, n_elem]")

for elements, comps, name in compositions_list:
    features = featurize_hea(elements, comps, element_features)
    print(f"\n{name}:")
    print(f"  VEC: {features[0]:.2f} ± {features[1]:.2f}")
    print(f"  radius: {features[2]:.3f} ± {features[3]:.3f} Å")
    print(f"  S_conf: {features[8]:.3f}R")

# Visualize feature space
fig, ax = plt.subplots(figsize=(10, 6))

# Generate random HEA compositions for visualization
np.random.seed(42)
n_samples = 100
all_elements = list(element_features.keys())

feature_data = []
for _ in range(n_samples):
    n_elem = np.random.randint(4, 7)
    selected = np.random.choice(all_elements, n_elem, replace=False)
    comps = np.random.dirichlet(np.ones(n_elem))
    features = featurize_hea(list(selected), comps, element_features)
    feature_data.append(features)

feature_data = np.array(feature_data)

# Plot VEC vs atomic size std (proxy for lattice distortion)
sc = ax.scatter(feature_data[:, 0], feature_data[:, 3] * 100,
                c=feature_data[:, 8], cmap='viridis', s=50, alpha=0.7)
plt.colorbar(sc, label='Configurational Entropy (R)')

ax.axhline(y=6.6, color='red', linestyle='--', linewidth=2, label='δ = 6.6% threshold')
ax.axvline(x=6.87, color='blue', linestyle='--', linewidth=2, label='VEC = 6.87')
ax.axvline(x=8.0, color='green', linestyle='--', linewidth=2, label='VEC = 8.0')

ax.set_xlabel('Valence Electron Concentration (VEC)', fontsize=12)
ax.set_ylabel('Atomic Size Difference δ (%)', fontsize=12)
ax.set_title('ML Feature Space for HEA Phase Prediction', fontsize=14)
ax.legend(loc='upper right')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()