Eve library

phase-127.md

Tracker

Revision 1

On this page

Historical task source. The Eve task board holds current task state.

Phase 127: Kalika Materials Code Interoperability & Databases — VASP, Quantum ESPRESSO, ABINIT, LAMMPS, Phonopy, WANNIER90, ASE, pymatgen Compatibility & Materials Database APIs#

Comprehensive interfaces to all major computational materials science codes and databases. This phase is critical for researcher adoption — users need to integrate Kalika with their existing DFT, MD, and post-processing workflows. Targets feature parity with ASE, pymatgen, atomate/atomate2, FireWorks/jobflow, and custodian. Covers input generation, output parsing, error handling, database APIs, and workflow orchestration for VASP, Quantum ESPRESSO, ABINIT, FHI-aims, LAMMPS, GROMACS, Phonopy, WANNIER90, LOBSTER, BoltzTraP2, and 10+ additional codes. TypeScript (~70%) for orchestration and I/O logic, Rust (~10%) for performance-critical parsing (large trajectory files, charge density grids), Python (~20%) for bridges to the ASE/pymatgen/AiiDA ecosystems.


127.1 Scaffolding & Core Types (@kalika/code-interfaces)#

127.1.1 Library Scaffolding#

  • 127.1.1.1 Create directory structure for libs/kalika/code-interfaces/ with package.json, project.json, tsconfig.json, and src/index.ts barrel export — register path mapping in tsconfig.base.json
  • 127.1.1.2 Create directory structure for libs/kalika/vasp-io/ with package.json, project.json, tsconfig.json, and src/index.ts — add path mapping
  • 127.1.1.3 Create directory structure for libs/kalika/qe-io/ with package.json, project.json, tsconfig.json, and src/index.ts — add path mapping
  • 127.1.1.4 Create directory structure for libs/kalika/lammps-io/ with package.json, project.json, tsconfig.json, and src/index.ts — add path mapping
  • 127.1.1.5 Create directory structure for libs/kalika/materials-databases/ with package.json, project.json, tsconfig.json, and src/index.ts — add path mapping
  • 127.1.1.6 Create directory structure for libs/kalika/workflows/ with package.json, project.json, tsconfig.json, and src/index.ts — add path mapping
  • 127.1.1.7 Create directory structures for ancillary interface libraries: libs/kalika/abinit-io/, libs/kalika/fhi-aims-io/, libs/kalika/phonopy-io/, libs/kalika/wannier90-io/, libs/kalika/lobster-io/, libs/kalika/boltztrap-io/, libs/kalika/gromacs-io/ — each with package.json, project.json, tsconfig.json, src/index.ts, and path mappings

127.1.2 Core Type Definitions#

  • 127.1.2.1 Implement CalculationInput type hierarchy: base type with code: CodeName, version?: string, structure: KalikaStructure, parameters: Record<string, unknown>, resources: ComputeResources (nprocs, memory, walltime, queue), workDir: string, inputFiles: Map<string, string> — plus code-specific subtypes VaspInput, QeInput, AbinitInput, LammpsInput each with typed parameter sets
  • 127.1.2.2 Implement CalculationOutput type hierarchy: base type with code: CodeName, status: JobStatus, walltime: number, exitCode: number, energy?: number, forces?: Float64Array[], stress?: Float64Array, structure?: KalikaStructure, rawFiles: Map<string, Buffer>, parseErrors: ParseError[] — plus code-specific subtypes with typed parsed results (eigenvalues, DOS, band structure, etc.)
  • 127.1.2.3 Implement CodeInterface abstract class: generateInputs(calc: CalculationInput): Map<string, string | Buffer>, parseOutputs(files: Map<string, Buffer>): CalculationOutput, validateInputs(calc: CalculationInput): ValidationResult[], detectErrors(output: CalculationOutput): CodeError[], suggestFixes(errors: CodeError[]): Fix[] — the contract every code adapter must implement
  • 127.1.2.4 Implement WorkflowStep type: id: string, name: string, code: CodeName, inputTemplate: CalculationInput, dependencies: string[] (step IDs), outputMapping: Map<string, string> (how outputs from dependencies map to this step's inputs), condition?: (outputs: Map<string, CalculationOutput>) => boolean (conditional execution), retryPolicy: RetryPolicy
  • 127.1.2.5 Implement WorkflowDAG class: topological sort of WorkflowStep nodes, cycle detection, dependency resolution, addStep(), removeStep(), connect(from, to, mapping), validate(): ValidationResult[], getExecutionOrder(): string[][] (returns layers of parallelizable steps), serialization to/from JSON
  • 127.1.2.6 Implement JobStatus enum and state machine: CREATED → SUBMITTED → QUEUED → RUNNING → COMPLETED | FAILED | CANCELLED, with transition validation, timestamp tracking for each state change, and JobStatusHistory recording all transitions

127.1.3 Structure Conversion Utilities#

  • 127.1.3.1 Implement KalikaStructure canonical type: lattice vectors (3x3 matrix), species list, fractional coordinates, Cartesian coordinates, site properties (magnetic moment, charge, selective dynamics flags), toCartesian(), toFractional(), getVolume(), getLatticeParameters() (a, b, c, alpha, beta, gamma), getReciprocalLattice(), getSuperCell(nx, ny, nz), applySymmetry(spaceGroup)
  • 127.1.3.2 Implement CIF ↔ KalikaStructure converter: parse CIF files (IUCr CIF 1.1 and 2.0 format) including symmetry operations, site occupancies, anisotropic displacement parameters — and write CIF from KalikaStructure with space group, Wyckoff positions, and all standard CIF data blocks
  • 127.1.3.3 Implement POSCAR/CONTCAR ↔ KalikaStructure converter: read/write VASP 5.x format (species line, direct/Cartesian, selective dynamics, velocities) — exact formatting to match VASP expectations
  • 127.1.3.4 Implement XYZ/extXYZ ↔ KalikaStructure converter: standard XYZ and extended XYZ (with lattice, properties columns) — supporting multi-frame trajectories
  • 127.1.3.5 Implement PDB ↔ KalikaStructure converter: Protein Data Bank format for biomolecular structures — ATOM/HETATM records, CRYST1 (unit cell), CONECT (bonds)

127.1.4 Unit System & Physical Constants#

  • 127.1.4.1 Implement unit conversion registry: energy (eV, Ry, Ha, J, kcal/mol, kJ/mol, cm⁻¹, K, meV), length (Å, Bohr, nm, pm), force (eV/Å, Ha/Bohr, N), pressure (GPa, kbar, eV/ų, Ha/Bohr³, Pa), time (fs, ps, au), mass (amu, kg, electron mass) — with composable unit arithmetic: convert(value, 'eV/Ų', 'Ha/Bohr²')
  • 127.1.4.2 Implement physical constants module: CODATA 2018 values for Bohr radius, Hartree energy, Rydberg constant, electron mass, Boltzmann constant, Planck constant, speed of light, fine structure constant, Avogadro number — all with uncertainties, and derived constants (eV_to_Ha, Bohr_to_Ang, etc.)

127.2 VASP Interface (@kalika/vasp-io)#

127.2.1 INCAR Generation#

  • 127.2.1.1 Implement INCAR writer: serialize a typed IncarParams object to VASP INCAR format — proper formatting of scalars, arrays (MAGMOM), booleans (.TRUE./.FALSE.), string values, comment lines, tag ordering by category (general → electronic → ionic → output)
  • 127.2.1.2 Implement INCAR tag validation engine: validate all major tags against allowed values (ALGO: Normal/Fast/VeryFast/All/Damped/..., PREC: Accurate/Normal/Low/..., ISPIN: 1/2, LREAL: Auto/.TRUE./.FALSE., ISMEAR: -5/-4/-1/0/1/2/..., IBRION: -1/0/1/2/3/5/6/7/8/44), range checks (ENCUT > 0, EDIFF > 0, SIGMA > 0, NSW >= 0), mutual exclusion checks (IBRION with NSW=0 is static), and dependency checks (LORBIT requires appropriate RWIGS or PAW)
  • 127.2.1.3 Implement INCAR tag database: comprehensive metadata for every supported VASP tag — name, type (int/float/bool/string/array), default value, allowed values/range, description, VASP version introduced, dependencies on other tags, category (electronic/ionic/output/symmetry/ parallel/hybrid/GW/response) — at least 150 tags covering all VASP functionality
  • 127.2.1.4 Implement INCAR preset: static — IBRION=-1, NSW=0, ISMEAR=-5 (tetrahedron with Blöchl corrections for insulators) or ISMEAR=1/SIGMA=0.2 (metals), LREAL=Auto, PREC=Accurate, EDIFF=1e-6, LORBIT=11, LWAVE=.FALSE., LCHARG=.TRUE.
  • 127.2.1.5 Implement INCAR preset: relaxation — IBRION=2 (CG), ISIF=3 (full cell+ions), NSW=100, EDIFF=1e-6, EDIFFG=-0.02 (force convergence), LREAL=Auto, PREC=Accurate, ISMEAR=1/SIGMA=0.2 (metals) or ISMEAR=0 (insulators), LWAVE=.FALSE., LCHARG=.FALSE.
  • 127.2.1.6 Implement INCAR preset: band_structure — non-self-consistent calculation: ICHARG=11, ISMEAR=0/SIGMA=0.05, LORBIT=11, LWAVE=.FALSE., LCHARG=.FALSE., NEDOS=2001 — designed to be chained after a static run using the CHGCAR
  • 127.2.1.7 Implement INCAR preset: dos — ISMEAR=-5 (tetrahedron), NEDOS=3001, LORBIT=11 (projected DOS), EMIN/EMAX auto-set from band edges, ICHARG=11 (non-SCF from CHGCAR)
  • 127.2.1.8 Implement INCAR preset: dielectric — LEPSILON=.TRUE. (DFPT dielectric), IBRION=8 (DFPT), EDIFF=1e-8, LREAL=.FALSE., PREC=Accurate, plus variant for LOPTICS=.TRUE. (frequency-dependent dielectric from RPA)
  • 127.2.1.9 Implement INCAR preset: neb — IBRION=3 (damped MD for NEB), POTIM=0, ICHAIN=0, IMAGES=N (configurable), SPRING=-5, LCLIMB=.TRUE. (CI-NEB), EDIFF=1e-5, NSW=200
  • 127.2.1.10 Implement INCAR preset: hybrid — LHFCALC=.TRUE., AEXX=0.25 (HSE06), HFSCREEN=0.2, ALGO=All (or Damped), TIME=0.4, PRECFOCK=Fast, NKRED if applicable — with variant for PBE0 (AEXX=0.25, HFSCREEN=0)
  • 127.2.1.11 Implement INCAR preset: gw — ALGO=GW, NOMEGA=100, NBANDS=large, ENCUTGW=auto, LSPECTRAL=.TRUE., plus variants for G0W0, GW0, scGW, and BSE (ALGO=BSE, NBANDSO/NBANDSV)
  • 127.2.1.12 Implement INCAR preset: phonon_finite_diff — IBRION=5 (finite differences) or IBRION=6 (central differences), NFREE=2, EDIFF=1e-8, PREC=Accurate, LREAL=.FALSE., ADDGRID=.TRUE., ISYM=0
  • 127.2.1.13 Implement INCAR preset: elastic — IBRION=6, ISIF=3, NFREE=4, EDIFF=1e-8, PREC=Accurate, LREAL=.FALSE.
  • 127.2.1.14 Implement INCAR preset: nmr — LNMR_SYM_RED=.TRUE., NSLPLINE=.TRUE., LCHIMAG=.TRUE., DQ=0.001, ICHIBARE=1-3, EDIFF=1e-8, LREAL=.FALSE.
  • 127.2.1.15 Implement INCAR preset: aimd — IBRION=0, ISIF=2 (NVT) or ISIF=3 (NPT), SMASS=0 (NVT via Nosé-Hoover) or SMASS=-1 (NVE), TEBEG/TEEND (temperatures), POTIM=1.0 (1 fs timestep), NSW=10000, PREC=Normal, ALGO=VeryFast, LREAL=Auto, LWAVE=.FALSE.
  • 127.2.1.16 Implement INCAR preset: soc — LSORBIT=.TRUE., LNONCOLLINEAR=.TRUE., SAXIS specification, NBANDS typically doubled, GGA_COMPAT=.FALSE., LORBMOM=.TRUE.

127.2.2 POSCAR & KPOINTS Generation#

  • 127.2.2.1 Implement POSCAR writer: write VASP 5+ POSCAR from KalikaStructure — comment line, scaling factor, lattice vectors (16-digit precision), element symbols line, atom counts line, Selective dynamics (optional T/F flags), Direct/Cartesian toggle, fractional/Cartesian coordinates (16-digit precision), optional velocities block
  • 127.2.2.2 Implement POSCAR reader: parse VASP 5+ POSCAR/CONTCAR — handle scaling factor (including negative = volume), lattice vectors, species (VASP 5 element line), counts, selective dynamics flags, direct/Cartesian coordinates, velocities — return KalikaStructure
  • 127.2.2.3 Implement KPOINTS writer: automatic Monkhorst-Pack mesh (subdivisions + shift), automatic Gamma-centered mesh, and explicit k-point list mode — with auto-generation of k-mesh density from target k-point density (e.g., 50 k-points/Å⁻¹) and lattice parameters
  • 127.2.2.4 Implement KPOINTS line-mode writer: generate k-point path for band structure calculations — input: list of high-symmetry points (Γ, X, M, K, L, W, U, etc.) with labels and coordinates, number of points per segment; include automatic high-symmetry path detection from space group (using Setyawan-Curtarolo conventions)
  • 127.2.2.5 Implement high-symmetry k-path database: Brillouin zone high-symmetry points and standard paths for all 14 Bravais lattices (cF, cI, cP, tI, tP, oF, oI, oC, oP, hR, hP, mC, mP, aP) following Setyawan-Curtarolo (Comp. Mat. Sci. 49, 2010) conventions

127.2.3 POTCAR Management#

  • 127.2.3.1 Implement POTCAR library manager: configure path to local VASP POTCAR library (e.g., $VASP_PP_DIR/), scan for available functionals (PBE, PBE_52, PBE_54, LDA, PW91), list available potentials per element per functional, and concatenate POTCARs in the correct element order
  • 127.2.3.2 Implement recommended POTCAR selection: maintain a mapping of recommended PAW potentials per element (e.g., Li_sv, Na_pv, Ca_sv, Ti_pv, etc.) following pymatgen/Materials Project conventions — with fallbacks when recommended potential is unavailable
  • 127.2.3.3 Implement POTCAR validation: verify POTCAR integrity via checksum (SHA-256 or TITEL hash), ensure functional consistency (all potentials from same functional family), verify element order matches POSCAR, extract ENMAX values for automatic ENCUT determination (ENCUT = max(ENMAX) × 1.3)

127.2.4 Output Parsing#

  • 127.2.4.1 Implement OUTCAR parser: extract total energy (E0, energy without entropy, energy(sigma→0)), ionic forces (eV/Å), stress tensor (kbar), magnetization (per atom and total), timing breakdown, number of SCF iterations per ionic step, convergence history (energy, force, stress per step), warnings and errors
  • 127.2.4.2 Implement OUTCAR advanced property parser: Born effective charges (LEPSILON), macroscopic dielectric tensor (ionic + electronic contributions), elastic tensor C_ij (6×6), piezoelectric tensor e_ij, NMR chemical shielding tensors (σ_iso, σ_aniso, η), electric field gradients (V_zz, η), internal strain tensor
  • 127.2.4.3 Implement vasprun.xml parser: full XML parsing of VASP's structured output — extract: calculation parameters (INCAR as parsed), k-points, basis set info, initial/final structure, electronic structure (eigenvalues at each k-point and band, occupations), DOS (total + projected onto atoms/orbitals), forces, stress, energy per ionic step, dielectric function (real + imaginary parts vs. energy), born charges, timing — handle both collinear and non-collinear spin
  • 127.2.4.4 Implement DOSCAR parser: read total DOS (energy, DOS-up, DOS-down, integrated-DOS-up, integrated-DOS-down) and projected DOS (per atom, per orbital: s, p_y, p_z, p_x, d_xy, d_yz, d_z2, d_xz, d_x2-y2, and f orbitals if LORBIT=11) — return structured DensityOfStates object with energy grid, total, and projected components
  • 127.2.4.5 Implement EIGENVAL parser: read k-point coordinates, weights, and eigenvalues (per k-point, per band, per spin) — return BandStructure object with k-path, eigenvalues, Fermi energy, band gap detection (direct/indirect, VBM/CBM k-points)
  • 127.2.4.6 Implement PROCAR parser: read projected band structure — orbital weights (s, p, d, f decomposition) and atom decomposition at each k-point and band — for fat band and orbital-character analysis
  • 127.2.4.7 Implement CHGCAR/AECCAR reader: parse charge density on FFT grid — header (structure, grid dimensions), volumetric data (spin-up, spin-down for spin-polarized), augmentation charges — support CHGCAR, AECCAR0 (core), AECCAR2 (valence) for Bader analysis preparation
  • 127.2.4.8 Implement LOCPOT parser: read local potential on FFT grid — same format as CHGCAR but containing the electrostatic potential — for work function calculations (vacuum level extraction) and dipole corrections
  • 127.2.4.9 Implement WAVECAR reader (Rust + WASM): parse VASP WAVECAR binary format — extract header (ISPIN, NKPTS, NBANDS, ENCUT, lattice), plane-wave coefficients for each k-point and band — for Wannier90 input (.amn/.mmn computation) and wavefunction visualization. Performance-critical: use Rust for binary parsing of potentially multi-GB files
  • 127.2.4.10 Implement XDATCAR parser: read MD trajectory — sequence of structures at each ionic step in direct coordinates — return array of KalikaStructure with step indices
  • 127.2.4.11 Implement OSZICAR parser: read SCF convergence per ionic step — electronic iteration energies (dE, mag), ionic step energies and forces — for real-time convergence monitoring
  • 127.2.4.12 Implement ELFCAR parser: read electron localization function on FFT grid — same volumetric format as CHGCAR but values in [0,1] range — for chemical bonding analysis
  • 127.2.4.13 Implement IBZKPT parser: read irreducible k-points with weights after symmetry reduction — for verifying k-point meshes and symmetry-related debugging
  • 127.2.4.14 Implement ML_LOGFILE parser: parse VASP 6.3+ ML force field training log — extract training errors (energy, force, stress RMSE), Bayesian error estimates, ab initio vs. ML calls, training set size growth — for monitoring on-the-fly ML potential quality
  • 127.2.4.15 Implement vaspout.h5 reader: parse VASP 6.4+ HDF5 output format using an HDF5 reading library — extract all quantities (energies, forces, eigenvalues, DOS, charge density) from the structured HDF5 hierarchy — the future-proof VASP output format

127.2.5 Error Handling & Custodian-Matching Fixes#

  • 127.2.5.1 Implement VASP error detector: scan OUTCAR and stdout for known error signatures — ZBRENT (bracketing failure in line minimization), EDDDAV (sub-space rotation error), ZPOTRF (Cholesky decomposition failure), SGRCON (symmetry error), PRICEL (primitive cell issue), BRMIX (Kerker mixing failure), DENTET (tetrahedron integration with too few k-points), RHOSYG (charge density symmetrization error), POSMAP (atom mapping error), TOO_FEW_BANDS, EDDRMM (RMM-DIIS not converging)
  • 127.2.5.2 Implement automatic fix suggestions matching custodian VaspErrorHandler: ZBRENT → reduce POTIM by 50%, EDDDAV → switch ALGO to All, ZPOTRF → reduce POTIM or switch to CG (IBRION=2), BRMIX → set IMIX=1/AMIX=0.1/BMIX=0.001, DENTET → switch to ISMEAR=0, TOO_FEW_BANDS → increase NBANDS by 25%, EDDRMM → switch ALGO to Normal, PRICEL → set SYMPREC=1e-8
  • 127.2.5.3 Implement SCF convergence monitor: track energy difference per electronic step, detect oscillation (sign alternation in dE), detect divergence (|dE| increasing), detect slow convergence (|dE| decreasing too slowly) — suggest ALGO/AMIX/AMIN/BMIX adjustments
  • 127.2.5.4 Implement ionic convergence monitor: track max force, stress components, energy per ionic step — detect: not converging (forces increasing), oscillating, converged-but-not-global-minimum (energy plateau with large forces) — suggest IBRION/POTIM adjustments
  • 127.2.5.5 Implement VASP version compatibility layer: detect VASP version from OUTCAR/vasprun.xml header, apply version-specific tag aliases and defaults (e.g., ML_LMLFF in 6.3+, LHARTREE in 6.4+), warn about deprecated tags, select appropriate output parser variant

127.3 Quantum ESPRESSO Interface (@kalika/qe-io)#

127.3.1 pw.x Input Generation#

  • 127.3.1.1 Implement QE input file writer: generate pw.x input from typed QeInput object — format Fortran namelist blocks (&CONTROL, &SYSTEM, &ELECTRONS, &IONS, &CELL) with proper quoting and comma separation, followed by card blocks (ATOMIC_SPECIES, ATOMIC_POSITIONS, K_POINTS, CELL_PARAMETERS, CONSTRAINTS, OCCUPATIONS, ATOMIC_FORCES)
  • 127.3.1.2 Implement &CONTROL block generation: calculation type (scf/relax/vc-relax/md/vc-md), prefix, outdir, pseudo_dir, restart_mode, tprnfor, tstress, etot_conv_thr, forc_conv_thr, nstep, disk_io, verbosity — with validation of allowed values
  • 127.3.1.3 Implement &SYSTEM block generation: ibrav (0-14 Bravais lattice index) with celldm(1-6) or A/B/C/cosAB/cosAC/cosBC, nat, ntyp, ecutwfc, ecutrho (auto-set from ecutwfc × 4 for NC, ×8-12 for US/PAW), occupations (smearing/tetrahedra/fixed), smearing (gaussian/mv/mp/cold), degauss, nspin (1/2/4), starting_magnetization, noncolin, lspinorb, nbnd, tot_charge, input_dft (functional override), vdw_corr (grimme-d2/d3/ts/mbd), hubbard_u (DFT+U)
  • 127.3.1.4 Implement &ELECTRONS block generation: conv_thr, mixing_mode, mixing_beta, mixing_ndim, diagonalization (david/cg/ppcg), electron_maxstep, startingpot, startingwfc
  • 127.3.1.5 Implement &IONS block generation: ion_dynamics (bfgs/damp/verlet/langevin/...), upscale, trust_radius_min, trust_radius_max, bfgs_ndim
  • 127.3.1.6 Implement &CELL block generation: cell_dynamics (bfgs/damp-w/...), press, press_conv_thr, cell_dofree (all/x/y/z/xy/xz/yz/xyz/shape/volume/2Dxy/2Dshape)
  • 127.3.1.7 Implement ATOMIC_SPECIES card writer: element symbol, atomic mass, pseudopotential filename — with automatic pseudopotential selection from configured library
  • 127.3.1.8 Implement ATOMIC_POSITIONS card writer: support crystal (fractional), angstrom, bohr, alat, crystal_sg (space group Wyckoff positions) — with optional per-atom if_pos constraints (0/1 for each direction, QE equivalent of VASP selective dynamics)
  • 127.3.1.9 Implement K_POINTS card writer: automatic (nk1 nk2 nk3 sk1 sk2 sk3), gamma, tpiba, crystal, tpiba_b (band structure), and crystal_b (band structure in crystal coords) — with auto-generation from target density
  • 127.3.1.10 Implement CELL_PARAMETERS card writer: when ibrav=0, write lattice vectors in angstrom, bohr, or alat units

127.3.2 QE Presets & Pseudopotential Management#

  • 127.3.2.1 Implement QE presets: scf (standard SCF), relax (ionic relaxation), vc-relax (full cell relaxation), band_structure (NSCF + bands.x), dos (NSCF + dos.x + projwfc.x), phonon (SCF → ph.x DFPT), md_nvt (Car-Parrinello or Born-Oppenheimer MD) — each preset sets all required namelists and cards with sensible defaults
  • 127.3.2.2 Implement pseudopotential library manager: support SSSP (Standard Solid-State Pseudopotentials) efficiency and precision libraries, PseudoDojo NC/US/PAW — for each element, store recommended pseudopotential filename, ecutwfc, ecutrho, and dual (rho/wfc ratio) — auto-select based on target accuracy
  • 127.3.2.3 Implement pseudopotential validation: verify UPF file header (PP_HEADER), extract Z_valence, mesh_size, functional, relativistic flag, is_ultrasoft/is_paw — ensure consistency with &SYSTEM settings

127.3.3 QE Output Parsing#

  • 127.3.3.1 Implement pw.x output parser: extract total energy (Ry), forces (Ry/Bohr), stress (kbar), eigenvalues, Fermi energy, magnetization, SCF convergence history, timing, number of k-points, number of plane waves, symmetry operations detected — handle both terminated and crashed runs
  • 127.3.3.2 Implement QE XML parser (data-file-schema.xml): parse QE 6.x+ XML output — extract: input parameters, atomic structure (initial + final), band structure (eigenvalues at all k-points), total energy, forces, stress, timing, convergence info — this is the robust machine-readable output format
  • 127.3.3.3 Implement ph.x output parser: extract dynamical matrices at each q-point, phonon frequencies (cm⁻¹ and THz), Born effective charges (Z*), macroscopic dielectric constant (ε∞), mode symmetry labels, Raman tensors (if calculated), IR intensities
  • 127.3.3.4 Implement matdyn.x output parser: parse phonon dispersion (frequencies along q-path) and phonon DOS from matdyn.x output — return PhononBandStructure and PhononDOS objects
  • 127.3.3.5 Implement pp.x output parser: read charge density, potential, ELF in cube format and XSF (XCrySDen) format — volumetric data on real-space grid for visualization

127.3.4 Additional QE Tool Interfaces#

  • 127.3.4.1 Implement bands.x interface: generate input for band structure post-processing (filband, lsym), parse output (bands.dat, bands.dat.gnu) for plotting
  • 127.3.4.2 Implement dos.x interface: generate input (fildos, Emin, Emax, DeltaE, ngauss, degauss), parse output DOS file — total DOS
  • 127.3.4.3 Implement projwfc.x interface: generate input (filpdos, Emin, Emax, DeltaE, ngauss, degauss), parse projected DOS output — per-atom, per-orbital PDOS files (.pdos_atm#_wfc#*)
  • 127.3.4.4 Implement epsilon.x interface: generate input for optical properties (interband transitions), parse dielectric function output (real and imaginary parts vs. energy)
  • 127.3.4.5 Implement hp.x interface: generate input for linear-response Hubbard U/V calculation (nq1-3, perturb_only_atom, compute_hp), parse output U and V values — for self-consistent DFT+U

127.4 ABINIT Interface (@kalika/abinit-io)#

127.4.1 Input Generation#

  • 127.4.1.1 Implement ABINIT input file writer: generate ABINIT input format (variable = value lines, multi-dataset syntax with jdtset/ndtset and variable? suffixes) — handle all value types: scalars, arrays, 2D arrays (rprim, xred), string-valued variables
  • 127.4.1.2 Implement core variable generation: acell, rprim (lattice), ntypat, znucl, natom, typat, xred/xcart/xangst (coordinates), ecut (PW cutoff), ngkpt + nshiftk + shiftk (k-points), tolvrs/toldfe/toldff (convergence), nstep, occopt + tsmear, nsppol/nspinor/nspden (spin), ixc (XC functional), pawecutdg (PAW augmentation cutoff)
  • 127.4.1.3 Implement multi-dataset generation: create multi-dataset ABINIT inputs for chained calculations (e.g., dataset 1: SCF, dataset 2: NSCF band structure, dataset 3: DOS) — with proper getden/irdden/irdwfk chaining between datasets
  • 127.4.1.4 Implement ABINIT presets: ground_state (standard SCF), relaxation (ionmov=2/22, optcell=0/2), band_structure (iscf=-2, kptopt=-N for line mode), dos (prtdos=1/2/3), dfpt_phonon (rfphon=1, rfatpol, rfdir), gw (optdriver=3/4, gwcalctyp), bse (optdriver=99, bs_loband, bs_nstates)

127.4.2 Output Parsing#

  • 127.4.2.1 Implement ABINIT main output parser: extract total energy (Ha), forces (Ha/Bohr), stress (Ha/Bohr³), eigenvalues, Fermi energy, magnetization, SCF convergence, timing, symmetry info, warnings/errors — handling multi-dataset outputs
  • 127.4.2.2 Implement ABINIT NetCDF output reader: parse _DEN.nc (density), _WFK.nc (wavefunctions), _DDB (derivative database for phonons), _EIG.nc (eigenvalues) — using a NetCDF reading library
  • 127.4.2.3 Implement ABINIT DDB file parser: parse derivative database (dynamical matrices, Born effective charges, dielectric tensor) — for Anaddb post-processing (phonon band structure, thermodynamic properties, Grüneisen parameters)
  • 127.4.2.4 Implement ABINIT GW output parser: extract quasiparticle energies (E_KS, E_QP, Z renormalization factors), self-energy Σ(ω) on real/imaginary frequency axis, spectral function

127.5 FHI-aims Interface (@kalika/fhi-aims-io)#

127.5.1 Input Generation#

  • 127.5.1.1 Implement geometry.in writer: write FHI-aims geometry file from KalikaStructure — lattice_vector lines (3 lines for periodic), atom or atom_frac lines (Cartesian or fractional), optional velocity, initial_moment, constrain_relaxation per atom
  • 127.5.1.2 Implement control.in writer: generate FHI-aims control file — xc (pbe/hse06/pbe0/lda/...), relativistic (atomic_zora/zora/none), spin (collinear/none), k_grid (n1 n2 n3), sc_accuracy_rho, sc_accuracy_eev, sc_accuracy_etot, sc_accuracy_forces, relax_geometry (bfgs/trm), relax_unit_cell (full/shape/none), compute_forces, output band lines, output dos settings — followed by species-specific basis set blocks
  • 127.5.1.3 Implement FHI-aims basis set selection: for each element, append the appropriate species_defaults block (light, intermediate, tight, really_tight) from the FHI-aims species_defaults directory — NAO (numeric atomic orbital) basis functions with radial functions, angular momentum channels, and basis set superposition
  • 127.5.1.4 Implement FHI-aims presets: scf (standard ground state), relax (geometry optimization with BFGS), band_structure (with output band directives along high-symmetry path), dos (with output dos settings), hybrid (HSE06/PBE0 with RI-V acceleration)

127.5.2 Output Parsing#

  • 127.5.2.1 Implement aims.out parser: extract total energy (eV), forces, stress, eigenvalues, Fermi energy, band gap, timing, SCF convergence history, Mulliken charges, Hirshfeld charges — handle periodic and molecular outputs
  • 127.5.2.2 Implement FHI-aims band structure parser: read band*.out files (k-point, eigenvalues per band, occupation) — construct BandStructure object with k-path labels

127.6 Other DFT Code Interfaces (@kalika/code-interfaces)#

127.6.1 SIESTA Interface#

  • 127.6.1.1 Implement SIESTA .fdf input writer: generate Flexible Data Format input — SystemName, SystemLabel, NumberOfAtoms, NumberOfSpecies, PAO.BasisSize (SZ/SZP/DZ/DZP/TZP), MeshCutoff, DM.MixingWeight, DM.Tolerance, MaxSCFIterations, MD.TypeOfRun, MD.NumCGsteps — plus block entries: %block LatticeVectors, %block AtomicCoordinatesAndAtomicSpecies, %block kgrid_Monkhorst_Pack, %block ChemicalSpeciesLabel
  • 127.6.1.2 Implement SIESTA output parser: parse .out file for total energy, forces, stress, Mulliken populations, eigenvalues, band structure (SystemLabel.bands), DOS (SystemLabel.DOS) — plus .XV (optimized coordinates), .ANI (trajectory)
  • 127.6.1.3 Implement SIESTA pseudopotential handling: .psf (Troullier- Martins) and .psml (PSML standard) format detection and validation

127.6.2 CP2K Interface#

  • 127.6.2.1 Implement CP2K .inp writer: generate CP2K input in hierarchical section format (&GLOBAL, &FORCE_EVAL{&DFT{&QS, &SCF, &XC, &MGRID, &POISSON}, &SUBSYS{&CELL, &COORD, &KIND}}, &MOTION{&GEO_OPT, &MD, &CELL_OPT}) — proper indentation and section nesting
  • 127.6.2.2 Implement CP2K output parser: extract total energy, forces, stress, SCF convergence, eigenvalues, Mulliken charges, band structure, MD trajectory — handle GPW (Gaussian and Plane Waves) and GAPW outputs
  • 127.6.2.3 Implement CP2K basis set and GTH pseudopotential selection: map elements to appropriate MOLOPT/ccGRB basis sets and GTH-PBE/GTH-BLYP pseudopotentials

127.6.3 GPAW Interface#

  • 127.6.3.1 Implement GPAW Python script generator: generate a Python script that imports gpaw, creates GPAW(mode=PW(ecut), xc='PBE', kpts=..., txt='output.txt'), attaches to ASE Atoms, runs calc.get_potential_energy() — for SCF, relaxation, band structure, DOS workflows
  • 127.6.3.2 Implement GPAW output parser: parse gpaw .txt output and .gpw binary restart file — extract energy, forces, eigenvalues, DOS

127.6.4 WIEN2k Interface#

  • 127.6.4.1 Implement WIEN2k struct file writer: generate case.struct with lattice type, lattice parameters, atom positions (in internal coordinates), RMT values (muffin-tin radii), R0 (first radial mesh point), NPT (number of radial mesh points), ISPLIT — the master input file for all-electron LAPW calculations
  • 127.6.4.2 Implement WIEN2k case.in* file generators: case.in1 (LAPW1: K-VECTORS, Emin/Emax), case.in2 (LAPW2: Fermi energy, partial charges), case.inm (MIXER: mixing parameters)
  • 127.6.4.3 Implement WIEN2k output parser: parse case.scf (SCF summary with energy, charge, moment per iteration), case.energy (eigenvalues), case.dos* (DOS)

127.6.5 Other Code Stubs#

  • 127.6.5.1 Implement Elk elk.in writer: key blocks — tasks, avec (lattice), atoms (species + positions), ngridk, rgkmax, swidth — and output parser for TOTENERGY.OUT, EIGVAL.OUT, TDOS.OUT
  • 127.6.5.2 Implement CASTEP .cell/.param writer: .cell (lattice_cart, positions_frac, kpoint_mp_grid, symmetry_ops, species_pot), .param (task, xc_functional, cut_off_energy, elec_energy_tol, max_scf_cycles) — and .castep output parser
  • 127.6.5.3 Implement FLEUR inp.xml writer: generate XML-based input (lattice, atomGroups, xcFunctional, kPointMesh, cutoffs) — and output parser for out.xml
  • 127.6.5.4 Implement CRYSTAL .d12 writer: geometry (dimensionality, space group, lattice, atoms), basis set (all-electron or ECP), DFT parameters — and output parser for total energy, forces, band structure
  • 127.6.5.5 Implement Gaussian .gjf/.com writer: route section (#p method/basis), charge/multiplicity, geometry, additional keywords — and .log + .fchk output parser (energy, forces, frequencies, molecular orbitals)
  • 127.6.5.6 Implement ORCA .inp writer: method block (! DFT PBE def2-SVP), %pal (parallelism), %scf (convergence), coordinate block — and output parser for energy, forces, frequencies, NMR, EPR parameters

127.7 LAMMPS Interface (@kalika/lammps-io)#

127.7.1 Data File I/O#

  • 127.7.1.1 Implement LAMMPS data file writer: generate atom data in full/atomic/charge/molecular atom styles — header (atom count, bond count, atom types, box bounds), Masses section, Atoms section (id, mol-id, type, charge, x, y, z), Velocities section, plus optional Bonds/Angles/Dihedrals/Impropers sections for molecular systems
  • 127.7.1.2 Implement LAMMPS data file reader: parse all sections of a LAMMPS data file — atoms, velocities, bonds, angles, masses, box dimensions (orthogonal and triclinic with tilt factors xy, xz, yz) — return KalikaStructure with topology information

127.7.2 Input Script Generation#

  • 127.7.2.1 Implement LAMMPS input script builder: fluent API for constructing LAMMPS input scripts — setUnits('metal'), setAtomStyle('atomic'), setBoundary('p p p'), readData('data.lmp'), setPairStyle('eam/alloy'), setPairCoeff('* * pot.eam.alloy Al Cu'), addFix('1 all nvt temp 300 300 0.1'), addCompute(...), setTimestep(0.001), addDump(...), setThermoStyle(...), setThermoFreq(100), run(10000) — serialize to valid LAMMPS script
  • 127.7.2.2 Implement pair style configuration helpers: generate pair_style and pair_coeff commands for common potentials — eam/alloy (single file, all elements), eam/fs (Finnis-Sinclair), tersoff (Si, C, BN), reaxff (with control file), lj/cut (with per-type ε, σ), buck (Buckingham), snap (SNAP ML potential), pace (ACE ML potential), meam — with automatic unit conversion
  • 127.7.2.3 Implement fix command helpers: generate fix commands for standard ensembles — nvt (Nosé-Hoover thermostat), npt (barostat + thermostat with iso/aniso/tri options), nve (microcanonical), langevin (Langevin thermostat), neb (nudged elastic band), shake (bond constraints), deform (box deformation for strain), wall/reflect (walls)
  • 127.7.2.4 Implement compute command helpers: pe/atom, stress/atom, rdf (radial distribution function with cutoff and bins), msd (mean square displacement), centro/atom (centrosymmetry parameter), cna/atom (common neighbor analysis), voronoi/atom, heat/flux (for Green-Kubo thermal conductivity)
  • 127.7.2.5 Implement dump command helpers: atom (id, type, x, y, z), custom (configurable columns: id, type, x, y, z, vx, vy, vz, fx, fy, fz, c_pe, c_stress[1-6]), cfg (AtomEye), netcdf (NetCDF format) — with dump_modify (element names, sort, pad)
  • 127.7.2.6 Implement LAMMPS presets: energy_minimization (min_style cg, minimize etol ftol maxiter maxeval), nvt_equilibration (fix nvt + thermo + dump), npt_equilibration (fix npt with iso/aniso barostat), tensile_test (fix deform + compute stress/atom + dump), thermal_conductivity (NEMD or Green-Kubo setup), neb (neb command + replica setup)

127.7.3 Output Parsing#

  • 127.7.3.1 Implement LAMMPS log file parser: extract thermodynamic data columns (Step, Temp, Press, PotEng, KinEng, TotEng, Volume, Density, Lx/Ly/Lz, custom computes) from each run — handle multiple run blocks, minimization output, and LAMMPS-style column headers
  • 127.7.3.2 Implement LAMMPS dump file parser (Rust + WASM): read custom dump format (ITEM: TIMESTEP, ITEM: NUMBER OF ATOMS, ITEM: BOX BOUNDS, ITEM: ATOMS) — multi-frame trajectory support, lazy loading for large files, support both orthogonal and triclinic boxes. Rust for performance on multi-GB trajectory files
  • 127.7.3.3 Implement LAMMPS restart file reader: read binary restart format — extract atom positions, velocities, box dimensions, force field parameters — for analysis and restart continuation

127.7.4 Potential File Management#

  • 127.7.4.1 Implement LAMMPS potential file registry: manage local potential file library (EAM: .eam.alloy/.eam.fs, Tersoff: .tersoff, ReaxFF: ffield.reax, SNAP: .snapparam+.snapcoeff, ACE: .yace) — index by element combination, potential type, source publication
  • 127.7.4.2 Implement OpenKIM query interface: query the OpenKIM API (query.openkim.org) for available interatomic potentials by element combination, model type, property tested — retrieve KIM model IDs for use with kim_interactions command in LAMMPS

127.8 GROMACS Interface (@kalika/gromacs-io)#

127.8.1 File I/O#

  • 127.8.1.1 Implement .gro coordinate file reader/writer: GROMACS format (title, atom count, residue number + name + atom name + atom number + coordinates in nm + optional velocities in nm/ps, box vectors) — convert to/from KalikaStructure
  • 127.8.1.2 Implement .top topology file writer: generate GROMACS topology — [defaults] (nbfunc, comb-rule, gen-pairs, fudgeLJ, fudgeQQ), [atomtypes], [moleculetype], [atoms] (nr, type, resnr, residue, atom, cgnr, charge, mass), [bonds], [pairs], [angles], [dihedrals] (proper + improper), [system], [molecules] — with #include for force field itp files
  • 127.8.1.3 Implement .mdp parameter file generator: generate run parameters for: em (energy minimization: integrator=steep/cg, emtol, emstep, nsteps), nvt (integrator=md, dt, nsteps, tcoupl= v-rescale, ref_t), npt (pcoupl=parrinello-rahman/berendsen, ref_p, tau_p), production (long MD run parameters) — with proper neighbor searching, cutoff, PME, constraint settings
  • 127.8.1.4 Implement .ndx index group file reader/writer: parse/generate GROMACS index files with named atom groups (System, Protein, DNA, Water, SOL, custom groups)

127.8.2 Trajectory & Energy Parsing#

  • 127.8.2.1 Implement .xtc trajectory reader (Rust + WASM): read compressed GROMACS trajectory format (XDR-encoded, lossy compression) — extract frame timestamps, box vectors, atom coordinates — lazy frame iteration for multi-GB trajectories. Rust for XDR decoding performance
  • 127.8.2.2 Implement .trr trajectory reader: read full-precision GROMACS trajectory (coordinates, velocities, forces, box, lambda) — XDR format parsing
  • 127.8.2.3 Implement .edr energy file reader: parse GROMACS portable energy format — extract all energy terms (Potential, Kinetic, Total, Temperature, Pressure, Volume, Density, individual LJ/Coulomb contributions) vs. time step
  • 127.8.2.4 Implement force field selection helper: map force field names (amber99sb-ildn, amber14sb, charmm36m, charmm27, oplsaa, gromos54a7) to appropriate GROMACS include paths and default settings

127.9 Phonopy / Phono3py Interface (@kalika/phonopy-io)#

127.9.1 Phonopy File I/O#

  • 127.9.1.1 Implement phonopy.yaml reader/writer: parse the master Phonopy YAML configuration (supercell_matrix, primitive_matrix, atom types, positions, displacements) — including phonopy_disp.yaml (supercells with displacements)
  • 127.9.1.2 Implement FORCE_SETS file reader/writer: read/write Phonopy force sets format (number of atoms, number of displacements, for each: atom index, displacement vector, forces on all atoms) — the bridge between DFT force calculations and phonon analysis
  • 127.9.1.3 Implement BORN file reader/writer: read/write Born effective charges and dielectric tensor — format: dielectric tensor (3×3), then Born charges (3×3 per atom) — needed for LO-TO splitting correction in polar materials
  • 127.9.1.4 Implement band.yaml reader: parse phonon band structure output — q-points along path, frequencies (THz), eigenvectors (complex, per atom per mode), labels at high-symmetry points — return PhononBandStructure object
  • 127.9.1.5 Implement mesh.yaml reader: parse phonon DOS mesh output — q-points on mesh, frequencies, weights — for phonon density of states calculation
  • 127.9.1.6 Implement thermal_properties.yaml reader: parse thermodynamic properties — temperature array, free energy (kJ/mol), entropy (J/K/mol), heat capacity Cv (J/K/mol) — from the quasiharmonic phonon partition function

127.9.2 Phonopy Workflow Integration#

  • 127.9.2.1 Implement supercell displacement generator: given a KalikaStructure and supercell_matrix, generate all symmetrically distinct displaced supercells (reproducing Phonopy's displacement generation algorithm — apply symmetry to reduce displacement count) — output as array of KalikaStructure ready for DFT calculations
  • 127.9.2.2 Implement force constant calculator: given FORCE_SETS (displacements + DFT forces), compute harmonic force constants Φ(R) using the finite displacement method — matrix equation relating displacements to forces via crystal symmetry constraints
  • 127.9.2.3 Implement phonon property calculator: given force constants, compute phonon frequencies and eigenvectors at arbitrary q-points via dynamical matrix D(q) = Σ_R Φ(R) exp(iq·R) / √(M_i M_j) — including non-analytic correction for polar materials (Born charges + dielectric tensor → LO-TO splitting)
  • 127.9.2.4 Implement phonon DOS calculator: compute phonon density of states by sampling frequencies on a dense q-mesh with tetrahedron integration — total DOS and projected DOS (per atom contribution)
  • 127.9.2.5 Implement phonon thermodynamics: from phonon DOS, compute temperature-dependent free energy F(T), entropy S(T), heat capacity C_v(T), zero-point energy via the phonon partition function Z = Π_qν [2 sinh(ℏω/2k_BT)]⁻¹

127.9.3 Phono3py Interface#

  • 127.9.3.1 Implement Phono3py FORCE_CONSTANTS_3RD reader/writer: read/write third-order force constants fc3(R1,R2) — the anharmonic force constants needed for lattice thermal conductivity
  • 127.9.3.2 Implement Phono3py thermal conductivity output parser: read kappa-m*.hdf5 or kappa-m*.dat — lattice thermal conductivity tensor κ_L(T) vs. temperature, mode-resolved κ contributions, phonon lifetimes τ(q,ν), group velocities v_g(q,ν), Grüneisen parameters

127.10 WANNIER90 Interface (@kalika/wannier90-io)#

127.10.1 Input Generation#

  • 127.10.1.1 Implement wannier90.win writer: generate Wannier90 input file — num_wann, num_bands, unit_cell_cart (lattice), atoms_frac/ atoms_cart, mp_grid (k-mesh), begin kpoints block, begin projections block — with all major keywords: dis_win_min/max, dis_froz_min/max (disentanglement windows), num_iter, conv_tol, conv_window, guiding_centres, write_hr, bands_plot, bands_num_points, begin kpoint_path block
  • 127.10.1.2 Implement projection block generator: generate begin projections from high-level specification — atom-centered projections (e.g., Fe: d, O: p, C: sp3), support all angular momentum channels (s, p, d, f), hybrid orbitals (sp, sp2, sp3, sp3d, sp3d2), custom radial functions, random projections — with automatic l, mr, r quantum number assignment
  • 127.10.1.3 Implement disentanglement window auto-setter: given eigenvalues from DFT, automatically determine optimal dis_win_min, dis_win_max (outer window encompassing target bands), dis_froz_min, dis_froz_max (frozen window around Fermi level or band gap) — heuristic based on band character and energy range

127.10.2 File I/O#

  • 127.10.2.1 Implement .amn file reader/writer: Wannier90 projection matrix A_{mn}(k) — for each k-point, the num_bands × num_wann complex matrix of initial projections — format: header (num_bands, num_kpts, num_wann), then (band, wann, kpt, Re, Im) entries
  • 127.10.2.2 Implement .mmn file reader/writer: overlap matrix M_{mn}(k,b) — for each k-point and each nearest-neighbor b-vector, the num_bands × num_bands complex overlap matrix — format: header, then (kpt, kpt+b, bx, by, bz) followed by matrix entries
  • 127.10.2.3 Implement .eig file reader/writer: eigenvalues ε_{nk} — for each k-point and band, the DFT eigenvalue (eV) — simple three-column format: (band, kpt, eigenvalue)
  • 127.10.2.4 Implement .wout output parser: parse Wannier90 output — extract: initial/final spread (Ω, Ω_I, Ω_D, Ω_OD), Wannier function centers and spreads (per WF), convergence history, disentanglement convergence (if applicable), symmetry-adapted WF info

127.10.3 Wannier Output & Applications#

  • 127.10.3.1 Implement _hr.dat reader: parse Wannier tight-binding Hamiltonian H(R) — degeneracy weights, then (Rx, Ry, Rz, i, j, Re_H, Im_H) entries — for Wannier-interpolated band structure and transport
  • 127.10.3.2 Implement Wannier-interpolated band structure calculator: given H(R) from _hr.dat, compute eigenvalues at arbitrary k-points via H(k) = Σ_R H(R) exp(ik·R) — much denser k-mesh than DFT for smooth band structure and accurate Fermi surface
  • 127.10.3.3 Implement _band.dat / _band.kpt reader: parse Wannier90 band structure output (k-point path coordinates + eigenvalues) for comparison with DFT bands
  • 127.10.3.4 Implement DFT→Wannier90 workflow connector: for VASP, generate INCAR tags (LWANNIER90=.TRUE. or manual .amn/.mmn via LWRITE_MMN_AMN); for QE, generate pw2wannier90.x input (outdir, prefix, seedname, write_amn, write_mmn, write_unk) — the glue between DFT and Wannier90
  • 127.10.3.5 Implement BoltzWann transport interface: generate BoltzWann input block in wannier90.win (boltzwann=.TRUE., boltz_calc_also_dos, boltz_mu_min/max, boltz_temp_min/max/step, boltz_relax_time) — parse BoltzWann output (σ, S, κ_e, PF vs. T, μ)

127.11 LOBSTER Interface (@kalika/lobster-io)#

127.11.1 Input Generation#

  • 127.11.1.1 Implement lobsterin writer: generate LOBSTER input file — COHPstartEnergy, COHPendEnergy, basisSet (pbeVaspFit2015 / basisSetMappingFile), gaussianSmearingWidth, userecommendedBasisSet, cohpGenerator (from/to atom lists), saveProjectionToFile, loadProjectionFromFile, basisfunctions (per-element orbital specifications: e.g., Fe 3d 4s 4p)
  • 127.11.1.2 Implement automatic orbital selection: given a structure and list of atom pairs of interest, automatically select appropriate basis functions for LOBSTER analysis (valence orbitals, bonding-relevant orbitals) following LOBSTER recommendations per element

127.11.2 Output Parsing#

  • 127.11.2.1 Implement COHPCAR.lobster parser: read Crystal Orbital Hamilton Population data — energy grid, COHP(E) and integrated COHP (ICOHP) for each atom pair — per-spin if spin-polarized, per-orbital decomposition if requested. Return structured CohpData with atom pair labels, distances, and COHP/ICOHP arrays
  • 127.11.2.2 Implement COOPCAR.lobster parser: read Crystal Orbital Overlap Population — same format as COHPCAR but for overlap population — return CoopData
  • 127.11.2.3 Implement ICOHPLIST.lobster parser: extract integrated COHP values (bond strengths) at Fermi level for all atom pairs — sorted by ICOHP value, with distances, labels, and translation vectors
  • 127.11.2.4 Implement CHARGE.lobster parser: read Löwdin and Mulliken charges per atom — return structured charge data
  • 127.11.2.5 Implement GROSSPOP.lobster parser: read gross orbital populations per atom per orbital — for detailed electronic structure analysis
  • 127.11.2.6 Implement COBICAR.lobster parser: read Crystal Orbital Bond Index (COBI) data — the bond-order analogue of COHP/COOP — parse energy-resolved and integrated COBI per atom pair

127.12 BoltzTraP2 Interface (@kalika/boltztrap-io)#

127.12.1 Input Preparation#

  • 127.12.1.1 Implement BoltzTraP2 input generator: from DFT band structure (eigenvalues on dense k-grid from VASP EIGENVAL or QE XML), generate BoltzTraP2 input — structure (lattice, atoms), eigenvalues ε_{nk} at all irreducible k-points, k-point weights, Fermi energy — in BoltzTraP2's expected format (or via Python bridge to btp2 API)

127.12.2 Output Parsing#

  • 127.12.2.1 Implement BoltzTraP2 transport coefficient parser: extract σ/τ (electrical conductivity / relaxation time), S (Seebeck coefficient), κ_e/τ (electronic thermal conductivity / relaxation time), R_H (Hall coefficient) — all as functions of temperature T and chemical potential μ — return structured TransportData with interpolation capabilities
  • 127.12.2.2 Implement thermoelectric figure of merit calculator: given BoltzTraP2 σ/τ, S, κ_e/τ, plus lattice thermal conductivity κ_L from Phono3py, and an assumed relaxation time τ — compute power factor PF = S²σ, and ZT = S²σT/(κ_e + κ_L) as function of T and carrier concentration — the key materials screening metric for thermoelectrics

127.13 Ecosystem Compatibility (@kalika/code-interfaces)#

127.13.1 ASE Compatibility#

  • 127.13.1.1 Implement ASE Atoms ↔ KalikaStructure bidirectional converter: map ASE Atoms (cell, positions, numbers, pbc, tags, momenta, initial_magnetic_moments, initial_charges, constraints) to/from KalikaStructure — preserve all site properties, handle FixAtoms and FixedLine/FixedPlane constraints ↔ selective dynamics
  • 127.13.1.2 Implement ASE Calculator adapter: wrap Kalika's code interfaces as an ASE-compatible Calculator (Python class via bridge) — implement calculate(), get_potential_energy(), get_forces(), get_stress() — enabling ASE workflows (optimizers, MD, NEB) to use Kalika-managed DFT codes as the energy/force engine
  • 127.13.1.3 Implement ASE trajectory reader/writer: read/write ASE's .traj format (Python pickle-based) and ASE's JSON trajectory format — for trajectory exchange between ASE and Kalika workflows
  • 127.13.1.4 Implement ASE database adapter: read/write ASE's SQLite database format (.db) — structure, energy, forces, stress, key-value pairs, data blobs — enabling Kalika to query and contribute to ASE databases

127.13.2 pymatgen Compatibility#

  • 127.13.2.1 Implement pymatgen Structure/Molecule ↔ KalikaStructure converter: map pymatgen Structure (lattice, species, frac_coords, site_properties) and Molecule (species, cart_coords) to/from KalikaStructure — handle oxidation states, spin, selective dynamics, Magmom objects
  • 127.13.2.2 Implement pymatgen DOS/BandStructure ↔ Kalika converter: convert pymatgen CompleteDos, Dos, BandStructureSymmLine objects to/from Kalika's DOS and BandStructure types — preserving orbital projections, spin channels, k-point labels
  • 127.13.2.3 Implement pymatgen PhaseDiagram compatibility: generate pymatgen-compatible PDEntry objects from Kalika calculation results (composition + energy) for phase stability analysis — or consume pymatgen PhaseDiagram results (stable entries, e_above_hull)
  • 127.13.2.4 Implement pymatgen InputSet/OutputParser adapter: bridge Kalika's VASP/QE input generators to pymatgen's VaspInputSet / QEInputSet interface, and Kalika's output parsers to pymatgen's Vasprun / Outcar classes — for code that expects pymatgen objects

127.13.3 Workflow Framework Compatibility#

  • 127.13.3.1 Implement AiiDA compatibility layer: convert Kalika WorkflowDAG to AiiDA WorkChain/CalcJob representation — map CalculationInput to AiiDA CalcJob inputs, CalculationOutput to AiiDA CalcJob outputs, WorkflowStep dependencies to AiiDA WorkChain logic — enable Kalika workflows to run on AiiDA infrastructure
  • 127.13.3.2 Implement FireWorks/Jobflow compatibility: convert Kalika WorkflowDAG to Jobflow Flow/Job representation (or FireWorks Workflow/ Firework/FireTask) — mapping step dependencies to job dependencies, output passing to data stores — for submission to FireWorks LaunchPad
  • 127.13.3.3 Implement custodian error handler registry: register Kalika's VASP/QE error handlers in a format compatible with custodian's ErrorHandler interface — check() (detect error) and correct() (apply fix) methods — so Kalika workflows get custodian-level robustness
  • 127.13.3.4 Implement atomate2 workflow recipe matching: for key atomate2 workflows (StaticMaker, RelaxMaker, BandStructureMaker, ElasticMaker, PhononMaker, DefectMaker), create equivalent Kalika WorkflowDAG templates that produce compatible output schemas

127.13.4 Additional Ecosystem Tools#

  • 127.13.4.1 Implement AFLOW prototype library interface: query AFLOW prototype encyclopedia (aflow.org/prototype-encyclopedia/) — given a composition and space group, retrieve matching prototypes (Strukturbericht designation, Pearson symbol, Wyckoff positions) — generate KalikaStructure from prototype
  • 127.13.4.2 Implement Open Babel molecular format bridge: via Python bridge to openbabel, convert between molecular formats (SMILES, InChI, MOL, SDF, PDB, XYZ, CIF, VASP) — enabling Kalika to ingest molecular structures from any standard chemistry format
  • 127.13.4.3 Implement CIF symmetry operations handler: parse and apply CIF symmetry operations (space group generators in x,y,z notation) to generate all symmetry-equivalent positions from asymmetric unit — essential for building full unit cells from CIF data

127.14 Materials Databases (@kalika/materials-databases)#

127.14.1 Materials Project API#

  • 127.14.1.1 Implement Materials Project REST client: authenticated HTTP client for MP API v2023+ (api.materialsproject.org) — API key management, rate limiting (configurable RPS), request retry with exponential backoff, pagination handling for large result sets
  • 127.14.1.2 Implement MP structure search: query materials by elements (contains/excludes), formula (exact/anonymous/reduced), crystal system, space group, number of sites, band gap range, energy above hull range, is_stable, magnetic ordering, has_props filter — return MaterialDoc list with material_id, formula, structure
  • 127.14.1.3 Implement MP property retrieval: fetch detailed properties for a material_id — total energy (per atom, per formula unit), formation energy, energy above hull, band gap (PBE, HSE, GW if available), DOS (total + projected), band structure, elastic tensor (C_ij, K_VRH, G_VRH, Poisson ratio), magnetic moment, dielectric constant, piezo tensor — return typed property objects
  • 127.14.1.4 Implement MP phase diagram client: fetch all entries in a chemical system (e.g., Li-Fe-O), construct PhaseDiagram from MP entries — compute stability (e_above_hull), decomposition products, equilibrium reaction, chemical potential ranges — for thermodynamic stability screening
  • 127.14.1.5 Implement MP thermo data access: fetch formation energies, decomposition energies, equilibrium reactions, energy above hull for all entries in a composition space — for large-scale stability analysis and Pourbaix diagram construction
  • 127.14.1.6 Implement MP task document access: fetch raw task documents (VASP calculation metadata) — INCAR settings used, k-point density, pseudopotentials, energy corrections applied (GGA mixing, anion corrections) — for reproducing or understanding MP calculations

127.14.2 AFLOW API#

  • 127.14.2.1 Implement AFLOW REST client: HTTP client for aflowlib.org REST API — construct AFLOW search URLs with filters (species, nspecies, Pearson, space_group, Egap, enthalpy_formation_atom), parse JSON responses, handle pagination (catalog, aurl)
  • 127.14.2.2 Implement AFLOW property retrieval: fetch structure (geometry, species, positions), formation enthalpy (enthalpy_formation_atom, enthalpy_formation_cell), band gap (Egap, Egap_type), elastic properties (ael_bulk_modulus_vrh, ael_shear_modulus_vrh, ael_poisson_ratio), magnetic properties — return typed objects
  • 127.14.2.3 Implement AFLOW prototype matching: given a KalikaStructure, query AFLOW prototype encyclopedia to identify the structure prototype (label, Strukturbericht, mineral name, Pearson symbol) — match by space group and Wyckoff positions

127.14.3 JARVIS API#

  • 127.14.3.1 Implement JARVIS REST client: HTTP client for jarvis.nist.gov API — query JARVIS-DFT, JARVIS-FF, JARVIS-ML datasets — filters by elements, formula, space group, dimensionality (3D/2D/1D), band gap range, formation energy range
  • 127.14.3.2 Implement JARVIS property retrieval: fetch DFT properties (optb88vdw formation energy, band gap, elastic constants, dielectric, piezoelectric, Born charges, phonon frequencies), 2D-specific properties (exfoliation energy, work function), ALIGNN ML predictions, solar cell efficiency metrics (SLME, SQ limit)
  • 127.14.3.3 Implement JARVIS 2D materials search: specialized query for 2D materials database — filter by number of layers, exfoliation energy, band gap, magnetic ordering — return structures with layer-specific properties

127.14.4 OQMD & NOMAD APIs#

  • 127.14.4.1 Implement OQMD REST client: query oqmd.org/api/v1 — search by composition, filter by stability (delta_e), formation energy (delta_e), band gap, space group — fetch structure (sites, lattice) and calculated properties
  • 127.14.4.2 Implement NOMAD API client: query nomad-lab.eu API v1 — search by elements, formula, code (VASP/QE/etc.), upload date, dataset — fetch structures, energies, band structure, DOS from the FAIR (Findable Accessible Interoperable Reusable) materials data repository

127.14.5 Crystallographic Databases#

  • 127.14.5.1 Implement COD (Crystallography Open Database) client: query cod.iimcb.gov.pl REST API — search by formula, elements, cell parameters, space group, journal reference — download CIF files, parse to KalikaStructure — completely free and open access
  • 127.14.5.2 Implement ICSD query interface: generate ICSD-compatible search queries (composition, space group, Pearson, Wyckoff, cell parameters, structure type) — parse ICSD CIF exports — note: ICSD requires institutional subscription, so implement query/parse but not direct API access
  • 127.14.5.3 Implement Materials Cloud API client: query materialscloud.org — browse AiiDA-based datasets (curated entries with full provenance), fetch structures and properties — especially useful for 2D materials, phonons, and GW datasets

127.14.6 Standardized APIs#

  • 127.14.6.1 Implement OPTIMADE client: query any OPTIMADE-compliant database (optimade.org) using standardized filter language — filter=elements HAS "Li" AND nelements=3 AND nsites<20 — parse OPTIMADE JSON:API responses, extract structures (species, coordinates, lattice_vectors) — works with MP, AFLOW, OQMD, COD, NOMAD, MC3D, and 30+ other databases through a single query interface
  • 127.14.6.2 Implement OPTIMADE provider registry: fetch and cache the list of OPTIMADE providers from providers.optimade.org — enable federated queries across all providers, aggregate results, de-duplicate by composition/space group
  • 127.14.6.3 Implement multi-database search aggregator: given search criteria (composition, property ranges), query multiple databases (MP, AFLOW, OQMD, JARVIS, NOMAD, COD) in parallel via OPTIMADE where available and native APIs otherwise — merge results, flag duplicates, compare reported properties across sources

127.14.7 Molecular & Chemical Databases#

  • 127.14.7.1 Implement PubChem REST client: query pubchem.ncbi.nlm.nih.gov PUG REST API — search by name, SMILES, InChI, molecular formula — retrieve 3D conformers, properties (molecular weight, charge, LogP, TPSA), CID — convert PubChem 3D structures to KalikaStructure (molecular, non-periodic)
  • 127.14.7.2 Implement Citrination/Citrine API client: query Citrine Informatics platform — search by material system, property (band gap, thermal conductivity, yield strength), data source — retrieve curated experimental and computational data — useful for ML training data

127.15 Workflow Engine (@kalika/workflows)#

127.15.1 DAG Execution Engine#

  • 127.15.1.1 Implement workflow execution engine: execute a WorkflowDAG — topological traversal, parallel execution of independent steps, data passing between steps (output file mapping → input file placement), status tracking per step, event emission (step started/completed/ failed), timeout handling, overall workflow status aggregation
  • 127.15.1.2 Implement job submission abstraction: JobSubmitter interface with implementations for local execution (child process), SSH remote (paramiko-style), PBS/Torque (qsub), SLURM (sbatch), SGE (qsub with SGE flags), LSF (bsub) — each generating the appropriate job script with resource requests (nodes, cores, memory, walltime, queue)
  • 127.15.1.3 Implement job status polling: for each scheduler backend (local/PBS/SLURM/SGE/LSF), implement getStatus(jobId): JobStatus — map scheduler-specific states (SLURM: PENDING/RUNNING/COMPLETING/ COMPLETED/FAILED/TIMEOUT/CANCELLED) to Kalika JobStatus enum — with configurable polling interval and exponential backoff
  • 127.15.1.4 Implement error recovery engine: when a workflow step fails, invoke the code-specific error detector (127.2.5.1 for VASP, etc.), apply automatic fixes if available, and restart the step — with configurable retry policy (max retries, fix escalation sequence) and dead-letter queue for unrecoverable failures

127.15.2 Provenance & Results#

  • 127.15.2.1 Implement provenance tracker: for each workflow execution, record the full provenance chain — input structure, calculation parameters (every INCAR/KPOINTS/POTCAR tag), code version, output files, parsed results, wall time, node/core count — stored as a DAG of ProvenanceNode objects with immutable content hashing
  • 127.15.2.2 Implement results database: store parsed calculation results (structure, energy, forces, band gap, DOS, elastic constants, etc.) in a queryable format — SQLite backend with typed columns, compound indices, and full-text search on notes/tags — for local result management and comparison
  • 127.15.2.3 Implement results comparison engine: given two or more calculation results for the same structure (e.g., PBE vs. HSE, or different k-point densities), compute differences in energy, forces, band gap, DOS overlap, elastic constants — for convergence testing and functional benchmarking
  • 127.15.2.4 Implement provenance serialization: export/import full provenance records as JSON/YAML — including structure snapshots, input parameters, output summaries, timing — for reproducibility documentation and sharing

127.15.3 Built-in Workflow Templates#

  • 127.15.3.1 Implement relaxation_static workflow: relax structure (ISIF=3, IBRION=2) → static calculation (ISMEAR=-5) → optional DOS/band structure — with automatic CONTCAR→POSCAR chaining, CHGCAR passing for NSCF, convergence checking between relax and static
  • 127.15.3.2 Implement convergence_encut workflow: run series of static calculations with increasing ENCUT (e.g., 200-800 eV in 50 eV steps) — extract energy vs. ENCUT, determine converged ENCUT (energy change < threshold, default 1 meV/atom)
  • 127.15.3.3 Implement convergence_kpoints workflow: run series of static calculations with increasing k-point density (e.g., 2×2×2 to 12×12×12) — extract energy vs. k-points, determine converged mesh
  • 127.15.3.4 Implement elastic_constants workflow: apply 6 independent deformations (3 normal + 3 shear, with ±δ for central differences) to relaxed structure → static calculation for each → extract stress tensors → compute full 6×6 elastic tensor C_ij via stress-strain relation → derive bulk modulus K, shear modulus G (Voigt-Reuss-Hill averages), Young's modulus E, Poisson ratio ν
  • 127.15.3.5 Implement phonon_supercell workflow: generate supercell with Phonopy-compatible displacements → DFT force calculation for each displaced supercell → collect forces into FORCE_SETS → compute force constants → phonon band structure + DOS + thermodynamic properties — with automatic supercell size selection based on target accuracy
  • 127.15.3.6 Implement defect_formation_energy workflow: relax bulk supercell → create defect supercell (vacancy, substitution, interstitial) → relax defect supercell → compute raw defect formation energy E_f = E_defect - E_bulk + Σ n_i μ_i + q(E_VBM + E_Fermi) + E_correction — apply finite-size corrections (Freysoldt/Kumagai for charged defects)
  • 127.15.3.7 Implement surface_energy workflow: cleave slab from bulk (Miller indices hkl, slab thickness, vacuum thickness) → optimize slab → compute surface energy γ = (E_slab - n·E_bulk) / (2A) — with slab thickness convergence testing (increasing layers until γ converges)
  • 127.15.3.8 Implement neb_barrier workflow: interpolate images between initial and final structures (linear interpolation or IDPP — image dependent pair potential) → run CI-NEB calculation → extract minimum energy path and activation barrier — with automatic image count selection
  • 127.15.3.9 Implement gw_band_gap workflow: DFT relaxation → DFT static (dense k-mesh, many empty bands) → G0W0 calculation → extract quasiparticle band gap — with automatic NBANDS, ENCUTGW, NOMEGA convergence checks
  • 127.15.3.10 Implement optical_bse workflow: DFT → GW (quasiparticle energies) → BSE (Bethe-Salpeter equation for excitons) → absorption spectrum with excitonic effects — extract optical gap, exciton binding energy, dielectric function ε(ω)
  • 127.15.3.11 Implement thermoelectric_zt workflow: DFT relaxation → static (dense k-mesh) → Wannier90 interpolation → BoltzTraP2/BoltzWann transport (σ/τ, S, κ_e/τ) + phonon workflow (κ_L from Phono3py) → combine for ZT(T, n) map — the complete thermoelectric screening pipeline
  • 127.15.3.12 Implement band_structure_hybrid workflow: PBE relaxation → PBE static → HSE06 or PBE0 band structure (NSCF with hybrid functional on PBE charge density) — for accurate band gap prediction beyond semilocal DFT

127.15.4 Workflow Utilities#

  • 127.15.4.1 Implement workflow serialization: save/load WorkflowDAG definitions as YAML/JSON — including all step parameters, dependencies, output mappings, retry policies — for workflow sharing and version control
  • 127.15.4.2 Implement workflow dry-run mode: validate a WorkflowDAG without executing — check all input file dependencies are satisfied, all referenced codes are available, all parameter values are valid, estimated compute cost (core-hours) from similar past runs
  • 127.15.4.3 Implement workflow progress dashboard data: emit structured status updates for each workflow — overall progress (steps completed/ total), per-step status (waiting/running/done/failed), estimated time remaining, resource utilization — for consumption by a UI layer
  • 127.15.4.4 Implement workflow template registry: register, discover, and instantiate built-in and user-defined workflow templates by name — registry.get('elastic_constants').instantiate({ structure, code: 'vasp', functional: 'PBE' }) — with parameter validation against template schema

127.16 Integration Tests & Cross-Code Validation#

127.16.1 Round-Trip Tests#

  • 127.16.1.1 Implement VASP round-trip tests: generate INCAR/POSCAR/ KPOINTS for Si diamond (FCC, 2 atoms) with each preset → write to string → parse back → verify all parameters preserved — for each preset (static, relaxation, band_structure, dos, dielectric, hybrid, phonon, elastic, aimd, soc)
  • 127.16.1.2 Implement QE round-trip tests: generate pw.x input for Si, GaAs, Fe (magnetic) with each preset → write → parse → verify all namelists and cards preserved — test ibrav=0 and ibrav>0 modes
  • 127.16.1.3 Implement LAMMPS round-trip tests: generate data file + input script for Cu FCC (EAM), SiO2 (Tersoff), polymer (full atom style) → write → parse → verify atom coordinates, box dimensions, pair coefficients preserved
  • 127.16.1.4 Implement structure format round-trip tests: convert Si diamond through all format converters (CIF → KalikaStructure → POSCAR → KalikaStructure → QE input → KalikaStructure → XYZ → KalikaStructure → CIF) — verify lattice parameters and fractional coordinates preserved within tolerance (1e-10)

127.16.2 Cross-Code Consistency Tests#

  • 127.16.2.1 Implement cross-code input consistency tests: for the same structure (Si diamond) and equivalent parameters (PBE, 500 eV, 8×8×8 k-mesh), generate inputs for VASP, QE, ABINIT, FHI-aims — verify that equivalent physical parameters are set (same XC functional, same effective PW cutoff in Ry vs eV, same k-mesh)
  • 127.16.2.2 Implement unit conversion tests: verify all unit conversions against NIST reference values — eV↔Ha, Å↔Bohr, GPa↔kbar, etc. — with tolerances matching published CODATA uncertainties
  • 127.16.2.3 Implement database API response tests: mock HTTP responses from MP, AFLOW, JARVIS, OQMD APIs with real response payloads → parse → verify extracted structures and properties match known values (e.g., Si mp-149 band gap ≈ 0.6 eV PBE, ≈ 1.17 eV HSE)

127.16.3 Output Parser Validation#

  • 127.16.3.1 Implement VASP output parser tests: include fixture files (truncated real OUTCAR, vasprun.xml, DOSCAR, EIGENVAL, PROCAR for Si, Fe, GaAs) → parse → verify extracted energies, forces, band gap, DOS shape against reference values from the actual VASP runs
  • 127.16.3.2 Implement QE output parser tests: include fixture files (truncated pw.x output, XML data-file-schema for Si, MgO) → parse → verify energies (Ry), forces, eigenvalues against known values
  • 127.16.3.3 Implement Phonopy parser tests: include fixture files (band.yaml, mesh.yaml, FORCE_SETS for Si 2×2×2 supercell) → parse → verify phonon frequencies at Γ (3 acoustic = 0, 3 optical ≈ 15.5 THz for Si), thermodynamic properties at 300 K against published values
  • 127.16.3.4 Implement Wannier90 parser tests: include fixture files (.wout for Si 4-band sp3 Wannier functions, _hr.dat) → parse → verify spread convergence, Wannier centers at bond-center positions, Hamiltonian matrix elements against reference
  • 127.16.3.5 Implement LOBSTER parser tests: include fixture COHPCAR for Fe-Fe bond → parse → verify ICOHP value, energy range, orbital decomposition against published LOBSTER tutorial values

127.16.4 Workflow Template Tests#

  • 127.16.4.1 Implement workflow DAG validation tests: construct each built-in workflow template → validate DAG (no cycles, all dependencies satisfied, all output mappings valid) → verify execution order layers — test with different codes (VASP, QE) and parameter variations
  • 127.16.4.2 Implement workflow serialization round-trip tests: for each built-in workflow template, serialize to YAML → deserialize → verify all steps, dependencies, and parameters preserved
  • 127.16.4.3 Implement error handler tests: simulate common VASP errors (inject ZBRENT, EDDDAV, ZPOTRF signatures into mock OUTCAR) → verify error detection triggers → verify fix suggestions are correct (POTIM reduction, ALGO change, etc.)
  • 127.16.4.4 Implement provenance tracking tests: execute a mock 3-step workflow → verify provenance DAG records all inputs, outputs, parameters, timing for each step — verify immutable content hashes match expected values

127.17 Documentation & Type Exports#

127.17.1 Public API Surface#

  • 127.17.1.1 Implement barrel exports for @kalika/code-interfaces: export all core types (CalculationInput, CalculationOutput, CodeInterface, WorkflowStep, WorkflowDAG, JobStatus, KalikaStructure), all code-specific interfaces (VaspInterface, QeInterface, AbinitInterface, etc.), all converters (CIF, POSCAR, XYZ, PDB), unit conversion utilities, physical constants
  • 127.17.1.2 Implement barrel exports for @kalika/vasp-io: export INCAR writer/reader/validator/presets, POSCAR reader/writer, KPOINTS writer (automatic + line-mode), POTCAR manager, all output parsers (OUTCAR, vasprun.xml, DOSCAR, EIGENVAL, PROCAR, CHGCAR, etc.), error handlers, version compatibility layer
  • 127.17.1.3 Implement barrel exports for @kalika/qe-io: export pw.x input writer/presets, pseudopotential manager, all output parsers (pw.x, XML, ph.x, matdyn.x, pp.x), post-processing tool interfaces (bands.x, dos.x, projwfc.x, epsilon.x, hp.x)
  • 127.17.1.4 Implement barrel exports for @kalika/lammps-io: export data file reader/writer, input script builder, pair style helpers, fix/compute/dump helpers, presets, log parser, dump parser, potential registry, OpenKIM interface
  • 127.17.1.5 Implement barrel exports for @kalika/materials-databases: export all database clients (MP, AFLOW, JARVIS, OQMD, NOMAD, COD, ICSD, Materials Cloud, OPTIMADE, PubChem, Citrination), multi-database aggregator, OPTIMADE provider registry
  • 127.17.1.6 Implement barrel exports for @kalika/workflows: export WorkflowDAG, execution engine, job submitters (local/SLURM/PBS/SGE/ LSF), all built-in workflow templates, provenance tracker, results database, template registry
  • 127.17.1.7 Implement barrel exports for ancillary libraries: @kalika/abinit-io, @kalika/fhi-aims-io, @kalika/phonopy-io, @kalika/wannier90-io, @kalika/lobster-io, @kalika/boltztrap-io, @kalika/gromacs-io — each exporting all public types, generators, parsers, and utilities