diff --git a/.bumpversion.cfg b/.bumpversion.cfg index 9c21bcd3..a553437c 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 2.2.1 +current_version = 2.3.0 commit = True tag = True diff --git a/.gitignore b/.gitignore index 9352105c..82ffafcf 100644 --- a/.gitignore +++ b/.gitignore @@ -21,6 +21,7 @@ alchemy-* *.data *.dump melting_temperature-* +dcci-* composition_scaling-* # transition-detection + melting-temperature artefacts diff --git a/CITATION.cff b/CITATION.cff index 8d00111f..a7073fc8 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -61,4 +61,4 @@ abstract: >- examples illustrate the accuracy and efficiency of our implementation. license-url: 'https://github.com/ICAMS/calphy/blob/main/LICENSE' -version: 2.2.1 +version: 2.3.0 diff --git a/DCCI_PLAN.md b/DCCI_PLAN.md new file mode 100644 index 00000000..61c93ba8 --- /dev/null +++ b/DCCI_PLAN.md @@ -0,0 +1,299 @@ +# Implementation plan: dynamic Clausius-Clapeyron integration (mode `dcci`) + +**Status:** proposal, awaiting owner review +**Date:** 2026-09-10 +**Reference:** M. de Koning, A. Antonelli, S. Yip, *Single-simulation determination of phase +boundaries: A dynamic Clausius-Clapeyron integration method*, J. Chem. Phys. 115, 11025 (2001), +DOI 10.1063/1.1420486 (`reference_paper/11025_1_online.pdf`). + +**Goal:** given one known coexistence point (T_m, P_i) for a solid and a liquid, trace the +whole coexistence line P_coex(T) between P_i and P_f in one nonequilibrium run per direction, +with two LAMMPS cells (solid, liquid) driven side by side, using the reversible-scaling +formulation of the paper. Output a `coexistence_line.dat` with a forward/backward hysteresis +estimate, in the same spirit as `ts` writes `temperature_sweep.dat`. + +**Non-goals (v1):** multi-component systems with different compositions in the two phases, +solid-solid boundaries (works in principle, not validated), Monte Carlo swaps, restart/resume +of an interrupted sweep, the paper's Woon/argon reproduction. + +--- + +## 1. The method, in calphy's variables + +Scaled system: `H_RS = K + lambda * U`, thermostatted at the *fixed* kinetic temperature `T0 = T_m`, +barostatted at the *scaled* pressure `P_RS`. Mapping to the real system (paper Eqs. 10, 11): + +``` +T = T0 / lambda +P_real = P_RS / lambda +``` + +Coexistence is preserved under a perturbation `(d lambda, d P_RS)` when the reversible work is +equal in both cells (Eqs. 18-20): + +``` +(u_s - u_l) d lambda + (v_s - v_l) d P_RS = 0 +``` + +with `u = /N = /(N lambda)` in eV/atom (LAMMPS reports `lambda * U_real` under +`hybrid/scaled`, exactly as `integrate_rs` already divides by lambda) and `v = /N` in +A^3/atom, `P_RS` converted bar -> eV/A^3 with the existing `EV_A3_TO_BAR`. Per-atom quantities +make the two cells free to have different N. The 3/2 k_B T ln(lambda) kinetic term of Eq. 12 is +identical per atom in both phases and cancels, so it never appears. + +**Independent variable: `P_RS`, ramped linearly in time. Dependent variable: `lambda`.** + +``` +d lambda / d P_RS = -(v_s - v_l) / (u_s - u_l) (Eq. 20 inverted) +``` + +This is the paper's own choice for the LJ test ("the scaled pressure P_RS was chosen as the +independent variable"), and it is forced on us by LAMMPS, see Section 2. The singular case is +`u_s = u_l` (never at a melting line); the alternative formulation (lambda independent, Eq. 23) is +singular at `v_s = v_l`, i.e. at a melting-curve maximum, and needs a time-dependent barostat +target that `fix npt` cannot provide. Section 6 lists it as an extension. + +Diagnostic written per block, for the user and for the tests: the real-space slope +`dP/dT = dH / (T dV)` with `dH = (u_l - u_s) + P_real (v_l - v_s)`, which must agree with the +finite-difference slope of the produced curve. + +### Discrete integration (one "block" = `n_block_steps` MD steps) + +Block k spans `P_RS,k -> P_RS,k+1` (known in advance, linear ramp). Let +`f_k = -(v_s - v_l)/(u_s - u_l)` from the block-k averages, `h = P_RS,k+1 - P_RS,k`. + +* Inside block k, lambda is ramped linearly from `lambda_k` to a *predicted* end value + `lambda_k + h f_(k-1)` (held constant at `lambda_0 = 1` in the first block). This keeps the + scaled Hamiltonian continuous in time instead of jumping at block boundaries. +* After the block, the corrected `lambda_(k+1) = lambda_k + h f_k` (Euler with the block average; + optional trapezoid `h (f_k + f_(k-1))/2` behind `dcci.integrator`). The O(h^2) mismatch between + predicted and corrected end value is the block-boundary perturbation; it vanishes with block size. +* Real-space point k: `T_k = T0/lambda_k`, `P_k = P_RS,k/lambda_k`. + +Per-step updating (the paper) is the `n_block_steps: 1` limit and is only sensible in +`execution_mode: library`. + +--- + +## 2. LAMMPS mechanics and the design constraints they impose (verified in the checkout) + +| Fact (source) | Consequence for the design | +|---|---| +| `fix npt` accepts only numeric `Pstart Pstop` (`src/fix_nh.cpp` lines 141-240, `utils::numeric`); no `v_` variable support. Its ramp is `(step - beginstep)/(endstep - beginstep)` (lines 2367-2381). | A time-dependent barostat target must be a linear ramp fixed at fix creation. Hence `P_RS` is the independent, linear variable and the fix is created once per sweep with `iso P_RS,i P_RS,f`. Blocks are run with `run n_block start 0 stop N` so the ramp follows global progress, not the block. Re-creating the fix per block would reset the Nose-Hoover chain (eta, omega) every block and is ruled out. | +| `pair_style hybrid/scaled` looks its scale variable up *by name every compute* (`src/pair_hybrid_scaled.cpp` lines 73-95, 437-450). | lambda can be an equal-style variable redefined per block by the driver (`variable lam equal +*(step-)/`, only literal numbers, no `$(...)` immediate evaluation so it survives `ExecutableRunner` segment boundaries). | +| `fix ave/time` flushes its file at every output (`fix_ave_time.cpp` lines 683, 904); `ExecutableRunner` suffixes replayed `file` targets with `.seg` and `read_timeseries` concatenates them. | Block averages of `pe/atoms`, `vol/atoms`, `v_lam` are read back through the existing runner contract (`fix fav all ave/time 1 n_block n_block ... file dcci.._.dat`, one row per block). No new data accessor is needed; `sync()` per block then read the last row. Works identically for `LibraryRunner`. | +| `fix nh` writes/reads its state to restart files (`fix_nh.cpp` 1247-1340) and `run ... start/stop` exists (`run.cpp` 68-73). | Executable mode: one block = one segment, barostat state carries over (this is already what `test_t2_nose_hoover_restoration` checks for a constant target). Needs one new check for a *ramped* target, Part 0. | +| `reset_timestep` is not in the runner vocabulary (`runner.py` `KNOWN_TOKENS`). | Add it to `ONE_SHOT_TOKENS` (restart files carry the timestep, so replay is unaffected), or have the driver track the step counter and pass `start S0 stop S0+N`. Prefer `reset_timestep 0` before each sweep for readable logs. | + +Cost in executable mode: one `lmp` process launch per block per cell. For a 1e5-step sweep with +`n_block_steps: 1000` that is 100 launches per cell per direction, well under the MD time. Library +mode has no per-block cost and can use `n_block_steps` of 10-100. + +--- + +## 3. Code changes + +### 3.1 `calphy/input.py` + +* New block `dcci: DynamicClausiusClapeyron(_StrictInput)`: + + | key | default | meaning | + |---|---|---| + | `n_block_steps` | 1000 | MD steps per integration block (the `h` of Section 1). | + | `integrator` | `"euler"` | `"euler"` or `"trapezoid"` corrector. | + | `stop_at_target_pressure` | `true` | End the sweep at the first block whose *real* pressure reaches `pressure[1]`. With `dT/dP > 0` (lambda < 1) the real pressure runs ahead of `P_RS`, so the ramp target `P_RS,f = pressure[1]` is conservative; with a negative slope the sweep ends at `P_RS = pressure[1]` and the reached real range is logged. | + | `n_check_blocks` | 0 | Run the solid-fraction melt/freeze checks every this many blocks (0 = only at the end of each sweep). | + | `hysteresis_tolerance` | 5.0 | K. Warn (and flag in `report.yaml`) when the backward sweep misses `T0` at `P_i` by more than this. | + | `parallel_cells` | `false` | Run the two cells concurrently (two threads, each cell's LAMMPS with `queue.cores/2`) instead of one after the other with all cores. Same results, half the sweep wall time; falls back to sequential with one core. | + +* `mode: dcci` validation: `pressure` must be a 2-list (`_pressure` = P_i, `_pressure_stop` = P_f; + already parsed), `temperature` a scalar > 0 (`_temperature` is `T0 = T_m`), + `n_switching_steps` gives `_n_sweep_steps` = N (existing semantics), `reference_phase` is + ignored and forced to `"solid"` so `create_identifier` yields + `dcci--solid--`. `monte_carlo.n_swaps > 0`, `pair_mode: overlay` with + composition changes, and `fe-qtb` are rejected with clear messages. + +### 3.2 `calphy/dcci.py` (new): `class DynamicCCI` + +Mirrors `MeltingTemp` in shape (a coordinator owning a `Solid` and a `Liquid`), but runs them in +lockstep. Simfolder layout: `dcci-.../` with `solid/` and `liquid/` sub-folders (each sub-job gets +its own `calphy.log`, `input_file.yaml`, `conf.equilibration.data`, `averaging.log.lammps`), the +coupled-sweep files and `report.yaml` at the top level. + +1. `prepare_cells()`: build two sub-`Calculation`s from the parent dict (mode `dcci`, + `reference_phase` solid/liquid, `temperature: T0`, `pressure: P_i`), instantiate `Solid` / + `Liquid`, attach the parent log handlers as `MeltingTemp.run_jobs` does, enable the phase + checks with `MeltingTemp._enable_phase_detection` semantics (factor that helper out of + `MeltingTemp` into a module-level function). +2. `equilibrate_cells()`: `soljob.run_averaging()`, `lqdjob.run_averaging()`. This reuses the + pressure-convergence machinery unchanged and yields `conf.equilibration.data`, `lx/ly/lz`, + `natoms` for each cell at (T0, P_i). Melted/frozen cells raise the existing errors. +3. `run_sweep(direction, iteration)`: opens two runners, one per cell: + * `create_object`, `hybrid/scaled` with `v_lam` (initialised to the sweep's starting lambda), + `read_data` (equilibration conf for forward; `conf.dcci.forward_..data` for + backward), `pair_coeff`, `mass`, `remap_box`; + * warm start + equilibration under `fix npt ... iso P_RS,start P_RS,start` (reuse + `_warm_start_steps`), `unfix`, `reset_timestep 0`; + * `fix f1 all npt temp T0 T0 tdamp iso P_RS,start P_RS,end pdamp`, thermo, the `ave/time` + fix, optional `dump` on `n_print_steps`; + * block loop: redefine `v_lam` in both cells, `run n_block start 0 stop N` in both, `sync()` + both, read the last `ave/time` row of each, `cce_step(...)`, append a row to + `dcci._.dat`, log `T_k, P_k, dP/dT`, apply the stop rule and the periodic checks; + * end: snapshot + melt/freeze check, `write_data`, `close`, `rotate_logs`. + By default the two runners are stepped one after the other in the same Python process, each + cell's `lmp` getting the full core count in turn; `dcci.parallel_cells` runs the two per-block + sequences (ramp, run, sync) in two threads with half the cores each. There is no MPI coupling: + the cells exchange information only through the driver, once per block. +4. `integrate(iteration)`: pure numpy (`integrators.integrate_dcci`), see 3.4. +5. `submit_report()` / `clean_up()`: `report.yaml` at the top level with + `results: {t0, p_start, p_stop_requested, p_stop_reached, t_stop, n_blocks_used, + hysteresis_t_at_p_start, hysteresis_high, coexistence_line: coexistence_line.dat}`, + `metadata.yaml` with the de Koning DOI appended to `publications`. + +Pure functions kept free of LAMMPS for unit testing: `cce_step(u_s, u_l, v_s, v_l, dp_rs_bar)`, +`predict_lambda(...)`, `plan_blocks(n_sweep, n_block)`, `lambda_ramp_command(name, l0, l1, step0, n)`. + +### 3.3 Dispatch and plumbing + +* `queuekernel.py` (`setup_calculation`, `main`) and `routines.py`: `mode == "dcci"` -> + `DynamicCCI(...).calculate_coexistence_line()`; extend the "Mode should be either ..." messages. +* `runner.py`: `required_styles` adds `hybrid/scaled`, `npt`, `ave/time`, `temp/com` for `dcci` + (liquid equilibration already pulls `ufm`); `reset_timestep` into `ONE_SHOT_TOKENS` + (plus a row in `tests/test_command_vocabulary.py`). +* `.gitignore`: `dcci-*`. +* `postprocessing.py`: `read_coexistence_line(folder)` returning a DataFrame, and a small + `plot_coexistence_line(folder)`; `gather_results` picks up `report.yaml` of `dcci` folders. + +### 3.4 Output files and the integration step + +* `dcci.._.dat` (raw `ave/time`, one row per block): + `step pe_atom vol_atom lambda`. +* `dcci._.dat` (driver, one row per block): + `block step lambda T[K] P_RS[bar] P[bar] u_s u_l v_s v_l dPdT[bar/K]`. +* `coexistence_line.dat`: forward and backward curves interpolated onto a common real-pressure + grid; columns `P[bar] T_forward[K] T_backward[K] T_mean[K] T_err[K]` where `T_err` is + half the local hysteresis combined with the standard error over `n_iterations` replicas + (same convention as `integrate_rs`). +* `conf.dcci.forward_..data`, `conf.dcci.backward_..data`. + +### 3.5 Docs and examples + +* `docs/source/inputfile.md`: `mode: dcci` under `mode`; new `dcci` block section; note on + `pressure` as a 2-list and `temperature` as the known melting temperature at `pressure[0]`. +* `docs/source/outputfiles.md`: the files above. +* `examples/example_13`: Cu (Mishin `Cu01.eam.alloy`, already in `tests/`) melting line + 0 -> 100 kbar starting from a `melting_temperature` run at 0 bar; notebook plotting + `coexistence_line.dat` against two independent `melting_temperature` points. +* Recommended two-step workflow documented: `melting_temperature` at `P_i`, then `dcci` with + `temperature: `. Chaining the two inside one calculation is Section 6. + +--- + +## 4. Tests + +Unit (no LAMMPS): + +* `tests/test_dcci_integrator.py`: `cce_step` sign and units (bar -> eV/A^3); constant + `dU, dV` synthetic data reproduces the analytic `lambda(P_RS)`; trapezoid beats Euler at + second order; `coexistence_line` regridding and hysteresis; `n_iterations` error combination. +* `tests/test_dcci_input.py`: scalar `pressure` rejected, `temperature: 0` rejected, identifier + and folder name, block defaults, rejection of swaps / qtb / composition-changing overlays. +* Golden command stream (`tests/conftest.py` `RecordingRunner` extended with a + `read_timeseries` stub returning synthetic block rows): the exact per-cell command sequence for + a 3-block forward + backward sweep, frozen under `tests/golden/`. + +Integration (`-m lammps`, run with the `lammps-bin` env recipe in the project memory): + +* `test_dcci_ramp_continuity`: T2-style check that `fix npt iso P0 P1` under + `run n start 0 stop N` across three segments reproduces a single-run trajectory's pressure + target (compare volume and `press` time series, not just energy). +* `test_dcci_smoke_cu`: Cu01, `repeat [3,3,3]`, tiny equilibration, `n_switching_steps: 2000`, + `n_block_steps: 500`: all files present, no NaN, `T` monotonic with `P`, forward and backward + `dP/dT` positive and within 30 % of `dH/(T dV)`, `report.yaml` complete. Marked `slow`. + +Physics validation (manual, results go into the example notebook, not CI): + +1. Cu01: `dcci` 0 -> 100 kbar with N = 2e4, 5e4, 1e5; convergence of `T(P_f)` with N + (paper Fig. 4) and hysteresis at `P_i` versus N (paper Fig. 5). Compare against independent + `melting_temperature` runs at 0 and 100 kbar (must agree within their error bars). +2. Stretch: LJ melting line `P* = 1 -> 170` against Agrawal & Kofke (paper Fig. 6) via + `md.init_commands: ["units lj"]`. Blocked on the metal-unit assumptions in equilibration + (`tolerance.pressure` in bar, `EV_A3_TO_BAR`), so only if a units-aware constant is cheap. + +--- + +## 5. Parts, in order (one PR per part, no Claude attribution in commits) + +| Part | Content | Acceptance | +|---|---|---| +| 0 | LAMMPS behaviour checks, kept as `tests/test_dcci_lammps_semantics.py` (`-m lammps`): ramped `fix npt` under `run n start 0 stop N` blocks reproduces the single-run pressure trajectory exactly (a control without start/stop collapses after the first boundary); `hybrid/scaled` picks up a redefined scale variable within a segment (`pre no post no`) and across a boundary; `ave/time 1 n n` writes exactly one row per block after a restart. | Done 2026-09-10, all three green: Section 2 assumptions hold. | +| 1 | `input.py` block + validation, dispatch, `required_styles`, `reset_timestep` token, `.gitignore`. | `test_dcci_input.py`, vocabulary test, full suite green. | +| 2 | `dcci.py`: cells, equilibration, forward sweep, `cce_step`, raw and driver `.dat` files. | Integrator unit tests; golden stream; Cu smoke test forward-only. | +| 3 | Backward sweep, `integrate_dcci`, `coexistence_line.dat`, `report.yaml`, hysteresis flag, `n_iterations`, postprocessing reader/plot. | Full smoke test; unit tests for regridding. | +| 4 | Docs, example_13 with validation notebook. | Done 2026-09-10: Cu01 lines to 5, 10 and 158 GPa (53/155/29 blocks) agree with each other to ~10 K, close to <0.01-2.4 K, track the published Simon fits within a few percent, and match direct fe crossings of both phases at 5 and 10 GPa to 2 K once the 13 K offset of the starting `melting_temperature` (1340 K vs 1353 K direct) is accounted for. Version bump left to the owner. | + +--- + +## 6. Extensions (not in v1, listed so the v1 design does not block them) + +* **lambda as independent variable** (Eq. 23, needed near a melting-curve maximum where + `dV -> 0`): requires a per-block barostat retarget without state loss. Route: make each block a + restart cycle in both runners and re-specify `fix f1` with the same ID after `read_restart` + (executable mode does this already; `LibraryRunner` would need a `write_restart/clear/ + read_restart` + `SessionState` replay). Verify `Modify::add_fix` re-applies restart state when + the fix is re-specified before the first `run`. +* **Chained initial condition**: `dcci.initial_condition: melting_temperature` runs `MeltingTemp` + at `P_i` first and feeds `T_m` in. +* **Per-step updating in library mode** via `run 1 pre no post no` (the paper's scheme). +* **Solid-solid boundaries**: two `Solid` cells with different lattices; only the equilibration + differs. + +--- + +## 7. Risks, assumptions, and one pre-existing finding + +* **Accuracy is set by the starting point.** The integration itself reproduces the pressure + dependence to a few kelvin; an error `dT0` in the starting coexistence temperature propagates + as roughly `dT0 * T/T0`. At 0 bar `melting_temperature` (30000-step sweeps, one iteration) + gave 1340 K where direct fe crossings of both phases give 1353 K, and the d-CCI line carries + that 1 % offset unchanged. Spend the effort on the starting point (n_iterations, longer + sweeps, or a direct fe crossing) rather than on the sweep. +* **Hysteresis is not a discretisation check.** Forward and backward Euler errors mirror each + other, so a round trip can close while each direction is biased; averaging the two directions + cancels the leading error. Convergence in `n_block_steps` / `n_switching_steps` has to be + checked by rerunning (Cu01: 1000-step blocks to 158 GPa are 11 K below 500-step blocks at + 10 GPa; 53 and 155 blocks of 500 steps agree at 5 GPa). +* **A runner fragility the mode exposes.** Two of the validation runs (a `melting_temperature` + at 200 kbar and the 155-block d-CCI) died with `LammpsExecutionError: exited with return code + 1` on a segment whose LAMMPS log ends cleanly (`Total wall time`, no `ERROR`), both under + several concurrent `mpirun -np 4` jobs; the d-CCI lost only its report, the sweep files were + complete and `integrate_dcci` recovered the line. A mode that launches hundreds of segments + needs the ExecutableRunner to treat a clean log with a nonzero `mpirun` exit as a warning, or + to retry the segment from its restart; worth a follow-up in `runner.py`. + +* **Noise in the slope.** Small cells give `dV/atom` comparable to its fluctuation; the error + integrates as a random walk that shrinks with N and is exposed by the hysteresis. Default + `n_block_steps: 1000` plus 500+ atoms per cell matches the paper's regime. +* **Cells changing phase mid-sweep.** If the solid melts (or liquid freezes) the slope collapses + silently; the `n_check_blocks` checks and the end-of-sweep checks raise `MeltedError` / + `SolidifiedError`, with the block index in the log. No automatic recovery in v1. +* **Executable-mode overhead** scales with blocks, not steps; documented in the `n_block_steps` + entry. +* **Assumption:** both cells contain the same composition (congruent melting). Multi-component + input is accepted only when every element appears in both cells with the same fraction. +* **Finding in the existing `ts` / `tscale` sweeps (fixed on branch `sweep-barostat`).** + `_reversible_scaling_forward`, `_reversible_scaling_backward` computed `pf = lf * pi` and + logged "P pi -> pf", but the barostat that stayed active through the sweep was created with + `iso pi pi`. The reversible-scaling relation (paper Eq. 11, and the `U + P V` integrand that + `integrate_rs` uses) requires `P_RS = lambda * P` during the sweep. With a constant `P_RS = P` + the sweep samples the real system on the path `(T0/lambda, P/lambda)` while the integration + labels it as the isobar `P`. Because the `P V` term in the integrand uses the fixed target + pressure, the leading error in the integrand is `-(alpha T) V (P/lambda - P)` plus a + second-order compressibility term, i.e. small for a stiff solid at tens of kbar (Cu, 50 kbar, + 400 -> 700 K: about 1 meV/atom, invisible in a quick fe cross-check) and growing with + `alpha T`, `V`, `P` and the temperature span; liquids at 100+ kbar are where it matters. + At `pressure: 0` it is exactly zero. `tscale` and the pre-flight scan had the opposite + mismatch (a scaled-pressure ramp applied to a real-temperature ramp, since v1.0.0), and the + `tscale` backward sweep had been quenching to `T0` instead of ramping `Tf -> T0` since + "switch to stepped ts" (b286426, released in 1.7.4), which corrupts every `tscale` result + since then at any pressure. The `dcci` sweep must use the ramped `P_RS`, as in Section 2. diff --git a/README.md b/README.md index 831dcf3b..674c931f 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,7 @@ - and for both solid and liquid phases at the given thermodynamic conditions using [non-equilibrium Hamiltonian interpolation](https://linkinghub.elsevier.com/retrieve/pii/S0927025615007089). - and , temperature dependence of Gibbs and Helmholtz free energies using the [reversible scaling](https://link.aps.org/doi/10.1103/PhysRevLett.83.3973) approach. - Calculation of solid-solid or solid-liquid phase transition temperatures. +- Calculation of solid-liquid coexistence lines over a wide pressure range from a single known coexistence point using [dynamic Clausius-Clapeyron integration](https://doi.org/10.1063/1.1420486). - Calculation of specific heat as a function of temperature. - Calculation of and for multicomponent systems using [alchemical transformations](https://journals.aps.org/prmaterials/abstract/10.1103/PhysRevMaterials.5.103801). - [Upsampling calculations](https://journals.aps.org/prmaterials/abstract/10.1103/PhysRevMaterials.5.103801). diff --git a/calphy/__init__.py b/calphy/__init__.py index dcf1b94d..3446f84d 100644 --- a/calphy/__init__.py +++ b/calphy/__init__.py @@ -28,7 +28,7 @@ from calphy.alchemy import Alchemy from calphy.routines import MeltingTemp -__version__ = "2.2.1" +__version__ = "2.3.0" def addtest(a,b): return a+b diff --git a/calphy/dcci.py b/calphy/dcci.py new file mode 100644 index 00000000..f5e91b47 --- /dev/null +++ b/calphy/dcci.py @@ -0,0 +1,702 @@ +""" +calphy: a Python library and command line interface for automated free +energy calculations. + +Copyright 2021-2026 (c) Sarath Menon, Yury Lysogorskiy, Ralf Drautz +Interdisciplinary Centre for Advanced Materials Simulation (ICAMS), +Ruhr University Bochum, 44801 Bochum, Germany + +calphy is published and distributed under the Academic Software Licence v1.0 (ASL). +calphy is distributed in the hope that it will be useful for non-commercial academic +research, but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the LICENSE file for details. + +The ASL permits academic non-commercial use only. Contact +sarath.menon@ruhr-uni-bochum.de to enquire about commercial use rights. + +More information about the program can be found in: +Menon, Sarath, Yury Lysogorskiy, Jutta Rogal, and Ralf Drautz. +"Automated Free Energy Calculation from Atomistic Simulations." Physical Review Materials 5(10), 2021 +DOI: 10.1103/PhysRevMaterials.5.103801 + +For more information contact: +sarath.menon@ruhr-uni-bochum.de +""" +"""Dynamic Clausius-Clapeyron integration (``mode: dcci``). + +Traces a solid-liquid coexistence line P_coex(T) from one known coexistence +point in a single nonequilibrium run per direction, following de Koning, +Antonelli and Yip, J. Chem. Phys. 115, 11025 (2001). Both phases are driven +side by side at the fixed kinetic temperature T0 of the starting point with the +scaled Hamiltonian K + lambda*U; the scaled pressure P_RS is ramped linearly and +lambda follows from the Clausius-Clapeyron condition in its scaled form, + + d lambda / d P_RS = -(v_s - v_l) / (u_s - u_l), + +evaluated from block averages of the potential energy u = /(N lambda) and +volume v = /N per atom of the two cells. Every point maps back to the real +system through T = T0/lambda and P = P_RS/lambda. See DCCI_PLAN.md. +""" +import copy +import os +import math +import shutil +import time +from concurrent.futures import ThreadPoolExecutor + +import numpy as np +import yaml + +import calphy.helpers as ph +from calphy.input import Calculation, generate_metadata +from calphy.integrators import EV_A3_TO_BAR +from calphy.liquid import Liquid +from calphy.solid import Solid +from calphy.routines import enable_phase_detection + + +# --------------------------------------------------------------------------- # +# Pure numerics (no LAMMPS): kept module-level for unit testing +# --------------------------------------------------------------------------- # +def cce_slope(u_s, u_l, v_s, v_l): + """ + Slope d lambda / d P_RS of the coexistence line in the scaled formulation. + + Parameters + ---------- + u_s, u_l : float + Real (unscaled) potential energy per atom of the solid and liquid cell, + eV/atom. + v_s, v_l : float + Volume per atom of the two cells, A^3/atom. + + Returns + ------- + float + ``-(v_s - v_l) / (u_s - u_l)`` in A^3/eV, i.e. per (eV/A^3) of scaled + pressure. Along a melting line both differences are negative for a + normal liquid, so the slope is negative: lambda falls (T rises) as the + scaled pressure rises. + """ + du = u_s - u_l + if du == 0: + raise ZeroDivisionError("solid and liquid potential energies coincide") + return -(v_s - v_l) / du + + +def clausius_clapeyron_slope(u_s, u_l, v_s, v_l, p_real_bar, t_real): + """ + Real-space slope dP/dT = dH / (T dV) in bar/K, for diagnostics. + + dH = (u_l - u_s) + P (v_l - v_s): the kinetic energy per atom is the same in + both cells at equal temperature and drops out. + """ + dv = v_l - v_s + if dv == 0: + return float("nan") + dh = (u_l - u_s) + (p_real_bar / EV_A3_TO_BAR) * dv + return dh / (t_real * dv) * EV_A3_TO_BAR + + +def lambda_ramp_command(name, lam_start, lam_end, step_start, n_steps): + """ + ``variable`` command ramping ``name`` linearly from ``lam_start`` at + ``step_start`` to ``lam_end`` at ``step_start + n_steps``. + + Written with literal numbers only (no ``$(...)`` immediate evaluation) so + that the ExecutableRunner can replay it across a segment boundary. + """ + return "variable %s equal %.12g+(%.12g)*(step-%d)/%d" % ( + name, lam_start, lam_end - lam_start, step_start, n_steps, + ) + + +def plan_blocks(n_sweep, n_block): + """Number of whole blocks covering ``n_sweep`` steps (rounded up).""" + return max(1, int(math.ceil(n_sweep / float(n_block)))) + + +def integrate_dcci(simfolder, t0, p_start, nsims=1, return_values=False): + """ + Combine the forward and backward sweeps into one coexistence line. + + The forward sweep of every iteration provides the pressure grid (with the + starting point prepended); the backward sweep of the same iteration is + interpolated onto it. The line is the mean of both directions, its error + half the local hysteresis combined with the standard error over the + iterations, as ``integrate_rs`` does for the temperature sweep. + + Parameters + ---------- + simfolder : str + Folder holding ``dcci.forward_.dat`` and ``dcci.backward_.dat``. + t0, p_start : float + The starting coexistence point (K, bar). + nsims : int + Number of iterations. + return_values : bool + Also return the arrays. + + Returns + ------- + hysteresis : float + Mean over iterations of T_backward(P_start) - T0, in K: how far the + round trip misses the starting temperature. + (pressure, temperature, error, t_forward, t_backward) : arrays + Only if ``return_values``; on the grid of the first iteration. + """ + grid = None + forwards, backwards, hyst = [], [], [] + for i in range(1, nsims + 1): + fwd = np.atleast_2d(np.loadtxt(os.path.join(simfolder, "dcci.forward_%d.dat" % i))) + bwd = np.atleast_2d(np.loadtxt(os.path.join(simfolder, "dcci.backward_%d.dat" % i))) + # real pressure and temperature, starting point included + p_f = np.concatenate(([p_start], fwd[:, 5])) + t_f = np.concatenate(([t0], fwd[:, 3])) + # the backward sweep starts where the forward one ended + p_b = np.concatenate(([fwd[-1, 5]], bwd[:, 5])) + t_b = np.concatenate(([fwd[-1, 3]], bwd[:, 3])) + order = np.argsort(p_b) + if grid is None: + grid = p_f + t_f_grid = np.interp(grid, p_f, t_f) if p_f[-1] >= p_f[0] else np.interp(grid[::-1], p_f[::-1], t_f[::-1])[::-1] + t_b_grid = np.interp(grid, p_b[order], t_b[order]) + forwards.append(t_f_grid) + backwards.append(t_b_grid) + hyst.append(float(np.interp(p_start, p_b[order], t_b[order]) - t0)) + + forwards = np.array(forwards) + backwards = np.array(backwards) + means = 0.5 * (forwards + backwards) + temperature = means.mean(axis=0) + half_hyst = 0.5 * np.abs(forwards - backwards).mean(axis=0) + stderr = means.std(axis=0, ddof=1) / np.sqrt(nsims) if nsims > 1 else np.zeros_like(temperature) + error = np.sqrt(half_hyst**2 + stderr**2) + hysteresis = float(np.mean(hyst)) + + np.savetxt( + os.path.join(simfolder, "coexistence_line.dat"), + np.column_stack((grid, temperature, error, forwards.mean(axis=0), backwards.mean(axis=0))), + header="dynamic Clausius-Clapeyron coexistence line\n" + "pressure[bar] temperature[K] error[K] T_forward[K] T_backward[K]", + ) + if return_values: + return hysteresis, (grid, temperature, error, forwards.mean(axis=0), backwards.mean(axis=0)) + return hysteresis + + +class SweepState: + """Where a sweep ended: what the next sweep starts from.""" + + def __init__(self, lam, p_rs, n_blocks, direction): + self.lam = lam + self.p_rs = p_rs + self.n_blocks = n_blocks + self.direction = direction + + +class DynamicCCI: + """ + Coordinator of a dynamic Clausius-Clapeyron integration. + + Owns one :class:`~calphy.solid.Solid` and one :class:`~calphy.liquid.Liquid` + sub-job, equilibrated independently at the starting coexistence point and + then stepped in lockstep through the coupled sweep. + + Parameters + ---------- + calculation : Calculation + The validated ``mode: dcci`` calculation. + simfolder : str + Folder for the coupled-sweep output; the cells live in ``solid/`` and + ``liquid/`` below it. + log_to_screen : bool + Also log to the screen. + """ + + CELLS = ("solid", "liquid") + + # Thresholds installed for the two cells unless the user set them. + DETECTION_SOLID_FRACTION = 0.7 + DETECTION_LIQUID_FRACTION = 0.05 + + def __init__(self, calculation=None, simfolder=None, log_to_screen=False): + self.calc = copy.deepcopy(calculation) + self.simfolder = simfolder + self.log_to_screen = log_to_screen + self.publications = ["10.1063/1.1420486", "10.1103/PhysRevLett.83.3973"] + + if self.calc.md.seed is None: + self.calc.md.seed = int(np.random.SeedSequence().entropy % (2**31 - 2)) + 1 + np.random.seed(self.calc.md.seed) + + with open(os.path.join(simfolder, "input_file.yaml"), "w") as fout: + yaml.safe_dump({"calculations": [self.calc.model_dump()]}, fout) + + logfile = os.path.join(self.simfolder, "calphy.log") + self.logger = ph.prepare_log(logfile, screen=log_to_screen) + + self.t0 = float(self.calc._temperature) + self.p_start = float(self.calc._pressure) + self.p_stop = float(self.calc._pressure_stop) + self.n_block = int(self.calc.dcci.n_block_steps) + self.n_blocks = plan_blocks(self.calc._n_sweep_steps, self.n_block) + self.logger.info( + "Dynamic Clausius-Clapeyron integration from the coexistence point " + "T = %.2f K, P = %.2f bar towards P = %.2f bar" % (self.t0, self.p_start, self.p_stop) + ) + self.logger.info( + "Sweep of %d blocks x %d steps (n_switching_steps %d), corrector %s" + % (self.n_blocks, self.n_block, self.calc._n_sweep_steps, self.calc.dcci.integrator) + ) + self.logger.info("Master random seed is %d (md.seed)" % self.calc.md.seed) + + # The cells exchange information once per block through this driver; + # in between they are independent and can run at the same time. + cores = int(self.calc.queue.cores) + self.parallel = bool(self.calc.dcci.parallel_cells) and cores >= 2 + if self.parallel: + self.cell_cores = cores // 2 + self.logger.info( + "dcci.parallel_cells: the solid and the liquid cell run concurrently " + "with %d cores each (queue.cores = %d)" % (self.cell_cores, cores) + ) + if cores % 2: + self.logger.warning("queue.cores = %d is odd; one core stays idle" % cores) + else: + self.cell_cores = cores + if self.calc.dcci.parallel_cells: + self.logger.warning( + "dcci.parallel_cells needs queue.cores >= 2; running the cells sequentially" + ) + self.logger.info( + "The solid and the liquid cell run one after the other, each with %d cores" % cores + ) + + self.jobs = {} + self.states = {} + + def _for_cells(self, fn): + """ + Call ``fn(phase)`` for the solid and the liquid cell and return + ``{phase: result}``; concurrently in two threads when + ``dcci.parallel_cells`` is on. An exception in either cell propagates. + """ + if not self.parallel: + return {phase: fn(phase) for phase in self.CELLS} + with ThreadPoolExecutor(max_workers=2) as pool: + futures = {phase: pool.submit(fn, phase) for phase in self.CELLS} + return {phase: fut.result() for phase, fut in futures.items()} + + # ------------------------------------------------------------------ cells + def _cell_calculation(self, phase): + """ + The sub-calculation of one cell: the parent input with the cell's + reference phase, the starting pressure and the melt/freeze checks on. + """ + data = self.calc.model_dump() + data["reference_phase"] = phase + data["pressure"] = [self.p_start, self.p_start] + data["temperature"] = self.t0 + data["kernel"] = 0 + data["inputfile"] = os.path.join(self.simfolder, "input_file.yaml") + # the structure file has been generated by the parent already + data["lattice"] = self.calc.lattice + data["file_format"] = "lammps-data" + data["queue"]["cores"] = self.cell_cores + # model_dump fills the defaults in; enable_phase_detection must only + # act where the user gave no value, so blank those out again + for key in ("solid_fraction", "liquid_fraction"): + if key not in self.calc.tolerance.model_fields_set: + data["tolerance"][key] = None + enable_phase_detection( + data, self.logger, "dcci", + self.DETECTION_SOLID_FRACTION, self.DETECTION_LIQUID_FRACTION, + ) + return Calculation(**data) + + def prepare_cells(self): + """Create the ``solid/`` and ``liquid/`` sub-jobs.""" + for phase, cls in (("solid", Solid), ("liquid", Liquid)): + folder = os.path.join(self.simfolder, phase) + os.makedirs(folder, exist_ok=True) + # validation copies the structure file into the working directory: + # let that be the cell's folder + cwd = os.getcwd() + os.chdir(folder) + try: + calc = self._cell_calculation(phase) + finally: + os.chdir(cwd) + job = cls(calculation=calc, simfolder=folder) + for handler in self.logger.handlers: + job.logger.addHandler(handler) + self.jobs[phase] = job + self.logger.info( + "Cells: solid %s (%d atoms), liquid %s (%d atoms)" + % (self.jobs["solid"].calc.lattice, self.jobs["solid"].natoms, + self.jobs["liquid"].calc.lattice, self.jobs["liquid"].natoms) + ) + + def equilibrate_cells(self): + """ + Equilibrate both cells at (T0, P_start) with the standard averaging + routines, which converge the pressure and write ``conf.equilibration.data``. + """ + def equilibrate(phase): + self.logger.info("Equilibrating the %s cell at %.2f K, %.2f bar" % (phase, self.t0, self.p_start)) + self.jobs[phase].run_averaging() + self.logger.info("%s cell: %.4f A^3/atom" % (phase, self.jobs[phase].volatom)) + + self._for_cells(equilibrate) + + # ------------------------------------------------------------------ sweep + def _open_cell(self, phase, lam, p_rs, conf, direction, iteration, seed): + """ + Open a LAMMPS session for one cell with the lambda-scaled potential at + constant ``lam`` and a barostat at the constant scaled pressure ``p_rs``, + and equilibrate it there. ``seed`` (drawn by the caller, so that the + random stream is used from one thread only) seeds the velocities of a + forward sweep. + """ + job = self.jobs[phase] + lmp = ph.create_object(job.calc, job.simfolder) + lmp.command("echo log") + lmp.command("variable lam equal %.12g" % lam) + lmp.command(ph.scaled_pair_style_command(job.calc, ["v_lam"])) + lmp = ph.read_data(lmp, conf) + for cmd in ph.hybrid_pair_coeff_commands(job.calc): + lmp.command(cmd) + lmp = ph.set_mass(lmp, job.calc) + + if direction == "forward": + # conf.equilibration.data is an equilibrium sample at (T0, P_start) + # with fluctuating box: pin it to the averaged box as every sweep does + lmp = ph.remap_box(lmp, job.lx, job.ly, job.lz) + lmp.command( + "velocity all create %f %d mom yes rot yes dist gaussian" + % (self.t0, seed) + ) + + lmp.command( + "fix f1 all npt temp %f %f %f %s %f %f %f" + % (self.t0, self.t0, job.calc.md.thermostat_damping[1], + job.iso, p_rs, p_rs, job.calc.md.barostat_damping[1]) + ) + lmp.command("thermo_style custom step pe press vol v_lam") + lmp.command("thermo %d" % max(self.n_block, 1)) + self.logger.info( + "%s sweep (iteration %d), %s cell: equilibration of %d steps at " + "lambda = %.6f, P_RS = %.2f bar" + % (direction, iteration, phase, job.calc.n_equilibration_steps, lam, p_rs) + ) + lmp.command("run %d" % job.calc.n_equilibration_steps) + lmp.command("unfix f1") + return lmp + + def _arm_sweep(self, phase, lmp, p_rs_start, p_rs_stop, direction, iteration): + """Install the ramping barostat and the block-average output of one cell.""" + job = self.jobs[phase] + n_total = self.n_blocks_current * self.n_block + lmp.command("reset_timestep 0") + lmp.command( + "fix f1 all npt temp %f %f %f %s %f %f %f" + % (self.t0, self.t0, job.calc.md.thermostat_damping[1], + job.iso, p_rs_start, p_rs_stop, job.calc.md.barostat_damping[1]) + ) + # real potential energy per atom: LAMMPS reports lambda*U under hybrid/scaled + lmp.command("variable u_real equal pe/atoms/v_lam") + lmp.command("variable vol_atom equal vol/atoms") + lmp.command( + "fix fav all ave/time 1 %d %d v_u_real v_vol_atom v_lam " + 'title1 "# block averages of the dcci %s sweep, %s cell" ' + 'title2 "# step u_real[eV/atom] vol[A^3/atom] lambda" ' + "file %s" % (self.n_block, self.n_block, direction, phase, + self._cell_file(direction, iteration)) + ) + if self.calc.n_print_steps > 0: + lmp.command( + "dump d1 all custom %d traj.dcci.%s_%d.dat " + "id type mass x y z vx vy vz" % (self.calc.n_print_steps, direction, iteration) + ) + return n_total + + @staticmethod + def _cell_file(direction, iteration): + """Raw block averages of one cell, inside the cell folder.""" + return "dcci.blocks.%s_%d.dat" % (direction, iteration) + + def _driver_file(self, direction, iteration): + return os.path.join(self.simfolder, "dcci.%s_%d.dat" % (direction, iteration)) + + def _read_block(self, phase, lmp, direction, iteration, k): + """Block-k averages (u_real, vol_atom, lambda) of one cell.""" + data = np.atleast_2d(lmp.read_timeseries(self._cell_file(direction, iteration))) + if data.shape[0] != k + 1: + raise RuntimeError( + "dcci %s sweep, %s cell: expected %d block-average rows after block %d, found %d" + % (direction, phase, k + 1, k, data.shape[0]) + ) + return data[-1, 1], data[-1, 2], data[-1, 3] + + def _check_phases(self, lmps, direction, iteration, tag): + """Melt/freeze checks on both cells (raise MeltedError / SolidifiedError).""" + + def check(phase): + job = self.jobs[phase] + snapshot = "traj.dcci.%s_%d.%s.dat" % (direction, iteration, tag) + job.dump_current_snapshot(lmps[phase], snapshot) + if phase == "solid": + job.check_if_melted(lmps[phase], snapshot) + else: + job.check_if_solidfied(lmps[phase], snapshot) + + self._for_cells(check) + + def run_sweep(self, direction="forward", iteration=1): + """ + Drive both cells through one sweep of the scaled pressure and integrate + lambda block by block. + + Forward: from (lambda = 1, P_RS = P_start) towards P_RS = P_stop, stopping + early when the real pressure reaches P_stop (``dcci.stop_at_target_pressure``). + Backward: from where the forward sweep of the same iteration ended, the + scaled pressure ramped back to P_start over the same number of blocks. + + Writes ``dcci._.dat`` (one row per block) and + ``conf.dcci._.data`` in each cell folder. + + Returns + ------- + SweepState + lambda, scaled pressure and number of blocks at the end. + """ + if direction == "forward": + lam = 1.0 + p_rs_start, p_rs_stop = self.p_start, self.p_stop + self.n_blocks_current = self.n_blocks + confs = { + phase: os.path.join(self.jobs[phase].simfolder, "conf.equilibration.data") + for phase in self.CELLS + } + else: + prev = self.states[(iteration, "forward")] + lam = prev.lam + p_rs_start, p_rs_stop = prev.p_rs, self.p_start + self.n_blocks_current = prev.n_blocks + confs = { + phase: os.path.join( + self.jobs[phase].simfolder, "conf.dcci.forward_%d.data" % iteration + ) + for phase in self.CELLS + } + + n_blocks = self.n_blocks_current + h_bar = (p_rs_stop - p_rs_start) / n_blocks + h = h_bar / EV_A3_TO_BAR + self.logger.info( + "%s sweep (iteration %d): P_RS %.2f -> %.2f bar in %d blocks of %d steps, " + "starting at lambda = %.6f (T = %.2f K)" + % (direction, iteration, p_rs_start, p_rs_stop, n_blocks, self.n_block, + lam, self.t0 / lam) + ) + + seeds = {phase: int(np.random.randint(1, 10000)) for phase in self.CELLS} + lmps = self._for_cells( + lambda phase: self._open_cell( + phase, lam, p_rs_start, confs[phase], direction, iteration, seeds[phase] + ) + ) + for phase in self.CELLS: + self._arm_sweep(phase, lmps[phase], p_rs_start, p_rs_stop, direction, iteration) + + rows = [] + f_prev = None + towards_higher = p_rs_stop > p_rs_start + for k in range(n_blocks): + p_rs_k = p_rs_start + k * h_bar + p_rs_k1 = p_rs_k + h_bar + # predictor: continue the last measured slope through this block + lam_pred = lam if f_prev is None else lam + h * f_prev + ramp = lambda_ramp_command("lam", lam, lam_pred, k * self.n_block, self.n_block) + run = "run %d start 0 stop %d" % (self.n_block, n_blocks * self.n_block) + + def block(phase): + lmps[phase].command(ramp) + lmps[phase].command(run) + lmps[phase].sync() + + self._for_cells(block) + + u_s, v_s, lam_s = self._read_block("solid", lmps["solid"], direction, iteration, k) + u_l, v_l, lam_l = self._read_block("liquid", lmps["liquid"], direction, iteration, k) + lam_mid = 0.5 * (lam_s + lam_l) + f_k = cce_slope(u_s, u_l, v_s, v_l) + if self.calc.dcci.integrator == "trapezoid" and f_prev is not None: + lam_new = lam + h * 0.5 * (f_k + f_prev) + else: + lam_new = lam + h * f_k + if not lam_new > 0: + raise RuntimeError( + "dcci %s sweep: lambda became non-positive (%g) in block %d; the " + "cells are no longer at coexistence" % (direction, lam_new, k) + ) + + t_mid = self.t0 / lam_mid + p_mid = 0.5 * (p_rs_k + p_rs_k1) / lam_mid + dpdt = clausius_clapeyron_slope(u_s, u_l, v_s, v_l, p_mid, t_mid) + t_new = self.t0 / lam_new + p_new = p_rs_k1 / lam_new + rows.append([k, (k + 1) * self.n_block, lam_new, t_new, p_rs_k1, p_new, + u_s, u_l, v_s, v_l, dpdt]) + self.logger.info( + "%s block %d/%d: T = %.2f K, P = %.1f bar (P_RS %.1f, lambda %.6f), " + "du = %.4f eV/atom, dv = %.4f A^3/atom, dP/dT = %.2f bar/K" + % (direction, k + 1, n_blocks, t_new, p_new, p_rs_k1, lam_new, + u_l - u_s, v_l - v_s, dpdt) + ) + lam, f_prev = lam_new, f_k + + n_check = self.calc.dcci.n_check_blocks + if n_check > 0 and (k + 1) % n_check == 0 and k + 1 < n_blocks: + self._check_phases(lmps, direction, iteration, "block%d" % (k + 1)) + + if ( + direction == "forward" + and self.calc.dcci.stop_at_target_pressure + and ((towards_higher and p_new >= self.p_stop) + or (not towards_higher and p_new <= self.p_stop)) + ): + self.logger.info( + "forward sweep: real pressure %.1f bar reached the target %.1f bar " + "after %d of %d blocks; stopping" % (p_new, self.p_stop, k + 1, n_blocks) + ) + n_blocks = k + 1 + break + + self._write_driver_file(direction, iteration, rows) + + for phase in self.CELLS: + lmps[phase].command("unfix fav") + if self.calc.n_print_steps > 0: + lmps[phase].command("undump d1") + self._check_phases(lmps, direction, iteration, "end") + + def finish(phase): + conf = os.path.join( + self.jobs[phase].simfolder, "conf.dcci.%s_%d.data" % (direction, iteration) + ) + lmps[phase].command("write_data %s" % conf) + self.jobs[phase].lammps_close(lmp=lmps[phase]) + lmps[phase].rotate_logs("dcci_%s_%d" % (direction, iteration)) + + self._for_cells(finish) + + state = SweepState(lam, p_rs_start + n_blocks * h_bar, n_blocks, direction) + self.states[(iteration, direction)] = state + self.logger.info( + "%s sweep (iteration %d) done: T = %.2f K, P = %.1f bar" + % (direction, iteration, self.t0 / state.lam, state.p_rs / state.lam) + ) + return state + + def _write_driver_file(self, direction, iteration, rows): + np.savetxt( + self._driver_file(direction, iteration), + np.array(rows), + fmt=["%d", "%d", "%.10f", "%.6f", "%.6f", "%.6f", "%.8f", "%.8f", "%.6f", "%.6f", "%.6f"], + header="dynamic Clausius-Clapeyron %s sweep, iteration %d; T0 = %.4f K\n" + "block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] " + "v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K]" % (direction, iteration, self.t0), + ) + + # ---------------------------------------------------------- integration + def integrate(self): + """Combine all sweeps into ``coexistence_line.dat`` and judge the hysteresis.""" + self.hysteresis, values = integrate_dcci( + self.simfolder, self.t0, self.p_start, + nsims=self.calc.n_iterations, return_values=True, + ) + pressure, temperature, error = values[0], values[1], values[2] + self.hysteresis_high = abs(self.hysteresis) > self.calc.dcci.hysteresis_tolerance + self.line = (pressure, temperature, error) + self.logger.info( + "Coexistence line from %.1f to %.1f bar written to coexistence_line.dat " + "(%d points)" % (pressure[0], pressure[-1], len(pressure)) + ) + self.logger.info( + "Round trip misses the starting temperature by %.2f K (tolerance %.2f K)" + % (self.hysteresis, self.calc.dcci.hysteresis_tolerance) + ) + if self.hysteresis_high: + self.logger.warning( + "The forward and backward sweeps do not close: the integration is " + "not reversible at this sweep length. Increase n_switching_steps " + "(or the cell size) before trusting the line." + ) + self.logger.warning("STATE: coexistence line unreliable, hysteresis too high") + self.logger.info( + "STATE: T_coex = %.2f K at %.1f bar (from %.2f K at %.1f bar)" + % (temperature[-1], pressure[-1], self.t0, self.p_start) + ) + + def submit_report(self): + """Write ``report.yaml`` at the top level.""" + pressure, temperature, error = self.line + last = self.states[(self.calc.n_iterations, "forward")] + report = { + "input": { + "temperature": float(self.t0), + "pressure": float(self.p_start), + "pressure_stop": float(self.p_stop), + "lattice": str(self.calc._original_lattice), + "element": " ".join(np.array(self.calc.element).astype(str)), + "n_block_steps": int(self.n_block), + "n_iterations": int(self.calc.n_iterations), + }, + "average": { + "vol_atom_solid": float(self.jobs["solid"].volatom), + "vol_atom_liquid": float(self.jobs["liquid"].volatom), + }, + "results": { + "coexistence_line": "coexistence_line.dat", + "pressure_reached": float(pressure[-1]), + "temperature_at_pressure_reached": float(temperature[-1]), + "error_at_pressure_reached": float(error[-1]), + "n_blocks_used": int(last.n_blocks), + "hysteresis": float(self.hysteresis), + "hysteresis_high": bool(self.hysteresis_high), + "unit": "K, bar", + }, + } + self.report = report + with open(os.path.join(self.simfolder, "report.yaml"), "w") as fout: + yaml.dump(report, fout) + self.logger.info("Report written in %s" % os.path.join(self.simfolder, "report.yaml")) + self.logger.info("Please cite the following publications:") + for doi in self.publications: + self.logger.info("- %s" % doi) + + def clean_up(self): + """Serialise the input configuration and the run metadata.""" + shutil.copy( + self.calc.lattice, os.path.join(self.simfolder, "input_configuration.data") + ) + metadata = generate_metadata() + metadata["publications"] = self.publications + with open(os.path.join(self.simfolder, "metadata.yaml"), "w") as fout: + yaml.safe_dump(metadata, fout) + + # ------------------------------------------------------------- top level + def calculate_coexistence_line(self): + """Run the whole mode: equilibrate both cells, sweep out and back, integrate, report.""" + self.prepare_cells() + self.equilibrate_cells() + for i in range(1, self.calc.n_iterations + 1): + ts = time.time() + self.run_sweep("forward", iteration=i) + self.run_sweep("backward", iteration=i) + self.logger.info("dcci cycle %d finished in %f s" % (i, time.time() - ts)) + self.integrate() + self.submit_report() + self.clean_up() diff --git a/calphy/input.py b/calphy/input.py index 85e2a93c..1337fe70 100644 --- a/calphy/input.py +++ b/calphy/input.py @@ -58,7 +58,7 @@ make_lattice, ) -__version__ = "2.2.1" +__version__ = "2.3.0" def _check_equal(val): @@ -468,6 +468,86 @@ class MeltingTemperature(_StrictInput, title="Input options for melting temperat attempts: Annotated[int, Field(default=5, ge=1)] +class DynamicClausiusClapeyron( + _StrictInput, title="Input options for dynamic Clausius-Clapeyron integration" +): + """Settings of ``mode: dcci`` (de Koning, Antonelli, Yip, J. Chem. Phys. 115, + 11025 (2001)). The coexistence line is traced from the known point + (``temperature``, ``pressure[0]``) to ``pressure[1]`` in blocks of + ``n_block_steps`` MD steps, during which the scaled pressure of both cells + is ramped and lambda = T0/T is updated from the block averages of U and V.""" + + n_block_steps: Annotated[ + int, + Field( + default=1000, + ge=1, + description=( + "MD steps per integration block: the pressure step of the " + "Clausius-Clapeyron integration, and in execution_mode " + "executable one lmp launch per block per cell. Smaller blocks " + "follow the line more finely; the block averages get noisier." + ), + ), + ] + integrator: Annotated[ + Literal["euler", "trapezoid"], + Field( + default="euler", + description=( + "Corrector applied after each block: 'euler' uses the slope of " + "the finished block, 'trapezoid' the mean of the last two." + ), + ), + ] + stop_at_target_pressure: Annotated[ + bool, + Field( + default=True, + description=( + "End the sweep at the first block whose real pressure reaches " + "pressure[1] (the ramp is applied to the scaled pressure, which " + "the real pressure runs ahead of when the line has a positive " + "slope). If False the sweep runs its full length." + ), + ), + ] + n_check_blocks: Annotated[ + int, + Field( + default=0, + ge=0, + description=( + "Run the solid-fraction melt/freeze checks on both cells every " + "this many blocks; 0 checks only at the end of each sweep." + ), + ), + ] + hysteresis_tolerance: Annotated[ + float, + Field( + default=5.0, + ge=0, + description=( + "K. Flag the result when the backward sweep misses the starting " + "temperature at pressure[0] by more than this." + ), + ), + ] + parallel_cells: Annotated[ + bool, + Field( + default=False, + description=( + "Run the solid and the liquid cell at the same time, each with " + "half of queue.cores, instead of one after the other with all of " + "them. Halves the wall time of the sweeps; needs queue.cores >= 2 " + "(with a single core the cells run sequentially)." + ), + ), + ] + + class MaterialsProject(_StrictInput, title="Input options for materials project"): api_key: Annotated[str, Field(default="", exclude=True)] conventional: Annotated[bool, Field(default=True)] @@ -504,6 +584,7 @@ class Calculation(_StrictInput, title="Main input class"): phase_transition_detection: Optional[PhaseTransitionDetection] = PhaseTransitionDetection() uhlenbeck_ford_model: Optional[UFMP] = UFMP() melting_temperature: Optional[MeltingTemperature] = MeltingTemperature() + dcci: Optional[DynamicClausiusClapeyron] = DynamicClausiusClapeyron() materials_project: Optional[MaterialsProject] = MaterialsProject() element: Annotated[List[str], BeforeValidator(to_list), Field(default=[])] @@ -859,6 +940,9 @@ def _validate_all(self) -> "Input": self._n_sweep_steps = self.n_switching_steps[1] self._n_switching_steps = self.n_switching_steps[0] + if self.mode == "dcci": + self._validate_dcci() + # here we also prepare lattice dict for count, element in enumerate(self.element): self._element_dict[element] = {} @@ -1074,6 +1158,42 @@ def _validate_all(self) -> "Input": ) return self + def _validate_dcci(self): + """ + Constraints of ``mode: dcci``: a known coexistence point and a pressure + range, one composition in both cells, no swaps. + + ``temperature`` is the coexistence temperature at ``pressure[0]`` and + must be given explicitly (the mendeleev melting-point guess is not a + coexistence point of the potential). ``reference_phase`` is forced to + ``solid``: the mode always builds one solid and one liquid cell, and the + value only enters the folder name. + """ + if np.shape(self.pressure) != (2,): + raise ValueError( + "mode dcci needs pressure: [P_start, P_stop] in bar, the pressure " + "of the known coexistence point and the pressure to integrate " + "the coexistence line to; got %r" % (self._pressure_input,) + ) + t_in = np.atleast_1d(self._temperature_input) + if np.shape(t_in) != (1,) or not t_in[0] > 0: + raise ValueError( + "mode dcci needs temperature: , the coexistence " + "temperature at pressure[0] in K (e.g. from a melting_temperature " + "calculation); got %r" % (self._temperature_input,) + ) + if self.monte_carlo.n_swaps > 0: + raise ValueError( + "mode dcci does not support monte_carlo swaps: both cells must " + "keep the composition of the input structure" + ) + if not self.npt: + raise ValueError("mode dcci integrates in the pressure-temperature plane and needs npt: True") + # the mode builds its own solid and liquid cells (each a sub-calculation + # carrying its phase here); on the parent the value only names the folder + if self.reference_phase not in ("solid", "liquid"): + self.reference_phase = "solid" + def fix_paths(self, potlist): """ Fix paths for potential files to complete ones. diff --git a/calphy/postprocessing.py b/calphy/postprocessing.py index 00631b57..97e35b1d 100644 --- a/calphy/postprocessing.py +++ b/calphy/postprocessing.py @@ -674,3 +674,58 @@ def find_transition_temperature(folder1, folder2, fit_order=4, plot=True): plt.xlabel("Temperature (K)") plt.legend(frameon=False) return transition_temp + + +def read_coexistence_line(folder): + """ + Read the coexistence line written by a ``mode: dcci`` calculation. + + Parameters + ---------- + folder : str + The ``dcci-*`` calculation folder. + + Returns + ------- + pandas.DataFrame + Columns ``pressure`` (bar), ``temperature`` (K), ``error`` (K), + ``temperature_forward`` and ``temperature_backward`` (K). + """ + data = np.atleast_2d(np.loadtxt(os.path.join(folder, "coexistence_line.dat"))) + return pd.DataFrame( + data, + columns=["pressure", "temperature", "error", "temperature_forward", "temperature_backward"], + ) + + +def plot_coexistence_line(folder, ax=None, show_directions=True, **kwargs): + """ + Plot the coexistence line of a ``mode: dcci`` calculation, T against P. + + Parameters + ---------- + folder : str + The ``dcci-*`` calculation folder. + ax : matplotlib axis, optional + Axis to draw on; a new figure is created otherwise. + show_directions : bool + Also draw the forward and backward sweeps as thin lines. + kwargs + Passed to ``ax.errorbar`` for the mean line. + + Returns + ------- + matplotlib axis + """ + df = read_coexistence_line(folder) + if ax is None: + _, ax = plt.subplots() + if show_directions: + ax.plot(df.pressure, df.temperature_forward, lw=0.8, alpha=0.6, label="forward") + ax.plot(df.pressure, df.temperature_backward, lw=0.8, alpha=0.6, label="backward") + kwargs.setdefault("label", "coexistence line") + ax.errorbar(df.pressure, df.temperature, yerr=df.error, **kwargs) + ax.set_xlabel("pressure (bar)") + ax.set_ylabel("temperature (K)") + ax.legend() + return ax diff --git a/calphy/queuekernel.py b/calphy/queuekernel.py index 72aabc5c..e7f5c4b8 100644 --- a/calphy/queuekernel.py +++ b/calphy/queuekernel.py @@ -36,6 +36,7 @@ from calphy.liquid import Liquid from calphy.solid import Solid from calphy.alchemy import Alchemy +from calphy.dcci import DynamicCCI from calphy.routines import ( MeltingTemp, routine_fe, @@ -68,6 +69,9 @@ def setup_calculation(calc): if calc.mode == "melting_temperature": simfolder = None job = MeltingTemp(calculation=calc, simfolder=simfolder) + elif calc.mode == "dcci": + simfolder = calc.create_folders() + job = DynamicCCI(calculation=calc, simfolder=simfolder) elif calc.mode == "alchemy" or calc.mode == "composition_scaling": simfolder = calc.create_folders() job = Alchemy(calculation=calc, simfolder=simfolder) @@ -101,6 +105,8 @@ def run_calculation(job): job = routine_alchemy(job) elif job.calc.mode == "melting_temperature": job.calculate_tm() + elif job.calc.mode == "dcci": + job.calculate_coexistence_line() elif job.calc.mode == "tscale": job = routine_tscale(job) elif job.calc.mode == "pscale": @@ -109,7 +115,7 @@ def run_calculation(job): job = routine_composition_scaling(job) else: raise ValueError( - "Mode should be either fe/ts/alchemy/melting_temperature/tscale/pscale/composition_scaling" + "Mode should be either fe/ts/alchemy/melting_temperature/dcci/tscale/pscale/composition_scaling" ) return job @@ -187,6 +193,11 @@ def main(): job = MeltingTemp( calculation=calc, simfolder=simfolder, log_to_screen=log_to_screen ) + elif calc.mode == "dcci": + job = DynamicCCI( + calculation=calc, simfolder=simfolder, log_to_screen=log_to_screen + ) + os.chdir(simfolder) elif calc.mode == "alchemy" or calc.mode == "composition_scaling": job = Alchemy( calculation=calc, simfolder=simfolder, log_to_screen=log_to_screen @@ -211,6 +222,8 @@ def main(): _ = routine_alchemy(job) elif job.calc.mode == "melting_temperature": job.calculate_tm() + elif job.calc.mode == "dcci": + job.calculate_coexistence_line() elif job.calc.mode == "tscale": _ = routine_tscale(job) elif job.calc.mode == "pscale": @@ -219,5 +232,5 @@ def main(): _ = routine_composition_scaling(job) else: raise ValueError( - "Mode should be either fe/ts/alchemy/melting_temperature/tscale/pscale/composition_scaling" + "Mode should be either fe/ts/alchemy/melting_temperature/dcci/tscale/pscale/composition_scaling" ) diff --git a/calphy/routines.py b/calphy/routines.py index f74f97c0..34a87b5c 100644 --- a/calphy/routines.py +++ b/calphy/routines.py @@ -41,6 +41,48 @@ from calphy.composition_transformation import CompositionTransformation +def enable_phase_detection(calc, logger, mode, solid_fraction=0.7, liquid_fraction=0.05): + """ + Switch the structural melt/solidify checks on in a raw calculation dict + unless the user set them explicitly. + + The shipped defaults (``tolerance.solid_fraction = 0``, + ``tolerance.liquid_fraction = 1``) make both checks unreachable. Modes + that build a solid and a liquid cell and depend on each staying in its + phase (``melting_temperature``, ``dcci``) turn them on for their + sub-calculations only. + + Parameters + ---------- + calc : dict + Raw sub-calculation dict, mutated in place before it is parsed. + logger : logging.Logger + Where the warning about the changed default goes. + mode : str + Name of the calling mode, for the log message. + solid_fraction, liquid_fraction : float + Thresholds to install when the user gave none. + """ + tolerance = calc.setdefault("tolerance", {}) + if not isinstance(tolerance, dict): + return + if tolerance.get("solid_fraction") is None: + tolerance["solid_fraction"] = solid_fraction + logger.warning( + "mode %s: enabling melt detection with tolerance.solid_fraction = %g " + "(the default of 0 makes the check unreachable). Set " + "tolerance.solid_fraction explicitly to override." % (mode, solid_fraction) + ) + if tolerance.get("liquid_fraction") is None: + tolerance["liquid_fraction"] = liquid_fraction + logger.warning( + "mode %s: enabling solidification detection with " + "tolerance.liquid_fraction = %g (the default of 1 makes the check " + "unreachable). Set tolerance.liquid_fraction explicitly to override." + % (mode, liquid_fraction) + ) + + class MeltingTemp: """ Class for automated melting temperature calculation. @@ -99,27 +141,13 @@ def _enable_phase_detection(self, calc): calc : dict Raw sub-calculation dict, mutated in place before it is parsed. """ - tolerance = calc.setdefault("tolerance", {}) - if not isinstance(tolerance, dict): - return - if tolerance.get("solid_fraction") is None: - tolerance["solid_fraction"] = self.DETECTION_SOLID_FRACTION - self.logger.warning( - "mode melting_temperature: enabling melt detection with " - "tolerance.solid_fraction = %g (the default of 0 makes the " - "check unreachable, and the temperature bracket is advanced " - "only when it fires). Set tolerance.solid_fraction " - "explicitly to override." % self.DETECTION_SOLID_FRACTION - ) - if tolerance.get("liquid_fraction") is None: - tolerance["liquid_fraction"] = self.DETECTION_LIQUID_FRACTION - self.logger.warning( - "mode melting_temperature: enabling solidification detection " - "with tolerance.liquid_fraction = %g (the default of 1 makes " - "the check unreachable, and the temperature bracket is " - "advanced only when it fires). Set tolerance.liquid_fraction " - "explicitly to override." % self.DETECTION_LIQUID_FRACTION - ) + enable_phase_detection( + calc, + self.logger, + "melting_temperature", + self.DETECTION_SOLID_FRACTION, + self.DETECTION_LIQUID_FRACTION, + ) def prepare_calcs(self): """ diff --git a/calphy/runner.py b/calphy/runner.py index e773f143..7bd49227 100644 --- a/calphy/runner.py +++ b/calphy/runner.py @@ -59,7 +59,7 @@ "dump_modify", }) ONE_SHOT_TOKENS = frozenset({ - "run", "velocity", "displace_atoms", "change_box", + "run", "velocity", "displace_atoms", "change_box", "reset_timestep", "read_data", "read_restart", "write_data", "write_restart", "print", }) REMOVAL_TOKENS = frozenset({"undump", "unfix", "uncompute"}) @@ -619,7 +619,7 @@ def required_styles(calc): if phase == "liquid" or mode == "melting_temperature": pair.add("ufm") pair.add("hybrid/scaled") - if mode in ("ts", "tscale") or getattr(calc, "pair_mode", None) == "overlay": + if mode in ("ts", "tscale", "dcci") or getattr(calc, "pair_mode", None) == "overlay": pair.add("hybrid/scaled") if getattr(getattr(calc, "monte_carlo", None), "n_swaps", 0) > 0: fix.add("atom/swap") diff --git a/docs/_static/example13.png b/docs/_static/example13.png new file mode 100644 index 00000000..a4d5809e Binary files /dev/null and b/docs/_static/example13.png differ diff --git a/docs/source/examples.md b/docs/source/examples.md index 3ec8f60c..0faa2aed 100644 --- a/docs/source/examples.md +++ b/docs/source/examples.md @@ -39,6 +39,12 @@ The gallery of examples below cover different ways in which calphy can be used t :link-type: doc ``` +```{grid-item-card} Melting line of Cu by dynamic Clausius-Clapeyron integration +:img-top: example13.png +:link: examples/example_13/analysis +:link-type: doc +``` + ```{grid-item-card} Running calphy from jupyter notebooks :img-top: example06.jpg :link: examples/example_06/analysis diff --git a/docs/source/examples/example_13/analysis.ipynb b/docs/source/examples/example_13/analysis.ipynb new file mode 100644 index 00000000..bef5405e --- /dev/null +++ b/docs/source/examples/example_13/analysis.ipynb @@ -0,0 +1,495 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c334ab82", + "metadata": {}, + "source": [ + "# Example 13: Melting line of Cu by dynamic Clausius-Clapeyron integration" + ] + }, + { + "cell_type": "markdown", + "id": "ecf1f486", + "metadata": {}, + "source": [ + "In this example the melting line of Cu is traced from 0 bar to 50 kbar in a single pair of nonequilibrium runs with `mode: dcci`, the dynamic Clausius-Clapeyron integration of [de Koning, Antonelli and Yip, J. Chem. Phys. 115, 11025 (2001)](https://doi.org/10.1063/1.1420486).\n", + "\n", + "The EAM potential is the same as in the melting-temperature examples: [Mishin, Y., M. J. Mehl, D. A. Papaconstantopoulos, A. F. Voter, and J. D. Kress, Physical Review B 63, 224106 (2001)](https://doi.org/10.1103/PhysRevB.63.224106).\n", + "\n", + "The method needs one known coexistence point. Here it is the melting temperature at 0 bar from a `melting_temperature` calculation (example 04), 1340 K. From there a solid and a liquid cell are driven side by side at a fixed kinetic temperature with the scaled Hamiltonian $K + \\lambda U$ of reversible scaling; the scaled pressure $P_{RS}$ of both cells is ramped linearly, and after every block of `n_block_steps` MD steps the scaling factor is updated from the block averages of the potential energy $u$ and volume $v$ per atom of the two cells,\n", + "\n", + "$$\\frac{d\\lambda}{dP_{RS}} = -\\frac{v_s - v_l}{u_s - u_l},$$\n", + "\n", + "which is the Clausius-Clapeyron equation in the scaled variables. Every block is a point $T = T_0/\\lambda$, $P = P_{RS}/\\lambda$ of the melting line. A backward sweep returns to 0 bar; the line is the mean of both directions and the mismatch of the round trip is the hysteresis of the integration. The input file is provided in the folder:\n", + "\n", + "```\n", + "mode: dcci\n", + "temperature: 1340.0\n", + "pressure: [0.0, 50000.0]\n", + "n_switching_steps: 30000\n", + "dcci:\n", + " n_block_steps: 500\n", + "```\n", + "\n", + "and is run with `calphy -i input.yaml`. The sweep stops once the real pressure reaches 50 kbar, after 53 of the 60 blocks; out and back it takes a few minutes on four cores. Two further inputs integrate the same line with other settings: `input_converged.yaml` to 100 kbar with 200 blocks of 500 steps (the sweep stops after 155 once the real pressure reaches 100 kbar), and `input_high.yaml` to 1.5 Mbar with 1000-step blocks, which stops after 29 blocks because the real pressure runs far ahead of the scaled ramp there." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "05d98251", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:20.214542Z", + "iopub.status.busy": "2026-09-10T10:12:20.214366Z", + "iopub.status.idle": "2026-09-10T10:12:23.570614Z", + "shell.execute_reply": "2026-09-10T10:12:23.570173Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import yaml\n", + "from calphy.postprocessing import read_coexistence_line" + ] + }, + { + "cell_type": "markdown", + "id": "08253e8f", + "metadata": {}, + "source": [ + "The result is written to `coexistence_line.dat` in the calculation folder; `report.yaml` summarises it." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "889b2ee0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.571886Z", + "iopub.status.busy": "2026-09-10T10:12:23.571754Z", + "iopub.status.idle": "2026-09-10T10:12:23.575533Z", + "shell.execute_reply": "2026-09-10T10:12:23.575187Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'coexistence_line': 'coexistence_line.dat',\n", + " 'error_at_pressure_reached': 0.0,\n", + " 'hysteresis': 0.2081550000000334,\n", + " 'hysteresis_high': False,\n", + " 'n_blocks_used': 53,\n", + " 'pressure_reached': 51028.767473,\n", + " 'temperature_at_pressure_reached': 1548.193549,\n", + " 'unit': 'K, bar'}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "folder = \"dcci-fcc-solid-1340-0\"\n", + "\n", + "with open(f\"{folder}/report.yaml\") as fin:\n", + " report = yaml.safe_load(fin)\n", + "report[\"results\"]" + ] + }, + { + "cell_type": "markdown", + "id": "cf130f23", + "metadata": {}, + "source": [ + "The round trip returns to within a fraction of a kelvin of the starting temperature, so the integration is reversible at this sweep length. The line itself, every tenth block:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2a432428", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.576573Z", + "iopub.status.busy": "2026-09-10T10:12:23.576504Z", + "iopub.status.idle": "2026-09-10T10:12:23.583838Z", + "shell.execute_reply": "2026-09-10T10:12:23.583490Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pressuretemperatureerrortemperature_forwardtemperature_backward
00.0000001340.1040780.1040781340.0000001340.208155
108561.3758471376.6954040.0261681376.6692361376.721573
2017592.4431531414.4601200.0276911414.4324291414.487811
3027115.6576821453.4995450.1002931453.3992521453.599839
4037158.0704491493.8044100.0499781493.7544321493.854389
5047743.5331281535.4662580.0342331535.4320251535.500491
\n", + "
" + ], + "text/plain": [ + " pressure temperature error temperature_forward \\\n", + "0 0.000000 1340.104078 0.104078 1340.000000 \n", + "10 8561.375847 1376.695404 0.026168 1376.669236 \n", + "20 17592.443153 1414.460120 0.027691 1414.432429 \n", + "30 27115.657682 1453.499545 0.100293 1453.399252 \n", + "40 37158.070449 1493.804410 0.049978 1493.754432 \n", + "50 47743.533128 1535.466258 0.034233 1535.432025 \n", + "\n", + " temperature_backward \n", + "0 1340.208155 \n", + "10 1376.721573 \n", + "20 1414.487811 \n", + "30 1453.599839 \n", + "40 1493.854389 \n", + "50 1535.500491 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "line = read_coexistence_line(folder)\n", + "line.iloc[::10]" + ] + }, + { + "cell_type": "markdown", + "id": "4c084987", + "metadata": {}, + "source": [ + "The other two runs report their hysteresis in the same way; the 155-block run closes to a hundredth of a kelvin:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e5e786eb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.584837Z", + "iopub.status.busy": "2026-09-10T10:12:23.584773Z", + "iopub.status.idle": "2026-09-10T10:12:23.588560Z", + "shell.execute_reply": "2026-09-10T10:12:23.588250Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'coexistence_line': 'coexistence_line.dat',\n", + " 'error_at_pressure_reached': 0.0,\n", + " 'hysteresis': 2.4347530000000006,\n", + " 'hysteresis_high': False,\n", + " 'n_blocks_used': 29,\n", + " 'pressure_reached': 1580250.711377,\n", + " 'temperature_at_pressure_reached': 4867.898743,\n", + " 'unit': 'K, bar'}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "folder_conv = \"dcci-fcc-solid-1340-0-converged\"\n", + "folder_high = \"dcci-fcc-solid-1340-0-high\"\n", + "\n", + "line_conv = read_coexistence_line(folder_conv)\n", + "line_high = read_coexistence_line(folder_high)\n", + "with open(f\"{folder_high}/report.yaml\") as fin:\n", + " report_high = yaml.safe_load(fin)\n", + "report_high[\"results\"]" + ] + }, + { + "cell_type": "markdown", + "id": "eb8fb5e3", + "metadata": {}, + "source": [ + "To check the lines, the melting point was calculated independently at several pressures in two ways: with `mode: melting_temperature` (the input files `tm.input.*.yaml` are in the folder), and by direct free-energy calculations of both phases at two temperatures bracketing the melting point, whose crossing of $G_l - G_s$ gives $T_m$ with an error bar. Each of those points costs more than a whole coexistence line." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "df3d8ebf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.589521Z", + "iopub.status.busy": "2026-09-10T10:12:23.589454Z", + "iopub.status.idle": "2026-09-10T10:12:23.592599Z", + "shell.execute_reply": "2026-09-10T10:12:23.592219Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'pressure': 0.0,\n", + " 'tm': 1340.6,\n", + " 'tm_error': 0.0,\n", + " 'method': 'melting_temperature'},\n", + " {'pressure': 50000.0,\n", + " 'tm': 1564.9,\n", + " 'tm_error': 0.0,\n", + " 'method': 'melting_temperature'},\n", + " {'pressure': 100000.0,\n", + " 'tm': 1776.3,\n", + " 'tm_error': 0.0,\n", + " 'method': 'melting_temperature'},\n", + " {'pressure': 500000.0,\n", + " 'tm': 2912.9,\n", + " 'tm_error': 0.0,\n", + " 'method': 'melting_temperature'},\n", + " {'pressure': 0.0, 'tm': 1353.3, 'tm_error': 1.9, 'method': 'fe_crossing'},\n", + " {'pressure': 50000.0, 'tm': 1559.9, 'tm_error': 1.6, 'method': 'fe_crossing'},\n", + " {'pressure': 100000.0,\n", + " 'tm': 1749.2,\n", + " 'tm_error': 3.4,\n", + " 'method': 'fe_crossing'}]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with open(\"melting_temperature_reference.yaml\") as fin:\n", + " reference = yaml.safe_load(fin)\n", + "reference" + ] + }, + { + "cell_type": "markdown", + "id": "61bd53eb", + "metadata": {}, + "source": [ + "As in example 05 we also compare with Simon-equation fits, $T_m(P) = T_{m0}(P/a + 1)^b$, reported for this potential by [Wang et al. (2013)](https://doi.org/10.1063/1.4798225) and by An et al.:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "054d9724", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.593477Z", + "iopub.status.busy": "2026-09-10T10:12:23.593421Z", + "iopub.status.idle": "2026-09-10T10:12:23.859471Z", + "shell.execute_reply": "2026-09-10T10:12:23.859063Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def simon(p_gpa, tm0, a, b):\n", + " return tm0 * (p_gpa / a + 1) ** b\n", + "\n", + "GPA = 1e-4 # bar -> GPa\n", + "BLUE, ORANGE, INK, AQUA = \"#2a78d6\", \"#eb6834\", \"#1a1a19\", \"#1baf7a\"\n", + "\n", + "def draw(ax, zoom):\n", + " for df, lw, label in ((line_high, 1.8, \"d-CCI, 0 to 158 GPa, 29 blocks of 1000 steps\"),\n", + " (line_conv, 3.0, \"d-CCI, 0 to 10 GPa, 155 blocks of 500 steps\"),\n", + " (line, 3.0, \"d-CCI, 0 to 5 GPa, 53 blocks of 500 steps\")):\n", + " p = df.pressure * GPA\n", + " ax.fill_between(p, df.temperature - df.error, df.temperature + df.error, color=BLUE, alpha=0.18, lw=0)\n", + " ax.plot(p, df.temperature, color=BLUE, lw=lw, label=label)\n", + " for method, fmt, color, mfc, dx in ((\"melting_temperature\", \"o\", ORANGE, ORANGE, 9), (\"fe_crossing\", \"s\", INK, \"white\", -9)):\n", + " pts = [r for r in reference if r[\"method\"] == method]\n", + " p = np.array([r[\"pressure\"] for r in pts]) * GPA\n", + " t = np.array([r[\"tm\"] for r in pts])\n", + " e = np.array([r[\"tm_error\"] for r in pts])\n", + " ax.errorbar(p, t, yerr=e, fmt=fmt, ms=7, color=color, mfc=mfc, mec=color if mfc == \"white\" else \"white\", mew=1.5,\n", + " ecolor=color, capsize=4, lw=1.2, zorder=5, label=method.replace(\"_\", \" \") + (\" mode\" if method == \"melting_temperature\" else \", direct fe of both phases\"))\n", + " if zoom:\n", + " for pi, ti in zip(p, t):\n", + " ax.annotate(\"%.0f K\" % ti, (pi, ti), textcoords=\"offset points\", xytext=(dx, -dx), fontsize=8,\n", + " color=color, ha=\"left\" if dx > 0 else \"right\", va=\"center\")\n", + " pfit = np.linspace(0, 160, 300)\n", + " ax.plot(pfit, simon(pfit, 1315, 15.84, 0.543), ls=\"--\", lw=1.2, color=AQUA, label=\"Simon fit, Wang et al. (2013)\")\n", + " ax.plot(pfit, simon(pfit, 1325, 15.37, 0.53), ls=\":\", lw=1.4, color=AQUA, label=\"Simon fit, An et al.\")\n", + " ax.set_xlabel(\"pressure (GPa)\")\n", + " if zoom:\n", + " ax.set_xlim(-0.4, 11.5); ax.set_ylim(1290, 1830); ax.set_title(\"low-pressure end\", loc=\"left\", fontsize=10)\n", + " else:\n", + " ax.set_ylabel(\"melting temperature (K)\"); ax.set_title(\"Melting line of Cu (Mishin Cu01 EAM, 500-atom cells)\", loc=\"left\")\n", + " ax.legend(frameon=False, fontsize=8, loc=\"lower right\")\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11.5, 4.8), gridspec_kw={\"width_ratios\": [1.45, 1]})\n", + "draw(ax1, False); draw(ax2, True)\n", + "fig.tight_layout()\n", + "plt.savefig(\"melting_line.png\", dpi=150, bbox_inches=\"tight\")" + ] + }, + { + "cell_type": "markdown", + "id": "b18a965b", + "metadata": {}, + "source": [ + "The three d-CCI runs agree with each other (1544 K at 5 GPa from both the 53- and the 155-block run; 1719 K against 1730 K at 10 GPa from the 29- and the 155-block run), so the line is converged to about 10 K at 10 GPa with 500-step blocks, and it tracks the published Simon fits for this potential to within a few percent up to 160 GPa.\n", + "\n", + "Against the direct free-energy crossings the d-CCI line runs about 1 percent low, and the whole offset is the starting point: the direct crossing at 0 bar is 1353 K where `melting_temperature` gave 1340 K, the value the integration started from. Scaling the line by 1353/1340 gives 1559 K at 5 GPa and 1747 K at 10 GPa against the direct 1560 K and 1749 K. The dynamic integration therefore reproduces the pressure dependence to within a few kelvin; its accuracy is set by the accuracy of the starting coexistence point, and an error there propagates roughly in proportion to $T/T_0$. The `melting_temperature` points scatter around the direct crossings by 10 to 30 K, which is the resolution of that mode at these short settings.\n", + "\n", + "The slope of the line agrees with the Clausius-Clapeyron slope $\\Delta H/(T\\Delta V)$ written per block to `dcci.forward_1.dat`:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "73e56a10", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.860547Z", + "iopub.status.busy": "2026-09-10T10:12:23.860478Z", + "iopub.status.idle": "2026-09-10T10:12:23.938437Z", + "shell.execute_reply": "2026-09-10T10:12:23.938048Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fwd = np.loadtxt(f\"{folder_conv}/dcci.forward_1.dat\")\n", + "temp, press, dpdt = fwd[:, 3], fwd[:, 5], fwd[:, 10]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(press * GPA, dpdt, \"o\", ms=3, label=r\"$\\Delta H / (T \\Delta V)$ per block\")\n", + "ax.plot(press * GPA, np.gradient(press, temp), \"-\", label=\"slope of the integrated line\")\n", + "ax.set_xlabel(\"pressure (GPa)\")\n", + "ax.set_ylabel(\"dP/dT (bar/K)\")\n", + "ax.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "2ab77485", + "metadata": {}, + "source": [ + "Convergence is judged from the hysteresis: repeat with a longer `n_switching_steps` (or more `n_iterations`) until the round trip closes within the accuracy needed. The reference paper found the hysteresis to fall below the error of the starting point at about $10^5$ steps for a 500-atom Lennard-Jones system spanning two orders of magnitude in pressure." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "calphy", + "language": "python", + "name": "calphy" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/coexistence_line.dat b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/coexistence_line.dat new file mode 100644 index 00000000..99097e81 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/coexistence_line.dat @@ -0,0 +1,158 @@ +# dynamic Clausius-Clapeyron coexistence line +# pressure[bar] temperature[K] error[K] T_forward[K] T_backward[K] +0.000000000000000000e+00 1.339993760500000008e+03 6.239499999992403900e-03 1.340000000000000000e+03 1.339987521000000015e+03 +5.008051639999999907e+02 1.342158209401751492e+03 3.694017514135339297e-04 1.342157840000000078e+03 1.342158578803502905e+03 +1.003227745000000027e+03 1.344317963465904086e+03 7.214534096078750736e-03 1.344325178000000051e+03 1.344310748931807893e+03 +1.507306456000000026e+03 1.346490538584029764e+03 3.656241597002463095e-02 1.346527100999999902e+03 1.346453976168059853e+03 +2.012934882000000016e+03 1.348645702182144305e+03 2.066881785572149965e-02 1.348666371000000026e+03 1.348625033364288583e+03 +2.520217635999999857e+03 1.350810756444710478e+03 2.589655528970524756e-02 1.350836653000000069e+03 1.350784859889420659e+03 +3.029162504999999783e+03 1.353010049415953745e+03 1.586958404607230477e-02 1.353025918999999931e+03 1.352994179831907786e+03 +3.539765569000000141e+03 1.355222337814984712e+03 2.194185015241600922e-03 1.355224531999999954e+03 1.355220143629969471e+03 +4.051920482999999876e+03 1.357424827483646823e+03 3.146548364691170718e-02 1.357393362000000025e+03 1.357456292967293848e+03 +4.565813122999999905e+03 1.359627303366280785e+03 2.961736628071776067e-02 1.359597686000000067e+03 1.359656920732561503e+03 +5.081301129999999830e+03 1.361815498811932684e+03 2.679581193262947636e-02 1.361788702999999941e+03 1.361842294623865200e+03 +5.598551629999999932e+03 1.364036779325487487e+03 2.601832548748461704e-02 1.364010761000000002e+03 1.364062797650974971e+03 +6.117401584000000184e+03 1.366248179041735511e+03 2.849204173560337949e-02 1.366219687000000022e+03 1.366276671083471228e+03 +6.638181835999999748e+03 1.368487279173131583e+03 5.621731315841316245e-04 1.368486716999999999e+03 1.368487841346263167e+03 +7.160361428999999589e+03 1.370686141619095224e+03 1.161738090468134033e-02 1.370697758999999905e+03 1.370674524238190543e+03 +7.684157793999999740e+03 1.372892849706615380e+03 1.000929338454170647e-02 1.372902859000000035e+03 1.372882840413230952e+03 +8.209824851999999737e+03 1.375152777134149801e+03 7.114134149787787464e-03 1.375145663000000013e+03 1.375159891268299589e+03 +8.737214035999999396e+03 1.377393150832657739e+03 2.944167342320724856e-03 1.377396095000000059e+03 1.377390206665315418e+03 +9.266126548000000184e+03 1.379620812958434271e+03 2.473041565849598555e-03 1.379623286000000007e+03 1.379618339916868308e+03 +9.796827347000000373e+03 1.381867950645094652e+03 3.273549052664748160e-04 1.381868277999999918e+03 1.381867623290189385e+03 +1.032908918699999958e+04 1.384109633309495621e+03 1.168230949565440824e-02 1.384097950999999966e+03 1.384121315618991275e+03 +1.086312865000000056e+04 1.386340035327550140e+03 2.097672449849596887e-03 1.386342133000000103e+03 1.386337937655100404e+03 +1.139927621100000033e+04 1.388621299610059850e+03 1.780238994035698852e-02 1.388639102000000094e+03 1.388603497220119380e+03 +1.193679761499999950e+04 1.390876008691932157e+03 2.040930806788310292e-02 1.390896418000000040e+03 1.390855599383864273e+03 +1.247581122999999934e+04 1.393112327714739422e+03 1.992628526056705596e-02 1.393132254000000103e+03 1.393092401429478969e+03 +1.301671017199999915e+04 1.395377689639206892e+03 1.364036079314701055e-02 1.395391329999999925e+03 1.395364049278413631e+03 +1.355926933800000006e+04 1.397649046293276797e+03 1.283293276856056764e-03 1.397647762999999941e+03 1.397650329586553653e+03 +1.410373944200000005e+04 1.399941503546857348e+03 1.477354685744103335e-02 1.399926729999999907e+03 1.399956277093714789e+03 +1.464986624999999913e+04 1.402213365843408610e+03 1.188184340855968912e-02 1.402201483999999937e+03 1.402225247686817056e+03 +1.519792548399999941e+04 1.404505679841597157e+03 7.738841596960810421e-03 1.404497941000000083e+03 1.404513418683194004e+03 +1.574775922800000080e+04 1.406802668767394607e+03 2.844767394549307937e-03 1.406799823999999944e+03 1.406805513534789043e+03 +1.629923497300000054e+04 1.409100758258444785e+03 5.605258444916216831e-03 1.409095152999999982e+03 1.409106363516889814e+03 +1.685247529500000019e+04 1.411403650242079493e+03 8.844242079476316576e-03 1.411394806000000017e+03 1.411412494484158969e+03 +1.740761628500000006e+04 1.413708809275104159e+03 6.347248960310025723e-04 1.413709444000000076e+03 1.413708174550208014e+03 +1.796436408500000107e+04 1.416003657878917238e+03 1.092312108266924042e-02 1.416014580999999907e+03 1.415992734757834569e+03 +1.852290537400000176e+04 1.418305024813920227e+03 2.030118607967779099e-02 1.418325325999999905e+03 1.418284723627840549e+03 +1.908289370300000155e+04 1.420609202730466677e+03 6.217269533408398274e-03 1.420615420000000086e+03 1.420602985460933269e+03 +1.964496562099999937e+04 1.422925671113979661e+03 6.973886020432473742e-03 1.422932645000000093e+03 1.422918697227959228e+03 +2.020865354799999841e+04 1.425245459728014566e+03 3.577728014533931855e-03 1.425241882000000032e+03 1.425249037456029100e+03 +2.077485606199999893e+04 1.427587277529819858e+03 1.821547018016644870e-02 1.427605493000000024e+03 1.427569062059639691e+03 +2.134262008300000161e+04 1.429933557447324574e+03 2.198855267533872393e-02 1.429955545999999913e+03 1.429911568894649236e+03 +2.191187078699999984e+04 1.432270749866374217e+03 1.738913362578387023e-02 1.432288139000000001e+03 1.432253360732748433e+03 +2.248288276699999915e+04 1.434588131395366645e+03 3.391160463343112497e-02 1.434622043000000076e+03 1.434554219790733214e+03 +2.305539307399999961e+04 1.436909285893453671e+03 3.149210654635226092e-02 1.436940777999999909e+03 1.436877793786907205e+03 +2.362996820300000036e+04 1.439257867668747622e+03 2.201333125242399547e-02 1.439279880999999932e+03 1.439235854337495084e+03 +2.420636405999999988e+04 1.441596619689516501e+03 2.684031048352153448e-02 1.441623460000000023e+03 1.441569779379032980e+03 +2.478459308299999975e+04 1.443931629968297102e+03 4.031503170290307025e-02 1.443971945000000005e+03 1.443891314936594199e+03 +2.536491370000000097e+04 1.446284810326121260e+03 5.494967387880933529e-02 1.446339760000000069e+03 1.446229860652242451e+03 +2.594769542100000035e+04 1.448684770845706225e+03 6.155715429372321523e-02 1.448746327999999949e+03 1.448623213691412502e+03 +2.653143133500000113e+04 1.451057424189347103e+03 4.943281065288829268e-02 1.451106856999999991e+03 1.451007991378694214e+03 +2.711658403399999952e+04 1.453417977394117770e+03 3.092660588220041973e-02 1.453448904000000084e+03 1.453387050788235683e+03 +2.770407111200000145e+04 1.455798646412313246e+03 2.312958768675343890e-02 1.455821776000000000e+03 1.455775516824626493e+03 +2.829376447199999893e+04 1.458181275371953006e+03 3.581662804708685144e-02 1.458217092000000093e+03 1.458145458743905920e+03 +2.888442160599999988e+04 1.460547964082934868e+03 2.278891706521335436e-02 1.460570752999999968e+03 1.460525175165869541e+03 +2.947720073699999921e+04 1.462924754254513118e+03 1.780074548707943904e-02 1.462942555000000084e+03 1.462906953509025925e+03 +3.007293770099999892e+04 1.465350572133488640e+03 2.166486651140075992e-02 1.465372237000000041e+03 1.465328907266977239e+03 +3.066976707199999873e+04 1.467764473361173486e+03 2.950638826405338477e-03 1.467767423999999892e+03 1.467761522722347081e+03 +3.126899415399999998e+04 1.470175915439923529e+03 1.538856007641697943e-02 1.470191303999999946e+03 1.470160526879847112e+03 +3.186958236400000169e+04 1.472595215223715059e+03 7.202237150067958282e-04 1.472594495000000052e+03 1.472595935447430065e+03 +3.247138889600000039e+04 1.475001794794719444e+03 3.023179471927051054e-02 1.474971563000000060e+03 1.475032026589438601e+03 +3.307690910299999814e+04 1.477443935129172132e+03 8.662129172080312856e-03 1.477435273000000052e+03 1.477452597258344213e+03 +3.368359217099999660e+04 1.479873723659117104e+03 4.428659117138522561e-03 1.479869294999999966e+03 1.479878152318234243e+03 +3.429232540000000154e+04 1.482328504136546144e+03 1.508313654619541921e-02 1.482313421000000062e+03 1.482343587273092453e+03 +3.490284400499999902e+04 1.484771188539336435e+03 1.528453933644868812e-02 1.484755904000000100e+03 1.484786473078672998e+03 +3.551570850800000335e+04 1.487233549021301087e+03 1.325502130111999577e-02 1.487220293999999967e+03 1.487246804042602207e+03 +3.613119341400000121e+04 1.489730941953329420e+03 1.404395332951935416e-02 1.489716897999999901e+03 1.489744985906658940e+03 +3.674761678499999834e+04 1.492185990550691486e+03 1.003655069143860601e-02 1.492175954000000047e+03 1.492196027101382924e+03 +3.736511214399999881e+04 1.494626337918719400e+03 2.185191871933511720e-02 1.494604485999999952e+03 1.494648189837438622e+03 +3.798647225500000059e+04 1.497111403129374139e+03 2.503870625673698669e-03 1.497113906999999926e+03 1.497108899258748579e+03 +3.860926469799999904e+04 1.499596405094885540e+03 9.817905114459790639e-03 1.499606223000000000e+03 1.499586587189771080e+03 +3.923333552100000088e+04 1.502067559270764832e+03 8.714729235066442925e-03 1.502076274000000012e+03 1.502058844541529879e+03 +3.985988792500000272e+04 1.504556178281751727e+03 1.423871824817979359e-02 1.504570416999999907e+03 1.504541939563503547e+03 +4.048811764499999845e+04 1.507039266121290439e+03 1.844587870959912834e-02 1.507057712000000038e+03 1.507020820242580839e+03 +4.111796822599999723e+04 1.509498295350716944e+03 3.807264928309450625e-02 1.509536368000000039e+03 1.509460222701433850e+03 +4.174937346399999660e+04 1.511970881218541763e+03 3.345478145809011039e-02 1.512004335999999967e+03 1.511937426437083786e+03 +4.238291542199999822e+04 1.514464979058242079e+03 1.786494175780717342e-02 1.514482843999999886e+03 1.514447114116484272e+03 +4.301960343699999794e+04 1.516987423314078342e+03 1.964568592165960581e-02 1.517007069000000001e+03 1.516967777628156682e+03 +4.365758267499999783e+04 1.519477140269394567e+03 3.352973060520980653e-02 1.519510669999999891e+03 1.519443610538789471e+03 +4.429781679399999848e+04 1.521981689337273565e+03 4.586166272645186837e-02 1.522027550999999903e+03 1.521935827674546999e+03 +4.494011028500000248e+04 1.524518294007509212e+03 3.228299249087740463e-02 1.524550576999999976e+03 1.524486011015018221e+03 +4.558301059199999872e+04 1.527021091820829042e+03 9.763179171045521798e-03 1.527030854999999974e+03 1.527011328641657883e+03 +4.622971948800000246e+04 1.529559006305370758e+03 1.689769462927870336e-02 1.529575904000000037e+03 1.529542108610741479e+03 +4.687788122899999871e+04 1.532096222615040915e+03 1.013938495907495962e-02 1.532106361999999990e+03 1.532086083230081840e+03 +4.752815959499999735e+04 1.534645170703177655e+03 9.817031775583018316e-04 1.534644189000000097e+03 1.534646152406355213e+03 +4.818243424799999775e+04 1.537223346491729899e+03 2.574650827011737420e-02 1.537249092999999903e+03 1.537197599983459668e+03 +4.883739240199999767e+04 1.539798496345414378e+03 1.575865458562475396e-02 1.539814255000000003e+03 1.539782737690828753e+03 +4.949274593599999935e+04 1.542327267260345934e+03 4.815739654077333398e-03 1.542332083000000011e+03 1.542322451520691857e+03 +5.014880805600000167e+04 1.544841560016109270e+03 2.770301610905789857e-02 1.544813857000000098e+03 1.544869263032218214e+03 +5.080919362600000022e+04 1.547393813366892573e+03 2.291636689267306792e-02 1.547370897000000014e+03 1.547416729733785360e+03 +5.147085376399999950e+04 1.549937170028344553e+03 2.831502834476395947e-02 1.549908854999999903e+03 1.549965485056689431e+03 +5.213499866699999984e+04 1.552510868050825820e+03 4.646305082587787183e-02 1.552464404999999942e+03 1.552557331101651698e+03 +5.280278163800000038e+04 1.555107452051332075e+03 3.652005133210423082e-02 1.555070932000000084e+03 1.555143972102664293e+03 +5.347033742099999654e+04 1.557669351526203400e+03 5.517452620347285119e-02 1.557614176999999927e+03 1.557724526052406873e+03 +5.414180622700000094e+04 1.560256627327371916e+03 4.113632737198713585e-02 1.560215490999999929e+03 1.560297763654743903e+03 +5.481615550400000211e+04 1.562868304456806754e+03 2.472245680678497592e-02 1.562843581999999969e+03 1.562893026913613539e+03 +5.549117360599999665e+04 1.565465374355106633e+03 3.016135510665662878e-02 1.565435212999999976e+03 1.565495535710213289e+03 +5.616830472400000144e+04 1.568057794721170467e+03 2.595472117047847860e-02 1.568031840000000102e+03 1.568083749442341059e+03 +5.684729839199999697e+04 1.570644717800080343e+03 1.832880008021220419e-02 1.570626389000000017e+03 1.570663046600160442e+03 +5.752936537099999987e+04 1.573265535298972736e+03 1.350229897275312396e-02 1.573252032999999983e+03 1.573279037597945489e+03 +5.821162127299999702e+04 1.575862566555141711e+03 3.281855514171638788e-02 1.575829748000000109e+03 1.575895385110283542e+03 +5.889593370300000242e+04 1.578441757883391347e+03 3.073488339146024373e-02 1.578411022999999886e+03 1.578472492766782807e+03 +5.958319017400000303e+04 1.581059025640494383e+03 3.972164049434923072e-02 1.581019303999999920e+03 1.581098747280988619e+03 +6.027442681699999957e+04 1.583711236270139352e+03 3.021827013935762807e-02 1.583681017999999995e+03 1.583741454540278710e+03 +6.096688373799999681e+04 1.586358045643202786e+03 3.524564320275658247e-02 1.586322799999999916e+03 1.586393291286405429e+03 +6.166070602700000018e+04 1.588989941340638325e+03 4.097834063838945440e-02 1.588948963000000049e+03 1.589030919681276828e+03 +6.235827090199999657e+04 1.591629469827852745e+03 8.840827852736765635e-03 1.591620629000000008e+03 1.591638310655705482e+03 +6.305667080200000055e+04 1.594272778802981065e+03 9.780802981254055339e-03 1.594262997999999925e+03 1.594282559605962433e+03 +6.375611314799999673e+04 1.596916490181818972e+03 3.440418181889981497e-02 1.596882086000000072e+03 1.596950894363637872e+03 +6.445882994699999836e+04 1.599571416376993511e+03 3.748837699345131114e-02 1.599533928000000060e+03 1.599608904753986963e+03 +6.516394532099999924e+04 1.602222650871653968e+03 2.656387165382056992e-02 1.602196087000000034e+03 1.602249214743307675e+03 +6.587298723899999459e+04 1.604907703577071061e+03 2.196577071117644664e-03 1.604905506999999943e+03 1.604909900154142179e+03 +6.658403559400000086e+04 1.607605232470640203e+03 9.320529359683860093e-03 1.607614552999999887e+03 1.607595911941280519e+03 +6.729595391199999722e+04 1.610289798893380976e+03 6.241106618858793809e-03 1.610296039999999948e+03 1.610283557786762231e+03 +6.801016203999999561e+04 1.612980886516347255e+03 3.487483652747869201e-03 1.612984373999999889e+03 1.612977399032694393e+03 +6.872554486100000213e+04 1.615671203178158976e+03 1.804317815901868016e-02 1.615653160000000071e+03 1.615689246356318108e+03 +6.944521541499999876e+04 1.618400552632981544e+03 2.509763298144207511e-02 1.618375455000000102e+03 1.618425650265962986e+03 +7.016693814199999906e+04 1.621128865012545475e+03 3.063901254540724040e-02 1.621098226000000068e+03 1.621159504025090882e+03 +7.088854748399999517e+04 1.623825303813229766e+03 5.344681322969790926e-02 1.623771856999999954e+03 1.623878750626459350e+03 +7.161558094600000186e+04 1.626563493409701096e+03 4.012940970130784990e-02 1.626523363999999901e+03 1.626603622819402517e+03 +7.234164958199999819e+04 1.629252233837536096e+03 4.533583753629955027e-02 1.629206897999999910e+03 1.629297569675072509e+03 +7.307080668599999626e+04 1.631964633145536709e+03 4.995014553674081981e-02 1.631914682999999968e+03 1.632014583291073450e+03 +7.379881473899999401e+04 1.634651923679552283e+03 9.966367955235000409e-02 1.634552259999999933e+03 1.634751587359104633e+03 +7.453344419900000503e+04 1.637396632842629060e+03 1.045798426290502903e-01 1.637292052999999896e+03 1.637501212685257997e+03 +7.526994691300000704e+04 1.640126170942852468e+03 9.805894285250360554e-02 1.640028111999999965e+03 1.640224229885704972e+03 +7.600928955800000404e+04 1.642876908946691174e+03 9.548994669125931978e-02 1.642781418999999914e+03 1.642972398893382433e+03 +7.675042920600000070e+04 1.645618975737974552e+03 8.977373797461041249e-02 1.645529201999999941e+03 1.645708749475949162e+03 +7.749575744899999700e+04 1.648410733536470616e+03 8.827353647063773678e-02 1.648322460000000092e+03 1.648499007072941367e+03 +7.824385172299999977e+04 1.651205712890302721e+03 7.561389030274767720e-02 1.651130098999999973e+03 1.651281326780605468e+03 +7.899280421899999783e+04 1.653974061468354876e+03 6.222346835488679062e-02 1.653911837999999989e+03 1.654036284936709762e+03 +7.974424908300000243e+04 1.656756902511550607e+03 5.467351155061805912e-02 1.656702228999999988e+03 1.656811576023101225e+03 +8.049662578200000280e+04 1.659531444187079387e+03 6.254318707942729816e-02 1.659468900999999960e+03 1.659593987374158814e+03 +8.125046863600000506e+04 1.662291006726462228e+03 6.767872646219075250e-02 1.662223328000000038e+03 1.662358685452924419e+03 +8.200788176099999691e+04 1.665078714664661675e+03 7.020666466166858299e-02 1.665008507999999892e+03 1.665148921329323230e+03 +8.276866854699999385e+04 1.667873065993499495e+03 5.327899349958897801e-02 1.667819786999999906e+03 1.667926344986999084e+03 +8.352904464900000312e+04 1.670651031128934846e+03 7.013812893478643673e-02 1.670580893000000060e+03 1.670721169257869633e+03 +8.429400214700000652e+04 1.673466656934386720e+03 7.461393438677532686e-02 1.673392043000000058e+03 1.673541270868773609e+03 +8.506376380800000334e+04 1.676317327793107324e+03 6.080579310730627185e-02 1.676256521999999904e+03 1.676378133586214517e+03 +8.583314857400000619e+04 1.679122641302445572e+03 5.082930244577710255e-02 1.679071811999999909e+03 1.679173470604891463e+03 +8.660309017999999924e+04 1.681923315526053557e+03 6.620152605376006250e-02 1.681857113999999910e+03 1.681989517052107431e+03 +8.737943822300000465e+04 1.684749197318333472e+03 2.333831833357180585e-02 1.684725858999999900e+03 1.684772535636667044e+03 +8.815540989700000500e+04 1.687570783106171575e+03 2.436510617167186865e-02 1.687546417999999903e+03 1.687595148212343247e+03 +8.893489338500000304e+04 1.690406154124681962e+03 1.243612468203991739e-02 1.690393718000000035e+03 1.690418590249364115e+03 +8.971329492899999605e+04 1.693228994228910324e+03 4.849822891048916063e-02 1.693180495999999948e+03 1.693277492457820927e+03 +9.049614367600000696e+04 1.696058828181527588e+03 4.718418152754111361e-02 1.696011643999999933e+03 1.696106012363055015e+03 +9.128180608100000245e+04 1.698881015440331339e+03 2.518044033138266968e-02 1.698855835000000070e+03 1.698906195880662835e+03 +9.206736811799999850e+04 1.701690887931842553e+03 3.194593184241512063e-02 1.701658942000000025e+03 1.701722833863684855e+03 +9.285653021500000614e+04 1.704539220297255724e+03 4.948729725572320604e-02 1.704489732999999887e+03 1.704588707594511334e+03 +9.365075922799999535e+04 1.707403413112952876e+03 2.902711295291737770e-02 1.707374385999999959e+03 1.707432440225905793e+03 +9.444479285300000629e+04 1.710247963239308774e+03 3.144423930871198536e-02 1.710216519000000062e+03 1.710279407478617486e+03 +9.524427091500000097e+04 1.713139609085784286e+03 2.117908578429705813e-02 1.713118429999999989e+03 1.713160788171568583e+03 +9.604578402500000084e+04 1.716021262547613105e+03 3.254547613096292480e-03 1.716018008000000009e+03 1.716024517095226201e+03 +9.684776292300000205e+04 1.718898660631469738e+03 1.121263146990258974e-02 1.718887447999999949e+03 1.718909873262939755e+03 +9.765335890200000722e+04 1.721811702509369297e+03 2.879550936927444127e-02 1.721782907000000023e+03 1.721840498018738572e+03 +9.846194405599999300e+04 1.724718535025320080e+03 2.565902532001018699e-02 1.724692876000000069e+03 1.724744194050640090e+03 +9.927238978199999838e+04 1.727612509769242479e+03 1.507676924245515693e-02 1.727597432999999910e+03 1.727627586538484820e+03 +1.000877429390000034e+05 1.730549361999999974e+03 0.000000000000000000e+00 1.730549361999999974e+03 1.730549361999999974e+03 diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.backward_1.dat b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.backward_1.dat new file mode 100644 index 00000000..74be18ad --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.backward_1.dat @@ -0,0 +1,157 @@ +# dynamic Clausius-Clapeyron backward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 500 0.7756266457 1727.635335 77000.000000 99274.567763 -3.31490000 -3.19354000 11.971200 12.479100 278.869050 +1 1000 0.7769208462 1724.757427 76500.000000 98465.629249 -3.31644000 -3.19351000 11.972300 12.482100 281.087725 +2 1500 0.7782302423 1721.855470 76000.000000 97657.474443 -3.31591000 -3.20108000 11.977700 12.459500 278.484283 +3 2000 0.7795612649 1718.915575 75500.000000 96849.347703 -3.31086000 -3.19670000 12.007800 12.494700 274.880093 +4 2500 0.7808738841 1716.026144 75000.000000 96046.239385 -3.31693000 -3.18864000 11.991300 12.530900 277.949796 +5 3000 0.7821750922 1713.171403 74500.000000 95247.216060 -3.32097000 -3.19875000 11.979900 12.489500 279.895638 +6 3500 0.7834905974 1710.294934 74000.000000 94449.123246 -3.31374000 -3.19356000 12.014900 12.521500 277.454122 +7 4000 0.7847975915 1707.446626 73500.000000 93654.721672 -3.32165000 -3.20446000 11.986400 12.477200 278.904655 +8 4500 0.7861021272 1704.613120 73000.000000 92863.252079 -3.31055000 -3.20089000 12.044400 12.502800 279.325795 +9 5000 0.7874301645 1701.738212 72500.000000 92071.656978 -3.32066000 -3.20340000 12.006500 12.505500 275.343327 +10 5500 0.7887372449 1698.918123 72000.000000 91285.152901 -3.31302000 -3.20386000 12.044100 12.501300 278.896932 +11 6000 0.7900344595 1696.128547 71500.000000 90502.381430 -3.31248000 -3.20593000 12.058700 12.501600 280.607629 +12 6500 0.7913537258 1693.300930 71000.000000 89719.676153 -3.32069000 -3.20556000 12.029300 12.516000 276.804546 +13 7000 0.7927003203 1690.424446 70500.000000 88936.510043 -3.32001000 -3.20133000 12.031400 12.543500 272.261736 +14 7500 0.7940239243 1687.606581 70000.000000 88158.552736 -3.31954000 -3.20151000 12.047100 12.547700 276.084007 +15 8000 0.7953545631 1684.783193 69500.000000 87382.411852 -3.32013000 -3.19998000 12.049600 12.561900 274.896330 +16 8500 0.7966610434 1682.020241 69000.000000 86611.490008 -3.31044000 -3.20584000 12.103100 12.541000 279.024865 +17 9000 0.7980006372 1679.196654 68500.000000 85839.530453 -3.32039000 -3.20095000 12.059900 12.572600 273.392671 +18 9500 0.7993289890 1676.406109 68000.000000 85071.354763 -3.31941000 -3.19419000 12.071800 12.604800 275.279980 +19 10000 0.8006810305 1673.575305 67500.000000 84303.233657 -3.31891000 -3.19503000 12.080200 12.616900 271.340819 +20 10500 0.8020336911 1670.752756 67000.000000 83537.637816 -3.32703000 -3.19294000 12.052400 12.633600 271.242898 +21 11000 0.8033814355 1667.949919 66500.000000 82775.126560 -3.31949000 -3.20281000 12.091000 12.594900 272.050692 +22 11500 0.8047177851 1665.180048 66000.000000 82016.330723 -3.32232000 -3.21053000 12.084800 12.563500 273.948371 +23 12000 0.8060692208 1662.388248 65500.000000 81258.530046 -3.32349000 -3.19743000 12.089800 12.635700 271.436254 +24 12500 0.8074130975 1659.621332 65000.000000 80504.019812 -3.32102000 -3.20001000 12.102400 12.623500 272.691237 +25 13000 0.8087708330 1656.835219 64500.000000 79750.650458 -3.32714000 -3.19385000 12.084000 12.663900 270.399969 +26 13500 0.8101264334 1654.062804 64000.000000 79000.014523 -3.32299000 -3.19810000 12.106800 12.649300 270.752325 +27 14000 0.8114751407 1651.313679 63500.000000 78252.551207 -3.31953000 -3.20055000 12.131700 12.645900 271.892791 +28 14500 0.8128420665 1648.536727 63000.000000 77505.831200 -3.32131000 -3.21008000 12.127900 12.615100 268.897073 +29 15000 0.8142203730 1645.746096 62500.000000 76760.545511 -3.32233000 -3.19592000 12.127400 12.685700 267.065910 +30 15500 0.8155752624 1643.012070 62000.000000 76019.961438 -3.32769000 -3.20103000 12.109200 12.659100 270.880382 +31 16000 0.8169415136 1640.264300 61500.000000 75280.786905 -3.32002000 -3.20355000 12.157700 12.667600 269.007709 +32 16500 0.8182985397 1637.544166 61000.000000 74544.921003 -3.32552000 -3.19469000 12.139300 12.708200 270.527274 +33 17000 0.8196759709 1634.792342 60500.000000 73809.654240 -3.32340000 -3.20203000 12.148400 12.684100 267.189960 +34 17500 0.8210610291 1632.034590 60000.000000 73076.175674 -3.33036000 -3.20549000 12.123200 12.677400 265.969080 +35 18000 0.8224312838 1629.315453 59500.000000 72346.469755 -3.32494000 -3.20216000 12.156500 12.695600 268.361812 +36 18500 0.8237943865 1626.619484 59000.000000 71619.813105 -3.33053000 -3.20706000 12.140200 12.679500 269.535889 +37 19000 0.8251740665 1623.899798 58500.000000 70894.132976 -3.32652000 -3.20718000 12.161700 12.689300 266.823014 +38 19500 0.8265627559 1621.171521 58000.000000 70170.110602 -3.32063000 -3.20966000 12.193000 12.686800 265.376206 +39 20000 0.8279601206 1618.435437 57500.000000 69447.789293 -3.32729000 -3.21051000 12.168300 12.691200 263.997363 +40 20500 0.8293638451 1615.696184 57000.000000 68727.375005 -3.32849000 -3.19910000 12.173400 12.755400 262.996086 +41 21000 0.8307624792 1612.976072 56500.000000 68009.811970 -3.32580000 -3.20656000 12.188100 12.722500 263.800021 +42 21500 0.8321527831 1610.281222 56000.000000 67295.334632 -3.33007000 -3.20300000 12.176200 12.742300 265.128386 +43 22000 0.8335445927 1607.592457 55500.000000 66583.120431 -3.32662000 -3.20545000 12.201000 12.741400 264.885407 +44 22500 0.8349374203 1604.910700 55000.000000 65873.200387 -3.32711000 -3.20390000 12.207000 12.756900 264.722264 +45 23000 0.8363193474 1602.258759 54500.000000 65166.494320 -3.31916000 -3.20164000 12.251100 12.771500 266.488141 +46 23500 0.8376977028 1599.622388 54000.000000 64462.394749 -3.32230000 -3.20520000 12.239600 12.756800 267.072424 +47 24000 0.8390925673 1596.963258 53500.000000 63759.353958 -3.32460000 -3.20817000 12.234700 12.755100 264.385594 +48 24500 0.8405016390 1594.286005 53000.000000 63057.580787 -3.33639000 -3.20944000 12.183100 12.756300 262.122702 +49 25000 0.8418982111 1591.641344 52500.000000 62359.082498 -3.32594000 -3.20601000 12.240600 12.777300 264.118532 +50 25500 0.8432737363 1589.045102 52000.000000 61664.436781 -3.32327000 -3.21269000 12.262400 12.749800 267.561407 +51 26000 0.8446768726 1586.405457 51500.000000 60970.060471 -3.32548000 -3.21136000 12.256400 12.769500 263.053455 +52 26500 0.8460922007 1583.751746 51000.000000 60277.118685 -3.32585000 -3.20870000 12.261500 12.792800 261.120594 +53 27000 0.8475047331 1581.112114 50500.000000 59586.687871 -3.31935000 -3.20241000 12.294200 12.823500 261.563950 +54 27500 0.8489165791 1578.482542 50000.000000 58898.602329 -3.33243000 -3.21519000 12.237200 12.767600 261.672483 +55 28000 0.8503044054 1575.906218 49500.000000 58214.446129 -3.33393000 -3.21194000 12.240800 12.783300 265.558820 +56 28500 0.8517219232 1573.283443 49000.000000 57530.513966 -3.32507000 -3.20110000 12.285300 12.848400 260.763124 +57 29000 0.8531397093 1570.668890 48500.000000 56848.836683 -3.32474000 -3.20185000 12.297000 12.855300 260.724492 +58 29500 0.8545417066 1568.091984 48000.000000 56170.459126 -3.32781000 -3.21589000 12.287500 12.790300 263.255222 +59 30000 0.8559537830 1565.505085 47500.000000 55493.650412 -3.32494000 -3.21099000 12.304400 12.820000 261.628403 +60 30500 0.8573801028 1562.900743 47000.000000 54818.160398 -3.33673000 -3.21335000 12.255300 12.819200 259.369144 +61 31000 0.8588034889 1560.310382 46500.000000 54145.099086 -3.32701000 -3.21379000 12.309300 12.825700 259.833857 +62 31500 0.8602197974 1557.741410 46000.000000 53474.705116 -3.32916000 -3.20883000 12.305300 12.851400 260.959441 +63 32000 0.8616504283 1555.155033 45500.000000 52805.637303 -3.32634000 -3.20776000 12.324200 12.867800 258.687588 +64 32500 0.8630843296 1552.571347 45000.000000 52138.590005 -3.33011000 -3.20686000 12.311300 12.877600 258.176530 +65 33000 0.8645307467 1549.973792 44500.000000 51473.010265 -3.32463000 -3.21071000 12.337700 12.865700 256.232037 +66 33500 0.8659556397 1547.423377 44000.000000 50810.916846 -3.32835000 -3.21341000 12.328900 12.853700 259.605261 +67 34000 0.8673828280 1544.877252 43500.000000 50150.866025 -3.31630000 -3.20758000 12.394900 12.892100 259.237659 +68 34500 0.8688203882 1542.321081 43000.000000 49492.392888 -3.32922000 -3.20954000 12.339800 12.891100 257.600372 +69 35000 0.8702551413 1539.778321 42500.000000 48836.252708 -3.33172000 -3.20987000 12.333400 12.893600 258.043350 +70 35500 0.8717202901 1537.190330 42000.000000 48180.592418 -3.32990000 -3.20455000 12.345200 12.933700 253.343699 +71 36000 0.8731652960 1534.646425 41500.000000 47528.228836 -3.32959000 -3.21517000 12.352400 12.882200 256.444749 +72 36500 0.8746260693 1532.083306 41000.000000 46877.175790 -3.33240000 -3.21052000 12.345300 12.915800 254.006440 +73 37000 0.8760817879 1529.537560 40500.000000 46228.560575 -3.33042000 -3.20891000 12.360600 12.927400 254.784938 +74 37500 0.8775326294 1527.008746 40000.000000 45582.350627 -3.33131000 -3.20823000 12.364300 12.936500 255.539740 +75 38000 0.8789896545 1524.477556 39500.000000 44937.957799 -3.33532000 -3.20548000 12.350500 12.956700 254.580657 +76 38500 0.8804645554 1521.923843 39000.000000 44294.798422 -3.32914000 -3.20318000 12.384700 12.980000 251.850900 +77 39000 0.8819066645 1519.435167 38500.000000 43655.413380 -3.34172000 -3.21084000 12.329500 12.934300 256.922225 +78 39500 0.8833439388 1516.962919 38000.000000 43018.351440 -3.32905000 -3.21269000 12.398600 12.934500 257.686272 +79 40000 0.8848139540 1514.442662 37500.000000 42381.790917 -3.33178000 -3.20037000 12.389300 13.008300 252.573820 +80 40500 0.8862848813 1511.929209 37000.000000 41747.299068 -3.33564000 -3.21074000 12.377500 12.966200 252.438505 +81 41000 0.8877399138 1509.451112 36500.000000 41115.645959 -3.32797000 -3.21288000 12.420900 12.957500 254.896830 +82 41500 0.8891740524 1507.016536 36000.000000 40487.011406 -3.32941000 -3.21730000 12.418800 12.934000 258.214201 +83 42000 0.8906384898 1504.538615 35500.000000 39859.045399 -3.33347000 -3.20970000 12.408900 12.989700 253.421207 +84 42500 0.8921100529 1502.056832 35000.000000 39232.827705 -3.32875000 -3.20401000 12.435100 13.023300 252.325154 +85 43000 0.8935809404 1499.584357 34500.000000 38608.701732 -3.33284000 -3.21776000 12.418900 12.961300 252.430022 +86 43500 0.8950588059 1497.108337 34000.000000 37986.330926 -3.34097000 -3.21351000 12.386200 12.989800 251.358824 +87 44000 0.8965291565 1494.653007 33500.000000 37366.325187 -3.33513000 -3.21415000 12.421400 12.991400 252.515594 +88 44500 0.8980040282 1492.198206 33000.000000 36748.164780 -3.33050000 -3.21243000 12.449000 13.007000 251.816733 +89 45000 0.8994809539 1489.748053 32500.000000 36131.949054 -3.33523000 -3.21388000 12.431200 13.005500 251.501055 +90 45500 0.9009919967 1487.249615 32000.000000 35516.408710 -3.33032000 -3.20855000 12.457000 13.046600 246.366193 +91 46000 0.9024847407 1484.789647 31500.000000 34903.637234 -3.33044000 -3.20724000 12.465600 13.054900 249.100061 +92 46500 0.9039720565 1482.346706 31000.000000 34293.095432 -3.33009000 -3.20686000 12.470800 13.058100 249.921905 +93 47000 0.9054794106 1479.879039 30500.000000 33683.813949 -3.32871000 -3.20776000 12.481200 13.065400 246.903743 +94 47500 0.9069654475 1477.454300 30000.000000 33077.335067 -3.32898000 -3.20745000 12.486700 13.065400 250.124418 +95 48000 0.9084512075 1475.037942 29500.000000 32472.850226 -3.33540000 -3.20742000 12.461900 13.071200 250.164114 +96 48500 0.9099576071 1472.596074 29000.000000 31869.616532 -3.33028000 -3.20482000 12.495600 13.101200 247.035692 +97 49000 0.9114668928 1470.157622 28500.000000 31268.277791 -3.33141000 -3.20772000 12.493500 13.091700 246.606719 +98 49500 0.9129551844 1467.760984 28000.000000 30669.632507 -3.33711000 -3.21048000 12.469100 13.073000 249.788423 +99 50000 0.9144729284 1465.324952 27500.000000 30071.967301 -3.33233000 -3.20972000 12.494300 13.090600 245.340518 +100 50500 0.9159864242 1462.903777 27000.000000 29476.419396 -3.33541000 -3.20860000 12.488100 13.103100 245.975593 +101 51000 0.9174806654 1460.521241 26500.000000 28883.442452 -3.33261000 -3.21016000 12.511100 13.097400 248.887590 +102 51500 0.9189793616 1458.139384 26000.000000 28292.256698 -3.33167000 -3.20923000 12.521100 13.109100 248.203432 +103 52000 0.9204740087 1455.771686 25500.000000 27703.117913 -3.33318000 -3.21306000 12.516200 13.091500 248.824355 +104 52500 0.9219874915 1453.381974 25000.000000 27115.335328 -3.33254000 -3.20876000 12.521700 13.122000 245.961779 +105 53000 0.9235010005 1451.000052 24500.000000 26529.478568 -3.33074000 -3.21022000 12.535400 13.119900 245.960182 +106 53500 0.9250224476 1448.613494 24000.000000 25945.316314 -3.32898000 -3.20593000 12.553500 13.153400 244.771188 +107 54000 0.9265525071 1446.221331 23500.000000 25362.836773 -3.32733000 -3.20844000 12.563700 13.146600 243.494283 +108 54500 0.9280515412 1443.885324 23000.000000 24783.106303 -3.33644000 -3.21765000 12.527600 13.098200 248.175759 +109 55000 0.9295447408 1441.565899 22500.000000 24205.397558 -3.33416000 -3.21988000 12.546400 13.093200 249.075362 +110 55500 0.9310516514 1439.232719 22000.000000 23629.193898 -3.33038000 -3.21306000 12.570000 13.136500 246.959396 +111 56000 0.9325804507 1436.873354 21500.000000 23054.311276 -3.33385000 -3.21674000 12.554700 13.128400 243.657648 +112 56500 0.9340910819 1434.549613 21000.000000 22481.747666 -3.33538000 -3.21054000 12.556400 13.160700 246.399877 +113 57000 0.9355901509 1432.251076 20500.000000 21911.303769 -3.34325000 -3.22032000 12.520600 13.111100 248.178749 +114 57500 0.9371227742 1429.908692 20000.000000 21341.920772 -3.32952000 -3.21539000 12.592700 13.153200 243.074663 +115 58000 0.9386601459 1427.566735 19500.000000 20774.292044 -3.33427000 -3.20947000 12.574000 13.188800 242.373624 +116 58500 0.9401862736 1425.249483 19000.000000 20208.761321 -3.33349000 -3.21777000 12.581500 13.147400 244.053907 +117 59000 0.9417268866 1422.917853 18500.000000 19644.761410 -3.33264000 -3.20790000 12.594000 13.209800 241.889564 +118 59500 0.9432619110 1420.602257 18000.000000 19082.716890 -3.33031000 -3.21091000 12.611300 13.198600 242.722426 +119 60000 0.9448047844 1418.282403 17500.000000 18522.344815 -3.33618000 -3.21316000 12.588900 13.197100 241.554284 +120 60500 0.9463333410 1415.991535 17000.000000 17964.071710 -3.34432000 -3.21045000 12.551500 13.207200 243.697172 +121 61000 0.9478618631 1413.708107 16500.000000 17407.599823 -3.33655000 -3.21850000 12.594900 13.173100 243.700558 +122 61500 0.9494029035 1411.413421 16000.000000 16852.697566 -3.33751000 -3.21082000 12.593300 13.218900 241.819533 +123 62000 0.9509569285 1409.106932 15500.000000 16299.371229 -3.34032000 -3.21013000 12.586000 13.234300 239.898650 +124 62500 0.9525124277 1406.805792 15000.000000 15747.826027 -3.33684000 -3.20569000 12.609100 13.262800 239.683506 +125 63000 0.9540665710 1404.514151 14500.000000 15198.100887 -3.33279000 -3.21765000 12.632400 13.205800 239.883371 +126 63500 0.9556231936 1402.226326 14000.000000 14650.125796 -3.34107000 -3.21224000 12.598300 13.240900 239.517972 +127 64000 0.9571718501 1399.957594 13500.000000 14104.050384 -3.33405000 -3.21024000 12.639100 13.253500 240.697573 +128 64500 0.9587518901 1397.650439 13000.000000 13559.295303 -3.33170000 -3.19838000 12.652800 13.327800 236.112260 +129 65000 0.9603236324 1395.362933 12500.000000 13016.445267 -3.32341000 -3.21220000 12.700100 13.260200 237.312085 +130 65500 0.9618898911 1393.090844 12000.000000 12475.440392 -3.33595000 -3.21391000 12.640700 13.253200 238.110033 +131 66000 0.9634367889 1390.854092 11500.000000 11936.434370 -3.33154000 -3.20652000 12.669800 13.289500 240.979923 +132 66500 0.9649991713 1388.602229 11000.000000 11398.973520 -3.33428000 -3.21755000 12.661200 13.245600 238.672439 +133 67000 0.9665753944 1386.337794 10500.000000 10863.094654 -3.33739000 -3.21430000 12.647000 13.268700 236.648908 +134 67500 0.9681226974 1384.122078 10000.000000 10329.269241 -3.33168000 -3.21472000 12.685300 13.265200 240.930709 +135 68000 0.9697021607 1381.867603 9500.000000 9796.822555 -3.33583000 -3.21238000 12.668200 13.293000 236.169761 +136 68500 0.9712832178 1379.618195 9000.000000 9266.092356 -3.33657000 -3.21358000 12.665300 13.288400 235.942309 +137 69000 0.9728544247 1377.390045 8500.000000 8737.175660 -3.33269000 -3.21310000 12.691900 13.294000 237.380770 +138 69500 0.9744318756 1375.160269 8000.000000 8209.912053 -3.34049000 -3.21437000 12.661600 13.299100 236.464528 +139 70000 0.9760486810 1372.882343 7500.000000 7684.042964 -3.34173000 -3.19932000 12.655300 13.393100 230.850115 +140 70500 0.9776212277 1370.674001 7000.000000 7160.237320 -3.33710000 -3.21529000 12.687500 13.301300 237.199829 +141 71000 0.9791829609 1368.487865 6500.000000 6638.187407 -3.34813000 -3.21003000 12.633600 13.324700 238.801954 +142 71500 0.9807668822 1366.277781 6000.000000 6117.661708 -3.33337000 -3.21275000 12.712600 13.324800 235.520707 +143 72000 0.9823587926 1364.063731 5500.000000 5598.769046 -3.34568000 -3.20861000 12.657400 13.356600 234.362871 +144 72500 0.9839605936 1361.843156 5000.000000 5081.504313 -3.33343000 -3.20837000 12.723300 13.365200 232.940899 +145 73000 0.9855421085 1359.657785 4500.000000 4566.014949 -3.33479000 -3.21594000 12.722000 13.324300 235.884592 +146 73500 0.9871398339 1357.457124 4000.000000 4052.110818 -3.33533000 -3.21417000 12.722600 13.342900 233.521040 +147 74000 0.9887692835 1355.220093 3500.000000 3539.753973 -3.34119000 -3.19887000 12.696100 13.439200 229.030926 +148 74500 0.9903962118 1352.993867 3000.000000 3029.090746 -3.33666000 -3.19903000 12.725700 13.443200 229.385906 +149 75000 0.9920161673 1350.784437 2500.000000 2520.120218 -3.33333000 -3.20264000 12.747500 13.425900 230.363970 +150 75500 0.9936047672 1348.624769 2000.000000 2012.872790 -3.33681000 -3.21020000 12.735800 13.380300 234.877039 +151 76000 0.9952069472 1346.453623 1500.000000 1507.224205 -3.33509000 -3.21415000 12.750400 13.371300 232.893650 +152 76500 0.9967933733 1344.310703 1000.000000 1003.216942 -3.33770000 -3.21550000 12.739900 13.361100 235.198723 +153 77000 0.9983917101 1342.158580 500.000000 500.805440 -3.34046000 -3.21673000 12.728900 13.362600 233.448241 +154 77500 1.0000093127 1339.987521 0.000000 0.000000 -3.33231000 -3.20988000 12.775500 13.410100 230.671386 diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.forward_1.dat b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.forward_1.dat new file mode 100644 index 00000000..16cb619a --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.forward_1.dat @@ -0,0 +1,157 @@ +# dynamic Clausius-Clapeyron forward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 500 0.9983922604 1342.157840 500.000000 500.805164 -3.33478000 -3.21387000 12.763200 13.386100 232.272857 +1 1000 0.9967826397 1344.325178 1000.000000 1003.227745 -3.33848000 -3.21395000 12.739500 13.381800 231.815400 +2 1500 0.9951526406 1346.527101 1500.000000 1507.306456 -3.33496000 -3.20990000 12.751300 13.404500 228.928568 +3 2000 0.9935741178 1348.666371 2000.000000 2012.934882 -3.33399000 -3.21790000 12.754700 13.341900 236.349079 +4 2500 0.9919778214 1350.836653 2500.000000 2520.217636 -3.33544000 -3.20946000 12.743700 13.388100 233.742156 +5 3000 0.9903727500 1353.025919 3000.000000 3029.162505 -3.33560000 -3.20817000 12.735700 13.391100 232.473471 +6 3500 0.9887660444 1355.224532 3500.000000 3539.765569 -3.34658000 -3.20411000 12.674000 13.407500 232.238580 +7 4000 0.9871862038 1357.393362 4000.000000 4051.920483 -3.32671000 -3.20886000 12.769300 13.365900 236.139873 +8 4500 0.9855856730 1359.597686 4500.000000 4565.813123 -3.34091000 -3.21850000 12.691900 13.319700 233.131506 +9 5000 0.9839999386 1361.788703 5000.000000 5081.301130 -3.33307000 -3.21369000 12.728800 13.335400 235.271301 +10 5500 0.9823969418 1364.010761 5500.000000 5598.551630 -3.33438000 -3.20990000 12.715100 13.354500 232.781456 +11 6000 0.9808085864 1366.219687 6000.000000 6117.401584 -3.33708000 -3.21271000 12.701600 13.334600 234.885794 +12 6500 0.9791837827 1368.486717 6500.000000 6638.181836 -3.33259000 -3.20350000 12.718800 13.390900 229.723051 +13 7000 0.9776042828 1370.697759 7000.000000 7160.361429 -3.33179000 -3.21184000 12.716600 13.323700 236.163281 +14 7500 0.9760340952 1372.902859 7500.000000 7684.157794 -3.33420000 -3.21491000 12.705100 13.305300 237.537135 +15 8000 0.9744422255 1375.145663 8000.000000 8209.824852 -3.33269000 -3.21328000 12.701100 13.310200 234.381525 +16 8500 0.9728501516 1377.396095 8500.000000 8737.214036 -3.34563000 -3.20779000 12.634600 13.337800 234.349883 +17 9000 0.9712796338 1379.623286 9000.000000 9266.126548 -3.33263000 -3.20953000 12.695600 13.315100 237.476828 +18 9500 0.9697016865 1381.868278 9500.000000 9796.827347 -3.33629000 -3.21551000 12.671100 13.281800 236.393694 +19 10000 0.9681395735 1384.097951 10000.000000 10329.089187 -3.32763000 -3.21076000 12.705800 13.290800 238.715181 +20 10500 0.9665723695 1386.342133 10500.000000 10863.128650 -3.33255000 -3.21598000 12.680800 13.266200 237.966496 +21 11000 0.9649735471 1388.639102 11000.000000 11399.276211 -3.33645000 -3.21063000 12.654400 13.299000 233.418453 +22 11500 0.9634074709 1390.896418 11500.000000 11936.797615 -3.33068000 -3.20747000 12.679000 13.297300 238.120000 +23 12000 0.9618612994 1393.132254 12000.000000 12475.811230 -3.33322000 -3.21569000 12.662600 13.244900 241.076448 +24 12500 0.9603040887 1395.391330 12500.000000 13016.710172 -3.33835000 -3.21516000 12.631500 13.246200 239.434687 +25 13000 0.9587537260 1397.647763 13000.000000 13559.269338 -3.33827000 -3.21518000 12.625900 13.237400 240.448856 +26 13500 0.9571929526 1399.926730 13500.000000 14103.739442 -3.33211000 -3.21394000 12.650600 13.241600 238.911763 +27 14000 0.9556401240 1402.201484 14000.000000 14649.866250 -3.34448000 -3.21632000 12.583400 13.221100 240.080358 +28 14500 0.9540775822 1404.497941 14500.000000 15197.925484 -3.33568000 -3.21313000 12.623500 13.237100 238.654974 +29 15000 0.9525164681 1406.799824 15000.000000 15747.759228 -3.33146000 -3.20440000 12.642700 13.278300 238.862101 +30 15500 0.9509648781 1409.095153 15500.000000 16299.234973 -3.32889000 -3.21702000 12.644500 13.200700 240.258483 +31 16000 0.9494154253 1411.394806 16000.000000 16852.475295 -3.33405000 -3.21407000 12.616100 13.211800 240.575003 +32 16500 0.9478609667 1413.709444 16500.000000 17407.616285 -3.33132000 -3.20741000 12.623400 13.240600 239.839438 +33 17000 0.9463179392 1416.014581 17000.000000 17964.364085 -3.33294000 -3.21962000 12.610900 13.171200 241.523012 +34 17500 0.9447761918 1418.325326 17500.000000 18522.905374 -3.33767000 -3.21371000 12.583700 13.196100 241.714317 +35 18000 0.9432531711 1420.615420 18000.000000 19082.893703 -3.33362000 -3.21750000 12.598800 13.165500 244.523694 +36 18500 0.9417170973 1422.932645 18500.000000 19644.965621 -3.33494000 -3.20910000 12.587300 13.206700 242.563713 +37 19000 0.9401912876 1425.241882 19000.000000 20208.653548 -3.34001000 -3.21091000 12.554900 13.186100 244.099877 +38 19500 0.9386346621 1427.605493 19500.000000 20774.856062 -3.33346000 -3.20453000 12.580900 13.224000 239.553082 +39 20000 0.9370920685 1429.955546 20000.000000 21342.620083 -3.33135000 -3.21553000 12.590000 13.162500 241.594332 +40 20500 0.9355659405 1432.288139 20500.000000 21911.870787 -3.34195000 -3.21165000 12.534000 13.171200 244.039501 +41 21000 0.9340439221 1434.622043 21000.000000 22482.882767 -3.33082000 -3.21448000 12.580900 13.148300 244.658624 +42 21500 0.9325366924 1436.940778 21500.000000 23055.393074 -3.33822000 -3.21403000 12.542100 13.141900 246.904066 +43 22000 0.9310211428 1439.279881 22000.000000 23629.968203 -3.33410000 -3.21784000 12.554200 13.118800 245.639765 +44 22500 0.9295076264 1441.623460 22500.000000 24206.364060 -3.33608000 -3.21321000 12.540400 13.136300 245.946348 +45 23000 0.9279958692 1443.971945 23000.000000 24784.593083 -3.33402000 -3.21014000 12.543900 13.144000 246.212927 +46 23500 0.9264766393 1446.339760 23500.000000 25364.913700 -3.33677000 -3.21087000 12.524500 13.137400 245.087395 +47 24000 0.9249376336 1448.746328 24000.000000 25947.695421 -3.33595000 -3.21110000 12.528400 13.144100 242.165172 +48 24500 0.9234330290 1451.106857 24500.000000 26531.431335 -3.33797000 -3.21375000 12.507300 13.106200 247.285748 +49 25000 0.9219450344 1453.448904 25000.000000 27116.584034 -3.33942000 -3.21719000 12.495300 13.078100 249.844120 +50 25500 0.9204423385 1455.821776 25500.000000 27704.071112 -3.32317000 -3.21848000 12.568600 13.072700 247.586396 +51 26000 0.9189303893 1458.217092 26000.000000 28293.764472 -3.33559000 -3.20993000 12.503300 13.112100 246.186701 +52 26500 0.9174495637 1460.570753 26500.000000 28884.421606 -3.33788000 -3.21725000 12.487600 13.060000 250.948242 +53 27000 0.9159621445 1462.942555 27000.000000 29477.200737 -3.33844000 -3.21696000 12.478800 13.057800 249.928266 +54 27500 0.9144434200 1465.372237 27500.000000 30072.937701 -3.33274000 -3.20125000 12.503400 13.143300 245.194828 +55 28000 0.9129511787 1467.767424 28000.000000 30669.767072 -3.33065000 -3.20584000 12.504700 13.101500 249.175024 +56 28500 0.9114460113 1470.191304 28500.000000 31268.994154 -3.33250000 -3.21521000 12.492100 13.057800 247.219479 +57 29000 0.9099585827 1472.594495 29000.000000 31869.582364 -3.33335000 -3.21271000 12.482600 13.057600 249.910189 +58 29500 0.9084920911 1474.971563 29500.000000 32471.388896 -3.33582000 -3.21599000 12.469500 13.032600 253.168642 +59 30000 0.9069771274 1477.435273 30000.000000 33076.909103 -3.33532000 -3.21197000 12.459400 13.058200 245.781293 +60 30500 0.9054853724 1479.869295 30500.000000 33683.592171 -3.33347000 -3.21341000 12.466400 13.040300 249.247941 +61 31000 0.9039923551 1482.313421 31000.000000 34292.325400 -3.33551000 -3.21459000 12.451000 13.029500 249.059548 +62 31500 0.9025052513 1484.755904 31500.000000 34902.844005 -3.33234000 -3.21117000 12.460700 13.038100 249.956954 +63 32000 0.9010097600 1487.220294 32000.000000 35515.708508 -3.33094000 -3.20565000 12.462000 13.062400 248.688730 +64 32500 0.8994997654 1489.716898 32500.000000 36131.193414 -3.33611000 -3.21006000 12.430900 13.040800 246.530399 +65 33000 0.8980174196 1492.175954 33000.000000 36747.616785 -3.33005000 -3.20567000 12.457500 13.048300 250.670812 +66 33500 0.8965582619 1494.604486 33500.000000 37365.112144 -3.32635000 -3.21289000 12.470800 13.001300 254.263693 +67 34000 0.8950554758 1497.113907 34000.000000 37986.472255 -3.33033000 -3.20353000 12.441100 13.051700 247.615970 +68 34500 0.8935679110 1499.606223 34500.000000 38609.264698 -3.32827000 -3.20869000 12.444500 13.014500 249.882790 +69 35000 0.8920985059 1502.076274 35000.000000 39233.335521 -3.32861000 -3.21369000 12.439500 12.980600 252.652426 +70 35500 0.8906196642 1504.570417 35500.000000 39859.887925 -3.33501000 -3.21521000 12.402600 12.970300 251.210206 +71 36000 0.8891497579 1507.057712 36000.000000 40488.117645 -3.33689000 -3.20995000 12.387800 12.985700 252.574040 +72 36500 0.8876897759 1509.536368 36500.000000 41117.968226 -3.33732000 -3.21065000 12.383300 12.975900 254.108051 +73 37000 0.8862408446 1512.004336 37000.000000 41749.373464 -3.33327000 -3.21664000 12.397100 12.938600 255.838188 +74 37500 0.8847904781 1514.482844 37500.000000 42382.915422 -3.33429000 -3.20777000 12.384100 12.972100 255.614063 +75 38000 0.8833182308 1517.007069 38000.000000 43019.603437 -3.34091000 -3.20989000 12.346500 12.964600 252.233613 +76 38500 0.8818628435 1519.510670 38500.000000 43657.582675 -3.32986000 -3.21126000 12.394800 12.947900 254.822186 +77 39000 0.8804045622 1522.027551 39000.000000 44297.816794 -3.33900000 -3.20420000 12.344000 12.973900 254.376008 +78 39500 0.8789475538 1524.550577 39500.000000 44940.110285 -3.33714000 -3.20717000 12.348800 12.955600 254.572217 +79 40000 0.8775199242 1527.030855 40000.000000 45583.010592 -3.32770000 -3.20898000 12.389700 12.932800 259.200816 +80 40500 0.8760598258 1529.575904 40500.000000 46229.719488 -3.33485000 -3.20601000 12.351500 12.954300 254.108537 +81 41000 0.8746129075 1532.106362 41000.000000 46877.881229 -3.32872000 -3.20522000 12.367600 12.940200 256.141876 +82 41500 0.8731665681 1534.644189 41500.000000 47528.159595 -3.32771000 -3.20470000 12.372200 12.942300 256.233846 +83 42000 0.8716869676 1537.249093 42000.000000 48182.434248 -3.33090000 -3.21152000 12.347400 12.913400 251.174256 +84 42500 0.8702348326 1539.814255 42500.000000 48837.392402 -3.33180000 -3.20797000 12.338800 12.915000 255.324368 +85 43000 0.8688141906 1542.332083 43000.000000 49492.745936 -3.32886000 -3.20424000 12.346400 12.913700 260.280657 +86 43500 0.8674184230 1544.813857 43500.000000 50148.808056 -3.32639000 -3.21444000 12.356500 12.857200 264.348180 +87 44000 0.8659850090 1547.370897 44000.000000 50809.193626 -3.32986000 -3.21077000 12.332800 12.879800 258.266286 +88 44500 0.8645669684 1549.908855 44500.000000 51470.853764 -3.32955000 -3.21236000 12.327500 12.860000 260.703329 +89 45000 0.8631437835 1552.464405 45000.000000 52134.998667 -3.32602000 -3.21035000 12.335900 12.863400 259.883797 +90 45500 0.8616970279 1555.070932 45500.000000 52802.781638 -3.32603000 -3.21026000 12.327100 12.863800 256.199184 +91 46000 0.8602900640 1557.614177 46000.000000 53470.337421 -3.32989000 -3.21038000 12.308500 12.847300 262.476158 +92 46500 0.8588557206 1560.215491 46500.000000 54141.806227 -3.32802000 -3.20409000 12.308900 12.878500 258.129905 +93 47000 0.8574114614 1562.843582 47000.000000 54816.155504 -3.32692000 -3.20477000 12.308700 12.874000 256.593683 +94 47500 0.8559919878 1565.435213 47500.000000 55491.173606 -3.32769000 -3.20510000 12.298400 12.856000 260.457135 +95 48000 0.8545744835 1568.031840 48000.000000 56168.304724 -3.33203000 -3.20971000 12.268600 12.824200 260.772770 +96 48500 0.8531627953 1570.626389 48500.000000 56847.298392 -3.32442000 -3.20615000 12.300300 12.835300 261.698916 +97 49000 0.8517389282 1573.252033 49000.000000 57529.365371 -3.32749000 -3.21650000 12.281300 12.787700 259.772651 +98 49500 0.8503456684 1575.829748 49500.000000 58211.621273 -3.33180000 -3.21322000 12.255800 12.785200 264.670318 +99 50000 0.8489550442 1578.411023 50000.000000 58895.933703 -3.31792000 -3.21166000 12.313900 12.787400 265.105666 +100 50500 0.8475544839 1581.019304 50500.000000 59583.190174 -3.32974000 -3.20340000 12.255000 12.822000 263.491119 +101 51000 0.8461299873 1583.681018 51000.000000 60274.426817 -3.32621000 -3.19794000 12.264600 12.850100 259.698814 +102 51500 0.8447208852 1586.322800 51500.000000 60966.883738 -3.32877000 -3.19870000 12.246300 12.833600 262.114876 +103 52000 0.8433247582 1588.948963 52000.000000 61660.706027 -3.32977000 -3.20057000 12.238700 12.816700 264.194128 +104 52500 0.8419091684 1591.620629 52500.000000 62358.270902 -3.33024000 -3.20458000 12.229200 12.799200 261.099481 +105 53000 0.8405137684 1594.262998 53000.000000 63056.670802 -3.32313000 -3.20339000 12.251400 12.786800 264.305182 +106 53500 0.8391352195 1596.882086 53500.000000 63756.113148 -3.32984000 -3.21047000 12.216000 12.743300 267.053047 +107 54000 0.8377440305 1599.533928 54000.000000 64458.829947 -3.32889000 -3.20715000 12.215500 12.758200 264.993399 +108 54500 0.8363520614 1602.196087 54500.000000 65163.945321 -3.32243000 -3.20096000 12.240300 12.782100 264.865760 +109 55000 0.8349401220 1604.905507 55000.000000 65872.987239 -3.32544000 -3.19835000 12.216000 12.791000 261.697399 +110 55500 0.8335331361 1607.614553 55500.000000 66584.035594 -3.32559000 -3.19823000 12.211000 12.785200 262.470922 +111 56000 0.8321451253 1610.296040 56000.000000 67295.953912 -3.32540000 -3.20509000 12.204600 12.739700 265.490865 +112 56500 0.8307582030 1612.984374 56500.000000 68010.162040 -3.33205000 -3.20152000 12.170500 12.750600 265.668970 +113 57000 0.8293859309 1615.653160 57000.000000 68725.544861 -3.32907000 -3.19842000 12.175800 12.750300 268.053071 +114 57500 0.8279908077 1618.375455 57500.000000 69445.215415 -3.32731000 -3.20050000 12.177900 12.744800 264.364284 +115 58000 0.8266001273 1621.098226 58000.000000 70166.938142 -3.32207000 -3.20235000 12.197100 12.730600 265.068253 +116 58500 0.8252390841 1623.771857 58500.000000 70888.547484 -3.32196000 -3.20321000 12.191400 12.709300 269.894091 +117 59000 0.8238430691 1626.523364 59000.000000 71615.580946 -3.31740000 -3.20006000 12.202300 12.727200 264.235265 +118 59500 0.8224860830 1629.206898 59500.000000 72341.649582 -3.32675000 -3.20730000 12.160000 12.679400 270.558664 +119 60000 0.8211213578 1631.914683 60000.000000 73070.806686 -3.31824000 -3.20539000 12.188400 12.681900 269.282432 +120 60500 0.8197963641 1634.552260 60500.000000 73798.814739 -3.32006000 -3.21247000 12.177100 12.633900 276.008006 +121 61000 0.8184245429 1637.292053 61000.000000 74533.444199 -3.32608000 -3.20799000 12.136600 12.655700 268.139374 +122 61500 0.8170591653 1640.028112 61500.000000 75269.946913 -3.32514000 -3.20183000 12.137900 12.677400 269.182487 +123 62000 0.8156897711 1642.781419 62000.000000 76009.289558 -3.32875000 -3.20685000 12.112900 12.647800 268.529011 +124 62500 0.8143276936 1645.529202 62500.000000 76750.429206 -3.32400000 -3.20227000 12.131800 12.663100 269.721507 +125 63000 0.8129477287 1648.322460 63000.000000 77495.757449 -3.32202000 -3.19834000 12.129200 12.676100 266.833134 +126 63500 0.8115653639 1651.130099 63500.000000 78243.851723 -3.31938000 -3.19675000 12.134200 12.677400 266.449417 +127 64000 0.8102003801 1653.911838 64000.000000 78992.804219 -3.32258000 -3.19864000 12.111300 12.653400 269.236255 +128 64500 0.8088357561 1656.702229 64500.000000 79744.249083 -3.31863000 -3.19157000 12.126200 12.681800 269.297076 +129 65000 0.8074872626 1659.468901 65000.000000 80496.625782 -3.32295000 -3.20328000 12.104400 12.621500 271.940256 +130 65500 0.8061491964 1662.223328 65500.000000 81250.468636 -3.32677000 -3.20787000 12.076900 12.586700 273.682347 +131 66000 0.8048006921 1665.008508 66000.000000 82007.881761 -3.32092000 -3.20581000 12.097300 12.594700 271.945107 +132 66500 0.8034441192 1667.819787 66500.000000 82768.668547 -3.32561000 -3.19821000 12.071600 12.625400 270.620188 +133 67000 0.8021162014 1670.580893 67000.000000 83529.044649 -3.31876000 -3.20250000 12.096000 12.590700 275.383720 +134 67500 0.8007687176 1673.392043 67500.000000 84294.002147 -3.31184000 -3.20058000 12.117700 12.598100 272.117903 +135 68000 0.7994003199 1676.256522 68000.000000 85063.763808 -3.32039000 -3.19831000 12.072000 12.607300 268.729126 +136 68500 0.7980599703 1679.071812 68500.000000 85833.148574 -3.32022000 -3.19498000 12.069800 12.607700 273.283766 +137 69000 0.7967383133 1681.857114 69000.000000 86603.090180 -3.31192000 -3.20335000 12.096700 12.556500 276.427049 +138 69500 0.7953816300 1684.725859 69500.000000 87379.438223 -3.31468000 -3.20054000 12.071600 12.567800 270.627232 +139 70000 0.7940522321 1687.546418 70000.000000 88155.409897 -3.32177000 -3.19855000 12.041100 12.566000 275.108559 +140 70500 0.7927147300 1690.393718 70500.000000 88934.893385 -3.31868000 -3.19427000 12.049500 12.582700 273.763014 +141 71000 0.7914100140 1693.180496 71000.000000 89713.294929 -3.31337000 -3.20052000 12.064300 12.536100 279.314609 +142 71500 0.7900889153 1696.011644 71500.000000 90496.143676 -3.31502000 -3.19953000 12.053000 12.541900 276.514688 +143 72000 0.7887661637 1698.855835 72000.000000 91281.806081 -3.31886000 -3.20191000 12.027100 12.522800 276.233834 +144 72500 0.7874668461 1701.658942 72500.000000 92067.368118 -3.31510000 -3.20291000 12.038900 12.506000 280.243081 +145 73000 0.7861590330 1704.489733 73000.000000 92856.530215 -3.31801000 -3.20495000 12.019500 12.493300 278.778824 +146 73500 0.7848307970 1707.374386 73500.000000 93650.759228 -3.31815000 -3.19595000 12.008000 12.528100 275.331666 +147 74000 0.7835265213 1710.216519 74000.000000 94444.792853 -3.30713000 -3.19027000 12.054300 12.542700 279.375537 +148 74500 0.7821992786 1713.118430 74500.000000 95244.270915 -3.31967000 -3.19190000 11.989800 12.533200 275.503418 +149 75000 0.7808775863 1716.018008 75000.000000 96045.784025 -3.32248000 -3.20010000 11.969200 12.487500 276.422801 +150 75500 0.7795740213 1718.887448 75500.000000 96847.762923 -3.31903000 -3.19502000 11.983600 12.501600 279.486600 +151 76000 0.7782630404 1721.782907 76000.000000 97653.358902 -3.31879000 -3.20298000 11.969600 12.456100 278.228080 +152 76500 0.7769499245 1724.692876 76500.000000 98461.944056 -3.31687000 -3.19823000 11.975600 12.474800 277.867105 +153 77000 0.7756436625 1727.597433 77000.000000 99272.389782 -3.32013000 -3.19726000 11.952600 12.466900 279.024287 +154 77500 0.7743205884 1730.549362 77500.000000 100087.742939 -3.31066000 -3.18954000 11.989200 12.502700 276.212206 diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml new file mode 100644 index 00000000..06f9462a --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml @@ -0,0 +1,118 @@ +calculations: +- alchemy_coupling: false + berendsen: + barostat_damping: 100.0 + thermostat_damping: 100.0 + composition_scaling: + output_chemical_composition: {} + restrictions: [] + dcci: + hysteresis_tolerance: 5.0 + integrator: euler + n_block_steps: 500 + n_check_blocks: 0 + stop_at_target_pressure: true + element: + - Cu + equilibration_control: null + execution_mode: executable + file_format: lammps-data + fix_potential_path: true + folder_prefix: null + inputfile: input.yaml + kernel: 0 + lammps_executable: null + lattice: /private/tmp/claude-501/-Users-smenon-Documents-Projects-projects-calphy-stable-calphy/b601b9bf-90db-47a1-aacf-55cdd80197ea/scratchpad/validation/dcci_conv/dcci-fcc-solid-1340-0.0.data + lattice_constant: 3.615 + mass: + - 63.546 + materials_project: + conventional: true + target_natoms: 1500 + md: + barostat_damping: 0.1 + cmdargs: '' + init_commands: [] + n_cycles: 100 + n_every_steps: 10 + n_repeat_steps: 10 + n_small_steps: 10000 + seed: 2049361027 + thermostat_damping: 0.1 + timestep: 0.001 + melting_cycle: true + melting_temperature: + attempts: 5 + guess: null + step: 200 + mode: dcci + monte_carlo: + allow_all_swaps: true + forward_swap_types: [] + n_steps: 1 + n_swaps: 0 + reverse_swap_types: [] + use_custom_lammps: false + mpi_executable: null + n_elements: 1 + n_equilibration_steps: 10000 + n_iterations: 1 + n_print_steps: 0 + n_print_steps_equilibration: 0 + n_switching_steps: 100000 + nose_hoover: + barostat_damping: 0.1 + thermostat_damping: 0.1 + npt: true + pair_coeff: + - '* * /Users/smenon/Documents/Projects/projects-calphy-stable/calphy/tests/Cu01.eam.alloy + Cu' + pair_mode: null + pair_style: + - eam/alloy + phase_name: '' + phase_transition_detection: + mode: none + onset_fraction: 0.85 + prescan_steps: 20000 + potential_file: null + pressure: + - 0.0 + - 100000.0 + pressure_coupling: null + quantum_thermal_bath: + barostat_damping: 0.1 + f_max: 200.0 + n_f: 100 + thermostat_damping: 0.1 + queue: + commands: [] + cores: 4 + jobname: calphy + memory: 3GB + options: {} + queuename: '' + scheduler: local + walltime: '23:59:00' + reference_composition: 0.0 + reference_phase: solid + repeat: + - 5 + - 5 + - 5 + script_mode: false + spring_constants: null + temperature: 1340.0 + temperature_high: 0.0 + tolerance: + dissipation: 0.001 + lattice_constant: 0.0002 + liquid_fraction: 1.0 + pressure: 10.0 + solid_fraction: 0.0 + spring_constant: 0.1 + uhlenbeck_ford_model: + p: 50.0 + sigma: 1.5 + single_p: null + single_sigma: null diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/coexistence_line.dat b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/coexistence_line.dat new file mode 100644 index 00000000..54b29c0a --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/coexistence_line.dat @@ -0,0 +1,32 @@ +# dynamic Clausius-Clapeyron coexistence line +# pressure[bar] temperature[K] error[K] T_forward[K] T_backward[K] +0.000000000000000000e+00 1.341217376500000000e+03 1.217376500000000306e+00 1.340000000000000000e+03 1.342434753000000001e+03 +1.574642767900000035e+04 1.407983669083667792e+03 1.302796083667885796e+00 1.406680873000000020e+03 1.409286465167335791e+03 +3.309359899900000164e+04 1.479487451224566485e+03 1.306696224566394449e+00 1.478180755000000090e+03 1.480794147449132879e+03 +5.213682671700000355e+04 1.554369132311963540e+03 1.850292311963585234e+00 1.552518839999999955e+03 1.556219424623927125e+03 +7.306490938899999310e+04 1.633896165067466882e+03 2.113189067466919369e+00 1.631782975999999962e+03 1.636009354134933801e+03 +9.609118537000000651e+04 1.718602597857017372e+03 1.773418857017304617e+00 1.716829179000000067e+03 1.720376016714034677e+03 +1.211787443789999961e+05 1.806663358264574072e+03 2.446497264573849861e+00 1.804216861000000108e+03 1.809109855529147808e+03 +1.487125583979999938e+05 1.900744592525499684e+03 2.889085525499581308e+00 1.897855506999999989e+03 1.903633678050999151e+03 +1.788605498810000136e+05 2.000302048343540719e+03 3.025908343540777423e+00 1.997276139999999941e+03 2.003327956687081496e+03 +2.117560125169999956e+05 2.104921035074243264e+03 3.046540074243466734e+00 2.101874495000000024e+03 2.107967575148486958e+03 +2.476194272789999959e+05 2.214865074935210032e+03 2.798190935209959207e+00 2.212066883999999845e+03 2.217663265870419764e+03 +2.864456314899999998e+05 2.328964601100758046e+03 2.678866100757886670e+00 2.326285734999999931e+03 2.331643467201515705e+03 +3.284199822290000156e+05 2.447056516710286360e+03 2.152204710286241607e+00 2.444904312000000118e+03 2.449208721420572601e+03 +3.737292301979999756e+05 2.570417650165438317e+03 2.227042165438206212e+00 2.568190607999999884e+03 2.572644692330876296e+03 +4.225106715940000140e+05 2.698006422148345791e+03 1.985946148345647089e+00 2.696020476000000144e+03 2.699992368296691438e+03 +4.746511783159999759e+05 2.828723968315865932e+03 1.912506315865812212e+00 2.826811462000000120e+03 2.830636474631731744e+03 +5.309384277940000175e+05 2.964612679545072751e+03 2.064575450726806594e-01 2.964406222000000071e+03 2.964819137090145432e+03 +5.902413705070000142e+05 3.102297847862366780e+03 6.373128623667980719e-01 3.101660534999999982e+03 3.102935160724733578e+03 +6.531698842360000126e+05 3.242119530561491956e+03 4.615865614916856430e-01 3.241657944000000043e+03 3.242581117122983414e+03 +7.196078626269999659e+05 3.383936393064989716e+03 5.169690649895528622e-01 3.383419424000000163e+03 3.384453362129979269e+03 +7.892036686960000079e+05 3.526079161181211020e+03 9.694411812110956816e-01 3.525109719999999925e+03 3.527048602362422116e+03 +8.626761336219999939e+05 3.670257331369233270e+03 4.604453692331844650e-01 3.669796886000000086e+03 3.670717776738466455e+03 +9.410696392040000064e+05 3.820799868526333285e+03 5.132114736666153476e-01 3.821313079999999900e+03 3.820286657052666669e+03 +1.021731614875999978e+06 3.966329413368098358e+03 2.135409631901438843e+00 3.968464822999999797e+03 3.964194003736196919e+03 +1.106473468819000060e+06 4.116145047442473697e+03 2.395086557526155957e+00 4.118540133999999853e+03 4.113749960884947541e+03 +1.193968546282999916e+06 4.264146970246318233e+03 2.300634753682516020e+00 4.266447605000000294e+03 4.261846335492635262e+03 +1.285754494973999914e+06 4.415650500527564873e+03 2.070071472435756732e+00 4.417720572000000175e+03 4.413580429055128661e+03 +1.380116036093000090e+06 4.564576610347607129e+03 1.733237652393199824e+00 4.566309847999999874e+03 4.562843372695213475e+03 +1.478739166847999906e+06 4.716568730486731511e+03 1.313373513269198156e+00 4.717882104000000254e+03 4.715255356973461858e+03 +1.580250711376999971e+06 4.867898742999999740e+03 0.000000000000000000e+00 4.867898742999999740e+03 4.867898742999999740e+03 diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.backward_1.dat b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.backward_1.dat new file mode 100644 index 00000000..c91cfbaa --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.backward_1.dat @@ -0,0 +1,31 @@ +# dynamic Clausius-Clapeyron backward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 1000 0.2843251728 4712.913693 420000.000000 1477181.903655 -1.96808000 -1.77592000 8.264620 8.450420 659.427453 +1 2000 0.2938723638 4559.802707 405000.000000 1378149.325733 -2.10352000 -1.91772000 8.408080 8.597550 646.517920 +2 3000 0.3038517688 4410.045086 390000.000000 1283520.584876 -2.19993000 -2.03609000 8.535190 8.709830 631.642546 +3 4000 0.3147108154 4257.877183 375000.000000 1191570.107052 -2.29772000 -2.12940000 8.657080 8.852310 603.821139 +4 5000 0.3260538574 4109.750489 360000.000000 1104112.071665 -2.38606000 -2.22980000 8.797250 8.986570 590.194012 +5 6000 0.3383300294 3960.629809 345000.000000 1019714.391185 -2.48131000 -2.32063000 8.919350 9.130040 565.548679 +6 7000 0.3508329223 3819.481910 330000.000000 940618.679314 -2.56318000 -2.41872000 9.067750 9.260670 560.278476 +7 8000 0.3649734010 3671.500433 315000.000000 863076.594410 -2.64367000 -2.49082000 9.202350 9.433210 523.355657 +8 9000 0.3797442227 3528.690945 300000.000000 790005.435449 -2.72140000 -2.57989000 9.349380 9.572640 511.435522 +9 10000 0.3958274621 3385.313371 285000.000000 720010.679587 -2.78870000 -2.64082000 9.507890 9.761930 487.733226 +10 11000 0.4131559611 3243.327281 270000.000000 653506.243261 -2.85314000 -2.71177000 9.668750 9.930410 467.989888 +11 12000 0.4317080326 3103.949658 255000.000000 590676.987084 -2.91618000 -2.77666000 9.827530 10.104000 450.420544 +12 13000 0.4519200477 2965.126258 240000.000000 531067.389513 -2.97532000 -2.83767000 9.985130 10.282300 428.936854 +13 14000 0.4729283027 2833.410461 225000.000000 475759.219162 -3.02946000 -2.90098000 10.156800 10.445100 419.698533 +14 15000 0.4957935295 2702.737975 210000.000000 423563.414023 -3.07971000 -2.94242000 10.314100 10.649400 398.990524 +15 16000 0.5202736556 2575.567657 195000.000000 374802.756021 -3.11579000 -2.98901000 10.508600 10.840100 383.064177 +16 17000 0.5465372151 2451.800102 180000.000000 329346.282412 -3.15738000 -3.02880000 10.677600 11.038300 366.898108 +17 18000 0.5739564984 2334.671711 165000.000000 287478.233049 -3.18426000 -3.06967000 10.878900 11.214500 357.223713 +18 19000 0.6034479465 2220.572640 150000.000000 248571.564222 -3.21610000 -3.09826000 11.045100 11.416300 340.602231 +19 20000 0.6348192087 2110.837198 135000.000000 212658.971468 -3.24642000 -3.12633000 11.204900 11.607300 326.934944 +20 21000 0.6680388879 2005.871251 120000.000000 179630.261321 -3.26402000 -3.14382000 11.398300 11.824800 314.355209 +21 22000 0.7031320586 1905.758646 105000.000000 149331.834212 -3.28330000 -3.16106000 11.569500 12.027700 302.349866 +22 23000 0.7400723958 1810.633673 90000.000000 121609.724279 -3.29734000 -3.17698000 11.747000 12.221900 291.153692 +23 24000 0.7784856572 1721.290543 75000.000000 96340.888628 -3.30843000 -3.18764000 11.921700 12.417300 282.619847 +24 25000 0.8186310196 1636.879092 60000.000000 73293.093665 -3.32156000 -3.19642000 12.070300 12.606900 272.804823 +25 26000 0.8607471331 1556.787062 45000.000000 52280.162513 -3.32398000 -3.21421000 12.252400 12.746200 262.103319 +26 27000 0.9047575042 1481.059835 30000.000000 33158.056009 -3.33124000 -3.21258000 12.392900 12.950700 252.277356 +27 28000 0.9507480763 1409.416473 15000.000000 15777.050065 -3.33186000 -3.20182000 12.558200 13.197000 242.368994 +28 29000 0.9981863157 1342.434753 0.000000 0.000000 -3.33932000 -3.20865000 12.671500 13.333600 235.377163 diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.forward_1.dat b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.forward_1.dat new file mode 100644 index 00000000..76ceb01e --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.forward_1.dat @@ -0,0 +1,31 @@ +# dynamic Clausius-Clapeyron forward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 1000 0.9525970147 1406.680873 15000.000000 15746.427679 -3.33985000 -3.21880000 12.667700 13.280600 241.743110 +1 2000 0.9065197170 1478.180755 30000.000000 33093.598999 -3.33839000 -3.21148000 12.523700 13.148300 242.451433 +2 3000 0.8631135194 1552.518840 45000.000000 52136.826717 -3.32890000 -3.21301000 12.407100 12.944400 255.820171 +3 4000 0.8211876330 1631.782976 60000.000000 73064.909389 -3.32830000 -3.21236000 12.229400 12.748600 263.826319 +4 5000 0.7805086357 1716.829179 75000.000000 96091.185370 -3.32185000 -3.19895000 12.070900 12.604900 270.572944 +5 6000 0.7427045103 1804.216861 90000.000000 121178.744379 -3.30725000 -3.19598000 11.930400 12.379700 286.651874 +6 7000 0.7060600741 1897.855507 105000.000000 148712.558398 -3.29527000 -3.17519000 11.761100 12.231100 293.860508 +7 8000 0.6709137374 1997.276140 120000.000000 178860.549881 -3.28658000 -3.16599000 11.560600 12.013300 302.992510 +8 9000 0.6375261717 2101.874495 135000.000000 211756.012517 -3.26785000 -3.14116000 11.390200 11.842000 314.192392 +9 10000 0.6057683020 2212.066884 150000.000000 247619.427279 -3.24347000 -3.12325000 11.223300 11.631100 325.168819 +10 11000 0.5760255415 2326.285735 165000.000000 286445.631490 -3.21885000 -3.10018000 11.039800 11.416800 339.542799 +11 12000 0.5480787094 2444.904312 180000.000000 328419.982229 -3.18849000 -3.06340000 10.866800 11.240200 353.494089 +12 13000 0.5217681258 2568.190608 195000.000000 373729.230198 -3.15749000 -3.03220000 10.677300 11.029400 367.158288 +13 14000 0.4970288661 2696.020476 210000.000000 422510.671594 -3.12041000 -2.98720000 10.497600 10.849600 381.250928 +14 15000 0.4740323216 2826.811462 225000.000000 474651.178316 -3.07433000 -2.94389000 10.334200 10.654600 398.225093 +15 16000 0.4520298163 2964.406222 240000.000000 530938.427794 -3.02922000 -2.88710000 10.154300 10.488300 408.821406 +16 17000 0.4320266466 3101.660535 255000.000000 590241.370507 -2.97614000 -2.83358000 9.986810 10.291400 431.500811 +17 18000 0.4133687215 3241.657944 270000.000000 653169.884236 -2.92011000 -2.77954000 9.819260 10.099400 449.088120 +18 19000 0.3960490356 3383.419424 285000.000000 719607.862627 -2.85580000 -2.71585000 9.663180 9.922080 468.221532 +19 20000 0.3801300119 3525.109720 300000.000000 789203.668696 -2.78461000 -2.64899000 9.515270 9.745870 490.684363 +20 21000 0.3651428244 3669.796886 315000.000000 862676.133622 -2.71919000 -2.57317000 9.352370 9.586120 507.448628 +21 22000 0.3506648034 3821.313080 330000.000000 941069.639204 -2.64754000 -2.48329000 9.196860 9.450860 517.191147 +22 23000 0.3376620582 3968.464823 345000.000000 1021731.614876 -2.56315000 -2.40661000 9.051450 9.268860 547.514204 +23 24000 0.3253580046 4118.540134 360000.000000 1106473.468819 -2.48182000 -2.31773000 8.913340 9.128990 564.338280 +24 25000 0.3140786256 4266.447605 375000.000000 1193968.546283 -2.39225000 -2.23168000 8.778790 8.972240 591.038397 +25 26000 0.3033238472 4417.720572 390000.000000 1285754.494974 -2.29909000 -2.12926000 8.651160 8.846250 606.477921 +26 27000 0.2934535861 4566.309848 405000.000000 1380116.036093 -2.19195000 -2.03456000 8.535930 8.701860 634.541711 +27 28000 0.2840257494 4717.882104 420000.000000 1478739.166848 -2.10102000 -1.92255000 8.406500 8.586220 650.399490 +28 29000 0.2752727759 4867.898743 435000.000000 1580250.711377 -1.99308000 -1.81668000 8.291730 8.456650 676.230854 diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml new file mode 100644 index 00000000..95d1a6d8 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml @@ -0,0 +1,118 @@ +calculations: +- alchemy_coupling: false + berendsen: + barostat_damping: 100.0 + thermostat_damping: 100.0 + composition_scaling: + output_chemical_composition: {} + restrictions: [] + dcci: + hysteresis_tolerance: 5.0 + integrator: euler + n_block_steps: 1000 + n_check_blocks: 0 + stop_at_target_pressure: true + element: + - Cu + equilibration_control: null + execution_mode: executable + file_format: lammps-data + fix_potential_path: true + folder_prefix: null + inputfile: input.yaml + kernel: 0 + lammps_executable: null + lattice: /private/tmp/claude-501/-Users-smenon-Documents-Projects-projects-calphy-stable-calphy/b601b9bf-90db-47a1-aacf-55cdd80197ea/scratchpad/validation/dcci_high/dcci-fcc-solid-1340-0.0.data + lattice_constant: 3.615 + mass: + - 63.546 + materials_project: + conventional: true + target_natoms: 1500 + md: + barostat_damping: 0.1 + cmdargs: '' + init_commands: [] + n_cycles: 100 + n_every_steps: 10 + n_repeat_steps: 10 + n_small_steps: 10000 + seed: 36717953 + thermostat_damping: 0.1 + timestep: 0.001 + melting_cycle: true + melting_temperature: + attempts: 5 + guess: null + step: 200 + mode: dcci + monte_carlo: + allow_all_swaps: true + forward_swap_types: [] + n_steps: 1 + n_swaps: 0 + reverse_swap_types: [] + use_custom_lammps: false + mpi_executable: null + n_elements: 1 + n_equilibration_steps: 10000 + n_iterations: 1 + n_print_steps: 0 + n_print_steps_equilibration: 0 + n_switching_steps: 100000 + nose_hoover: + barostat_damping: 0.1 + thermostat_damping: 0.1 + npt: true + pair_coeff: + - '* * /Users/smenon/Documents/Projects/projects-calphy-stable/calphy/tests/Cu01.eam.alloy + Cu' + pair_mode: null + pair_style: + - eam/alloy + phase_name: '' + phase_transition_detection: + mode: none + onset_fraction: 0.85 + prescan_steps: 20000 + potential_file: null + pressure: + - 0.0 + - 1500000.0 + pressure_coupling: null + quantum_thermal_bath: + barostat_damping: 0.1 + f_max: 200.0 + n_f: 100 + thermostat_damping: 0.1 + queue: + commands: [] + cores: 4 + jobname: calphy + memory: 3GB + options: {} + queuename: '' + scheduler: local + walltime: '23:59:00' + reference_composition: 0.0 + reference_phase: solid + repeat: + - 5 + - 5 + - 5 + script_mode: false + spring_constants: null + temperature: 1340.0 + temperature_high: 0.0 + tolerance: + dissipation: 0.001 + lattice_constant: 0.0002 + liquid_fraction: 1.0 + pressure: 10.0 + solid_fraction: 0.0 + spring_constant: 0.1 + uhlenbeck_ford_model: + p: 50.0 + sigma: 1.5 + single_p: null + single_sigma: null diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/report.yaml b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/report.yaml new file mode 100644 index 00000000..daf2ae51 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/report.yaml @@ -0,0 +1,20 @@ +average: + vol_atom_liquid: 13.408466735619454 + vol_atom_solid: 12.759740873592614 +input: + element: Cu + lattice: fcc + n_block_steps: 1000 + n_iterations: 1 + pressure: 0.0 + pressure_stop: 1500000.0 + temperature: 1340.0 +results: + coexistence_line: coexistence_line.dat + error_at_pressure_reached: 0.0 + hysteresis: 2.4347530000000006 + hysteresis_high: false + n_blocks_used: 29 + pressure_reached: 1580250.711377 + temperature_at_pressure_reached: 4867.898743 + unit: K, bar diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0/coexistence_line.dat b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/coexistence_line.dat new file mode 100644 index 00000000..e2414fe3 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/coexistence_line.dat @@ -0,0 +1,56 @@ +# dynamic Clausius-Clapeyron coexistence line +# pressure[bar] temperature[K] error[K] T_forward[K] T_backward[K] +0.000000000000000000e+00 1.340104077500000130e+03 1.040775000000166983e-01 1.340000000000000000e+03 1.340208155000000033e+03 +8.355712350000000015e+02 1.343713887308695575e+03 1.153413086955197286e-01 1.343598545999999942e+03 1.343829228617390982e+03 +1.675659585000000106e+03 1.347321929684968609e+03 9.162368496868111833e-02 1.347230305999999928e+03 1.347413553369937290e+03 +2.520276542000000063e+03 1.350925407128272127e+03 5.718012827230722905e-02 1.350868226999999933e+03 1.350982587256544548e+03 +3.369245621000000028e+03 1.354533882292447288e+03 9.714229244718808332e-02 1.354436740000000100e+03 1.354631024584894476e+03 +4.223042540000000372e+03 1.358205330365929512e+03 7.484936592948088219e-02 1.358130480999999918e+03 1.358280179731858880e+03 +5.081292994000000363e+03 1.361876145525081711e+03 8.962352508160620346e-02 1.361786522000000105e+03 1.361965769050163317e+03 +5.944245904999999766e+03 1.365567738511279003e+03 8.953651127899320272e-02 1.365478202000000010e+03 1.365657275022557997e+03 +6.812113325999999688e+03 1.369289942117935880e+03 5.516311793610384484e-02 1.369234778999999889e+03 1.369345105235872097e+03 +7.684376260000000002e+03 1.372966578597259286e+03 2.468659725911948044e-02 1.372941892000000053e+03 1.372991265194518292e+03 +8.561375846999999339e+03 1.376695404476502063e+03 2.616847650199360942e-02 1.376669235999999955e+03 1.376721572953003943e+03 +9.443116344000000026e+03 1.380431328149485580e+03 1.941214948556080344e-02 1.380411916000000019e+03 1.380450740298971141e+03 +1.032951951600000029e+04 1.384154867608689301e+03 7.473913105968676973e-04 1.384155614999999898e+03 1.384154120217378704e+03 +1.122079850500000066e+04 1.387906517453044216e+03 1.994354695591482596e-02 1.387926461000000018e+03 1.387886573906088188e+03 +1.211636789099999987e+04 1.391683226086293871e+03 3.182808629401279177e-02 1.391651397999999972e+03 1.391715054172587998e+03 +1.301678964099999939e+04 1.395441050236550609e+03 4.120023655059412704e-02 1.395399850000000015e+03 1.395482250473101203e+03 +1.392220370899999944e+04 1.399194358012615339e+03 1.288501261535657250e-02 1.399181473000000096e+03 1.399207243025230810e+03 +1.483187979400000040e+04 1.402961938922624086e+03 4.060292262397524610e-02 1.402921336000000110e+03 1.403002541845248061e+03 +1.574726454100000046e+04 1.406797300890635142e+03 4.166889063503731450e-02 1.406755632000000105e+03 1.406838969781270180e+03 +1.666729585999999836e+04 1.410623874266904750e+03 4.430926690463365958e-02 1.410579565000000002e+03 1.410668183533809270e+03 +1.759244315300000017e+04 1.414460120076113299e+03 2.769107611334220564e-02 1.414432428999999956e+03 1.414487811152226641e+03 +1.852177054100000169e+04 1.418277368441557428e+03 3.893844155720671552e-02 1.418238430000000108e+03 1.418316306883114521e+03 +1.945765265300000101e+04 1.422154515095488023e+03 2.300590451204698184e-02 1.422177521000000070e+03 1.422131509190975976e+03 +2.039746180599999934e+04 1.426034481474532186e+03 1.415252546792089561e-02 1.426048633999999993e+03 1.426020328949064151e+03 +2.134297618900000089e+04 1.429964635309772575e+03 1.476969022746743576e-02 1.429979405000000042e+03 1.429949865619545108e+03 +2.229305571399999826e+04 1.433875048945771596e+03 1.429505422845522844e-02 1.433889343999999937e+03 1.433860753891543027e+03 +2.324729668500000116e+04 1.437773390235498255e+03 1.750323549822496716e-02 1.437755887000000030e+03 1.437790893470996480e+03 +2.420632452499999999e+04 1.441668338396611034e+03 4.723339661097725184e-02 1.441621104999999943e+03 1.441715571793221898e+03 +2.517036025199999858e+04 1.445573589404126551e+03 7.575740412653431122e-02 1.445497832000000017e+03 1.445649346808253085e+03 +2.614026155999999901e+04 1.449505333654460401e+03 7.289965446034329943e-02 1.449432434000000057e+03 1.449578233308920744e+03 +2.711565768200000093e+04 1.453499545319495155e+03 1.002933194951083351e-01 1.453399251999999933e+03 1.453599838638990150e+03 +2.809685420599999998e+04 1.457484106103245040e+03 7.308810324502701405e-02 1.457411018000000013e+03 1.457557194206490067e+03 +2.908265674199999921e+04 1.461454468956565051e+03 5.096795656493213755e-02 1.461403501000000006e+03 1.461505436913129870e+03 +3.007383955599999899e+04 1.465441682355333342e+03 2.550035533352001949e-02 1.465416181999999935e+03 1.465467182710666975e+03 +3.106972731500000009e+04 1.469458226195813040e+03 4.288719581325040053e-02 1.469415338999999904e+03 1.469501113391626404e+03 +3.207115072100000179e+04 1.473519288605219344e+03 7.899260521935502766e-02 1.473440295999999989e+03 1.473598281210438699e+03 +3.307878502399999707e+04 1.477574342578347114e+03 5.527857834692895267e-02 1.477519064000000071e+03 1.477629621156693929e+03 +3.409052086899999995e+04 1.481612972527339934e+03 5.736252734016034083e-02 1.481555609999999888e+03 1.481670335054680208e+03 +3.510781274500000291e+04 1.485683469872982187e+03 6.865687298238754011e-02 1.485614812999999913e+03 1.485752126745964688e+03 +3.613030900899999688e+04 1.489736677451374817e+03 5.624445137493694347e-02 1.489680432999999994e+03 1.489792921902749868e+03 +3.715807044899999892e+04 1.493804410401425230e+03 4.997840142516452033e-02 1.493754431999999952e+03 1.493854388802850281e+03 +3.819081758299999638e+04 1.497912222803247460e+03 8.698680324766883132e-02 1.497825235999999904e+03 1.497999209606495242e+03 +3.922893736799999897e+04 1.502035405995456131e+03 1.275179954561735940e-01 1.501907887999999957e+03 1.502162923990912304e+03 +4.027371091999999771e+04 1.506117978655892784e+03 6.850965589285351598e-02 1.506049469000000045e+03 1.506186488311785752e+03 +4.132364330799999880e+04 1.510280606927930648e+03 8.927892793053615605e-02 1.510191328000000112e+03 1.510369885855861185e+03 +4.237797805199999857e+04 1.514416934387463243e+03 1.105183874632302832e-01 1.514306415999999899e+03 1.514527452774926360e+03 +4.344034690399999818e+04 1.518619642098943814e+03 9.621109894374058058e-02 1.518523431000000073e+03 1.518715853197887554e+03 +4.450959590100000059e+04 1.522847298398835619e+03 5.091139883552386891e-02 1.522796387000000095e+03 1.522898209797671143e+03 +4.558339854400000331e+04 1.527081312861148717e+03 3.746186114881311369e-02 1.527043850999999904e+03 1.527118774722297530e+03 +4.666110933800000203e+04 1.531270533641495376e+03 2.433364149533190357e-02 1.531246200000000044e+03 1.531294867282990708e+03 +4.774353312800000276e+04 1.535466257866018395e+03 3.423286601832842280e-02 1.535432025000000067e+03 1.535500490732036724e+03 +4.883041742700000032e+04 1.539663646105948374e+03 6.930810594838021643e-02 1.539594338000000107e+03 1.539732954211896867e+03 +4.992686155000000144e+04 1.543923408428574930e+03 3.122842857499108504e-02 1.543892180000000053e+03 1.543954636857150035e+03 +5.102876747299999988e+04 1.548193549000000075e+03 0.000000000000000000e+00 1.548193549000000075e+03 1.548193549000000075e+03 diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0/dcci.backward_1.dat b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/dcci.backward_1.dat new file mode 100644 index 00000000..260b2e02 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/dcci.backward_1.dat @@ -0,0 +1,55 @@ +# dynamic Clausius-Clapeyron backward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 500 0.8678961541 1543.963519 43333.333333 49929.168517 -3.33072000 -3.20666000 12.328600 12.894200 259.639705 +1 1000 0.8702697421 1539.752487 42500.000000 48835.433365 -3.33243000 -3.21548000 12.329300 12.863000 259.731213 +2 1500 0.8726742828 1535.509899 41666.666667 47745.954574 -3.32764000 -3.21146000 12.359000 12.896100 256.792427 +3 2000 0.8750726769 1531.301383 40833.333333 46662.790885 -3.33178000 -3.21283000 12.348200 12.896700 257.375655 +4 2500 0.8774636808 1527.128734 40000.000000 45585.932360 -3.33007000 -3.22437000 12.370600 12.856500 258.077059 +5 3000 0.8798936310 1522.911353 39166.666667 44512.956209 -3.33590000 -3.20989000 12.351000 12.939700 254.413372 +6 3500 0.8823101536 1518.740314 38333.333333 43446.551282 -3.33538000 -3.20839000 12.365800 12.955800 255.671270 +7 4000 0.8847484020 1514.554869 37500.000000 42384.931031 -3.33177000 -3.20909000 12.387600 12.962700 253.643586 +8 4500 0.8871870555 1510.391739 36666.666667 41329.127200 -3.32952000 -3.21424000 12.407000 12.947500 253.608800 +9 5000 0.8896547804 1506.202214 35833.333333 40277.795525 -3.32747000 -3.20615000 12.427400 13.003000 250.939901 +10 5500 0.8920293246 1502.192768 35000.000000 39236.378262 -3.33840000 -3.21946000 12.386900 12.929900 259.753735 +11 6000 0.8945146634 1498.019043 34166.666667 38195.759181 -3.32906000 -3.21289000 12.438200 12.993300 249.312977 +12 6500 0.8970019002 1493.865286 33333.333333 37160.828004 -3.33252000 -3.21280000 12.433200 13.005700 249.155859 +13 7000 0.8994466649 1489.804846 32500.000000 36133.326485 -3.33327000 -3.21347000 12.437600 13.000700 253.057806 +14 7500 0.9018913742 1485.766511 31666.666667 35111.397639 -3.33178000 -3.21736000 12.454600 12.992400 253.057468 +15 8000 0.9043776259 1481.681945 30833.333333 34093.427843 -3.33608000 -3.21489000 12.441800 13.021100 249.218897 +16 8500 0.9068511605 1477.640497 30000.000000 33081.503675 -3.33314000 -3.21671000 12.468100 13.021800 250.388720 +17 9000 0.9093292061 1473.613726 29166.666667 32074.925638 -3.33287000 -3.21852000 12.474900 13.019700 249.971465 +18 9500 0.9118691104 1469.509148 28333.333333 31071.710851 -3.33135000 -3.21272000 12.489000 13.068300 244.406731 +19 10000 0.9143813308 1465.471740 27500.000000 30074.979742 -3.33603000 -3.21160000 12.479600 13.080600 246.878145 +20 10500 0.9168572842 1461.514265 26666.666667 29084.860998 -3.33256000 -3.21700000 12.506100 13.056200 250.194710 +21 11000 0.9193386558 1457.569517 25833.333333 28099.909833 -3.33437000 -3.22032000 12.508000 13.052100 249.686682 +22 11500 0.9218387033 1453.616555 25000.000000 27119.711844 -3.33870000 -3.20942000 12.493100 13.114500 247.963805 +23 12000 0.9243994887 1449.589724 24166.666667 26143.098261 -3.33279000 -3.20290000 12.533200 13.172700 242.519791 +24 12500 0.9269116749 1445.660936 23333.333333 25173.200387 -3.33631000 -3.21134000 12.522700 13.126300 246.876039 +25 13000 0.9294437458 1441.722542 22500.000000 24208.027760 -3.33105000 -3.21156000 12.558400 13.140100 245.065649 +26 13500 0.9319836970 1437.793391 21666.666667 23247.903087 -3.32516000 -3.20901000 12.593000 13.160200 244.358887 +27 14000 0.9345411148 1433.858798 20833.333333 22292.580822 -3.33846000 -3.21448000 12.535800 13.145400 242.799259 +28 14500 0.9370970577 1429.947932 20000.000000 21342.506451 -3.33492000 -3.21736000 12.561700 13.139400 242.932662 +29 15000 0.9396792275 1426.018540 19166.666667 20397.031356 -3.33713000 -3.21315000 12.558600 13.174100 240.613672 +30 15500 0.9422494285 1422.128748 18333.333333 19456.985356 -3.33841000 -3.19995000 12.564300 13.248500 241.672082 +31 16000 0.9447792497 1418.320735 17500.000000 18522.845422 -3.33320000 -3.21163000 12.595300 13.186600 245.314607 +32 16500 0.9473373680 1414.490809 16666.666667 17593.169265 -3.32995000 -3.21188000 12.626000 13.206700 242.737216 +33 17000 0.9499013743 1410.672767 15833.333333 16668.397121 -3.33604000 -3.21603000 12.599700 13.191300 242.211006 +34 17500 0.9524871870 1406.843072 15000.000000 15748.243340 -3.33674000 -3.21036000 12.605900 13.234200 240.266159 +35 18000 0.9550919414 1403.006289 14166.666667 14832.777927 -3.33259000 -3.21282000 12.637000 13.236800 238.600770 +36 18500 0.9576843980 1399.208343 13333.333333 13922.471078 -3.33386000 -3.20975000 12.638700 13.257300 239.686152 +37 19000 0.9602392189 1395.485597 12500.000000 13017.589527 -3.32982000 -3.21003000 12.667400 13.255800 243.073461 +38 19500 0.9628390719 1391.717515 11666.666667 12116.943535 -3.34419000 -3.21011000 12.602300 13.272500 239.014875 +39 20000 0.9654977606 1387.885146 10833.333333 11220.464485 -3.32768000 -3.20271000 12.690900 13.329700 233.916767 +40 20500 0.9681003198 1384.154072 10000.000000 10329.508002 -3.33511000 -3.21386000 12.665500 13.272200 238.801018 +41 21000 0.9706966271 1380.451897 9166.666667 9443.389840 -3.33387000 -3.21351000 12.678100 13.278900 239.351978 +42 21500 0.9733257921 1376.722995 8333.333333 8561.710170 -3.33427000 -3.21215000 12.685600 13.302900 236.441533 +43 22000 0.9759704083 1372.992448 7500.000000 7684.659223 -3.33520000 -3.20927000 12.689700 13.330000 235.098594 +44 22500 0.9785682680 1369.347488 6666.666667 6812.674072 -3.33522000 -3.21313000 12.698000 13.307800 239.236553 +45 23000 0.9812100666 1365.660673 5833.333333 5945.040243 -3.33593000 -3.20833000 12.699800 13.347900 235.329714 +46 23500 0.9838699020 1361.968688 5000.000000 5081.972718 -3.33854000 -3.21028000 12.696100 13.352000 233.766510 +47 24000 0.9865402082 1358.282196 4166.666667 4223.514290 -3.32763000 -3.21006000 12.758400 13.362000 232.865170 +48 24500 0.9891977214 1354.633124 3333.333333 3369.734140 -3.34482000 -3.21361000 12.678100 13.348500 233.974025 +49 25000 0.9918699995 1350.983496 2500.000000 2520.491598 -3.33070000 -3.21201000 12.755800 13.365600 232.691781 +50 25500 0.9944972157 1347.414531 1666.666667 1675.888721 -3.33336000 -3.22283000 12.756100 13.314400 236.658058 +51 26000 0.9971500469 1343.829852 833.333333 835.715082 -3.33530000 -3.21474000 12.752000 13.366900 234.376522 +52 26500 0.9998446846 1340.208155 0.000000 0.000000 -3.32999000 -3.20744000 12.785700 13.420600 230.748108 diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0/dcci.forward_1.dat b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/dcci.forward_1.dat new file mode 100644 index 00000000..204dc4b1 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/dcci.forward_1.dat @@ -0,0 +1,55 @@ +# dynamic Clausius-Clapeyron forward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 500 0.9973217105 1343.598546 833.333333 835.571235 -3.34079000 -3.21153000 12.733400 13.399000 232.507854 +1 1000 0.9946332070 1347.230306 1666.666667 1675.659585 -3.32867000 -3.21621000 12.784000 13.365300 231.317714 +2 1500 0.9919546360 1350.868227 2500.000000 2520.276542 -3.33850000 -3.21638000 12.728100 13.357000 232.168430 +3 2000 0.9893411487 1354.436740 3333.333333 3369.245621 -3.33783000 -3.22457000 12.722200 13.291300 237.897245 +4 2500 0.9866504130 1358.130481 4166.666667 4223.042540 -3.33731000 -3.21638000 12.718100 13.343700 231.155292 +5 3000 0.9840015142 1361.786522 5000.000000 5081.292994 -3.33609000 -3.21810000 12.716400 13.317300 234.742940 +6 3500 0.9813411872 1365.478202 5833.333333 5944.245905 -3.33310000 -3.20154000 12.723500 13.396400 233.756782 +7 4000 0.9786488197 1369.234779 6666.666667 6812.113326 -3.33024000 -3.20324000 12.726100 13.383500 231.029158 +8 4500 0.9760063467 1372.941892 7500.000000 7684.376260 -3.33401000 -3.21406000 12.700500 13.309900 235.287902 +9 5000 0.9733638006 1376.669236 8333.333333 8561.375847 -3.33627000 -3.20288000 12.685500 13.363200 235.287316 +10 5500 0.9707247410 1380.411916 9166.666667 9443.116344 -3.32693000 -3.20377000 12.723300 13.348200 235.589656 +11 6000 0.9680992407 1384.155615 10000.000000 10329.519516 -3.33799000 -3.20415000 12.658800 13.334400 236.769906 +12 6500 0.9654690197 1387.926461 10833.333333 11220.798505 -3.33200000 -3.21248000 12.680500 13.284900 236.360448 +13 7000 0.9628848160 1391.651398 11666.666667 12116.367891 -3.33611000 -3.21736000 12.648400 13.238400 240.419174 +14 7500 0.9602982260 1395.399850 12500.000000 13016.789641 -3.34224000 -3.22183000 12.612500 13.211300 240.211274 +15 8000 0.9577027899 1399.181473 13333.333333 13922.203709 -3.33740000 -3.22221000 12.627100 13.201900 239.425072 +16 8500 0.9551497763 1402.921336 14166.666667 14831.879794 -3.33241000 -3.22099000 12.644900 13.191800 243.231893 +17 9000 0.9525463906 1406.755632 15000.000000 15747.264541 -3.33368000 -3.21105000 12.629300 13.243100 238.741506 +18 9500 0.9499641374 1410.579565 15833.333333 16667.295860 -3.34119000 -3.20674000 12.586600 13.254100 240.594984 +19 10000 0.9473764685 1414.432429 16666.666667 17592.443153 -3.33764000 -3.21724000 12.591400 13.190400 240.119295 +20 10500 0.9448340784 1418.238430 17500.000000 18521.770541 -3.33020000 -3.20606000 12.624800 13.231600 244.168083 +21 11000 0.9422171143 1422.177521 18333.333333 19457.652653 -3.33033000 -3.20456000 12.614000 13.246800 237.596511 +22 11500 0.9396593973 1426.048634 19166.666667 20397.461806 -3.33619000 -3.21680000 12.576400 13.163500 242.767085 +23 12000 0.9370764332 1429.979405 20000.000000 21342.976189 -3.33155000 -3.21230000 12.586200 13.178400 240.544165 +24 12500 0.9345212070 1433.889344 20833.333333 22293.055714 -3.33197000 -3.20481000 12.577100 13.201800 242.986796 +25 13000 0.9320080077 1437.755887 21666.666667 23247.296685 -3.33813000 -3.20725000 12.542400 13.174800 246.788462 +26 13500 0.9295091445 1441.621105 22500.000000 24206.324525 -3.33561000 -3.21499000 12.546200 13.125700 248.115033 +27 14000 0.9270162643 1445.497832 23333.333333 25170.360252 -3.33245000 -3.22070000 12.552500 13.088100 248.671188 +28 14500 0.9244998032 1449.432434 24166.666667 26140.261560 -3.33769000 -3.21626000 12.516800 13.104300 246.507758 +29 15000 0.9219765308 1453.399252 25000.000000 27115.657682 -3.34016000 -3.21846000 12.494900 13.085300 245.889026 +30 15500 0.9194386370 1457.411018 25833.333333 28096.854206 -3.33664000 -3.21435000 12.503000 13.099700 244.580758 +31 16000 0.9169267754 1461.403501 26666.666667 29082.656742 -3.33900000 -3.21478000 12.484600 13.084500 246.910751 +32 16500 0.9144159976 1465.416182 27500.000000 30073.839556 -3.33408000 -3.21049000 12.496800 13.093400 247.011790 +33 17000 0.9119273255 1469.415339 28333.333333 31069.727315 -3.33543000 -3.21162000 12.482500 13.074900 249.021016 +34 17500 0.9094362382 1473.440296 29166.666667 32071.150721 -3.33237000 -3.21319000 12.490500 13.061300 248.803302 +35 18000 0.9069256921 1477.519064 30000.000000 33078.785024 -3.33201000 -3.20383000 12.482000 13.100700 247.045507 +36 18500 0.9044547442 1481.555610 30833.333333 34090.520869 -3.33936000 -3.20580000 12.437500 13.072000 250.638406 +37 19000 0.9019834672 1485.614813 31666.666667 35107.812745 -3.33085000 -3.21223000 12.467200 13.030800 250.613149 +38 19500 0.8995217836 1489.680433 32500.000000 36130.309009 -3.33404000 -3.21369000 12.444200 13.013800 251.496312 +39 20000 0.8970684680 1493.754432 33333.333333 37158.070449 -3.33064000 -3.21236000 12.451700 13.009600 252.271554 +40 20500 0.8946304067 1497.825236 34166.666667 38190.817583 -3.32738000 -3.21188000 12.459700 13.001100 253.693454 +41 21000 0.8921985235 1501.907888 35000.000000 39228.937368 -3.33139000 -3.21380000 12.429400 12.979200 254.274455 +42 21500 0.8897450102 1506.049469 35833.333333 40273.710920 -3.32421000 -3.21514000 12.450500 12.965000 252.266510 +43 22000 0.8873047905 1510.191328 36666.666667 41323.643308 -3.32317000 -3.21406000 12.447400 12.959300 253.490741 +44 22500 0.8848935632 1514.306416 37500.000000 42377.978052 -3.33105000 -3.21681000 12.400400 12.930000 256.207554 +45 23000 0.8824361697 1518.523431 38333.333333 43440.346904 -3.33292000 -3.20982000 12.382500 12.964100 251.929707 +46 23500 0.8799600597 1522.796387 39166.666667 44509.595901 -3.32978000 -3.20217000 12.388400 12.995900 250.238070 +47 24000 0.8775124558 1527.043851 40000.000000 45583.398544 -3.33070000 -3.19967000 12.375300 12.991900 252.806179 +48 24500 0.8751042123 1531.246200 40833.333333 46661.109338 -3.32425000 -3.21043000 12.394800 12.921800 256.448603 +49 25000 0.8727185429 1535.432025 41666.666667 47743.533128 -3.33018000 -3.20702000 12.362100 12.927000 258.589209 +50 25500 0.8703591376 1539.594338 42500.000000 48830.417427 -3.33324000 -3.21411000 12.337300 12.877700 261.120946 +51 26000 0.8679362569 1543.892180 43333.333333 49926.861550 -3.33150000 -3.20304000 12.332200 12.930600 255.122526 +52 26500 0.8655248569 1548.193549 44166.666667 51028.767473 -3.33046000 -3.20732000 12.327500 12.898400 256.173440 diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml new file mode 100644 index 00000000..1fac61b2 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml @@ -0,0 +1,118 @@ +calculations: +- alchemy_coupling: false + berendsen: + barostat_damping: 100.0 + thermostat_damping: 100.0 + composition_scaling: + output_chemical_composition: {} + restrictions: [] + dcci: + hysteresis_tolerance: 5.0 + integrator: euler + n_block_steps: 500 + n_check_blocks: 0 + stop_at_target_pressure: true + element: + - Cu + equilibration_control: null + execution_mode: executable + file_format: lammps-data + fix_potential_path: true + folder_prefix: null + inputfile: input.yaml + kernel: 0 + lammps_executable: null + lattice: /private/tmp/claude-501/-Users-smenon-Documents-Projects-projects-calphy-stable-calphy/b601b9bf-90db-47a1-aacf-55cdd80197ea/scratchpad/validation/dcci/dcci-fcc-solid-1340-0.0.data + lattice_constant: 3.615 + mass: + - 63.546 + materials_project: + conventional: true + target_natoms: 1500 + md: + barostat_damping: 0.1 + cmdargs: '' + init_commands: [] + n_cycles: 100 + n_every_steps: 10 + n_repeat_steps: 10 + n_small_steps: 10000 + seed: 2121331448 + thermostat_damping: 0.1 + timestep: 0.001 + melting_cycle: true + melting_temperature: + attempts: 5 + guess: null + step: 200 + mode: dcci + monte_carlo: + allow_all_swaps: true + forward_swap_types: [] + n_steps: 1 + n_swaps: 0 + reverse_swap_types: [] + use_custom_lammps: false + mpi_executable: null + n_elements: 1 + n_equilibration_steps: 10000 + n_iterations: 1 + n_print_steps: 0 + n_print_steps_equilibration: 0 + n_switching_steps: 30000 + nose_hoover: + barostat_damping: 0.1 + thermostat_damping: 0.1 + npt: true + pair_coeff: + - '* * /Users/smenon/Documents/Projects/projects-calphy-stable/calphy/tests/Cu01.eam.alloy + Cu' + pair_mode: null + pair_style: + - eam/alloy + phase_name: '' + phase_transition_detection: + mode: none + onset_fraction: 0.85 + prescan_steps: 20000 + potential_file: null + pressure: + - 0.0 + - 50000.0 + pressure_coupling: null + quantum_thermal_bath: + barostat_damping: 0.1 + f_max: 200.0 + n_f: 100 + thermostat_damping: 0.1 + queue: + commands: [] + cores: 4 + jobname: calphy + memory: 3GB + options: {} + queuename: '' + scheduler: local + walltime: '23:59:00' + reference_composition: 0.0 + reference_phase: solid + repeat: + - 5 + - 5 + - 5 + script_mode: false + spring_constants: null + temperature: 1340.0 + temperature_high: 0.0 + tolerance: + dissipation: 0.001 + lattice_constant: 0.0002 + liquid_fraction: 1.0 + pressure: 10.0 + solid_fraction: 0.0 + spring_constant: 0.1 + uhlenbeck_ford_model: + p: 50.0 + sigma: 1.5 + single_p: null + single_sigma: null diff --git a/docs/source/examples/example_13/dcci-fcc-solid-1340-0/report.yaml b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/report.yaml new file mode 100644 index 00000000..75b75d9a --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/report.yaml @@ -0,0 +1,20 @@ +average: + vol_atom_liquid: 13.404046514698337 + vol_atom_solid: 12.759807913666805 +input: + element: Cu + lattice: fcc + n_block_steps: 500 + n_iterations: 1 + pressure: 0.0 + pressure_stop: 50000.0 + temperature: 1340.0 +results: + coexistence_line: coexistence_line.dat + error_at_pressure_reached: 0.0 + hysteresis: 0.2081550000000334 + hysteresis_high: false + n_blocks_used: 53 + pressure_reached: 51028.767473 + temperature_at_pressure_reached: 1548.193549 + unit: K, bar diff --git a/docs/source/examples/example_13/input.yaml b/docs/source/examples/example_13/input.yaml new file mode 100644 index 00000000..8c9742e0 --- /dev/null +++ b/docs/source/examples/example_13/input.yaml @@ -0,0 +1,25 @@ +# Dynamic Clausius-Clapeyron integration: the melting line of Cu (Mishin Cu01) +# from a known melting point at 0 bar to 50 kbar, out and back. +# +# The starting temperature is the result of a melting_temperature calculation +# at 0 bar (example 04); see the notebook for the comparison with independent +# melting_temperature runs at the end points. +calculations: +- mode: dcci + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + temperature: 1340.0 + pressure: [0.0, 50000.0] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 30000 + n_iterations: 1 + dcci: + n_block_steps: 500 + queue: + scheduler: local + cores: 4 diff --git a/docs/source/examples/example_13/input_converged.yaml b/docs/source/examples/example_13/input_converged.yaml new file mode 100644 index 00000000..5fede24f --- /dev/null +++ b/docs/source/examples/example_13/input_converged.yaml @@ -0,0 +1,25 @@ +# Dynamic Clausius-Clapeyron integration: the melting line of Cu (Mishin Cu01) +# from a known melting point at 0 bar to 100 kbar with 200 blocks of 500 steps (the converged line of the notebook). +# +# The starting temperature is the result of a melting_temperature calculation +# at 0 bar (example 04); see the notebook for the comparison with independent +# melting_temperature runs at the end points. +calculations: +- mode: dcci + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + temperature: 1340.0 + pressure: [0.0, 100000.0] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 100000 + n_iterations: 1 + dcci: + n_block_steps: 500 + queue: + scheduler: local + cores: 4 diff --git a/docs/source/examples/example_13/input_high.yaml b/docs/source/examples/example_13/input_high.yaml new file mode 100644 index 00000000..74fa2020 --- /dev/null +++ b/docs/source/examples/example_13/input_high.yaml @@ -0,0 +1,25 @@ +# Dynamic Clausius-Clapeyron integration: the melting line of Cu (Mishin Cu01) +# from a known melting point at 0 bar to 1.5 Mbar, out and back (the second line in the notebook). +# +# The starting temperature is the result of a melting_temperature calculation +# at 0 bar (example 04); see the notebook for the comparison with independent +# melting_temperature runs at the end points. +calculations: +- mode: dcci + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + temperature: 1340.0 + pressure: [0.0, 1500000.0] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 100000 + n_iterations: 1 + dcci: + n_block_steps: 1000 + queue: + scheduler: local + cores: 4 diff --git a/docs/source/examples/example_13/melting_line.png b/docs/source/examples/example_13/melting_line.png new file mode 100644 index 00000000..a4d5809e Binary files /dev/null and b/docs/source/examples/example_13/melting_line.png differ diff --git a/docs/source/examples/example_13/melting_temperature_reference.yaml b/docs/source/examples/example_13/melting_temperature_reference.yaml new file mode 100644 index 00000000..33111069 --- /dev/null +++ b/docs/source/examples/example_13/melting_temperature_reference.yaml @@ -0,0 +1,36 @@ +# Independent melting points of Cu (Mishin Cu01, 500-atom cells) used to check +# the dynamic Clausius-Clapeyron line. Two kinds: +# method: melting_temperature -- mode melting_temperature (fe + reversible +# scaling of both phases, 10000 equilibration / 30000 switching steps, +# one iteration; the mode reports no error bar for a single iteration) +# method: fe_crossing -- direct fe of both phases at two temperatures +# bracketing the melting point (two iterations each), crossing of +# G_liquid - G_solid; error from the fe error bars. +- pressure: 0.0 + tm: 1340.6 + tm_error: 0.0 + method: melting_temperature +- pressure: 50000.0 + tm: 1564.9 + tm_error: 0.0 + method: melting_temperature +- pressure: 100000.0 + tm: 1776.3 + tm_error: 0.0 + method: melting_temperature +- pressure: 500000.0 + tm: 2912.9 + tm_error: 0.0 + method: melting_temperature +- pressure: 0.0 + tm: 1353.3 + tm_error: 1.9 + method: fe_crossing +- pressure: 50000.0 + tm: 1559.9 + tm_error: 1.6 + method: fe_crossing +- pressure: 100000.0 + tm: 1749.2 + tm_error: 3.4 + method: fe_crossing diff --git a/docs/source/examples/example_13/tm.input.0kbar.yaml b/docs/source/examples/example_13/tm.input.0kbar.yaml new file mode 100644 index 00000000..ae501a9a --- /dev/null +++ b/docs/source/examples/example_13/tm.input.0kbar.yaml @@ -0,0 +1,17 @@ +calculations: +- mode: melting_temperature + temperature: 1340.0 + pressure: 0.0 + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 30000 + n_iterations: 1 + queue: + scheduler: local + cores: 4 diff --git a/docs/source/examples/example_13/tm.input.50kbar.yaml b/docs/source/examples/example_13/tm.input.50kbar.yaml new file mode 100644 index 00000000..e552fd9e --- /dev/null +++ b/docs/source/examples/example_13/tm.input.50kbar.yaml @@ -0,0 +1,17 @@ +calculations: +- mode: melting_temperature + temperature: 1540.0 + pressure: 50000.0 + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 30000 + n_iterations: 1 + queue: + scheduler: local + cores: 4 diff --git a/docs/source/gettingstarted.md b/docs/source/gettingstarted.md index 0e90bc95..2b25adcd 100644 --- a/docs/source/gettingstarted.md +++ b/docs/source/gettingstarted.md @@ -116,7 +116,7 @@ calphy needs an `lmp` executable that includes the LAMMPS packages its methods r |---|---|---| | EAM / MEAM / most `pair_style`s | `MANYBODY` (and the relevant potential package) | your interatomic potential | | solid free energy, `ts`, `tscale` | `EXTRA-FIX` | `fix ti/spring` (Frenkel–Ladd spring) | -| liquid free energy, `melting_temperature` | `EXTRA-PAIR` | `pair_style ufm`, `pair_style hybrid/scaled` | +| liquid free energy, `melting_temperature`, `dcci` | `EXTRA-PAIR` | `pair_style ufm`, `pair_style hybrid/scaled` | | Monte-Carlo swaps (`monte_carlo.n_swaps > 0`) | `MC` | `fix atom/swap` | | `mode: fe-qtb` (quantum thermal bath) | `QTB` | `fix qtb` | diff --git a/docs/source/index.rst b/docs/source/index.rst index 15014de7..c33b2858 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -23,6 +23,9 @@ calphy can perform are: approach. - Calculation of solid-solid or solid-liquid phase transition temperatures. +- Calculation of solid-liquid coexistence lines :math:`P_{coex}(T)` over a + wide pressure range from a single known coexistence point using `dynamic + Clausius-Clapeyron integration `__. - Calculation of specific heat :math:`c_P(T)` as a function of temperature. - Calculation of :math:`F(x, T)` and :math:`G(x, T)` for multicomponent diff --git a/docs/source/inputfile.md b/docs/source/inputfile.md index 9398c397..5d4c0599 100644 --- a/docs/source/inputfile.md +++ b/docs/source/inputfile.md @@ -172,6 +172,24 @@ points at where it belongs. ``` ```` +### `dcci` + +````{grid} 1 2 3 4 +:outline: +```{grid-item} [](n_block_steps) +``` +```{grid-item} [](integrator) +``` +```{grid-item} [](stop_at_target_pressure) +``` +```{grid-item} [](n_check_blocks) +``` +```{grid-item} [](hysteresis_tolerance) +``` +```{grid-item} [](parallel_cells) +``` +```` + ### `composition_scaling` ````{grid} 1 2 3 4 @@ -325,7 +343,7 @@ Mass of the element(s) in the simulation. It should follow the same order as tha (mode)= #### `mode` -_type_: string, `fe` or `fe-qtb` or `ts` or `alchemy` or `melting_temperature` or `tscale` or `pscale` or `composition_scaling` \ +_type_: string, `fe` or `fe-qtb` or `ts` or `alchemy` or `melting_temperature` or `dcci` or `tscale` or `pscale` or `composition_scaling` \ _default_: None \ _example_: ``` @@ -340,6 +358,7 @@ Calculation mode. A small description of the different modes are given below. - `ts` performs a direct free energy calculation followed by reversible scaling to find temperature dependence. - `alchemy` is used for switching between two different interatomic potentials, or for integration over concentration. - `melting_temperature` can be used for automated calculation of melting temperature. +- `dcci` traces a solid-liquid coexistence line in the pressure-temperature plane from one known coexistence point by dynamic Clausius-Clapeyron integration (de Koning, Antonelli and Yip, J. Chem. Phys. 115, 11025 (2001)). See the [`dcci`](dcci_block) block. - `tscale` is used for similar purpose as `ts`, but scales the temperature directly. - `pscale` calculates the free energy as a function of the pressure. - `composition_scaling` performs integration over composition. @@ -360,6 +379,7 @@ temperature: [1200, 1300] Temperatures for the simulation in Kelvin. The way temperature is used in `calphy` depends on the selected mode of calculation. - mode `ts` or `tscale`, a temperature sweep is carried out. In that case, only two values of temperature should be specified. - mode `melting_temperature`, if provided it is used as an initial guess temperature. If not, the experimental melting temperature is used as a guess value. +- mode `dcci`, the coexistence temperature at `pressure[0]` in Kelvin, e.g. the result of a `melting_temperature` calculation at that pressure. It must be given explicitly. - all other modes, a calculation is launched for each temperature on the list. --- @@ -386,11 +406,13 @@ Pressure for the simulation in bars. Depending on the pressure input, other opti | `None` | `pressure: None` | True | True | `fe`, `alchemy` | None | | scalar | `pressure: 100` | True | False | all except `pscale` | None | | `(1,)` | `pressure: [100]` | True | False | all except `pscale` | None | -| `(2,)` | `pressure: [100, 200]` | True | False | `pscale` | None | +| `(2,)` | `pressure: [100, 200]` | True | False | `pscale`, `dcci` | None | | `(3,)` | `pressure: [100, 100, 100]` | False | False | all except `pscale` | px=py=pz | | `(1,3)` | `pressure: [[100, 100, 100]]` | False | False | all except `pscale` | px=py=pz | | `(2,3)` | `pressure: [[100, 100, 100], [200, 200, 200]]` | False | False | `pscale` | px=py=pz | +For mode `dcci`, `pressure[0]` is the pressure of the known coexistence point and `pressure[1]` the pressure the coexistence line is integrated to. + --- (pressure_coupling)= @@ -1911,3 +1933,159 @@ target_natoms: 1500 The structure parsed from Materials Project is replicated isotropically until it contains approximately this many atoms (ignored if `repeat` is set to anything other than `[1, 1, 1]`). --- + +--- +--- + +(dcci_block)= +## `dcci` block + +This block contains keywords that are used only for the mode `dcci`, the dynamic +Clausius-Clapeyron integration of a solid-liquid coexistence line. + +``` +mode: dcci +temperature: 1340 # coexistence temperature at pressure[0] +pressure: [0, 100000] # from the known point to the target pressure, in bar +n_switching_steps: 50000 # length of one sweep +dcci: + n_block_steps: 1000 + integrator: euler + stop_at_target_pressure: True + n_check_blocks: 0 + hysteresis_tolerance: 5.0 + parallel_cells: False +``` + +The mode builds a solid and a liquid cell from the input structure (the liquid +through the usual melting cycle), equilibrates both at (`temperature`, +`pressure[0]`) and then drives them side by side at the fixed kinetic +temperature `T0 = temperature` with the scaled Hamiltonian `K + λU` of +reversible scaling. The scaled pressure `P_RS` of both cells is ramped linearly +from `pressure[0]` to `pressure[1]` over `n_switching_steps` steps, and after +every block of `n_block_steps` steps the scaling factor is updated from the +block averages of the potential energy and volume of the two cells through the +Clausius-Clapeyron condition `dλ/dP_RS = -(v_s - v_l)/(u_s - u_l)`. The two +cells exchange information only at these block boundaries, and only through +calphy; within a block each follows its pre-set pressure and λ ramps on its own. +Each block is a point `T = T0/λ`, `P = P_RS/λ` on the coexistence line. A backward sweep +returns to `pressure[0]`; the line is the mean of both directions and the +mismatch of the round trip is the hysteresis. Use `n_iterations` for +independent repetitions. The mode needs `npt: True`, does not support +`monte_carlo` swaps, and assumes the same composition in both cells. + +Both cells have the melt and solidification checks switched on +(`tolerance.solid_fraction: 0.7`, `tolerance.liquid_fraction: 0.05` unless set +explicitly): a solid that melts or a liquid that freezes along the line stops +the calculation with `MeltedError` / `SolidifiedError`. + +--- + +(n_block_steps)= +#### `n_block_steps` + +_type_: int \ +_default_: 1000 \ +_example_: +``` +n_block_steps: 500 +``` + +MD steps per integration block, i.e. the pressure step of the Clausius-Clapeyron +integration. Smaller blocks follow the line more finely but average over fewer +steps. With the default `execution_mode: executable` every block is one launch of +the LAMMPS binary per cell, so a 1e5-step sweep with 1000-step blocks means 100 +launches per cell and direction; the library backend has no such cost and can use +blocks of 10-100 steps. + +--- + +(integrator)= +#### `integrator` + +_type_: string, `euler` or `trapezoid` \ +_default_: `euler` \ +_example_: +``` +integrator: trapezoid +``` + +Corrector applied after each block. `euler` advances λ with the slope of the +finished block; `trapezoid` uses the mean of the slopes of the last two blocks. +Within a block λ is always ramped linearly along the last measured slope, so the +Hamiltonian stays continuous in time. + +--- + +(stop_at_target_pressure)= +#### `stop_at_target_pressure` + +_type_: bool \ +_default_: True \ +_example_: +``` +stop_at_target_pressure: False +``` + +The ramp is applied to the scaled pressure `P_RS`; the real pressure `P_RS/λ` +runs ahead of it when the coexistence line has a positive slope (λ < 1). With +this option the forward sweep ends at the first block whose real pressure +reaches `pressure[1]`, and the backward sweep starts there. Set it to `False` +to always run the full `n_switching_steps`. For a line with negative slope the +real pressure lags the ramp and the sweep ends at `P_RS = pressure[1]`; the +pressure actually reached is reported in `report.yaml`. + +--- + +(n_check_blocks)= +#### `n_check_blocks` + +_type_: int \ +_default_: 0 \ +_example_: +``` +n_check_blocks: 10 +``` + +Run the solid-fraction melt and solidification checks on both cells every this +many blocks during the sweeps. With 0 the checks run only at the end of each +sweep. + +--- + +(hysteresis_tolerance)= +#### `hysteresis_tolerance` + +_type_: float \ +_default_: 5.0 \ +_example_: +``` +hysteresis_tolerance: 2.0 +``` + +In Kelvin. The backward sweep should return to `temperature` at `pressure[0]`; +the difference is the hysteresis of the integration and is reported in +`report.yaml`. When it exceeds this tolerance, `hysteresis_high` is set and a +warning is logged: the sweep is too fast for a reversible integration and +`n_switching_steps` should be increased. The hysteresis shrinks quickly with the +sweep length (de Koning et al., Fig. 5). + +--- + +(parallel_cells)= +#### `parallel_cells` + +_type_: bool \ +_default_: False \ +_example_: +``` +parallel_cells: True +``` + +By default the solid and the liquid cell are advanced one after the other, each +LAMMPS run using all of `queue.cores`, so the wall time of a block is the sum of +the two cells. With `parallel_cells: True` the two cells run at the same time +with `queue.cores / 2` cores each, which halves the wall time of the sweeps at +the same total core count. Needs `queue.cores >= 2`; with a single core the +cells run sequentially and a warning is logged. The results do not depend on +this setting. diff --git a/docs/source/outputfiles.md b/docs/source/outputfiles.md index fb6f15ee..3f81f6e1 100644 --- a/docs/source/outputfiles.md +++ b/docs/source/outputfiles.md @@ -166,6 +166,64 @@ Same four columns as `ts.*`, but `lambda` maps to pressure. --- +## Coexistence line — [](mode) `dcci` + +A `dcci-*` folder holds the coupled-sweep results at the top level and the two +cells in `solid/` and `liquid/`, each a complete calculation folder of its own +(equilibration data, `conf.equilibration.data`, `dcci__.log.lammps`, +`conf.dcci._.data` and the raw block averages +`dcci.blocks._.dat`). + +### `report.yaml` + +| Key | Meaning | +|---|---| +| `input.temperature`, `input.pressure` | The starting coexistence point [K, bar] | +| `input.pressure_stop` | The requested target pressure [bar] | +| `average.vol_atom_solid`, `average.vol_atom_liquid` | Equilibrium volumes per atom at the starting point [ų] | +| `results.coexistence_line` | Name of the line file below | +| `results.pressure_reached` | Real pressure at the end of the line [bar]; larger than `pressure_stop` when the sweep stopped on reaching it | +| `results.temperature_at_pressure_reached`, `results.error_at_pressure_reached` | Coexistence temperature there and its error [K] | +| `results.n_blocks_used` | Blocks of the forward sweep | +| `results.hysteresis` | `T_backward(pressure[0]) - temperature` [K], how far the round trip misses the start | +| `results.hysteresis_high` | Whether that exceeds [](hysteresis_tolerance) | + +### `coexistence_line.dat` + +The coexistence line, the mean of the forward and backward sweeps of all +iterations on the pressure grid of the forward sweep (starting point included). +Read it with `calphy.postprocessing.read_coexistence_line` or plot it with +`plot_coexistence_line`. + +| Column | Meaning | +|---|---| +| 1 | `pressure` [bar] | +| 2 | `temperature` — coexistence temperature [K] | +| 3 | `error` [K] — half the local forward/backward hysteresis, combined with the standard error over [](n_iterations) | +| 4 | `T_forward` [K] | +| 5 | `T_backward` [K] | + +The last point is where the backward sweep started, so its error is zero by +construction; the first point carries the round-trip hysteresis. + +### `dcci.forward_.dat` / `dcci.backward_.dat` + +One row per integration block of iteration `i`. + +| Column | Meaning | +|---|---| +| 1 | `block` index | +| 2 | `step` at the end of the block | +| 3 | `lambda` — scaling factor `T0/T` | +| 4 | `T` [K] | +| 5 | `P_RS` — scaled pressure imposed by the barostat [bar] | +| 6 | `P` — real pressure `P_RS/lambda` [bar] | +| 7, 8 | `u_solid`, `u_liquid` — block-averaged potential energy of the cells [eV/atom] | +| 9, 10 | `v_solid`, `v_liquid` — block-averaged volume of the cells [ų/atom] | +| 11 | `dPdT` — Clausius-Clapeyron slope `ΔH/(TΔV)` from the block averages [bar/K] | + +--- + ## Averaging data Time series written during the NPT/NVT equilibration and volume-convergence diff --git a/examples/example_13/analysis.ipynb b/examples/example_13/analysis.ipynb new file mode 100644 index 00000000..bef5405e --- /dev/null +++ b/examples/example_13/analysis.ipynb @@ -0,0 +1,495 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c334ab82", + "metadata": {}, + "source": [ + "# Example 13: Melting line of Cu by dynamic Clausius-Clapeyron integration" + ] + }, + { + "cell_type": "markdown", + "id": "ecf1f486", + "metadata": {}, + "source": [ + "In this example the melting line of Cu is traced from 0 bar to 50 kbar in a single pair of nonequilibrium runs with `mode: dcci`, the dynamic Clausius-Clapeyron integration of [de Koning, Antonelli and Yip, J. Chem. Phys. 115, 11025 (2001)](https://doi.org/10.1063/1.1420486).\n", + "\n", + "The EAM potential is the same as in the melting-temperature examples: [Mishin, Y., M. J. Mehl, D. A. Papaconstantopoulos, A. F. Voter, and J. D. Kress, Physical Review B 63, 224106 (2001)](https://doi.org/10.1103/PhysRevB.63.224106).\n", + "\n", + "The method needs one known coexistence point. Here it is the melting temperature at 0 bar from a `melting_temperature` calculation (example 04), 1340 K. From there a solid and a liquid cell are driven side by side at a fixed kinetic temperature with the scaled Hamiltonian $K + \\lambda U$ of reversible scaling; the scaled pressure $P_{RS}$ of both cells is ramped linearly, and after every block of `n_block_steps` MD steps the scaling factor is updated from the block averages of the potential energy $u$ and volume $v$ per atom of the two cells,\n", + "\n", + "$$\\frac{d\\lambda}{dP_{RS}} = -\\frac{v_s - v_l}{u_s - u_l},$$\n", + "\n", + "which is the Clausius-Clapeyron equation in the scaled variables. Every block is a point $T = T_0/\\lambda$, $P = P_{RS}/\\lambda$ of the melting line. A backward sweep returns to 0 bar; the line is the mean of both directions and the mismatch of the round trip is the hysteresis of the integration. The input file is provided in the folder:\n", + "\n", + "```\n", + "mode: dcci\n", + "temperature: 1340.0\n", + "pressure: [0.0, 50000.0]\n", + "n_switching_steps: 30000\n", + "dcci:\n", + " n_block_steps: 500\n", + "```\n", + "\n", + "and is run with `calphy -i input.yaml`. The sweep stops once the real pressure reaches 50 kbar, after 53 of the 60 blocks; out and back it takes a few minutes on four cores. Two further inputs integrate the same line with other settings: `input_converged.yaml` to 100 kbar with 200 blocks of 500 steps (the sweep stops after 155 once the real pressure reaches 100 kbar), and `input_high.yaml` to 1.5 Mbar with 1000-step blocks, which stops after 29 blocks because the real pressure runs far ahead of the scaled ramp there." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "05d98251", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:20.214542Z", + "iopub.status.busy": "2026-09-10T10:12:20.214366Z", + "iopub.status.idle": "2026-09-10T10:12:23.570614Z", + "shell.execute_reply": "2026-09-10T10:12:23.570173Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import yaml\n", + "from calphy.postprocessing import read_coexistence_line" + ] + }, + { + "cell_type": "markdown", + "id": "08253e8f", + "metadata": {}, + "source": [ + "The result is written to `coexistence_line.dat` in the calculation folder; `report.yaml` summarises it." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "889b2ee0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.571886Z", + "iopub.status.busy": "2026-09-10T10:12:23.571754Z", + "iopub.status.idle": "2026-09-10T10:12:23.575533Z", + "shell.execute_reply": "2026-09-10T10:12:23.575187Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'coexistence_line': 'coexistence_line.dat',\n", + " 'error_at_pressure_reached': 0.0,\n", + " 'hysteresis': 0.2081550000000334,\n", + " 'hysteresis_high': False,\n", + " 'n_blocks_used': 53,\n", + " 'pressure_reached': 51028.767473,\n", + " 'temperature_at_pressure_reached': 1548.193549,\n", + " 'unit': 'K, bar'}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "folder = \"dcci-fcc-solid-1340-0\"\n", + "\n", + "with open(f\"{folder}/report.yaml\") as fin:\n", + " report = yaml.safe_load(fin)\n", + "report[\"results\"]" + ] + }, + { + "cell_type": "markdown", + "id": "cf130f23", + "metadata": {}, + "source": [ + "The round trip returns to within a fraction of a kelvin of the starting temperature, so the integration is reversible at this sweep length. The line itself, every tenth block:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2a432428", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.576573Z", + "iopub.status.busy": "2026-09-10T10:12:23.576504Z", + "iopub.status.idle": "2026-09-10T10:12:23.583838Z", + "shell.execute_reply": "2026-09-10T10:12:23.583490Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pressuretemperatureerrortemperature_forwardtemperature_backward
00.0000001340.1040780.1040781340.0000001340.208155
108561.3758471376.6954040.0261681376.6692361376.721573
2017592.4431531414.4601200.0276911414.4324291414.487811
3027115.6576821453.4995450.1002931453.3992521453.599839
4037158.0704491493.8044100.0499781493.7544321493.854389
5047743.5331281535.4662580.0342331535.4320251535.500491
\n", + "
" + ], + "text/plain": [ + " pressure temperature error temperature_forward \\\n", + "0 0.000000 1340.104078 0.104078 1340.000000 \n", + "10 8561.375847 1376.695404 0.026168 1376.669236 \n", + "20 17592.443153 1414.460120 0.027691 1414.432429 \n", + "30 27115.657682 1453.499545 0.100293 1453.399252 \n", + "40 37158.070449 1493.804410 0.049978 1493.754432 \n", + "50 47743.533128 1535.466258 0.034233 1535.432025 \n", + "\n", + " temperature_backward \n", + "0 1340.208155 \n", + "10 1376.721573 \n", + "20 1414.487811 \n", + "30 1453.599839 \n", + "40 1493.854389 \n", + "50 1535.500491 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "line = read_coexistence_line(folder)\n", + "line.iloc[::10]" + ] + }, + { + "cell_type": "markdown", + "id": "4c084987", + "metadata": {}, + "source": [ + "The other two runs report their hysteresis in the same way; the 155-block run closes to a hundredth of a kelvin:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e5e786eb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.584837Z", + "iopub.status.busy": "2026-09-10T10:12:23.584773Z", + "iopub.status.idle": "2026-09-10T10:12:23.588560Z", + "shell.execute_reply": "2026-09-10T10:12:23.588250Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'coexistence_line': 'coexistence_line.dat',\n", + " 'error_at_pressure_reached': 0.0,\n", + " 'hysteresis': 2.4347530000000006,\n", + " 'hysteresis_high': False,\n", + " 'n_blocks_used': 29,\n", + " 'pressure_reached': 1580250.711377,\n", + " 'temperature_at_pressure_reached': 4867.898743,\n", + " 'unit': 'K, bar'}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "folder_conv = \"dcci-fcc-solid-1340-0-converged\"\n", + "folder_high = \"dcci-fcc-solid-1340-0-high\"\n", + "\n", + "line_conv = read_coexistence_line(folder_conv)\n", + "line_high = read_coexistence_line(folder_high)\n", + "with open(f\"{folder_high}/report.yaml\") as fin:\n", + " report_high = yaml.safe_load(fin)\n", + "report_high[\"results\"]" + ] + }, + { + "cell_type": "markdown", + "id": "eb8fb5e3", + "metadata": {}, + "source": [ + "To check the lines, the melting point was calculated independently at several pressures in two ways: with `mode: melting_temperature` (the input files `tm.input.*.yaml` are in the folder), and by direct free-energy calculations of both phases at two temperatures bracketing the melting point, whose crossing of $G_l - G_s$ gives $T_m$ with an error bar. Each of those points costs more than a whole coexistence line." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "df3d8ebf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.589521Z", + "iopub.status.busy": "2026-09-10T10:12:23.589454Z", + "iopub.status.idle": "2026-09-10T10:12:23.592599Z", + "shell.execute_reply": "2026-09-10T10:12:23.592219Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'pressure': 0.0,\n", + " 'tm': 1340.6,\n", + " 'tm_error': 0.0,\n", + " 'method': 'melting_temperature'},\n", + " {'pressure': 50000.0,\n", + " 'tm': 1564.9,\n", + " 'tm_error': 0.0,\n", + " 'method': 'melting_temperature'},\n", + " {'pressure': 100000.0,\n", + " 'tm': 1776.3,\n", + " 'tm_error': 0.0,\n", + " 'method': 'melting_temperature'},\n", + " {'pressure': 500000.0,\n", + " 'tm': 2912.9,\n", + " 'tm_error': 0.0,\n", + " 'method': 'melting_temperature'},\n", + " {'pressure': 0.0, 'tm': 1353.3, 'tm_error': 1.9, 'method': 'fe_crossing'},\n", + " {'pressure': 50000.0, 'tm': 1559.9, 'tm_error': 1.6, 'method': 'fe_crossing'},\n", + " {'pressure': 100000.0,\n", + " 'tm': 1749.2,\n", + " 'tm_error': 3.4,\n", + " 'method': 'fe_crossing'}]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with open(\"melting_temperature_reference.yaml\") as fin:\n", + " reference = yaml.safe_load(fin)\n", + "reference" + ] + }, + { + "cell_type": "markdown", + "id": "61bd53eb", + "metadata": {}, + "source": [ + "As in example 05 we also compare with Simon-equation fits, $T_m(P) = T_{m0}(P/a + 1)^b$, reported for this potential by [Wang et al. (2013)](https://doi.org/10.1063/1.4798225) and by An et al.:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "054d9724", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.593477Z", + "iopub.status.busy": "2026-09-10T10:12:23.593421Z", + "iopub.status.idle": "2026-09-10T10:12:23.859471Z", + "shell.execute_reply": "2026-09-10T10:12:23.859063Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def simon(p_gpa, tm0, a, b):\n", + " return tm0 * (p_gpa / a + 1) ** b\n", + "\n", + "GPA = 1e-4 # bar -> GPa\n", + "BLUE, ORANGE, INK, AQUA = \"#2a78d6\", \"#eb6834\", \"#1a1a19\", \"#1baf7a\"\n", + "\n", + "def draw(ax, zoom):\n", + " for df, lw, label in ((line_high, 1.8, \"d-CCI, 0 to 158 GPa, 29 blocks of 1000 steps\"),\n", + " (line_conv, 3.0, \"d-CCI, 0 to 10 GPa, 155 blocks of 500 steps\"),\n", + " (line, 3.0, \"d-CCI, 0 to 5 GPa, 53 blocks of 500 steps\")):\n", + " p = df.pressure * GPA\n", + " ax.fill_between(p, df.temperature - df.error, df.temperature + df.error, color=BLUE, alpha=0.18, lw=0)\n", + " ax.plot(p, df.temperature, color=BLUE, lw=lw, label=label)\n", + " for method, fmt, color, mfc, dx in ((\"melting_temperature\", \"o\", ORANGE, ORANGE, 9), (\"fe_crossing\", \"s\", INK, \"white\", -9)):\n", + " pts = [r for r in reference if r[\"method\"] == method]\n", + " p = np.array([r[\"pressure\"] for r in pts]) * GPA\n", + " t = np.array([r[\"tm\"] for r in pts])\n", + " e = np.array([r[\"tm_error\"] for r in pts])\n", + " ax.errorbar(p, t, yerr=e, fmt=fmt, ms=7, color=color, mfc=mfc, mec=color if mfc == \"white\" else \"white\", mew=1.5,\n", + " ecolor=color, capsize=4, lw=1.2, zorder=5, label=method.replace(\"_\", \" \") + (\" mode\" if method == \"melting_temperature\" else \", direct fe of both phases\"))\n", + " if zoom:\n", + " for pi, ti in zip(p, t):\n", + " ax.annotate(\"%.0f K\" % ti, (pi, ti), textcoords=\"offset points\", xytext=(dx, -dx), fontsize=8,\n", + " color=color, ha=\"left\" if dx > 0 else \"right\", va=\"center\")\n", + " pfit = np.linspace(0, 160, 300)\n", + " ax.plot(pfit, simon(pfit, 1315, 15.84, 0.543), ls=\"--\", lw=1.2, color=AQUA, label=\"Simon fit, Wang et al. (2013)\")\n", + " ax.plot(pfit, simon(pfit, 1325, 15.37, 0.53), ls=\":\", lw=1.4, color=AQUA, label=\"Simon fit, An et al.\")\n", + " ax.set_xlabel(\"pressure (GPa)\")\n", + " if zoom:\n", + " ax.set_xlim(-0.4, 11.5); ax.set_ylim(1290, 1830); ax.set_title(\"low-pressure end\", loc=\"left\", fontsize=10)\n", + " else:\n", + " ax.set_ylabel(\"melting temperature (K)\"); ax.set_title(\"Melting line of Cu (Mishin Cu01 EAM, 500-atom cells)\", loc=\"left\")\n", + " ax.legend(frameon=False, fontsize=8, loc=\"lower right\")\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11.5, 4.8), gridspec_kw={\"width_ratios\": [1.45, 1]})\n", + "draw(ax1, False); draw(ax2, True)\n", + "fig.tight_layout()\n", + "plt.savefig(\"melting_line.png\", dpi=150, bbox_inches=\"tight\")" + ] + }, + { + "cell_type": "markdown", + "id": "b18a965b", + "metadata": {}, + "source": [ + "The three d-CCI runs agree with each other (1544 K at 5 GPa from both the 53- and the 155-block run; 1719 K against 1730 K at 10 GPa from the 29- and the 155-block run), so the line is converged to about 10 K at 10 GPa with 500-step blocks, and it tracks the published Simon fits for this potential to within a few percent up to 160 GPa.\n", + "\n", + "Against the direct free-energy crossings the d-CCI line runs about 1 percent low, and the whole offset is the starting point: the direct crossing at 0 bar is 1353 K where `melting_temperature` gave 1340 K, the value the integration started from. Scaling the line by 1353/1340 gives 1559 K at 5 GPa and 1747 K at 10 GPa against the direct 1560 K and 1749 K. The dynamic integration therefore reproduces the pressure dependence to within a few kelvin; its accuracy is set by the accuracy of the starting coexistence point, and an error there propagates roughly in proportion to $T/T_0$. The `melting_temperature` points scatter around the direct crossings by 10 to 30 K, which is the resolution of that mode at these short settings.\n", + "\n", + "The slope of the line agrees with the Clausius-Clapeyron slope $\\Delta H/(T\\Delta V)$ written per block to `dcci.forward_1.dat`:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "73e56a10", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-10T10:12:23.860547Z", + "iopub.status.busy": "2026-09-10T10:12:23.860478Z", + "iopub.status.idle": "2026-09-10T10:12:23.938437Z", + "shell.execute_reply": "2026-09-10T10:12:23.938048Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fwd = np.loadtxt(f\"{folder_conv}/dcci.forward_1.dat\")\n", + "temp, press, dpdt = fwd[:, 3], fwd[:, 5], fwd[:, 10]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(press * GPA, dpdt, \"o\", ms=3, label=r\"$\\Delta H / (T \\Delta V)$ per block\")\n", + "ax.plot(press * GPA, np.gradient(press, temp), \"-\", label=\"slope of the integrated line\")\n", + "ax.set_xlabel(\"pressure (GPa)\")\n", + "ax.set_ylabel(\"dP/dT (bar/K)\")\n", + "ax.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "2ab77485", + "metadata": {}, + "source": [ + "Convergence is judged from the hysteresis: repeat with a longer `n_switching_steps` (or more `n_iterations`) until the round trip closes within the accuracy needed. The reference paper found the hysteresis to fall below the error of the starting point at about $10^5$ steps for a 500-atom Lennard-Jones system spanning two orders of magnitude in pressure." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "calphy", + "language": "python", + "name": "calphy" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/example_13/dcci-fcc-solid-1340-0-converged/coexistence_line.dat b/examples/example_13/dcci-fcc-solid-1340-0-converged/coexistence_line.dat new file mode 100644 index 00000000..99097e81 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-converged/coexistence_line.dat @@ -0,0 +1,158 @@ +# dynamic Clausius-Clapeyron coexistence line +# pressure[bar] temperature[K] error[K] T_forward[K] T_backward[K] +0.000000000000000000e+00 1.339993760500000008e+03 6.239499999992403900e-03 1.340000000000000000e+03 1.339987521000000015e+03 +5.008051639999999907e+02 1.342158209401751492e+03 3.694017514135339297e-04 1.342157840000000078e+03 1.342158578803502905e+03 +1.003227745000000027e+03 1.344317963465904086e+03 7.214534096078750736e-03 1.344325178000000051e+03 1.344310748931807893e+03 +1.507306456000000026e+03 1.346490538584029764e+03 3.656241597002463095e-02 1.346527100999999902e+03 1.346453976168059853e+03 +2.012934882000000016e+03 1.348645702182144305e+03 2.066881785572149965e-02 1.348666371000000026e+03 1.348625033364288583e+03 +2.520217635999999857e+03 1.350810756444710478e+03 2.589655528970524756e-02 1.350836653000000069e+03 1.350784859889420659e+03 +3.029162504999999783e+03 1.353010049415953745e+03 1.586958404607230477e-02 1.353025918999999931e+03 1.352994179831907786e+03 +3.539765569000000141e+03 1.355222337814984712e+03 2.194185015241600922e-03 1.355224531999999954e+03 1.355220143629969471e+03 +4.051920482999999876e+03 1.357424827483646823e+03 3.146548364691170718e-02 1.357393362000000025e+03 1.357456292967293848e+03 +4.565813122999999905e+03 1.359627303366280785e+03 2.961736628071776067e-02 1.359597686000000067e+03 1.359656920732561503e+03 +5.081301129999999830e+03 1.361815498811932684e+03 2.679581193262947636e-02 1.361788702999999941e+03 1.361842294623865200e+03 +5.598551629999999932e+03 1.364036779325487487e+03 2.601832548748461704e-02 1.364010761000000002e+03 1.364062797650974971e+03 +6.117401584000000184e+03 1.366248179041735511e+03 2.849204173560337949e-02 1.366219687000000022e+03 1.366276671083471228e+03 +6.638181835999999748e+03 1.368487279173131583e+03 5.621731315841316245e-04 1.368486716999999999e+03 1.368487841346263167e+03 +7.160361428999999589e+03 1.370686141619095224e+03 1.161738090468134033e-02 1.370697758999999905e+03 1.370674524238190543e+03 +7.684157793999999740e+03 1.372892849706615380e+03 1.000929338454170647e-02 1.372902859000000035e+03 1.372882840413230952e+03 +8.209824851999999737e+03 1.375152777134149801e+03 7.114134149787787464e-03 1.375145663000000013e+03 1.375159891268299589e+03 +8.737214035999999396e+03 1.377393150832657739e+03 2.944167342320724856e-03 1.377396095000000059e+03 1.377390206665315418e+03 +9.266126548000000184e+03 1.379620812958434271e+03 2.473041565849598555e-03 1.379623286000000007e+03 1.379618339916868308e+03 +9.796827347000000373e+03 1.381867950645094652e+03 3.273549052664748160e-04 1.381868277999999918e+03 1.381867623290189385e+03 +1.032908918699999958e+04 1.384109633309495621e+03 1.168230949565440824e-02 1.384097950999999966e+03 1.384121315618991275e+03 +1.086312865000000056e+04 1.386340035327550140e+03 2.097672449849596887e-03 1.386342133000000103e+03 1.386337937655100404e+03 +1.139927621100000033e+04 1.388621299610059850e+03 1.780238994035698852e-02 1.388639102000000094e+03 1.388603497220119380e+03 +1.193679761499999950e+04 1.390876008691932157e+03 2.040930806788310292e-02 1.390896418000000040e+03 1.390855599383864273e+03 +1.247581122999999934e+04 1.393112327714739422e+03 1.992628526056705596e-02 1.393132254000000103e+03 1.393092401429478969e+03 +1.301671017199999915e+04 1.395377689639206892e+03 1.364036079314701055e-02 1.395391329999999925e+03 1.395364049278413631e+03 +1.355926933800000006e+04 1.397649046293276797e+03 1.283293276856056764e-03 1.397647762999999941e+03 1.397650329586553653e+03 +1.410373944200000005e+04 1.399941503546857348e+03 1.477354685744103335e-02 1.399926729999999907e+03 1.399956277093714789e+03 +1.464986624999999913e+04 1.402213365843408610e+03 1.188184340855968912e-02 1.402201483999999937e+03 1.402225247686817056e+03 +1.519792548399999941e+04 1.404505679841597157e+03 7.738841596960810421e-03 1.404497941000000083e+03 1.404513418683194004e+03 +1.574775922800000080e+04 1.406802668767394607e+03 2.844767394549307937e-03 1.406799823999999944e+03 1.406805513534789043e+03 +1.629923497300000054e+04 1.409100758258444785e+03 5.605258444916216831e-03 1.409095152999999982e+03 1.409106363516889814e+03 +1.685247529500000019e+04 1.411403650242079493e+03 8.844242079476316576e-03 1.411394806000000017e+03 1.411412494484158969e+03 +1.740761628500000006e+04 1.413708809275104159e+03 6.347248960310025723e-04 1.413709444000000076e+03 1.413708174550208014e+03 +1.796436408500000107e+04 1.416003657878917238e+03 1.092312108266924042e-02 1.416014580999999907e+03 1.415992734757834569e+03 +1.852290537400000176e+04 1.418305024813920227e+03 2.030118607967779099e-02 1.418325325999999905e+03 1.418284723627840549e+03 +1.908289370300000155e+04 1.420609202730466677e+03 6.217269533408398274e-03 1.420615420000000086e+03 1.420602985460933269e+03 +1.964496562099999937e+04 1.422925671113979661e+03 6.973886020432473742e-03 1.422932645000000093e+03 1.422918697227959228e+03 +2.020865354799999841e+04 1.425245459728014566e+03 3.577728014533931855e-03 1.425241882000000032e+03 1.425249037456029100e+03 +2.077485606199999893e+04 1.427587277529819858e+03 1.821547018016644870e-02 1.427605493000000024e+03 1.427569062059639691e+03 +2.134262008300000161e+04 1.429933557447324574e+03 2.198855267533872393e-02 1.429955545999999913e+03 1.429911568894649236e+03 +2.191187078699999984e+04 1.432270749866374217e+03 1.738913362578387023e-02 1.432288139000000001e+03 1.432253360732748433e+03 +2.248288276699999915e+04 1.434588131395366645e+03 3.391160463343112497e-02 1.434622043000000076e+03 1.434554219790733214e+03 +2.305539307399999961e+04 1.436909285893453671e+03 3.149210654635226092e-02 1.436940777999999909e+03 1.436877793786907205e+03 +2.362996820300000036e+04 1.439257867668747622e+03 2.201333125242399547e-02 1.439279880999999932e+03 1.439235854337495084e+03 +2.420636405999999988e+04 1.441596619689516501e+03 2.684031048352153448e-02 1.441623460000000023e+03 1.441569779379032980e+03 +2.478459308299999975e+04 1.443931629968297102e+03 4.031503170290307025e-02 1.443971945000000005e+03 1.443891314936594199e+03 +2.536491370000000097e+04 1.446284810326121260e+03 5.494967387880933529e-02 1.446339760000000069e+03 1.446229860652242451e+03 +2.594769542100000035e+04 1.448684770845706225e+03 6.155715429372321523e-02 1.448746327999999949e+03 1.448623213691412502e+03 +2.653143133500000113e+04 1.451057424189347103e+03 4.943281065288829268e-02 1.451106856999999991e+03 1.451007991378694214e+03 +2.711658403399999952e+04 1.453417977394117770e+03 3.092660588220041973e-02 1.453448904000000084e+03 1.453387050788235683e+03 +2.770407111200000145e+04 1.455798646412313246e+03 2.312958768675343890e-02 1.455821776000000000e+03 1.455775516824626493e+03 +2.829376447199999893e+04 1.458181275371953006e+03 3.581662804708685144e-02 1.458217092000000093e+03 1.458145458743905920e+03 +2.888442160599999988e+04 1.460547964082934868e+03 2.278891706521335436e-02 1.460570752999999968e+03 1.460525175165869541e+03 +2.947720073699999921e+04 1.462924754254513118e+03 1.780074548707943904e-02 1.462942555000000084e+03 1.462906953509025925e+03 +3.007293770099999892e+04 1.465350572133488640e+03 2.166486651140075992e-02 1.465372237000000041e+03 1.465328907266977239e+03 +3.066976707199999873e+04 1.467764473361173486e+03 2.950638826405338477e-03 1.467767423999999892e+03 1.467761522722347081e+03 +3.126899415399999998e+04 1.470175915439923529e+03 1.538856007641697943e-02 1.470191303999999946e+03 1.470160526879847112e+03 +3.186958236400000169e+04 1.472595215223715059e+03 7.202237150067958282e-04 1.472594495000000052e+03 1.472595935447430065e+03 +3.247138889600000039e+04 1.475001794794719444e+03 3.023179471927051054e-02 1.474971563000000060e+03 1.475032026589438601e+03 +3.307690910299999814e+04 1.477443935129172132e+03 8.662129172080312856e-03 1.477435273000000052e+03 1.477452597258344213e+03 +3.368359217099999660e+04 1.479873723659117104e+03 4.428659117138522561e-03 1.479869294999999966e+03 1.479878152318234243e+03 +3.429232540000000154e+04 1.482328504136546144e+03 1.508313654619541921e-02 1.482313421000000062e+03 1.482343587273092453e+03 +3.490284400499999902e+04 1.484771188539336435e+03 1.528453933644868812e-02 1.484755904000000100e+03 1.484786473078672998e+03 +3.551570850800000335e+04 1.487233549021301087e+03 1.325502130111999577e-02 1.487220293999999967e+03 1.487246804042602207e+03 +3.613119341400000121e+04 1.489730941953329420e+03 1.404395332951935416e-02 1.489716897999999901e+03 1.489744985906658940e+03 +3.674761678499999834e+04 1.492185990550691486e+03 1.003655069143860601e-02 1.492175954000000047e+03 1.492196027101382924e+03 +3.736511214399999881e+04 1.494626337918719400e+03 2.185191871933511720e-02 1.494604485999999952e+03 1.494648189837438622e+03 +3.798647225500000059e+04 1.497111403129374139e+03 2.503870625673698669e-03 1.497113906999999926e+03 1.497108899258748579e+03 +3.860926469799999904e+04 1.499596405094885540e+03 9.817905114459790639e-03 1.499606223000000000e+03 1.499586587189771080e+03 +3.923333552100000088e+04 1.502067559270764832e+03 8.714729235066442925e-03 1.502076274000000012e+03 1.502058844541529879e+03 +3.985988792500000272e+04 1.504556178281751727e+03 1.423871824817979359e-02 1.504570416999999907e+03 1.504541939563503547e+03 +4.048811764499999845e+04 1.507039266121290439e+03 1.844587870959912834e-02 1.507057712000000038e+03 1.507020820242580839e+03 +4.111796822599999723e+04 1.509498295350716944e+03 3.807264928309450625e-02 1.509536368000000039e+03 1.509460222701433850e+03 +4.174937346399999660e+04 1.511970881218541763e+03 3.345478145809011039e-02 1.512004335999999967e+03 1.511937426437083786e+03 +4.238291542199999822e+04 1.514464979058242079e+03 1.786494175780717342e-02 1.514482843999999886e+03 1.514447114116484272e+03 +4.301960343699999794e+04 1.516987423314078342e+03 1.964568592165960581e-02 1.517007069000000001e+03 1.516967777628156682e+03 +4.365758267499999783e+04 1.519477140269394567e+03 3.352973060520980653e-02 1.519510669999999891e+03 1.519443610538789471e+03 +4.429781679399999848e+04 1.521981689337273565e+03 4.586166272645186837e-02 1.522027550999999903e+03 1.521935827674546999e+03 +4.494011028500000248e+04 1.524518294007509212e+03 3.228299249087740463e-02 1.524550576999999976e+03 1.524486011015018221e+03 +4.558301059199999872e+04 1.527021091820829042e+03 9.763179171045521798e-03 1.527030854999999974e+03 1.527011328641657883e+03 +4.622971948800000246e+04 1.529559006305370758e+03 1.689769462927870336e-02 1.529575904000000037e+03 1.529542108610741479e+03 +4.687788122899999871e+04 1.532096222615040915e+03 1.013938495907495962e-02 1.532106361999999990e+03 1.532086083230081840e+03 +4.752815959499999735e+04 1.534645170703177655e+03 9.817031775583018316e-04 1.534644189000000097e+03 1.534646152406355213e+03 +4.818243424799999775e+04 1.537223346491729899e+03 2.574650827011737420e-02 1.537249092999999903e+03 1.537197599983459668e+03 +4.883739240199999767e+04 1.539798496345414378e+03 1.575865458562475396e-02 1.539814255000000003e+03 1.539782737690828753e+03 +4.949274593599999935e+04 1.542327267260345934e+03 4.815739654077333398e-03 1.542332083000000011e+03 1.542322451520691857e+03 +5.014880805600000167e+04 1.544841560016109270e+03 2.770301610905789857e-02 1.544813857000000098e+03 1.544869263032218214e+03 +5.080919362600000022e+04 1.547393813366892573e+03 2.291636689267306792e-02 1.547370897000000014e+03 1.547416729733785360e+03 +5.147085376399999950e+04 1.549937170028344553e+03 2.831502834476395947e-02 1.549908854999999903e+03 1.549965485056689431e+03 +5.213499866699999984e+04 1.552510868050825820e+03 4.646305082587787183e-02 1.552464404999999942e+03 1.552557331101651698e+03 +5.280278163800000038e+04 1.555107452051332075e+03 3.652005133210423082e-02 1.555070932000000084e+03 1.555143972102664293e+03 +5.347033742099999654e+04 1.557669351526203400e+03 5.517452620347285119e-02 1.557614176999999927e+03 1.557724526052406873e+03 +5.414180622700000094e+04 1.560256627327371916e+03 4.113632737198713585e-02 1.560215490999999929e+03 1.560297763654743903e+03 +5.481615550400000211e+04 1.562868304456806754e+03 2.472245680678497592e-02 1.562843581999999969e+03 1.562893026913613539e+03 +5.549117360599999665e+04 1.565465374355106633e+03 3.016135510665662878e-02 1.565435212999999976e+03 1.565495535710213289e+03 +5.616830472400000144e+04 1.568057794721170467e+03 2.595472117047847860e-02 1.568031840000000102e+03 1.568083749442341059e+03 +5.684729839199999697e+04 1.570644717800080343e+03 1.832880008021220419e-02 1.570626389000000017e+03 1.570663046600160442e+03 +5.752936537099999987e+04 1.573265535298972736e+03 1.350229897275312396e-02 1.573252032999999983e+03 1.573279037597945489e+03 +5.821162127299999702e+04 1.575862566555141711e+03 3.281855514171638788e-02 1.575829748000000109e+03 1.575895385110283542e+03 +5.889593370300000242e+04 1.578441757883391347e+03 3.073488339146024373e-02 1.578411022999999886e+03 1.578472492766782807e+03 +5.958319017400000303e+04 1.581059025640494383e+03 3.972164049434923072e-02 1.581019303999999920e+03 1.581098747280988619e+03 +6.027442681699999957e+04 1.583711236270139352e+03 3.021827013935762807e-02 1.583681017999999995e+03 1.583741454540278710e+03 +6.096688373799999681e+04 1.586358045643202786e+03 3.524564320275658247e-02 1.586322799999999916e+03 1.586393291286405429e+03 +6.166070602700000018e+04 1.588989941340638325e+03 4.097834063838945440e-02 1.588948963000000049e+03 1.589030919681276828e+03 +6.235827090199999657e+04 1.591629469827852745e+03 8.840827852736765635e-03 1.591620629000000008e+03 1.591638310655705482e+03 +6.305667080200000055e+04 1.594272778802981065e+03 9.780802981254055339e-03 1.594262997999999925e+03 1.594282559605962433e+03 +6.375611314799999673e+04 1.596916490181818972e+03 3.440418181889981497e-02 1.596882086000000072e+03 1.596950894363637872e+03 +6.445882994699999836e+04 1.599571416376993511e+03 3.748837699345131114e-02 1.599533928000000060e+03 1.599608904753986963e+03 +6.516394532099999924e+04 1.602222650871653968e+03 2.656387165382056992e-02 1.602196087000000034e+03 1.602249214743307675e+03 +6.587298723899999459e+04 1.604907703577071061e+03 2.196577071117644664e-03 1.604905506999999943e+03 1.604909900154142179e+03 +6.658403559400000086e+04 1.607605232470640203e+03 9.320529359683860093e-03 1.607614552999999887e+03 1.607595911941280519e+03 +6.729595391199999722e+04 1.610289798893380976e+03 6.241106618858793809e-03 1.610296039999999948e+03 1.610283557786762231e+03 +6.801016203999999561e+04 1.612980886516347255e+03 3.487483652747869201e-03 1.612984373999999889e+03 1.612977399032694393e+03 +6.872554486100000213e+04 1.615671203178158976e+03 1.804317815901868016e-02 1.615653160000000071e+03 1.615689246356318108e+03 +6.944521541499999876e+04 1.618400552632981544e+03 2.509763298144207511e-02 1.618375455000000102e+03 1.618425650265962986e+03 +7.016693814199999906e+04 1.621128865012545475e+03 3.063901254540724040e-02 1.621098226000000068e+03 1.621159504025090882e+03 +7.088854748399999517e+04 1.623825303813229766e+03 5.344681322969790926e-02 1.623771856999999954e+03 1.623878750626459350e+03 +7.161558094600000186e+04 1.626563493409701096e+03 4.012940970130784990e-02 1.626523363999999901e+03 1.626603622819402517e+03 +7.234164958199999819e+04 1.629252233837536096e+03 4.533583753629955027e-02 1.629206897999999910e+03 1.629297569675072509e+03 +7.307080668599999626e+04 1.631964633145536709e+03 4.995014553674081981e-02 1.631914682999999968e+03 1.632014583291073450e+03 +7.379881473899999401e+04 1.634651923679552283e+03 9.966367955235000409e-02 1.634552259999999933e+03 1.634751587359104633e+03 +7.453344419900000503e+04 1.637396632842629060e+03 1.045798426290502903e-01 1.637292052999999896e+03 1.637501212685257997e+03 +7.526994691300000704e+04 1.640126170942852468e+03 9.805894285250360554e-02 1.640028111999999965e+03 1.640224229885704972e+03 +7.600928955800000404e+04 1.642876908946691174e+03 9.548994669125931978e-02 1.642781418999999914e+03 1.642972398893382433e+03 +7.675042920600000070e+04 1.645618975737974552e+03 8.977373797461041249e-02 1.645529201999999941e+03 1.645708749475949162e+03 +7.749575744899999700e+04 1.648410733536470616e+03 8.827353647063773678e-02 1.648322460000000092e+03 1.648499007072941367e+03 +7.824385172299999977e+04 1.651205712890302721e+03 7.561389030274767720e-02 1.651130098999999973e+03 1.651281326780605468e+03 +7.899280421899999783e+04 1.653974061468354876e+03 6.222346835488679062e-02 1.653911837999999989e+03 1.654036284936709762e+03 +7.974424908300000243e+04 1.656756902511550607e+03 5.467351155061805912e-02 1.656702228999999988e+03 1.656811576023101225e+03 +8.049662578200000280e+04 1.659531444187079387e+03 6.254318707942729816e-02 1.659468900999999960e+03 1.659593987374158814e+03 +8.125046863600000506e+04 1.662291006726462228e+03 6.767872646219075250e-02 1.662223328000000038e+03 1.662358685452924419e+03 +8.200788176099999691e+04 1.665078714664661675e+03 7.020666466166858299e-02 1.665008507999999892e+03 1.665148921329323230e+03 +8.276866854699999385e+04 1.667873065993499495e+03 5.327899349958897801e-02 1.667819786999999906e+03 1.667926344986999084e+03 +8.352904464900000312e+04 1.670651031128934846e+03 7.013812893478643673e-02 1.670580893000000060e+03 1.670721169257869633e+03 +8.429400214700000652e+04 1.673466656934386720e+03 7.461393438677532686e-02 1.673392043000000058e+03 1.673541270868773609e+03 +8.506376380800000334e+04 1.676317327793107324e+03 6.080579310730627185e-02 1.676256521999999904e+03 1.676378133586214517e+03 +8.583314857400000619e+04 1.679122641302445572e+03 5.082930244577710255e-02 1.679071811999999909e+03 1.679173470604891463e+03 +8.660309017999999924e+04 1.681923315526053557e+03 6.620152605376006250e-02 1.681857113999999910e+03 1.681989517052107431e+03 +8.737943822300000465e+04 1.684749197318333472e+03 2.333831833357180585e-02 1.684725858999999900e+03 1.684772535636667044e+03 +8.815540989700000500e+04 1.687570783106171575e+03 2.436510617167186865e-02 1.687546417999999903e+03 1.687595148212343247e+03 +8.893489338500000304e+04 1.690406154124681962e+03 1.243612468203991739e-02 1.690393718000000035e+03 1.690418590249364115e+03 +8.971329492899999605e+04 1.693228994228910324e+03 4.849822891048916063e-02 1.693180495999999948e+03 1.693277492457820927e+03 +9.049614367600000696e+04 1.696058828181527588e+03 4.718418152754111361e-02 1.696011643999999933e+03 1.696106012363055015e+03 +9.128180608100000245e+04 1.698881015440331339e+03 2.518044033138266968e-02 1.698855835000000070e+03 1.698906195880662835e+03 +9.206736811799999850e+04 1.701690887931842553e+03 3.194593184241512063e-02 1.701658942000000025e+03 1.701722833863684855e+03 +9.285653021500000614e+04 1.704539220297255724e+03 4.948729725572320604e-02 1.704489732999999887e+03 1.704588707594511334e+03 +9.365075922799999535e+04 1.707403413112952876e+03 2.902711295291737770e-02 1.707374385999999959e+03 1.707432440225905793e+03 +9.444479285300000629e+04 1.710247963239308774e+03 3.144423930871198536e-02 1.710216519000000062e+03 1.710279407478617486e+03 +9.524427091500000097e+04 1.713139609085784286e+03 2.117908578429705813e-02 1.713118429999999989e+03 1.713160788171568583e+03 +9.604578402500000084e+04 1.716021262547613105e+03 3.254547613096292480e-03 1.716018008000000009e+03 1.716024517095226201e+03 +9.684776292300000205e+04 1.718898660631469738e+03 1.121263146990258974e-02 1.718887447999999949e+03 1.718909873262939755e+03 +9.765335890200000722e+04 1.721811702509369297e+03 2.879550936927444127e-02 1.721782907000000023e+03 1.721840498018738572e+03 +9.846194405599999300e+04 1.724718535025320080e+03 2.565902532001018699e-02 1.724692876000000069e+03 1.724744194050640090e+03 +9.927238978199999838e+04 1.727612509769242479e+03 1.507676924245515693e-02 1.727597432999999910e+03 1.727627586538484820e+03 +1.000877429390000034e+05 1.730549361999999974e+03 0.000000000000000000e+00 1.730549361999999974e+03 1.730549361999999974e+03 diff --git a/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.backward_1.dat b/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.backward_1.dat new file mode 100644 index 00000000..74be18ad --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.backward_1.dat @@ -0,0 +1,157 @@ +# dynamic Clausius-Clapeyron backward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 500 0.7756266457 1727.635335 77000.000000 99274.567763 -3.31490000 -3.19354000 11.971200 12.479100 278.869050 +1 1000 0.7769208462 1724.757427 76500.000000 98465.629249 -3.31644000 -3.19351000 11.972300 12.482100 281.087725 +2 1500 0.7782302423 1721.855470 76000.000000 97657.474443 -3.31591000 -3.20108000 11.977700 12.459500 278.484283 +3 2000 0.7795612649 1718.915575 75500.000000 96849.347703 -3.31086000 -3.19670000 12.007800 12.494700 274.880093 +4 2500 0.7808738841 1716.026144 75000.000000 96046.239385 -3.31693000 -3.18864000 11.991300 12.530900 277.949796 +5 3000 0.7821750922 1713.171403 74500.000000 95247.216060 -3.32097000 -3.19875000 11.979900 12.489500 279.895638 +6 3500 0.7834905974 1710.294934 74000.000000 94449.123246 -3.31374000 -3.19356000 12.014900 12.521500 277.454122 +7 4000 0.7847975915 1707.446626 73500.000000 93654.721672 -3.32165000 -3.20446000 11.986400 12.477200 278.904655 +8 4500 0.7861021272 1704.613120 73000.000000 92863.252079 -3.31055000 -3.20089000 12.044400 12.502800 279.325795 +9 5000 0.7874301645 1701.738212 72500.000000 92071.656978 -3.32066000 -3.20340000 12.006500 12.505500 275.343327 +10 5500 0.7887372449 1698.918123 72000.000000 91285.152901 -3.31302000 -3.20386000 12.044100 12.501300 278.896932 +11 6000 0.7900344595 1696.128547 71500.000000 90502.381430 -3.31248000 -3.20593000 12.058700 12.501600 280.607629 +12 6500 0.7913537258 1693.300930 71000.000000 89719.676153 -3.32069000 -3.20556000 12.029300 12.516000 276.804546 +13 7000 0.7927003203 1690.424446 70500.000000 88936.510043 -3.32001000 -3.20133000 12.031400 12.543500 272.261736 +14 7500 0.7940239243 1687.606581 70000.000000 88158.552736 -3.31954000 -3.20151000 12.047100 12.547700 276.084007 +15 8000 0.7953545631 1684.783193 69500.000000 87382.411852 -3.32013000 -3.19998000 12.049600 12.561900 274.896330 +16 8500 0.7966610434 1682.020241 69000.000000 86611.490008 -3.31044000 -3.20584000 12.103100 12.541000 279.024865 +17 9000 0.7980006372 1679.196654 68500.000000 85839.530453 -3.32039000 -3.20095000 12.059900 12.572600 273.392671 +18 9500 0.7993289890 1676.406109 68000.000000 85071.354763 -3.31941000 -3.19419000 12.071800 12.604800 275.279980 +19 10000 0.8006810305 1673.575305 67500.000000 84303.233657 -3.31891000 -3.19503000 12.080200 12.616900 271.340819 +20 10500 0.8020336911 1670.752756 67000.000000 83537.637816 -3.32703000 -3.19294000 12.052400 12.633600 271.242898 +21 11000 0.8033814355 1667.949919 66500.000000 82775.126560 -3.31949000 -3.20281000 12.091000 12.594900 272.050692 +22 11500 0.8047177851 1665.180048 66000.000000 82016.330723 -3.32232000 -3.21053000 12.084800 12.563500 273.948371 +23 12000 0.8060692208 1662.388248 65500.000000 81258.530046 -3.32349000 -3.19743000 12.089800 12.635700 271.436254 +24 12500 0.8074130975 1659.621332 65000.000000 80504.019812 -3.32102000 -3.20001000 12.102400 12.623500 272.691237 +25 13000 0.8087708330 1656.835219 64500.000000 79750.650458 -3.32714000 -3.19385000 12.084000 12.663900 270.399969 +26 13500 0.8101264334 1654.062804 64000.000000 79000.014523 -3.32299000 -3.19810000 12.106800 12.649300 270.752325 +27 14000 0.8114751407 1651.313679 63500.000000 78252.551207 -3.31953000 -3.20055000 12.131700 12.645900 271.892791 +28 14500 0.8128420665 1648.536727 63000.000000 77505.831200 -3.32131000 -3.21008000 12.127900 12.615100 268.897073 +29 15000 0.8142203730 1645.746096 62500.000000 76760.545511 -3.32233000 -3.19592000 12.127400 12.685700 267.065910 +30 15500 0.8155752624 1643.012070 62000.000000 76019.961438 -3.32769000 -3.20103000 12.109200 12.659100 270.880382 +31 16000 0.8169415136 1640.264300 61500.000000 75280.786905 -3.32002000 -3.20355000 12.157700 12.667600 269.007709 +32 16500 0.8182985397 1637.544166 61000.000000 74544.921003 -3.32552000 -3.19469000 12.139300 12.708200 270.527274 +33 17000 0.8196759709 1634.792342 60500.000000 73809.654240 -3.32340000 -3.20203000 12.148400 12.684100 267.189960 +34 17500 0.8210610291 1632.034590 60000.000000 73076.175674 -3.33036000 -3.20549000 12.123200 12.677400 265.969080 +35 18000 0.8224312838 1629.315453 59500.000000 72346.469755 -3.32494000 -3.20216000 12.156500 12.695600 268.361812 +36 18500 0.8237943865 1626.619484 59000.000000 71619.813105 -3.33053000 -3.20706000 12.140200 12.679500 269.535889 +37 19000 0.8251740665 1623.899798 58500.000000 70894.132976 -3.32652000 -3.20718000 12.161700 12.689300 266.823014 +38 19500 0.8265627559 1621.171521 58000.000000 70170.110602 -3.32063000 -3.20966000 12.193000 12.686800 265.376206 +39 20000 0.8279601206 1618.435437 57500.000000 69447.789293 -3.32729000 -3.21051000 12.168300 12.691200 263.997363 +40 20500 0.8293638451 1615.696184 57000.000000 68727.375005 -3.32849000 -3.19910000 12.173400 12.755400 262.996086 +41 21000 0.8307624792 1612.976072 56500.000000 68009.811970 -3.32580000 -3.20656000 12.188100 12.722500 263.800021 +42 21500 0.8321527831 1610.281222 56000.000000 67295.334632 -3.33007000 -3.20300000 12.176200 12.742300 265.128386 +43 22000 0.8335445927 1607.592457 55500.000000 66583.120431 -3.32662000 -3.20545000 12.201000 12.741400 264.885407 +44 22500 0.8349374203 1604.910700 55000.000000 65873.200387 -3.32711000 -3.20390000 12.207000 12.756900 264.722264 +45 23000 0.8363193474 1602.258759 54500.000000 65166.494320 -3.31916000 -3.20164000 12.251100 12.771500 266.488141 +46 23500 0.8376977028 1599.622388 54000.000000 64462.394749 -3.32230000 -3.20520000 12.239600 12.756800 267.072424 +47 24000 0.8390925673 1596.963258 53500.000000 63759.353958 -3.32460000 -3.20817000 12.234700 12.755100 264.385594 +48 24500 0.8405016390 1594.286005 53000.000000 63057.580787 -3.33639000 -3.20944000 12.183100 12.756300 262.122702 +49 25000 0.8418982111 1591.641344 52500.000000 62359.082498 -3.32594000 -3.20601000 12.240600 12.777300 264.118532 +50 25500 0.8432737363 1589.045102 52000.000000 61664.436781 -3.32327000 -3.21269000 12.262400 12.749800 267.561407 +51 26000 0.8446768726 1586.405457 51500.000000 60970.060471 -3.32548000 -3.21136000 12.256400 12.769500 263.053455 +52 26500 0.8460922007 1583.751746 51000.000000 60277.118685 -3.32585000 -3.20870000 12.261500 12.792800 261.120594 +53 27000 0.8475047331 1581.112114 50500.000000 59586.687871 -3.31935000 -3.20241000 12.294200 12.823500 261.563950 +54 27500 0.8489165791 1578.482542 50000.000000 58898.602329 -3.33243000 -3.21519000 12.237200 12.767600 261.672483 +55 28000 0.8503044054 1575.906218 49500.000000 58214.446129 -3.33393000 -3.21194000 12.240800 12.783300 265.558820 +56 28500 0.8517219232 1573.283443 49000.000000 57530.513966 -3.32507000 -3.20110000 12.285300 12.848400 260.763124 +57 29000 0.8531397093 1570.668890 48500.000000 56848.836683 -3.32474000 -3.20185000 12.297000 12.855300 260.724492 +58 29500 0.8545417066 1568.091984 48000.000000 56170.459126 -3.32781000 -3.21589000 12.287500 12.790300 263.255222 +59 30000 0.8559537830 1565.505085 47500.000000 55493.650412 -3.32494000 -3.21099000 12.304400 12.820000 261.628403 +60 30500 0.8573801028 1562.900743 47000.000000 54818.160398 -3.33673000 -3.21335000 12.255300 12.819200 259.369144 +61 31000 0.8588034889 1560.310382 46500.000000 54145.099086 -3.32701000 -3.21379000 12.309300 12.825700 259.833857 +62 31500 0.8602197974 1557.741410 46000.000000 53474.705116 -3.32916000 -3.20883000 12.305300 12.851400 260.959441 +63 32000 0.8616504283 1555.155033 45500.000000 52805.637303 -3.32634000 -3.20776000 12.324200 12.867800 258.687588 +64 32500 0.8630843296 1552.571347 45000.000000 52138.590005 -3.33011000 -3.20686000 12.311300 12.877600 258.176530 +65 33000 0.8645307467 1549.973792 44500.000000 51473.010265 -3.32463000 -3.21071000 12.337700 12.865700 256.232037 +66 33500 0.8659556397 1547.423377 44000.000000 50810.916846 -3.32835000 -3.21341000 12.328900 12.853700 259.605261 +67 34000 0.8673828280 1544.877252 43500.000000 50150.866025 -3.31630000 -3.20758000 12.394900 12.892100 259.237659 +68 34500 0.8688203882 1542.321081 43000.000000 49492.392888 -3.32922000 -3.20954000 12.339800 12.891100 257.600372 +69 35000 0.8702551413 1539.778321 42500.000000 48836.252708 -3.33172000 -3.20987000 12.333400 12.893600 258.043350 +70 35500 0.8717202901 1537.190330 42000.000000 48180.592418 -3.32990000 -3.20455000 12.345200 12.933700 253.343699 +71 36000 0.8731652960 1534.646425 41500.000000 47528.228836 -3.32959000 -3.21517000 12.352400 12.882200 256.444749 +72 36500 0.8746260693 1532.083306 41000.000000 46877.175790 -3.33240000 -3.21052000 12.345300 12.915800 254.006440 +73 37000 0.8760817879 1529.537560 40500.000000 46228.560575 -3.33042000 -3.20891000 12.360600 12.927400 254.784938 +74 37500 0.8775326294 1527.008746 40000.000000 45582.350627 -3.33131000 -3.20823000 12.364300 12.936500 255.539740 +75 38000 0.8789896545 1524.477556 39500.000000 44937.957799 -3.33532000 -3.20548000 12.350500 12.956700 254.580657 +76 38500 0.8804645554 1521.923843 39000.000000 44294.798422 -3.32914000 -3.20318000 12.384700 12.980000 251.850900 +77 39000 0.8819066645 1519.435167 38500.000000 43655.413380 -3.34172000 -3.21084000 12.329500 12.934300 256.922225 +78 39500 0.8833439388 1516.962919 38000.000000 43018.351440 -3.32905000 -3.21269000 12.398600 12.934500 257.686272 +79 40000 0.8848139540 1514.442662 37500.000000 42381.790917 -3.33178000 -3.20037000 12.389300 13.008300 252.573820 +80 40500 0.8862848813 1511.929209 37000.000000 41747.299068 -3.33564000 -3.21074000 12.377500 12.966200 252.438505 +81 41000 0.8877399138 1509.451112 36500.000000 41115.645959 -3.32797000 -3.21288000 12.420900 12.957500 254.896830 +82 41500 0.8891740524 1507.016536 36000.000000 40487.011406 -3.32941000 -3.21730000 12.418800 12.934000 258.214201 +83 42000 0.8906384898 1504.538615 35500.000000 39859.045399 -3.33347000 -3.20970000 12.408900 12.989700 253.421207 +84 42500 0.8921100529 1502.056832 35000.000000 39232.827705 -3.32875000 -3.20401000 12.435100 13.023300 252.325154 +85 43000 0.8935809404 1499.584357 34500.000000 38608.701732 -3.33284000 -3.21776000 12.418900 12.961300 252.430022 +86 43500 0.8950588059 1497.108337 34000.000000 37986.330926 -3.34097000 -3.21351000 12.386200 12.989800 251.358824 +87 44000 0.8965291565 1494.653007 33500.000000 37366.325187 -3.33513000 -3.21415000 12.421400 12.991400 252.515594 +88 44500 0.8980040282 1492.198206 33000.000000 36748.164780 -3.33050000 -3.21243000 12.449000 13.007000 251.816733 +89 45000 0.8994809539 1489.748053 32500.000000 36131.949054 -3.33523000 -3.21388000 12.431200 13.005500 251.501055 +90 45500 0.9009919967 1487.249615 32000.000000 35516.408710 -3.33032000 -3.20855000 12.457000 13.046600 246.366193 +91 46000 0.9024847407 1484.789647 31500.000000 34903.637234 -3.33044000 -3.20724000 12.465600 13.054900 249.100061 +92 46500 0.9039720565 1482.346706 31000.000000 34293.095432 -3.33009000 -3.20686000 12.470800 13.058100 249.921905 +93 47000 0.9054794106 1479.879039 30500.000000 33683.813949 -3.32871000 -3.20776000 12.481200 13.065400 246.903743 +94 47500 0.9069654475 1477.454300 30000.000000 33077.335067 -3.32898000 -3.20745000 12.486700 13.065400 250.124418 +95 48000 0.9084512075 1475.037942 29500.000000 32472.850226 -3.33540000 -3.20742000 12.461900 13.071200 250.164114 +96 48500 0.9099576071 1472.596074 29000.000000 31869.616532 -3.33028000 -3.20482000 12.495600 13.101200 247.035692 +97 49000 0.9114668928 1470.157622 28500.000000 31268.277791 -3.33141000 -3.20772000 12.493500 13.091700 246.606719 +98 49500 0.9129551844 1467.760984 28000.000000 30669.632507 -3.33711000 -3.21048000 12.469100 13.073000 249.788423 +99 50000 0.9144729284 1465.324952 27500.000000 30071.967301 -3.33233000 -3.20972000 12.494300 13.090600 245.340518 +100 50500 0.9159864242 1462.903777 27000.000000 29476.419396 -3.33541000 -3.20860000 12.488100 13.103100 245.975593 +101 51000 0.9174806654 1460.521241 26500.000000 28883.442452 -3.33261000 -3.21016000 12.511100 13.097400 248.887590 +102 51500 0.9189793616 1458.139384 26000.000000 28292.256698 -3.33167000 -3.20923000 12.521100 13.109100 248.203432 +103 52000 0.9204740087 1455.771686 25500.000000 27703.117913 -3.33318000 -3.21306000 12.516200 13.091500 248.824355 +104 52500 0.9219874915 1453.381974 25000.000000 27115.335328 -3.33254000 -3.20876000 12.521700 13.122000 245.961779 +105 53000 0.9235010005 1451.000052 24500.000000 26529.478568 -3.33074000 -3.21022000 12.535400 13.119900 245.960182 +106 53500 0.9250224476 1448.613494 24000.000000 25945.316314 -3.32898000 -3.20593000 12.553500 13.153400 244.771188 +107 54000 0.9265525071 1446.221331 23500.000000 25362.836773 -3.32733000 -3.20844000 12.563700 13.146600 243.494283 +108 54500 0.9280515412 1443.885324 23000.000000 24783.106303 -3.33644000 -3.21765000 12.527600 13.098200 248.175759 +109 55000 0.9295447408 1441.565899 22500.000000 24205.397558 -3.33416000 -3.21988000 12.546400 13.093200 249.075362 +110 55500 0.9310516514 1439.232719 22000.000000 23629.193898 -3.33038000 -3.21306000 12.570000 13.136500 246.959396 +111 56000 0.9325804507 1436.873354 21500.000000 23054.311276 -3.33385000 -3.21674000 12.554700 13.128400 243.657648 +112 56500 0.9340910819 1434.549613 21000.000000 22481.747666 -3.33538000 -3.21054000 12.556400 13.160700 246.399877 +113 57000 0.9355901509 1432.251076 20500.000000 21911.303769 -3.34325000 -3.22032000 12.520600 13.111100 248.178749 +114 57500 0.9371227742 1429.908692 20000.000000 21341.920772 -3.32952000 -3.21539000 12.592700 13.153200 243.074663 +115 58000 0.9386601459 1427.566735 19500.000000 20774.292044 -3.33427000 -3.20947000 12.574000 13.188800 242.373624 +116 58500 0.9401862736 1425.249483 19000.000000 20208.761321 -3.33349000 -3.21777000 12.581500 13.147400 244.053907 +117 59000 0.9417268866 1422.917853 18500.000000 19644.761410 -3.33264000 -3.20790000 12.594000 13.209800 241.889564 +118 59500 0.9432619110 1420.602257 18000.000000 19082.716890 -3.33031000 -3.21091000 12.611300 13.198600 242.722426 +119 60000 0.9448047844 1418.282403 17500.000000 18522.344815 -3.33618000 -3.21316000 12.588900 13.197100 241.554284 +120 60500 0.9463333410 1415.991535 17000.000000 17964.071710 -3.34432000 -3.21045000 12.551500 13.207200 243.697172 +121 61000 0.9478618631 1413.708107 16500.000000 17407.599823 -3.33655000 -3.21850000 12.594900 13.173100 243.700558 +122 61500 0.9494029035 1411.413421 16000.000000 16852.697566 -3.33751000 -3.21082000 12.593300 13.218900 241.819533 +123 62000 0.9509569285 1409.106932 15500.000000 16299.371229 -3.34032000 -3.21013000 12.586000 13.234300 239.898650 +124 62500 0.9525124277 1406.805792 15000.000000 15747.826027 -3.33684000 -3.20569000 12.609100 13.262800 239.683506 +125 63000 0.9540665710 1404.514151 14500.000000 15198.100887 -3.33279000 -3.21765000 12.632400 13.205800 239.883371 +126 63500 0.9556231936 1402.226326 14000.000000 14650.125796 -3.34107000 -3.21224000 12.598300 13.240900 239.517972 +127 64000 0.9571718501 1399.957594 13500.000000 14104.050384 -3.33405000 -3.21024000 12.639100 13.253500 240.697573 +128 64500 0.9587518901 1397.650439 13000.000000 13559.295303 -3.33170000 -3.19838000 12.652800 13.327800 236.112260 +129 65000 0.9603236324 1395.362933 12500.000000 13016.445267 -3.32341000 -3.21220000 12.700100 13.260200 237.312085 +130 65500 0.9618898911 1393.090844 12000.000000 12475.440392 -3.33595000 -3.21391000 12.640700 13.253200 238.110033 +131 66000 0.9634367889 1390.854092 11500.000000 11936.434370 -3.33154000 -3.20652000 12.669800 13.289500 240.979923 +132 66500 0.9649991713 1388.602229 11000.000000 11398.973520 -3.33428000 -3.21755000 12.661200 13.245600 238.672439 +133 67000 0.9665753944 1386.337794 10500.000000 10863.094654 -3.33739000 -3.21430000 12.647000 13.268700 236.648908 +134 67500 0.9681226974 1384.122078 10000.000000 10329.269241 -3.33168000 -3.21472000 12.685300 13.265200 240.930709 +135 68000 0.9697021607 1381.867603 9500.000000 9796.822555 -3.33583000 -3.21238000 12.668200 13.293000 236.169761 +136 68500 0.9712832178 1379.618195 9000.000000 9266.092356 -3.33657000 -3.21358000 12.665300 13.288400 235.942309 +137 69000 0.9728544247 1377.390045 8500.000000 8737.175660 -3.33269000 -3.21310000 12.691900 13.294000 237.380770 +138 69500 0.9744318756 1375.160269 8000.000000 8209.912053 -3.34049000 -3.21437000 12.661600 13.299100 236.464528 +139 70000 0.9760486810 1372.882343 7500.000000 7684.042964 -3.34173000 -3.19932000 12.655300 13.393100 230.850115 +140 70500 0.9776212277 1370.674001 7000.000000 7160.237320 -3.33710000 -3.21529000 12.687500 13.301300 237.199829 +141 71000 0.9791829609 1368.487865 6500.000000 6638.187407 -3.34813000 -3.21003000 12.633600 13.324700 238.801954 +142 71500 0.9807668822 1366.277781 6000.000000 6117.661708 -3.33337000 -3.21275000 12.712600 13.324800 235.520707 +143 72000 0.9823587926 1364.063731 5500.000000 5598.769046 -3.34568000 -3.20861000 12.657400 13.356600 234.362871 +144 72500 0.9839605936 1361.843156 5000.000000 5081.504313 -3.33343000 -3.20837000 12.723300 13.365200 232.940899 +145 73000 0.9855421085 1359.657785 4500.000000 4566.014949 -3.33479000 -3.21594000 12.722000 13.324300 235.884592 +146 73500 0.9871398339 1357.457124 4000.000000 4052.110818 -3.33533000 -3.21417000 12.722600 13.342900 233.521040 +147 74000 0.9887692835 1355.220093 3500.000000 3539.753973 -3.34119000 -3.19887000 12.696100 13.439200 229.030926 +148 74500 0.9903962118 1352.993867 3000.000000 3029.090746 -3.33666000 -3.19903000 12.725700 13.443200 229.385906 +149 75000 0.9920161673 1350.784437 2500.000000 2520.120218 -3.33333000 -3.20264000 12.747500 13.425900 230.363970 +150 75500 0.9936047672 1348.624769 2000.000000 2012.872790 -3.33681000 -3.21020000 12.735800 13.380300 234.877039 +151 76000 0.9952069472 1346.453623 1500.000000 1507.224205 -3.33509000 -3.21415000 12.750400 13.371300 232.893650 +152 76500 0.9967933733 1344.310703 1000.000000 1003.216942 -3.33770000 -3.21550000 12.739900 13.361100 235.198723 +153 77000 0.9983917101 1342.158580 500.000000 500.805440 -3.34046000 -3.21673000 12.728900 13.362600 233.448241 +154 77500 1.0000093127 1339.987521 0.000000 0.000000 -3.33231000 -3.20988000 12.775500 13.410100 230.671386 diff --git a/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.forward_1.dat b/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.forward_1.dat new file mode 100644 index 00000000..16cb619a --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.forward_1.dat @@ -0,0 +1,157 @@ +# dynamic Clausius-Clapeyron forward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 500 0.9983922604 1342.157840 500.000000 500.805164 -3.33478000 -3.21387000 12.763200 13.386100 232.272857 +1 1000 0.9967826397 1344.325178 1000.000000 1003.227745 -3.33848000 -3.21395000 12.739500 13.381800 231.815400 +2 1500 0.9951526406 1346.527101 1500.000000 1507.306456 -3.33496000 -3.20990000 12.751300 13.404500 228.928568 +3 2000 0.9935741178 1348.666371 2000.000000 2012.934882 -3.33399000 -3.21790000 12.754700 13.341900 236.349079 +4 2500 0.9919778214 1350.836653 2500.000000 2520.217636 -3.33544000 -3.20946000 12.743700 13.388100 233.742156 +5 3000 0.9903727500 1353.025919 3000.000000 3029.162505 -3.33560000 -3.20817000 12.735700 13.391100 232.473471 +6 3500 0.9887660444 1355.224532 3500.000000 3539.765569 -3.34658000 -3.20411000 12.674000 13.407500 232.238580 +7 4000 0.9871862038 1357.393362 4000.000000 4051.920483 -3.32671000 -3.20886000 12.769300 13.365900 236.139873 +8 4500 0.9855856730 1359.597686 4500.000000 4565.813123 -3.34091000 -3.21850000 12.691900 13.319700 233.131506 +9 5000 0.9839999386 1361.788703 5000.000000 5081.301130 -3.33307000 -3.21369000 12.728800 13.335400 235.271301 +10 5500 0.9823969418 1364.010761 5500.000000 5598.551630 -3.33438000 -3.20990000 12.715100 13.354500 232.781456 +11 6000 0.9808085864 1366.219687 6000.000000 6117.401584 -3.33708000 -3.21271000 12.701600 13.334600 234.885794 +12 6500 0.9791837827 1368.486717 6500.000000 6638.181836 -3.33259000 -3.20350000 12.718800 13.390900 229.723051 +13 7000 0.9776042828 1370.697759 7000.000000 7160.361429 -3.33179000 -3.21184000 12.716600 13.323700 236.163281 +14 7500 0.9760340952 1372.902859 7500.000000 7684.157794 -3.33420000 -3.21491000 12.705100 13.305300 237.537135 +15 8000 0.9744422255 1375.145663 8000.000000 8209.824852 -3.33269000 -3.21328000 12.701100 13.310200 234.381525 +16 8500 0.9728501516 1377.396095 8500.000000 8737.214036 -3.34563000 -3.20779000 12.634600 13.337800 234.349883 +17 9000 0.9712796338 1379.623286 9000.000000 9266.126548 -3.33263000 -3.20953000 12.695600 13.315100 237.476828 +18 9500 0.9697016865 1381.868278 9500.000000 9796.827347 -3.33629000 -3.21551000 12.671100 13.281800 236.393694 +19 10000 0.9681395735 1384.097951 10000.000000 10329.089187 -3.32763000 -3.21076000 12.705800 13.290800 238.715181 +20 10500 0.9665723695 1386.342133 10500.000000 10863.128650 -3.33255000 -3.21598000 12.680800 13.266200 237.966496 +21 11000 0.9649735471 1388.639102 11000.000000 11399.276211 -3.33645000 -3.21063000 12.654400 13.299000 233.418453 +22 11500 0.9634074709 1390.896418 11500.000000 11936.797615 -3.33068000 -3.20747000 12.679000 13.297300 238.120000 +23 12000 0.9618612994 1393.132254 12000.000000 12475.811230 -3.33322000 -3.21569000 12.662600 13.244900 241.076448 +24 12500 0.9603040887 1395.391330 12500.000000 13016.710172 -3.33835000 -3.21516000 12.631500 13.246200 239.434687 +25 13000 0.9587537260 1397.647763 13000.000000 13559.269338 -3.33827000 -3.21518000 12.625900 13.237400 240.448856 +26 13500 0.9571929526 1399.926730 13500.000000 14103.739442 -3.33211000 -3.21394000 12.650600 13.241600 238.911763 +27 14000 0.9556401240 1402.201484 14000.000000 14649.866250 -3.34448000 -3.21632000 12.583400 13.221100 240.080358 +28 14500 0.9540775822 1404.497941 14500.000000 15197.925484 -3.33568000 -3.21313000 12.623500 13.237100 238.654974 +29 15000 0.9525164681 1406.799824 15000.000000 15747.759228 -3.33146000 -3.20440000 12.642700 13.278300 238.862101 +30 15500 0.9509648781 1409.095153 15500.000000 16299.234973 -3.32889000 -3.21702000 12.644500 13.200700 240.258483 +31 16000 0.9494154253 1411.394806 16000.000000 16852.475295 -3.33405000 -3.21407000 12.616100 13.211800 240.575003 +32 16500 0.9478609667 1413.709444 16500.000000 17407.616285 -3.33132000 -3.20741000 12.623400 13.240600 239.839438 +33 17000 0.9463179392 1416.014581 17000.000000 17964.364085 -3.33294000 -3.21962000 12.610900 13.171200 241.523012 +34 17500 0.9447761918 1418.325326 17500.000000 18522.905374 -3.33767000 -3.21371000 12.583700 13.196100 241.714317 +35 18000 0.9432531711 1420.615420 18000.000000 19082.893703 -3.33362000 -3.21750000 12.598800 13.165500 244.523694 +36 18500 0.9417170973 1422.932645 18500.000000 19644.965621 -3.33494000 -3.20910000 12.587300 13.206700 242.563713 +37 19000 0.9401912876 1425.241882 19000.000000 20208.653548 -3.34001000 -3.21091000 12.554900 13.186100 244.099877 +38 19500 0.9386346621 1427.605493 19500.000000 20774.856062 -3.33346000 -3.20453000 12.580900 13.224000 239.553082 +39 20000 0.9370920685 1429.955546 20000.000000 21342.620083 -3.33135000 -3.21553000 12.590000 13.162500 241.594332 +40 20500 0.9355659405 1432.288139 20500.000000 21911.870787 -3.34195000 -3.21165000 12.534000 13.171200 244.039501 +41 21000 0.9340439221 1434.622043 21000.000000 22482.882767 -3.33082000 -3.21448000 12.580900 13.148300 244.658624 +42 21500 0.9325366924 1436.940778 21500.000000 23055.393074 -3.33822000 -3.21403000 12.542100 13.141900 246.904066 +43 22000 0.9310211428 1439.279881 22000.000000 23629.968203 -3.33410000 -3.21784000 12.554200 13.118800 245.639765 +44 22500 0.9295076264 1441.623460 22500.000000 24206.364060 -3.33608000 -3.21321000 12.540400 13.136300 245.946348 +45 23000 0.9279958692 1443.971945 23000.000000 24784.593083 -3.33402000 -3.21014000 12.543900 13.144000 246.212927 +46 23500 0.9264766393 1446.339760 23500.000000 25364.913700 -3.33677000 -3.21087000 12.524500 13.137400 245.087395 +47 24000 0.9249376336 1448.746328 24000.000000 25947.695421 -3.33595000 -3.21110000 12.528400 13.144100 242.165172 +48 24500 0.9234330290 1451.106857 24500.000000 26531.431335 -3.33797000 -3.21375000 12.507300 13.106200 247.285748 +49 25000 0.9219450344 1453.448904 25000.000000 27116.584034 -3.33942000 -3.21719000 12.495300 13.078100 249.844120 +50 25500 0.9204423385 1455.821776 25500.000000 27704.071112 -3.32317000 -3.21848000 12.568600 13.072700 247.586396 +51 26000 0.9189303893 1458.217092 26000.000000 28293.764472 -3.33559000 -3.20993000 12.503300 13.112100 246.186701 +52 26500 0.9174495637 1460.570753 26500.000000 28884.421606 -3.33788000 -3.21725000 12.487600 13.060000 250.948242 +53 27000 0.9159621445 1462.942555 27000.000000 29477.200737 -3.33844000 -3.21696000 12.478800 13.057800 249.928266 +54 27500 0.9144434200 1465.372237 27500.000000 30072.937701 -3.33274000 -3.20125000 12.503400 13.143300 245.194828 +55 28000 0.9129511787 1467.767424 28000.000000 30669.767072 -3.33065000 -3.20584000 12.504700 13.101500 249.175024 +56 28500 0.9114460113 1470.191304 28500.000000 31268.994154 -3.33250000 -3.21521000 12.492100 13.057800 247.219479 +57 29000 0.9099585827 1472.594495 29000.000000 31869.582364 -3.33335000 -3.21271000 12.482600 13.057600 249.910189 +58 29500 0.9084920911 1474.971563 29500.000000 32471.388896 -3.33582000 -3.21599000 12.469500 13.032600 253.168642 +59 30000 0.9069771274 1477.435273 30000.000000 33076.909103 -3.33532000 -3.21197000 12.459400 13.058200 245.781293 +60 30500 0.9054853724 1479.869295 30500.000000 33683.592171 -3.33347000 -3.21341000 12.466400 13.040300 249.247941 +61 31000 0.9039923551 1482.313421 31000.000000 34292.325400 -3.33551000 -3.21459000 12.451000 13.029500 249.059548 +62 31500 0.9025052513 1484.755904 31500.000000 34902.844005 -3.33234000 -3.21117000 12.460700 13.038100 249.956954 +63 32000 0.9010097600 1487.220294 32000.000000 35515.708508 -3.33094000 -3.20565000 12.462000 13.062400 248.688730 +64 32500 0.8994997654 1489.716898 32500.000000 36131.193414 -3.33611000 -3.21006000 12.430900 13.040800 246.530399 +65 33000 0.8980174196 1492.175954 33000.000000 36747.616785 -3.33005000 -3.20567000 12.457500 13.048300 250.670812 +66 33500 0.8965582619 1494.604486 33500.000000 37365.112144 -3.32635000 -3.21289000 12.470800 13.001300 254.263693 +67 34000 0.8950554758 1497.113907 34000.000000 37986.472255 -3.33033000 -3.20353000 12.441100 13.051700 247.615970 +68 34500 0.8935679110 1499.606223 34500.000000 38609.264698 -3.32827000 -3.20869000 12.444500 13.014500 249.882790 +69 35000 0.8920985059 1502.076274 35000.000000 39233.335521 -3.32861000 -3.21369000 12.439500 12.980600 252.652426 +70 35500 0.8906196642 1504.570417 35500.000000 39859.887925 -3.33501000 -3.21521000 12.402600 12.970300 251.210206 +71 36000 0.8891497579 1507.057712 36000.000000 40488.117645 -3.33689000 -3.20995000 12.387800 12.985700 252.574040 +72 36500 0.8876897759 1509.536368 36500.000000 41117.968226 -3.33732000 -3.21065000 12.383300 12.975900 254.108051 +73 37000 0.8862408446 1512.004336 37000.000000 41749.373464 -3.33327000 -3.21664000 12.397100 12.938600 255.838188 +74 37500 0.8847904781 1514.482844 37500.000000 42382.915422 -3.33429000 -3.20777000 12.384100 12.972100 255.614063 +75 38000 0.8833182308 1517.007069 38000.000000 43019.603437 -3.34091000 -3.20989000 12.346500 12.964600 252.233613 +76 38500 0.8818628435 1519.510670 38500.000000 43657.582675 -3.32986000 -3.21126000 12.394800 12.947900 254.822186 +77 39000 0.8804045622 1522.027551 39000.000000 44297.816794 -3.33900000 -3.20420000 12.344000 12.973900 254.376008 +78 39500 0.8789475538 1524.550577 39500.000000 44940.110285 -3.33714000 -3.20717000 12.348800 12.955600 254.572217 +79 40000 0.8775199242 1527.030855 40000.000000 45583.010592 -3.32770000 -3.20898000 12.389700 12.932800 259.200816 +80 40500 0.8760598258 1529.575904 40500.000000 46229.719488 -3.33485000 -3.20601000 12.351500 12.954300 254.108537 +81 41000 0.8746129075 1532.106362 41000.000000 46877.881229 -3.32872000 -3.20522000 12.367600 12.940200 256.141876 +82 41500 0.8731665681 1534.644189 41500.000000 47528.159595 -3.32771000 -3.20470000 12.372200 12.942300 256.233846 +83 42000 0.8716869676 1537.249093 42000.000000 48182.434248 -3.33090000 -3.21152000 12.347400 12.913400 251.174256 +84 42500 0.8702348326 1539.814255 42500.000000 48837.392402 -3.33180000 -3.20797000 12.338800 12.915000 255.324368 +85 43000 0.8688141906 1542.332083 43000.000000 49492.745936 -3.32886000 -3.20424000 12.346400 12.913700 260.280657 +86 43500 0.8674184230 1544.813857 43500.000000 50148.808056 -3.32639000 -3.21444000 12.356500 12.857200 264.348180 +87 44000 0.8659850090 1547.370897 44000.000000 50809.193626 -3.32986000 -3.21077000 12.332800 12.879800 258.266286 +88 44500 0.8645669684 1549.908855 44500.000000 51470.853764 -3.32955000 -3.21236000 12.327500 12.860000 260.703329 +89 45000 0.8631437835 1552.464405 45000.000000 52134.998667 -3.32602000 -3.21035000 12.335900 12.863400 259.883797 +90 45500 0.8616970279 1555.070932 45500.000000 52802.781638 -3.32603000 -3.21026000 12.327100 12.863800 256.199184 +91 46000 0.8602900640 1557.614177 46000.000000 53470.337421 -3.32989000 -3.21038000 12.308500 12.847300 262.476158 +92 46500 0.8588557206 1560.215491 46500.000000 54141.806227 -3.32802000 -3.20409000 12.308900 12.878500 258.129905 +93 47000 0.8574114614 1562.843582 47000.000000 54816.155504 -3.32692000 -3.20477000 12.308700 12.874000 256.593683 +94 47500 0.8559919878 1565.435213 47500.000000 55491.173606 -3.32769000 -3.20510000 12.298400 12.856000 260.457135 +95 48000 0.8545744835 1568.031840 48000.000000 56168.304724 -3.33203000 -3.20971000 12.268600 12.824200 260.772770 +96 48500 0.8531627953 1570.626389 48500.000000 56847.298392 -3.32442000 -3.20615000 12.300300 12.835300 261.698916 +97 49000 0.8517389282 1573.252033 49000.000000 57529.365371 -3.32749000 -3.21650000 12.281300 12.787700 259.772651 +98 49500 0.8503456684 1575.829748 49500.000000 58211.621273 -3.33180000 -3.21322000 12.255800 12.785200 264.670318 +99 50000 0.8489550442 1578.411023 50000.000000 58895.933703 -3.31792000 -3.21166000 12.313900 12.787400 265.105666 +100 50500 0.8475544839 1581.019304 50500.000000 59583.190174 -3.32974000 -3.20340000 12.255000 12.822000 263.491119 +101 51000 0.8461299873 1583.681018 51000.000000 60274.426817 -3.32621000 -3.19794000 12.264600 12.850100 259.698814 +102 51500 0.8447208852 1586.322800 51500.000000 60966.883738 -3.32877000 -3.19870000 12.246300 12.833600 262.114876 +103 52000 0.8433247582 1588.948963 52000.000000 61660.706027 -3.32977000 -3.20057000 12.238700 12.816700 264.194128 +104 52500 0.8419091684 1591.620629 52500.000000 62358.270902 -3.33024000 -3.20458000 12.229200 12.799200 261.099481 +105 53000 0.8405137684 1594.262998 53000.000000 63056.670802 -3.32313000 -3.20339000 12.251400 12.786800 264.305182 +106 53500 0.8391352195 1596.882086 53500.000000 63756.113148 -3.32984000 -3.21047000 12.216000 12.743300 267.053047 +107 54000 0.8377440305 1599.533928 54000.000000 64458.829947 -3.32889000 -3.20715000 12.215500 12.758200 264.993399 +108 54500 0.8363520614 1602.196087 54500.000000 65163.945321 -3.32243000 -3.20096000 12.240300 12.782100 264.865760 +109 55000 0.8349401220 1604.905507 55000.000000 65872.987239 -3.32544000 -3.19835000 12.216000 12.791000 261.697399 +110 55500 0.8335331361 1607.614553 55500.000000 66584.035594 -3.32559000 -3.19823000 12.211000 12.785200 262.470922 +111 56000 0.8321451253 1610.296040 56000.000000 67295.953912 -3.32540000 -3.20509000 12.204600 12.739700 265.490865 +112 56500 0.8307582030 1612.984374 56500.000000 68010.162040 -3.33205000 -3.20152000 12.170500 12.750600 265.668970 +113 57000 0.8293859309 1615.653160 57000.000000 68725.544861 -3.32907000 -3.19842000 12.175800 12.750300 268.053071 +114 57500 0.8279908077 1618.375455 57500.000000 69445.215415 -3.32731000 -3.20050000 12.177900 12.744800 264.364284 +115 58000 0.8266001273 1621.098226 58000.000000 70166.938142 -3.32207000 -3.20235000 12.197100 12.730600 265.068253 +116 58500 0.8252390841 1623.771857 58500.000000 70888.547484 -3.32196000 -3.20321000 12.191400 12.709300 269.894091 +117 59000 0.8238430691 1626.523364 59000.000000 71615.580946 -3.31740000 -3.20006000 12.202300 12.727200 264.235265 +118 59500 0.8224860830 1629.206898 59500.000000 72341.649582 -3.32675000 -3.20730000 12.160000 12.679400 270.558664 +119 60000 0.8211213578 1631.914683 60000.000000 73070.806686 -3.31824000 -3.20539000 12.188400 12.681900 269.282432 +120 60500 0.8197963641 1634.552260 60500.000000 73798.814739 -3.32006000 -3.21247000 12.177100 12.633900 276.008006 +121 61000 0.8184245429 1637.292053 61000.000000 74533.444199 -3.32608000 -3.20799000 12.136600 12.655700 268.139374 +122 61500 0.8170591653 1640.028112 61500.000000 75269.946913 -3.32514000 -3.20183000 12.137900 12.677400 269.182487 +123 62000 0.8156897711 1642.781419 62000.000000 76009.289558 -3.32875000 -3.20685000 12.112900 12.647800 268.529011 +124 62500 0.8143276936 1645.529202 62500.000000 76750.429206 -3.32400000 -3.20227000 12.131800 12.663100 269.721507 +125 63000 0.8129477287 1648.322460 63000.000000 77495.757449 -3.32202000 -3.19834000 12.129200 12.676100 266.833134 +126 63500 0.8115653639 1651.130099 63500.000000 78243.851723 -3.31938000 -3.19675000 12.134200 12.677400 266.449417 +127 64000 0.8102003801 1653.911838 64000.000000 78992.804219 -3.32258000 -3.19864000 12.111300 12.653400 269.236255 +128 64500 0.8088357561 1656.702229 64500.000000 79744.249083 -3.31863000 -3.19157000 12.126200 12.681800 269.297076 +129 65000 0.8074872626 1659.468901 65000.000000 80496.625782 -3.32295000 -3.20328000 12.104400 12.621500 271.940256 +130 65500 0.8061491964 1662.223328 65500.000000 81250.468636 -3.32677000 -3.20787000 12.076900 12.586700 273.682347 +131 66000 0.8048006921 1665.008508 66000.000000 82007.881761 -3.32092000 -3.20581000 12.097300 12.594700 271.945107 +132 66500 0.8034441192 1667.819787 66500.000000 82768.668547 -3.32561000 -3.19821000 12.071600 12.625400 270.620188 +133 67000 0.8021162014 1670.580893 67000.000000 83529.044649 -3.31876000 -3.20250000 12.096000 12.590700 275.383720 +134 67500 0.8007687176 1673.392043 67500.000000 84294.002147 -3.31184000 -3.20058000 12.117700 12.598100 272.117903 +135 68000 0.7994003199 1676.256522 68000.000000 85063.763808 -3.32039000 -3.19831000 12.072000 12.607300 268.729126 +136 68500 0.7980599703 1679.071812 68500.000000 85833.148574 -3.32022000 -3.19498000 12.069800 12.607700 273.283766 +137 69000 0.7967383133 1681.857114 69000.000000 86603.090180 -3.31192000 -3.20335000 12.096700 12.556500 276.427049 +138 69500 0.7953816300 1684.725859 69500.000000 87379.438223 -3.31468000 -3.20054000 12.071600 12.567800 270.627232 +139 70000 0.7940522321 1687.546418 70000.000000 88155.409897 -3.32177000 -3.19855000 12.041100 12.566000 275.108559 +140 70500 0.7927147300 1690.393718 70500.000000 88934.893385 -3.31868000 -3.19427000 12.049500 12.582700 273.763014 +141 71000 0.7914100140 1693.180496 71000.000000 89713.294929 -3.31337000 -3.20052000 12.064300 12.536100 279.314609 +142 71500 0.7900889153 1696.011644 71500.000000 90496.143676 -3.31502000 -3.19953000 12.053000 12.541900 276.514688 +143 72000 0.7887661637 1698.855835 72000.000000 91281.806081 -3.31886000 -3.20191000 12.027100 12.522800 276.233834 +144 72500 0.7874668461 1701.658942 72500.000000 92067.368118 -3.31510000 -3.20291000 12.038900 12.506000 280.243081 +145 73000 0.7861590330 1704.489733 73000.000000 92856.530215 -3.31801000 -3.20495000 12.019500 12.493300 278.778824 +146 73500 0.7848307970 1707.374386 73500.000000 93650.759228 -3.31815000 -3.19595000 12.008000 12.528100 275.331666 +147 74000 0.7835265213 1710.216519 74000.000000 94444.792853 -3.30713000 -3.19027000 12.054300 12.542700 279.375537 +148 74500 0.7821992786 1713.118430 74500.000000 95244.270915 -3.31967000 -3.19190000 11.989800 12.533200 275.503418 +149 75000 0.7808775863 1716.018008 75000.000000 96045.784025 -3.32248000 -3.20010000 11.969200 12.487500 276.422801 +150 75500 0.7795740213 1718.887448 75500.000000 96847.762923 -3.31903000 -3.19502000 11.983600 12.501600 279.486600 +151 76000 0.7782630404 1721.782907 76000.000000 97653.358902 -3.31879000 -3.20298000 11.969600 12.456100 278.228080 +152 76500 0.7769499245 1724.692876 76500.000000 98461.944056 -3.31687000 -3.19823000 11.975600 12.474800 277.867105 +153 77000 0.7756436625 1727.597433 77000.000000 99272.389782 -3.32013000 -3.19726000 11.952600 12.466900 279.024287 +154 77500 0.7743205884 1730.549362 77500.000000 100087.742939 -3.31066000 -3.18954000 11.989200 12.502700 276.212206 diff --git a/examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml b/examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml new file mode 100644 index 00000000..06f9462a --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml @@ -0,0 +1,118 @@ +calculations: +- alchemy_coupling: false + berendsen: + barostat_damping: 100.0 + thermostat_damping: 100.0 + composition_scaling: + output_chemical_composition: {} + restrictions: [] + dcci: + hysteresis_tolerance: 5.0 + integrator: euler + n_block_steps: 500 + n_check_blocks: 0 + stop_at_target_pressure: true + element: + - Cu + equilibration_control: null + execution_mode: executable + file_format: lammps-data + fix_potential_path: true + folder_prefix: null + inputfile: input.yaml + kernel: 0 + lammps_executable: null + lattice: /private/tmp/claude-501/-Users-smenon-Documents-Projects-projects-calphy-stable-calphy/b601b9bf-90db-47a1-aacf-55cdd80197ea/scratchpad/validation/dcci_conv/dcci-fcc-solid-1340-0.0.data + lattice_constant: 3.615 + mass: + - 63.546 + materials_project: + conventional: true + target_natoms: 1500 + md: + barostat_damping: 0.1 + cmdargs: '' + init_commands: [] + n_cycles: 100 + n_every_steps: 10 + n_repeat_steps: 10 + n_small_steps: 10000 + seed: 2049361027 + thermostat_damping: 0.1 + timestep: 0.001 + melting_cycle: true + melting_temperature: + attempts: 5 + guess: null + step: 200 + mode: dcci + monte_carlo: + allow_all_swaps: true + forward_swap_types: [] + n_steps: 1 + n_swaps: 0 + reverse_swap_types: [] + use_custom_lammps: false + mpi_executable: null + n_elements: 1 + n_equilibration_steps: 10000 + n_iterations: 1 + n_print_steps: 0 + n_print_steps_equilibration: 0 + n_switching_steps: 100000 + nose_hoover: + barostat_damping: 0.1 + thermostat_damping: 0.1 + npt: true + pair_coeff: + - '* * /Users/smenon/Documents/Projects/projects-calphy-stable/calphy/tests/Cu01.eam.alloy + Cu' + pair_mode: null + pair_style: + - eam/alloy + phase_name: '' + phase_transition_detection: + mode: none + onset_fraction: 0.85 + prescan_steps: 20000 + potential_file: null + pressure: + - 0.0 + - 100000.0 + pressure_coupling: null + quantum_thermal_bath: + barostat_damping: 0.1 + f_max: 200.0 + n_f: 100 + thermostat_damping: 0.1 + queue: + commands: [] + cores: 4 + jobname: calphy + memory: 3GB + options: {} + queuename: '' + scheduler: local + walltime: '23:59:00' + reference_composition: 0.0 + reference_phase: solid + repeat: + - 5 + - 5 + - 5 + script_mode: false + spring_constants: null + temperature: 1340.0 + temperature_high: 0.0 + tolerance: + dissipation: 0.001 + lattice_constant: 0.0002 + liquid_fraction: 1.0 + pressure: 10.0 + solid_fraction: 0.0 + spring_constant: 0.1 + uhlenbeck_ford_model: + p: 50.0 + sigma: 1.5 + single_p: null + single_sigma: null diff --git a/examples/example_13/dcci-fcc-solid-1340-0-high/coexistence_line.dat b/examples/example_13/dcci-fcc-solid-1340-0-high/coexistence_line.dat new file mode 100644 index 00000000..54b29c0a --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-high/coexistence_line.dat @@ -0,0 +1,32 @@ +# dynamic Clausius-Clapeyron coexistence line +# pressure[bar] temperature[K] error[K] T_forward[K] T_backward[K] +0.000000000000000000e+00 1.341217376500000000e+03 1.217376500000000306e+00 1.340000000000000000e+03 1.342434753000000001e+03 +1.574642767900000035e+04 1.407983669083667792e+03 1.302796083667885796e+00 1.406680873000000020e+03 1.409286465167335791e+03 +3.309359899900000164e+04 1.479487451224566485e+03 1.306696224566394449e+00 1.478180755000000090e+03 1.480794147449132879e+03 +5.213682671700000355e+04 1.554369132311963540e+03 1.850292311963585234e+00 1.552518839999999955e+03 1.556219424623927125e+03 +7.306490938899999310e+04 1.633896165067466882e+03 2.113189067466919369e+00 1.631782975999999962e+03 1.636009354134933801e+03 +9.609118537000000651e+04 1.718602597857017372e+03 1.773418857017304617e+00 1.716829179000000067e+03 1.720376016714034677e+03 +1.211787443789999961e+05 1.806663358264574072e+03 2.446497264573849861e+00 1.804216861000000108e+03 1.809109855529147808e+03 +1.487125583979999938e+05 1.900744592525499684e+03 2.889085525499581308e+00 1.897855506999999989e+03 1.903633678050999151e+03 +1.788605498810000136e+05 2.000302048343540719e+03 3.025908343540777423e+00 1.997276139999999941e+03 2.003327956687081496e+03 +2.117560125169999956e+05 2.104921035074243264e+03 3.046540074243466734e+00 2.101874495000000024e+03 2.107967575148486958e+03 +2.476194272789999959e+05 2.214865074935210032e+03 2.798190935209959207e+00 2.212066883999999845e+03 2.217663265870419764e+03 +2.864456314899999998e+05 2.328964601100758046e+03 2.678866100757886670e+00 2.326285734999999931e+03 2.331643467201515705e+03 +3.284199822290000156e+05 2.447056516710286360e+03 2.152204710286241607e+00 2.444904312000000118e+03 2.449208721420572601e+03 +3.737292301979999756e+05 2.570417650165438317e+03 2.227042165438206212e+00 2.568190607999999884e+03 2.572644692330876296e+03 +4.225106715940000140e+05 2.698006422148345791e+03 1.985946148345647089e+00 2.696020476000000144e+03 2.699992368296691438e+03 +4.746511783159999759e+05 2.828723968315865932e+03 1.912506315865812212e+00 2.826811462000000120e+03 2.830636474631731744e+03 +5.309384277940000175e+05 2.964612679545072751e+03 2.064575450726806594e-01 2.964406222000000071e+03 2.964819137090145432e+03 +5.902413705070000142e+05 3.102297847862366780e+03 6.373128623667980719e-01 3.101660534999999982e+03 3.102935160724733578e+03 +6.531698842360000126e+05 3.242119530561491956e+03 4.615865614916856430e-01 3.241657944000000043e+03 3.242581117122983414e+03 +7.196078626269999659e+05 3.383936393064989716e+03 5.169690649895528622e-01 3.383419424000000163e+03 3.384453362129979269e+03 +7.892036686960000079e+05 3.526079161181211020e+03 9.694411812110956816e-01 3.525109719999999925e+03 3.527048602362422116e+03 +8.626761336219999939e+05 3.670257331369233270e+03 4.604453692331844650e-01 3.669796886000000086e+03 3.670717776738466455e+03 +9.410696392040000064e+05 3.820799868526333285e+03 5.132114736666153476e-01 3.821313079999999900e+03 3.820286657052666669e+03 +1.021731614875999978e+06 3.966329413368098358e+03 2.135409631901438843e+00 3.968464822999999797e+03 3.964194003736196919e+03 +1.106473468819000060e+06 4.116145047442473697e+03 2.395086557526155957e+00 4.118540133999999853e+03 4.113749960884947541e+03 +1.193968546282999916e+06 4.264146970246318233e+03 2.300634753682516020e+00 4.266447605000000294e+03 4.261846335492635262e+03 +1.285754494973999914e+06 4.415650500527564873e+03 2.070071472435756732e+00 4.417720572000000175e+03 4.413580429055128661e+03 +1.380116036093000090e+06 4.564576610347607129e+03 1.733237652393199824e+00 4.566309847999999874e+03 4.562843372695213475e+03 +1.478739166847999906e+06 4.716568730486731511e+03 1.313373513269198156e+00 4.717882104000000254e+03 4.715255356973461858e+03 +1.580250711376999971e+06 4.867898742999999740e+03 0.000000000000000000e+00 4.867898742999999740e+03 4.867898742999999740e+03 diff --git a/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.backward_1.dat b/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.backward_1.dat new file mode 100644 index 00000000..c91cfbaa --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.backward_1.dat @@ -0,0 +1,31 @@ +# dynamic Clausius-Clapeyron backward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 1000 0.2843251728 4712.913693 420000.000000 1477181.903655 -1.96808000 -1.77592000 8.264620 8.450420 659.427453 +1 2000 0.2938723638 4559.802707 405000.000000 1378149.325733 -2.10352000 -1.91772000 8.408080 8.597550 646.517920 +2 3000 0.3038517688 4410.045086 390000.000000 1283520.584876 -2.19993000 -2.03609000 8.535190 8.709830 631.642546 +3 4000 0.3147108154 4257.877183 375000.000000 1191570.107052 -2.29772000 -2.12940000 8.657080 8.852310 603.821139 +4 5000 0.3260538574 4109.750489 360000.000000 1104112.071665 -2.38606000 -2.22980000 8.797250 8.986570 590.194012 +5 6000 0.3383300294 3960.629809 345000.000000 1019714.391185 -2.48131000 -2.32063000 8.919350 9.130040 565.548679 +6 7000 0.3508329223 3819.481910 330000.000000 940618.679314 -2.56318000 -2.41872000 9.067750 9.260670 560.278476 +7 8000 0.3649734010 3671.500433 315000.000000 863076.594410 -2.64367000 -2.49082000 9.202350 9.433210 523.355657 +8 9000 0.3797442227 3528.690945 300000.000000 790005.435449 -2.72140000 -2.57989000 9.349380 9.572640 511.435522 +9 10000 0.3958274621 3385.313371 285000.000000 720010.679587 -2.78870000 -2.64082000 9.507890 9.761930 487.733226 +10 11000 0.4131559611 3243.327281 270000.000000 653506.243261 -2.85314000 -2.71177000 9.668750 9.930410 467.989888 +11 12000 0.4317080326 3103.949658 255000.000000 590676.987084 -2.91618000 -2.77666000 9.827530 10.104000 450.420544 +12 13000 0.4519200477 2965.126258 240000.000000 531067.389513 -2.97532000 -2.83767000 9.985130 10.282300 428.936854 +13 14000 0.4729283027 2833.410461 225000.000000 475759.219162 -3.02946000 -2.90098000 10.156800 10.445100 419.698533 +14 15000 0.4957935295 2702.737975 210000.000000 423563.414023 -3.07971000 -2.94242000 10.314100 10.649400 398.990524 +15 16000 0.5202736556 2575.567657 195000.000000 374802.756021 -3.11579000 -2.98901000 10.508600 10.840100 383.064177 +16 17000 0.5465372151 2451.800102 180000.000000 329346.282412 -3.15738000 -3.02880000 10.677600 11.038300 366.898108 +17 18000 0.5739564984 2334.671711 165000.000000 287478.233049 -3.18426000 -3.06967000 10.878900 11.214500 357.223713 +18 19000 0.6034479465 2220.572640 150000.000000 248571.564222 -3.21610000 -3.09826000 11.045100 11.416300 340.602231 +19 20000 0.6348192087 2110.837198 135000.000000 212658.971468 -3.24642000 -3.12633000 11.204900 11.607300 326.934944 +20 21000 0.6680388879 2005.871251 120000.000000 179630.261321 -3.26402000 -3.14382000 11.398300 11.824800 314.355209 +21 22000 0.7031320586 1905.758646 105000.000000 149331.834212 -3.28330000 -3.16106000 11.569500 12.027700 302.349866 +22 23000 0.7400723958 1810.633673 90000.000000 121609.724279 -3.29734000 -3.17698000 11.747000 12.221900 291.153692 +23 24000 0.7784856572 1721.290543 75000.000000 96340.888628 -3.30843000 -3.18764000 11.921700 12.417300 282.619847 +24 25000 0.8186310196 1636.879092 60000.000000 73293.093665 -3.32156000 -3.19642000 12.070300 12.606900 272.804823 +25 26000 0.8607471331 1556.787062 45000.000000 52280.162513 -3.32398000 -3.21421000 12.252400 12.746200 262.103319 +26 27000 0.9047575042 1481.059835 30000.000000 33158.056009 -3.33124000 -3.21258000 12.392900 12.950700 252.277356 +27 28000 0.9507480763 1409.416473 15000.000000 15777.050065 -3.33186000 -3.20182000 12.558200 13.197000 242.368994 +28 29000 0.9981863157 1342.434753 0.000000 0.000000 -3.33932000 -3.20865000 12.671500 13.333600 235.377163 diff --git a/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.forward_1.dat b/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.forward_1.dat new file mode 100644 index 00000000..76ceb01e --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.forward_1.dat @@ -0,0 +1,31 @@ +# dynamic Clausius-Clapeyron forward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 1000 0.9525970147 1406.680873 15000.000000 15746.427679 -3.33985000 -3.21880000 12.667700 13.280600 241.743110 +1 2000 0.9065197170 1478.180755 30000.000000 33093.598999 -3.33839000 -3.21148000 12.523700 13.148300 242.451433 +2 3000 0.8631135194 1552.518840 45000.000000 52136.826717 -3.32890000 -3.21301000 12.407100 12.944400 255.820171 +3 4000 0.8211876330 1631.782976 60000.000000 73064.909389 -3.32830000 -3.21236000 12.229400 12.748600 263.826319 +4 5000 0.7805086357 1716.829179 75000.000000 96091.185370 -3.32185000 -3.19895000 12.070900 12.604900 270.572944 +5 6000 0.7427045103 1804.216861 90000.000000 121178.744379 -3.30725000 -3.19598000 11.930400 12.379700 286.651874 +6 7000 0.7060600741 1897.855507 105000.000000 148712.558398 -3.29527000 -3.17519000 11.761100 12.231100 293.860508 +7 8000 0.6709137374 1997.276140 120000.000000 178860.549881 -3.28658000 -3.16599000 11.560600 12.013300 302.992510 +8 9000 0.6375261717 2101.874495 135000.000000 211756.012517 -3.26785000 -3.14116000 11.390200 11.842000 314.192392 +9 10000 0.6057683020 2212.066884 150000.000000 247619.427279 -3.24347000 -3.12325000 11.223300 11.631100 325.168819 +10 11000 0.5760255415 2326.285735 165000.000000 286445.631490 -3.21885000 -3.10018000 11.039800 11.416800 339.542799 +11 12000 0.5480787094 2444.904312 180000.000000 328419.982229 -3.18849000 -3.06340000 10.866800 11.240200 353.494089 +12 13000 0.5217681258 2568.190608 195000.000000 373729.230198 -3.15749000 -3.03220000 10.677300 11.029400 367.158288 +13 14000 0.4970288661 2696.020476 210000.000000 422510.671594 -3.12041000 -2.98720000 10.497600 10.849600 381.250928 +14 15000 0.4740323216 2826.811462 225000.000000 474651.178316 -3.07433000 -2.94389000 10.334200 10.654600 398.225093 +15 16000 0.4520298163 2964.406222 240000.000000 530938.427794 -3.02922000 -2.88710000 10.154300 10.488300 408.821406 +16 17000 0.4320266466 3101.660535 255000.000000 590241.370507 -2.97614000 -2.83358000 9.986810 10.291400 431.500811 +17 18000 0.4133687215 3241.657944 270000.000000 653169.884236 -2.92011000 -2.77954000 9.819260 10.099400 449.088120 +18 19000 0.3960490356 3383.419424 285000.000000 719607.862627 -2.85580000 -2.71585000 9.663180 9.922080 468.221532 +19 20000 0.3801300119 3525.109720 300000.000000 789203.668696 -2.78461000 -2.64899000 9.515270 9.745870 490.684363 +20 21000 0.3651428244 3669.796886 315000.000000 862676.133622 -2.71919000 -2.57317000 9.352370 9.586120 507.448628 +21 22000 0.3506648034 3821.313080 330000.000000 941069.639204 -2.64754000 -2.48329000 9.196860 9.450860 517.191147 +22 23000 0.3376620582 3968.464823 345000.000000 1021731.614876 -2.56315000 -2.40661000 9.051450 9.268860 547.514204 +23 24000 0.3253580046 4118.540134 360000.000000 1106473.468819 -2.48182000 -2.31773000 8.913340 9.128990 564.338280 +24 25000 0.3140786256 4266.447605 375000.000000 1193968.546283 -2.39225000 -2.23168000 8.778790 8.972240 591.038397 +25 26000 0.3033238472 4417.720572 390000.000000 1285754.494974 -2.29909000 -2.12926000 8.651160 8.846250 606.477921 +26 27000 0.2934535861 4566.309848 405000.000000 1380116.036093 -2.19195000 -2.03456000 8.535930 8.701860 634.541711 +27 28000 0.2840257494 4717.882104 420000.000000 1478739.166848 -2.10102000 -1.92255000 8.406500 8.586220 650.399490 +28 29000 0.2752727759 4867.898743 435000.000000 1580250.711377 -1.99308000 -1.81668000 8.291730 8.456650 676.230854 diff --git a/examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml b/examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml new file mode 100644 index 00000000..95d1a6d8 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml @@ -0,0 +1,118 @@ +calculations: +- alchemy_coupling: false + berendsen: + barostat_damping: 100.0 + thermostat_damping: 100.0 + composition_scaling: + output_chemical_composition: {} + restrictions: [] + dcci: + hysteresis_tolerance: 5.0 + integrator: euler + n_block_steps: 1000 + n_check_blocks: 0 + stop_at_target_pressure: true + element: + - Cu + equilibration_control: null + execution_mode: executable + file_format: lammps-data + fix_potential_path: true + folder_prefix: null + inputfile: input.yaml + kernel: 0 + lammps_executable: null + lattice: /private/tmp/claude-501/-Users-smenon-Documents-Projects-projects-calphy-stable-calphy/b601b9bf-90db-47a1-aacf-55cdd80197ea/scratchpad/validation/dcci_high/dcci-fcc-solid-1340-0.0.data + lattice_constant: 3.615 + mass: + - 63.546 + materials_project: + conventional: true + target_natoms: 1500 + md: + barostat_damping: 0.1 + cmdargs: '' + init_commands: [] + n_cycles: 100 + n_every_steps: 10 + n_repeat_steps: 10 + n_small_steps: 10000 + seed: 36717953 + thermostat_damping: 0.1 + timestep: 0.001 + melting_cycle: true + melting_temperature: + attempts: 5 + guess: null + step: 200 + mode: dcci + monte_carlo: + allow_all_swaps: true + forward_swap_types: [] + n_steps: 1 + n_swaps: 0 + reverse_swap_types: [] + use_custom_lammps: false + mpi_executable: null + n_elements: 1 + n_equilibration_steps: 10000 + n_iterations: 1 + n_print_steps: 0 + n_print_steps_equilibration: 0 + n_switching_steps: 100000 + nose_hoover: + barostat_damping: 0.1 + thermostat_damping: 0.1 + npt: true + pair_coeff: + - '* * /Users/smenon/Documents/Projects/projects-calphy-stable/calphy/tests/Cu01.eam.alloy + Cu' + pair_mode: null + pair_style: + - eam/alloy + phase_name: '' + phase_transition_detection: + mode: none + onset_fraction: 0.85 + prescan_steps: 20000 + potential_file: null + pressure: + - 0.0 + - 1500000.0 + pressure_coupling: null + quantum_thermal_bath: + barostat_damping: 0.1 + f_max: 200.0 + n_f: 100 + thermostat_damping: 0.1 + queue: + commands: [] + cores: 4 + jobname: calphy + memory: 3GB + options: {} + queuename: '' + scheduler: local + walltime: '23:59:00' + reference_composition: 0.0 + reference_phase: solid + repeat: + - 5 + - 5 + - 5 + script_mode: false + spring_constants: null + temperature: 1340.0 + temperature_high: 0.0 + tolerance: + dissipation: 0.001 + lattice_constant: 0.0002 + liquid_fraction: 1.0 + pressure: 10.0 + solid_fraction: 0.0 + spring_constant: 0.1 + uhlenbeck_ford_model: + p: 50.0 + sigma: 1.5 + single_p: null + single_sigma: null diff --git a/examples/example_13/dcci-fcc-solid-1340-0-high/report.yaml b/examples/example_13/dcci-fcc-solid-1340-0-high/report.yaml new file mode 100644 index 00000000..daf2ae51 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-high/report.yaml @@ -0,0 +1,20 @@ +average: + vol_atom_liquid: 13.408466735619454 + vol_atom_solid: 12.759740873592614 +input: + element: Cu + lattice: fcc + n_block_steps: 1000 + n_iterations: 1 + pressure: 0.0 + pressure_stop: 1500000.0 + temperature: 1340.0 +results: + coexistence_line: coexistence_line.dat + error_at_pressure_reached: 0.0 + hysteresis: 2.4347530000000006 + hysteresis_high: false + n_blocks_used: 29 + pressure_reached: 1580250.711377 + temperature_at_pressure_reached: 4867.898743 + unit: K, bar diff --git a/examples/example_13/dcci-fcc-solid-1340-0/coexistence_line.dat b/examples/example_13/dcci-fcc-solid-1340-0/coexistence_line.dat new file mode 100644 index 00000000..e2414fe3 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0/coexistence_line.dat @@ -0,0 +1,56 @@ +# dynamic Clausius-Clapeyron coexistence line +# pressure[bar] temperature[K] error[K] T_forward[K] T_backward[K] +0.000000000000000000e+00 1.340104077500000130e+03 1.040775000000166983e-01 1.340000000000000000e+03 1.340208155000000033e+03 +8.355712350000000015e+02 1.343713887308695575e+03 1.153413086955197286e-01 1.343598545999999942e+03 1.343829228617390982e+03 +1.675659585000000106e+03 1.347321929684968609e+03 9.162368496868111833e-02 1.347230305999999928e+03 1.347413553369937290e+03 +2.520276542000000063e+03 1.350925407128272127e+03 5.718012827230722905e-02 1.350868226999999933e+03 1.350982587256544548e+03 +3.369245621000000028e+03 1.354533882292447288e+03 9.714229244718808332e-02 1.354436740000000100e+03 1.354631024584894476e+03 +4.223042540000000372e+03 1.358205330365929512e+03 7.484936592948088219e-02 1.358130480999999918e+03 1.358280179731858880e+03 +5.081292994000000363e+03 1.361876145525081711e+03 8.962352508160620346e-02 1.361786522000000105e+03 1.361965769050163317e+03 +5.944245904999999766e+03 1.365567738511279003e+03 8.953651127899320272e-02 1.365478202000000010e+03 1.365657275022557997e+03 +6.812113325999999688e+03 1.369289942117935880e+03 5.516311793610384484e-02 1.369234778999999889e+03 1.369345105235872097e+03 +7.684376260000000002e+03 1.372966578597259286e+03 2.468659725911948044e-02 1.372941892000000053e+03 1.372991265194518292e+03 +8.561375846999999339e+03 1.376695404476502063e+03 2.616847650199360942e-02 1.376669235999999955e+03 1.376721572953003943e+03 +9.443116344000000026e+03 1.380431328149485580e+03 1.941214948556080344e-02 1.380411916000000019e+03 1.380450740298971141e+03 +1.032951951600000029e+04 1.384154867608689301e+03 7.473913105968676973e-04 1.384155614999999898e+03 1.384154120217378704e+03 +1.122079850500000066e+04 1.387906517453044216e+03 1.994354695591482596e-02 1.387926461000000018e+03 1.387886573906088188e+03 +1.211636789099999987e+04 1.391683226086293871e+03 3.182808629401279177e-02 1.391651397999999972e+03 1.391715054172587998e+03 +1.301678964099999939e+04 1.395441050236550609e+03 4.120023655059412704e-02 1.395399850000000015e+03 1.395482250473101203e+03 +1.392220370899999944e+04 1.399194358012615339e+03 1.288501261535657250e-02 1.399181473000000096e+03 1.399207243025230810e+03 +1.483187979400000040e+04 1.402961938922624086e+03 4.060292262397524610e-02 1.402921336000000110e+03 1.403002541845248061e+03 +1.574726454100000046e+04 1.406797300890635142e+03 4.166889063503731450e-02 1.406755632000000105e+03 1.406838969781270180e+03 +1.666729585999999836e+04 1.410623874266904750e+03 4.430926690463365958e-02 1.410579565000000002e+03 1.410668183533809270e+03 +1.759244315300000017e+04 1.414460120076113299e+03 2.769107611334220564e-02 1.414432428999999956e+03 1.414487811152226641e+03 +1.852177054100000169e+04 1.418277368441557428e+03 3.893844155720671552e-02 1.418238430000000108e+03 1.418316306883114521e+03 +1.945765265300000101e+04 1.422154515095488023e+03 2.300590451204698184e-02 1.422177521000000070e+03 1.422131509190975976e+03 +2.039746180599999934e+04 1.426034481474532186e+03 1.415252546792089561e-02 1.426048633999999993e+03 1.426020328949064151e+03 +2.134297618900000089e+04 1.429964635309772575e+03 1.476969022746743576e-02 1.429979405000000042e+03 1.429949865619545108e+03 +2.229305571399999826e+04 1.433875048945771596e+03 1.429505422845522844e-02 1.433889343999999937e+03 1.433860753891543027e+03 +2.324729668500000116e+04 1.437773390235498255e+03 1.750323549822496716e-02 1.437755887000000030e+03 1.437790893470996480e+03 +2.420632452499999999e+04 1.441668338396611034e+03 4.723339661097725184e-02 1.441621104999999943e+03 1.441715571793221898e+03 +2.517036025199999858e+04 1.445573589404126551e+03 7.575740412653431122e-02 1.445497832000000017e+03 1.445649346808253085e+03 +2.614026155999999901e+04 1.449505333654460401e+03 7.289965446034329943e-02 1.449432434000000057e+03 1.449578233308920744e+03 +2.711565768200000093e+04 1.453499545319495155e+03 1.002933194951083351e-01 1.453399251999999933e+03 1.453599838638990150e+03 +2.809685420599999998e+04 1.457484106103245040e+03 7.308810324502701405e-02 1.457411018000000013e+03 1.457557194206490067e+03 +2.908265674199999921e+04 1.461454468956565051e+03 5.096795656493213755e-02 1.461403501000000006e+03 1.461505436913129870e+03 +3.007383955599999899e+04 1.465441682355333342e+03 2.550035533352001949e-02 1.465416181999999935e+03 1.465467182710666975e+03 +3.106972731500000009e+04 1.469458226195813040e+03 4.288719581325040053e-02 1.469415338999999904e+03 1.469501113391626404e+03 +3.207115072100000179e+04 1.473519288605219344e+03 7.899260521935502766e-02 1.473440295999999989e+03 1.473598281210438699e+03 +3.307878502399999707e+04 1.477574342578347114e+03 5.527857834692895267e-02 1.477519064000000071e+03 1.477629621156693929e+03 +3.409052086899999995e+04 1.481612972527339934e+03 5.736252734016034083e-02 1.481555609999999888e+03 1.481670335054680208e+03 +3.510781274500000291e+04 1.485683469872982187e+03 6.865687298238754011e-02 1.485614812999999913e+03 1.485752126745964688e+03 +3.613030900899999688e+04 1.489736677451374817e+03 5.624445137493694347e-02 1.489680432999999994e+03 1.489792921902749868e+03 +3.715807044899999892e+04 1.493804410401425230e+03 4.997840142516452033e-02 1.493754431999999952e+03 1.493854388802850281e+03 +3.819081758299999638e+04 1.497912222803247460e+03 8.698680324766883132e-02 1.497825235999999904e+03 1.497999209606495242e+03 +3.922893736799999897e+04 1.502035405995456131e+03 1.275179954561735940e-01 1.501907887999999957e+03 1.502162923990912304e+03 +4.027371091999999771e+04 1.506117978655892784e+03 6.850965589285351598e-02 1.506049469000000045e+03 1.506186488311785752e+03 +4.132364330799999880e+04 1.510280606927930648e+03 8.927892793053615605e-02 1.510191328000000112e+03 1.510369885855861185e+03 +4.237797805199999857e+04 1.514416934387463243e+03 1.105183874632302832e-01 1.514306415999999899e+03 1.514527452774926360e+03 +4.344034690399999818e+04 1.518619642098943814e+03 9.621109894374058058e-02 1.518523431000000073e+03 1.518715853197887554e+03 +4.450959590100000059e+04 1.522847298398835619e+03 5.091139883552386891e-02 1.522796387000000095e+03 1.522898209797671143e+03 +4.558339854400000331e+04 1.527081312861148717e+03 3.746186114881311369e-02 1.527043850999999904e+03 1.527118774722297530e+03 +4.666110933800000203e+04 1.531270533641495376e+03 2.433364149533190357e-02 1.531246200000000044e+03 1.531294867282990708e+03 +4.774353312800000276e+04 1.535466257866018395e+03 3.423286601832842280e-02 1.535432025000000067e+03 1.535500490732036724e+03 +4.883041742700000032e+04 1.539663646105948374e+03 6.930810594838021643e-02 1.539594338000000107e+03 1.539732954211896867e+03 +4.992686155000000144e+04 1.543923408428574930e+03 3.122842857499108504e-02 1.543892180000000053e+03 1.543954636857150035e+03 +5.102876747299999988e+04 1.548193549000000075e+03 0.000000000000000000e+00 1.548193549000000075e+03 1.548193549000000075e+03 diff --git a/examples/example_13/dcci-fcc-solid-1340-0/dcci.backward_1.dat b/examples/example_13/dcci-fcc-solid-1340-0/dcci.backward_1.dat new file mode 100644 index 00000000..260b2e02 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0/dcci.backward_1.dat @@ -0,0 +1,55 @@ +# dynamic Clausius-Clapeyron backward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 500 0.8678961541 1543.963519 43333.333333 49929.168517 -3.33072000 -3.20666000 12.328600 12.894200 259.639705 +1 1000 0.8702697421 1539.752487 42500.000000 48835.433365 -3.33243000 -3.21548000 12.329300 12.863000 259.731213 +2 1500 0.8726742828 1535.509899 41666.666667 47745.954574 -3.32764000 -3.21146000 12.359000 12.896100 256.792427 +3 2000 0.8750726769 1531.301383 40833.333333 46662.790885 -3.33178000 -3.21283000 12.348200 12.896700 257.375655 +4 2500 0.8774636808 1527.128734 40000.000000 45585.932360 -3.33007000 -3.22437000 12.370600 12.856500 258.077059 +5 3000 0.8798936310 1522.911353 39166.666667 44512.956209 -3.33590000 -3.20989000 12.351000 12.939700 254.413372 +6 3500 0.8823101536 1518.740314 38333.333333 43446.551282 -3.33538000 -3.20839000 12.365800 12.955800 255.671270 +7 4000 0.8847484020 1514.554869 37500.000000 42384.931031 -3.33177000 -3.20909000 12.387600 12.962700 253.643586 +8 4500 0.8871870555 1510.391739 36666.666667 41329.127200 -3.32952000 -3.21424000 12.407000 12.947500 253.608800 +9 5000 0.8896547804 1506.202214 35833.333333 40277.795525 -3.32747000 -3.20615000 12.427400 13.003000 250.939901 +10 5500 0.8920293246 1502.192768 35000.000000 39236.378262 -3.33840000 -3.21946000 12.386900 12.929900 259.753735 +11 6000 0.8945146634 1498.019043 34166.666667 38195.759181 -3.32906000 -3.21289000 12.438200 12.993300 249.312977 +12 6500 0.8970019002 1493.865286 33333.333333 37160.828004 -3.33252000 -3.21280000 12.433200 13.005700 249.155859 +13 7000 0.8994466649 1489.804846 32500.000000 36133.326485 -3.33327000 -3.21347000 12.437600 13.000700 253.057806 +14 7500 0.9018913742 1485.766511 31666.666667 35111.397639 -3.33178000 -3.21736000 12.454600 12.992400 253.057468 +15 8000 0.9043776259 1481.681945 30833.333333 34093.427843 -3.33608000 -3.21489000 12.441800 13.021100 249.218897 +16 8500 0.9068511605 1477.640497 30000.000000 33081.503675 -3.33314000 -3.21671000 12.468100 13.021800 250.388720 +17 9000 0.9093292061 1473.613726 29166.666667 32074.925638 -3.33287000 -3.21852000 12.474900 13.019700 249.971465 +18 9500 0.9118691104 1469.509148 28333.333333 31071.710851 -3.33135000 -3.21272000 12.489000 13.068300 244.406731 +19 10000 0.9143813308 1465.471740 27500.000000 30074.979742 -3.33603000 -3.21160000 12.479600 13.080600 246.878145 +20 10500 0.9168572842 1461.514265 26666.666667 29084.860998 -3.33256000 -3.21700000 12.506100 13.056200 250.194710 +21 11000 0.9193386558 1457.569517 25833.333333 28099.909833 -3.33437000 -3.22032000 12.508000 13.052100 249.686682 +22 11500 0.9218387033 1453.616555 25000.000000 27119.711844 -3.33870000 -3.20942000 12.493100 13.114500 247.963805 +23 12000 0.9243994887 1449.589724 24166.666667 26143.098261 -3.33279000 -3.20290000 12.533200 13.172700 242.519791 +24 12500 0.9269116749 1445.660936 23333.333333 25173.200387 -3.33631000 -3.21134000 12.522700 13.126300 246.876039 +25 13000 0.9294437458 1441.722542 22500.000000 24208.027760 -3.33105000 -3.21156000 12.558400 13.140100 245.065649 +26 13500 0.9319836970 1437.793391 21666.666667 23247.903087 -3.32516000 -3.20901000 12.593000 13.160200 244.358887 +27 14000 0.9345411148 1433.858798 20833.333333 22292.580822 -3.33846000 -3.21448000 12.535800 13.145400 242.799259 +28 14500 0.9370970577 1429.947932 20000.000000 21342.506451 -3.33492000 -3.21736000 12.561700 13.139400 242.932662 +29 15000 0.9396792275 1426.018540 19166.666667 20397.031356 -3.33713000 -3.21315000 12.558600 13.174100 240.613672 +30 15500 0.9422494285 1422.128748 18333.333333 19456.985356 -3.33841000 -3.19995000 12.564300 13.248500 241.672082 +31 16000 0.9447792497 1418.320735 17500.000000 18522.845422 -3.33320000 -3.21163000 12.595300 13.186600 245.314607 +32 16500 0.9473373680 1414.490809 16666.666667 17593.169265 -3.32995000 -3.21188000 12.626000 13.206700 242.737216 +33 17000 0.9499013743 1410.672767 15833.333333 16668.397121 -3.33604000 -3.21603000 12.599700 13.191300 242.211006 +34 17500 0.9524871870 1406.843072 15000.000000 15748.243340 -3.33674000 -3.21036000 12.605900 13.234200 240.266159 +35 18000 0.9550919414 1403.006289 14166.666667 14832.777927 -3.33259000 -3.21282000 12.637000 13.236800 238.600770 +36 18500 0.9576843980 1399.208343 13333.333333 13922.471078 -3.33386000 -3.20975000 12.638700 13.257300 239.686152 +37 19000 0.9602392189 1395.485597 12500.000000 13017.589527 -3.32982000 -3.21003000 12.667400 13.255800 243.073461 +38 19500 0.9628390719 1391.717515 11666.666667 12116.943535 -3.34419000 -3.21011000 12.602300 13.272500 239.014875 +39 20000 0.9654977606 1387.885146 10833.333333 11220.464485 -3.32768000 -3.20271000 12.690900 13.329700 233.916767 +40 20500 0.9681003198 1384.154072 10000.000000 10329.508002 -3.33511000 -3.21386000 12.665500 13.272200 238.801018 +41 21000 0.9706966271 1380.451897 9166.666667 9443.389840 -3.33387000 -3.21351000 12.678100 13.278900 239.351978 +42 21500 0.9733257921 1376.722995 8333.333333 8561.710170 -3.33427000 -3.21215000 12.685600 13.302900 236.441533 +43 22000 0.9759704083 1372.992448 7500.000000 7684.659223 -3.33520000 -3.20927000 12.689700 13.330000 235.098594 +44 22500 0.9785682680 1369.347488 6666.666667 6812.674072 -3.33522000 -3.21313000 12.698000 13.307800 239.236553 +45 23000 0.9812100666 1365.660673 5833.333333 5945.040243 -3.33593000 -3.20833000 12.699800 13.347900 235.329714 +46 23500 0.9838699020 1361.968688 5000.000000 5081.972718 -3.33854000 -3.21028000 12.696100 13.352000 233.766510 +47 24000 0.9865402082 1358.282196 4166.666667 4223.514290 -3.32763000 -3.21006000 12.758400 13.362000 232.865170 +48 24500 0.9891977214 1354.633124 3333.333333 3369.734140 -3.34482000 -3.21361000 12.678100 13.348500 233.974025 +49 25000 0.9918699995 1350.983496 2500.000000 2520.491598 -3.33070000 -3.21201000 12.755800 13.365600 232.691781 +50 25500 0.9944972157 1347.414531 1666.666667 1675.888721 -3.33336000 -3.22283000 12.756100 13.314400 236.658058 +51 26000 0.9971500469 1343.829852 833.333333 835.715082 -3.33530000 -3.21474000 12.752000 13.366900 234.376522 +52 26500 0.9998446846 1340.208155 0.000000 0.000000 -3.32999000 -3.20744000 12.785700 13.420600 230.748108 diff --git a/examples/example_13/dcci-fcc-solid-1340-0/dcci.forward_1.dat b/examples/example_13/dcci-fcc-solid-1340-0/dcci.forward_1.dat new file mode 100644 index 00000000..204dc4b1 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0/dcci.forward_1.dat @@ -0,0 +1,55 @@ +# dynamic Clausius-Clapeyron forward sweep, iteration 1; T0 = 1340.0000 K +# block step lambda T[K] P_RS[bar] P[bar] u_solid[eV/atom] u_liquid[eV/atom] v_solid[A^3/atom] v_liquid[A^3/atom] dPdT[bar/K] +0 500 0.9973217105 1343.598546 833.333333 835.571235 -3.34079000 -3.21153000 12.733400 13.399000 232.507854 +1 1000 0.9946332070 1347.230306 1666.666667 1675.659585 -3.32867000 -3.21621000 12.784000 13.365300 231.317714 +2 1500 0.9919546360 1350.868227 2500.000000 2520.276542 -3.33850000 -3.21638000 12.728100 13.357000 232.168430 +3 2000 0.9893411487 1354.436740 3333.333333 3369.245621 -3.33783000 -3.22457000 12.722200 13.291300 237.897245 +4 2500 0.9866504130 1358.130481 4166.666667 4223.042540 -3.33731000 -3.21638000 12.718100 13.343700 231.155292 +5 3000 0.9840015142 1361.786522 5000.000000 5081.292994 -3.33609000 -3.21810000 12.716400 13.317300 234.742940 +6 3500 0.9813411872 1365.478202 5833.333333 5944.245905 -3.33310000 -3.20154000 12.723500 13.396400 233.756782 +7 4000 0.9786488197 1369.234779 6666.666667 6812.113326 -3.33024000 -3.20324000 12.726100 13.383500 231.029158 +8 4500 0.9760063467 1372.941892 7500.000000 7684.376260 -3.33401000 -3.21406000 12.700500 13.309900 235.287902 +9 5000 0.9733638006 1376.669236 8333.333333 8561.375847 -3.33627000 -3.20288000 12.685500 13.363200 235.287316 +10 5500 0.9707247410 1380.411916 9166.666667 9443.116344 -3.32693000 -3.20377000 12.723300 13.348200 235.589656 +11 6000 0.9680992407 1384.155615 10000.000000 10329.519516 -3.33799000 -3.20415000 12.658800 13.334400 236.769906 +12 6500 0.9654690197 1387.926461 10833.333333 11220.798505 -3.33200000 -3.21248000 12.680500 13.284900 236.360448 +13 7000 0.9628848160 1391.651398 11666.666667 12116.367891 -3.33611000 -3.21736000 12.648400 13.238400 240.419174 +14 7500 0.9602982260 1395.399850 12500.000000 13016.789641 -3.34224000 -3.22183000 12.612500 13.211300 240.211274 +15 8000 0.9577027899 1399.181473 13333.333333 13922.203709 -3.33740000 -3.22221000 12.627100 13.201900 239.425072 +16 8500 0.9551497763 1402.921336 14166.666667 14831.879794 -3.33241000 -3.22099000 12.644900 13.191800 243.231893 +17 9000 0.9525463906 1406.755632 15000.000000 15747.264541 -3.33368000 -3.21105000 12.629300 13.243100 238.741506 +18 9500 0.9499641374 1410.579565 15833.333333 16667.295860 -3.34119000 -3.20674000 12.586600 13.254100 240.594984 +19 10000 0.9473764685 1414.432429 16666.666667 17592.443153 -3.33764000 -3.21724000 12.591400 13.190400 240.119295 +20 10500 0.9448340784 1418.238430 17500.000000 18521.770541 -3.33020000 -3.20606000 12.624800 13.231600 244.168083 +21 11000 0.9422171143 1422.177521 18333.333333 19457.652653 -3.33033000 -3.20456000 12.614000 13.246800 237.596511 +22 11500 0.9396593973 1426.048634 19166.666667 20397.461806 -3.33619000 -3.21680000 12.576400 13.163500 242.767085 +23 12000 0.9370764332 1429.979405 20000.000000 21342.976189 -3.33155000 -3.21230000 12.586200 13.178400 240.544165 +24 12500 0.9345212070 1433.889344 20833.333333 22293.055714 -3.33197000 -3.20481000 12.577100 13.201800 242.986796 +25 13000 0.9320080077 1437.755887 21666.666667 23247.296685 -3.33813000 -3.20725000 12.542400 13.174800 246.788462 +26 13500 0.9295091445 1441.621105 22500.000000 24206.324525 -3.33561000 -3.21499000 12.546200 13.125700 248.115033 +27 14000 0.9270162643 1445.497832 23333.333333 25170.360252 -3.33245000 -3.22070000 12.552500 13.088100 248.671188 +28 14500 0.9244998032 1449.432434 24166.666667 26140.261560 -3.33769000 -3.21626000 12.516800 13.104300 246.507758 +29 15000 0.9219765308 1453.399252 25000.000000 27115.657682 -3.34016000 -3.21846000 12.494900 13.085300 245.889026 +30 15500 0.9194386370 1457.411018 25833.333333 28096.854206 -3.33664000 -3.21435000 12.503000 13.099700 244.580758 +31 16000 0.9169267754 1461.403501 26666.666667 29082.656742 -3.33900000 -3.21478000 12.484600 13.084500 246.910751 +32 16500 0.9144159976 1465.416182 27500.000000 30073.839556 -3.33408000 -3.21049000 12.496800 13.093400 247.011790 +33 17000 0.9119273255 1469.415339 28333.333333 31069.727315 -3.33543000 -3.21162000 12.482500 13.074900 249.021016 +34 17500 0.9094362382 1473.440296 29166.666667 32071.150721 -3.33237000 -3.21319000 12.490500 13.061300 248.803302 +35 18000 0.9069256921 1477.519064 30000.000000 33078.785024 -3.33201000 -3.20383000 12.482000 13.100700 247.045507 +36 18500 0.9044547442 1481.555610 30833.333333 34090.520869 -3.33936000 -3.20580000 12.437500 13.072000 250.638406 +37 19000 0.9019834672 1485.614813 31666.666667 35107.812745 -3.33085000 -3.21223000 12.467200 13.030800 250.613149 +38 19500 0.8995217836 1489.680433 32500.000000 36130.309009 -3.33404000 -3.21369000 12.444200 13.013800 251.496312 +39 20000 0.8970684680 1493.754432 33333.333333 37158.070449 -3.33064000 -3.21236000 12.451700 13.009600 252.271554 +40 20500 0.8946304067 1497.825236 34166.666667 38190.817583 -3.32738000 -3.21188000 12.459700 13.001100 253.693454 +41 21000 0.8921985235 1501.907888 35000.000000 39228.937368 -3.33139000 -3.21380000 12.429400 12.979200 254.274455 +42 21500 0.8897450102 1506.049469 35833.333333 40273.710920 -3.32421000 -3.21514000 12.450500 12.965000 252.266510 +43 22000 0.8873047905 1510.191328 36666.666667 41323.643308 -3.32317000 -3.21406000 12.447400 12.959300 253.490741 +44 22500 0.8848935632 1514.306416 37500.000000 42377.978052 -3.33105000 -3.21681000 12.400400 12.930000 256.207554 +45 23000 0.8824361697 1518.523431 38333.333333 43440.346904 -3.33292000 -3.20982000 12.382500 12.964100 251.929707 +46 23500 0.8799600597 1522.796387 39166.666667 44509.595901 -3.32978000 -3.20217000 12.388400 12.995900 250.238070 +47 24000 0.8775124558 1527.043851 40000.000000 45583.398544 -3.33070000 -3.19967000 12.375300 12.991900 252.806179 +48 24500 0.8751042123 1531.246200 40833.333333 46661.109338 -3.32425000 -3.21043000 12.394800 12.921800 256.448603 +49 25000 0.8727185429 1535.432025 41666.666667 47743.533128 -3.33018000 -3.20702000 12.362100 12.927000 258.589209 +50 25500 0.8703591376 1539.594338 42500.000000 48830.417427 -3.33324000 -3.21411000 12.337300 12.877700 261.120946 +51 26000 0.8679362569 1543.892180 43333.333333 49926.861550 -3.33150000 -3.20304000 12.332200 12.930600 255.122526 +52 26500 0.8655248569 1548.193549 44166.666667 51028.767473 -3.33046000 -3.20732000 12.327500 12.898400 256.173440 diff --git a/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml b/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml new file mode 100644 index 00000000..1fac61b2 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml @@ -0,0 +1,118 @@ +calculations: +- alchemy_coupling: false + berendsen: + barostat_damping: 100.0 + thermostat_damping: 100.0 + composition_scaling: + output_chemical_composition: {} + restrictions: [] + dcci: + hysteresis_tolerance: 5.0 + integrator: euler + n_block_steps: 500 + n_check_blocks: 0 + stop_at_target_pressure: true + element: + - Cu + equilibration_control: null + execution_mode: executable + file_format: lammps-data + fix_potential_path: true + folder_prefix: null + inputfile: input.yaml + kernel: 0 + lammps_executable: null + lattice: /private/tmp/claude-501/-Users-smenon-Documents-Projects-projects-calphy-stable-calphy/b601b9bf-90db-47a1-aacf-55cdd80197ea/scratchpad/validation/dcci/dcci-fcc-solid-1340-0.0.data + lattice_constant: 3.615 + mass: + - 63.546 + materials_project: + conventional: true + target_natoms: 1500 + md: + barostat_damping: 0.1 + cmdargs: '' + init_commands: [] + n_cycles: 100 + n_every_steps: 10 + n_repeat_steps: 10 + n_small_steps: 10000 + seed: 2121331448 + thermostat_damping: 0.1 + timestep: 0.001 + melting_cycle: true + melting_temperature: + attempts: 5 + guess: null + step: 200 + mode: dcci + monte_carlo: + allow_all_swaps: true + forward_swap_types: [] + n_steps: 1 + n_swaps: 0 + reverse_swap_types: [] + use_custom_lammps: false + mpi_executable: null + n_elements: 1 + n_equilibration_steps: 10000 + n_iterations: 1 + n_print_steps: 0 + n_print_steps_equilibration: 0 + n_switching_steps: 30000 + nose_hoover: + barostat_damping: 0.1 + thermostat_damping: 0.1 + npt: true + pair_coeff: + - '* * /Users/smenon/Documents/Projects/projects-calphy-stable/calphy/tests/Cu01.eam.alloy + Cu' + pair_mode: null + pair_style: + - eam/alloy + phase_name: '' + phase_transition_detection: + mode: none + onset_fraction: 0.85 + prescan_steps: 20000 + potential_file: null + pressure: + - 0.0 + - 50000.0 + pressure_coupling: null + quantum_thermal_bath: + barostat_damping: 0.1 + f_max: 200.0 + n_f: 100 + thermostat_damping: 0.1 + queue: + commands: [] + cores: 4 + jobname: calphy + memory: 3GB + options: {} + queuename: '' + scheduler: local + walltime: '23:59:00' + reference_composition: 0.0 + reference_phase: solid + repeat: + - 5 + - 5 + - 5 + script_mode: false + spring_constants: null + temperature: 1340.0 + temperature_high: 0.0 + tolerance: + dissipation: 0.001 + lattice_constant: 0.0002 + liquid_fraction: 1.0 + pressure: 10.0 + solid_fraction: 0.0 + spring_constant: 0.1 + uhlenbeck_ford_model: + p: 50.0 + sigma: 1.5 + single_p: null + single_sigma: null diff --git a/examples/example_13/dcci-fcc-solid-1340-0/report.yaml b/examples/example_13/dcci-fcc-solid-1340-0/report.yaml new file mode 100644 index 00000000..75b75d9a --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0/report.yaml @@ -0,0 +1,20 @@ +average: + vol_atom_liquid: 13.404046514698337 + vol_atom_solid: 12.759807913666805 +input: + element: Cu + lattice: fcc + n_block_steps: 500 + n_iterations: 1 + pressure: 0.0 + pressure_stop: 50000.0 + temperature: 1340.0 +results: + coexistence_line: coexistence_line.dat + error_at_pressure_reached: 0.0 + hysteresis: 0.2081550000000334 + hysteresis_high: false + n_blocks_used: 53 + pressure_reached: 51028.767473 + temperature_at_pressure_reached: 1548.193549 + unit: K, bar diff --git a/examples/example_13/input.yaml b/examples/example_13/input.yaml new file mode 100644 index 00000000..8c9742e0 --- /dev/null +++ b/examples/example_13/input.yaml @@ -0,0 +1,25 @@ +# Dynamic Clausius-Clapeyron integration: the melting line of Cu (Mishin Cu01) +# from a known melting point at 0 bar to 50 kbar, out and back. +# +# The starting temperature is the result of a melting_temperature calculation +# at 0 bar (example 04); see the notebook for the comparison with independent +# melting_temperature runs at the end points. +calculations: +- mode: dcci + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + temperature: 1340.0 + pressure: [0.0, 50000.0] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 30000 + n_iterations: 1 + dcci: + n_block_steps: 500 + queue: + scheduler: local + cores: 4 diff --git a/examples/example_13/input_converged.yaml b/examples/example_13/input_converged.yaml new file mode 100644 index 00000000..5fede24f --- /dev/null +++ b/examples/example_13/input_converged.yaml @@ -0,0 +1,25 @@ +# Dynamic Clausius-Clapeyron integration: the melting line of Cu (Mishin Cu01) +# from a known melting point at 0 bar to 100 kbar with 200 blocks of 500 steps (the converged line of the notebook). +# +# The starting temperature is the result of a melting_temperature calculation +# at 0 bar (example 04); see the notebook for the comparison with independent +# melting_temperature runs at the end points. +calculations: +- mode: dcci + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + temperature: 1340.0 + pressure: [0.0, 100000.0] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 100000 + n_iterations: 1 + dcci: + n_block_steps: 500 + queue: + scheduler: local + cores: 4 diff --git a/examples/example_13/input_high.yaml b/examples/example_13/input_high.yaml new file mode 100644 index 00000000..74fa2020 --- /dev/null +++ b/examples/example_13/input_high.yaml @@ -0,0 +1,25 @@ +# Dynamic Clausius-Clapeyron integration: the melting line of Cu (Mishin Cu01) +# from a known melting point at 0 bar to 1.5 Mbar, out and back (the second line in the notebook). +# +# The starting temperature is the result of a melting_temperature calculation +# at 0 bar (example 04); see the notebook for the comparison with independent +# melting_temperature runs at the end points. +calculations: +- mode: dcci + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + temperature: 1340.0 + pressure: [0.0, 1500000.0] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 100000 + n_iterations: 1 + dcci: + n_block_steps: 1000 + queue: + scheduler: local + cores: 4 diff --git a/examples/example_13/melting_line.png b/examples/example_13/melting_line.png new file mode 100644 index 00000000..a4d5809e Binary files /dev/null and b/examples/example_13/melting_line.png differ diff --git a/examples/example_13/melting_temperature_reference.yaml b/examples/example_13/melting_temperature_reference.yaml new file mode 100644 index 00000000..33111069 --- /dev/null +++ b/examples/example_13/melting_temperature_reference.yaml @@ -0,0 +1,36 @@ +# Independent melting points of Cu (Mishin Cu01, 500-atom cells) used to check +# the dynamic Clausius-Clapeyron line. Two kinds: +# method: melting_temperature -- mode melting_temperature (fe + reversible +# scaling of both phases, 10000 equilibration / 30000 switching steps, +# one iteration; the mode reports no error bar for a single iteration) +# method: fe_crossing -- direct fe of both phases at two temperatures +# bracketing the melting point (two iterations each), crossing of +# G_liquid - G_solid; error from the fe error bars. +- pressure: 0.0 + tm: 1340.6 + tm_error: 0.0 + method: melting_temperature +- pressure: 50000.0 + tm: 1564.9 + tm_error: 0.0 + method: melting_temperature +- pressure: 100000.0 + tm: 1776.3 + tm_error: 0.0 + method: melting_temperature +- pressure: 500000.0 + tm: 2912.9 + tm_error: 0.0 + method: melting_temperature +- pressure: 0.0 + tm: 1353.3 + tm_error: 1.9 + method: fe_crossing +- pressure: 50000.0 + tm: 1559.9 + tm_error: 1.6 + method: fe_crossing +- pressure: 100000.0 + tm: 1749.2 + tm_error: 3.4 + method: fe_crossing diff --git a/examples/example_13/tm.input.0kbar.yaml b/examples/example_13/tm.input.0kbar.yaml new file mode 100644 index 00000000..ae501a9a --- /dev/null +++ b/examples/example_13/tm.input.0kbar.yaml @@ -0,0 +1,17 @@ +calculations: +- mode: melting_temperature + temperature: 1340.0 + pressure: 0.0 + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 30000 + n_iterations: 1 + queue: + scheduler: local + cores: 4 diff --git a/examples/example_13/tm.input.50kbar.yaml b/examples/example_13/tm.input.50kbar.yaml new file mode 100644 index 00000000..e552fd9e --- /dev/null +++ b/examples/example_13/tm.input.50kbar.yaml @@ -0,0 +1,17 @@ +calculations: +- mode: melting_temperature + temperature: 1540.0 + pressure: 50000.0 + element: Cu + mass: 63.546 + lattice: FCC + lattice_constant: 3.615 + repeat: [5, 5, 5] + pair_style: eam/alloy + pair_coeff: '* * ../potentials/Cu01.eam.alloy Cu' + n_equilibration_steps: 10000 + n_switching_steps: 30000 + n_iterations: 1 + queue: + scheduler: local + cores: 4 diff --git a/pyproject.toml b/pyproject.toml index dd912efb..93735dfb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "calphy" -version = "2.2.1" +version = "2.3.0" description = "free energy calculation for python" readme = "README.md" license = "LicenseRef-ASL-1.0" diff --git a/tests/test_command_vocabulary.py b/tests/test_command_vocabulary.py index a30f61fa..638e9b76 100644 --- a/tests/test_command_vocabulary.py +++ b/tests/test_command_vocabulary.py @@ -21,7 +21,7 @@ "variable", "fix", "fix_modify", "thermo", "thermo_style", "echo", "dump", } ONE_SHOT = { - "run", "velocity", "displace_atoms", "change_box", + "run", "velocity", "displace_atoms", "change_box", "reset_timestep", "read_data", "read_restart", "write_data", "write_restart", "print", } REMOVAL = {"undump", "unfix", "uncompute"} diff --git a/tests/test_dcci_driver.py b/tests/test_dcci_driver.py new file mode 100644 index 00000000..5f66b713 --- /dev/null +++ b/tests/test_dcci_driver.py @@ -0,0 +1,308 @@ +"""The d-CCI block loop driven against a fake LAMMPS runner. + +The runner records every command and answers ``read_timeseries`` with synthetic +block averages for a system whose solid and liquid differ by constant du and dv, +so the integrated line can be checked against the analytic solution and the +emitted command stream against the design (one ramping fix npt per sweep, +``run n start 0 stop N`` blocks, lambda redefined per block). +""" +import os + +import numpy as np +import pytest +import yaml + +import calphy.helpers as ph +from calphy.dcci import DynamicCCI, cce_slope +from calphy.input import Calculation +from calphy.integrators import EV_A3_TO_BAR +from calphy.liquid import Liquid +from calphy.solid import Solid + +HERE = os.path.dirname(os.path.abspath(__file__)) + +T0 = 1300.0 +P0, P1 = 0.0, 100000.0 +N_BLOCK, N_SWEEP = 500, 2000 +U_S, U_L, V_S, V_L = -3.0, -2.9, 12.0, 12.6 + +BASE = dict( + element=["Cu"], mass=[63.546], mode="dcci", temperature=T0, + pressure=[P0, P1], lattice="FCC", lattice_constant=3.615, repeat=[2, 2, 2], + pair_style="eam/alloy", pair_coeff="* * %s Cu" % os.path.join(HERE, "Cu01.eam.alloy"), + n_equilibration_steps=100, n_switching_steps=N_SWEEP, + dcci={"n_block_steps": N_BLOCK, "stop_at_target_pressure": False}, +) + + +class FakeRunner: + """Records commands; synthesises ave/time rows from the lambda ramps it saw.""" + + def __init__(self, directory): + self.directory = directory + self.commands = [] + self.blocks = [] # (lam_start, lam_end) per block run + self._pending = None + self.closed = False + + def command(self, s): + cmd = " ".join(s.split()) + self.commands.append(cmd) + t = cmd.split() + if t[:3] == ["variable", "lam", "equal"] and "step" in t[3]: + a, rest = t[3].split("+(", 1) + b = rest.split(")")[0] + self._pending = (float(a), float(a) + float(b)) + elif t[0] == "run" and self._pending is not None and "start" in t: + self.blocks.append(self._pending) + + def sync(self): + pass + + def close(self): + self.closed = True + + def rotate_logs(self, name): + pass + + def read_timeseries(self, name, usecols=None): + phase = os.path.basename(self.directory) + u, v = (U_S, V_S) if phase == "solid" else (U_L, V_L) + rows = [] + for k, (l0, l1) in enumerate(self.blocks): + rows.append([(k + 1) * N_BLOCK, u, v, 0.5 * (l0 + l1)]) + return np.array(rows) + + +@pytest.fixture +def driver(tmp_path, monkeypatch, request): + monkeypatch.chdir(tmp_path) + runners = {} + overrides = getattr(request, "param", {}) + + def fake_create_object(calc, directory): + r = FakeRunner(directory) + runners.setdefault(os.path.basename(directory), []).append(r) + return r + + def fake_averaging(self): + self.lx = self.ly = self.lz = 14.46 + self.volatom = self.lx**3 / self.natoms + open(os.path.join(self.simfolder, "conf.equilibration.data"), "w").close() + + def fake_solid_fraction(path): + # the solid stays solid, the liquid stays liquid + return 10**6 if "/solid/" in path else 0 + + monkeypatch.setattr(ph, "create_object", fake_create_object) + monkeypatch.setattr(Solid, "run_averaging", fake_averaging) + monkeypatch.setattr(Liquid, "run_averaging", fake_averaging) + monkeypatch.setattr(ph, "find_solid_fraction", fake_solid_fraction) + + data = {**BASE, **overrides} + if "dcci" in overrides: + data["dcci"] = {**BASE["dcci"], **overrides["dcci"]} + calc = Calculation(**data) + simfolder = calc.create_folders() + job = DynamicCCI(calculation=calc, simfolder=simfolder) + job.runners = runners + return job + + +def test_forward_sweep_integrates_the_analytic_line(driver): + job = driver + job.prepare_cells() + job.equilibrate_cells() + state = job.run_sweep("forward", iteration=1) + + n_blocks = N_SWEEP // N_BLOCK + assert state.n_blocks == n_blocks + assert state.p_rs == pytest.approx(P1) + + data = np.loadtxt(os.path.join(job.simfolder, "dcci.forward_1.dat")) + assert data.shape == (n_blocks, 11) + lam, temp, p_rs, p_real = data[:, 2], data[:, 3], data[:, 4], data[:, 5] + # constant du, dv: lambda is linear in P_RS with the analytic slope + f = cce_slope(U_S, U_L, V_S, V_L) + h = (P1 - P0) / n_blocks / EV_A3_TO_BAR + assert lam == pytest.approx(1.0 + f * h * np.arange(1, n_blocks + 1)) + assert temp == pytest.approx(T0 / lam) + assert p_real == pytest.approx(p_rs / lam) + assert np.all(np.diff(temp) > 0) and np.all(np.diff(p_real) > 0) + # the diagnostic slope of the produced line matches the finite-difference one + dpdt = data[:, 10] + fd = np.gradient(p_real, temp) + assert np.allclose(dpdt[1:-1], fd[1:-1], rtol=0.05) + assert state.lam == pytest.approx(lam[-1]) + + for phase in ("solid", "liquid"): + (run,) = job.runners[phase] + cmds = run.commands + npt = [c for c in cmds if " npt " in c] + assert len(npt) == 2, npt + # equilibration at constant P_RS, then a single ramp for the whole sweep + assert npt[0].split()[-3:-1] == ["%f" % P0, "%f" % P0] + assert npt[1].split()[-3:-1] == ["%f" % P0, "%f" % P1] + blocks = [c for c in cmds if c.startswith("run ") and "start 0 stop %d" % N_SWEEP in c] + assert len(blocks) == n_blocks + assert cmds.count("reset_timestep 0") == 1 + assert any(c.startswith("pair_style hybrid/scaled v_lam") for c in cmds) + assert any(c.startswith("fix fav all ave/time 1 %d %d v_u_real v_vol_atom v_lam" % (N_BLOCK, N_BLOCK)) for c in cmds) + assert any(c.startswith("write_data") and "conf.dcci.forward_1.data" in c for c in cmds) + assert run.closed + # the lambda ramp of each block starts where the previous corrected value ended + starts = [b[0] for b in run.blocks] + assert starts == pytest.approx([1.0] + list(lam[:-1])) + + +def test_forward_sweep_stops_at_target_pressure(driver): + job = driver + job.calc.dcci.stop_at_target_pressure = True + job.prepare_cells() + job.equilibrate_cells() + # the ramp is applied to the scaled pressure; the real pressure P_RS/lambda + # runs ahead of it and reaches pressure[1] before the ramp does + state = job.run_sweep("forward", iteration=1) + data = np.atleast_2d(np.loadtxt(os.path.join(job.simfolder, "dcci.forward_1.dat"))) + assert state.n_blocks == data.shape[0] == 3 < N_SWEEP // N_BLOCK + assert data[-1, 5] >= P1 > data[-2, 5] + assert state.p_rs == pytest.approx(data[-1, 4]) and state.p_rs < P1 + (run,) = job.runners["solid"] + assert len([c for c in run.commands if c.startswith("run ") and "start 0" in c]) == 3 + + +def test_trapezoid_corrector(driver): + job = driver + job.calc.dcci.integrator = "trapezoid" + job.prepare_cells() + job.equilibrate_cells() + job.run_sweep("forward", iteration=1) + data = np.loadtxt(os.path.join(job.simfolder, "dcci.forward_1.dat")) + # constant slope: trapezoid and euler coincide + f = cce_slope(U_S, U_L, V_S, V_L) + h = (P1 - P0) / (N_SWEEP // N_BLOCK) / EV_A3_TO_BAR + assert data[:, 2] == pytest.approx(1.0 + f * h * np.arange(1, data.shape[0] + 1)) + + +def test_cells_are_built_at_the_starting_point(driver): + job = driver + job.prepare_cells() + for phase in ("solid", "liquid"): + c = job.jobs[phase].calc + assert c.reference_phase == phase + assert (c._pressure, c._pressure_stop) == (P0, P0) + assert c._temperature == T0 + assert c.tolerance.solid_fraction == 0.7 and c.tolerance.liquid_fraction == 0.05 + assert os.path.isdir(os.path.join(job.simfolder, phase)) + with open(os.path.join(job.simfolder, "input_file.yaml")) as fh: + assert yaml.safe_load(fh)["calculations"][0]["mode"] == "dcci" + + +def test_full_cycle_closes_and_reports(driver): + job = driver + job.calculate_coexistence_line() + + n_blocks = N_SWEEP // N_BLOCK + fwd = np.loadtxt(os.path.join(job.simfolder, "dcci.forward_1.dat")) + bwd = np.loadtxt(os.path.join(job.simfolder, "dcci.backward_1.dat")) + assert fwd.shape == bwd.shape == (n_blocks, 11) + # constant du, dv: the backward sweep retraces the forward one exactly + assert bwd[-1, 2] == pytest.approx(1.0) + assert bwd[-1, 4] == pytest.approx(P0) and bwd[-1, 5] == pytest.approx(P0) + assert bwd[:, 4][::-1] == pytest.approx(np.concatenate(([P0], fwd[:-1, 4]))) + + line = np.loadtxt(os.path.join(job.simfolder, "coexistence_line.dat")) + assert line.shape == (n_blocks + 1, 5) + assert line[0, :2] == pytest.approx([P0, T0]) + assert line[:, 1] == pytest.approx(np.concatenate(([T0], fwd[:, 3]))) + assert np.all(line[:, 2] < 1e-6) + assert job.hysteresis == pytest.approx(0.0, abs=1e-6) and not job.hysteresis_high + + with open(os.path.join(job.simfolder, "report.yaml")) as fh: + report = yaml.safe_load(fh) + assert report["results"]["hysteresis_high"] is False + assert report["results"]["pressure_reached"] == pytest.approx(line[-1, 0]) + assert report["results"]["temperature_at_pressure_reached"] == pytest.approx(line[-1, 1]) + assert report["results"]["n_blocks_used"] == n_blocks + assert report["input"]["pressure_stop"] == P1 + assert os.path.exists(os.path.join(job.simfolder, "metadata.yaml")) + assert os.path.exists(os.path.join(job.simfolder, "input_configuration.data")) + + # backward sessions start from the forward end configuration at its lambda + for phase in ("solid", "liquid"): + fwd_run, bwd_run = job.runners[phase] + assert any("conf.dcci.forward_1.data" in c and c.startswith("read_data") for c in bwd_run.commands) + first_lam = [c for c in bwd_run.commands if c.startswith("variable lam equal")][0] + assert float(first_lam.split()[3]) == pytest.approx(fwd[-1, 2]) + npt = [c for c in bwd_run.commands if " npt " in c] + assert npt[1].split()[-3:-1] == ["%f" % P1, "%f" % P0] + assert not any("remap" in c for c in bwd_run.commands) + assert any("velocity" in c for c in fwd_run.commands) + assert not any("velocity" in c for c in bwd_run.commands) + + +def test_integrate_dcci_hysteresis_and_error(tmp_path): + from calphy.dcci import integrate_dcci + + t0, p0 = 1000.0, 0.0 + cols = 11 + p_f = np.array([10000.0, 20000.0, 30000.0]) + t_f = np.array([1010.0, 1020.0, 1030.0]) + offset = 4.0 + for i in (1, 2): + fwd = np.zeros((3, cols)); fwd[:, 3] = t_f; fwd[:, 5] = p_f + # the backward sweep runs 2 K (iteration 1) / 6 K (iteration 2) hot + d = offset - 2.0 if i == 1 else offset + 2.0 + # backward rows at 20, 10, 0 kbar: the forward line there, shifted by d + bwd = np.zeros((3, cols)); bwd[:, 5] = p_f[::-1] - 10000.0 + bwd[:, 3] = np.interp(bwd[:, 5], [p0, *p_f], [t0, *t_f]) + d + np.savetxt(tmp_path / ("dcci.forward_%d.dat" % i), fwd) + np.savetxt(tmp_path / ("dcci.backward_%d.dat" % i), bwd) + + hyst, (p, t, err, tf, tb) = integrate_dcci(str(tmp_path), t0, p0, nsims=2, return_values=True) + assert hyst == pytest.approx(offset) + assert p == pytest.approx([p0, *p_f]) + assert tf == pytest.approx([t0, *t_f]) + # the backward sweep starts exactly where the forward one ended + shift = np.array([offset, offset, offset, 0.0]) + assert tb == pytest.approx(tf + shift) + assert t == pytest.approx(tf + shift / 2) + # half the hysteresis, plus the spread of the two iterations' means + stderr = np.array([np.std([s / 2 - 1.0, s / 2 + 1.0], ddof=1) / np.sqrt(2) if s else 0.0 for s in shift]) + assert err == pytest.approx(np.sqrt((shift / 2) ** 2 + stderr**2)) + assert os.path.exists(tmp_path / "coexistence_line.dat") + + +@pytest.mark.parametrize( + "driver", [{"dcci": {"parallel_cells": True}, "queue": {"cores": 4}}], indirect=True +) +def test_parallel_cells_give_the_same_line(driver): + """The cells only talk at block boundaries, so running them concurrently + must reproduce the sequential result exactly, with half the cores each.""" + job = driver + assert job.parallel and job.cell_cores == 2 + job.calculate_coexistence_line() + for phase in ("solid", "liquid"): + assert job.jobs[phase].calc.queue.cores == 2 + # both sweeps happened in each cell, run as one block per exchange + fwd_run, bwd_run = job.runners[phase] + assert len([c for c in fwd_run.commands if c.startswith("run ") and "start 0" in c]) == N_SWEEP // N_BLOCK + + n_blocks = N_SWEEP // N_BLOCK + fwd = np.loadtxt(os.path.join(job.simfolder, "dcci.forward_1.dat")) + f = cce_slope(U_S, U_L, V_S, V_L) + h = (P1 - P0) / n_blocks / EV_A3_TO_BAR + assert fwd[:, 2] == pytest.approx(1.0 + f * h * np.arange(1, n_blocks + 1)) + assert job.hysteresis == pytest.approx(0.0, abs=1e-6) + + +@pytest.mark.parametrize( + "driver", [{"dcci": {"parallel_cells": True}, "queue": {"cores": 1}}], indirect=True +) +def test_parallel_cells_falls_back_to_sequential_on_one_core(driver): + job = driver + assert not job.parallel and job.cell_cores == 1 + job.prepare_cells() + assert all(job.jobs[p].calc.queue.cores == 1 for p in ("solid", "liquid")) + with open(os.path.join(job.simfolder, "calphy.log")) as fh: + assert "parallel_cells needs queue.cores >= 2" in fh.read() diff --git a/tests/test_dcci_input.py b/tests/test_dcci_input.py new file mode 100644 index 00000000..abf41826 --- /dev/null +++ b/tests/test_dcci_input.py @@ -0,0 +1,117 @@ +"""Input validation and dispatch of ``mode: dcci``.""" +import os + +import pytest +from pydantic import ValidationError + +from calphy.input import Calculation +from calphy.runner import required_styles + +HERE = os.path.dirname(os.path.abspath(__file__)) + +BASE = dict( + element=["Cu"], mass=[63.546], mode="dcci", temperature=1350.0, + pressure=[0.0, 100000.0], lattice="FCC", lattice_constant=3.615, + pair_style="eam/alloy", pair_coeff="* * %s Cu" % os.path.join(HERE, "Cu01.eam.alloy"), +) + + +@pytest.fixture +def build(tmp_path, monkeypatch): + # structure generation during validation writes a data file into cwd + monkeypatch.chdir(tmp_path) + + def _build(**extra): + return Calculation(**{**BASE, **extra}) + + return _build + + +def error_of(build, **extra): + with pytest.raises(ValidationError) as ei: + build(**extra) + return str(ei.value) + + +def test_valid_dcci_input(build): + calc = build() + assert calc.mode == "dcci" + assert calc._temperature == 1350.0 and calc._temperature_stop == 1350.0 + assert (calc._pressure, calc._pressure_stop) == (0.0, 100000.0) + # the mode always builds a solid and a liquid cell; the value only names the folder + assert calc.reference_phase == "solid" + assert calc.create_identifier().startswith("dcci-") + assert calc.create_identifier().endswith("-solid-1350-0") + + +def test_dcci_block_defaults(build): + d = build().dcci + assert d.n_block_steps == 1000 + assert d.integrator == "euler" + assert d.stop_at_target_pressure is True + assert d.n_check_blocks == 0 + assert d.hysteresis_tolerance == 5.0 + assert d.parallel_cells is False + + +def test_dcci_block_overrides_and_hints(build): + calc = build(dcci={"n_block_steps": 200, "integrator": "trapezoid"}) + assert calc.dcci.n_block_steps == 200 and calc.dcci.integrator == "trapezoid" + assert "integrator" in error_of(build, dcci={"integrator": "rk4"}) + assert "did you mean 'n_block_steps'" in error_of(build, dcci={"n_block_step": 5}) + assert "n_block_steps" in error_of(build, dcci={"n_block_steps": 0}) + + +def test_dcci_parallel_cells_needs_two_cores(build): + from calphy.dcci import DynamicCCI + + calc = build(dcci={"parallel_cells": True}, queue={"cores": 4}) + job = DynamicCCI(calculation=calc, simfolder=calc.create_folders()) + assert job.parallel and job.cell_cores == 2 + + calc = build(dcci={"parallel_cells": True}, queue={"cores": 1}, folder_prefix="one") + job = DynamicCCI(calculation=calc, simfolder=calc.create_folders()) + assert not job.parallel and job.cell_cores == 1 + + calc = build(queue={"cores": 4}, folder_prefix="seq") + job = DynamicCCI(calculation=calc, simfolder=calc.create_folders()) + assert not job.parallel and job.cell_cores == 4 + + +def test_dcci_needs_pressure_range(build): + assert "pressure: [P_start, P_stop]" in error_of(build, pressure=0.0) + assert "pressure: [P_start, P_stop]" in error_of(build, pressure=[100000.0]) + + +def test_dcci_needs_explicit_coexistence_temperature(build): + assert "temperature: " in error_of(build, temperature=[1300.0, 1400.0]) + # the mendeleev melting-point guess is not a coexistence point of the potential + assert "temperature: " in error_of(build, temperature=0) + + +def test_dcci_rejects_swaps_and_nvt(build): + assert "monte_carlo swaps" in error_of(build, monte_carlo={"n_swaps": 10}) + assert "npt: True" in error_of(build, npt=False) + + +def test_dcci_requires_hybrid_scaled(build): + styles = required_styles(build()) + assert "hybrid/scaled" in styles["pair"] + assert {"npt", "ave/time"} <= styles["fix"] + + +def test_dcci_dispatch(build, tmp_path): + from calphy.dcci import DynamicCCI + from calphy.queuekernel import setup_calculation, run_calculation + + calc = build() + job = setup_calculation(calc) + assert isinstance(job, DynamicCCI) + assert os.path.isdir(job.simfolder) and job.simfolder.startswith(str(tmp_path)) + assert os.path.exists(os.path.join(job.simfolder, "input_file.yaml")) + assert (job.t0, job.p_start, job.p_stop) == (1350.0, 0.0, 100000.0) + + called = [] + job.calculate_coexistence_line = lambda: called.append(True) + run_calculation(job) + assert called == [True] diff --git a/tests/test_dcci_integrator.py b/tests/test_dcci_integrator.py new file mode 100644 index 00000000..82936247 --- /dev/null +++ b/tests/test_dcci_integrator.py @@ -0,0 +1,62 @@ +"""Pure numerics of the dynamic Clausius-Clapeyron driver (no LAMMPS).""" +import numpy as np +import pytest + +from calphy.dcci import ( + cce_slope, + clausius_clapeyron_slope, + lambda_ramp_command, + plan_blocks, +) +from calphy.integrators import EV_A3_TO_BAR + + +def test_cce_slope_sign_and_units(): + # normal melting: liquid has higher energy and larger volume + u_s, u_l, v_s, v_l = -3.0, -2.9, 12.0, 12.6 + f = cce_slope(u_s, u_l, v_s, v_l) + # d lambda / d P_RS = -(v_s - v_l)/(u_s - u_l) = -(-0.6)/(-0.1) = -6 A^3/eV + assert f == pytest.approx(-6.0) + # lambda falls (T rises) as the scaled pressure rises + assert f < 0 + with pytest.raises(ZeroDivisionError): + cce_slope(-3.0, -3.0, 12.0, 12.6) + + +def test_cce_slope_is_the_scaled_clausius_clapeyron_equation(): + """A linear coexistence line T(P) = T0 + s P with constant dH, dV is + reproduced by integrating d lambda / d P_RS from block averages taken at + the *scaled* state, i.e. the two slope functions agree with each other.""" + t0 = 1000.0 + u_s, u_l, v_s, v_l = -3.0, -2.85, 12.0, 12.5 + p_bar = 20000.0 + # real slope from dH/(T dV) + dpdt = clausius_clapeyron_slope(u_s, u_l, v_s, v_l, p_bar, t0) + dh = (u_l - u_s) + p_bar / EV_A3_TO_BAR * (v_l - v_s) + assert dpdt == pytest.approx(dh / (t0 * (v_l - v_s)) * EV_A3_TO_BAR) + # scaled form at lambda = 1: dP_RS = dP + P dlambda and dlambda = -dT/T0 + # => dlambda/dP_RS = -1/(T0 dP/dT - P) + f = cce_slope(u_s, u_l, v_s, v_l) + dpdt_ev = dpdt / EV_A3_TO_BAR + assert f == pytest.approx(-1.0 / (t0 * dpdt_ev - p_bar / EV_A3_TO_BAR)) + + +def test_clausius_clapeyron_slope_degenerate_volume(): + assert np.isnan(clausius_clapeyron_slope(-3.0, -2.9, 12.0, 12.0, 0.0, 1000.0)) + + +def test_lambda_ramp_command_is_replayable(): + cmd = lambda_ramp_command("lam", 0.9, 0.85, 3000, 1000) + tokens = cmd.split() + assert tokens[:3] == ["variable", "lam", "equal"] + expr = tokens[3] + assert "$(" not in expr and "v_" not in expr + # evaluate the expression at both ends of the block + for step, expected in ((3000, 0.9), (4000, 0.85)): + assert eval(expr.replace("step", str(step))) == pytest.approx(expected) + + +def test_plan_blocks(): + assert plan_blocks(50000, 1000) == 50 + assert plan_blocks(50001, 1000) == 51 + assert plan_blocks(10, 1000) == 1 diff --git a/tests/test_dcci_lammps_e2e.py b/tests/test_dcci_lammps_e2e.py new file mode 100644 index 00000000..fde772e6 --- /dev/null +++ b/tests/test_dcci_lammps_e2e.py @@ -0,0 +1,109 @@ +"""End-to-end ``mode: dcci`` on the real LAMMPS binary (DCCI_PLAN Part 3). + +Cu (Mishin Cu01), 500 atoms, from a rough coexistence point at 0 bar to 50 kbar +in six blocks of 500 steps, out and back. Deliberately tiny: it checks that +the whole mode runs, writes its files, produces a line with the right sign and +a slope consistent with dH/(T dV), and closes within a loose hysteresis bound. +The physics validation with converged settings lives in the example notebook. + +Marked ``lammps`` and ``slow``; skipped when no ``lmp`` binary resolves. +""" +import os +import glob +import sys +import subprocess + +import numpy as np +import pytest +import yaml + +from calphy.runner import resolve_lammps_executable + +HERE = os.path.dirname(os.path.abspath(__file__)) +REPO = os.path.dirname(HERE) + +try: + BINARY = resolve_lammps_executable(None) +except ValueError: + BINARY = None + +pytestmark = [ + pytest.mark.lammps, + pytest.mark.slow, + pytest.mark.skipif(BINARY is None, reason="no lmp binary resolves"), +] + +INPUT = { + "calculations": [ + { + "mode": "dcci", + "element": "Cu", + "mass": 63.546, + "lattice": "FCC", + "lattice_constant": 3.615, + "repeat": [5, 5, 5], + "temperature": 1340.0, + "pressure": [0.0, 50000.0], + "pair_style": "eam/alloy", + "pair_coeff": "* * %s Cu" % os.path.join(HERE, "Cu01.eam.alloy"), + "md": {"timestep": 0.001, "n_small_steps": 1000}, + "n_equilibration_steps": 2000, + "n_switching_steps": 3000, + "n_iterations": 1, + "dcci": {"n_block_steps": 500}, + "queue": {"scheduler": "local", "cores": 1}, + } + ] +} + + +@pytest.mark.parametrize("parallel", [False, True], ids=["sequential", "parallel_cells"]) +def test_dcci_cu_out_and_back(tmp_path, parallel): + import copy + + inp = copy.deepcopy(INPUT) + if parallel: + # two cells at once, one core each: exercises the threaded block loop + inp["calculations"][0]["dcci"]["parallel_cells"] = True + inp["calculations"][0]["queue"]["cores"] = 2 + with open(tmp_path / "input.yaml", "w") as fh: + yaml.safe_dump(inp, fh, sort_keys=False) + env = dict(os.environ, PYTHONPATH=REPO) + proc = subprocess.run( + [sys.executable, "-c", + "import sys; sys.argv=['calphy_kernel','-i','input.yaml','-k','0']; " + "from calphy.queuekernel import main; main()"], + cwd=str(tmp_path), capture_output=True, text=True, timeout=1500, env=env, + ) + assert proc.returncode == 0, proc.stdout[-2000:] + proc.stderr[-4000:] + + (folder,) = [d for d in glob.glob(str(tmp_path / "dcci-*")) if os.path.isdir(d)] + for name in ("coexistence_line.dat", "report.yaml", "metadata.yaml", + "dcci.forward_1.dat", "dcci.backward_1.dat", + "solid/conf.dcci.forward_1.data", "liquid/conf.dcci.backward_1.data", + "solid/dcci_forward_1.log.lammps", "liquid/dcci_backward_1.log.lammps"): + assert os.path.exists(os.path.join(folder, name)), name + + fwd = np.loadtxt(os.path.join(folder, "dcci.forward_1.dat")) + assert fwd.shape[0] >= 3 and np.all(np.isfinite(fwd)) + temp, p_real, dpdt = fwd[:, 3], fwd[:, 5], fwd[:, 10] + # copper melts at higher temperature under pressure + assert np.all(np.diff(temp) > 0) and np.all(np.diff(p_real) > 0) + assert p_real[-1] >= 50000.0 + # the produced line has the slope the block averages say it should + fd = np.gradient(p_real, temp) + assert np.allclose(dpdt[1:-1], fd[1:-1], rtol=0.3) + # of the right order for Cu (about 40 K/GPa, i.e. ~250 bar/K) + assert 150 < dpdt.mean() < 400 + + line = np.loadtxt(os.path.join(folder, "coexistence_line.dat")) + assert line.shape[0] == fwd.shape[0] + 1 + # the first point is the starting pressure; its temperature averages the + # forward start (T0 exactly) with where the backward sweep came back to + assert line[0, 0] == 0.0 and line[0, 3] == 1340.0 + assert abs(line[0, 1] - 1340.0) < 100.0 + with open(os.path.join(folder, "report.yaml")) as fh: + report = yaml.safe_load(fh) + # loose: six blocks of 500 steps is far from converged, but it must close + assert abs(report["results"]["hysteresis"]) < 100.0 + assert report["results"]["n_blocks_used"] == fwd.shape[0] diff --git a/tests/test_dcci_lammps_semantics.py b/tests/test_dcci_lammps_semantics.py new file mode 100644 index 00000000..ab3aa149 --- /dev/null +++ b/tests/test_dcci_lammps_semantics.py @@ -0,0 +1,220 @@ +"""LAMMPS semantics the dynamic Clausius-Clapeyron driver relies on (DCCI_PLAN Part 0). + +The d-CCI sweep is a Python block loop over two LAMMPS sessions. It needs three +things from LAMMPS that no other calphy mode exercises, checked here against the +real binary through the ExecutableRunner (one block = one segment): + +1. a single ``fix npt`` with a linear pressure ramp keeps following the *global* + sweep progress when the sweep is chopped into ``run n start 0 stop N`` blocks; +2. the ``hybrid/scaled`` scale variable can be redefined between runs and takes + effect immediately, also across a segment boundary; +3. ``fix ave/time 1 n n`` writes exactly one row per block after a restart. + +Marked ``lammps``; skipped when no ``lmp`` binary resolves. +""" +import os +import re +import glob + +import numpy as np +import pytest + +from calphy.runner import ExecutableRunner, resolve_lammps_executable, read_timeseries + +HERE = os.path.dirname(os.path.abspath(__file__)) +POT = os.path.join(HERE, "Cu01.eam.alloy") +CONF = os.path.join(HERE, "fixtures", "conf.equilibration.data") # Cu fcc, 500 atoms + +try: + BINARY = resolve_lammps_executable(None) +except ValueError: + BINARY = None + +pytestmark = [ + pytest.mark.lammps, + pytest.mark.skipif(BINARY is None, reason="no lmp binary resolves"), +] + +T = 500.0 +P0, P1 = 0.0, 100000.0 # bar +N_BLOCK, N_BLOCKS = 1000, 3 +N_TOTAL = N_BLOCK * N_BLOCKS + + +def make_runner(directory): + os.makedirs(str(directory), exist_ok=True) + return ExecutableRunner( + binary=BINARY, mpi_command=None, cores=1, cmdargs="", + directory=str(directory), dry_run=False, timeout=600, + ) + + +def boot(run, pair_style="pair_style eam/alloy", pair_coeff="pair_coeff * * %s Cu" % POT): + for c in [ + "units metal", "boundary p p p", "atom_style atomic", "timestep 0.001", + pair_style, "read_data %s" % CONF, pair_coeff, "mass 1 63.546", + ]: + run.command(c) + + +def seg_logs(directory): + return sorted( + glob.glob(os.path.join(str(directory), "calphy.seg*.log")), + key=lambda p: int(re.search(r"seg(\d+)", p).group(1)), + ) + + +def thermo_rows(directory): + """(step, col1, col2, ...) rows of every thermo table in every segment log.""" + rows = [] + for logpath in seg_logs(directory): + cols = None + with open(logpath) as fh: + for line in fh: + s = line.split() + if not s: + continue + if s[0] == "Step": + cols = s + continue + if cols is None: + continue + try: + rows.append([float(x) for x in s]) + except ValueError: + cols = None + return np.array(rows) + + +def printed(directory, tag): + vals = [] + for logpath in seg_logs(directory): + with open(logpath) as fh: + for line in fh: + if line.startswith(tag + " "): + vals.append([float(x) for x in line.split()[1:]]) + return vals + + +def _window_mean(rows, lo, hi, col=1): + sel = (rows[:, 0] > lo) & (rows[:, 0] <= hi) + assert sel.any(), "no thermo rows in (%d, %d]" % (lo, hi) + return rows[sel, col].mean() + + +def _ramped_npt(run): + run.command("velocity all create %f 4321 mom yes rot yes" % T) + run.command("fix 1 all npt temp %f %f 0.1 iso %f %f 0.1" % (T, T, P0, P1)) + run.command("thermo_style custom step press vol") + run.command("thermo 10") + + +# --------------------------------------------------------------------------- # +# 1. fix npt ramp under `run n start 0 stop N` blocks +# --------------------------------------------------------------------------- # +def test_npt_ramp_follows_global_progress_across_blocks(tmp_path): + # reference: the whole ramp in one run + ref = make_runner(tmp_path / "single") + boot(ref) + _ramped_npt(ref) + ref.command("run %d" % N_TOTAL) + ref.sync() + ref.close() + single = thermo_rows(tmp_path / "single") + + # blocks with start/stop: the target must keep ramping across segments + blk = make_runner(tmp_path / "blocks") + boot(blk) + _ramped_npt(blk) + for _ in range(N_BLOCKS): + blk.command("run %d start 0 stop %d" % (N_BLOCK, N_TOTAL)) + blk.sync() + blk.close() + blocks = thermo_rows(tmp_path / "blocks") + + # control without start/stop: every segment restarts the ramp from P0 + ctl = make_runner(tmp_path / "control") + boot(ctl) + _ramped_npt(ctl) + for _ in range(N_BLOCKS): + ctl.command("run %d" % N_BLOCK) + ctl.sync() + ctl.close() + control = thermo_rows(tmp_path / "control") + + assert blocks[:, 0].max() == N_TOTAL and blocks.shape[0] >= N_TOTAL // 10 + + # Right after the first boundary the target is ~1/3 of the way up the + # ramp; the control has just been reset to P0 and its pressure collapses. + lo, hi = N_BLOCK, N_BLOCK + 300 + p_single = _window_mean(single, lo, hi) + p_blocks = _window_mean(blocks, lo, hi) + p_control = _window_mean(control, lo, hi) + print("press (%d,%d]: single %.0f blocks %.0f control %.0f" % (lo, hi, p_single, p_blocks, p_control)) + assert abs(p_blocks - p_single) < 0.15 * P1 + assert p_control < 0.5 * p_single + + # and the end of the sweep reaches P1 in both + assert abs(_window_mean(blocks, N_TOTAL - 300, N_TOTAL) - P1) < 0.15 * P1 + assert abs(_window_mean(single, N_TOTAL - 300, N_TOTAL) - P1) < 0.15 * P1 + + +# --------------------------------------------------------------------------- # +# 2. hybrid/scaled picks up a redefined scale variable +# --------------------------------------------------------------------------- # +def test_hybrid_scaled_variable_redefinition(tmp_path): + run = make_runner(tmp_path) + run.command("variable lam equal 1.0") + boot( + run, + pair_style="pair_style hybrid/scaled v_lam eam/alloy", + pair_coeff="pair_coeff * * eam/alloy %s Cu" % POT, + ) + run.command("compute pr all pair eam/alloy") # unscaled sub-style energy + run.command("velocity all create %f 4321 mom yes rot yes" % T) + run.command("fix 1 all nvt temp %f %f 0.1" % (T, T)) + run.command("thermo_style custom step pe c_pr") + run.command("thermo 10") + run.command("run 20") + run.command('print "RATIO $(v_lam) $(pe/c_pr)"') + # redefinition inside one segment, with pre no / post no as the block loop + run.command("variable lam equal 0.5") + run.command("run 20 pre no post no") + run.command('print "RATIO $(v_lam) $(pe/c_pr)"') + run.sync() + # redefinition across a segment boundary (variable replayed, then replaced) + run.command("variable lam equal 0.25") + run.command("run 20") + run.command('print "RATIO $(v_lam) $(pe/c_pr)"') + run.sync() + run.close() + + ratios = printed(tmp_path, "RATIO") + assert [r[0] for r in ratios] == [1.0, 0.5, 0.25] + for lam, ratio in ratios: + assert ratio == pytest.approx(lam, rel=1e-6), ratios + + +# --------------------------------------------------------------------------- # +# 3. fix ave/time: one row per block, across restarts +# --------------------------------------------------------------------------- # +def test_ave_time_one_row_per_block(tmp_path): + run = make_runner(tmp_path) + boot(run) + run.command("velocity all create %f 4321 mom yes rot yes" % T) + run.command("fix 1 all npt temp %f %f 0.1 iso %f %f 0.1" % (T, T, P0, P0)) + run.command("variable pe_atom equal pe/atoms") + run.command("variable vol_atom equal vol/atoms") + run.command( + "fix fav all ave/time 1 %d %d v_pe_atom v_vol_atom file blocks.dat" + % (N_BLOCK, N_BLOCK) + ) + for _ in range(N_BLOCKS): + run.command("run %d start 0 stop %d" % (N_BLOCK, N_TOTAL)) + run.sync() + run.close() + + data = read_timeseries(str(tmp_path), "blocks.dat") + assert data.shape == (N_BLOCKS, 3), data + assert list(data[:, 0]) == [N_BLOCK * (k + 1) for k in range(N_BLOCKS)] + assert np.all(data[:, 1] < 0) and np.all(data[:, 2] > 10)