K-Dense-AI/scientific-agent-skills / skills/pycalphad
pycalphad
VerifiedComputes finite-temperature CALPHAD equilibria, phase fractions, and phase compositions from thermodynamic TDB databases using pycalphad. Use for alloy phase stability, equilibrium temperature sweeps, tie lines, lever-rule checks, or reproducible phase-fraction calculations with explicit components and mole-fraction conditions.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 8.0 KB |
| assets/equilibrium.json | config | 443 B |
| assets/ideal-cu-ni.tdb | other | 702 B |
| references/model-and-validation.md | markdown | 9.8 KB |
| scripts/equilibrate.py | script | 10.9 KB |
scripts/equilibrate.py
View on GitHub#!/usr/bin/env python3
"""Compute TDB-based equilibria at one bulk mole composition over temperatures."""
from __future__ import annotations
import argparse
import csv
import hashlib
import json
from pathlib import Path
import numpy as np
import pycalphad as pc
from pycalphad import variables as v
from pycalphad.core.utils import filter_phases, unpack_species
def finite(value, name, positive=False):
if isinstance(value, bool) or not isinstance(value, (int, float)) or not np.isfinite(value):
raise ValueError(f"{name} must be a finite number")
if positive and value <= 0:
raise ValueError(f"{name} must be positive")
return float(value)
def validate(db, settings):
keys = {"components", "phases", "composition_basis", "dependent_component", "independent_mole_fractions",
"temperatures_k", "pressure_pa", "database_temperature_range_k", "pdens",
"mass_balance_tolerance", "phase_fraction_tolerance", "gibbs_energy_tolerance_j_per_mol"}
if set(settings) != keys:
raise ValueError(f"Missing settings: {sorted(keys-set(settings))}; unknown: {sorted(set(settings)-keys)}")
for key in ("components", "phases"):
values = settings[key]
if not isinstance(values, list) or not values or any(not isinstance(s, str) for s in values) or len(set(values)) != len(values):
raise ValueError(f"{key} must be a nonempty list of unique names")
comps = settings["components"]
phases = settings["phases"]
if set(comps) - db.elements:
raise ValueError(f"Components absent from database elements: {sorted(set(comps) - db.elements)}")
if set(phases) - set(db.phases):
raise ValueError(f"Unknown phases: {sorted(set(phases) - set(db.phases))}")
active = filter_phases(db, unpack_species(db, comps), phases)
if set(active) != set(phases):
raise ValueError(f"Incompatible or order-disorder-filtered phases: {sorted(set(phases) - set(active))}")
if settings["composition_basis"] != "mole_fraction":
raise ValueError("Only elemental mole_fraction conditions are accepted; convert mass fractions explicitly")
material = set(comps) - {"VA"}
dependent = settings["dependent_component"]
if dependent not in material:
raise ValueError("dependent_component must be a non-vacancy selected element")
fractions = settings["independent_mole_fractions"]
if not isinstance(fractions, dict) or set(fractions) != material - {dependent}:
raise ValueError("Specify exactly one mole fraction for each nondependent, non-vacancy component")
fractions = {name: finite(value, name) for name, value in fractions.items()}
if any(value < 0 or value > 1 for value in fractions.values()) or sum(fractions.values()) > 1:
raise ValueError("Mole fractions must be in [0,1] and sum to at most one")
bulk = {**fractions, dependent: 1 - sum(fractions.values())}
temperatures = settings["temperatures_k"]
if not isinstance(temperatures, list) or not temperatures or len(temperatures) > 1000:
raise ValueError("temperatures_k must contain between 1 and 1000 explicit temperatures")
for temperature in temperatures:
finite(temperature, "temperature_k", True)
if len(set(temperatures)) != len(temperatures):
raise ValueError("Duplicate temperatures are not accepted")
bounds = settings["database_temperature_range_k"]
if bounds is not None:
if not isinstance(bounds, list) or len(bounds) != 2:
raise ValueError("database_temperature_range_k must be [low, high] or null if unknown")
low, high = [finite(x, "database temperature bound", True) for x in bounds]
if low >= high or min(temperatures) < low or max(temperatures) > high:
raise ValueError("Requested temperatures lie outside the declared database range")
for name in ("pressure_pa", "mass_balance_tolerance", "phase_fraction_tolerance", "gibbs_energy_tolerance_j_per_mol"):
finite(settings[name], name, True)
pdens = settings["pdens"]
if isinstance(pdens, bool) or not isinstance(pdens, int) or not 10 <= pdens <= 10000:
raise ValueError("pdens must be an integer from 10 through 10000")
return bulk
def solve_point(db, settings, bulk, temperature, pdens):
conditions = {v.T: temperature, v.P: settings["pressure_pa"], v.N: 1}
conditions.update({v.X(name): value for name, value in settings["independent_mole_fractions"].items()})
result = pc.equilibrium(db, settings["components"], settings["phases"], conditions, calc_opts={"pdens": pdens})
# pycalphad clips independent composition conditions near zero and one.
# Preserve the actual imposed coordinates without replacing the requested bulk.
solver_bulk = {name: float(result.coords[str(v.X(name))].values.item())
for name in settings["independent_mole_fractions"]}
solver_bulk[settings["dependent_component"]] = 1 - sum(solver_bulk.values())
condition_adjustment = max(abs(solver_bulk[name] - bulk[name]) for name in bulk)
energy = float(result.GM.values.item())
names = result.Phase.values.ravel()
amounts = result.NP.values.ravel()
components = [str(c) for c in result.component.values]
compositions = result.X.values.reshape(-1, len(components))
if not np.isfinite(energy) or set(components) != set(bulk):
raise ValueError("Equilibrium failed: nonfinite energy or unexpected output components")
vertices = []
reconstructed = {name: 0.0 for name in bulk}
phase_sums = {name: 0.0 for name in settings["phases"]}
for index, (name, amount, composition) in enumerate(zip(names, amounts, compositions)):
if name == "":
continue # pycalphad pads unused vertices with blank names and NaN amounts.
if name not in phase_sums or not np.isfinite(amount) or not np.isfinite(composition).all():
raise ValueError("Equilibrium contains an invalid or fictitious stable vertex")
if amount < -1e-10 or amount > 1 + 1e-10 or np.min(composition) < -1e-10 or abs(composition.sum() - 1) > 1e-7:
raise ValueError("Equilibrium has invalid phase fraction or composition")
fractions = dict(zip(components, map(float, composition)))
vertices.append({"vertex": index, "phase": str(name), "mole_phase_fraction": float(amount), "mole_fractions": fractions})
phase_sums[str(name)] += float(amount)
for component, fraction in fractions.items():
reconstructed[component] += float(amount) * fraction
if not vertices:
raise ValueError("Equilibrium produced no stable phases")
amount_error = abs(sum(phase_sums.values()) - 1)
mass_error = max(abs(reconstructed[c] - bulk[c]) for c in bulk)
return {"temperature_k": temperature, "gibbs_energy_j_per_mol": energy, "vertices": vertices,
"phase_totals": phase_sums, "reconstructed_bulk_mole_fractions": reconstructed,
"solver_bulk_mole_fractions": solver_bulk,
"composition_condition_adjustment_absolute_error": condition_adjustment,
"phase_fraction_sum_error": amount_error, "mass_balance_absolute_error": mass_error,
"balance_passed": amount_error <= settings["mass_balance_tolerance"] and mass_error <= settings["mass_balance_tolerance"]}
def calculate(db, settings):
bulk = validate(db, settings)
points = []
for temperature in settings["temperatures_k"]:
baseline = solve_point(db, settings, bulk, temperature, settings["pdens"])
refined = solve_point(db, settings, bulk, temperature, 2 * settings["pdens"])
fraction_change = max(abs(baseline["phase_totals"][p] - refined["phase_totals"][p]) for p in settings["phases"])
energy_change = abs(baseline["gibbs_energy_j_per_mol"] - refined["gibbs_energy_j_per_mol"])
points.append({"baseline": baseline, "refined": refined,
"maximum_phase_fraction_change": fraction_change,
"gibbs_energy_change_j_per_mol": energy_change,
"checks_passed": baseline["balance_passed"] and refined["balance_passed"] and
fraction_change <= settings["phase_fraction_tolerance"] and energy_change <= settings["gibbs_energy_tolerance_j_per_mol"]})
return {"bulk_mole_fractions": bulk, "points": points,
"all_checks_passed": all(point["checks_passed"] for point in points),
"excluded_database_phases": sorted(set(db.phases) - set(settings["phases"]))}
def run(database_path, settings_path, output_dir):
database_path, settings_path, output_dir = map(Path, (database_path, settings_path, output_dir))
if output_dir.exists():
raise ValueError("Output directory already exists; choose a new directory")
settings = json.loads(settings_path.read_text())
db = pc.Database(str(database_path))
report = calculate(db, settings)
report.update(versions={"pycalphad": pc.__version__, "numpy": np.__version__}, settings=settings,
database_sha256=hashlib.sha256(database_path.read_bytes()).hexdigest(),
settings_sha256=hashlib.sha256(settings_path.read_bytes()).hexdigest(),
phase_fraction_basis="molar, N=1; vacancies excluded from bulk composition",
database_experimental_validity="not_evaluated_by_helper",
refinement="pdens doubled; phase totals and GM compared; not a proof of the global minimum")
output_dir.mkdir(parents=True)
(output_dir / "report.json").write_text(json.dumps(report, indent=2, allow_nan=False) + "\n")
with (output_dir / "phase-equilibria.csv").open("w", newline="") as handle:
writer = csv.writer(handle)
components = sorted(report["bulk_mole_fractions"])
writer.writerow(["run", "temperature_k", "vertex", "phase", "mole_phase_fraction", "gibbs_energy_j_per_mol", *[f"X_{c}" for c in components]])
for point in report["points"]:
for variant in ("baseline", "refined"):
result = point[variant]
for vertex in result["vertices"]:
writer.writerow([variant, result["temperature_k"], vertex["vertex"], vertex["phase"],
vertex["mole_phase_fraction"], result["gibbs_energy_j_per_mol"],
*[vertex["mole_fractions"][c] for c in components]])
return report
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("database", type=Path, help="Thermodynamic TDB database")
parser.add_argument("settings", type=Path, help="Conditions JSON")
parser.add_argument("output", type=Path, help="New output directory")
args = parser.parse_args()
try:
report = run(args.database, args.settings, args.output)
except (ValueError, OSError, TypeError, KeyError) as error:
parser.error(str(error))
print(json.dumps({"output": str(args.output), "all_checks_passed": report["all_checks_passed"]}))
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| deprecation-and-migrationaddyosmani/agent-skillsManages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when migrating a database schema in production, such as renaming or dropping a column without downtime (expand/contract). Use when deciding whether to maintain or sunset existing code. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| performance-optimizationaddyosmani/agent-skillsOptimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |
| agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |