Chapter 2: Types of High-Entropy Materials

import numpy as np
import matplotlib.pyplot as plt

# Comparison of HEA types by density and specific strength

hea_types = {
    '3d TM HEAs': {'density': 8.0, 'strength': 800, 'examples': ['CoCrFeMnNi', 'AlCoCrFeNi']},
    'Refractory HEAs': {'density': 12.5, 'strength': 1200, 'examples': ['WMoTaNb', 'VNbMoTaW']},
    'Light-weight HEAs': {'density': 4.5, 'strength': 600, 'examples': ['AlLiMgScTi', 'AlMgTiVZn']},
    'Eutectic HEAs': {'density': 7.5, 'strength': 1500, 'examples': ['AlCoCrFeNi2.1']},
    'Conventional Al alloys': {'density': 2.8, 'strength': 500, 'examples': ['7075-T6']},
    'Ni superalloys': {'density': 8.5, 'strength': 1100, 'examples': ['Inconel 718']},
}

# Calculate specific strength
for hea_type, props in hea_types.items():
    props['specific_strength'] = props['strength'] / props['density']

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

# Density vs Strength plot
ax1 = axes[0]
colors = plt.cm.Set2(np.linspace(0, 1, len(hea_types)))

for i, (name, props) in enumerate(hea_types.items()):
    ax1.scatter(props['density'], props['strength'], s=200, c=[colors[i]],
                edgecolors='black', linewidth=1.5, label=name, zorder=5)

# Add specific strength contours
densities = np.linspace(2, 15, 100)
for ss in [50, 100, 150, 200]:
    strengths = ss * densities
    ax1.plot(densities, strengths, '--', color='gray', alpha=0.5, linewidth=1)
    ax1.text(14, ss*14, f'{ss} MPa/(g/cm³)', fontsize=8, color='gray')

ax1.set_xlabel('Density (g/cm³)', fontsize=12)
ax1.set_ylabel('Yield Strength (MPa)', fontsize=12)
ax1.set_title('Density vs. Strength for Different HEA Types', fontsize=14)
ax1.legend(loc='upper left', fontsize=9)
ax1.set_xlim(2, 15)
ax1.set_ylim(0, 1800)
ax1.grid(True, alpha=0.3)

# Specific strength comparison
ax2 = axes[1]
names = list(hea_types.keys())
specific_strengths = [props['specific_strength'] for props in hea_types.values()]

bars = ax2.barh(names, specific_strengths, color=colors, edgecolor='black', linewidth=1)
ax2.set_xlabel('Specific Strength (MPa·cm³/g)', fontsize=12)
ax2.set_title('Specific Strength Comparison', fontsize=14)
ax2.grid(axis='x', alpha=0.3)

for bar, val in zip(bars, specific_strengths):
    ax2.text(val + 2, bar.get_y() + bar.get_height()/2,
             f'{val:.0f}', va='center', fontsize=10)

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def gibbs_free_energy_heo(T, delta_H_mix, n_components):
    """
    Calculate Gibbs free energy for HEO formation.

    Parameters:
    -----------
    T : float or array
        Temperature in Kelvin
    delta_H_mix : float
        Enthalpy of mixing in kJ/mol
    n_components : int
        Number of cation components

    Returns:
    --------
    float or array : Gibbs free energy in kJ/mol
    """
    R = 8.314e-3  # kJ/(mol·K)

    # Configurational entropy for equiatomic system
    S_conf = -R * n_components * (1/n_components) * np.log(1/n_components)

    # Gibbs free energy
    delta_G = delta_H_mix - T * S_conf

    return delta_G, S_conf

# Temperature range
T = np.linspace(300, 1500, 100)

# Compare different systems
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

# Effect of enthalpy
ax1 = axes[0]
delta_H_values = [5, 10, 15, 20]  # kJ/mol (positive = unfavorable)
n = 5

for dH in delta_H_values:
    dG, _ = gibbs_free_energy_heo(T, dH, n)
    ax1.plot(T, dG, linewidth=2, label=f'ΔH_mix = {dH} kJ/mol')

ax1.axhline(y=0, color='black', linestyle='--', linewidth=1)
ax1.set_xlabel('Temperature (K)', fontsize=12)
ax1.set_ylabel('ΔG_mix (kJ/mol)', fontsize=12)
ax1.set_title('Gibbs Free Energy vs Temperature\n(5-component HEO)', fontsize=14)
ax1.legend()
ax1.grid(True, alpha=0.3)
ax1.set_xlim(300, 1500)

# Highlight entropy-stabilized region
ax1.fill_between(T, ax1.get_ylim()[0], 0, where=(gibbs_free_energy_heo(T, 15, 5)[0] < 0),
                  alpha=0.2, color='green', label='Stable region')

# Effect of number of components
ax2 = axes[1]
n_values = [3, 4, 5, 6, 7]
dH = 15  # kJ/mol

for n in n_values:
    dG, S = gibbs_free_energy_heo(T, dH, n)
    ax2.plot(T, dG, linewidth=2, label=f'{n} components (S = {S:.3f}R)')

ax2.axhline(y=0, color='black', linestyle='--', linewidth=1)
ax2.set_xlabel('Temperature (K)', fontsize=12)
ax2.set_ylabel('ΔG_mix (kJ/mol)', fontsize=12)
ax2.set_title(f'Effect of Number of Components\n(ΔH_mix = {dH} kJ/mol)', fontsize=14)
ax2.legend()
ax2.grid(True, alpha=0.3)
ax2.set_xlim(300, 1500)

plt.tight_layout()
plt.show()

# Calculate transition temperature
print("=== Entropy Stabilization Temperatures ===")
print("(Temperature where ΔG = 0 for different systems)")
R = 8.314e-3

for n in [3, 4, 5, 6, 7]:
    S_conf = -R * n * (1/n) * np.log(1/n)
    for dH in [10, 15, 20]:
        T_trans = dH / S_conf
        print(f"  {n} components, ΔH = {dH} kJ/mol: T_transition = {T_trans:.0f} K")

import numpy as np
import matplotlib.pyplot as plt

def calculate_glass_forming_ability(compositions, T_g, T_l, T_x):
    """
    Calculate glass-forming ability parameters.

    Parameters:
    -----------
    compositions : dict
        Element mole fractions
    T_g : float
        Glass transition temperature (K)
    T_l : float
        Liquidus temperature (K)
    T_x : float
        Crystallization temperature (K)

    Returns:
    --------
    dict : GFA parameters
    """
    # Reduced glass transition temperature
    T_rg = T_g / T_l

    # Gamma parameter (Lu and Liu)
    gamma = T_x / (T_g + T_l)

    # Delta parameter (Chen)
    delta = T_x / (T_l - T_g) if T_l > T_g else float('inf')

    # Configurational entropy (for HE effect)
    x = np.array(list(compositions.values()))
    x = x[x > 0]
    S_conf = -8.314 * np.sum(x * np.log(x))

    return {
        'T_rg': T_rg,
        'gamma': gamma,
        'delta': delta,
        'S_conf': S_conf
    }

# Example: Compare GFA of different systems
systems = {
    'Conventional BMG\n(Zr-Cu-Ni-Al)': {
        'compositions': {'Zr': 0.55, 'Cu': 0.30, 'Ni': 0.05, 'Al': 0.10},
        'T_g': 683, 'T_l': 1115, 'T_x': 758
    },
    'HE-BMG 1\n(TiZrHfCuNiBe)': {
        'compositions': {'Ti': 0.167, 'Zr': 0.167, 'Hf': 0.167,
                        'Cu': 0.167, 'Ni': 0.167, 'Be': 0.167},
        'T_g': 693, 'T_l': 1050, 'T_x': 773
    },
    'HE-BMG 2\n(TiZrCuNiAlBe)': {
        'compositions': {'Ti': 0.15, 'Zr': 0.20, 'Cu': 0.15,
                        'Ni': 0.15, 'Al': 0.15, 'Be': 0.20},
        'T_g': 698, 'T_l': 1020, 'T_x': 785
    }
}

# Calculate GFA parameters
results = {}
for name, data in systems.items():
    results[name] = calculate_glass_forming_ability(
        data['compositions'], data['T_g'], data['T_l'], data['T_x']
    )

# Visualization
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# T_rg comparison
ax1 = axes[0]
names = list(results.keys())
T_rg_values = [results[name]['T_rg'] for name in names]
bars1 = ax1.bar(names, T_rg_values, color=['#3498db', '#e74c3c', '#27ae60'],
                edgecolor='black', linewidth=1)
ax1.set_ylabel('Reduced Glass Transition T_rg', fontsize=12)
ax1.set_title('Glass Forming Ability\n(Higher T_rg = Better GFA)', fontsize=12)
ax1.axhline(y=0.6, color='gray', linestyle='--', alpha=0.7)
ax1.set_ylim(0.5, 0.75)
for bar, val in zip(bars1, T_rg_values):
    ax1.text(bar.get_x() + bar.get_width()/2, val + 0.01,
             f'{val:.3f}', ha='center', fontsize=10)

# Gamma comparison
ax2 = axes[1]
gamma_values = [results[name]['gamma'] for name in names]
bars2 = ax2.bar(names, gamma_values, color=['#3498db', '#e74c3c', '#27ae60'],
                edgecolor='black', linewidth=1)
ax2.set_ylabel('Gamma Parameter', fontsize=12)
ax2.set_title('Crystallization Resistance\n(Higher gamma = Better)', fontsize=12)
ax2.set_ylim(0.3, 0.5)
for bar, val in zip(bars2, gamma_values):
    ax2.text(bar.get_x() + bar.get_width()/2, val + 0.005,
             f'{val:.3f}', ha='center', fontsize=10)

# Configurational entropy
ax3 = axes[2]
S_values = [results[name]['S_conf'] for name in names]
bars3 = ax3.bar(names, np.array(S_values)/8.314, color=['#3498db', '#e74c3c', '#27ae60'],
                edgecolor='black', linewidth=1)
ax3.set_ylabel('Configurational Entropy (R)', fontsize=12)
ax3.set_title('Entropy Contribution\n(Higher = More HE Character)', fontsize=12)
ax3.axhline(y=1.5, color='red', linestyle='--', alpha=0.7, label='HE threshold')
ax3.legend()
for bar, val in zip(bars3, np.array(S_values)/8.314):
    ax3.text(bar.get_x() + bar.get_width()/2, val + 0.05,
             f'{val:.2f}R', ha='center', fontsize=10)

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from itertools import combinations

# Element database (subset for demonstration)
element_data = {
    'Co': {'r': 1.252, 'VEC': 9, 'Tm': 1768, 'chi': 1.88},
    'Cr': {'r': 1.249, 'VEC': 6, 'Tm': 2180, 'chi': 1.66},
    'Fe': {'r': 1.241, 'VEC': 8, 'Tm': 1811, 'chi': 1.83},
    'Mn': {'r': 1.350, 'VEC': 7, 'Tm': 1519, 'chi': 1.55},
    'Ni': {'r': 1.246, 'VEC': 10, 'Tm': 1728, 'chi': 1.91},
    'Al': {'r': 1.432, 'VEC': 3, 'Tm': 933, 'chi': 1.61},
    'Ti': {'r': 1.462, 'VEC': 4, 'Tm': 1941, 'chi': 1.54},
    'Cu': {'r': 1.278, 'VEC': 11, 'Tm': 1358, 'chi': 1.90},
    'V':  {'r': 1.316, 'VEC': 5, 'Tm': 2183, 'chi': 1.63},
    'Nb': {'r': 1.429, 'VEC': 5, 'Tm': 2750, 'chi': 1.60},
}

def screen_hea_composition(elements, compositions=None):
    """
    Screen HEA composition using empirical parameters.

    Parameters:
    -----------
    elements : list
        List of element symbols
    compositions : array-like, optional
        Mole fractions (equiatomic if None)

    Returns:
    --------
    dict : Screening parameters and predictions
    """
    n = len(elements)
    if compositions is None:
        x = np.ones(n) / n  # Equiatomic
    else:
        x = np.array(compositions)

    # Extract element data
    r = np.array([element_data[el]['r'] for el in elements])
    vec = np.array([element_data[el]['VEC'] for el in elements])
    Tm = np.array([element_data[el]['Tm'] for el in elements])
    chi = np.array([element_data[el]['chi'] for el in elements])

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

    # Atomic size difference (delta)
    delta = 100 * np.sqrt(np.sum(x * (1 - r/r_avg)**2))

    # VEC
    VEC = np.sum(x * vec)

    # Electronegativity difference
    chi_avg = np.sum(x * chi)
    delta_chi = np.sqrt(np.sum(x * (chi - chi_avg)**2))

    # Configurational entropy
    x_nz = x[x > 0]
    S_conf = -np.sum(x_nz * np.log(x_nz))  # In units of R

    # Predictions
    # Phase structure
    if VEC >= 8.0:
        predicted_structure = 'FCC'
    elif VEC < 6.87:
        predicted_structure = 'BCC'
    else:
        predicted_structure = 'FCC+BCC'

    # Single phase formation
    single_phase = delta < 6.6

    return {
        'elements': elements,
        'compositions': x,
        'delta': delta,
        'VEC': VEC,
        'delta_chi': delta_chi,
        'S_conf': S_conf,
        'predicted_structure': predicted_structure,
        'single_phase_likely': single_phase
    }

# Example: Design HEAs for different applications
print("=== HEA Composition Screening ===\n")

# FCC HEA for cryogenic applications
fcc_hea = screen_hea_composition(['Co', 'Cr', 'Fe', 'Mn', 'Ni'])
print(f"FCC HEA (CoCrFeMnNi):")
print(f"  VEC = {fcc_hea['VEC']:.2f} -> {fcc_hea['predicted_structure']}")
print(f"  delta = {fcc_hea['delta']:.2f}% -> {'Single phase' if fcc_hea['single_phase_likely'] else 'Multi-phase'}")
print(f"  S_conf = {fcc_hea['S_conf']:.2f}R")

# BCC HEA for high-temperature
bcc_hea = screen_hea_composition(['V', 'Nb', 'Ti', 'Cr', 'Al'])
print(f"\nBCC HEA (VNbTiCrAl):")
print(f"  VEC = {bcc_hea['VEC']:.2f} -> {bcc_hea['predicted_structure']}")
print(f"  delta = {bcc_hea['delta']:.2f}% -> {'Single phase' if bcc_hea['single_phase_likely'] else 'Multi-phase'}")
print(f"  S_conf = {bcc_hea['S_conf']:.2f}R")

# Non-equiatomic for property tuning
tuned_hea = screen_hea_composition(['Al', 'Co', 'Cr', 'Fe', 'Ni'],
                                    [0.3, 0.175, 0.175, 0.175, 0.175])
print(f"\nTuned HEA (Al0.3CoCrFeNi):")
print(f"  VEC = {tuned_hea['VEC']:.2f} -> {tuned_hea['predicted_structure']}")
print(f"  delta = {tuned_hea['delta']:.2f}% -> {'Single phase' if tuned_hea['single_phase_likely'] else 'Multi-phase'}")
print(f"  S_conf = {tuned_hea['S_conf']:.2f}R")