From 9db35438aab519e5faafde75a06cad136e7873fb Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 11:10:20 +0200 Subject: [PATCH 01/14] ts: ramp the scaled pressure lambda*P during the reversible-scaling sweeps The scaled system at (T0, lambda) samples the real system at (T0/lambda, P) only if the barostat imposes P_RS = lambda*P (de Koning, Antonelli, Yip, J. Chem. Phys. 115, 11025 (2001), Eq. 11), and integrate_rs assumes that when it integrates U + P V at constant P. Both sweeps computed pf = lf*pi and logged the ramp, but the fix that stayed active through the sweep was created with a constant target pi, so the sweep sampled the real system at P/lambda and the middle equilibration of the backward sweep sat at the wrong scaled pressure. fix npt can only ramp its target linearly over one run, so the constant pressure equilibration fix is now replaced right before each sweep by one ramping pi -> pf (forward) and pf -> pi (backward), with the COM-corrected temperature rebound to the new fix; the middle equilibration holds pf. Exactly a no-op at pressure 0, which is where the golden streams are recorded; they only gain the unfix/fix/fix_modify triple. Cross-check with a direct fe at the sweep endpoint (Cu01, 500 atoms, 2500/5000 steps): at 50 kbar 400 -> 700 K both old and new agree with fe within 0.5 meV/atom; at 300 kbar 400 -> 1000 K the old sweep ends at a real pressure of 750 kbar and is off by 30 meV/atom, the new one agrees within 0.3 meV/atom. --- calphy/phase.py | 55 ++++++++++++++++++++++--- tests/golden/ts_backward_solid.txt | 3 ++ tests/golden/ts_forward_solid.txt | 3 ++ tests/golden/ts_mc_swaps.txt | 3 ++ tests/golden/ts_uniform_temperature.txt | 3 ++ 5 files changed, 62 insertions(+), 5 deletions(-) diff --git a/calphy/phase.py b/calphy/phase.py index 4845573..0f36439 100644 --- a/calphy/phase.py +++ b/calphy/phase.py @@ -1435,13 +1435,47 @@ def _run_sweep( lmp.command("run %d" % n_sweep) lmp.command("unfix f3") + def _install_sweep_barostat(self, lmp, p_start, p_stop): + """ + Replace the COM-constrained NPT fix ``f1`` by one whose pressure target + ramps ``p_start`` → ``p_stop`` over the run that follows. + + The scaled system at (T0, λ) samples the real system at (T0/λ, P) only + if the barostat imposes the *scaled* pressure P_RS = λ·P (de Koning, + Antonelli and Yip, J. Chem. Phys. 115, 11025 (2001), Eq. 11), and + ``integrate_rs`` relies on exactly that when it integrates U + P·V at + the constant real pressure P. ``fix npt`` can only ramp its target + linearly over a single run, so the constant-pressure equilibration fix + has to be swapped for a ramping one right before the sweep; the + ``fix_modify`` binding the COM-corrected temperature has to be reissued + for the new fix. At ``pressure: 0`` the ramp is flat and the only + effect is a restart of the Nose-Hoover chain, as in ``pressure_scaling``. + + Parameters + ---------- + lmp : BaseRunner + Active LAMMPS runner with fix ``f1`` and compute ``tcm`` defined. + p_start, p_stop : float + Scaled pressure at the start and at the end of the sweep, in bar. + """ + t0 = self.calc._temperature + lmp.command("unfix f1") + lmp.command( + "fix f1 all npt temp %f %f %f %s %f %f %f " + "fixedpoint ${xcm} ${ycm} ${zcm}" + % (t0, t0, self.calc.md.thermostat_damping[1], + self.iso, p_start, p_stop, self.calc.md.barostat_damping[1]) + ) + lmp.command("fix_modify f1 temp tcm") + def _reversible_scaling_forward(self, iteration: int = 1) -> None: """ Perform the forward sweep of a reversible-scaling calculation. 1. Short NPT warm start at T0 (see :meth:`_warm_start_steps`). 2. COM-constrained equilibration at T0. - 3. Forward sweep: λ 1 → T0/Tf. + 3. Forward sweep: λ 1 → T0/Tf under the scaled pressure P_RS = λ·P, + i.e. the barostat ramps P → (T0/Tf)·P. 4. Write ``conf.ts.forward_{iteration}.data`` for the backward sweep. Parameters @@ -1542,6 +1576,10 @@ def _reversible_scaling_forward(self, iteration: int = 1) -> None: "forward sweep (iteration %d): COM-constrained equilibration done", iteration ) + # ── Sweep barostat: P_RS ramps pi → pf = lf·pi ───────────────────── + if self.calc.npt: + self._install_sweep_barostat(lmp, pi, pf) + # ---------------------------------------------------------------- # Lambda schedule for the forward sweep. # @@ -1664,8 +1702,9 @@ def _reversible_scaling_backward(self, iteration: int = 1) -> None: 1. Load ``conf.ts.forward_{iteration}.data`` written by the forward sweep. - 2. Middle equilibration at Tf. - 3. Backward sweep: λ T0/Tf → 1. + 2. Middle equilibration at Tf, i.e. at λ = T0/Tf and the scaled + pressure (T0/Tf)·P. + 3. Backward sweep: λ T0/Tf → 1, the scaled pressure ramping back to P. Parameters ---------- @@ -1716,7 +1755,9 @@ def _reversible_scaling_backward(self, iteration: int = 1) -> None: # scaled potential. Using a constant scaling variable (rather # than the ramp) keeps λ frozen at lf during this run. A single # copy of the potential scaled by lambda is used throughout the - # reversible-scaling stage (see _reversible_scaling_forward). + # reversible-scaling stage (see _reversible_scaling_forward). The + # barostat likewise holds the scaled pressure pf = lf·pi that the + # forward sweep ended at, see _install_sweep_barostat. lmp.command("variable lambda_eq equal %f" % lf) lmp.command(ph.scaled_pair_style_command(self.calc, ["v_lambda_eq"])) for cmd in ph.hybrid_pair_coeff_commands(self.calc): @@ -1731,7 +1772,7 @@ def _reversible_scaling_backward(self, iteration: int = 1) -> None: "fix f1 all npt temp %f %f %f %s %f %f %f " "fixedpoint ${xcm} ${ycm} ${zcm}" % (t0, t0, self.calc.md.thermostat_damping[1], - self.iso, pi, pi, self.calc.md.barostat_damping[1]) + self.iso, pf, pf, self.calc.md.barostat_damping[1]) ) else: lmp.command( @@ -1763,6 +1804,10 @@ def _reversible_scaling_backward(self, iteration: int = 1) -> None: else: self.check_if_solidfied(lmp, "traj.temp.dat") + # ── Sweep barostat: P_RS ramps pf = lf·pi → pi ───────────────────── + if self.calc.npt: + self._install_sweep_barostat(lmp, pf, pi) + # ── Switch from the constant-λ scaled potential to the ramping # scaled potential for the backward sweep: define the lambda # variables, then re-install hybrid/scaled driven by blambda. diff --git a/tests/golden/ts_backward_solid.txt b/tests/golden/ts_backward_solid.txt index f1dd625..6069c04 100644 --- a/tests/golden/ts_backward_solid.txt +++ b/tests/golden/ts_backward_solid.txt @@ -28,6 +28,9 @@ run 2500 dump 2 all custom 1 traj.temp.dat id type mass x y z vx vy vz run 0 undump 2 +unfix f1 +fix f1 all npt temp 400.000000 400.000000 0.100000 iso 0.000000 0.000000 0.100000 fixedpoint ${xcm} ${ycm} ${zcm} +fix_modify f1 temp tcm variable T0_rs equal 400.000000 variable flambda equal ramp(${li},${lf}) variable blambda equal ramp(${lf},${li}) diff --git a/tests/golden/ts_forward_solid.txt b/tests/golden/ts_forward_solid.txt index 6e13624..d3ada5f 100644 --- a/tests/golden/ts_forward_solid.txt +++ b/tests/golden/ts_forward_solid.txt @@ -26,6 +26,9 @@ thermo_style custom step pe c_tcm press vol thermo 10000 velocity all create 400.000000 7271 mom yes rot yes dist gaussian run 2500 +unfix f1 +fix f1 all npt temp 400.000000 400.000000 0.100000 iso 0.000000 0.000000 0.100000 fixedpoint ${xcm} ${ycm} ${zcm} +fix_modify f1 temp tcm variable T0_rs equal 400.000000 variable flambda equal ramp(${li},${lf}) variable blambda equal ramp(${lf},${li}) diff --git a/tests/golden/ts_mc_swaps.txt b/tests/golden/ts_mc_swaps.txt index e375fb7..878b7cd 100644 --- a/tests/golden/ts_mc_swaps.txt +++ b/tests/golden/ts_mc_swaps.txt @@ -26,6 +26,9 @@ thermo_style custom step pe c_tcm press vol thermo 10000 velocity all create 400.000000 7271 mom yes rot yes dist gaussian run 2500 +unfix f1 +fix f1 all npt temp 400.000000 400.000000 0.100000 iso 0.000000 0.000000 0.100000 fixedpoint ${xcm} ${ycm} ${zcm} +fix_modify f1 temp tcm variable T0_rs equal 400.000000 variable flambda equal ramp(${li},${lf}) variable blambda equal ramp(${lf},${li}) diff --git a/tests/golden/ts_uniform_temperature.txt b/tests/golden/ts_uniform_temperature.txt index f716626..f1c2dad 100644 --- a/tests/golden/ts_uniform_temperature.txt +++ b/tests/golden/ts_uniform_temperature.txt @@ -26,6 +26,9 @@ thermo_style custom step pe c_tcm press vol thermo 10000 velocity all create 400.000000 7271 mom yes rot yes dist gaussian run 2500 +unfix f1 +fix f1 all npt temp 400.000000 400.000000 0.100000 iso 0.000000 0.000000 0.100000 fixedpoint ${xcm} ${ycm} ${zcm} +fix_modify f1 temp tcm variable T0_rs equal 400.000000 variable Nsweep equal 5000 variable Tf_rs equal 700.000000 From d8914d918d721b5ffd4574f230457d31b0bc8fce Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 11:10:20 +0200 Subject: [PATCH 02/14] tscale, prescan: heat at constant real pressure and ramp Tf -> T0 backward temperature_scaling and scan_temperature_range ramp the real temperature with the thermostat; lambda = T0/T is only the recorded label. Both nevertheless ramped the barostat to (T0/Tf)*P, the scaled-pressure end point that belongs to the lambda-scaled Hamiltonian of reversible_scaling, and so sampled the wrong isobar at finite pressure (a no-op at 0 bar). The real pressure is now held throughout. Since "switch to stepped ts" (b286426) the tscale backward sweep was also created with temp T0 T0 instead of Tf T0, i.e. it quenched to T0 at the start of the sweep instead of mirroring the forward ramp, corrupting the backward integral at any pressure. Restored to Tf -> T0. --- calphy/phase.py | 24 +++++++++++++++--------- tests/golden/tscale.txt | 2 +- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/calphy/phase.py b/calphy/phase.py index 0f36439..318ce37 100644 --- a/calphy/phase.py +++ b/calphy/phase.py @@ -2041,12 +2041,14 @@ def scan_temperature_range(self): lmp.command("unfix 1") # ── Real-thermostat ramp T0 -> Tf, recording every step ───────────── - pf = (t0 / tf) * p0 + # The real system is heated, so the barostat holds the real pressure + # p0 throughout; the scaled-pressure ramp belongs to the λ-scaled + # sweep of _reversible_scaling_forward only. lmp.command("variable dU equal pe/atoms") lmp.command( "fix f2 all npt temp %f %f %f %s %f %f %f" % (t0, tf, self.calc.md.thermostat_damping[1], - self.iso, p0, pf, self.calc.md.barostat_damping[1]) + self.iso, p0, p0, self.calc.md.barostat_damping[1]) ) scan_file = "prescan.forward.dat" lmp.command( @@ -2200,8 +2202,11 @@ def temperature_scaling(self, iteration=1): tf = self.calc._temperature_stop li = 1 lf = t0 / tf + # The real temperature is ramped by the thermostat and λ = T0/T is only + # the recorded label, so the real pressure p0 is held fixed throughout; + # a scaled-pressure ramp would sample the wrong isobar (it belongs to + # the λ-scaled Hamiltonian of reversible_scaling, not here). p0 = self.calc._pressure - pf = lf * p0 # create lammps object lmp = ph.create_object(self.calc, self.simfolder) @@ -2253,7 +2258,7 @@ def temperature_scaling(self, iteration=1): self.calc.md.thermostat_damping[1], self.iso, p0, - pf, + p0, self.calc.md.barostat_damping[1], ) ) @@ -2279,8 +2284,8 @@ def temperature_scaling(self, iteration=1): tf, self.calc.md.thermostat_damping[1], self.iso, - pf, - pf, + p0, + p0, self.calc.md.barostat_damping[1], ) ) @@ -2300,18 +2305,19 @@ def temperature_scaling(self, iteration=1): else: self.check_if_solidfied(lmp, "traj.temp.dat") - # start reverse loop + # start reverse loop: the thermostat ramps Tf -> T0, mirroring the + # forward sweep lmp.command("variable lambda equal ramp(${lf},${li})") lmp.command( "fix f2 all npt temp %f %f %f %s %f %f %f" % ( - t0, + tf, t0, self.calc.md.thermostat_damping[1], self.iso, p0, - pf, + p0, self.calc.md.barostat_damping[1], ) ) diff --git a/tests/golden/tscale.txt b/tests/golden/tscale.txt index 0e1e9e6..ff01b24 100644 --- a/tests/golden/tscale.txt +++ b/tests/golden/tscale.txt @@ -32,7 +32,7 @@ dump 2 all custom 1 traj.temp.dat id type mass x y z vx vy vz run 0 undump 2 variable lambda equal ramp(${lf},${li}) -fix f2 all npt temp 400.000000 400.000000 0.100000 iso 0.000000 0.000000 0.100000 +fix f2 all npt temp 700.000000 400.000000 0.100000 iso 0.000000 0.000000 0.100000 fix f3 all print 1 "${dU} $(press) $(vol) ${lambda}" title "# dU[eV/atom] press[bar] vol[A^3] lambda" screen no file ts.backward_1.dat run 5000 unfix f3 From 3873cf8a5d5b8d6e799719e5d23e7dbc6a5c3892 Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 11:10:20 +0200 Subject: [PATCH 03/14] tests: pin the sweep barostat and thermostat targets at 50 kbar The golden streams are recorded at pressure 0, where the scaled and the real pressure coincide, so they cannot tell a ramped from a constant barostat. Record the same driver methods at 50 kbar and assert the targets directly: the ts sweeps ramp P <-> (T0/Tf)*P and the backward middle equilibration sits at (T0/Tf)*P; tscale and the pre-scan hold the real pressure and tscale ramps Tf -> T0 on the way back. --- tests/test_sweep_barostat_targets.py | 127 +++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 tests/test_sweep_barostat_targets.py diff --git a/tests/test_sweep_barostat_targets.py b/tests/test_sweep_barostat_targets.py new file mode 100644 index 0000000..7bd3abd --- /dev/null +++ b/tests/test_sweep_barostat_targets.py @@ -0,0 +1,127 @@ +"""Barostat and thermostat targets of the temperature-sweep fixes at finite pressure. + +Reversible scaling (mode ``ts``) samples the real system at (T0/lambda, P) only +when the barostat imposes the *scaled* pressure lambda*P (de Koning, Antonelli, +Yip, J. Chem. Phys. 115, 11025 (2001), Eq. 11) -- the sweep fix has to ramp +P -> (T0/Tf)*P and the middle equilibration of the backward sweep has to sit at +(T0/Tf)*P. ``tscale`` and the pre-flight range scan heat the *real* system and +have to hold the real pressure instead. None of this is visible at pressure 0, +where the golden command streams are recorded, so the targets are pinned here at +50 kbar with the same RecordingRunner setup. +""" +import pytest + +from calphy.solid import Solid + +P0 = 50000.0 # bar +T0, TF = 400.0, 700.0 # K, from the B6/B8/B12 baseline inputs +N_SWEEP = 5000 # n_switching_steps of those inputs + + +def _npt_fixes(commands): + """(index, id, Tstart, Tstop, Pstart, Pstop) of every ``fix ... npt`` command.""" + out = [] + for i, cmd in enumerate(commands): + t = cmd.split() + if len(t) > 3 and t[0] == "fix" and t[3] == "npt": + k = t.index("iso") + out.append((i, t[1], float(t[5]), float(t[6]), float(t[k + 1]), float(t[k + 2]))) + return out + + +def _sweep_runs(commands): + return [i for i, cmd in enumerate(commands) if cmd == "run %d" % N_SWEEP] + + +def _last_fix_before(fixes, index): + return [f for f in fixes if f[0] < index][-1] + + +def _job(make_calc, recorded_job, scenario, **overrides): + calc = make_calc(scenario, pressure=P0, **overrides) + job, rec = recorded_job(Solid, calc) + job.lx = job.ly = job.lz = 18.075 + return job, rec + + +def test_ts_forward_sweep_ramps_scaled_pressure(make_calc, recorded_job): + job, rec = _job(make_calc, recorded_job, "B6") + job._reversible_scaling_forward(iteration=1) + cmds = rec.commands + + (run_idx,) = _sweep_runs(cmds) + fixes = _npt_fixes(cmds) + sweep = _last_fix_before(fixes, run_idx) + + # Warm start and COM-constrained equilibration hold the real pressure. + for f in fixes: + if f[0] < sweep[0]: + assert f[4] == f[5] == P0 + # The sweep ramps the scaled pressure lambda*P from P to (T0/Tf)*P. + assert sweep[1] == "f1" + assert sweep[2] == sweep[3] == T0 + assert sweep[4] == P0 + assert sweep[5] == pytest.approx(P0 * T0 / TF) + # The COM-corrected temperature is rebound to the replaced fix. + assert "fix_modify f1 temp tcm" in cmds[sweep[0] + 1 : run_idx] + + +def test_ts_backward_sweep_ramps_scaled_pressure_back(make_calc, recorded_job): + job, rec = _job(make_calc, recorded_job, "B6") + job._reversible_scaling_backward(iteration=1) + cmds = rec.commands + + (run_idx,) = _sweep_runs(cmds) + fixes = _npt_fixes(cmds) + pf = P0 * T0 / TF + + # Middle equilibration at lambda = T0/Tf sits at the scaled pressure pf. + middle = fixes[0] + assert middle[4] == pytest.approx(pf) + assert middle[5] == pytest.approx(pf) + # The sweep ramps pf -> P. + sweep = _last_fix_before(fixes, run_idx) + assert sweep[4] == pytest.approx(pf) + assert sweep[5] == P0 + assert "fix_modify f1 temp tcm" in cmds[sweep[0] + 1 : run_idx] + + +def test_ts_nvt_sweep_has_no_barostat(make_calc, recorded_job): + job, rec = _job(make_calc, recorded_job, "B6", npt=False) + job._reversible_scaling_forward(iteration=1) + cmds = rec.commands + (run_idx,) = _sweep_runs(cmds) + assert _npt_fixes(cmds) == [] + # Only the warm-start thermostat is replaced; the COM-constrained nvt fix + # stays in place for the sweep (nothing to ramp without a barostat). + assert cmds[:run_idx].count("unfix f1") == 1 + nvt = [c for c in cmds[:run_idx] if c.startswith("fix f1 all nvt")] + assert len(nvt) == 2 and "fixedpoint" in nvt[-1] + + +def test_tscale_holds_real_pressure_and_reverses_temperature(make_calc, recorded_job): + job, rec = _job(make_calc, recorded_job, "B8") + job.temperature_scaling(iteration=1) + cmds = rec.commands + + fixes = _npt_fixes(cmds) + assert fixes, "no npt fix recorded" + for f in fixes: + assert f[4] == f[5] == P0 + + fwd_run, bwd_run = _sweep_runs(cmds) + fwd = _last_fix_before(fixes, fwd_run) + bwd = _last_fix_before(fixes, bwd_run) + assert (fwd[2], fwd[3]) == (T0, TF) + assert (bwd[2], bwd[3]) == (TF, T0) + + +def test_prescan_holds_real_pressure(make_calc, recorded_job): + job, rec = _job(make_calc, recorded_job, "B12") + job.scan_temperature_range() + fixes = _npt_fixes(rec.commands) + assert fixes, "no npt fix recorded" + for f in fixes: + assert f[4] == f[5] == P0 + ramp = [f for f in fixes if f[1] == "f2"] + assert len(ramp) == 1 and (ramp[0][2], ramp[0][3]) == (T0, TF) From 11beba787ab4f0983295cdee2192cb2023dcc723 Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 11:17:48 +0200 Subject: [PATCH 04/14] dcci part 0: plan and the LAMMPS semantics the block-driven sweep relies on DCCI_PLAN.md lays out the dynamic Clausius-Clapeyron mode: two cells driven in lockstep at a fixed kinetic temperature, the scaled pressure P_RS ramped linearly by a single fix npt and lambda integrated per block from the block averages of U and V (de Koning, Antonelli, Yip 2001). The three LAMMPS behaviours that design leans on are pinned as -m lammps tests: a ramped fix npt keeps following the global sweep when the sweep is chopped into 'run n start 0 stop N' segments (a control without start/stop restarts the ramp at every boundary), hybrid/scaled re-reads a redefined scale variable immediately, and fix ave/time 1 n n writes exactly one row per block across restarts. --- DCCI_PLAN.md | 277 ++++++++++++++++++++++++++++ tests/test_dcci_lammps_semantics.py | 220 ++++++++++++++++++++++ 2 files changed, 497 insertions(+) create mode 100644 DCCI_PLAN.md create mode 100644 tests/test_dcci_lammps_semantics.py diff --git a/DCCI_PLAN.md b/DCCI_PLAN.md new file mode 100644 index 0000000..343ba96 --- /dev/null +++ b/DCCI_PLAN.md @@ -0,0 +1,277 @@ +# 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. | + +* `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`. + The two runners are stepped sequentially in the same Python process (no MPI coupling, no + threads); with `queue.cores > 1` each cell's `lmp` gets the full core count in turn. +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, version bump. | Docs build; validation item 1 done and plotted. | + +--- + +## 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 + +* **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/tests/test_dcci_lammps_semantics.py b/tests/test_dcci_lammps_semantics.py new file mode 100644 index 0000000..ab3aa14 --- /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) From 9c85b984ae1aaeee58d6fa8977d92240b9a4062f Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 11:24:59 +0200 Subject: [PATCH 05/14] dcci part 1: input block, validation and dispatch of mode dcci mode: dcci takes the known coexistence point as temperature and pressure[0], the pressure to integrate to as pressure[1], and a dcci: block (n_block_steps, integrator, stop_at_target_pressure, n_check_blocks, hysteresis_tolerance). The temperature must be explicit: the mendeleev melting-point guess is not a coexistence point of the potential. Swaps and NVT are rejected, reference_phase is forced to solid since the mode always builds one solid and one liquid cell. queuekernel dispatches to calphy.dcci.DynamicCCI (the coordinator, whose sweep follows in the next parts), the preflight requires hybrid/scaled for the mode, reset_timestep joins the runner vocabulary for the sweep clock, and dcci-* folders are ignored. --- .gitignore | 1 + calphy/dcci.py | 95 ++++++++++++++++++++++++++++ calphy/input.py | 105 +++++++++++++++++++++++++++++++ calphy/queuekernel.py | 17 ++++- calphy/runner.py | 4 +- tests/test_command_vocabulary.py | 2 +- tests/test_dcci_input.py | 97 ++++++++++++++++++++++++++++ 7 files changed, 316 insertions(+), 5 deletions(-) create mode 100644 calphy/dcci.py create mode 100644 tests/test_dcci_input.py diff --git a/.gitignore b/.gitignore index 9352105..82ffafc 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/calphy/dcci.py b/calphy/dcci.py new file mode 100644 index 0000000..dd727ed --- /dev/null +++ b/calphy/dcci.py @@ -0,0 +1,95 @@ +""" +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 numpy as np +import yaml + +import calphy.helpers as ph + + +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. + """ + + 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"] + + 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.logger.info( + "Dynamic Clausius-Clapeyron integration from the coexistence point " + "T = %.2f K, P = %.2f bar to P = %.2f bar" % (self.t0, self.p_start, self.p_stop) + ) + self.logger.info("Master random seed is %d (md.seed)" % self.calc.md.seed) + + def calculate_coexistence_line(self): + """Run the whole mode: equilibrate both cells, sweep, integrate, report.""" + raise NotImplementedError("mode dcci: the coupled sweep is not implemented yet") diff --git a/calphy/input.py b/calphy/input.py index 7103e7a..d9cb329 100644 --- a/calphy/input.py +++ b/calphy/input.py @@ -458,6 +458,74 @@ 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." + ), + ), + ] + + class MaterialsProject(_StrictInput, title="Input options for materials project"): api_key: Annotated[str, Field(default="", exclude=True)] conventional: Annotated[bool, Field(default=True)] @@ -494,6 +562,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=[])] @@ -854,6 +923,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] = {} @@ -1099,6 +1171,39 @@ 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") + self.reference_phase = "solid" + def fix_paths(self, potlist): """ Fix paths for potential files to complete ones. diff --git a/calphy/queuekernel.py b/calphy/queuekernel.py index 72aabc5..e7f5c4b 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/runner.py b/calphy/runner.py index e773f14..7bd4922 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/tests/test_command_vocabulary.py b/tests/test_command_vocabulary.py index a30f61f..638e9b7 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_input.py b/tests/test_dcci_input.py new file mode 100644 index 0000000..04dee2a --- /dev/null +++ b/tests/test_dcci_input.py @@ -0,0 +1,97 @@ +"""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 + + +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_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) + with pytest.raises(NotImplementedError): + run_calculation(job) From bde549f463692b05a57a78fd4308d8db0f964209 Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 11:31:46 +0200 Subject: [PATCH 06/14] dcci part 2: the two cells, their equilibration and the forward sweep DynamicCCI builds a Solid and a Liquid sub-calculation from the parent input (its phase, the starting pressure, the melt/freeze checks switched on as melting_temperature does; enable_phase_detection is factored out of MeltingTemp for that), equilibrates both with run_averaging at (T0, P_start), and then drives them in lockstep: one lambda-scaled session per cell, a single fix npt ramping the scaled pressure P_start -> P_stop over the sweep, 'run n start 0 stop N' blocks, and after every block lambda is corrected from the block averages of U = pe/lambda and V of the two cells through d lambda / d P_RS = -(v_s - v_l)/(u_s - u_l); within a block lambda is ramped along the last measured slope so the Hamiltonian stays continuous. T = T0/lambda and P = P_RS/lambda are written per block to dcci.forward_.dat together with the real-space slope dH/(T dV), and the sweep stops once the real pressure reaches P_stop. Checked against a fake runner with constant du, dv (the analytic line is reproduced, the command stream matches the design) and on Cu01: 500 atoms, 6 blocks of 500 steps from 1340 K at 0 bar reach 1580 K at 59 kbar in ten seconds, with dP/dT of 236-257 bar/K, i.e. the known ~40 K/GPa melting slope of copper. --- calphy/dcci.py | 413 +++++++++++++++++++++++++++++++++- calphy/input.py | 5 +- calphy/routines.py | 70 ++++-- tests/test_dcci_driver.py | 194 ++++++++++++++++ tests/test_dcci_input.py | 7 +- tests/test_dcci_integrator.py | 62 +++++ 6 files changed, 724 insertions(+), 27 deletions(-) create mode 100644 tests/test_dcci_driver.py create mode 100644 tests/test_dcci_integrator.py diff --git a/calphy/dcci.py b/calphy/dcci.py index dd727ed..c231b18 100644 --- a/calphy/dcci.py +++ b/calphy/dcci.py @@ -39,11 +39,88 @@ """ import copy import os +import math import numpy as np import yaml import calphy.helpers as ph +from calphy.input import Calculation +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)))) + + +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: @@ -65,11 +142,17 @@ class DynamicCCI: 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"] + 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 @@ -84,12 +167,336 @@ def __init__(self, calculation=None, simfolder=None, log_to_screen=False): 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 to P = %.2f bar" % (self.t0, self.p_start, self.p_stop) + "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) + self.jobs = {} + self.states = {} + + # ------------------------------------------------------------------ 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" + # 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``. + """ + for phase in self.CELLS: + 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) + ) + + # ------------------------------------------------------------------ sweep + def _open_cell(self, phase, lam, p_rs, conf, direction, iteration): + """ + 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. + """ + 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, np.random.randint(1, 10000)) + ) + + 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).""" + for phase in self.CELLS: + 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) + + 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) + ) + + lmps = { + phase: self._open_cell(phase, lam, p_rs_start, confs[phase], direction, iteration) + for phase in self.CELLS + } + 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 + for phase in self.CELLS: + lmps[phase].command( + lambda_ramp_command("lam", lam, lam_pred, k * self.n_block, self.n_block) + ) + lmps[phase].command( + "run %d start 0 stop %d" % (self.n_block, n_blocks * self.n_block) + ) + lmps[phase].sync() + + 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") + for phase in self.CELLS: + 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)) + + 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), + ) + + # ------------------------------------------------------------- top level def calculate_coexistence_line(self): """Run the whole mode: equilibrate both cells, sweep, integrate, report.""" - raise NotImplementedError("mode dcci: the coupled sweep is not implemented yet") + self.prepare_cells() + self.equilibrate_cells() + for i in range(1, self.calc.n_iterations + 1): + self.run_sweep("forward", iteration=i) + raise NotImplementedError("mode dcci: backward sweep and integration follow in part 3") diff --git a/calphy/input.py b/calphy/input.py index d9cb329..bd0b53d 100644 --- a/calphy/input.py +++ b/calphy/input.py @@ -1202,7 +1202,10 @@ def _validate_dcci(self): ) if not self.npt: raise ValueError("mode dcci integrates in the pressure-temperature plane and needs npt: True") - self.reference_phase = "solid" + # 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): """ diff --git a/calphy/routines.py b/calphy/routines.py index f74f97c..34a87b5 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/tests/test_dcci_driver.py b/tests/test_dcci_driver.py new file mode 100644 index 0000000..ab4ff0a --- /dev/null +++ b/tests/test_dcci_driver.py @@ -0,0 +1,194 @@ +"""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): + monkeypatch.chdir(tmp_path) + runners = {} + + 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) + + calc = Calculation(**BASE) + 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" diff --git a/tests/test_dcci_input.py b/tests/test_dcci_input.py index 04dee2a..a658b68 100644 --- a/tests/test_dcci_input.py +++ b/tests/test_dcci_input.py @@ -93,5 +93,8 @@ def test_dcci_dispatch(build, tmp_path): 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) - with pytest.raises(NotImplementedError): - run_calculation(job) + + 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 0000000..8293624 --- /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 From 737ab67e480ce5986f3e91b1bcddc0a9702fe395 Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 11:36:33 +0200 Subject: [PATCH 07/14] dcci part 3: backward sweep, coexistence line, report and postprocessing After each forward sweep the cells are driven back: the sessions restart from the forward end configurations at the lambda reached, equilibrate there, and the scaled pressure is ramped back to P_start over the same number of blocks. integrate_dcci puts the forward line on the real pressure grid (starting point included), interpolates the backward one onto it and writes coexistence_line.dat with the mean of both directions; the error is half the local hysteresis combined with the standard error over n_iterations, as integrate_rs does. The round-trip miss of the starting temperature is reported as the hysteresis and flagged against dcci.hysteresis_tolerance. report.yaml and metadata.yaml are written at the top level; postprocessing gains read_coexistence_line and plot_coexistence_line. Fake-runner cycle with constant du, dv closes exactly; synthetic sweeps check the error combination; the -m lammps slow end-to-end test runs Cu out to 50 kbar and back (500 atoms, 6 blocks of 500 steps, ~20 s) and closes within 2 K. --- calphy/dcci.py | 159 +++++++++++++++++++++++++++++++++- calphy/postprocessing.py | 55 ++++++++++++ tests/test_dcci_driver.py | 75 ++++++++++++++++ tests/test_dcci_lammps_e2e.py | 101 +++++++++++++++++++++ 4 files changed, 387 insertions(+), 3 deletions(-) create mode 100644 tests/test_dcci_lammps_e2e.py diff --git a/calphy/dcci.py b/calphy/dcci.py index c231b18..18c4ac3 100644 --- a/calphy/dcci.py +++ b/calphy/dcci.py @@ -40,12 +40,14 @@ import copy import os import math +import shutil +import time import numpy as np import yaml import calphy.helpers as ph -from calphy.input import Calculation +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 @@ -113,6 +115,75 @@ def plan_blocks(n_sweep, n_block): 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.""" @@ -492,11 +563,93 @@ def _write_driver_file(self, direction, iteration, rows): "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, integrate, report.""" + """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) - raise NotImplementedError("mode dcci: backward sweep and integration follow in part 3") + 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/postprocessing.py b/calphy/postprocessing.py index 8941de5..d3c98a9 100644 --- a/calphy/postprocessing.py +++ b/calphy/postprocessing.py @@ -662,3 +662,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/tests/test_dcci_driver.py b/tests/test_dcci_driver.py index ab4ff0a..70f2d42 100644 --- a/tests/test_dcci_driver.py +++ b/tests/test_dcci_driver.py @@ -192,3 +192,78 @@ def test_cells_are_built_at_the_starting_point(driver): 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") diff --git a/tests/test_dcci_lammps_e2e.py b/tests/test_dcci_lammps_e2e.py new file mode 100644 index 0000000..29a893e --- /dev/null +++ b/tests/test_dcci_lammps_e2e.py @@ -0,0 +1,101 @@ +"""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}, + } + ] +} + + +def test_dcci_cu_out_and_back(tmp_path): + with open(tmp_path / "input.yaml", "w") as fh: + yaml.safe_dump(INPUT, 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] From 8f6bf0f9f6c968d0aa23a71afc8a5e49ad144699 Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 12:14:15 +0200 Subject: [PATCH 08/14] dcci part 4: documentation and the Cu melting-line example Input-file docs for mode dcci and its block, the output files of a dcci-* folder, the LAMMPS package table, and example 13: the melting line of Cu (Mishin Cu01, 500-atom cells) from a melting_temperature point at 0 bar out to 5, 10 and 158 GPa with 53, 155 and 29 blocks. The three lines agree with each other to about 10 K, close their round trips to between 0.01 and 2.4 K, track the published Simon fits for this potential within a few percent up to 160 GPa, 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 value (1340 K against 1353 K from direct fe) is taken into account: the accuracy of the line is the accuracy of its starting point. The notebook is executed; the raw result folders follow the repository convention and are not committed. The plan records the validation and two findings from it: hysteresis does not measure discretisation error, and the ExecutableRunner fails a segment whose LAMMPS log ends cleanly when mpirun returns nonzero under heavy concurrency. --- DCCI_PLAN.md | 21 +- docs/_static/example13.png | Bin 0 -> 155305 bytes docs/source/examples.md | 6 + .../source/examples/example_13/analysis.ipynb | 495 ++++++++++++++++++ docs/source/examples/example_13/input.yaml | 25 + .../examples/example_13/input_converged.yaml | 25 + .../examples/example_13/input_high.yaml | 25 + .../examples/example_13/melting_line.png | Bin 0 -> 155305 bytes .../melting_temperature_reference.yaml | 36 ++ .../examples/example_13/tm.input.0kbar.yaml | 17 + .../examples/example_13/tm.input.50kbar.yaml | 17 + docs/source/gettingstarted.md | 2 +- docs/source/inputfile.md | 157 +++++- docs/source/outputfiles.md | 58 ++ examples/example_13/analysis.ipynb | 495 ++++++++++++++++++ examples/example_13/input.yaml | 25 + examples/example_13/input_converged.yaml | 25 + examples/example_13/input_high.yaml | 25 + examples/example_13/melting_line.png | Bin 0 -> 155305 bytes .../melting_temperature_reference.yaml | 36 ++ examples/example_13/tm.input.0kbar.yaml | 17 + examples/example_13/tm.input.50kbar.yaml | 17 + 22 files changed, 1520 insertions(+), 4 deletions(-) create mode 100644 docs/_static/example13.png create mode 100644 docs/source/examples/example_13/analysis.ipynb create mode 100644 docs/source/examples/example_13/input.yaml create mode 100644 docs/source/examples/example_13/input_converged.yaml create mode 100644 docs/source/examples/example_13/input_high.yaml create mode 100644 docs/source/examples/example_13/melting_line.png create mode 100644 docs/source/examples/example_13/melting_temperature_reference.yaml create mode 100644 docs/source/examples/example_13/tm.input.0kbar.yaml create mode 100644 docs/source/examples/example_13/tm.input.50kbar.yaml create mode 100644 examples/example_13/analysis.ipynb create mode 100644 examples/example_13/input.yaml create mode 100644 examples/example_13/input_converged.yaml create mode 100644 examples/example_13/input_high.yaml create mode 100644 examples/example_13/melting_line.png create mode 100644 examples/example_13/melting_temperature_reference.yaml create mode 100644 examples/example_13/tm.input.0kbar.yaml create mode 100644 examples/example_13/tm.input.50kbar.yaml diff --git a/DCCI_PLAN.md b/DCCI_PLAN.md index 343ba96..ffa940d 100644 --- a/DCCI_PLAN.md +++ b/DCCI_PLAN.md @@ -227,7 +227,7 @@ Physics validation (manual, results go into the example notebook, not CI): | 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, version bump. | Docs build; validation item 1 done and plotted. | +| 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. | --- @@ -249,6 +249,25 @@ Physics validation (manual, results go into the example notebook, not CI): ## 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. diff --git a/docs/_static/example13.png b/docs/_static/example13.png new file mode 100644 index 0000000000000000000000000000000000000000..a4d5809effc38b8ca6e9507ff627fb0b45da18de GIT binary patch literal 155305 zcmce;cQ}{*8$N!UnGuR)m1Jfodq*K;ugq-OvPa5RDj~9ECxncw%#f^%WXs-LR^RKc z=lLAZaeV*y{qy_%-bYXM=*@lKuh;duuJbz2^LmG=D$5fSP!k{sLVW9{tQvygrXUDr zJsvK6#eBgg2mTOty`kf(?qK2SZsKf?+%|D_v~zH^vo>XTVD9Wgwns%*A#8fA8RQaJJ;KU@8lTpMvjrQ`ZGSD9Oxg{&5;gPsJ>aL@% zO@C_Lq2cC`Hwzvc!)nbL(jL7%!@FPgN_31LsXw71n>gAgkfa zz5n0;m(>jZ#C+*LuRLBN@iYH<-H9<-4-5UzE05@r%71@?hB=kbf4=`xI$Pre`G0=E z8O`&!DgXKY(46-FFK!{7*>tiY=-JK7^COimnLprnzRP6z=Qs^?%#XeF;IHuOG`+Y% zTJ@s+;Jdr?y_tk|c6JOg3KyT>BzQoH*CMPFnHB!Oz&1Oek$YN!<4F0+3 z!OHMldQILc$(cKDTElb6c_&KSi}{7pm!3~_r^#sc(*1qho(w9VJY4>Vbe&zZov%CI z_T_7H6$tb2@Tk;g{Qh2Sb_(t$lvd<{Xqj1WNxARggYBh3l8YBFe*W_1aZQa_Vq&7P zwY6^U?(XVn#Kv@M#+?kgqO!7}=g-e9FE4k0xUa92B2JsFlJaiqjK&x5wVIHI25AnR zB1A2BS0C=ww(R7j_Fyre_s45d&-YqMaXcQnx?y2q`*5q>1^U-3s;U~Any@V_EOPFC z6gb#hi!$;*KD)56pt8J=kB|TAn(evjni>;RQ%rq*{r!Uj)0y@dQtY%QuZ@k3{jDyE zjZdfOQ}xU3i%LrJd*_VEX*jyNa_(fb+c|tq6f*sFeas`H!MCWmSjy1QFn4BpdfLRw zied;S-{ zd*(&u=P0lbyV#;D`S_dt zGloAAm>w4~S+a^~)?Bk4Fy3FEWSSkX^QS-DTk{VW>-}KXdit$?`DsS^r?S6KjukoP zW@m9792|yz{E(>mDuy#QHijVT>V1|Y(b-F{9cnQUB5HoTrNP3&?fs1O^!0v%I{#r032B7Zq`H=zk!>z`#J4DCNMG~0@7-mo>6Rxv9_tgl9fi6j zxb!~jQenT~HB@S?9>3z@;UUQx*Vx{kCw=Uzmh9$_Ema?9Axn6MXZi~WMpExA^Jc|>)caXkzljdrzT4S z1w&=Fl=pb!l}A(jPtMc(A34SB%BO6K%A3zno;x?SH||gAKVIuA63bcai61_E2!|L!KHuY|qN1AE zoaw0W`Na$05dsTZKRSBX;TY~U)n)GM)RT)@Sy`XEy5v1P1REL~i%lAFu}__9Y-yR@ zz}3MIA)#++rS~WD_y6sT!?f`0Tdl9R>)IGCY!iI>=wbPo*OIRLKPe~g{8yhmx#g7= z6AO#rN2f@p;IWxv_3Qk^G}zAC48A+w7S_gxJ(9n7@A8=M-l*kh4BOfB=fggKzFB(z z$F8pXOm3Cy0vTfbE$2?mY0;pdptQRmAK;OYgv7_6KiRAM4WUM;$`*6;)-6~CjCTf= zf#@bED=XvS<4YMB7-*i(FsMB_utn-0_R#3RxxmKkzBZL&*4tbU$_D%aIql0s_m7h@bqYYgix9M{G8Fz&8?tUoWro13Nj%# z56>rw-$#!i^0AP}Cr@}hH}5%V^})l2=j5;?9c;~Z%GlX)JXjuj_-kt}!*=kU=5SqJ zsZBo{Qm^k&!}K+kW#!s&j?^REPhY+ep;7bXNx%LqL=%LMY?83s#N6E8ev+Sb;G;*y z?rVlfJy+dPV46%wxT3>@r2*m}Gcb6^3bg0N=eF4ymB`=9tg~sgK+tL$?-y)ye+Z(Dqw^Zx=d|$nKRsZ$tX*lTb zwrlUUwYBYU_o-kYkYRP+-@6rGcuhh=!sqw#-pp!U@a(TXN-6`$cL-Y0a@4b*DxbV$ zRX4V`KOLjMgxem@Ze3YE*9oby2!iEirdstz%LP-0h2`%h6^@hAmBZZEueUzCD5Fs0 zneIWlYkew)UApggmD|!Hv84Naw^Vh9<`#92wgdwMLM!ar-Ntp|)vH}63e~O1bIYO{ zvH@C&?e5>d7}qhmy83j`(3?10IjJ`{!_(m#_U$Mdp>&tigL~y_&s~CpEw~grr%P=I zIk9nZ8{i3JV`JxsiZi~}K8I5%;^X6EY-Wb#;^MOZ>zC#&$JKHF-_5XX@MAewzYjoV zREp=tVOB~0rZ1nVW&((2eym0WMMZXYM5j)jLW{)f>kgc5h2`xm92`yPk^7n?(l|C| zID*yl0{?-bnye2EJs|i<5xmva)j++1bE2Z6*hs^3MtRrv zr|0?P5C)&kHfHIYH$xFggkhxCS3mo$S}sM)lMBqT7!0pozb3@R#hqFMgdnY?q!i}6 zxwl8z_mp0OQ&30<-?`ENVfZ}b{Hd+&*3ulDGE+}~e}9aCBI8e(NxP$?qc}(diNp~D ztcx~G$@S-E9DUVC+R<$H;|qpK?gf(I2gQ0WT!7RS}AL0fZOOJep~TCv?9-5m<%zV!C0 z0S=y8gAFBBQ&(pfy&^^W7|Mo~Sna^TfL>t;6a&2Y_;}M_Lqj?nmHjV^i;H{Ubjajt z5NK&>VImi~xr@|%DY2z=N-Uo2m#e*)>UvaL7xBK-?zWY6O3+Ci;bh2Ot?QA*P-u@LS`N=r+7m9@s>IZ{{BdlJmQbKQP~ z#ly=hd<`F-LeD=AO%NMS9Bq(fngpKGiRn!q%q-NkK<0&|gWt<~A%QoGAN`t3VH#NL z$p}FttpLQtAG0p~DrD*0r(5y9;R`o~iKGEMH62FNEJB*46tDJ99PqKEpz}}I*c_-T zsapAE?W`08p8z?-62Wdp?pIJsv}(k(`jR+4cyJEEi@tK3t@z8Jk^fbM^o?5Xv*>8X zEOrV4DYh5_5DgWv0@d!No z(V@>aO)Z?E0^ze_mZHNF5ELdSN57`bGKEO2{IuTcT!d1$v11G%Sw}}F^cRF!L$a7R z+YS}npvmWF7xh|8ii*0u5)-c3W~pfU z`=sf!YnImZdr-yQF#;y$=XH8QLPO^()dnnm(&xfvw`QaFITU4Ow?!wvWZPuz)9y!& zE##@Ptk0$ROS8qq+Wva?y~NTCFu$X-bAyV+@#B{-DFA(3yndY$dK9akbewlabx)xJ zOBZOxeK&-3e1@K$YYhLLL&|dipjuYd5Qp*x1~gFmFaQm_eaj&$CztMfxJ!zS(U)~w zMounRxdzVM)M9@=T1E3T^Pk1U1eKQZH?_2w&UdGwng7L$7i{0+^0sGRJ2Z535So~n zsIpLe{`$2AF07g%M|{u1!nFM*E7QP_5=#Ttjy^X~=2X252j;4&-X)$L^2V9PJDm z>2-N}J`M?q=$hVopYmKB&d8KfRQU2jrl&aF@$0kLQi-=zZt76=HL+n$nWw)E1RP29+V5SWHOsMRvXH~8B( zjW^lZjGUaOM?bosLcYZFog$>K_AzYcGKBaH>?8yX%i4V5-cEtlK6_YFZ^2y%n3 z4IYaiS0fy{6?(MbT3B3hc5yjFNf`pqKmSFEorOg*Mcmi%VA~op5*bANbqWHU-oC!) zNl8y21U~ijocZ`*h0U$2C>$Ctaul9c8a$0**S^HgP6!R}=g!U>($bhv+_;<`M2kbE z!9oCi#M)Y1JJS;}53Q3F+yYvx0E9q`=(GOm)J+wYLAG*>PU-^PTIyT3Zaq`T)XVp< zf@lFeWDLi3W;M!!DL60?6K%=q=;)qx%s|TFob5`9s;(AI5>C*RGBq_Vf_N=;7^ee} ztf#0z7#M)wF8~=x%y1^8;G7hDY?#*M8@+k+#u)In)wi58|MbDIhm!^6V-2tYrR`%i z-jvbID!~vo;SyI;d^Yi+qacY_ z3O+eLj4*#+QnJy;oRWGg`U>~8Ye9f_kB*PsEM(#ap~32@@pd2j{#}YQF2k_KYkxi? z>RD1!f%=F2={o44(Ypr@0ho#A&@+q*BbHDE&#zT)olZrGm5S23v;~E6$1!WW(gjiJBcPc&@Nid(299!(Ck5{ z^G;nmQ!R||&U&PUcz>ah(UQH#69DjG=Br~h`7z~|U344D`xO;}HOEx|ygUZI018*O zMnird8Xkt+euhzQ{_588-gtyBAt7O38`laCYe#zwd-FlFWvk}5=;U7%G&CFox0RJS zOXw5ICm`iG1rK+=zTWJN9&QA0XR*I;LH~w@xV6Qg5A-Hysk^3+l41tvr9Ae%02Y#x zk&(G>av4^$!~)#b2|6h7G-4Ac&*r7GoK@eb3yF-3BwO;|8+A9WoLU<^5Y3HOIj~5J z6<{wD?6hM7*aVGW=z>j|UJfKIMAA|qvR2$`Y);~EnGYjieL&yAI%aEYiyXnbAYey| zE#+aum$E)?7dOSXiQoZ-Kf5|!SEydTzw`k31SY!aqhDL5m2fg67MjPWxeO{)O^<<_ z3Y`IPuZL*4G`SEIYcPnM1Zhwjp<9Fv%Vj?1nVB!l`ph{{NCPPQd6PE|t8W6$yUvZs%Ic zB;7Fwp(MId-5K&EXxPtxFUjV<_nFkB;W0kkKqtq*TZ5^osY}}{KeXqE%kuXd*flJxg$QVH0-npj)of=+Oh9|K?USTGo*p?xxzAfH*dOfB5i0bNGQ~6%_1%^cpX= zUKMh3a%ck$Y_rJM*B!J<;`Gg}S3`Z)C!{hLwV}PLZi%8Nfrc_^8*Sqbhc!y?cP`E7 z)@r?f|Gw$>>x6_@op&CF8^S8;hK6)-1{IE3Sy;OD-TU)2k#IxC=GIHkZ>|I0u!&)f zf?^6_$n?jD`%}|STeG)m#Jnf~62o2?n}_JyJ6F<>Gb_tNqaYY9m!`_V#zuf9VcAQc zASrhP-J5h?HR`Zhf~)W~><9+SF!Oufyv0Q5op^i?T$5ZC6%{ui!*voD*6b!IpC=(9 z0UV5(v+o^hAz+jt_k`PNs>ykPrw?wrek5K_8xB-Qdl$Q1hG@zyc2}7Sgm4ni}4kVg!bNE?P5m-qX zS66-j43Zm zE-Z8iYB78PH#G&#ScTuQ@X5)c1KJ3fra+)Qf$U)lRHkua=NrzfVGBi7f~ z>!HPx& z>)9@P-QuS=-CG?cw6vTf^XE5uI$r5A*GBY)C}GBQJ6E^l3Np`e%XM``2)Uss8dGXr z6BR{5L`#6U9jQ6|d>(>uXn}B-DKeR3TNM#mL7;4$B<^Np8T|BBlr0L*zz> z@e`nSL>??lIy*a8F2M;}_Ov?m^eYfmk$XymFGZ?w+_M*?0HEu`{U5l9mr+JS<{pqy z9mjsti;LmFuU%wjKBfP`4nvjV@mXvPM!CoU1J1&qEFE3nzn_O1KrZaQN(7P4GYSB{ zBaW*TwgdwKiG*wWJu8Y>ft%>b(`47t*KdT!0Coj_!Lnipki|V?Rn$!41HuxIkB_g$ z6L?r80CIlZe)&7r=-61Tldo8UPE*)Os!EFZ%)98A7$(1kogR7m7%#d34i$~FDM?gqzaxl$H?My@FC`Gkvx?uNM^+)k91*FWo@6`S=GSs&CJfw&_rI<|G)q-2gR3br%aCyk|#BAc(}050Kd%Y126zxLBXcH zqLLh0V%Zg|SI6sbIkR(lcwnUYH-`~>bF1d?xZXx}FI~i34@h&s$75Z;e!b>XE@0|3 zxRz>uzaHN~dwP7*M?m<{m-Ezb2_7bEW&+FH2)4<^a)fSSG!H6rN`gUcz)bGH9g(T zl?zRlq8N$ofjR`Nu-oEept7g|APto}&>MQMT&t+4NYyIPqZ0FSt+dd#w$NMpVfHw5 z{>Fpt`8!DW$KfEjilOJsS(HG?!kU;Qy3!e$1u(#%(ita7#C@O*vbiL1k-68e#aaMu zC~RF=d%y<780p!wnR{6Qz#uHXxgjgd0LUG#-|J1h^z$b+pb4}BR903Z;TBVvH%eS~ zfuda$l2m^HSP=9OR;RU&R;K4Sx5xIKpoAlm0GzhPzb1$oHa0Z0i^`drUg9*U2*4$# zuK)2vpVoLZk;xbC{Svl5+O*^{-;Mh*Z}28dJOubKVqIqaK4&zSGVgofq_ z8?WakylA^Obt(aXNtn@CjQcOn7zG>zl`z|@84XFXlV(mOTPEo8o8M)iNV&gN-6v`! z*+bbdtcWqb~1-g-{J}XHMj+^8Wnp#I_b(G4ik&#?XcVK0wu)3hzBm$PkY~yc8`i)_4pE zbS=3SK&+PGhOwe&vb*GAnOe_aXNDUv9^1Gg;azk}w{CrcUj120N)%x531CJ)x3!&d zFbIu`qKwP-HRxJQ+^FC`&b?U|o)V%0gu%Nl$6JaA8sAVU7}C7iLT@I@kkio8qP;TY zf^@|=P9Vi^=3)qTF3Gr@X1tWg30(k5n5^1VCw77^SF>fLIJL2`^G`f%DM?951f^&} zyqI0kcU~JRHlw;`^YUv~M*eAF+h2NM1!dJ8SiD~(yk})$x-$Avdu@&fjv!=s8B**G zF$r#NQa+0>lAy!^8pi_i9~jTm^uF8Ahmuhag4=aoHBrzB6Ux>@&`+V?-00Uf(pB@4EZbNIxh4wp%Rh8kHO_O7pUH99oDf{Y_;EHG|`9TzHl{l!lk*UCGR2vB= zYW}MGuT68P-Vrr7(J%2?etr4z2o5_bHit z)Rbc983nr^ABbyfYhMYw<&9M(a9v6%pL-ZOZ_VmgA_d!W2c%1<@oZ4zBriQjWt=Nl zu2}VDJ<&2I=sqoe1Ar^MNw`&~!qKEsdw^vnnAUfYGT{P4b#-+&ES%a8PP!4@_xJFD zM59G%KR~I1en*0U1RnuIYtj*Wb;|h|_|&2I=7i$=6Ikeb06h!3EmA=7+W?Ww6dV93 zhg{i`<-q!}w?)gx2X0rdgF-w{G^#MG0FLf_QnN;4?Q7n4Z!-l?2M;C)wpGEcTx#3V zs%zj_xMWXZ^qeUIP7H#e3>1{a{8A$|>zW0hP| zpkE$)kXFmfFVz7&1Zc<$S2NUdn`V6Tyn+MM(k`NXOsduIS5r&YahdyOX}St*Ky)m9 zEuB(^1zzwwN5UW~%$P0;L`x5Jl^dslvGk{fx)HOgV*N&qb-3Ii3L5<|_c80(QjZ=u z6M9F|zMyc=_!W9?ugPtBu`Uq0mg(J{GQ0*_#?*9`!?<{jIR!yb1&xv}WnI^W&bQfs zz=0*p|3=?QNtqx#lO|+zmV%-l_)>@3UluV@Y47Ze+nZOTJxCq|0=f1i*Uc_$3Y zf+*C))D@8Ki^ab-!&GArmIh#&Ff>-(GCakgWnLl{#US0o{gy2{w{GeC)x#ixYxTj} z*xglO0Re$2A!BGHRo)n#?Rj&H{Al-w!_-plo4q}tG&jDkz6ks&E6bG!`CFRwG1=Zw z-dgWnfSP%ZCz_U_y|0cIHJTJz(;xx4w!9w^{@B zjXHNATp3td@!{mj0yqW$awWFM;N#0}T4~+uSuX`@q3?9g?hQ`Z^JNIwF22#D`hyr9D zMrpuwm3+H{t1h&pExCz$z-9K!8HuJS0Q}nT3|Py2AX`C`{N|cBxKb>T@Z@R8Yc+1M zoOksW#J#+|Bi!q>?`hq10vE^G-xlm5jZ1f!aE1fYMb2NN41)uu>0E8uIW|TIn}wxH z@iy_AtyVln&U9;(?Oj1E5+g3aL|#jU`sK=rm1$id!{DUOM_BptvG^Tr$ltTH1h_A` zW{BOD4{Lh_Z6y)_x^~0JNHs*8(wEfKRA;VRK&>nKz(1nv1NX)D^^GTWyH^3KhfY!A z9v|%Vwb2VXUq&VX$9csSiufLsQn~h2%We0Q;N$mPAR4c7%cmL{(5~Zvz8wkwdiKC# zCrQHJaINxA287<+Wa5S(iqDY>=NSS}VeYJYH9NduVMjE5Sesh!3?GWDJ4$4~7#nYF zY=kU{dYEwYLPPTijf{+tdSInoHz7%{1K|in!Qz*5yBPK@H>R3(sy&>7V%4q3sw*p8JD@?2 zyeJbq0W9EDoHK}9X!o6+;zvM25=F35kY35R47C9)2^{V|^mKa4gM$E1!zH z?&Rd;0Ws_Z^@D5;&)*O@XA&%2A_PI1@>haR=>s7ru*ZqwzSOW#;v=J@?4{!6s22@q z3JwmpNdxxf%a;+BVeaD)dOuPlE|6}?uV)r0?C$Ok!D@o4>Gb==7X=V#C=PO+3a{mV z3icY12qz{dAD(5`vhsbtytv55`ANWKR*6Q`L)E}*5*kaO(w58$^;g%{NK!ZXav&vg zopjm=6#5##oi~2VRd)h!16W#kjv+g};x#8o&&a?)p!Eo& z1{2qOe?BGnvJ$m{7I$-y0V!{~gEu@k?UtWUwVc{EkjG&NV zN|AC~bu)lN3yZ}|%x<*mEcB-W0qI-b#>U1$t$Xe4g_3MBm#$qq3tdW8g}(;)q)v{u zRH`@I*_l?QFhoT|j4GXP*go2wN)B;pnFgx`>Gg*wkG)a%`&fmDA4CpFt7tE3`b@zL z=+7x z#C*LEcE1`{MC4^PVnJDx0j>@bhF(cOAprrmc{|0=pFfR(8`bj`z$B6ADm17h3uLhJ zO-6fX@ak-U-iINXDQ;_p>iv4xS(uoa%>XqZ0ic7#e58e@95xWO!~sfz!Z8cXh2E!k zC@t>oa*p!MnTL-bW20hiK7uySUUB4O(6M1lbr09&{6nyTxQG&1Ja^MnCsxYG-)T6$ zh5izchzLkSJdh>RT&DB&3Q$*41UOn^@@s&&lLD@`J5|c7)eRU&r{AOPyx`dY`_xmQ z50qXD++Hd5J{lHJ}CPE?+t!d z*J2_B1RTN#4;}!tNYgq1+_b&hHa>2YJqp4cASS7|whj(l6(2tmf+?Z_7PHy; z|4)H9!uQdyBacxJf?zGMW}uJ2?~6ahJk}+1jOuEKPJw>+3HUCA0hs1Vz#(TxMn=F> z0THMmDtC*2CHV2q}4|>^y&kGx91rXG2GFzLQH9ZWVYam@x zyiE3~rA2P3j1*i2pzscUdw!9NOT}Sys>@whB2!GBsYg@- zydt2kv+ZO9crvX43KZ5D8vU3<9iT43)d6(I;E#}S@z#XayW>Jx9v_)z;{g;PLkD+onNt==>jpp!#y3E>nXI2LKSyIBbAuh{I@=X1<+y*ZEA} z;BJ;B2NhDfH8EMxo(lClqcSry!C%!h{`!w8ftB?Z7^x$a#b7N!!Rz&m~hC?AwQ zNpl#l^(w?r@H*j#M+kzm5T5emqwB&YXf2iIzvV{nk2XM))UmZr2mym)v%{e(H(S)~ zAq_oe^BNwVSZmzwzO8tP#6cw!tnT{uHiSi)O+Q&M2|Xw1CwOYP8c<+OGbQp-qVA^P zR+z#)W8(nGJ5ykMhpHrsnz-RBkGNv^f^kLnIJg1uBD;>i)g#0&pi&rZR~6;L@pZTRK+@Y9#7kgd`{nZzmumL=A8N8_-e~ z8Wz^`v9KGgEXBaJ@;i*tK*fd?Sl`(AggP7=NhDr=4}r5i2?_^#>(INVYOtX;W~daC zz}+?i-CQQ%=XVb1gJ;j4sV=IhsgVVwyB%EfZY81>E*)v@ektaE;*%MxpNj|d>27)T zYa_~Xa0e*8;>JMXUUW1$_#V*vnw<^Cz`{j)DCmPLDu{B#p{YXKU9^#boA~tkGoED6 z+cb!RX{c$!-VzkrkRlAKJILAMi- zp(J43=W%hTK*i?2KTM&Xt=tS~B2T>wnu${+bWPyn1Gl{Kw>(Wku+e}&BPb$*&})1C z;Y>%|(%tY9UcddxQ$7GWK}KbUrDVXv1WU*r;2uCfr3CV;6;+07s=_~l6r`Liicd}+ zt#EbnrtJ15)D#RvCKeF#kAs3H;j&(u&q}un*|y>Q2J8HbIFYmXT>BC}WOMK8uEq$nOCA-ScSEo#%X9e4|#MqPA?JL8ip_rftGTTWA6oAQIARksGeO`O z2gM!>@HuMOg0`!b;6C3v@C1y4f>dyFZv6FUft4TcRYJlPNXp*J@hXx%mVwa3nT=F9 z0q6vML*yBB9OHh6w-YDj(5Cekc3PrHF?o%w{Yb?{&PS+T2*RY;G+j@`PjLPLVj$#( z-D0bByqLZT(h?P@?da$R2!t_J{Fizv49lNWERZgO#h9)Up9ULcnO=c=9r2|+FStfm6`^dG80c9X1{I_bPyPdU zFa8}@u?hD^ZyY*|x|0L;({!StKuR<6@SFjg7T7#x;o-Ucjy%BCCB9@2>HgnWjpP3{ za^;o^NAiEK{})EAB4Lt7(%fxzVbnpPe)a>Wy=S%}(5fP2hZ59LP1Yo2AR29hGtx&T- z9cLHN5j)sji2!@A_=A5v>TclDErNE(a`cG}DlLM89EyKe6+7x-?^gz%8lWUP?yw+W zI5ZL6k}CBGY|-zcSHW%&jdq0`cdIBMD|^huXg`C!L)Br_atxV*$G9Fz5{4pxTE?Mv z9335@E)fue7T( zE$%W)Bw_W}Yb+)YlGXDUFE-zP+)xAOA`rn{RbX#{8-Agd`&c^7_!$z=)`1-X+tuXHwrBuBm`I|iCmEFH;IJ@!F#i$*W-eCN(?h-SkD#`r zQaU^lHUf=wD&$j8-dli80rZ^e#)0O#;9ygDtIh|z^GIq@5vfeb=^Lu5q-ZkBFvWpLnWlt)CAzmfKG&pn%WeaU~U*;0V{O9 zNa_C~6;vNRFV;X6Pft%MCAbI?ov048QS=AzJ^O-fXv<&fWJ3!8UOGWg!J$&RF2baS zyrs1m%m%=W8tS_Q&x3#DzenTGpJFM7`xAZOF9lEGpD28ciPE083hz@U0z zety2PA5g^@2kPoA_@_Di}@RBM_LVrUcejaL}T@3~)Mv4#riMoS)AQBT;ZK z5kUUMEa@b;`bzQs%`<;<0_7;-1s_nL8=;;6*)0!)OITonYz8rY9WIDkh>J=~n@X+w z5aj#!?|(+t$bLX}k@4~p1`-+^vljOvi@F z!ZSizp2I+j|L^5>r>2N6MFCiW!c=H)V8*Hy+$Io@2=q@#fOHy5v7xf^X{3H+ga&C6 zP7qa8?BHFZDAevP-tK4Zgh1TRisNSt|IbR#>w1}3ipR8oj{sSp_=JT7yncNFVc_Ic zcJKs;@%FYWcnBgsF+y^O;vA!=68+A)PPDaG8=TMod*xK+#D2<#tw2aDDLuWtWv)bD z1Z3@?iVlh*0RYl%GOybXD6!WGf`1TIv#vyc`tjqVft!NJx&N%y9XHjLKoxL)3VLm` zAgSgZu?PZ~2t|lU(fuC+;P5O3NN1b52br-+7@YxxFv7&bg8b&TxI9*K0Rm6Y4Gc(* zAmhUQropL=p{D=OC3?1&gNVeTFC&1m0Tw=XF|Zr}dV{WH zx+qIC8xl3@-v;a(3{X1*DnAPg3p8h^z;lmI0D{TVroR|Wqp&(WAO*rfrvkpAsJt9C zEIm(7ehSfY33{|_e-!LMqCrgzG{UZU(4)$NVF(@Uf+0E-g88IJk^FbrN;ajx`oJ_G z?G@$3P>^mW;2J26h?25!Gt=nwDEtHvM%@-+NYEX|8i=X+tpd=B0E1V+&NKnLfwEvV zt?+eHXpvA4Eb2l+1u?V^L8pSc`yFVZ&4X-?&J*5LPymZ6w1xO^jS%2q3d|4wyMB4( zVe9k5ZrjqRhZmWEKA@|D87&2}ve@gwE7ntHx8bkbKQ)>y3n-mu{~1>K`&?ov|5t_o z|8J;z`^%_`w&`@+H_K7tKgT-{^WT~99zK^1drk|7su1nEu$H-xWR5$At0k+wE^7ev zQI#I`OhRi3x*klp#_7$$iGX(X(&9h?VZ0J9z<<=SJ?^tb3@J|Wt@~6HJ_>}v^9SY$ zc~DM^VVl*W&O(I2sB0?ZNYqA+CZs<$>S~22ap)2oilU+UXDMa3o$uu0&{QP^xwWdD zagrAqDqYoKtEHRWjP%+yMJKC@fkJkUiwX}9gy;vl@lLt@U37R6@B~0zv=ac7!HGs1 zSSIv#0s{k4pC))KP?J6MC%~0~5Ke(w8(?mEo@NQQ8%PB#VCB0joXpTFBq~ai;&;G` zA~=YH&-dQ9`Vpb`IsdCA{-0s_Z4H)9&HZT)HZRWFu!Re&3)soX#CV79=g*qfnYlRE zPJA7SA3Z$@&Is#K$^Y0@0A@S15gn@Wz7AYM2gh%izDE5Tpf7O3q#l}amPbEQUUwLK z49*vT?7>jgW%5ykAQweP9HS5f=Y0}P1VbP0U%14`IJvM8293<6%a>*6bYME(c3JiE;WDpzNe}aKj2H^}nxQs_VYGU#JP_NJzr{j##WY;mGvL^f<*xdfHb!Bas_DrpUy&PB!KJRsgCt_ z5;`$U(+7PTD9nPc^Q161_7u{ywgn5iiraw`*=~P}XdW+HS->N0-i=u<9;y>{qFuvp z^d2_LY^_sgIEQ{GGt2!N4tvOqcre>B#@;14gQfEB%7D&L1#?4HT@=ZMn)Z5ioIj%M zI`|`H3jFr(K_58DS8D`;4)P~2xapjwXXEb6f=)v2}Yl*8MkjT-o1 z4?_nk<~04fP{JI4em;ZFyPi5tQx76NLa}o88WaQ6Bb)C7=IecbU>j@hC&b4uyzD=! zyX4lM{@r2X4tn-LvZ(xlwsYy(5&wRWMqW{e(~U!+l{$?BKV=73j^VDh-ZxgWYO%Z| zuU8+N&2*Aiq`bZuTa&PX5Es}W2vH`kmD$`$Q|tQs3XhFT;7P;5!un%c@bmM7CIUUd zsC~o)FaXN$P<=Uro%TgwC#L633+}6 z%FjIQgXc!6^&38?vXE{tT*u0{Pi_i+#rK)*3uVV}#~1D@`%~Yzi@m0f{m-+;C=i|J z#ok*RM+f-zO0E8oel37FQ(;O6m<$x|4plfo_W%OL+Y~U<0RT&S;Nl#Y;*?rG+8~l{7w2%?mnLoMiV>fAG`8FD+?o-cwGo8pyx_e(~efhDZ zrNd1owVM05&3Eg+mFQz2w|;#m5*Ne0T`xbroH?}s1ian?FkdJq0Vh72+((Tq2L0HC zd%Wj?r7c@TjVWMU==0{d?FFMh?ANK#OyFhmzpd1JH`393V3s@N&O;uQxjeUh01Ku2 zZ)|(VF~r>L9xsd6c~EW1e2?8Um+88x5#(Gj@4d6L({?r-t8Bfh9bd8( zT6W(%J$QhNz(6rAxFPfu7cnFO7$KPRZ)*~q07eNE41~Kd(e>`y8>YAsY|H-K`2M&B_4uK;P7p`!1qPw3X@@VIDFlW@K zq#cZ;u!`2nP{fP!;q&`)zv-oZQGd7z3l8w@LeW=0R=U^dwY7I>3 zFj*i4ps2YtO8fv1wg(eI**%$HA}Q$dfZgr}^#G<1r+_kmu_|e(<4%yuP??C<5{MZp zVOJJxsQ|DvLy2{QfeG-JnEfRM;+4mN%X~h4^rXYFWkd-w(R!QDm8{J5D?ijSl`YLbmI|`@&e#*0#E*=iKTp$(~CU zd<&lRBPD*he&?8}~aNnkEg7{7ChF z66|=ri`eN8WH80)f3QviZME2Ee#qq9Oe|FpI zg^Ze%zGGMxxWfx(4bL=Rksx^CB2hxbAHzFl<1e%s+g~PMx<~QT)OJ~@`c8I%mSb)~ zl1RdjiiZ9s>SiGf~jfPi0`M)1-#l>BwCpizJ)1$9-8iv*!P7|Jx>$&e-}y>&7>CTGB-Xh)@ZsMSDm6hcQEUbAANQB8&Cho))yo7kaZB` z&9l^UMYG7g<;SxE?}l5|S)I7W$!cr_25hnmZOMH+-6X0xXn4M6n4Nw4>`!bZXYt>- zC_b`_uzm+p;m`HY)F}0y4H|M~Bfg-Lbx||T|GrqIg+%sKft;0fM~5tf7&8AcA;Rl? z`q+Z~ZK=j`o(6+Buja>4SZ~mL8nK6+`zT6-toM?(;XR4 z>-!ooYVIazj86Pn*!lQdZJbSq`m59TO4HkaSp4sLjCh#JqhCHPGO`NZX%8}%=i-ap zDUlH&SwZ8n$*lQ_>T;DkKHH>8Q(mzqvC`(IOjp7aW0royMzQ%-oFk8EymyvYrfv={ zJdZ)jgi!So-`aaK5n@;c21f17^2nr048t|62$K~%&Iw=03bPvrtNSy3E>Eh zEJtz=51#hb*ORi}UT@&4VW6xV7k{EzuFN1*XC;wSR<3OFB92~(7<%#3&Mr0gIiH9= zCT}Z85VQ>mj4RagqhwxdrMrM8hn|vH|J~HFdUYqb*-xJ{&fmL=m7-Rd3{1ik^HVR1 zukhn6%5#e8RlJ^fJ;~|#VN=?9$oFyf*r&aMVAJY*hi3F~|JH)+pS`07Z-o*9vEoWx zIgj`gD%yDl#!ug+)~lC1aP-eQ6k6C{nZ>sY#g}=yIO(U%d1ZiVZ6Tv1E?Q4j=HT;a z_?pMTgzVd@5y%@8zqS1-eVCKW#D8_#DkjpxAPwyECG||v?&0ZN{-APB=@@DfEd4p=k^F3~pL*wJ?|TPq zCx&z^p+RHw&J4Nh3t zJc4wIL4gx_#q-zX|Do(H!?N7AFx-z;Qbbxn1tg@AE(I0o?i8dEkS+-kP-&5p5)=_> z>Fx&Uk`j<^kghX6bnR2u`Ek~ty{^6Ya=qVt-#O-(W8BX(3_a;?yB?;Ng;>35iGEB+ zrdNVCuQ!f|xTH|^iTJNmU35xchW2V>kMF9!F!mXffH(9~30p zfuwG5G#5{agc+oUO{+U|l@FWysI5(2*}Sjnc2{47q%_~ny+tTI&es$D3o&` zn;w}qvf@tf39(=LHi8JlEJ?}iQAG%m zngd4nh(j*QA4!tX`Z-vyNJB!*$SOA=eVx!4fI7(#)5?tUHl7sFOPBCOzVWexMtP#5 z2CAB2yPRFlTVYeE}nPcPYbp(7An|~EuB*)R*jej;dA1+NZsTP}%9HPdjU^tQ8 z-^$`yO7}>P=uYtdW}V&s5C>mh4c2?#2XEnQ*pm6fiKsPj>5eJCcF{Re6SJ_e09*hK z*=yD?ctMPGxXWJ!MT}D)9AJP6cmkv>VM_%CQ6OXM!4d^b+yoDSNNoUx6SB;Ia#dY2?7bdu2Zb;Dq|5j%UNB zkT$2D2bZdxz$;Kg*mV;DvWa@Q6gh1JSL!g3JB5H!&D9tikhkD@z7PTm$TrXOFbqsA z;2H+H^at?e;DQlCU|O1q|MH5l=+oQ5!XIv4oWFY4`teqH{iS#=39nU!`}*JCYW*>+ zZ`$3a{c@l=Jv>YGhD=IrAgS~0@sLE4`}zM?Ljt~@3Rw6 z%~=Hr;vbo@qWFa5GnMlXHY6R#^!9xrnao}Y%lR=GE=|qW5|gf+IvhbmT z!TS)8=nm&p(*T8zP)KGu3NlCN#hH7)x7-HqK|rzfRKLK2GKD0=IRF3$P*Tn_YQhFE zf8{s$;mp9-4OhnR>SAC$GQGAI0;~*Bgmuu8PtOsBD|kbe7WeeRLLgYC;@!SoE~B6k zon>+Z&d3z$kU&9hVr7{zQm?Rd)HI6ZjnJ0jJlw>}AG=*!P2m)!S!8bsTQojJXW%uv zIcIHhzPF5WRnay1?`%?i*{Ms6yi1FPrr%`BRJ0|>DZAD%Huh^5pVuz$ZeP1lJVnr) zlH}%F2eja?6WX%LgEy|wt`tjpRQzDL18BPHd&s%e(B8kYIq6Z*TV%yoxh?HtJ^KA&da!Z^I)aRna^*KUB_%D??!eIz zjezy^l-L@u=WCIYNp+JmJBavMK*Mk^QS_s2Y^vGhV+}jW2y6wMz?S7Z{{``|*WHRUVY3+rJFp)0fzT zQny`*EnfeS7xz&S$=;jVT7Bh^;R3fGTK&w4FUwd`$Rn9O4XDAo_I7N*2nO1~wi6H9 zAb|g~(+`1I+oz}q4;Y2QK5i~9yVD~l#6u6|DB!`dkU$)=5d|MVc>I_Qxy7vs#)K-k zG}EU4nhq#HMQ>esWb~-z$h9CMQT1tM1kDbDDFG> z*MVOu2`HzUj&@f#EeF1~Q0O>CX?(0_5Sq#7zNKNV5^?HeaFnkB?a?oY4um*_^gNqdr z_Cx&Yb1!ld_A^Yx6|xaxsB|?z^L%<$ckikTc$h%Hxha{TkY+u9WOkx2a)W_}J&GSOjvCCA78MCX^E=st6XS%8kuqel6UPA&Jjsc zhET4swK<=<)4?kT7eTbd%9|3H4L}17=R8D3fSW`i^yY@hZ> z#W%v=ko;tg5iBkqVXA?48>QjqK9#2BdBG6t1Fy!LBi^Lgh*;fjnwEDqDKgbQH!JvP zi?hj1_1f8sLcaf33}=seDbC~k5Xhql)p04N9-T*~jCDRkLr|C@v2p%M$;7Zg+72FK8C`MPS4pT3Rxjc6%wH}r#*a1sKK1AIk0E5X3f1po z&CjdhmNmg_9jzf564LnSuVA2gmjHo_oANfy_aie)!FgP}Fc}WPz7tpY7R^d*g|GRXWq>j#mH)!bypF4473d3;;Up` z?Ld+{Xyd04zeln&xwi`0hnHZ-Zz+1^tTLyokhnhX>~4-|GIXS$9T>3?@O!*|K;khIXIvv1;ra@oR{1RgaRC=6VmFq023;qMe znASBS=x-jNIyt*%)G>T2mvijf4n4(qOc(C5x}PV9L#f-%RhLyWW5>`$#)1A@T$FK#%;=n$_%T#|KZ%ba?^DxqWxsU^ z3dQwjt;s$qgtCGJtozT2{SOZ|>usznD18;sc?MqksI+mKJKecDx+3PQ5P%{L1D3jkzyL-ROwSU4 zlLDR>X~Kat{s4j}dPE=iW+W;C>Dx_EtN|}dChEx#m42MEO3Nf+Wca+rJbLO#KSU*0 zR}7^{Ca9xSTD5Wvbzc;Bd+r^hatY7jM@v%G)xBELUP`2@+O!ez)}$m}Tlh>ea7pTQ zeRpq*p{ZeT5!GZL^ZBE-VsmRXqO;JXFsBG?g{X=jS6O$Qnz|2Iv^m=ctEe;fL3{+?9W4Y)%(r@!QeM zq_4&|x1iMF5>)CSMla`a^7^N8(5Um>GW?~Bbx0T(e%#Ic_1(;kqVIuOYndEt+$dKi zXtSM>mV+<2eX+3;1RX4X+UIQF(bdX*l9@%I=S3N0(!qy+Wwpe-}rn+AG?@25ht9=K}p zzdamkzO5~@cJT-IcHG%GV0$dfa>J?@BWBi~(_vO*T&920u&q<`ZMP8V$NA)l@MHYO z@A$UA###+M$3OFBg~){`B%w<=3tsc~!s!>?sQvgzkCC<^{CGp~YyVY4&UtPyp!~)= ze!1agkay7V9nn3f-YzZFwh2wfVlNztu=zZ)Qzkm)40!{Z791K+Y*-gCQ$|wSaE;70 ziKgMRxel3@T266)Umq~>=3iBr|DUKXT)mmVBEt_vOWE%K7ZeAOLKFnZIgof9^r@zS z!(ntH`O6@xjW<=4X}a-~*J%{Uu=JPt3N#;%rTAA^yfNv-GhsZjbrUhpKnW-{DUl#!7-t=iaV{jR6-1(IgFF{I~J^K3@?xoUx z2$WE#nfx!_lKj-C7-fj3qNl%1O@mCb1B9&~D@wGg)EadzgcrGCAPiS0D8%oxZR0g+b}bSH z85(imSFw(c1iv=N4TS9GpQbhq)7h2zQ>B)1{C)ert*tcg&AF&k!4}t+0-|}|$at)Cqin{%(jq=?+R*jk*gxmz#76w0E2)i^H|DJJA|-o#hJz!OmX~nA8oXTM zXS8$cH}zS8bjy)=x91U@cozqc@VQ~3wuJH800$>WJvzI=2$>kJ(I8Jr z3mtn6Gd2CiepDkBPr3S*$eXsg6rZhrTuv^(HAB73(@^W$B4_TxwPUc9R&^X_9=7M6H4f#v+~$U>l# zR<||GIgGoejZW$jna><2w#5UP zJd~*(A(&~QQbu%sbFZ3OPv%4z&vbDw(OW0z+-HBfDFwbWkSqm&;&rIcd2S2FIar;Z zfo&R6cC1<9%-Y#Sqi+tTuD3w?jDRKlR>BH)jQ}^%^75+ViZ(SjM{A|K3j94j<8K*+ zWSjLN+pt%;aCW2fx%p~!Ah*d%#AEr5sqKdBY@AsO8r|9cKghL%Y7&-OzVtC(*ze-8{br1>1w^EOA;Kum=PJ`Qut zI(CQruU-mYa>GXWEZ05zos5HtAmiKfZ7ek}Ds+5!bKbfv%!|+?9LxCn-Sr#ATc(nf zoy$w;w0^0-dZ0sbYyJM+g!30z-_`YQ@)QhsSZlRZw~A1pH_hk5&4%_z-_@Ive4jQ# z9zQMeAl`H4Y5YES`HNI=@RP$Ie61(DFBps2>aLJVSXZT=muFV$xBlt}9fJ>8ffxeb zlULARv$XLE=|&CeJSaD!LB$X`=mTJy`OY{$@RpNEQ@#my0xZdir<-h#Ra8#n3FH4q zlS%i36r*bCKb-96#V{LprL;TP`O{A+coQB=Jj#)_CD)*&4c;n|IFD8jCttF$iqBN8 z-}t5cnfUi>i(P2_mL-8^^saA8A)}%bI|CK1d{$ld>eGR{`QrN&cu(kFkTq^U-}DJX z6Z88^8i!XcS$$QZd0j)AAoTjB0~QK`H+k)qub$kisULN#a{E5P=!I;Ruh1S*rG&?d z+r*%DljO%zao`5@1=igZiX)fJNt6iH#)wlmzZ%BM$?TTREyy)2f`5x4*XtdU=YAqBQ zpqqBq-LsouLbhNVxGu-?#9VPZE#i$Yq5GiqD>0+`o`Le)Uj|l!*Lf)JG56xD3d9Rn zW^Q`fU^-7!yt-fXL8Hy}Vy}L6&p-9lc;jYSp)Gnn9wO53V7c2TuX>iG~3Y zzG-Ree~J?lQiT|T*oV_I(iIv1P%9WD_JQNuLtA$#?$nD1*MC|Pxt+iK7~46y`(Db~ z8+miBF?8GGv4-I>*@Z8;i&=ChWKQV79R7NyK*M=D;eNKLR6q#G2NZ`l0Sa8gC^I*l zV~OSrf6Q4|KvZ2p{c?+1)U~L2mVNC0#W|ud1<7q;^(?y-46y+h44t$V`8MU5s;>R# zN9v*K<><9!-a`EDX0v`c509Boo%V%qdmPpc^puLXlmZsCkudsd?Cmv#PvkhNSTS|L z-k#I9r?_g<{y3sA+5ihoumKiNRd)yB1bDx`2O~+AXjX;rmVW|}1}1xmo-j2EDm|Eg z3my`Q?*Cs@A7RxhTg#l$T*S5OmGAuDk>G6Z^R|rqa5h)dae1@Sv9!M>F+h0YaE^_B z$?kEbFW*X`Kd=^vUzV0=8Y+}@3udz&cg|;WD;B^j2t(*(ve(k=wT=w#bE}M^@xLHc zl_ogmwpY2Rs0os1*8&l6lV0aoUXYR-%~PcCw&!x3#Fgt;qAC0Uk7aqrQ!4Ju06~9R zo{U8Igz|7XRV40&N(9)iDK;dm$Q6phLr1j*Lud(GdOI5+*#0Z@9| zwtK=n{-b}h9wS-$CpQx)TtJVFbj642?41F9P*fm3LJ39N?f=9PzZ94aKm{Ku;)DMX zXN$2KJOtfo9*D$#FD!sw=ZzZ-jzQ{jz}cV&bR_os7cAmeL8VL#bc3$?c3P&=>oMsi z!TBlZXxds&3X`cUM=hr=Bg@Q@savPJ4g85$X}?fD{!F&`6E||@umO+{=(qrL!V*mF zrO(IrZW>B-dBV)sa)-<>$4c!IkOqe+x`b83g+6JX#$QYFhUZB5|<9=c) zc>j)qsp4Tz=R()fEm3wNl`6EJX#s814W(`a{?*H10n-en)`;Zf+^8h*t%s7w45$)d z2t~6G3R>YdcqU>2R*NJ=y-#;zVv}NHUkf zw%#V+(Zx#gA+?)VF#%5~q&O7m!vne-B$^9^;w)5jVIG%nQ4tT)fmTIjt!VZcOj-a5 z4(Q^qK?)r3{~{Ve!ZRQ+2^CF9=dh5zdY~T?|GyKB$U$7mLp>LXd{S8gDo=4>n( zrYpJD!SLI3x@zY>EZ%sheDg70c}jF#SA%g|r{NuLkAKC))R_Az(zPzfM9|`5rq;{M z_Dg4~CSQM~NhJ=(#01EnNi0ZF$X$z?hga0SUuaHnZ2Y4cY zf?WH5$|aEtl?AdNSLlYRw-J@aKBeBo`a+BeFHC zAe8Lvn|yuxu{Zyg?Kk^F6bp-;TK2O8U%N?6Xs3qB5CH`y`jgHwZWIZstp-|X>*6zc5JjAb8Uql)uywV5J(6rjfM~o6pjyNbod%@wiQ9&`%cQRiLUzTA0H>8!zp#BN%i4nA|W~BfLQP4t_iu#;u@-x%C4JHmRO0` z{0}v~k8!=;h`#;p=^wjpX%qr&V7qrZuPv0~-YmK=dVIZE+x|H8IW^T2Q%0hl6&=Cn zVi#!Zt#4PQqkNjq>3)R~SqQpOhtS;U+h&X&=aJwGYn!p3CQf7QY{6P^xy87Sinxb; z*_7{6W5w>t&8Wv6Ur$f|oBc`MG3Zftux5viuiGYmIf$^fB#FG)saP`e=WW521aNqw zNyVQXUYvcbAv*rGq&SWWIMJ3`?XD+ugOgb89rY+(&vc)&t+8>vce^AP{3z^0$Tv^x zf6=2NM%!nJa>j1gt6IH01%=~~nDXR90giwhMr#{W?MoRCxE6+A)n*!xb&QDwnOtk$%5KdY4Zj`$1N!xq4KtA6B(3 z&maGvQ&KelJ)U^I?E*aBRbT{r<87hUeGbO*YgSm$DM>u}ePT^FZ<3OthR6Brg9~ED zftzzs2q9v{`%3jz6V*dzWVnDHFA}B(8I^X29J=7J z4=fc>ixcFB+iNK^>!ewycwPS}5)Zi+~(Nw{W zt6yufN8R-AYmAaYW(`q($$pW9&N|*bZ3CKbpR8qb_O+1UM?Vrg+$xJZ5IABy1At49 zTWFQQRYUh>Zd7*s&;|km+EwU5AnrLjU)>Wa4M@_}{wuah`Y6S;XhRWt<(QDR+cb}nud*lt&TsVc})uJq<_Cwk%k*CM9}=?8-iW8RD+7rf$S zR%4S}O*)CI9I1YIS+cl}+q3q4$bf|GRbW^WLk4FmEPs27WSFB{b^d164J;eeVk0Pz z-JIOotW)3<-zqj^I1qFd_WcVI5)zMka}rHm50;eo1*-A~zBJigkUOrnks`l3|Tm9CwT(e-syb?9d0zJ ztu$=z4RJ&+VI~?~W74E{LI;`a5b@Gw;x#A%^)EX;vJ!IPl%xNezdR)MJL5h7J6E)r z{*6!hPI8>d_x}bOW=QqG*;g%Xc~ZKwp%8E1?v7G6vFkf>X^xUGBFvH^6vRp2JP)o& z_0=89{YHomcN~K$wcfZcbl!eoLXV07zEgA3UDH2i#UtXsbyds+ZD+K9G6DVU&r?sp zhFS4Ap;qrVrY&KkdW2azAHc=AIWSR%^2Ocd5jUkqw&67dl#n(*cvxjsJ6&B{wOslA z_r5E_bbos3z*<9i`~6Gx@_5?K2CJg!B|6gnWi7#(rzN8toOg42IFaZW)H3hoNMA-Q znj4UI=n(jS8lTz1+PwY`Wm=^F0?@u)8sp-h#ei}OdG!F-u_=5s9UX};42zDOr_?rP z=^vA=R5+i3CTF~(tCo&k>~5j`BiDASV8JqK9=YtzhXr2RyA1A!$WybBiT9u8eNn27 zNpW`eBi4w6s0u@_UM5QdH%{~6iN^FB5^Xo)%ffS+*qrBm)WA)mAs*kTQ{DIxt5t)8 zOP4m)sX_H`!TwxT&cIl$dH)8vVx~sElUzJmc%0P*B1a|PU*@N*H}#GVXnMMcphL=^ z$MHU;;1g+9upHuAm$~+&J0s$kvorP)%_%YBMkIw%xeIA_#ffFCW=eq6Ty*P2S>o2W z*OXfiJ60#8hN|(oIHL{C_fc6C#xb0#Ax9i}^JRz)DR{`3C6i7oO-w{ZmH6W82Z~=N?V9Q)!EUC3!)6e{HztZp@JN2y@ z8yjOaw6)eYF!DK{ns-k|s2}I#5!~I+T81hJXEwMX@O_;iA*vKi z33x*cuto1ytr6XClR72S(CQqy8+;sBJ4(JgN!-yX`9^j9;xthr&zb0GdgbI2k&xCW z%@--f@v#DxrZAV_&F^U^ML_ddEIB{Il|J)v!>c^G(r_;VrbFybo1P-+qqAH8_Q_WY zW=2)xmQh@w^D*}Ocd-(MuZM7^1c@NUExxMWJyNuQ(H2jJ_+?)~Yy!we|6r$$JNRqYtu`}diWMO z%tRY-h<+kY>fvbh6eUB|#jVP3E8>z&NYnVEiKaim_-rZJ+=k|gkMx!Bgyd{u&v(+F zT}$-MSi%H@rFKtxyVKet$^Rb2O61?SRgrXZ=tCyQZQWqG`wEc5)scXA?C7TL+orDbaKWP{o)e_bI-5^Ru;pwWzD{-kGRg|O8KB}Bj zaLM8pO2%NqRyl7rXmE+RS^EAt4Wef_?J|YVFuG!));h<&`T;K&8HjCuJzIKRbIM@B zs?ghAbor=^*Y{7&Zr9(8CaE~c#bI;3oc}YUs{77t-}~AZ3XU!|K4@DJuDSO$pv(NN zhZCt>vmYUOl{Sfjh^1`LD{VsjnU{0D_1`8j6u_`NaTCPLlu!Y7{e0$IM9_62w6)%{ z>N54bONfD&6vs5W4KBkHcJ#Bpu{IWrEl`T&JU~Y@E2FKxuJG}6y2>@ zqbFwKMfqw`ix3^fN?aw+(fi#GE{`zna2Vh$gMPesxG?&9Bq~);MpE45$Np-p z;k>)sS8`06gO=1E*$3|~zRq_Ns_*R4%nZ#);RN`ok#873HAqEdgfd?3^e=e+nwe2V z(tk95#*Rx+l0kvKL;QY7X84o^+8ag3hVj>Xyyi=mc*YX(*fcUqvFw;h`neOBIPrg8 zzVYpy#rsI{4+&nxc$b)7-yCV7>B2(1BmnP`bzF{vsfU_M*vU_x!a)C&^p1_NZv1$A zE4rC_UVASO3w($gvyd@wneX zC8_U-&0bg@5g>i<*`?!Gya$eoc#gJ4T1&ILUq>&gEF()AgnpJh-oZ&4w*L^VDg>8< z+KAmP;+3%UTihDiC9?5?Ut+JAhdDdR$>0iF;ARY76`SJ6yhAGhiZesU3H&^cceDax zl&2Ej_ftLwpkM9$mW)n-gO#5Ym46w|k#CNFlllk5Y3eu!Japt81h+qZR@+0DFj4w- z*{6N$w%7U?8mk^NiK`$)cwoHDZDyIjR84J0wL2fD{dYPzu)u-?4mlG>l+oJWPvdC0 z@#O7gz17|?IqO`mpc{cS{U%6evaI(7VPhkF+@nJeiqK#P;YGLGGg%bJ1*!rkc&l|@5{0%_YrB$vOfmX|!KMwO@HSA5$`N*ysg+&)RvHPgL zq!5~An>k(yBuq?1M_elRK#`cxd3(rw|DNKwTcuWdqWT0Bz@C^qeF@U$U)IWpbBq_? z{_Af)k}(<_fua!;JD%)LoS{7(S+vDGYbqij6DQd>SL<7g5l z1Sb`o>{$QeM-p0_mcORMT?`%hw3`|kVvE;$YOfQOk9^9{Jp0%mS{kJ3EP`G_ z%w$wv)rm_aa=K}nSj@q57ZagL8D9%+?Zs8Pr=;_`%DLG_^`}qYNO7kQ&Ut#CI8|BCP%RbnVeer7o#EZ7%2v z46?7+>ij58Ig0O-1`OM%@bLXrSSvTFul`sNo1(r|lE7_;A{;tcceR*Qwx=|jf!#of zioN75mO@#y(Yk?HqMKwfO-)i;$eWnmx#DsvjyPE}PlA|R{t6fG_xxoR>YZfPuHO|= zacmlbak6$Mo(Pvc>`zKg3q5Td!CVCQB|hnJTC|7@ciD^&=1~qmEcuoB!n@CS`YGx} zl~&(^=y;d6h^G^dZS8gkO>KXcBTTpv6}ER$H=Jlg-zRhh;Z49^z2r!Vhjwf8`A)4-$<~Cg)6*!DcWTb5!|j{|YLRCbH?jn@QGed*gIO{I_U_cY0k?|RL@E7x zRrOy_f+;tFxA@a_!#co@pJJvmhrZ1!OnD>V0&C5diF?_|Sj^FhFbt7E_H2dv>+ zeL}xjCgLt0>hYjfIc->Awb%o%{GASW-i_2-b*)*$Q?n;X-Mk>5e`mEbeczg+iSw)yjy$G86iwVx_TLVA=2;{h$$s8SSCY_^q0m2@qGFA=(6jU^iu}0Ds_Sk`cS@31 zu+>P2&T?@>%S6AD=-n^GH0xTJwW$MoCiM(|A7p2uSmI&u`OFOqw_=rIC-zGw;VuT$ zOGB^7&cm_8l#B|tSBDG^ji!=Azk5*b{_?$DMJ$|1kDYw6zTfWMe-mP>{*=>6>$bqd z9GVaAO^4h$F8p$qf`Re@Pu{yNE?rZPiN4u;osqwJBtUP8y!Ulu0lN7{tMt6B!X zuV-1;J*A5OPJnV{b-H2fSwP<%uD##|_BoZmi(`+8Exqbl!4;X&!PUm*NG0fGyV`vq z`s8l*+^nh@877P)FzgG(IGHjzT_RH_MSw5FSa#sm<++Z=E(ceEEthdwQ$hd1v@f=K zpS(*;#FC3^ma@j{@4j}uANYx_4)v?OG&fiN$N)(t z?#55bvn>4Ok(XD_WJ1#}`H$s71lsHWvv{D({nBS#|L zCf_S~h3bb%FZ{iKhEQCgamp-SC0{YSq5E)eD6iA01PWtbv{6f~&4{b_K39^h=qAhf zMbqeY>!=HVM|~;#yU|4L<#OM)P6=q|mm~A?)o%>>N@~?`!Rbad2hw%FO-WC6}M`h1s z1B9w8Dpc%7a|;P98)HNQ64W=*?IcfsSa%CZceg&$r5apy1Qq`M=}6=fKgPJGvwE^= z#+%I6#>nTmJWw09^`hQfX>2&-2M2ESmyPL=H5|=kryeEhU+YbaM~N1s+VM zZ?z|ccrbgLuBLxcxYFx&vvzB(bIMxecjs;P^oM_+s#WT}=BlhgWEVqFSVWSU)99BM zFASRZFQ+?EA@|(CjIfQ~A-($SfmHd~y8gI+4Ux;hhAga?2CG*XeDes;0&l!el#Xou z26Y!d^R@14`?uD@n{wEh@30e>aSNhS%QNk|vqR0?(GWS$po^lR(bCedJI#sP@XJr6 z!_{QWbH>kdQ)QUbwT$WPfN!aU9l2*_#4~nX7ym5H7=NBG$4~q@v@^FZI$fBtBIx*? z(z)}?EP?Fc3)He|XDcuH(Z;XtROJ01ac(Ag@5c9h#d66x#Ah!MavOU0t>)(6fZ$+# zJZ;o0C-V415b5D6^}}m-6B!qyRnk~Ykg z1gm|)_vB;#hL(sLrXq??&6uv1ATIt7vx1J6dM$zQA}tK2x=l`#$&cM$NTO;C zzMkDXO1wTtz`HJ2vWdweJ@zn9a&+h8(NOSgZ|NN}ihkwHza6{ZFZcU@S|=qvM~|Oy zs%o3@Z(GLu?bG%{?!_})8*<$Y&f=#uGd~8WB6MRh?giUkqA99~=y++BIQn}on91{k zKc0ql+Bup{>5s4;PEqOj2{S$z683gq=&cJ?i|*XWwN)^*IHE?p+wLRRPiGaip+*Ro zTio6WwZ{6@zART-`G`o;prEaDBBWen_u0SCN+nHQsQbk8Rr2s$Qeom{Zurs-Ez4dH zkL`UjaEy#BJ{M}>IGC@cIJ4ckF1^~4Je89*`ARA~hqkqU;ab(4?!R~*b2q5#SIn+} zXCb4XgceE6vk#KT9MuYBi4;d=xQSN_2zHJ_F*?tucnJ{trY<>eEJK@Y99}78XEyQI zr!#qIL|^_Jksq)*1{Sc6?;hUY`z&BfZ{xz={B*azam$R^h0k^Io8b7!mgsn=4Kekn z9_@DHc+>6Kx)4NZT&FOF3x+YJ#_;Zac0p{El-*wtN(}sa z-nY^>S#rk~Fa;8jyr&W5$wvO-Cyqh8?E5l0@lO`!qYUi6GEyR3BIBNLW}DM!2eR*- zwvis6(WMNFG-5syJUS@z$p75^0v1%w%ixy%lIwceLacy;ssC6q3*!fFGvvfY$F-k> z88*$qoC|M!2#l?W04F-M z@DCrPW7zauVf-jLzugVcU$FGsLc16ifg2orftbhj8MHJ3>1<~#ryr?-XM|aj+q|QV z4ssbJ${zBrAJ5XxlYdYtT+NSg|cBn8pKSKt$gZ2E%}vDTM$K*wf5#$*ay;|a)}O_pKgN*zqkBIhtf z0QPDB9_C&JfY}wq=ld|ZG>%vvJi1^~^6bWj0%(3fG#ypbThq&(57&2Zg6{g#_6W_vop=!Fwq}4hr=F_1u49F7fKE8iBCT077E&&&bD83~gKysyBGnl^%Y7IxVt+)? z+b3iv`I$a#HR<`Mc5ga(@ot3$%E$0IQ3;wvk-+nd#l93Mkcz&oxS+Rms2lvl`z8{=r$y;0i&>UYR=r#k3d*})&tXl(*+e26u|is zxm7{M`WfcrAYemhjEgd~1H0P_U)aTl)BPx&jj7Ph-`TlaChru`_UQSV)B8v3^*iRY zp7@2vj{A!1W$^DTdAou6gnL!?XSGjT1&L6*P3D+y`pmI<6Kku$zgrU<#mYYE_E6>B zp*5GPDc34Hh34JM3+=9Oz9pr_!V+x4FKaD0Bi41gl-<$r{DnEGHkJ=c5gQyHV(Hd1 zzRgv3d=+Y^cyC@O&?7BQ1D+t&vtV7-F)%kj|1L2R?;cES>o|iUlvyyb5eBwO9=uOT z@N5_LwnetkNTWXqkgUhP(_MF-AFBNXzXJ7R;St-q#YFJ&*dxf+jp;GQtM)vi(-=^G zt<1MsvF4g6supm^S0*_8y+!_t4r%=|4!!D-)J zv8}O)n!Q3B^6O2+Jn?pBr);j}r@Osn#+rIZ!@&#Re|;ENFY$ZHKv?!G!MdaB_W)yE|j;jhM!l?u-O}+h57xehPzty!>;Kl?XG_xpm?7!{sXvNj{D9QVSGq z3RB2f>?V#YW{S9!!UoOS&u;OJQGF#VmGp}Je(RTDLT=wn5UM_J7d!i^hbG=8K3E~1|*kH-XF6p zigPxk(y_-!<8T|kg(=B5j19}nn4r0P7jzz#l?gRHmoHtiJ1NV{3rEV$dBK+%ad3Pr zw0nn<(M}*IQ#AcuZ0zFq%1UA-cz$IkxUG(#nqXV)5ep8EPDnGpnS8ZhM-pqDbm02I z)!7d3h=)LMZ7b<@&AV)Yz$F9jq=;R?_s8Nvx@7-OC=A+)p62)TEeFmfx0~3CJvR5b z9CU^)$NSPKy!3zEj~KL>P4|m;byyI`Cox6g*l2am$?9#~GIW^HO~1*>>gF+Qgq=k{ zuA0uu+t3qe2H(o4H81Q(%-Yw4w7SKYadGJw8DA$PT!-O3uY-adEF<5&L%k;}8~lj{ zQVp)xNZHCrmW-J3rz(tE(Vaie(t`uv(+kn8++ltR4hwXZuI6`X0O zmn@I{%`>qG%gjL=?E@SpaH+qHRvxh@9_1>VzfA*fKJz== ztveDPVeeyd<-+yDkaV#dOx-6d+4GRxytYJD8`PC+s_GY7S>!+%4~cGbD2DuO3x=A; zCfzO4C?cJ882vu;S!eXm#uSYYj0zMQ>`D@epP4ao-(L?YDJfA&2Kl8DytXgM(-7U z5Mg*2qJ7GK;}v+6@6_Y4BP|`hj+PiO38-=J0XPesJ_mw8c=KMIC=AZ}1gsnKER>{n zdsQ;&j)TY?YzL$LJWZByhi(y9S69`oM7WK##z}V+acoDTt#;daopEt+Yz@oY;qeo3 zHC7Z$rM=nMUs7*;ovD2~ho@gN-c8sVdwX+wZAb#HZ3|F4S)lnBGbTB3{rtza-8{Sm zJ(Oj1iBNBzfe>YFSt?!AJ_blam1z1p)P2iJOq)!#raJ$PQtk>6TQ> zSM_X)wQvx19Se z7lY#3IB*yEcTgka;-p|6jg*1{121nh2pQgw?SWJOZx|S70xt^&DfL0xn&i1H1t6!Y zO)|{1e1DinMM~NNPh7S;q|>nmadYM%FA@GASy^1ZaXX2q7b7-53z-mL>Tl-B3Q25) zcmL4)TerJq%$kx=V|GKnc|4zrnucqZi<@X$-Ak6+YnruTSbRn;zs^SVPtw~AY-epd z1nP-{CNXLoemD1t?ysx~5(?b;li<9*=)wxeqbatu^*GP&jg>u8Nd4#IrM&vx42ucZ zh?|3{OH?M(?Z@8JFt&c)uPx>k~n`T%+r;RwVxdnVv)Toh)tg z{c$xs-6k&_c?j04g%iBGQ1z;{V$>5_#)L?By3TksaVZhEWv}09WAA5UgJi<0xq#7$ z^wYA7W7gY?x&~p{wKY-g#%IZNk$UE07D6TUmUn-wh_3~-xTa4y9h7^hyJ!9M8gwl? zyaCP=;R-+T7}&lxFUjk$agd(0r(@ud^rS1$z>Ty4uG6~f?dkqFq{NO`aeOFGDUNNMzjRlmLJw0#;cJ3@7GsFFZ>_zl0>+rKs1Y$5ww+XXf-zJD9F**Q z1maaE-}X!&JUDyQZLtvQH4JNB`h-gwZn|FLh`0*hrw7v*s6MnNABy|iQo=B z#&(B~HzHwm+TRn8vK*MlSK&N@FM>;B@aY-e!-o%psf40o@HI6IiH$6NF&n~%aE0AR zRY!CWA`!XJ|H0Z{M^(8;@8T#Jpn#%+f>Mf7(jZ+1h>}W5H%NCZQbjHg?oHNe-<1&V0?6K9o*Lq`q=6vQ8ZX943;Jr0yVYZ7H z;DRa{No0^+J#p^x<<_jcYLfAybxR=kLafhw$gh$G@W9<2No<9D1|)h3ia62?=*sco zaw^5eqI~mMcuf+WS1JFP%s$Uz+*zvI)g6=kZnj!zF4~pH1bY3-$wV~|OSJW@m8mM$$ z+vdY@W;S~7Oj(r|t7OuQpR_IYIi*x(0)m{o zpYheWC2tJsMt^e=^PwL`Xj&^+D<;l+%kCeqX8PE>Bx|Gb)Em%$FBDXlZC#PeS~=!U zTEZ-kH`e9!6gu;@mztP_4{bgt>z!N~W*i^DB6y&3Q8k8i;H1|q60e7XJBol1klk(q z-n}y=Bl#x8OiWB5Bc!-^aYk(nrn+WV$J;mL(4lXR)x8{`;$Hogi?crgDAF3A@ zE7s9_S(I|wGs)FcuEO;4#inH8D!KN(FL#Y3qpp}7Ml21N`ihD~PX*r^3iv%+CD@<* zvvQ{1{Z62=TScPSa+&}5_&A>qCW=J_zZ0LA`+|i)N=oX5zkh368|0&egTxzh>cD|Y z(z533S62AG@=i_#*S$sip0Knj7a`0<^Z;x~`G1??>RynkIOiyBGE!+Hw@Y<2ykTniHf@%Kv$q|pxul0GNtjcEdC4uf~O)adg7W*Gow370v2>jf+ z_3cGs35zGY_lc%IJJbazL*C$YD@$@JCBm&n$hPbpN32> zJ3Jsx*I-tZa=XZb-@aACz~%UNQL$XX_`;kwx77ZL^CAJa{a&I}_>%kklU_Rx$|>~2 zDtT2?4nu39N?t6RZa<>5&J(cbbBsK`k$;;!%{mE|* zvs@kDnRp5g7&9dxl0Q*9HddpMOyLSyvFVGd5&62CB5~kz9y0@&4^qcOVt%i1Pv@X4 zvoQwK1=W_E_RBRlUxc06*Zr-tD7d_Xqq(5sF52cjBL4Kk6aOLKYr})z=)Bd3TZ`jOXqnu9|V{lao{Ory?UG=YFOHrR0F92i(U9 zQd3jQD$PL?2^NPC%qdo%0#h-lRa#nGuQ4$NzyXr(%aZFpxyy1`Y19zt)a=xU%#zc0 z3;zfDINPstx<7c;w0>q{!}5y5uRbijxlrX%X=ZEtV%Msu?atcx{oiIxgL~X3CuYUILg>nM*-Z00P!}Ef+g0o1UJ@$IUVwc1qDkKlEJW0G#9Tt6N)$!Ib9Qe zuijRH!h6MmsD!M3q!Uj#{p2BG(3=8Fpcp*fau}XDf!cMjw^6p* zJ@MG8bPZY`f)1(j6or3VT}DPffHQdZ{SRncOOgs~(}()Xs@gew&#tFO+dBj_4@Aav z(Ph(pxQE1hEL7j+4<}9`;uJcyli{HK!Q=QM;b0QrDAkPiL-X+Q$u>#&5Pl68&W<<4s08(>Oe} zO8v*l#R+PWbqaXv(9N)G=1!-COF~@LTgaBGQb>m3lY*MM1>EZKbLq*nGhj+74h|J& zxn6f6-uTZjnjiT$>n+#Aoc_NiPBrg`DNrX{YSLhXEgQ^NHeYxi={XRd5ry_g)SrLvXX z@j>#AcaP-_+k4i@n|uH0@8}=YfprVcDwp?UNG@Td=6P6O4?MgRiKpz>53=}vUb2$& zgBKThbEodw(pt6~O}Bkwd!lu9O070Y?aTWTe`xjdZraOm8B(S}(e z_BKRHCN}NDBsT}~?9kDg15gc79r@;+S0Mad9s&$dldoC2`fP)dgXB_hry(FJqdISu z?k9C-j5c(BUk$r9{PX(za{%$Y2Z*PeEgog-b&Qy_kalM6j)2FlWs*@$)%)u*A_SGC zUTiQ_N_hQ8oN|g_6{I zX##pv+_2}VnEt0uL%3-9ZYByz!b%v=ik|*_0eRLjNT%+@#2xrD$Sm1DLbUS#hdI6icYm`D#OxIzEO1fv{>0GspO~V!=_NOaZ^>UKg5U0|J zV$7;%S^P-mED_8WW}ZrrJza6>e1v?bpQgnca6$4bb_B<2Yrn5?ZhDI=ii?#IEnNW? z`&_UN(~I;J8MI5%5fRhYl*NNHVODkQoJ142a0?Oijyi;>$y?3*r2`0K98+UUXTRjz zXg+V>HUBv(?x23cb^(vh?&jiT9O!9Y!vWO+52pZ-*=)KMnRv0M0Khl)NGvhi-F#*9 z#8v2DK&#VvSliMkxxGT^;1cG^$mFbSn^swyEd0FY1HIOND?YyUYC|+9KXdPdlXA+k z!YDd6oqM5~(-mXFr@o)S8c`!=JrOx#$08&Y17}#r?3?r~r0;aHqiwr6GlIX|F%;{c zRlJJ8^eb%+ySL6b;A`;SW}B6L^nEXbtS?e_^p7m!k1KHokC> zh0b@QkpPqt`B4LVoq%{r@!N7=8Z)|Tm5frDp4>Z2=%Dq8vl{({>Tom)qg8J{(4HOk z;T*=lS|I)c4K>O$4~@DKL|_FI0&bZRAVfBzj#XfW4%QL^gkgJ>1|UCJ zLvHm_A-#A+A!Al;TXS&O+DIk`hak3>O}sV{mJEU&FBYuEQyWzk}I z#Y;DZMs1y|QbOZfJ6wNq?sy(u;mV_L|LU1YDgJNiulA!&0v~e37;qtLLDg9ymY3>e z{ZW1T{d`o^*`!&z!KUEXxSdb!OJOmmJDCe#uw-1YaG8yS#bw)jHt(H@Ae+(3xEh0- zSFb*UD-7c^y22B{pB+zBs7}ynAi%ga6VuGza_Pm z33FqQ=5tLOrm3#CaD%aSG)Ks z>%VdLd`2t~m`o()%@3Y4ri(V15=Wki96A21{c|M>_l1?w|BCv}TcR2&wIkLw7FwPc z2!Nv#k~^kV7paEsIh!1KmQD_G$ng-xLk)stIP_=8CzqAHy~P2)fppzBfHotL1$$m) zJ(!|>8%(G<@%Mb@Hvu*o1uj;cJMrLh+W(9}5-~xlKmi+G;E*3{n2PrWPNp!=yXMK< zkD8_&gVBtaXh$AKbly#Qc1mtZuyVMl09oTpOQ-T}eYxn2lO=B9av4plU)Gm4YA{1q zB+K(%n@e{+Yz%KCEk}`t2%6GO1JT8?4E9p@3D0}~vJ(anHfx$*`f$0Z=JF04=4G=V ztd+9zz@Pv^k**`Z!1hIagbjK19*AhHa2o!yw}fNFO>0czcd}O=8B581JomZ8AN-%s z=VZwgiU}p|(QF&59fXA)x4b9r1BVG~{_}|5tt^eS?SGmoC$?C$WN`WyhQ`K-N@`|y zydu`vgNoqC=KAq{gS;|1y)hoL>cN`8*E;5^R#MgHOo1d;IkbKS_^DkUhm5%iZaXgJ zbv;rLYWY|}1m@*=@k9riP-b;ca->c%GR7Q>9~pmrL~s7PY1j!9OXgmwV#1bNMGv5C z)q<>sXM(#s=S0*Jj?h6U4t2AdJ7wOrS8&crBhhUKYKGwC{FZnzj*LTFrp?Ko0%N*nxoolI{E_9Aq?tArMCXkEHhCV$02M z>uaA)yi0GA1_w)AsXsn^xt}GZF2~=|-T7?dI!B}TH?PYKES%{B=7hB;Zmp8TKh!mk zL^eH-(52~1&_iX2UvNM9xVp{)pZoWjl;+a6-nzu&HhsNf)Hpz zff`U2XPvy|0gO5CQFwdz@4nhNE55YwO0CHYXKQ!YUlkyq#=bdZ|u{CJyI-gWr|^3=_3KK^o9*6X6`4b46Hb3-Z>QF+@r6FG^b ztsI;#?}^L2_$!rYlHRQ7d^v!{QB(iO@xlxz;-P<%(-y}-BV^$@s@US7Wq(Fk4taxu zkAJORk<+KYqS(z$7DGNsb?&s>luWBOE4L;7h7=G85XeNUl< z@+EG41#lv0vyG35kp+jhC)M5}FzG>Xb;9zuzmFL(w*EK0UC7*dxo^n};hs!_?3!Gj zF%tN>u!3D*qZ=1Z-&%0a22F1c(_kWRliSNy)dZdW^!FN^7tw3HB<8Lt(K25Zz_oCu zRE6XUC!ss3VE6@5z2cxG#hdPnif~A6XCFLow5)IxibHdJWnOBSSF2l;xw!%#99av& z5&!^2TK11XvcmQ*gHgOLY9=b%pe6~{m+ydR;o`CZHbih+r&a!!vcT?;L@cv+AaK0#Zm`J-8_R_A%IS zF*|41;!oC7C;BrETAKni?*!@(h?z_j%O#C%PCm2#Rs<+HnC1g*5L+o0J#m`H%FX3|{3Ul5Tk zYx@$>){f9szaDl~ zIhiDU4PIUG>NzU8MGb=8KAScgPT~c$(xJKqC3MudF0p|nHw4aYzT^!Uzd3{*f*(o{ zIC=i8_VMyP*wnmx_imS}6^4A!Knl0*PuZrk(n164bI%T2Xy=KHCinbM$@_IL)CQvILR=?p$<2Q;(hYsHnB363oq9DjD1B3!8I9nh}pO!?Fs zZC@pn@Sja47=?*wDk#lo=Ngc$rVqBquwi1$)*$gVoF@ya+>$Mq8G;TC!Yc5BU>W6BcVYjpIWd4OAoaFOSz$Tz9seu z>H!bnyLX_Hhz=)z`+m04to-?%hdG=;q7Fd|zvV*p^WmGyUlOY=XYB%L(a(Jp5~{^U z@Dhbz^NpwZlS)N0BmS6af}$1-;lfAkuwWPd1;|9yfp_5I<6#l8w)J}*F^!B+WxH97 z!~Zf-(DDp14tAcWgoQ$xq!F1NT}VZ|^B*;<()GUTK4k5zmF7oh>?O0=1T;t{P$smn zc49L+3+HrF*kVrhi)U^BQ?58=41TM5%bU!i`ec4m@ow!Z>z7+jEU~rAk@6{DyiSon zRhx4JD9V!ZTph5bwF9Jak1J?0CMaCK^iXB+rPE1*Rl8V}1hh}!c8D0`{D5rYIPPl%Q`vz31X6YTwyj>$>QYFgST{wK~^S zNW1pqS935H#1=L2#VJ(&*teR;2RQ;I+XJmWC`u7=({bo1I2*FQ(R=qlC@@EJ8z|Y> z*q}ExvT#%g$jBJ;fs;7c1Lby;CNel-et5*tBgkra5d0ZyBK>USIlG)sC?}ZaOFxEW^XQ&OdmGs~OGE9V*13hOQSFFuiv zt#szyZrZBt9w8-Q5F&@Y`a#Gnms1He4U`lVDfilur$|XvJ2yZG`vun?NE@?RHMx)a zW`Co&L0s>*MbxDWlXD9@_`so@xQK$+&x^TCfTV1&VsNGw=$fYQ>i=4;z+^Bvo^Nb- z_~+^zsw`sd{`+-ylI{Idp3Qh%{f`ePJSqr_Z;CgK?vo*CquXp+gi36qmu+sp zJI-lTY-!aJ5F>SAB$zWo{$74#7nPssdg~v`ADo7e17Uv>P{#%j~ZViVF{$0?*zVR5pa7u*H^bet*1BrNItx7WMTiFw!1&~w(L zSge0=B$&-+mAK?%%9HvnC%=Kt;r{C+g=nWwKliU=;=V1{Ol!##v~Y2L{(Gcv2ESp% zlG>hNgPY}a7GRW0PDn-3xdQB9rOj);cEipn;r`;&O#s6gr4E=+6jrgLEU?DS_nH;i zzrYw_{xEqD_$%&}_)E)6-LP{t5=2Wf{51=PE1x`Kx4Pev;$0(Jv421CbOZa*4ueGS z=~p5z2X)iyO#lXu1l7WNZev(M1&u5A6SI#)PhpZS!N0|Nf*Iy4om9W&h%XgZG;ZRH zQXe&jJ>)inP`YP@5jF-0CZNGkc~d|)bB$gyESY6Rx5K%U=>1&!|2#nRGn9kW_*OzU zdNvVDvBJ*ab|)^23+d>|j(t$O>2kS)#jb8fCd(DM{Rb3Ie_N7Iwn-eDCRPr$ImUCdnks zE)57yMB1*LlwOtY$@)4w*A6G5alQ1XV#)@dB5WygAiiqRDw?}}&D}dm;m&K^@g$HL zfP5|2nx=!|xCt9m5&`)NNq9ad_EgHze&945iGXmY6SDQv}rMqDUHD%{h7{Rrd~;bLw!Ho&~k0BIR9 zL5)TtzOmS5SpRna0XzlB5mbRjJW{;jLcWUEncDF)A3*H`i|`QGm+2-gY`8-~eyW*s z)|zkIgaFoIb+1I1+KMiZebrG{GC=-5U^1V2t+3U3s!s|EYt5=U#e!Zmk@8fMux+)Q zIu$Z+*it(UO%-Qe>V&80ou2mhvOvA!h5+4f(1h&PfMfY``2v@|$Hd9%{dIYI&p+1` zm??l%3wBgN5R888*s+$*P9}c-NTBB#7Hb2>_3`7?<*IFcdap&^`i5fNNAL-_yfNfd zxVA;L-;3-nna=zTp>%i4vfPF1s=KhF7cm?#pFfLo4o7Dq6UZ-%G(zI1+y2-_3}>)SED*hh~AHxC;AT>426 zeq@^^lWgnM+Ky3tx_S@KIziRn9V=M@C2AhwK+X z*x@ri4M3nVT{XEJw`%=}Mj&FdvN}rkXXux)kZ*^lT4ygfCu*22PN8#Z^4a#@reuFN zpLzP2>!)vX=~Gy#;=eA1s%@X{ee<8x&AHZ2$iubkakX~DQo*PLd!s217EtXS@(otM z*trNAz8Xw$u9Gzw&R4687tUyAH?3h?4bIw595z*D!f@S1Y%#MrxVq{PporY6$3SJ1 z!QfD?N;ir56T4kWHU#;rm4*A=Pt`RvqLsXG{2tdFxj;PPo=J+^Vrdg9Q-~Y&{&%@V zgq%onhIyIdzBjF~OgRVY)}`Q}O)SH1tMjhyf(?8J2X z>ns$RXs?SpaWvX=$QhZqk#OGo+&z!5H=rP zAK|jQvcImbPm|NrGYe%0(orx6HWf|RG5dU-qmX{-epUXL8_uJL{WW9blz`9i(_8D=z0|>~?)<>lntt+z;Lkbj81kXf+hwH- zIYTmBF8_$cZI7)45PB#BSBC?BOK0hkGW{~co$aPWB^?ep0IOe^^y0{m8{YeUC)(o1 z`6ZhA^rgU_4f|_7z#wt7XyCHg2I>g%lNzFul}KD8_Wgw|KHY|fe!Px9(azL-nGwcL zc>(Skl5m)x7*_BN=fy)a#^Rde^^W4 z6R!Z?N)rL`k;LuI(FC7Y7A5;~#$D&5H&Fz^BW(imQcYVm>dNMkXoWq$Lyo`YfYG9V zB3s4oV22>6Fo$cwR&p>l_yv#AXER%dQCj`r)!XErJgL7-;uM%iE%`&P`FYnL-R(@KspiTb~@d*n^vn%7@ z){$owenSfzlz@tkevaXx%^Cajaz<-5hGo3}wmWxPi#cIf^2)6OePZVCTPMch$ys&Y zo`fygOATW$BIvf@C*ukX`@4CT3J2EGE{+m1&_gmZr^W$Bkq5rPP1GH0c_AnlQ2bTMiK)o7%@WOc^ zk}g&nR0Kt2uX9(a1sl59F|)YC~vNbYW)@vv?B@^{}J<^$Gh8zseS*$);eA0F|nHLDR_GPh=|-`_NQw|cK@gPtf&GxQnc67HV_z& z-~L!3v{H2W%lJbsEp^Xw*T;{~hl{TxsnoErj|Kkh>Uul3*gO)n1_p(VU`3wg^aQSY zgq+CR$8BZYXZZjWN*`}EeesvzE46vKkF#ia{Pagz>3aauF%P#V_iO96YbM$eek?H% z7*Y!s$@&jEWK0*dRln3)&ejr!$qRJyUrf!L=mwCA)vG<+?p68^yO8uFcxDI&0Y@+$t@9 zCS!8n<}2%t{ntPtXE5hzPCNYl9*xDL{TiGfac>AVRKtJGd0R9EAFTT)b5SQkQy&!o zhykB@2Q?A|0;Ftn=Ru)>h5kHcgn;?r!FXDXerDz;E_e~~;_bvc2U{iZ`rD~hr&TfWV7W5z`B_nX6ML3&dJ~8UYMzu8^mr-(+{LAT@ z`pwn1y6!NlZ;#s5Pa5P4vPH|%nFSKc9C@WIZ7z|P31*@KN{#=qGa?EX!u3!JJM-t5 zG_WIFhh5;gu(qXPBamld<5>knC)&;z};?5h^^euk7_a8~LG-TM>`x0^6 zB(_(kVCc*QykB^5ATXCr+f49iTD0;xWx*=B|KV1kYI(>I7I3;epYq^uSm8on>|`5% zKfB|pQor2G`mReK0c*EJHRGh1_o;M z{e=$AfUGfg6xUdR>uKe5lYAst5=f;?maViqt&~U;$Lp$)EW;E09O_H&LOrx zPBOSF6PUYIL>iJa*rxpl!PB>}7w|0y`)5l%S}Yjl8Dz~UKACsjv3GTQrZfKY(@RUo zA7zZs1sz{Nxo=-EccHrn=n{b)vXVMa1$WeHq+Gyne~lQ(MK?r6hs@%EdLw8vPzzb~ z|6RZ!^@k@bZ?Q*7WH2eY-jTE$_A(Q`H$*gL?nZY7j-BW_)D3k1T7Cyuj*&voo3 z0dw}=^E|Q9FH{#~l};$!oWJ7k52kE-NxSCKDNK^r z`zn08{s^#!kss{ugisMOl)C}Cj^f#f7*+fcFTpQ~$U%+wASnLz23KZ;w+I{0_>j&$ zMdJp71Sb;pl6A}R+ULWNO;m}WjsM=%^egot1xySzM~7mzLq$fgM|zT@L64d~4{X54 z>J0!)w=iXY?d`IV59c*&<&6nyEy=;Qn;d6+oinkdR$4Po-EE5xJ)=b&H?}|z3|7KZ zxOEHd7!1n3Uj@!z)Ypd$R!>P!BF{6hO#)%^p3F`Ggn#e7t-qYLlcF@YZ-;JMYPA2H z#%tTH-xl=KVSQt7wG)VM7mk1M{*^eb5;z>ld=CHGB zbe2I?baVL5VBysLDte|36RD-7ENl3I^X_`WbbKI!RccskoUI~z^;{t_|H(A)^01;m2_7{cZK8_uswO?%-r#xLWaJxnOizU%@d^z=PqbVog(o zxR;(H9KTXD8q6M^URXxZJrF#rXzk#S*~CVdFKs5Us+@*P3S^=l0DD2pdHObtyAu-= zAi;tQsKP5EBRCqL+*Kq6t&T_6pPpOKf_7!jsdwVX2VCP?6^6y*6$gW8&7d1U?XYbO z((_}(Rf7f&+5a!$2^(%8WRCme7hdK~f8rb7{PB;cyn&j85fMz{etn5MW$}7Kk^zST zQ+UH|zRD5too`E_MdVq|yA)JtX?3j~N=iy;FeJ~M2MIPKBf-ETkyLJ{`Ff>G0cj$6 zL=GSZCdadS@}DQS9|o(qJL1~7X{BU6iB~;(vY4mTtpsSxx`W*{<$T*;Sf>VVn(YF@M%!1Vn2nYfev3lPO za=o9_)V!s#pflT>xR72BP4U#;OXqt*=fsC~?R^ZXiDU#xVP4<}425&Y!EZ_*jADYH#$4 za^>(a`jZ=tEGpfBv*?@%1>7qMU^8tj^oN6th~Kp3ZDu)AM08)MICCg`h;Ld91vMrx zS?wq~sx)6x%o}W_gn(+)&6Gyb-|7)2?}{54XcL|_3RfGq^(-!*O8WZj$eNr?lj71uhaE7X_PPM;$<&%=6zc5D>*F`8TWeafVz6p8J6bffjq%w zckkcF?W!H_M2qhqd|K~zUvK^Lb(G{qWX0;RdMLWQ&p>BN{g#KQZfqwEe69&+XeZ~q znsApQYSgrLdQ)V{q0RwTWBr>0D3LzDwglsGacAJsav~1St92(4^TEzmW?QB58@x3p9xor=$q69K8&l@1^w#< z&WmgVKVfDt!@G(x>tA1gOPkD2qf+PK&i0OZ6upI6lVlS(_L!ud{L4@XvbDcaFE;Ly z&c%52$ZVpAvvl}H>-26VQZggf7v;Gpq6RZKFzVxK*kz(pm$POzd5`uhhueC!76q$^ zw^<_HIIcFY_aBZ)T)(pB7XQg?RJ%g396wk=_}>F>0^7OkQX;jp{wz{st-7?&(pwW% zvMDk054bv}`MR|)UTNSV`?9Fl>a63}U`}hG;c7jyg}BSC-qIY@oMF6sF;E$>^qfq2 zM5e`bwPv6xD41`@3dO8JMf$m-ad+*((S!MyV#z;?ZrBPTTD0X#m-KRQB-$xMC4{p5 z8@^h!-X=V*UnM7htL`vAQn0+N9k0=8KiOzogEPX=e4U}u{lqJ`q(QGM<)5q~cx>DZ zIDxbNz?$y6+@UMoW^!1{;!w`4_yIXlA$|H9U@RUe)ML;J+Es08T%e#x9FjWN=!sSM z;&gtdL zEXvE!u5!5nd%9zDa3lHscdUG(e|qdA^3fWBH{^D~j+ey=6-FxB&Wj`bFIijrRG19r zcLLUR3kf~uLIwU_?+DWR7vIH+s?nt|9q{N7g3=S$)%iGNg+i%$)pP&XQWpuaG67O2 zn$~#X;a*ei7XxNaf(+H75I=YI4kNIOA@@0?ovVWE8FVxVst3xPrf#Vt1!%((cU_l< z4PZ433mCP8P=kAm<>!|}0ih(jR^E*0Y&xw!d z)i9{q6s}tSBC*TuNh*$O1v@hK(*A{)uxf?AR<)gln!A*AYwF)n*}??R)94OoXm^ZR zG^Xi-OYG-e_NQ-u2X_Y+e_9^Xf0Vs=o(BRXgtX5x|7eI0`mk}Wqx}f*2gY;_v#~C? zHJSCcip&(MUlc@A)*yS~A!J~$ZEbO>9@Y^v@BknCemK3NlM|nvomqDfQhG{9+;jq( zAW+;Gk_~|S;Jd#j`&Wzzib}`|o#+%AGljCW0kj{5n#U>kBa)K3UY@2vHn;>DSy2G* zf};VMzW168_%X!wR64_(N2=`hJnA9t7v9oVFmOWG&$az3khc?F)fQl8E(g{vHt685 zp(M6%Ep}Bcq&t7(30^*b29J9awCcL;Qj~*ba4WI@uVQ812C$n>^_`Y`Exz$P1;@2k zNpwg@^Y^EY z3wHbC1kLNpzSWUBb~mog-Yy8Ct*<=DA5!+A?>!BNNw{r7s~@?Y;ZtpS=Hl|)U+ihp z(;ZN!f#b;-GXslt2%X@w9~G}YI`mquIr0U6g(vC_k?HAJHtnQgxSNF3e5S8d z^ z5VWvy8vhClP#7sCi8mtt2;Fn>!97Ia;wxGf!7`Qi*|vBHJ1zO|I7+qR7>#JIGDsIr zJlIn{)Hl~hS4;L;kF*h2#H<_RveumQ1~StdWJHG7utGL%k|$~lHg53Ak(}E8E$GFF zRRKOAEE}XO51{Pdh4=fifEA^tfsd>DnT2VPE}BB1+%2o#SDu^mB7NMtWp9C}rlPB> zpr%F%TYApz%JhHc4N| z_~wVYQ}7{BqoCKIXyIwQKj-R4VuC29Ro$$0VS@!EkIFJv`nc%&sU==V`H?O0fmCwf z-BS*7gxL3X=9|6v*UIQpk3!eMA|Do|W53N&t2-|X{tctmBJ+M&v6DRL%^$EV+8yw1 z%07$^d3THe5%Z*!G+Y#ay-(UT_j>sH{gClcq0w>Rdm$`jb*IjLeXmfcco4NbQ0*fI zg3I1)twj6_2}4Oc&Stv_3Q+0w zqFI=j9s|*bL=URYv<)U%zn-)vwZK^UxvJjB@VLFaH--=54Li*Hy=*jb8#4|@f`}6n z&_c)nQLf{g_-E?%N>@0{JjUr@Z?Cn5-7i@}en9`tLN=jc@R9M^C_(1mVg>ak?+3EQ z(WpyfbWcd11+|7!eIPdl7O#aM>b%Hx>@DvC%n}ep2WQ@-_C&pXOK=-Jb972WzS}f+|L*ZER6@Bf;a+lduILL;Y%X2 z=NjZe8XSn6@kx}BSpUN7bT8HA1pzt;tXPTC38+qZAW;faYvkJ2=s zcz9?087o~7`wD4mZ@;_;dUEx`s6LTM6v)?$fw>ZrO*e1;Tv-Asdq!)|ox! zVK}+*i*sHmCmhEyiOSZ}Xr8P+J!rQa6xEz_UyD|UE`1)|HWpMLY5!*?%jmQWuyqqL zX`9s8+)K~%NtOJJB+5tH`$8xQccJ+(9j4@yI_kmZ#@+_zUu23a9)$U0BG@0$_`K+E8P)he~41Ct+7vz-&orN>SPJ59ez;Q)yS>=@xV zf=HojTwGll26Am{&TPiUhjPD6jE%wn$Uh~Q(Fa~Ht{bq>ujCVpdih=aZ_5D_m7{99 zl}A~W-brtuWn(X3`4)ae^UW|U={Na=dPT9Rg0BMd<1~>!K(_qhLr0rLZnyifZ@XsW z8t3Ga%Lw#owQ*2^P>%LC-6Y|W+6nU0V;T=aGy5aJNwT>?7hU*SdU`RVV3kc&w0t;c z7BU1g9;Xn&owV5BS%VLy*7uDIZZRRmg6V(S($dm;hOkzHQu@|#PoA}a&VXqKMyg(4@0EbQ z=Cg*>_tDAM|J9!9{TPsl4tVW>bf`RA=$k5SRm86kn6kDCDto=3sl(3C+f{)F)Ddlf zpZRfV)}m&R&pGPzuvqB*pV-G-=VzyNv3fDKG|8@j6Y z-p!S<O`)73pW7`I(rSY5*bv z`EAIp1Bxk#Vwuc_KvU@qr^gzIELEyJU306phWIui{*M_RSx|nh_b5w=v_Xon2UK1{ zkMZZkZ5x(A4u`&rnUgaV94x*+wky`Y41vR!f&;vk(ZuB81@-|j;3S0et!D$MZUpPD zXW$z$X9xacJigVXN$ulv_?#L?OlBT!ohopk$K0zEw=tu)Icv^A-xFq?691p(`8@iW zPZ>`lCY@H?a`nWIf!^4&*Uk`>f%D-9qQ0-I)bRx>e@dr)WLJB|%P!>=mu*caN>3Z8 zo3SSYW3m}IZ$OvSR2o{&Z>FCLV(`7n#x_^fEGH+2^u#X%0)CdeT7x3KwWY-nOh#x$ zoRGlpFG`7WE*opp;!;w{I`&mj@RfpK#yUqqaS!S?p!rzfVS*x%A07{HpLY5;`Z?MH zNDw%1GMnCByZ2|bO3cW}2xz5m6B9e3rT#NgQQEUF30oI%5NLs|K9VL5X@S|`0aoR; z{R@z$B#+70J=N||(47(6HrTp?m%{bZfn~KZ^d|;oUA@F1qof)Asg<(Uf_~Rpy)i!gNvBIS^0}UyQAv5U_BxHAy#Y_G_ligz;hQWCL=5! zb8ETt-G|=qzu#+Aa*cStEH29Pu05VeSb{aXUEzy*i-E=MQ7TNN{Z`&JjEeNzbn=Ww zeD9{_e*#0NPh!#bW&;&_!XH#e@k&I$ty(=y8+j(yPc8qU->tzVdQ)HMDY$F$WKl3_ zOf&{;7YUjT9K3-;4x`*xx?9p*1W+&3)$ZJ>yKFC_3F=s2l?0HKlAk&?4mt?Qr8NkL z?0|kuBSZ4%&!66hcx<`^*haUYqg73(md1MUhus_@ev8rL=7Bn*np3%>Mmwk|iSGhn z+XkJHIou)dfvx*Qy>EzXfwbMPtuGI@bJrK#YkR!Aq}={Bl@BiJ6bdEtCZ|8La;@r2 zGAd9}TT$jP+ACu&qHuQ$70YqdS4hB~O1dlVg9p6O*ZS zI2oClXLZjYRKIk<@Ikrn&^< zophu;hi=b7uj2#@b*P}y(wRSCto8tE%4Km6o?@%MdZ3>^4GMkt?t;GGf$LC_! z{QjDfN-QrEB0O!3#)VTXCaU;_6M3A;VLfw;(lEIQBhNQ;TAWcTQz3eeKn$n$7)s~5Lnp}Hw##bUt-Pa&6cX~rk9_S5(2}7 zx{n%nlyt7Z`m{4L-aJ2V{7KyUp0StZ-f{Q~g^Orxk_lwzM$IEEmSjnvfdVtqzAVjj zP#zK>f|+i~y^x6OvZA)KQZOxp=;Y0aUAj)G9Tb;*uvf6FSP~Sp9r~X7FfyU(|8D(;Ce0xDF6KFm$>jYAt59$j~nU_7sk`mQ>D;cF}Hfx3S^EB%zyV5mqECW13G>6 z{uH$aj5?901B*$`>o1-^u@~+0a~gW!ZkvNpk)Tr1woKISJ1y-8Wie7oM;^S$)-qEc z95N7>1R#8+!7sHu{e#q{B{wmk)f+pV0G!Gyjy7FuN2|QRgNvhw1w13*8W|T3 zBBmn9GeZDE0++d80YYQmk+1{$RcO)8cK~tqGO!YWJa)tN=~e>RxF7`;?w$ugREVue z=43xC$*>PVocn2IdFnyQ0xnUBC(aP`)rkC3#p_JqZ@WAFuZRG=Gao>)t+_)R7<+E7 zzlIa|W?euOTwme6+$1H`FCt-H7>BW|2!-31eUpnN{Ra$%1b~+v&42}ZOTc#?vP(AY zQ)yZmT;zeFS#zDL{c7o2Md7M?K;Lo0>0fVm@{W36Q$clPIUEmGWcXW_CxPgB_hWNL z={|z&J~`0owq%Yx4UV2prNw)Th23QbTNpI3(m4)EIOVBn@BKxUDuVyf z#pL45MS?(?;7f_?w(Rhc@!PZ=95amuVFfPfIKk5}v@cijB`jcq#?9SE1??^DZc+$! zGmmK>`%5$KE8_0+39Df`coZpV;l7TvoDtVC%pBB;@>pnT2bLbf#OUx7MUm=@<<$=Wc3u{y4EVm;Y6 z;wAC>gC`EDtU;ZFL1hK^X%S3zJ*0}j$TIAI++prt9IcA4tQ2p<^sPke*on{}5~h~1{W!JSLMa9_ zzxx@gdH^*f(W)hGZ636}2QLLldF|HJMAC1UiR3-UntNcy^+sl861r+<4<9f{P1s{a zTJk)2kBv$(mOnlc!mBr4wLQwNdIY9kYhdoMKA)8*+V;Pq39c!hKO;%)V3!%T$|fR$ zfA4cR3aL_EQiA~+xqj|aY+BKgCH!&YpSE&Z-tepeMMiwg+c3bNrNYPp03@L1|6H>+ znw((vDXVzwE@AOTS32{Sw;aH(!)1=JRf@vQeveWA%l_(0TD(hRzaQPEZ0(#dUn!x0 zD3o&a?yk9T@74Lr?CR4G@igSm5Z2}eQJ_=qSd7}Z(!tJ3rHAEDb~ggMW!{H$XabnD z5w5EE&bWUFgA~1=pC2+(BWzE7uO$JbPlSGsu%-KGLDAj7z#yi76NhuQ@|x_9nsdI% z(nYiLpOeTAW)mKBtN3@Mmp3i>8l%?*hs3ykU^=pddOurdOSz>89kk?iqnQ_oywuf`#~N-IuTe)rN})+?HlogL>~cl-LZ`M|0|UZ2Xjk(}5Ad zy6kKY7>mJZOF{kbS?!1DdP=6(U_ngVUMkYJ{RW5qNf^;fvc{pB1cp-II}77{JhD=< ztNp0Eg=ii?`6B?IW=9Qxj^S14HWxcY)mjxhfho>96djRy1Sfv@@H9xqg}5tMUtIUT zX-^zknZt%b7B(L~HC*H?Dd!%Zqhu{W?{aXFN-wx3_839OLk$uE7I>V6M=wt85t zR}6-JkgOvB{@qmJ)^&vL99T#dfqM+#9ij>a2pQbXoS;eIcba~Hd{0vD%D>2m`zVS9 z3cfkKGygXJ``r;Xq}`q3ZSUy1>?t(Kov^KU`sN02d{jVpe#0Spj)Eok^=zgvC*?w# zF_-dC*0HyRlJ-!vM7)k2JKQbx1M!*CCb%R{CwW2kHB$fxU%+|SpU;PcloXC2mwC-6 zPfk6nsj2CC0-FRb>||zl2G~uPb8y?sfQOS>m=U%3>e4meu@9PdG!+(vCqttRx7%;< zbjYbaUA!DB!duP#9Mq+jKLS8N#9to$Dxs!B-Srb#rTr){ljo}0cZ%7ptE=;dZyVcb z4qj@lnO8IrO^ih$jdvkqWY*a50;PDI0uPYBYK9HE**uOtiH`mr8E+x-BK=(W6lQuO zXOL1ErzLU)Fw4Rd?<*mkz=mbVQ9%%=nEB zPJd5k?*R?Yp#+#E?^Y$b`~pkF)h^;18-i%FMRT*JYLajxYNDRA*-Yt0Estl7+@^p& z4v3@fG?13kpt6CV*YeI_4{qmI`->OHnyb6O#~X1t14jYPzwDNnB0bq)d`)uLH@soK zs$R;xzPPjPnGcP^ejmGwDI@h0WVc@tZM?Dho>b|QWG(oXb<8jWtMWwzjz{4w9UdxEGgVAquvj9gCV4a9jNK)U^I z0K>a}+`@#kq}Ld+=$m_fUa-(dqtRx*L<8W57Uu?rVAIpW48F+ga#7Pb zpC3$i0;>z*9<93wIj&rs*mrOr;j4=@qV5ncdo5JL@X5@DmzfAx{wQ03d<3oxr&%F5&eE4EF2)V79zItkQa*FNDps(XOV8v0oo441y-}UaZgnf;2Q`pB zFYh)}`aY06oUGd#Rtvi{lk_>}m97H92!g`?@ZrO-WK6Mj5Ny$*)Pxnl3-Zlj;_iH3 zPmDHv?{w?V(PKn4RpH@ObPZPAI{hU{-2BYFW(wUr;=_lci(UqYy!W#c+IC!}R=0AQ zQe&nICAL`&mUR>%N<(rv3A@7ukL|QB>d&Vj2WRIgu)j8ek{h;ORCEg|wBtLdM=WkU zgveeBe1Q;~(q!M=425Kv$*G?a(|dgE5dO~3(C0M#^jkDf%>|H-2*`sqVg7iU@Z3Q?(NzwakJO=wzIS_?w>bYJ7?%u3FxuhW& z;z-NLYd-8Z1uIky*_nXk_~nj3SKkKo&Z%#}l;wZ#oe3^$YqRn8d|-!;SPVjo4PBlE zetpK&%XPf0GA>#c58r6+;Xg1LK*sV zt)2gewfByv`tRe1kBSBo%7`dJ2-%y4Qi!6+&i>jfdsPy$%HA3{WbeJlu~oA7JlPHz z$Gl&k>iXUHU-$jbeg3!}kL$X=-{O2e@7MeFdaf4`k}c^o7Y0iw4?LE-bHgEBG2xEh z64TNcp8k}^%fTwC2BX!-_ zV&9X(`;C*IYl44y_QM)d*aFis|ftJCzq(I6G3Vgc8{QUerzz0TcBn{V8A_09& zJw%E;L|KBiA^}D*6<~e@66F7AyJ>ThxySpXYJ}=`H9eTY-T zfWY_KpNswYqL-oVkd>@@SnWdP&wVr4IV81c5360up3I9bk9=R%kV)1*tPl$`@#OZ3 ztD?O4bX$Mj?^==3)uvMO1e^J!tud+4&63eOzYO^ z@47WW`Zm8@GTz+Z9|h4t;=Kn4-;|MiRj^|8`B0L2r65nj>(Km@;;@Lz!1vrr1s}aM z4>m%caT)(bVeLtS`1`?8%+ze^#sxV3@Zlx|9Z}=&h7PSHx3*$6ZK_)PJ7!ahrmSy8 z%HQ;3x<@mVr+djxVLMg(aS%qKVCqHrxcUlO+yS&ONS~W@wD0SA0P8W5;15flLS*h< z(wFoM>^`Vyd*A0tEGrh{G84BBvaheolf?7792bq$mlz#^SZ>ahA)UYb-Dg4{J<*?j zOSVjax{U$9}V1^UbT=?KQE~BrnBJvVBg?~ zx>%%{j^_mi#J+BhWs({>ILQxD-8~br!D56;Om?@SmjY2SOU=O+T}ny{M765+8Xw#a&vmekz- zXPJ?2St1>j*cxXZPy&``^qkjOd`wGW?e{4y3j5%1f}d}JXrLtAW_)+PLo%QArCYxe zc019@Kq#jB#V(WGhxGiK3y865WMrgtJ~a-=jr&ivkzVI>q?*Na46SVG?3d$;bt*4Q zV$eBRUDz)MZ6}nFz($u@YK3PYSi1!{1@N&;bareeXTVSXtW!x! zB~W0b?8aV_eKcHhk-t1B-Dd3t#ChIom$Eyd;0fUh5kX(iY zEdxq(2Wq6BzrStSg``$PeMn|`Dp&}`j?nb5PfKTqCE~Y4hRWzHjzEI~{SCr|+yW#3Eg(La`|!o2vCAY3G}SP zepzX0H1v(R&>KWqUVtSHEh*OpF~CdG8`TxNqsv=vIw3QhjxB*vn;ICQ>PV&YYA*LY zcD%FPH!_+l?ncb_3#0~p*#F60LylwQ$|kEkW~d@StTtNka_U~Yb1CjZpyegi)NCfC zad9tpV(GRzAdRzij|Umv`m-KRn;x)GiTVSNg=p%ZMu9oC?AqWm(UEpoXY%-u__JPu zF%!F6S4O;yL=MM{7*VRptFy2yMMPCxkmMA0cCP=MROVTf!~UJ_)_nvTf;V7)Z7-6Z zA>NTj6JJItlyv>wG?l&s&y@GiB-%%h!XPL^E{Gp=!H3rE^r*^?mCC+#4IFN5Q1tnWMpW#260=*u$iCDSd{g)A zd8)_yC3YWg6#SU%f&8JEa;FPELc~eMbc!424i4`o>;LYA`?5v-iCNJGY<+UC+@Yb; z91PQy98n0Ir)~SS^2xaz^5W|z>n%Lx1{+}~-Ho`8%7J||BCZ3!8$8mmm*n$5^=mvd z4LH#DoPz-8r)t_wCF7oMKeook#vlgHE1~Vs6xs_CTDwa~vy+Za{CqDcHaRsFk{YJ? zmVp=n{!$MTZ`S~^BB!Ei1H&Zp`=vhION0$Ds=J9`8}CYc%$%-WAvEr}cL{Jt^vVlz z&Y~e&@a_t+QYYmvM<;$lmN0n`3fp%NF*;{#o`XD8PD$gBzQVdMDhYLkm6$4zD~{fh zneqC%Kb#R5NK$>c3;9p#cYu`wK4cF3jzrIah+7)1h?4Tyg}l#wNASkAG#RSckt-cI zM<*95qst?UJe-YfNI`%s+6MVXY9*c6jVewsBc@GLx4qQB6=qX40Iq{JF=Rd_8P7=c z_a%kc!+~N;aZp-ybQqvXk~)m}vouSjOz9eKMBkWX02I1aNxHMPeK7|c1^R;s(>=(^ z&V%qH9& zA@OjMR`)5k8>V3uuU@gLyiv%irsKH3-Fx|Rysled0|J}JGm=>ux`Ea+u%_*?Dn?1O zD&YR?Q_~#*%OL>(Kkq;Q2M@7}lkV(!yV2pj9rqafwV!BH6in1108~PT@@;eWZp(w9#lxMS?shRpFsgIWL52QVsoK4MX!Nq z#IBtSP|OO2VIVqzwTkZ%c^E4|@Vq}e;X-VGID3-axX1R78ZR$k{x;;LoL$YWE>2fV z+y&X#-3J9_;m$@I3)Q*ZzGZQ{b@(*9(`uYJvR>{-W)i!y`K-dt*cq{M(C z6sELkI1vpN+4rm=yP3Rc~^)SNs}(C@??W*@{cxeQ5OUfpHJFpu@8}T zHV2k@TUXCHj6wD5g`t=$P5yD}Lv?&!=Y2GdN+}PSmg`hcP{^qIK z4+VN4i?77t`~7xyqhD@__UFi*4W;Bn*{!ANouNtiLBpMLJ1ee>xHBg;(d(H{vwCE) zFYK22V8DKCVtpaVrDF5Zu@`;0eotP(Eek2Er${9om=fdS+*G$d0vjdT56eOzSFu@` zvmjno+~;KJhF8BT+9d2H-|Qkk+4`^Mq|?9GCLu2$@o!!B;J5o3AfaiH7vNO!=hirEWld=&!#;Y1Yw7a^BE3RHH0RUJrk9*?qpo4*Ke0DQ18 zIvN$1i`(j`xL7{)BIdX#Y}FBbX*gjh;aWhDrPe1=ST(f)0xEvj-^&Q?1X|yFLFHAS zOKfiK+31O_c65uF(#0tW6_=)HQTE5|q}@YHs#d3*h||MB`Yv4-k^RG;txg57`YDqm zApax@%}tO5gAY!p%n}h)!!%R|r{VA9Z~ygUV;6L2vwb0CB7{mnLc80T3-FMn&!0*J zdG;6tpmI`IwNu7<>KRrAqn>R1ZW?cp|K~M}r$z)MV8w(Y;~2iVG)N4A`_O4TOI?oS zihCe0|K(|hDriBn7uq2*=~<0u)t3&lB1CoZJ>Q5EMiQOLGWcEjp)o$}-y*B=hs4;hS&rilZA-58?1`Utc^CU+yU++6|r ziGeN!A=rS7C%Gta>LuVa@Y8jIj=BS`dSDs!U^B-bRJKKQ!$g^Y(o5pDT;zrsy3X>o zbDHkeS6-USg%Tb-lqDU;KnbB(mwv9Do`H>15H!eqC9xW7vGV8f+2J&S{s6(y`SUZ! zbItp$;BO&Cf>zgXI1ruqzzRTKpuQj+DgZk5-meiz(mv3|e1M5#HX&shMtNV@v}b~h z^+@vFeR+8VRZ3CK(m-+rf{S4d#c^GC-U#tk`Uc1gf_QKmAZiE!=~9T>@<>@lAVekU zg!)TPBXvgy<1$N*6+P-tsl7YgIUB}CF(2p`9}JgO)TyWm>1TTgpH3G~pPLN`iIerg z3`W|&F-!CeroIe%>u!NXuY14@iPDDY?Qev?>nVX=0Ld2A*Jol4oA+wB4oO-yq#*(c zsxe&G@GGeHzK_ZTar*z+J2x|>_DJ94$A|!M?PE2SuJ6T_bTz%R^A3aaVdLh#L;Qt| zkV`h3UPJhbzuG%AKD$$Mg9L=vv@doJn8p7FC0O92E^z;OccNm7jEgtZhNYg0L zc|(A(((T){W0$U>2vDd8GPj;U)c@VaCc)WHz6_rMfJMjefgukQFIq5IRk3822s=!W zY6^((#!nSW*pXnt;>nCH+1w+hk(|BE(ii3>Nw=`t44aa^e+}kwiPUEp6$!({>f8#q zzVFi47?YMzOqrip@ACVP$(w_b z2Atv6%UX@emoOy{1@!dIeBb^ddGEiYtRx5P1#1?*3RmS{ikF@uauE z8Mmt7%Jb$Ng=@rE@;2+`%gRs1{9b?d+dU(6;>6>;%lgzQr-j6xz2~^Us_pvg&HLM~ zF)@3G9~i&zUZH%B^1&8R5zmcytcW_@kBRZWn_|D2zgHybmy+$R8F*2&2dg!7k}FR1pVk{ zx;X<|Q)u1VC3`$xtM4SnGn>Kv#p)e73I7(ZFG}_BdL8Obe>c3>DUQMK#0!=%ex+-% zx4eTp7&l{UxRHBNNUM|kCkcmK`|a7m^Y*Xz>N&n$EhHIz*OwcGTwd_`P|-hoo>)>U zct*jZtL@^TGwTQSW#Jz|BvRtV!EVRSe9w9o?8zkY>0bhhVMMj2(4iixz{Y?9C#260cq(oUcHp0oXx@9B_ zCmQT?vYa>DTyG%)msesLBHH@qc+F$8I zIj{(Y#^fx>Z0s5iMdBNO;jv{lqF6Ju?;;^iYxwn!vtgEFKCO_HMB!VfBdybh5yNh| z_XXSbsF^xAv2&Gw$|sZEUW&Eut%WwxXNpTjC1sJBuhrTUoqw7+^fVth8eF%&?qA;` zzAA&SXHb||dEoX4kLup`3a<4D7oxY}BE&!2zwtdKm(a*)( z*(NT1m)ClDmLBu&L>bPtzy2rJLBAQA*`L})4|}Y*DY1>JVs+gGev$I|jeoC5CGA^i zZf_SC&-gHg6>UtA)+<^S4g8yxm`O~jYPQL`|b$kvq9{WyN2mJoL#9fpT z@9m3Ja&~V?^st_149TQEq=m_xUZ>sHxBtCfyT&Bl%7vTJXlcfu3yu$s&LKEQSMs)L zNpPY$d22hYLP>v?S5KORt$pQv;=~CpweiL$oFVQPTm63pN=#emMA>FlM^a6);6JLC zm@7J}TlCR$#_9hEW1pC`k6>V83KpF%itJI9x+LNJ9-1dzLEH)T(_f)ISc5D)adU)s zFn1K~ZEH;W{H#Tcq_+?)Nxn=u&SjpkRn4~h+|OmFB-egCoP^656GyOyNY zVCCOwcV>LG#Ye!^gX)2u>)7_b+n(Y3M-HO4#R78)gLl=B9wl=03mi>f)tSkICFx%@ zWG_-(x3pH9dLVO18XxJt4qB6I*IM+nZr(&49uAR#h~6qh@FXQ|#o96Iqr9P3!(H>D zo(R5^DDRSvNwmG!=OflUaqXyYIicK)TYLodq2aG$#{2on{Lbwqng8)BxSb1Vsd?8EsssXsS-8-c z1qCmFo<_?6iR=d!9h}*=eaOIor%2MDT~2v?eJlnZCGOZt;G$}@21}(q{o*;DCSYTo zHVi$#+&WQ;4TNL^q$GHOL!@K^gs(Tad3is8m`$sn227BSlP;bkp&OD|X~CR{c1_88 z+~$kP!DC!4h3fO_l|pwt=*I`FX^4^-v@vmeUJaKy8#e!&Cwk+$tJ4o(xD^$eB?<5+ zE(FQ|DR4BO(HV$`Zgt%M_5BNkx+1$p$2|8eO%Psx>f6`j{(;)giSqtXL0Bmv(5j;+ zi+F0YrdQEF#x(jNtD9(5@ZGOB_GVOHk5;*4?0WB1xQwmi{}~5Cqp(r2QWdw(EZA^w zyqj6nhFh{*q=6;j)x$GuS{Y2yo$#7~ogc~~kM4A`IzMfh`IQaD)nm2oO+jR4j$b@v zX8%;P&IzapFxxA@+^Y^y*!GA$nV{LvkIuL$RJ?>sC`?3p1%qIwI}SsUU2!!aCtx~h zQ&)lSk>E0vg*Q!QIgT9UQ(Ze&KIxAo%rAs>=JL9BD_s|>@IA@&m9JVu)@>=C=zuq_ zL$vFk)4-`jC5q2^CyY`{v1pbSI~V0=UgWT}cDnhVZbzwBj|jCgB~77`P{mXi>fGdo zmO|I6becyye-1pqD5$MKdAnC*DMUA1Vr>GMqM}nEiF zVa-->dROr5T)HYD?nS%YwM%k-Q=c|VTf$CZv)`8(l z0a*n&SV|(eTvao@(L=7nU&6i$%t&z zN}C*1ebq64Ir*6nQ`_tJih@hy61MWP{aPMQ7A7f!smY-)9e$bY_Bwmh!2QGP7;a-j zbK#hex?i5ZE#mgW9I1*orLysxttwL`3>t*k^TxOoyW1ynk1K$f>d)t@?{5XV5GC=Z zV#@Th28`L%jRBX=OwQ?lMk`rT@b{R~>3o=ys_Pd>MF-I7_AWPBQ=k2j;cThE+Or7( zZZnaOLDnO4xN%+8JEy;S4cGSH^}Z!c{qfQ0Z&f#nRtN zOI`R<<=ix=IFxdIyR-h`HGcai;{&=UK7=rrg&TJAcP&NMb}b={ItNkcPM$^R^?_7CtIArfZ68y0Dly_lx}22m}DT{Ux{lLnGff1!0$yKHu-Wk$;JJ-BwQl zdqd;tdI<)SIz4Ng8xx(^9X6l4_XfY<($Hoh{`-(-zDlW+cVaksL<2cB2Oe^zJc{Zl9eI%Y_ zQgx5^gz9!*y4+)Iq#x8JaGJ|L1N|3@XF4K}q4K`cqnNj1lix6~$FYaIw{0WTC{_Cs z7GJH-J;*V?7FM#>VU;+}oAg4nk95yNzE960;w;jidPPFbH)swdcn;$svLUoUovsL; zzy{ZNRBbdNwVzU}&SGu*Xk*Kk&o5Q+b78GA3K|qp+w^~YdU{pk#~__o@KZv0-YOl& z`pSKr?PlpiwZGvi&`Ij+PdPM6?zf)qLOY8sZ9mC4_qOm9#OHqJSYjB<`0nFIeEv(g zwO>QEP(!oZNi{zF+C`L>g0W7{k3`Rug;{gB(~eZ(o4X|G8V*AqABa6n68MxLoJb0Z zT>{L?#h!_ApzX!e-1ksG(c-mGpj_hOs3$}>O1ZrhvSEfY5Q^z=+X4<0rq73W1kv?=?Rzu9)zontHpr8(d0^_4nVgl^q!Dyl|F~ zt!bn+xIg|o>;U)j=sOE{ zG}d986bY!GOcJ_2L5ephn-u`INLNldgWB6(HGy8$9r9!ll>@lgjTSdX?7I;QaAjp> zDS!q57#M(rVjr@<_hG@oikj0iXkKf)sdH#BVIybZ5BfTPJ?M~8^Ea(moMS~kf5 z6AX?)4^Y~sYnAaKQ$6g+45SkdMmRgyO*09J7nmx)`<|APi5>FNiPP@xTL;IqJ8u*| zy+tI%{xT!rG!O}PJ5H<&T2>*aUu@{xWvvvFaC&8cPwvmhDec>9Q$y9=gpki%g%7=6 z*Uq#jALOB;n2c<5`oe#22CPfHiaWXIT2(uI((Cx;dd~N1<}W_?NmD3A7RZ)Kn4aRk zLhkJ3LKOA!kwp~G2ixZ=+33yXy^GvFa)##ocp{yCL1X%%ds8MyzM@xOzeJ;-Z;@4J zZ}_#0w!-BE4h_WB4O>{(wzr-7Omob@><(THP7KFqK$XIw`40u!!*<~(yOvh|!sl#Y z1s;U4KK^)1Au`HeD-m2! zeksr)&Gb+FUSew+XSVwJu7|j-wr>`4Po~&%>foBW&)pwC5cgNnZ7y=YyYH)5zvQq; zbqRjdI`~R~99oB7y{F9H1aS_vh6-sMcjADY=Af*z@=gbAf5P_)WkvCLx z-4swCWNrJmZ;x0Npp?H-VHUOH<=3oe?PQa+=-#~*_@Ay{Rg`$oK}foDc`09}7JrAaeRZ>3o}r=J zzS(Rs&D&QQgDkR{vn^*cP0mgaJH04w?CFdw#+yJX2-fr|-;q8PVs)~FhOocOG^xeK z&8+|^ab#qJQ_KGNGqQ{Wax3Wbpy7<*R1-7*MW3DNXy??u`zby$(wH#^P%6=>3WvpJ z(2%u+vdHJNB!QdXwO49+xC8@h9pS*fhksD_l|zaWaGv(zeVk9y&LJlnstBStgw-sg z6A|zHMqDz5yiFJNqw^&$1_Hz+1zUj$Ms(1ggq5Z zH@0~!m343<#r@8;u#hSr%eO%#WY@9%8z-Z!3vS;N<7FOxezn=)?5Vmc4V6mqv&~Bz z{gwP7D;?zwO4i(7ze!?zi(ds0TN#;8_H5E>HOS4-uuX=U@KQ|ky5Of&vsuS35lvrw z%qlz5o1DEHJX5wht&<_>d4SQk`%ap`WakmT)iVu*R-sw%y9Qq}P!)socors;vgWzS z_jZxs^s@t>PFn=0ERM<-62bOv%JotOy$))yUoD-tJj+M>vsz6Q4ToNOQbl6)xS zz2ihgvE!v;%cb0flj%`;aEO!Cl2^l6*NQ0MwK`dtLg`@E109+ua;`yjLL+2BlOh*U zk72|9cw*uPOB)7iyre-SPY-iFU=9#I3>UfmQoFWNf*9d@^QqId7>q9j+d<_7Jy;`H zz5)N7nx5WRQcJ#1UTits3~nY~;#3o}^}o9G z3e!W2k|vr8WpqZ0-ov-~y#CFrTkizDW#r3M#sAPme)p?8G#DE+<$1&cIUf(aE&8F+ zEYqxwMzQzS|zQGkgC>A5UY3 zkrIl8dGR36Je^}_)1{YT^`cJf&grTL+8fML35hLYvMEHRYG%(vY&kV4w>g6R7`IQc z%S&O7{I}_q`Z|x7@b$Lt+Y_5E&Q10f?g?sVfOP=|xk5PdZIN6se(vk@xH)kG_jXy>8y*FrlyP9(9`O#KmXeaQdp=GMjJ9JqRu776!EnU zHwCe^2^l}b8%IAZXO{olSg#w?5FKqV(|V3B?i7@*-Bfco&ouDpphXc`#5U#6Db2cB zPujENUTAKx^U}7W1ci?rY93TKd#npDDyBHU3~CdNy33cIpU$E&hs5fuKxok`|@2E zVu*fmUDqFN)+B+)<9}4DPZJy)sa(5JvA!>vwVvR7YzOyK(QV4~(L9ktPCwh~yGw5g zyxhDNFFqCu`L>kj5`R8hkNA98+{r_w$^gx#-K$lhE0UaG9NK={-mKt;@8C#&zA*k)|r>-5tw($Z*?+bpDRWpOx zJ~kfc0=tV2%s4;8s7W09BeU{A<@`p8c9(6Y*<+=#1@c?Cb52uy%D;B@&@!x;p%7}D zZN1w?C;wx7j8|1e7#8>(HhiY!D?K^@8=`nM@BXCgtH6aPG%uB_ued)gp-$wsdP3Ib z5f|jOySqcgaKd81hQDkL2JYY2AB%TO(Tc0xzIV}z<;XQ>Q8k^Q)Gaj6%e(44?1|s&zTd?yDVE*<-shAdG|&@cPy*O7_a%)1qC?M#kn&f(?{h z#C&O{1X|kpD{ZkJ`sT%rDyHMFJFNF<2qmlz6JP(W#C9eFcGvx7Ys7*&Z;iDY=Hr}C zs=XDw7N1q6bHCL+C@jxf^4`6RTvPg}QZ|;LCV~sssN-IeC%$bRr8Mtwp{Vh^0L@fG z%5(A?F)b4L-ans?Pb!z5Pb6h5OzK`*_I1M4C3nOrOa<~f|FrU6wj+VE(LhiC)}+U3 zYoMJ`!e4XnVyR4c)6Bg0=E!4ZuQ)Od-jua!ABEL_jmNKwn|qgJ$=1u zefkDDxh!CpLnYRXNbuUu+T`_Txi5h>gnq)dcikRLT@HQUMBlu5gF1KV5-HMc;MUeI zg8%{6X+285zg2PGacO|yCY-&3A~g_&!P^MS&mgG+4OR(QH|p!_dlF#Z?miP}oww`{ zdwQEG$jf?+o{^+p4>2Apr#V!ARrutV)0peEcsX*N!69+#tY!pEHtS4QY8|S4y!lE( zKJD*rBftI8pMu{NG#p#?;(cXV@5WioHbnOb1kuS9xo6w$RwP@GH&eMKa&CsjCP<$g zuTf$;C*VoWO<2$CvI~7ZtHUh4#cAH>12;}mH)r7QI2T=d*~+}Pr@yLN#p|{kTD~j( zqvYUiYXjZ3+$PR*jeRfi5sI7K=>B*${qVa%8d}rngV(m4UOZ#l((mLyP4&BT*{~1@ zerV*m7b@XI@m8;);_2$5Sd`z02YjUqU|#@BW5bPS1;(Thjp>#Ro0&kFWM#HK-!=ew z2}HHPxgyXtA_;d|(Rxe9n8@Y1GE#!-HG0k$xol$xwCPfL`VxhViIwb!M?r%~{CxT=zY) zIoj#rgEDh5tTcX;&Re&JS9IuMw$+X_{*W|5Q)WdGZ~+KUFfUoM`t7jTXA2`II2_+) zEb2zRkBMo8+=ynNUe?yvr+{V6XM|hKRBc8Vd1MC{#dGJ?MQN z7#p*~L?>WnWu@o^IRS^35Q9It)n1u5b1a>9FiPBqu#~S_Q)IJ!$L2b3tgLYN+<(df z?cGPMOK%UBZ6DrlADL4BAMU08w&@<`0Y;QEZvIBGo;st{qV5}cTAu+b#s^O{j&+aq zFpc}8t(i-3>nlyA(VZRJo`GLqkqe7?kbe+={TI!#?MtTzcLNO^%F9=;z5$X387d)@ zx)IC?qF#p*@Cqm-NhQGVIkbl~sV0doZ(GCIR3MT$YV9Yat7Q zDCy}tK+y9LmKFZ$%c29=lLh`@X#3B>x(!%Q_8&~E!Fc$egTO(=@3L+PMc^(JP(&Mw z31LKL;YuLvgbzgF{Ekv6X9a58B8B{DB!8go|2`51$>>PwTMH^>Jl zjVMyVTmdY?fg&CfE;qi*GTN?9+yY`eO)ZB3ka)91qqV*q-R>RS^kAVWB`q!Ole9;# zKHc%93IrDe@aehPYx+a{un)~$Uj%T{x}iayRC@1bBO>x^P@al~jTrZf&3xSr2ytq>G5 z5Q?*2a6q(4B5`BrQ8Cx-yH|zHj}&HFX-#Z?>!AlNZWI>8T-hG8*Pgy=oQnHd%=nDf z;nd4xD^dzs!vRBt+1A!9K+e#aRQ8p#x1xc1$a7d!g?B^-dTS(k1a)6YiA_@S67&Hl zP0q>wzO5-^RrGtA^S-v|$#(y$EusF`_9dJ_P45#jp zpXZur8w_vn5Xp<_4mo^m+x(`_+j=}<4@iy4V3EdO?IJ64{d2QzkU?oE*9&E!W2j;c<3)WWm@nCo?5MS z4=UoCyXsxsF{kXxhvFiRz)rg{*7tW#mt%RD?9g^YXm>WHL`W`RwHVCz0XTveaykyn z(iQ-JZ0_s~0;oq6At=jQf0X332;zP_nPyb8cwprArezmQMsXJwR@;8c1|St$!I&;2 z^C;FMs(YAHsrMN3P7(eQQH0gU#{VU3g#kv!H6|9C)7aw?aqw*4f;}MS!! z9R1-oIWOHqw&%Y)Y&G^wr_ilCRE+^r?5E`e%xTai@yLOJXCVB$1^EmpNavu=Z#qFp z_&87hE>zQBnIIaSVU^bwWgE9;5Y#;OsHBi=)a>Mq%7@o(NvYSEjdXAWK^|PES<}>O zn5zCM-(4L|ZDkx4Cj@aU$fu0|u8tgf<0QsD-2DhdChirFhy>VCFLUBf@-J-aIqjiFqy+4QO>=B!q%{Mknpra#6z!;)g9 z^t_;8sR8@1qM$$mAscoyCVVk~k=i2+svYGZg+UIN)Rn$O_uZK_4Np<8m)ba!Yp_ov zr}OR9>_Qi%5#4xT`oD#Y+7rtu)UYYEOHb>4i2u;`K`SSwWa`4V2!BS0T=TdGLZ4 z(My30AO3V)S9~l|OW=#TOVaRh8~p(~IK(;SjYxB;BJbtEyZe3gYiiW~jsErei;{`^zByVGy=RZh5D8^5*`igmvHV zzk|!nS;w8*7fCUft_TfAn#8xBFsOLLyX&<_RuQAUQ>mzw`g5T!t!>$cclLl6LQve@ zow-6RWA1zvq@-lMr&gU*k|FIEC$|iTh##N~4z=tK0EZw5X#yfT*Z_D3Ee#A4NDKm0 zE+nG`26DM5?&ZG^Z6mGsOgB}?4DIw_J{z2>A;#5U@rFntX6MSx=_=G;enG~r;JKzm z0$WmTsMFYKC1J`hd*$CZ$7(H>!A$*vTcdMQ1c1oy`NoE?;#SJ;MF`#S>)Gu{Q#od&a+EAF80^?_^-8bpp!hJw=dCgq@kwz zRqwH#G&d-%W?T0&7Tqpfk!pKgh_gya!9+!&PiO0H<*^vm9I^}R>Z#x~v%~(Jp}gr& z!2+=YWbqy_UXy=zxf%q z73?`GX#RbYD=4A3AYaf?)t0^R&D(5u?kTgR@Gi+dHnHs8o=!n?tKhcLhGb&KppUUn zTR!{TiK5p5xTm8!Z=82@w!wRIH2^v+7+#X$dk_FoWp^p`JhqSlzq_@(m#YN0A$&e8hDXOfh;s_I7wx^3 zAo=`J&+|k}%~K6GemzO%2`-&s|~)@pNcQge+FM+_fzwYCpw}TC?_pCa=^^ z*Njvop&mX?X#n$^iX5gjG=>Gxj;+#m6<87zz?|WnbB}r~`|vVj@4|WEVc7B2B z*HVygwBUQ(oO8K48p4#UICqLzpA8pryGsG620Zm`EKB<1j#*NBkMCg(7=Ixx26{a{P(#dmnu6- z?^54a?DjNKpS-Cy=6UV4^5i4yLGi1a{7aZnF4{`XFZ@}=YNfqB|1?wL9ceDu=$hsH zhEj?vE5DaRTf*G1Ymf9Fj-~C^3XV>AiZVyA6?Kgv{?qZIKTP0vc^pF`$$jqDMZIJBb%(dy zUQc3_6d0>SF5Hvv(t(4dM326y#O3@e_nQTS7B7yjg#wo#9%!llJqjaM`fX)9halQT zpE%-J{YKHy>C1egZx88AYz5dazHB4#!IuN~T6HY@=om;Ul!U|GFY+6c{Fxnri9uo_ zp|zVGWD^hw2V!re1-XKb2j5Ep;f0Cl#fSsK>Zl5THL|3+~ z3D0=^U&WO3LBIXF47Nl3&4 zRs{wPTV{BeEe;x`l8Lwg?)R~#hUPivR_f?R@5E3SB;K1RW&brVpHgd+Sb-+2NtCV) z*O0uHrF`P=`)udEmGB@1i~jKJ(oBL@=bBy;lRy=wdu+=tMdMr4(V_=65CwOkTn-AdG!#fRrT(ZZMOhZHPmH&FtF6LXgY?x3?J}SlW_Hi1H4(+xnxIY{J+*Alu-!7=cpInAmXLO zzbbw4W>M~vaBf9(2MNdMWnF_NljQa0L)}(^%+eUG=x5Wn%BeG4wBbJeVD5CM6>sQ&5M| zQa>I1C%&Q+Fk2Cw!`j`Mk&Za)VA9CUO0>H3Zpb8H<8DG?sTM{q<)#x)b!JZhTZsn- zUBsBG_==*R*BlD04h-1-fbDj_K8hHW-;<50l7rCBe*V|*QIt7LIvs(OamyG64%L9& zD=gNVPyVsoXF;B=jgFuAhKKTsyzlu1(xhsYO0j}rMp&}-!@7vdM|lpwU6p98+29wa zyUMSyJR9G|yGQ(jpBSsW{y=8tYnm($4S7O3eQEV!onKzFz2pr8#Yi%!P@TD(`P~!kel7Nzh>XK;d-Ku@_vb%(@24 z{?hFRao9DTPHq8?XG3Gz&=R*Sf0}{+yfg>ey~H^C$m#Ec?Mrx@MSNE7u+Kb~I ztdt1>PnZW9Fq6+}62)s(hP^I##Vs9! z=e&Z+lOpwY$+o<-qRRefWmKpX-XejIwIKL7i&313&gV zsf}uVBFocLqT1sk;fMz`OfStjK17)otOF|H?q)}alFD9jw_9yM`1n!K^pj&BBhOZP zW$mbKDWN5$V~lRJ-c)@)N4#2Y@4`%{8CmXr{S~RS-XM_vYDz-fF7hcm4q$u~nUc-U z?ec~J$EOE0{gUCVoYE8S3r4~A{!xxx`pQ{W_=}uU%n?^KYi2`!8KB;{5#FfM(d8g| zGx|*s9@EA(JpA5_Mo6?z6ThDA`T0n%$ia<|>Kg$|yh%ozD~8RgmLUP`8G*NQLLGiR z&F}iZAMdLvmFtBbSQ`JoFP63D`&SR|plF_^b17NvCEgU~Vc^i=)HO&@s_I}~ME|MC zX0OQIwR41hBo1z&b6rs9eT6W=QO4BwY#SD-%wAF+we7{k8tCik;XDhP_btVSK7gH( z65vopR@t1t{_LB2&pGn4=}TfsPmOujmAClZ4t3Oxw!TI=erjrKv4DFsxSiqe>+Yu& zFi58#lY6yIPYXQfgGy8l?c)5Hys`dgF%3OUK{< z8Z2V45NdH6*;9* z*GRXAYKvyr?yKN$kV&}+grgn1VEU#Yjw7i~J@AF|fwtfKk5OmPbJ~r7jPY%xxgGMN zeu(P^p@Baon{tkhBp}<}kRi$ra^~V`HpTdf7?VW3?nFt8p~BO!n+hWSkxm}*>Om@H zaX~8Ft(XUjC49zpgq~d~9Xe6>vIGCSP)CjF=fi(9voK^yjrEP3_0||gB*__QBp(ua zw%0%t*3Zr+;(nz;&%$@%u(FpqUeR3IM0Ug!MFi1lC8Q^3%$t;_(OuolRB3JWK z#G)UuNIU;Lme4k90qEJ)T1C|t5H7T8YT zQ_azN2=LsJrAb%(6#;>t$kD}ji@RS5Vqm-rkCM zoTG;adp%j2!tbcK-nAM|fmg00K|BfoS%ZQ>1aW$q*{cjMT2mZynM=6Ofa0luQy(S0OFS>t>)8Y|u%^nmbe&{}8JZEVZ0?ZHb53Q%d?Jn+~+G$slxrVtj7ydo$F zTR@gT06dA5>R4gx#H{h!SI7N>gN-3fT_I6|7MPIRKn^_1eU2m>K8GwGe9bfRGA?fP zv;Q`_cqw}5E!Iv1mP&_v1`(sa)jaW_N*a|9Wl3QDWVB{y+rAx*Kv>BN2A&c{-Z_h# zsj4=4f4>P&R*(^3^zaC7U%k7)iI6skdFh%~=?&700sy=dgmY^T#Wai-WruT*)Oa0P zCi?r0qy?Ogkr2mTuTV@iHs9V5*Z`eoaM`k6M|INj@?mzOyR)^EhR-Mz;XnEGE~VP5 zJy6YHZ?zhixiB1r=HN^1u#kH_!QB-UCWy2&LCirP_CyQ@a{u#R|F2yvt7SWQ_v2%x zb@A3X55pBc_P3yV)!rBYHEdJiRglx>l;r@tAHuI=E_x7&2UeO7bgL#ws!+WPmu1d$ zcZ%Lo2o=r;Sb_ulzYoIc_AljP- zs5&_2HD*g-)kUR2P;0QkKOq$S;4o<$T8~45#nZk0ssp)rzx|59ST}CaQmpGSWYVZd zI-GX z8;Bh!qlL83{Y4hECavJAMEe#i@b|U_kIE;dgkrivOC z)kIqN_%s+A>Y!wJy?E`7%{~+zyRfacflcsbj<$7&ajTW1V$f-tBvRng?JG(c&PZg- zb{=VE^(r+9i9+;$mmJBsSw|TWCczd6Vp#KF3&Psx{JS{+h$+? zUh&rL!))h%_3pk#N>pX3`4z_Ty>mSan^(S#2Am@sA5r|HNt}8V!)N3S0udyAzA1p3 zjhj0d$ay~f##7K@`1YC^ftGY@Cpr1*UQJb1mAxc7Bt$8Afb*z2QYu($(0U>XB1}>x zQ|`uJ=Iy-=7?-VRZyk|R?a?S>+skG`)PJ<9iLJh>_Pmn*KdP@dmz9byCBg78l$g@- zZsgd@k^phW(P8hsGis%I0dO&Uu>fug67XgSnnb06Dj9B_c1LVDpq48o9;YkUr(Kl! z@@vv^RNCVD%LzA@bU0aSQ4m&;r}wBiXTmZj18HDKL|wO65|;Bo-2|C@$-t?Al*z}3 zm^vSBI#5HR46_t$u9ie|TC#?*k9)|>Y>B>*f}1s=cIxu#%)+sxP0o7<`BGcOOk=kc za>k=pm8?t@BDP9nwAUqMZyR4!vN(u@lT3KIqbF&8bN7+xjs3SdVB|VXKmh5ZgKb*} z2cxk{7dUU<)zKH=<}P?fD)r3q0|+AR>D>xV31a&c(b&Fj(FBTCg1rwwNq-!e*A|)bSDy@WyNOy@y zBO!I>&%NW0aWDUTV{hesKe3**=A3KJzmw1>T5ip7%C#FN#tO#YfaP$Rsz!Lp z-r%61dnN95SJjazM$uw%qUbA+sHkYuq|HcQ70yvx^O9EY!#k_v4xQ|Cn)IChcUW9i zlsU83CbT?x55wukcbhziL}HlFms}DMjdt8gASD95KFo@P=P^sI@p`2IX3;Yc7n65% zAxhSZZo}={N6+_GA3N+(dD3W?>MTRY%KX<@N0V#0YZO8oV;%oCWTsD!Y0%x79$Njg zqxG+3CT07>dUz3RCVi6f~vMVDmMzAQsfZ)XP$loz`FZtmj3uy=c&wyK8yg zw@*~9Vo~v4Uz)@$07^;Z&FO9kGcKdIcj+Dd>FAD(&4qDW^(la~@`Tufue4FjRgA&a z*g`S$ebE)hkr#fw`qr=FSDoPp{PhIQ44PB^PO#~d`eMonJxU{ef5CH+C|w38r2*|*mQF;1;sA{~cO^i7f@i8w37fh{dB=goDxfCssd<}ev0$4(j%BPy4s z{5N?&8-;Xs2WpJ>zo7D{mniMo>Ryx~%zOC9(8t99+Na7gmJ|{v-}rA{4C8xt#x$0z zi6L`r3549vJht{%bH*^2pn>ydrX0X{}g9zWhe-2d^f{-^yH{e!HH2RPAb z5UPRo7)aI*K+in@5yQ7sjWA#W1{%lgi)La~54tOlDfCBJ)^-0Vm1K1gu#M%Cuf9At zq8;<(Nkkn@Td}_VH(iQX>mE$oW^yR?V2YHiVoc9MapRAgUWK^?zi!sx?VN}Gmw4Wu zThUTxmFou)5*TinnbV@#V3k}LVU*nU>CV(#Ya6ET>t|?pul-9uXU|g_Z%9yx zs{@HYp{OcJn8(?4Lch5nRQsmS(n-Wqv!*^8^l9X4X%pY|&!3|~7e1_W?XucOy(P3* zJeU@DKTzY$f8qxfBZdw46JrdQ0}VVgvSgj78{^N3M$st*NEY|XnTYK*R4KL;d5l%5 z`XnyvZFrn+6D35WTJRNq8L2TL>uNe_R|kLU z^O+_8%-IP{_O2~wba=mk@j3;@4L$Q@BPEMdq!xn6i~L5#x!u(&+SZ!RGb7;J_Ws6= zTh?Cw+z@bCL9*_7g+718qk6g8CPz;0rRrdf5{~jn%2Opl_KX@Y#M2DJMoKo3XBkBq z*6YG84(uVYNU)NSSls#tjEY!O`Tfn6B^*L*>+etqD|DuG%KV)`$@6bqSCKINZX?Hq zPc;QqftwjRM19BX@BK2@=C+VaZt^@GWh9XQaanQu(O#> z)bsClE_y%O^cTz&)BsnIv6bhs?!w6WqQ+_dxe)(<-0t6uZO$okYf>p%b7($y_AKqx zOo`V2=6%{(J!u&Em#O@Pnyei7_Q+Qf1ka0wNCO$aCL^O zo#pmc+B8S;Ye0uiezWI@gN)}PtWf+Iuu)M6|SWdbsc>Ib72gbM%K=zT42| zX`%aJou<)L`mVp2%>kQ+=Qmn^2o0>`cqYJH(W%lBFy|r-^6_=^yV@s8F{SUi>mO`g zxG2F==z14)p$#@Zx!Gy%e>`5;L(rO&Q46;ex}Cw76MJRiFZ@b5)f>kL@J-?{2>nmY z^XJhHuHbPt1XtTNN|F#1rOLL~x@(CJ5+>qsbh?@-&jLM5;1DyqlTr+|o40Q#D=jty zA1C4A9vB*WtF(#dKu(?a@@BCqV*~%PYXv55a_)tP&)q{}w6a5mqH#S>t;d^})jR%Y zv$;P(lr`>j!{+l-A&z@mk3Nto@@`f+nir`x|9rOe+ZOJMlZ__@Qe164hvt`icM=VQ zZBiJeNF=Ra&rRDScsEA0<~}C6J1_rkO42Smv0ZH9RIIgZD3>n67)eEI690|`2ghF- zl@u=(lXjsP9)g=aS!{HkxmmnCtKqh~>~QAnS=$+NU~FVB{);viCp0V7F`gr549dPQ z$OeK&L^aRm5DKjkyzUBDR~B(roV?{r&I%TmOX#s-y}<|Rls={jGB9G@x(^Ip2d;;3 zT&>|m%THO?!rq{wT3)rPO($y_LQFF|Ob<24hju5~T-rQ4q5E0#r@_DE|09vM**+Pn z`Jcy?H?D_S_Jnr*CUuqBdh43D#+U^^*3$C+`PiA3Kn*9SIlUC=?{|2V%u0iAFzGaO zUdB`AV52@|4EPBEMVIcBF{C}NxHup?Z5$ki&_#5Uct5k2l37I}Z-m0r2$zbARRWi3 zu>Z$NF!g`t#^chh|G$^#VwbrC3A%-7MCcm-CbS}I3t-D@M9d)Cd9DEpug%6OUMJ3^cI%OiIVPk3!Flih4|*OA&ehW6 zNq6jrST2#GD1DhPOF9pgTlAO@#hPJPX&cv2Fq!B-Q($=R5UWl7@u>H+`abnz<%S|J8|Nft z>&I>Y+@*LjORa0&upjU4EtX6i0|hPAAstL2R@bvDv5I`&KbsR~`kvcZ^zgQj@C#vn zvsiyt$!&L{qL@%;MEx;Mc!P*XIgt)La1OL`htix&Yo^h53N&Cf)-}k(#X4A~d7BVH zHWZvkJBt=y-A;Q;{v6&|;v-{PEV0vC0xPdY`~AHn&kwwe>L~K!WD;{5e3v(U>N|^0 zT+?vURg6V{=dWw$I1IizO8iGg%36rohh>v^j~*PV9EVzZCdzr zMkURuoM(c~yKIAKWcXawayU+pbqd?Dkk>B%X@3LSsL@rS2svh~VZ+RDuq6@8LWPL! zC0{b_SH?GNP%(1`P+-R|WONdql|LXNg7to7Q&UrC?BmC$(2G)>^QNt~PdRYT`!&8I zAeS2o62Q|w>c*8+dR2{v=w=WqldIXSrPFY-=z?M3vTs^*tQWnJjp%+;d;OR-@|fl`nNP%3l(L==(iNQY6`*8m_57N1WOBy#LEr1$jVh|t+uhUqcC;7L4Q|`BC8vRZLC&s{iSKfi590n-$d+6Wh=T^MRm(9}nbW7Y4Zs6cSt8zMkD4tgOcw zPBoirHuU~LW4N`RKtPy9m25~WGJ*2^1pbo@o$PqEb~9C!eQ05We7A{5z#`p?D^5E8 z99q4e*G_`)&bs}Z=1!PTRO#ekY-@E&)iKw$>lB?(>N}642nqj!0t3x-)@lKSX2%g^ ztp0n_59d7R*YhsfKLr!WFDC*Z(oZ=zq5GdkU`yt^sqkAbJY%Ah&du=o1M4k zw2=2=s33vesuq2ix=qa0s~K`0I<$VDMqV-Ja!_!vEej7;+FDB7-P1-@Gkb$Z}=+p#~46*APpJ+W&ka?q!$yF|=0wi`B}KlS>p@8ti3|J!P^slc876yo~R? z_7wixFLN}Z`Z()m^%sWOKn0eYOsu5SM}Ydnsch8i!8DiSZ=~I8`CPN+UE?~~hj=9~ zNUpMxZGrEgm!gN4x{-bvcH zz>ojbX2PIs&7I!P_cbY9VZ`6y7e2q#%3!{v+A*b9-|V-W@JEPXr^kM-`!499r;67Q1ziZ3V9adLh|Hm}jd3T|d^;7{F1=(b4g8vFn1_ZP0{e01$0h zMlQO54NiB8Jz%rkdo87KVpL6txmG>o=5@BzAKYf^DX)K!^6P%KO<4b5 zW!KKUD>BB)CyL#DeY})CGj20&5O{O;Df1{sY%pRMKs@Z5YoFU!(rahKd|SA-`+}ab zaf!=)qV?;fwR-%TSad5l#khL=`r7p#Pt!tH8iD`usDTskAd%4YVWwSFU$EiGrAl!M z>c}@N1X+g?>;{%_L}z`~^X-lp8yk~+Mj$hWBh#2d|3hc61NEBK=l=v~;!R_dA8E$L zUl|q?oIakYFEDDJ^g=j@F~~lwNnur1j99h|bnbn7SW%*B`adpS5;qFlW#ei(_$t(GbD{5I5Hy>o)NG_1eRa`xvTh<{EONg6c-oQaDjIx!Y$Up zhm@U*%NGgoMkgiEU;!jidwX-|^iX|Hj!vOtAj%@e1biZHi~#&%*&}3D1ss`C)aH2+ z2}woZdl2??uzlwj73G%U)4nBn+rg|5NIXW%t{-aM9dIEnpI8MLg*KRG^R9aOqF8M<3nC41X=jHpKj`zZv zh3H-m2>Vs%e(zFTT@%cqV2DLE3Yb(dy1TDx_K`AyP8gB(|9{YyXni0xGe5qpE#Q$&!%!cPXQwAFpbeY{=Ur}pFz=P+D%V-CEUlJ~1~EYKGB`YS2xef00L z$3ThM*mqUw`T(216Jvlv*gsa+zq>T9Pjr}`nPvS|NiWDKm)dRGcFlD%LcGlIIViUx z(&S`hrG({%{9LcP1_(2j{#TUFvKaq)eIofBS$^Dm7d<-Gu1(dhPz56 z5#Gl|TE5tLJmTck!xzdlZeZu<=YM(m>6){i+irk~%bPudtzw8e`auczVE`jE0oj8g z_AA(fS@57yI1rQrzoYoUn4!du%@hpmOhN%tYkc>0I*Hs{qf5!9ZS=v{OXXE9T{HJX2On|SVNgtM4QoKj#SwdMb-z-tE3R%c+a+GM)av$D8#X_Z z^M3(bnWE9V2U_n#Dr-TVnErQ1k&tt!u$uXHUjJ=aP>^jNaN)xp1;S|4>X>KK;tL9; zY#fe!`S4oJsQLDZuM4H&iI|m6yu@p!Bsm$>a65&(#GOi*Iv}aPPfwI=J%4 zxXusawspWE&b{L!QJ#<_IK2#mkT?7ha`>>-Zenn8#YP()&}m3ce$_x{ECOcYsepp5 zM5msm?2)3q$*bomDp+DZJ)3x+8>#hU$CZIwmk{AYe#Q3) zWA>Uz9+nj14S<=+AY z)pngc=S|O3hvOB*Z(YWuE@sM2n>Xu%6s-b9LpMxN%K2vMmhYRy>E67MdLidb}e3}~g1m_B=G(MDc{C8Vuu!-55gD4v0 z$@5&}D>i{8Lj|>lOd*jg)vQNOQdqs0df?DK8u9$Ua$>(NR(9ZN09!`ul>fAq;NQR1u=HAxAXcP-639C+pxA_l$ zHM=i9N&9Q8cFu3_3)wF}a~wYW*B+_N8#mp^zhoWlxMkKF>-VylnPG|;iK@i1ch5^lGWQAv>1C79t}j03@G~qmYMRlvVfNS9FZuxJ6K7e?cKiAAM#Xl z$0?o(WbRU6VS6>9?Z@p{aJ1(?Ev;}@uz>vJVqEpMK6RC;zUA1R;kE4k2el72cX$G} zYth@Yn=2-rkBN@!5?|at?iU=B#-pCbS6(jJ*WxCXMMNv#B0eTS1Uz7RswHTMAiFZ8 zL47{k`s1=xT75-)^~}<7@K|ejb)O|GXtdY5A1Xete6yBgPU89hbqFaZ`)wO%{iM=6 z>_xZV^>e`{!_2??c~+xCGhN4h6lE*y{j}bddaC_iay|kIq9kn^$|gt=^=z|h=-tr2SYegPhW@oGb?1Vpx1~@S<@Mj*r9Wvr zEln6`PKG_Te?dX<6Zl5h;90(?=unk^-C=j;y<(&PN&r7PjZW)W3wFb8-109r@u0(v z;u!z-<3sncuB%^jDC(bB4q6rJdwrQ{5xIZuh;?qH=8r3dgVfr0Q3Gmw-eMQz=FP*B zt4jg}4&#PcD*wN&sXW83X&tk?)Yuv?W960cw#+4Kkz~8mhM$jIy=Y01xm&Yc)v_S$ z``esKPSO~VpPUcgw>MLvz?PoYJS|B-D4`X!Lo$cCa%_8g84*RFz94gNHDjnj(!7|q z8b#7dRA4tyRgMr>fUxez;5e5?qLzt;1Y;syU_liC6puQQ+6*7H7h9>Q__yp`OTU#O zDVr)`Z`-M%1C1}~6#H+>zxmA^%`pgwd{u2h@ANS@KL{`66Lud2!aiV*6 z__m!PEU`v7#;Lma!l@H|T`i z+Ix;Ba#EFc2eXZkriw!Il3{1kmx!_Qw~%#6t#m}klBU=I%AsgU_t=@48BKlYW}xM_ znf(kj7{;lwU$)liFKBdD4@OE~kMWaIuU~Vysx%<|=kJ7kvN=M2Y_@_V=}3s~o_N?U zIsT`hXKr_Y#^C-_%4>{)^QV;9G2fw#D$&)BKaJCDO3bs|@W!|Qv;lF+8+E=7%k+Kb z7j}d)9!Ml!E_B*rv(5V0qS{#Xr`%caqJ-B43-~oxmz)#$J(u!zJ>BZGs;mBl%;9?) zS@zM{nj8L+zI-L&`)EYGBAzPpQ&s!;iQ!XtG-Is^KACzRKy5$2c@|exYrsF*E`F>f zyN8ypRJy)*?u48eWsP`I1Mzd({jSFOcG8X=xAf`B*YW`oavU*D#D*TvXp!^pXK+cG zpYONaobl+wMGwC)H<3#3WiN{7^e3d$C(W<(^U5t^)*PMwmUlrA7n)HaESf3nUwj^z zX|?RI-JkAt5#N)$Zc=xTTIkKv96C%t7}2NN@pzY9Ue3l??ldwL==9AVRt|=ATO^RV z)Ytj;=IO80;n>UR!rRgSuv-ECYd|dyaLGC7KDw}SjzgW{MBnkn`UJ}B*RTKfqP+Hf z>*BucJYbd>p_+&C7|Of<^DxLiDQ*3T@=+9EXN{w)MfRq<7?WxwS)W{*|dH z8jWyQN9t)Nap@~@|F{O^Nc<7eVeNW{Lhb7*`~CbatPXYOo*{|$CH{CgKzbfHdi0}O zA`MYK(i{;J967!@$-S{AJ1>Feip%zRb@4|z8j`M>9oBpiL}WmI0yPFhSnJ=qUs=H>fMbIWT^jr%pIH5>2(Dce?`**#+s+r}3lSNidh*4A*%~hS`cwbhHv#spRKEEEY0{I5?9tCwy>R^ zVnrL)&{RG(#)FcDg0(-ZjE;8Ri_BS z{zT&3P3Hg|fBk{wtz>@YI+5wwlzi*mv4H;I#@CZX(<73>NFk}R9q-$v(t9r~{sj%z zqeEEpQa$VF>C>luu~-aqH*LW>kjNSR%RZV?V`9ot?_sq#f9qPij`?1h>vb0e)O=IQ z8n*6M=S$JdOlD92Z}l;H_>AU;Q4SW4V*=xC`)-TXxGqXIN|9Xb%Vb$0BFs)YN z2Mfx9tGVB(n0QxY9|DTPzn9;!Mnblre zp^XE=TQ=tN&kYByb2hpiee1vx53G`XB3fj=f2@iteJ&{^tR|@adUTTdo%qVbaJ3TF z9&O5|+t@)muquR)lWyh%nh*v^=1tXUU ze>k*E3wvzG2W)?NpIm#Y^zl^y!1ODtZ5$T?Ov&rw3C3#u1;~GXG^NL(eCxp#L_S@C zt;L0%+DC`>$cyj#*W;~k2qSH8VD8m==?UA+r^H#5#T;}^)6AY~xJY1~6}pvks6o)K zBAfQ>zskvbpbhC*ckeFu;VHg=mvrLy?{YA2$R?Vq5vaEUBFj9Ti}Go&^9c#c=V6*W zIWuz*n_@ksp21I^^uO+cXoLaVZm4YeV;SirQ1ld$dxk3Tu2P~IZW24d`F`XEPV!9Ev z`>~_Tb()&UZ@Iba-oIQRale4GYoQbjKW@Csb33acd5}b`?jS?$SbZ_(G<~R(iQxz0 z$WPvoP$8=k^YincpPkzZId3noTkBh6;8x--ty^dhKOUXb4-l_F*Xx9hazYm19+BsS zXl(%V08@w&t3)#6COj&{j+Ue;5UUfoB3J{x#fPo{sVwR^u@8XSr|;uXawovr4?r6d zIO=iVj5`ZOnS?E#L-n)ZDm^t0y}K*!JXjZ!V7m>btf1^F!};`8i(N%w%aX$(k0&t+ z$$C&O4rW4ggg{Z^C%Tc<^)aFy0@Jh#PTY2L$hYpR$N*sr8eId>i(J@J;T`i{FMK!)%dAm$awZv=e<~cuwM1M zMayv)m#~*-(|fb**CL{>Jp<sedt!?0D@W=h;cnQAGN`04()aeSts-v?!goukv287ZAU~wnt z0MizopcYs9Dq!|D&JH#(p<;cSHM}nzc19{s6qwZDfSiBPa@lk9b0QH~tq*}pN2L7r zN`CbzA}GoW79EZ0!L`Ju7A?7vWnMIOCsN^QUc1B=ioMxo&dCRNea^G9%PDR%N?~4)TID@RfH7?FcX(vZaE!wZ3zz2nfhW5GG13HG30AFX+ zoNVC0cX76i=1y`lCj|b6c*IeQ=e*=r6KQqJn3SyLCBJV(>GqAAieoni70AF>u zv*_gGkfr=7S9n`>bh_g`fgQ{))CC-S#@JKwpSq)R@g(S(hMuNoi0^NHPhniYg_by} zLCf_e%Txs%A+t8r|H4|2>YsmM@?>F;E$p~d!>SBe=uLA<;Tsn|Fna@!YB}#>(RrL% z^L>@pR%8PhOoWOyQ?)7ep(7nTD6g^b4IPfArlx9FzomLk!?2M*UIw9 zMI?%v`34$y@7^eC_mErsa>`~mavn23`F%iKf^D}>6BB1O@Zbb6bGz(C$G5Ms$T~xr z<|^>KOz^iF6g!}zp25zTSaRbWfwJR*;*-ARbrgiQF*GzR4%$UQ&Qoq~Zb;21BL|(t zfpKrVuHdTGGdNfwKG&`<85@Nslpnd58>krGC8uKvcXpKW*XB&gJH3QeH~e1XBWOG^=|U<7Ou_qzPb z5UVe7U9h3p3sWhk*b#)iQ65(1O^&Wdz-2BpM~o7#A|T31@HlCkh)f!*SRE6NDw?7y zf0y0hvy~V6u;8kNIaV)c4b-$xIE=}mBr@|ul+YySl7NqBFsk>qf$%L}7-S-%F>Uu{dvp>l_}7)@c7b)K*LJ*1T%sY` zCYh7_Ox-hyRX388B2f(KGh1r#9YkS9AKMfbmq!Qj4UCSb@bzsLrf!hzwd*>8c5G>` zJjz(#({KSgj-IP}wkRLf5e}TueatGw^>gE0Fg7VuDp^f`3%@FfdQnklZk$8)sIHC+ z17QnThfGq-WTzlrf89}*#ZM7HX!rA*7o&h-H*O+WRe226s@Z0Y7%ppsV&l^@kVJ@u zRR#1Jq^fSFqUuN6Le#GY1_s?wBnT47vIyRY&k!{z24#|R-#wp-lYl?`gi(f2!wA}*)W7zQhE^1mb~*UK1RIF9%<3Kz9(uv~&|3!pkLpd=G|&;=*F zpr}^^Sjf4MN4KU1<3v)yn)CXhid3g#`se z5bQ>xuifxCnaTL#9H3!fsKVcJ({j-$s84#(d0>PWt)z}j!IHO^*Za~^wx+nPput*J z;`H?N(*B6w9+>Z1Emlv7Uv)WOPpCY??mhl(KRY+XMkpz`1`@TBhORx9TdrjqUV^rI zz-)l>{bW-!Dh?JC`eGb9t7mU_p>~U56=o%B(9%!;+Y*+^favJ`(J!~MU*J6b#3Iv% zUzF~Sl;#J`1 z?P{goRVAl1-#k2@7^_#lBE{uKf8o_z-}gjSpQoS?Pkz zJ6d@|GOn;Mt7I&``)9}~aSc8q)(93LM4Q>7*X7tpO-NQ=eDKXb|fgdd#5%x=+JI9ADH1uK={Uu!Ok~DJS z&NJ^C8$+Pr)XA#H*@tY%>MPPyACJD^4B3slMo)pS@zZKAUNCTd_fS(NFnIP~;A%{| z<_UV6r~-&811}VF?6mrzv%tXb<@tL3x<~di%kD+>hu(nzf8^))0>YveH;Yy?q1J5k zPncY6pTyYB2r9!_5=GW&X|ghcPv4_6-n;#Mr?&HcOq*!{*J>Z{BD_DWs$8%Ag+Y9i zTkk#{i0pTY-I}!7Zc+c0_@tuv%S}F!RAjqQYU~8g*qQo*6X*KJtfsDR0HoNfDEHlD zed#e4O#zD6k(sTnyVJ@%v+{}4P}|^<1FLQi*F?|0DKk#9mxpc(zD2mOHq47gZRoSe zM_RVVD1#G?8g0Ycs=2+9_|LwoK(>P%99=Vw3g{Ck-blRWQ9Qg@yAC5@9){NdPEPhM z^mR`3){c%M@RiEV&5gp-fy16G%R*<>(nf3vO_3;qmw%yTby3pA1y}{yz^E6W(~R{B z;#>_NzJHo|HnX!>b8MB}gg+rtseO*3UTm5Q-A{#?5Z>AgVBtque?eMCHZ-xU&4}el z9LS|@ZEeM#S4~WQQj61*zX&^Rx%v5T&=@hVCgLU3ehTd0L`_}Z*x1-9eB#6&dipTUlI^R*6FsGbC~MXa zxWQTAcn;2guT{BRQB`JlTVW~C5W5%XX#aQ&IcL%yzD#mX(MQ?1c9EqEAdO}jd9@ru zLL=O(oH}a(J=7oj{$+0Uw?x>TA~R#{#isI#3d2RlA3sb}@JbRj1t@TSyC0V!&m!$S zhJ?SmE?Wt}+1LMDme^V8a=_n=^wAsOGdv$Lp}xzDA0s0nu zrrBG*aF0jU26zp6?*77p**J4Vm2E;q*bE-0F-T{YYpJEqpb88*72_2mN#`(b=ryZOMi2#b-FH(~r`v-RpsDP^ zJX!m@5LcNLE6np1#W0AHkm&3YJYj>7K{R=AQ~3M;vo=ZM2nfJ=XWd`5li*v|5~vW_ z%ue93qWd)C?FAR)*UlQCj=K7qeiauvKzpy*Jlgv1be?-L1XI&344 zUEZ}eF}5bwk^g;F!rbL!ylVv5J70bGQsK-|LLD00gT@v0*OLgZk$+*SASZ{7twSw( zvQG}bFPiH#UAa=gfVi`d%8Q9u1tc#8q5rKKWK3Z7{u|GfJvHM1b(Imkw={=}yUf+^ilnOY|ph_b0 zgM?J)dnrnW*odm1eR>OJ=~Q;(Wg@Hw&Zuk=NP%%*Sx9UcbUqYlJ&;$} ziwugAr_-@GfdF*qW~r-XnS_+S+K`r(Mm%m|kzj@H7W)%hfr~sDH`#;}y>50M-NZY+ z41k}R$+N~SZw?_67$HHt8jB(0!JLPt;f1!*;84(1JWd5Nt;oS37{Yb!taS-k!o`!` zhn{6W8{2&n6*++i19(yI@Nfi1LX3G3?(TJ+z~&w>y9Io{%+Uyg4AuF;D9e``Icdu- z@RzxVPcs2eM*|ms1Ui+$ikI1Kb+w~0_EYk*FEJRod-pD8gMDrFwI!?84)rTfC$e1q z@^W)8=U8Y-tjz0EK&%)zZVDPVF8sM%WTAB#G(?r9HTQa6yg3x>Chl-2mWjCMj;pcW z9vu*2D_k3)RKl9BX!7ZS$@as9Kz0yJbp^APZ8vm7JHo}E>e>n8Lk`_euh_NO6<|RZ z{XJyaXA!rtm2@nR(|3hgh83qZd3BA{>jooEwZ?l?3I>M_5tKqRdE=r?N&Gnel#E)i>RycWc%1dpu%`Yd9lfq68oH4#IaD|#Hn zi3MO9d!?B40f_8-%yeYZHEw*h`*Bv}3&1X$P*35|`I4-dh)=kLjEin`VsbGi#?^Gu)Sw9fccumK3ay@V@2wllF z25kNgI1vaVR&+{sBj5dSYymT9DRL3U=M)X{^DnNDSo|e`mX|ELA}^2u1U}j5p=erO zg^al?Zm7X=zK_P>MDxW=tA9AB`@H z3t}N_N=MCiuibKuZ{K)G4oEbI^=DUtk1D6!R7_Ewyrpn<>`dm$Bfg`>j_(djI%i(7 ztBaB@yBFry+f`(2CPC+3kjQ>uDm?=RN#xz~C@3hnlA_AjhZ&I{H`iSAlPr%`;hx#A zj)JDW4mb9ao0W}jf#J?1@YexT3vja;Iy$PV;e0S4XG0IJa~lATMjt?GKAhB4?~oz< zcDWh1-4Bz-9{6{71Ox;ivtCvo$M3=kOKibV?Q4=mamcKsW|e41i}{RXw~&trQ$=Z< zrha&52SkiqT?;3XoXmjNnisejxi#@#S>wZGQAPv{uZjDk4*hlI_;c9%so%^tsY!*${& z
\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/input.yaml b/docs/source/examples/example_13/input.yaml new file mode 100644 index 0000000..8c9742e --- /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 0000000..5fede24 --- /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 0000000..74fa202 --- /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 0000000000000000000000000000000000000000..a4d5809effc38b8ca6e9507ff627fb0b45da18de GIT binary patch literal 155305 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 z
\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": "iVBORw0KGgoAAAANSUhEUgAABGsAAAHWCAYAAADARQSRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd0FNXbwPHv7iabnk2vhARCgEDoNfQSCEgTFaRKE5SiImJBX0UURVHBgkqRDoLth1KU3kuoIr3XQHrv2ezO+0dkw5JCgkAoz+ecPYe9c2fm3iHZnTxz731UiqIoCCGEEEIIIYQQQogHgrq8GyCEEEIIIYQQQgghCkiwRgghhBBCCCGEEOIBIsEaIYQQQgghhBBCiAeIBGuEEEIIIYQQQgghHiASrBFCCCGEEEIIIYR4gEiwRgghhBBCCCGEEOIBIsEaIYQQQgghhBBCiAeIBGuEEEIIIYQQQgghHiASrBFCCCGEEEIIIYR4gEiwpowWLFiASqVCpVKxdevWQtsVRaFKlSqoVCratGlzR+do06aN2b6ZmZm8//77RZ7vRnsuXbp0R+f6L4o69+DBgwkICLjvbSmL3NxcXnzxRby9vdFoNNStW/e2+6xatYpu3brh6emJVqvFxcWF9u3bs3TpUvR6/V1t36JFi3B3dyctLc1UFhAQUOLP1KJFi4r8uXz//fdRqVRlOv+lS5dQqVR8/vnnt617J8cvjdTUVD766CMaNmyIo6MjVlZWBAQEMHToUA4dOnTHx924cSOhoaHY2tri5ubG4MGDiY2NLVTv//7v/+jatSu+vr6oVCoGDx5c6nPc/BlR1Kuo32O9Xo+XlxcqlYpff/21yOPeuNZqtZoLFy4U2p6RkYGjo2OZ21vatkdHRxeqX9rrqdfrmTRpEgEBAVhZWVG9enW++eabO2pjSU6cOMH7779fLp+H91NRn7MBAQFl/n+fO3cuvr6+ZGRk3L3GCSGEEEKIu0KCNXfIwcGBuXPnFirftm0b58+fx8HB4a6dKzMzk0mTJhX5R16XLl3Ys2cP3t7ed+18/8W7777LihUryrsZJfr++++ZNWsW77zzDjt37mTx4sXF1lUUhSFDhtC9e3eMRiPTpk1j48aNLFy4kDp16jBq1Ci+++67u9a2zMxM3n77bd58881CP0MODg5s376d8+fPF9pv3rx5ODo6Fip//vnn2bNnz11r3/04/vnz56lXrx6ffPIJbdu2ZdmyZaxfv55JkyYRExNDgwYNSElJKfNxt23bRufOnfH09OSPP/7gq6++YuPGjbRv356cnByzutOnTychIYHu3buj1WrvqB/z589nz549hV7169cvVHf16tXExMQAFPm5cjN7e3vmz59fqPyXX35Br9djaWl5R+29XdtdXV3N6pTleo4aNYopU6YwevRo1q1bR8+ePXnllVf4+OOP/3Nbb3bixAkmTZr0yAdr7pZBgwZhZ2fH1KlTy7spQjxU2rRpw9ixY8u7GeIuGDx4ME8++WR5N0MIIYpkUd4NeFg9++yzLF26lG+//dbsj+S5c+cSGhpKamrqfWmHu7s77u7u9+VcpREYGFjeTbitY8eOYWNjw5gxY25b97PPPmPBggVMmjSJ9957z2xbt27deOONNzh37txda9vChQtJSEjg+eefL7StRYsWHD16lHnz5vHRRx+Zys+fP8/27dt5/vnnmTNnjtk+FSpUoEKFCnetfbe628c3GAz07NmT+Ph49uzZQ0hIiGlb69atGTRoEH/99dcdBSRef/11qlatyq+//oqFRf5HX6VKlWjevDnz5s1j5MiRprppaWmo1fmx7JKCeSUJCQmhYcOGpao7d+5ctFotrVu3Zv369URGRhZ7XZ999lkWLlzIpEmTTG28cYyePXuycuXKO2pvWdte2ut5/Phx5s6dy0cffcTrr78O5P+hk5CQwOTJk3nxxRdxcXH5z20WZWdhYcELL7zAhx9+yJtvvomtrW15N0kIIYQQQvxLRtbcob59+wKwbNkyU1lKSgq//fYbQ4cOLXKf3NxcJk+eTPXq1bGyssLd3Z0hQ4YQFxdX7HkuXbpkCsZMmjTJNCXhxnD3oqYitWnThpCQEPbv30/Lli2xtbWlcuXKfPLJJxiNRrPjHz9+nI4dO2Jra4u7uzujR49mzZo1xU7XuJ2ihuerVCrGjBnD4sWLCQ4OxtbWljp16rB69epC+589e5Z+/frh4eGBlZUVwcHBfPvtt6U6d3Z2NhMmTKBSpUpotVp8fX0ZPXo0ycnJZm354YcfyMrKMl3LBQsWFHk8vV7Pp59+SvXq1Xn33XeLrOPl5UWLFi0A2Lp1a5HX7ca0ouLOc7Pvv/+ebt264eTkVGibWq3mueeeY+HChWb/j/PmzcPPz4+wsLBC+xQ1TWnz5s20adMGV1dXbGxsqFixIk8//TSZmZmF9p82bRqVKlXC3t6e0NBQIiIibnv8gIAAunbtytq1a6lfvz42NjZUr16defPm3bb/v//+O0ePHmXChAlmgZqbde7c2fRHZXHT7m5t17Vr19i/fz8DBw40BRYAmjVrRtWqVQuNBrs5CHKvXb9+nbVr19KtWzdef/11jEZjiT8rQ4cO5erVq2zYsMFUdubMGXbu3FnsZ8/dVpbr+fvvv5tGqN1syJAhZGVlsXbt2tue78CBA/Tp04eAgABsbGwICAigb9++XL582VRnwYIF9OrVC4C2bdsW+fs9b9486tSpg7W1NS4uLvTs2ZOTJ0+anWvw4MHY29tz6tQpwsPDsbOzw9vbm08++QSAiIgIWrRogZ2dHVWrVmXhwoWlumY5OTl88MEHBAcHY21tjaurK23btmX37t2mOoqi8N1331G3bl1sbGxwdnbmmWeeKXLa2+0YjUYmT55MtWrVsLGxwcnJidq1a/PVV1+Z1evfvz+pqaksX768zOcQQjy4FEUhLy+vvJth5kFskxBCPMgkWHOHHB0deeaZZ8z+AF22bBlqtZpnn322UH2j0UiPHj345JNP6NevH2vWrOGTTz5hw4YNtGnThqysrCLP4+3tbfpjZtiwYaYpCcUFD26Ijo6mf//+DBgwgJUrV9K5c2cmTJjAkiVLTHWioqJo3bo1p0+f5vvvv2fRokWkpaWVasRJWa1Zs4YZM2bwwQcf8Ntvv5n+ULr5j5ATJ07QqFEjjh07xhdffMHq1avp0qULL7/8MpMmTSrx+Iqi8OSTT/L5558zcOBA1qxZw7hx41i4cCHt2rUzTcvYs2cPTzzxBDY2NqZr2aVLlyKPeeDAARITE+nRo8c9WZflVpGRkRw9epS2bdsWW2fo0KFcv36ddevWAfkjURYuXMjgwYNLFWC4dOkSXbp0QavVMm/ePNauXcsnn3yCnZ0dubm5ZnW//fZbNmzYwJdffsnSpUvJyMjgiSeeKNUUpH/++YfXXnuNV199lT/++IPatWszbNgwtm/fXuJ+69evB7jrQ5KPHTsGQO3atQttq127tmn73WQwGMjLyzN7GQyGQvUWLFiAwWBg6NChhIWF4e/vz7x581AUpcjjBgUF0bJlS7PPnnnz5hEQEED79u3vStu7du2KRqPBxcWFp556qtD1Kcv1PHbsGO7u7nh5eRWqd/OxSnLp0iWqVavGl19+ybp16/j000+JioqiUaNGxMfHA/lTQm9Mq/r2228L/X5PmTKFYcOGUbNmTf73v//x1VdfceTIEUJDQzl79qzZ+fR6PU899RRdunThjz/+MH1+vv322wwaNIihQ4eyYsUKqlWrxuDBgzl48GCJ7c/Ly6Nz5858+OGHdO3alRUrVrBgwQKaNWvGlStXTPVeeOEFxo4dS1hYGL///jvfffcdx48fp1mzZqZpcqU1depU3n//ffr27cuaNWv46aefGDZsmFnwGvIDztWrV2fNmjVlOr4QokBSUhLPPfcczs7O2Nra0rlzZ9PniqIouLu789tvv5nq161bFw8PD9P7PXv2YGlpSXp6epHHv/HQZ/ny5TRr1gxra2tq1qxp9nDoxgOjdevW0bBhQ6ysrNixYweKojB16lQqV66MjY0NderUMVsbLSkpif79++Pu7o6NjQ1BQUGmqba5ubmMGTMGb29vrK2tCQgIYMqUKWZtOnz4sOlYycnJZg+t7rRNRcnNzeWNN97A19cXOzs7mjRpYtb/BQsW4OTkxLp16wgODsbe3p5OnToRFRVlqmMwGBg3bhxOTk64urryxhtvFPtdK4QQDwRFlMn8+fMVQNm/f7+yZcsWBVCOHTumKIqiNGrUSBk8eLCiKIpSs2ZNpXXr1qb9li1bpgDKb7/9Zna8/fv3K4Dy3Xffmcpat25ttm9cXJwCKBMnTiy2PRcvXjTbH1D27t1rVrdGjRpKeHi46f3rr7+uqFQq5fjx42b1wsPDFUDZsmVLqa7FzeceNGiQ4u/vb1YPUDw9PZXU1FRTWXR0tKJWq5UpU6aYnbdChQpKSkqK2f5jxoxRrK2tlcTExGLbsnbtWgVQpk6dalb+008/KYAye/Zsszba2dmV2DdFUZTly5crgDJz5szb1lUUxfTzcOt1u3jxogIo8+fPL3H/G22NiIgotM3f31/p0qWLoij5/7/PPPOMoiiKsmbNGkWlUikXL15Ufvnll0LnnzhxonLzr/mvv/6qAMrhw4eLbceN9taqVUvJy8szle/bt08BlGXLlhV7/Btttba2Vi5fvmwqy8rKUlxcXJQXXnihxGvQqVMnBVCys7NLrHdDUT9vRbVr6dKlCqDs2bOnUN0RI0YoWq222HPY2dkpgwYNKlV7FKXg96Kol0ajMatrNBqVKlWqKL6+vqZrfaPtmzZtKrJPcXFxyvz58xUrKyslISFBycvLU7y9vZX333//jtp7s7/++kt55513lFWrVinbtm1TZsyYoVSoUEGxs7Mz+5kpy/Xs0KGDUq1atSLPp9VqlREjRpS5nXl5eUp6erpiZ2enfPXVV6byon4HFEVRkpKSFBsbG+WJJ54wK79y5YpiZWWl9OvXz1Q2aNCgQp/Ver1ecXd3VwDl0KFDpvKEhARFo9Eo48aNK7G9ixYtUgBlzpw5xdbZs2ePAihffPGFWfnVq1cVGxsb5Y033jBr460/9/7+/mb/7127dlXq1q1bYrtu6N+/v+Lp6VmqukKI/O/hV155xfS+e/fuSnBwsLJ9+3bl8OHDSnh4uFKlShUlNzdXURRFeeqpp5QxY8YoiqIoiYmJiqWlpeLk5GS6//r444+VJk2aFHu+G9/LFSpUUH799VflxIkTyvPPP684ODgo8fHxiqIU3IPUrl1bWb9+vXLu3DklPj5eefvtt5Xq1asra9euVc6fP2/6/ti6dauiKIoyevRopW7dusr+/fuVixcvKhs2bFBWrlypKIqifPbZZ4qfn5+yfft25dKlS8qOHTuUH3/80axNf//9t6mdSUlJZp/Bd9qmovTr109p1qyZsn37duXcuXPKZ599plhZWSlnzpxRFCX/u9fS0lIJCwtT9u/frxw8eFAJDg42+3z/9NNPFZ1OZ7qGw4YNUxwcHJQePXrc7r9cCCHKhYys+Q9at25NYGAg8+bN4+jRo+zfv7/YaQirV6/GycmJbt26mT1pr1u3Ll5eXnc05agkXl5eNG7c2Kysdu3aZtMGtm3bRkhICDVq1DCrd2OK193Utm1bswVzPT098fDwMLUnOzubTZs20bNnT2xtbc2u0RNPPEF2dnahKTg327x5M0ChbCi9evXCzs6OTZs23fU+3W3Xr18HMHvaVpShQ4eycuVKEhISmDt3Lm3bti11Bq66deui1WoZMWIECxcuLHF6RZcuXdBoNKb3N0ZC3PwzVNJ5KlasaHpvbW1N1apVS7XvvVTcCKl7MXJq0aJF7N+/3+y1d+9eszrbtm3j3LlzDBo0yHSthwwZgkqlKnHaWK9evdBqtSxdupQ///yT6OjoO84AdbNOnToxefJkunbtSqtWrRg9ejQ7duxApVIVWrMJSn89S7q+N7Yp/w6Pv/l1Q3p6Om+++SZVqlTBwsICCwsL7O3tycjIKDSNqSh79uwhKyur0DXy8/OjXbt2hT4fVCoVTzzxhOm9hYUFVapUwdvbm3r16pnKXVxczD7HivPXX39hbW1d4jS11atXo1KpGDBggNk18PLyok6dOmX+jmjcuDH//PMPo0aNYt26dSWuo+bh4UFsbKxMTxDiDpw9e5aVK1fyww8/0LJlS+rUqcPSpUu5du0av//+O5A/Pf3G7/D27dupU6cO7dq1MxuBUpoMomPGjOHpp58mODiY77//Hp1OV2hR+g8++IAOHToQGBiItbU106ZNY968eYSHh1O5cmUGDx7MgAEDmDVrFgBXrlyhXr16NGzYkICAAMLCwujWrZtpW1BQEC1atMDf358WLVrc0T1iWdt0q/Pnz7Ns2TJ++eUXWrZsSWBgIOPHj6dFixZmC+7r9XpmzpxJw4YNqV+/PmPGjDH7fP/yyy+ZMGGC6RrOnDkTnU5X5v4IIcT9IsGa/0ClUjFkyBCWLFnCzJkzqVq1Ki1btiyybkxMDMnJyWi1WiwtLc1e0dHRpqH8d8utmVsArKyszKZbJSQk4OnpWaheUWX3uj0JCQnk5eXxzTffFLo+N/5oKukaJSQkYGFhUWixZZVKhZeXFwkJCWVu841gw8WLF8u87524cS2sra1LrPfMM89gbW3N9OnTWbVqFcOGDSv1OQIDA9m4cSMeHh6MHj2awMBAAgMDC61jAYX/z6ysrMzaWZLS/PwV5V5d8xvtKernIDEx8Z4scBscHEzDhg3NXg0aNDCrc+Mmu2fPniQnJ5OcnIxOp6NFixb89ttvhaas3GBnZ8ezzz7LvHnzmDt3rmn61L0QEBBAixYtzIKlZbmerq6uRdbLyMggNzfXVHfhwoWFfvdv6NevHzNmzOD5559n3bp17Nu3j/379+Pu7l6qn8cb5y8qa56Pj0+h9tna2hb6PdRqtUX+nGi1WrKzs0s8f1xcHD4+PiVOVYyJiUFRFDw9PQtdh4iIiDJ/R0yYMIHPP/+ciIgIOnfujKurK+3bt+fAgQOF6lpbW6Moym37IYQo7OTJk1hYWNCkSRNTmaurK9WqVTMFk9u0acPx48eJj49n27ZttGnThjZt2rBt2zby8vLYvXs3rVu3BuDFF1/E3t7e9LpZaGio6d8WFhY0bNiwUMD65sXhT5w4QXZ2Nh06dDA75qJFi0yZJUeOHMny5cupW7cub7zxhtk6WoMHD+bw4cNUq1aNl19+2TRVuazK2qZbHTp0CEVRqFq1qtk+NzKw3mBra2uW6MLb25vY2Fggf13JqKioIq+hEEI8qCQb1H80ePBg3nvvPWbOnGmWoedWbm5uuLq6FruY5t1M9V1arq6uRa6DEB0dfd/b4uzsjEajYeDAgYwePbrIOpUqVSp2f1dXV/Ly8oiLizML2CiKQnR0NI0aNSpzmxo2bIiLiwt//PEHU6ZMue3oixt/3N2atri0f2S5ubkB+X/slpSK3dbWlj59+jBlyhQcHR156qmnSnX8G1q2bEnLli0xGAwcOHCAb775hrFjx+Lp6UmfPn3KdKy7LTw8nNmzZ/P777/z1ltv3ba+tbV1oesNha/5jcWKjx49ajZi4kZZcYsZ30s3FiQHiv35/PHHHxk1alSR24YOHcoPP/zAkSNHWLp06T1rJ+T/Ht0caCjL9axVqxbLly8nOjrabN2ao0ePmh2rW7du7N+/v9C5U1JSWL16NRMnTjT7mcjJySExMbFU7b8RXLp57YIbrl+/bvrdu1fc3d3ZuXMnRqOx2ICNm5sbKpWKHTt2mAKjNyuqrCQWFhaMGzeOcePGkZyczMaNG3n77bcJDw/n6tWrZpmfEhMTsbKyKvSHoRDi9pRi1jxRFMV03xASEoKrqyvbtm1j27ZtfPDBB/j5+fHRRx+xf/9+srKyTMkKPvjgA8aPH1/q8996b2JnZ2f6941kBGvWrMHX19es3o3PlM6dO3P58mXWrFnDxo0bad++PaNHj+bzzz+nfv36XLx4kb/++ouNGzfSu3dvwsLC+PXXX02fZTf3X6/XF9nGsrbpVkajEY1Gw8GDB81G/AJmn1u3ZopUqVSyJo0Q4qEmI2v+I19fX15//XW6devGoEGDiq3XtWtXEhISMBgMhZ62N2zYkGrVqhW7b1lGNJRF69atOXbsGCdOnDArL4+sILa2trRt25a///6b2rVrF3mNihqtccONhVVvXkAZ4LfffiMjI+OOFl61tLTkzTff5NSpU3z44YdF1omNjWXXrl0ApqlIR44cMatT2lTK1atXByj2ydLNRo4cSbdu3XjvvfduOxKnOBqNhiZNmpiybR06dOiOjnM39ejRg1q1ajFlypRiF55dt26dKXNVQEAAsbGxZkHH3Nxc0wLMN/j6+tK4cWOWLFlitshvREQEp0+fLnPA62748ccfycrK4sMPP2TLli2FXm5ubiVOhQoNDWXo0KH07NmTnj173rN2Xrx4kV27dtG0aVNTWVmu540Fum/NmrRgwQJsbGzo1KkTkB9QufV3Hgputm+9if/hhx8KLdhc3GdlaGgoNjY2hT4fIiMj2bx5811bmLk4nTt3Jjs7u8QsX127dkVRFK5du1bk51+tWrXu+PxOTk4888wzjB49msTERLPsgQAXLlwoNB1WCFE6NWrUIC8vz2yaa0JCAmfOnCE4OBjI/xxr1aoVf/zxB8eOHaNly5bUqlXLNG2nfv36pod2Hh4eVKlSxfS62c0jHPPy8jh48KDp3qG4tllZWXHlyhWzY1apUgU/Pz9TPXd3dwYPHsySJUv48ssvmT17tmmbo6Mjzz77LHPmzOGnn37it99+IzEx0fRg7OYg+M2LDf/XNt2sXr16GAwGYmNjC+1z6+L1xdHpdHh7exd5DYUQ4kElI2vughspXUvSp08fli5dyhNPPMErr7xC48aNsbS0JDIyki1bttCjR49i/+BycHDA39+fP/74g/bt2+Pi4oKbm1up1ykpztixY5k3bx6dO3fmgw8+wNPTkx9//JFTp04B9zd9McBXX31FixYtaNmyJSNHjiQgIIC0tDTOnTvHqlWrTOvSFKVDhw6Eh4fz5ptvkpqaSvPmzTly5AgTJ06kXr16DBw48I7a9Prrr3Py5EkmTpzIvn376NevH35+fqSkpLB9+3Zmz57NpEmTaN68OV5eXoSFhTFlyhScnZ3x9/dn06ZN/O9//yvVuZo0aYKNjQ0RERF07969xLp169Y1zYUvi5kzZ7J582a6dOlCxYoVyc7ONgUEikr9fb9pNBpWrFhBx44dCQ0NZeTIkbRt2xY7OzsuX77Mr7/+yqpVq0hKSgLg2Wef5b333qNPnz68/vrrZGdn8/XXXxeZdenTTz+lQ4cO9OrVi1GjRhEbG8tbb71FSEhIobTS27ZtIy4uDsjPHnHj3JAf5Lx1ul1Rjh07VuQaIIGBgbi7uzN37lycnZ0ZP358kQG35557jmnTpvHPP/9Qp06dIs9x61oFxbkx3P52TxjDwsJo1aoVtWvXxtHRkaNHjzJ16lRUKlWhgGVpr2fNmjUZNmwYEydORKPR0KhRI9avX8/s2bOZPHnybaegOTo60qpVKz777DPT5962bduYO3duoRT3N0bpzJ49GwcHB6ytralUqRKurq68++67vP322zz33HP07duXhIQEJk2ahLW1NRMnTizVdbxTffv2Zf78+bz44oucPn2atm3bYjQa2bt3L8HBwfTp04fmzZszYsQIhgwZwoEDB2jVqhV2dnZERUWxc+dOatWqxciRI0t9zm7duhESEkLDhg1xd3fn8uXLfPnll/j7+xMUFGSqZzQa2bdvX5mmUwohCgQFBdGjRw+GDx/OrFmzcHBw4K233sLX15cePXqY6rVp04ZXX32VevXq4ejoCECrVq1YunQp48aNK9W5vv32W4KCgggODmb69OkkJSWVuBaWg4MD48eP59VXX8VoNNKiRQtSU1PZvXs39vb2DBo0iPfee48GDRpQs2ZNcnJyWL16tSnINH36dLy9valbty5qtZpffvkFLy8vnJycUKvVNG3alE8++YSAgADi4+P5v//7v9v2oTRtulXVqlXp378/zz33HF988QX16tUjPj6ezZs3U6tWrUIjPIvzyiuv8Mknn5iu4bRp04qdbiyEEA+EclnW+CF2czaoktyaDUpR8jOKfP7550qdOnUUa2trxd7eXqlevbrywgsvKGfPnjXVuzUblKIoysaNG5V69eopVlZWCmDK+lFcNqiaNWsWalNRGUSOHTumhIWFKdbW1oqLi4sybNgwZeHChQqg/PPPP6W6FqXJBjV69OhC+9+avURR8rMLDB06VPH19VUsLS0Vd3d3pVmzZsrkyZNLbIui5GccevPNNxV/f3/F0tJS8fb2VkaOHKkkJSWZ1SttNqib/fHHH0qXLl0Ud3d3xcLCQnF2dlbatm2rzJw5U8nJyTHVi4qKUp555hnFxcVF0el0yoABA5QDBw6UKhuUoijKwIEDlRo1ahQqvzkbVHFKkw1qz549Ss+ePRV/f3/FyspKcXV1VVq3bm3K/KAoBRkePvvss0Ln4JasZMVlgyqqrUX9XBcnOTlZ+fDDD5X69esr9vb2iqWlpVKxYkVlwIAByq5du8zq/vnnn0rdunUVGxsbpXLlysqMGTOKbJeiKMr69euVpk2bmn7en3vuOSUmJqbItlJMRqfSZkkr7jVnzhzln3/+UQBl7NixxR7n1KlTCqC89NJLiqKYZ4MqSVHZoBo0aKB4eXmVuJ+iKMrYsWOVGjVqKA4ODoqFhYXi4+OjDBgwQDl9+nSR9Ut7PXNzc5WJEycqFStWVLRarVK1alXl66+/vm17boiMjFSefvppxdnZWXFwcFA6deqkHDt2rMjPkC+//FKpVKmSotFoCv3e/fDDD0rt2rUVrVar6HQ6pUePHoWy4RX3+VDc52ppfjcVJf/z6b333lOCgoIUrVaruLq6Ku3atVN2795tVm/evHlKkyZNFDs7O8XGxkYJDAxUnnvuOeXAgQNmbbxdNqgvvvhCadasmeLm5qZotVqlYsWKyrBhw5RLly6Z7bdp0yYFUA4ePHjbPggh8t2aDSoxMVEZOHCgotPpFBsbGyU8PNyUpeiGo0ePKoAyfvx4U9n06dMVQFm9enWJ57vxvfzjjz8qTZo0UbRarRIcHGyWNfBG5qVb73mMRqPy1VdfKdWqVTPdV4WHhyvbtm1TFEVRPvzwQyU4OFixsbFRXFxclB49eigXLlxQFEVRZs+erdStW1exs7NTHB0dlfbt25tlxDtx4oTStGlTxcbGRqlbt66yfv36IrNBlbVNRcnNzVXee+89JSAgQLG0tFS8vLyUnj17KkeOHFEUJf+7V6fTme2zYsUKs3sBvV6vvPLKK4qjo6Pi5OSkjBs3TnnuueckG5QQ4oGlUhSZzCnMjRgxgmXLlpGQkIBWqy3v5jxWDhw4QKNGjYiIiDBbrFCIO5WWloaLiwtffvllsetBicfXwIEDuXDhgmk6pxDiwXPp0iUqVarE33//Td26dcu7OUIIIe4TmQb1mPvggw/w8fGhcuXKpKens3r1an744Qf+7//+TwI15aBhw4b07t2bDz/8kNWrV5d3c8QjYPv27fj6+jJ8+PDybop4wJw/f56ffvqpxCmmQgghhBCifEiw5jFnaWnJZ599RmRkJHl5eQQFBTFt2jReeeWV8m7aY+uLL75g7ty5pKWllUuWMPFo6dKlC126dCnvZogH0JUrV5gxY4YpC40QQgghhHhwyDQoIYQQQgghhBBCiAeIpO4WQgghhBBCCCGEeIBIsEYIIYQQQgghhBDiASLBGiGEEEIIIYQQQogHiCwwXEpGo5Hr16/j4OCASqUq7+YIIYQQQpQrRVFIS0vDx8cHtfrRf/4n94JCCCH+izJ/byrlaOLEiQpg9vL09DRtNxqNysSJExVvb2/F2tpaad26tXLs2DGzY2RnZytjxoxRXF1dFVtbW6Vbt27K1atXzeokJiYqAwYMUBwdHRVHR0dlwIABSlJSUpnaevXq1UJtlZe85CUveclLXvJ63F+33nc9quReUF7ykpe85HU3XqX93iz3kTU1a9Zk48aNpvcajcb076lTpzJt2jQWLFhA1apVmTx5Mh06dOD06dOmlMZjx45l1apVLF++HFdXV1577TW6du3KwYMHTcfq168fkZGRrF27FoARI0YwcOBAVq1aVep23jjf1atXcXR0/M/9FkIIIYR4mKWmpuLn52e6R3rUyb2gEEKI/6Ks35vlHqyxsLDAy8urULmiKHz55Ze88847PPXUUwAsXLgQT09PfvzxR1544QVSUlKYO3cuixcvJiwsDIAlS5bg5+fHxo0bCQ8P5+TJk6xdu5aIiAiaNGkCwJw5cwgNDeX06dNUq1atVO28MdzV0dFRvqCFEEIIIf71uEwJkntBIYQQd0NpvzfLfYLx2bNn8fHxoVKlSvTp04cLFy4AcPHiRaKjo+nYsaOprpWVFa1bt2b37t0AHDx4EL1eb1bHx8eHkJAQU509e/ag0+lMgRqApk2botPpTHWEEEIIIYQQQgghHhTlOrKmSZMmLFq0iKpVqxITE8PkyZNp1qwZx48fJzo6GgBPT0+zfTw9Pbl8+TIA0dHRaLVanJ2dC9W5sX90dDQeHh6Fzu3h4WGqU5ScnBxycnJM71NTU++sk0IIIYQQQgghhBBlUK7Bms6dO5v+XatWLUJDQwkMDGThwoU0bdoUKDxESFGU2w4burVOUfVvd5wpU6YwadKkUvVDCCGEEEIIIYQQ4m4p92lQN7Ozs6NWrVqcPXvWtI7NraNfYmNjTaNtvLy8yM3NJSkpqcQ6MTExhc4VFxdXaNTOzSZMmEBKSorpdfXq1f/UNyGEEEIIIYQQQojSeKCCNTk5OZw8eRJvb28qVaqEl5cXGzZsMG3Pzc1l27ZtNGvWDIAGDRpgaWlpVicqKopjx46Z6oSGhpKSksK+fftMdfbu3UtKSoqpTlGsrKxMC8jJQnJCCCGEEEIIIYS4X8p1GtT48ePp1q0bFStWJDY2lsmTJ5OamsqgQYNQqVSMHTuWjz/+mKCgIIKCgvj444+xtbWlX79+AOh0OoYNG8Zrr72Gq6srLi4ujB8/nlq1apmyQwUHB9OpUyeGDx/OrFmzgPzU3V27di11JighhBBCCCGEEEKI+6VcgzWRkZH07duX+Ph43N3dadq0KREREfj7+wPwxhtvkJWVxahRo0hKSqJJkyasX7/eLC/59OnTsbCwoHfv3mRlZdG+fXsWLFiARqMx1Vm6dCkvv/yyKWtU9+7dmTFjxv3trBBCCCGEEEIIIUQpqBRFUcq7EQ+D1NRUdDodKSkpMiVKCCGEEI+9x+3e6HHrrxBCiLurrN8jD9SaNUIIIYQQQgghhBCPOwnWCCGEEEIIIYQQQjxAJFgjhBBCCCGEEEII8QCRYI0QQgghhBBCCCHEA0SCNUIIIYQQQgghhBAPEAnWCCGEEEI8RLJyjfy8N4l1R1PLuylCCCGEuEckWCOEEEII8RCIS8vj6/WxhH16jkm/R/P1+jiMRqW8m/WfbN++nW7duuHj44NKpeL33383256ens6YMWOoUKECNjY2BAcH8/3335vVycnJ4aWXXsLNzQ07Ozu6d+9OZGSkWZ2kpCQGDhyITqdDp9MxcOBAkpOT73HvhBBCiDsnwRohhBBCiAfY6ahs3vn1Oh0+PcesLQkkZxoAyMkzEpWiByDboGfZpQN03PwNUVkp5dncMsnIyKBOnTrMmDGjyO2vvvoqa9euZcmSJZw8eZJXX32Vl156iT/++MNUZ+zYsaxYsYLly5ezc+dO0tPT6dq1KwaDwVSnX79+HD58mLVr17J27VoOHz7MwIED73n/hBBCiDtlUd4NEEIIIYQQ5oxGhZ1nMli4M4GI85lm22r7WTOohSthNR1Izcvky1M7WXAxgvicDBwsrDiREo23ja6cWl42nTt3pnPnzsVu37NnD4MGDaJNmzYAjBgxglmzZnHgwAF69OhBSkoKc+fOZfHixYSFhQGwZMkS/Pz82LhxI+Hh4Zw8eZK1a9cSERFBkyZNAJgzZw6hoaGcPn2aatWq3fN+CiGEEGUlwRohhBBCiAdEtt7Iyr9TWLwzkQtxuaZytQrCajowqIULdf1tTeWfHFnPj5cP4GvjxMSQJ+jj3wAHS+vyaPo90aJFC1auXMnQoUPx8fFh69atnDlzhq+++gqAgwcPotfr6dixo2kfHx8fQkJC2L17N+Hh4ezZswedTmcK1AA0bdoUnU7H7t27JVgjhBDigSTBGiGEEEKIchaXlsfyiCR+2ptEUkbB9B1brZqnG+kY0MwFX2dL9iZcYtyhQ3xStwdatQUvVGlBc/dAuvjUxEKtKcce3Btff/01w4cPp0KFClhYWKBWq/nhhx9o0aIFANHR0Wi1Wpydnc328/T0JDo62lTHw8Oj0LE9PDxMdYqSk5NDTk6O6X1qqizoLIQQ4v6RYI0QQgghRDk5E53Nop2JrD6cit5QsFiwl86Cgc1deLqREzZa+CvqBC8c2cE/yddQoeJpv7o0dw8k0MGdQAf3cuzBvfX1118TERHBypUr8ff3Z/v27YwaNQpvb2/TtKeiKIqCSqUyvb/538XVudWUKVOYNGnSf+uAEEIIcYckWCOEEEIIcR8ZjQq7zmawaGciu89lmG0L8bVmcCtXOtR0wEKj4pcrh5h+ajNXMpOwUlswIKARI6q0oLK9W/6xFCNbYs7iaGlNI1f/8ujOPZOVlcXbb7/NihUr6NKlCwC1a9fm8OHDfP7554SFheHl5UVubi5JSUlmo2tiY2Np1qwZAF5eXsTExBQ6flxcHJ6ensWef8KECYwbN870PjU1FT8/v7vVPSGEEKJEEqwRQgghhLgPsvVGVv2dwqJdiVyILViPRqWCdjXsGdzClXr+NmQb87DQ5I/4uJyRSFpeDq9Wa8egyk1ws7I3O+aqa8cYfeAnQt0q8UuL5+9rf+41vV6PXq9HrTZPXqrRaDAajQA0aNAAS0tLNmzYQO/evQGIiori2LFjTJ06FYDQ0FBSUlLYt28fjRs3BmDv3r2kpKSYAjpFsbKywsrK6l50TQghhLgtCdYIIYQQQtxD8f+uR7O8iPVoejbQMaC5CxVdtZxPi+PNw+v4K+oE28NexVlry4tVWjI6qBU2FloArmcmcyI1mjCv6gCEewfT1LUSPSrUvu20ngdReno6586dM72/ePEihw8fxsXFhYoVK9K6dWtef/11bGxs8Pf3Z9u2bSxatIhp06YBoNPpGDZsGK+99hqurq64uLgwfvx4atWqZZomFRwcTKdOnRg+fDizZs0C8rNKde3aVRYXFkII8cCSYI0QQgghxD1wNjqbRbsSWfW3+Xo0no4F69E4WKvZn3iZSRE7WR99CgWFes5+xGWn46y1xd6yYGRHQk4GLTZOQ6u2YH/4GzhYWmOtseTXlg/viJoDBw7Qtm1b0/sb044GDRrEggULWL58ORMmTKB///4kJibi7+/PRx99xIsvvmjaZ/r06VhYWNC7d2+ysrJo3749CxYsQKMpWHB56dKlvPzyy6asUd27d2fGjBn3qZdCCCFE2akURVFuX02kpqai0+lISUnB0dGxvJsjhBBCiAeQouSvR7NwZyK7z5qvR1PD15ohLV3oEOKI5b/TnMYe/JVfr/4NQEev6rwY1JJGLv6oVCryjAa2xZ6lnWc104iZ0ft/wsHSivHBYYWmRN1vj9u90ePWXyGEEHdXWb9HZGSNEEIIIcR/lKM3svpwKgt3JnD+lvVo2gbbM7ilK/X9bcg26Nked4b2XvnTb1q4B6JVa3ihSotCWZ367JpPRMJFfmnxPKFulQCY0bD3QzfVSQghhBBlJ8EaIYQQQog7lJD+73o0EUkk3rQejY1WRc8GTgz8dz2ahJwMpp3azMKLESTlZrEtbCyV7d14pmI9nqlYD4AL6fE4a21x1toC+evRZBlyuTk0I4EaIYQQ4vEgwRohhBBCiDI6F5PDop0JrDqcSm6e+Xo0/Zs580xjZ3Q2Gi6kxzPh8C5+vnKIHGMeFW2debV6O7yszYc/zzm3i0nH/mRc9XaMq94egKGBoTwf2EwCNEIIIcQjoKwr0EiwRgghhBCiFBRFYfe/69HsumU9mmAfK4a0dKVjrYL1aADePbKabbFnqePky4tBLensXQMLtYYsg57IzCQq2DoDEOpWCUcLayxVBYvialTmKauFEEII8XBKSMtj3OLIMu0jwRohhBBCiBLoDQrrjqQyb0cCp6NyTOUqFbSpbs+Qlq7UD7BBQWFD9Ek2RZ/m07pPolKpeCM4jNFBrQh1q2QaIXM8+Tp9d8+nqoOnKZNTiJMPBzu/hY3Gslz6KIQQQoh7I+JcBm/9fJ3o+Mwy7SfBGiGEEEKIImTkGPnfgWQW7kwgKjnPVG5tqeLJBjqea+6Kv5uWHEMeyy4fYNa5nZxPjzdbMLiOcwUAYrPT8LB2ACDQwR2NSo1GpSIrLxcbCy2ABGqEEEKIR4jBYOS7zQnM2RqPwVj2/SVYI4QQQghxk/i0PJbuSWR5RBKpWQV3Vy52GvqHOtMn1AUn2/zpSj+c28X353YQk52GztKaMVVbM6RyUzz/XZNGbzQwcM9CDidFsj/8DRwsrbHWWLK5/SumhYSFEEIIUZiiKGbrtt36/kEWm6rnjZ+us/9C/mgajcbA823dGDe99MeQYI0QQgghBHA5PpcFOxL4/VCK2aLBFV0tGdLSlR71dVhZqtEbC7I+nUyNQYWKd2t2pn9AI+wtrcg26E03lJZqDXYaLVZqC86kxdLApSKABGqEEEKI21CpVBhir2CIvozGKwCNh195N6lUdpxO5+1frpuyRNr4Xcbof4QnGvZlXBmOI8EaIYQQQjzWjlzJYu72BDadSOPmRA0hFax5vrUr7Wo4oFGruJAez8xjO9gVd4EtYa+gVVvwfyGdmGLRHa06/5Zq4YUIpp3azPeN+tDMvTIAH9XpjpPWBmuZ5iSEEEKUijE9hbSFE9Ef22UqswxpjsOgSajtdeXYsuLlGYx8tT6eBTsSMP57P9Gymi2Gakn8FZPCxqjTZTqeBGuEEEII8dgxGhV2nEln3vZEDlw0X/CvZVU7hrdxo36ADSqVisNJkXx3djt/XT+BgkJ9Zz9is9OoYOuMs9bWLBWn3mggITeDXXHnTcEaLxvzNN1CCCGEKMyYmojKwRmVSlUoUAOgP7aLtIXvoxs9HUUxonqAsiZGJet5ffk1/r6cBYCFBsZ29GBwSxfS8zzpHV+XJna+jCnDMSVYI4QQQojHRm6ewpp/UliwI5FzMQWZnSzU8EQdHcNau1LF08pUPnL/clZdOwpAO8+qjA5qTWNXf1QqFSdTovnkxHrqOlfg1ertAOjj35CmbpUIcfK5vx0TQgghHnLpyz7B8YWpGGKvFArU3KA/thND7NUHakrUlpNp/N+vUSRnGlBQsPO/hHPgZfo2fx6VSoWDpTUdvINJTU0t03ElWCOEEEKIR156toFf9iWzeFciMakFmZ3stGp6NXbiuRYueOosyTMaOJp8jVpOvgDUcPTCUqVhZFBLgnVeZsc0KEY2xZzmYkYCY6u1RaVSYW9pJYEaIYQQ4g6o7PJHohqiL5dYzxBz6YEI1ujzjExbG8fiXYncGGPbvqYdJ73PcyItms0xZ3jCp+YdH1+CNUIIIYR4ZMWm6lm8K4mf9yaRnlOQ2cnNXsPA5i4829QZB2sNWQY9Cy9EMOvcTmJz0tnX8XVcrOx4qVobALLycvnu7HZOpkTzTcPeAIQ4+TCzUR/aelZ9aLJTCCGEEA8qu6deAUDj5V9iPY1nwH1oTckik3J57cdrHIvMBsDKQsVrT3jQr6kzF9L7cD49no7ewf/pHA/OJC8hhBBCiLvkfGwO7/52nQ5TzzFve4IpUFPJTcsHT3mx4c0qPN/GjTx1Dl+e2kzTdZ/xzpFVpOXlMCqoJRZqjdnxVCoVs8/tZEXkP5xOjTGVd/WthZ2FFUIIIcSD5t13/48mTRrj6+vDqVOnzLZ1796NDh3C6NAhjHbt2uLr68OJEyfM6uzevRs/vwrMnz/PVBYXF8fzzw8jLKw9rVq1ZM6cOcWev0mTxqbzZmdnM2TIYEaOfBG9Xl9kfbWtA4qioPGoiGVI8yLrWIa0QOPhZ7Ze3P224Vgqvb65yLHI7PxpT5XOUz/8CP2a5q+3E+jg/p8DNSAja4QQQgjxiFAUhUOXs5i3PYGtJ9PNttWtaMPzbVxpXc0etbpgFMzAPQs5nBRJBRsnPqjVlT7+DbC10HIo8SoLLkTwUZ1uOFhaY62x5KPa3fG0dqCao+f97poQQghRZl26dGXkyFH07PlkoW0rV64y/Xv16tVMnz6NGjVqmMrS09P5+OOPaNu2ndl+kya9T/Xq1fnhh7lkZGTQo0d3GjVqRN26dYttR1paGkOGDCYwsApTpkxBrS5+zMiNkaoOgyaRtvB99Md2mrZZhrTAYfD7ZvXup9w8I1PXxLIsIslUFlZHy2aHw6yNz+Jwcij1nO/e9CwJ1gghhBDioWY0Kmw5mc687QkcvpJlKlcBbYLteb61K3X9bQE4kxrLjrhzDAtsBsDYam1J1WfTzbcWljeNpplxZivro09Ry8mH4VXyn+518Q25f50SQggh/qOmTZuWqt5PPy2nT5++ZmWTJr3Piy+OZOPGjWblJ06cYNiw5wGws7OjadOm/Pbbr8UGaxISEhg79hVatWrF22+/U+q2q+116EZPxxB7NX+NGs+Acl2n5nJ8Lq8ti+Tk9fzkBNaWKt7q6kmvxs5sjXkWg2IsMVCjKAoLL+wt0zklWCOEEEKIh1KO3sjKv/MzO12KzzWVW2pUdKvnyNBWrlRyz5+idCDhMt+e3c6G6Pzh2B28qlPRzoUwr+pk5uWy5NI+ajv50sClIgCjq7amvktFelWsf/87JoQQQtwnUVFR7N69m6+++spUtnnzZlJSUunatWuhYE2dOnVYsWIFderUITExka1bt1GlSmCxx3/hhRH079+fCRPeLnPb8qdE+ZmCNIqilMuImj//SWHSimjTlGpdpUt0b2RHr3rVAWjjGVTi/sm5Wbz292/8df5wmc4rwRohhBBCPFRSsgz8vDeJxbsSSUg3mModrNX0buLMwOYuuDvk3+JsjTnLN2e2sjfhEipUdPKuwaigVlS0czHt9+PlA7x/dA0dvKozv+lAABq4VDQFboQQQohH1c8//0xYWAdcXFwBSElJ4eOPP2b58uVF1n/vvYl8+OEHhId3xMPDg+bNm5OYmFDs8du3D2P16tU899wgfH19y9S2WwMz9ztQk6s3MnlVDL/tTzaVtalvZJXlLmZeUTGgWi0q2Drf9jjD9i5hb8IluvjU5IcynF+CNUIIIYR4KEQl61m8K5Ff9iWTmVuQ2cnD0YJBLVzo1dgJOyvzhYHnnN/JwcQrPFuxPiODWlHFwZ0L6fFsij5Fe6/8J2J9KjZgf8JlBlZqfF/7I4QQQpQnRVH4+eef+Oijj01lp0+fIjY2hi5dngAgMTGRDRs2kJCQwPjxr+Ps7My0adNN9d98802CgqoWe46RI0eyeXNVevV6hl9++QVf3wr3rkO3SP/pc3KPbMeYGIXT/y3DwreKaVvyZ0NRcvMzOWEwYIi6gNM7P2JRIYjU2W+SFXWFa0l6OusVxhiv8oFuLB16P0GP+k50+dOHWns3YPfPCyQp4DjmSzSuPoXOn/hOdxxHTeOtGh05l3SNjn8up3FYZRRDXqnaL8EaIYQQQjzQLsTmMG97AqsOp5BXMJCGKh5ahrZ25Yk6Oiw1KnKNefx0+SDbYs/ybcNnUalUTKrVFRuNJb62TgBczkik9cYvcdHaEhH+OjYaS+wtrZjVuG/RJxdCCCEeUXv27CE3N5dWrVqZyho3bsKRI0dN78eOHUudOrUZMmQokB+8cXBwwNLSkqNHj7Bu3VrWrVtf4nlGjRqNWq3mmWee4ZdffqVChfsTsLGq3w6bjgNJ+Xx4oW1OrxdkuMo5tInMNXOwqJA/nWlLwwlM/iOaTBuFapYX+DxrKq0H1aRHsBN5V08Tun8Ljq/ORuPkjjErHZXGPKySlJvJ63+v4ENjflCmga0rQQs/xujiwwsbL/CspnRhGAnWCCGEEOKBdPRqFj9sS2DTiTRuztDZsJItz7d2pUVVO1QqFVl5uSw+f5CZ53ZwPSsFRwtrLmcmEmDnSmV7Vw4kXjEFa/ztXAj3DsbfzoVcQx42Gsvy6ZwQQghxj7399gTWrVtPXFwsffo8i52dHbt27TZtX7ZsGc8++2yJ2ZludfjwYd599/+wsLDA3t6emTNn4el5+yyJL744EpVKzdNPP8Uvv/xKxYr3fqqxZVDp1p3L3r0S62bdyc418MEfMfxxKMW0bajTJla5uDHv4ho6VakGG5dg074/Gid3ANQ29mbHOph4hZH7l3M9K4W3DXqM6cmkLZyENrgxhvaDUIa8X+r2q5TyTFD+EElNTUWn05GSkoKjo2N5N0cIIYR4JCmKwt7zmczZGk/E+UyzbW2D7RnR1o3afjamsllnd/Ld2e0k5GbgqrVjeJXmPFepCY6W1gA8s+MHIhIu8lebUdRy8jWdozwWKHzUPG73Ro9bf4UQ4lFxYzrSzdOgbjAkx5L03lMkj/2VV3/P4EJcfsICeys1k7q50mhpb37o0pua1VvQ1TeEpI8HoK3VAv3ZQyhZGWhrtcC26wgUlYpZ53bx6Yn1WKg1TK7dlY6zP0DJycS6xZPYPTmmzN8jpQ+h3WNTpkxBpVIxduxYU9ngwYNRqVRmr1vTj+Xk5PDSSy/h5uaGnZ0d3bt3JzIy0qxOUlISAwcORKfTodPpGDhwIMnJyfehV0IIIYQoDaNRYcOxVPp8d4lhc6+YAjUaNXSv58jKVysz4zk/avvZkGcsmAt1Pj0Oa40lH9buSkTH8QwMaIyFquD2pqVHIEEO7qTpc0xlEqgRQgghBEDOntXE+jbh2QXJpkCNR+A1vnreiTaG/Wg8/Hiz/Yt09Q3J38GQR96VU+jGfI3T63PJu3CUrO2/MWzvUj46vpZK9q6saT2SPv4NAdCGtCDn0CYMidFlbtsDMQ1q//79zJ49m9q1axfa1qlTJ+bPn296r9VqzbaPHTuWVatWsXz5clxdXXnttdfo2rUrBw8eRKPJX2SwX79+REZGsnbtWgBGjBjBwIEDWbVq1T3slRBCCCFuJzdPYc3hFOZuT+BiXEH6bWtLFU81dGJoK1e8nfKnKkVmJjHz7E62xJ5hc7tXsNJY8E7NTnxUR4ulWsPPlw/x7tFVvFa9PSOqtADgxSotealqa9SqB+b5lBBCCCFuoSgKWVlZZdrHxsbmPz2AycjO4/r6FUzVDCDbMn/CUaOmsWxUtvDBudP8+PdRrJr3MNtH7eKNVb22qLT5I3i19dqSd+k4IY1b4mRpw0d1umNrURCzsOkwAM3xyqRMfxHN85+VqX3lHqxJT0+nf//+zJkzh8mTJxfabmVlhZeXV5H7pqSkMHfuXBYvXkxYWBgAS5Yswc/Pj40bNxIeHs7JkydZu3YtERERNGnSBIA5c+YQGhrK6dOnqVat2r3rnBBCCCGKlJlr5Nd9ySzcmUB0SkFWBAdrNf1C89NvO9vl36acTYvluzPbWRH5D3mKkdpOPsRkp1LRzgUbC0ss1fkPZ/ztXMjM03MlI8l0PKtSLuInhBBCiPKTlZVFUFDhaUolOXv2HLa2tnd0vpPXs5k9dz3P5+RywDEEnY2aD5/2oVm1QPruPsULLoHkXf4Jxxc/N9vPqlE4uUe2Y9nkCRZd3Ev3E3uwrdqQcdXbFRs4su34HKhUZM5+jQr22iLrFKXc72BGjx5Nly5dCAsLKzJYs3XrVjw8PHBycqJ169Z89NFHeHh4AHDw4EH0ej0dO3Y01ffx8SEkJITdu3cTHh7Onj170Ol0pkANQNOmTdHpdOzevbvYYE1OTg45OQVDplNTU+9Wl4UQQojHVnKmgR/3JLJ0dxLJmQXTmdwcNAxu4UrvJubpt988/Ds/XjqAgkKoWyVeqtqGlu6BRGYmM2D3AqzUFsxtOgCAxq7+7O7wGn52zve9X0IIIYR4sKQv+zQ/dXdqAilfj0ZlZYvzpP+xPCKJqX/G8nrKJv7StsI3KIHvetQn0C1/seAVLUeQuWomxrrtCi0gbNWwI+kXjnD17ScINuZyNKAGrdv0vu0IH9sOA8nJyeWPy5dQEqOgFGvWlGuwZvny5Rw6dIj9+/cXub1z58706tULf39/Ll68yLvvvku7du04ePAgVlZWREdHo9VqcXY2vynz9PQkOjp/Tlh0dLQpuHMzDw8PU52iTJkyhUmTJv2H3gkhhBDihpgUPQt3JvLzviSycgtyG/i5WDKstSs96uvQWqhRFIXLGYn427kA4Gujo71nVcZUbU1DV3/Tfk5aGw4mXsFCrSElNwudNn8otARqhBBCiIfbP/8cKXbETGZmJnXqFF4+pSj2fd+Evm+a3qdn5zF2aSQbj6cD8LHdi9RtdpXjhnV8fTmGr9x6Aflr29l1H1nkMfcmXma0k5GY0EY8W7EBk2t3LZS6+waXj1aavde06kWDbs+T8p13qdpfbsGaq1ev8sorr7B+/Xqsra2LrPPss8+a/h0SEkLDhg3x9/dnzZo1PPXUU8Ue+9YsD0VFuW6XCWLChAmMGzfO9D41NRU/P78S+ySEEEIIc5ficpi3PYE//k4hr2AgDdW8rHihnRthNR3QqFUoisLG6FN8c2Ybx1OiiOg4Hjcre16q2gaABRcj+ODYX/zcYhjWGkscLK1ZFDqIGjov7CysyqdzQgghhLjrbG1t73h6U3GORmbx2o/XuJakB8DZTsPHvbyp7OfFUzsO08ojqMT9jYqRGWe28fnJTVhrLPmy/jM8U7HeXW3jrcotWHPw4EFiY2Np0KCBqcxgMLB9+3ZmzJhBTk6OaYHgG7y9vfH39+fs2bMAeHl5kZubS1JSktnomtjYWJo1a2aqExMTU+j8cXFxJeaDt7KywspKbv6EEEKIO3HiWhZztiaw4XgaSsFAGhoE2PJCW1eaBdmhUqkwKEb+iDzKjDPbOJkajVat4Rm/ehgUI1DwwOWv6yc4lHSV9VEn6V4h/4lao5tG2gghhBBC3EpRFBbtTGT6ujj0hvwbkipBqcx+uh6euvz1Y3aEjbvtGncGRWFTzBmCHD2Y1agvVRzc73nbyy1Y0759e44ePWpWNmTIEKpXr86bb75ZKFADkJCQwNWrV/H2zh821KBBAywtLdmwYQO9e/cGICoqimPHjjF16lQAQkNDSUlJYd++fTRu3BiAvXv3kpKSYgroCCGEEOK/UxSF/RczmbM1gd1nM8y2ta5uzwtt3ahT0casfPjepayPPoWtRsuIwOYMr9Ico6Lw3ZkdPOtfnxq6/O/8t2p0JNOQS3O3yvetP0IIIYR4eKVm5THh5yi2nsqf9qRWQUjzC+zQ72ZlXB7Ddc2BkpMRnE2LJcjBA0u1hjmN++FgYYWNRekXCf4vyi1Y4+DgQEhIiFmZnZ0drq6uhISEkJ6ezvvvv8/TTz+Nt7c3ly5d4u2338bNzY2ePXsCoNPpGDZsGK+99hqurq64uLgwfvx4atWqZcoOFRwcTKdOnRg+fDizZs0C8lN3d+3aVTJBCSGEEHeB0aiw9VQ6c7bGc+Rqtqlco4bOtR0Z3saNKp75o1VzDHnsij9PO8/87+Cn/eoRrPPm+cBmOGvzhzxPO7WJuRd2E5+bzrcN86dE13eRqchCCCGEKJ2/L2cyftk1U8ZJV3sNn/XxIc/RikN7D6CztClxf4Ni5OvTW5l+ajNf1H+KXhXr42HtcD+ablLu2aCKo9FoOHr0KIsWLSI5ORlvb2/atm3LTz/9hINDwUWaPn06FhYW9O7dm6ysLNq3b8+CBQvMRuYsXbqUl19+2ZQ1qnv37syYMeO+90kIIYR4lOgNCn/+k8LcbQmcj801lVtZqOjZ0IlhrVzxcbYEICsvl6WXD/D92e3EZKexoe1LBOu86OIbgpeNI4cSr9DeqzoAQyqHkpiTyfAqzculX0IIIYR4OCmKwg/bEpixIY68/BnV1A7K49veVXCxtwTsiej4uukBUVFis9N4+eAv7Iw7Tw1HLxq4VLw/jb+FSlFunkkuipOamopOpyMlJQXHUqTZEkIIIR5VWblG/ncgmfk7EohKzjOVO1ir6dPUmeeau+Bin/88KF2fw6JLe5l9bifxORm4W9nzYpWWDKjUCDsLK44kX+OJrd/hY6NjV4fXsFQXngYtHkyP273R49ZfIYS4nzIzMwkKqgLA2bPnSswGVVy95Iw83vjpOrv+nYqtUUPN5mfZrd/P0maDaeEeeNt27Io7z5gDPxOXk86AgEZMrNUFG43lf+0eUPbvkQd2ZI0QQgghHixp2QaW7Uli8a5EEjMKUju52Wt4roULzzZxxt7aPNjy2t//Y831Y3jb6Piwdlee8avHiZRoUwanWjofwr2DaeBSkTzFiCUSrBFCCCEeZ5mZmWXeduBi/rSnuLT8h0gejhZ83seXvw2J7DuhJjor9bbnTdVnM2Lfj+QpRr5t+Cw9KpQuRfi9IsEaIYQQQpQoNcvAkl2JLN6VSGq20VTu62zJsFauPNlAh5WlGoDEnAxWRP7D0MqhqFQqXgxqQSuPKvSqWA9LlYbOW7/leEo0W9q/QhUHd1QqFXObDCivrgkhhBDiAVOnTumDJEajwqwt8Xy3KR7jv3OGmlTTMK13JZxsLaivNKO9V3Uq2bsWewyDYkSjUuNoac2Mhs/ib+dCZXu3/9qN/0yCNUIIIYQoUnKmgcW7ElmyK5H0nIIgTZCnFSPauhJeyxGNOj+1dmx2GrPO7WTxxX1kGnIJcvCglUcVAu3dqeHojVadf8vR0qMKCvlPr4QQQggh7lRCmp6JS+PYeyF/tI1Go1C7xTn2GY6QqozCCRdUKlWJgZodsed4+5+VLAodRCV7V9p6Vr1fzb8tCdYIIYQQwkxSRh4LdyaydHcSmbkFQZrq3laMDnOjbbADKlV+kOZ6ZjLfn9vJj5f2k2PMo7qjJ69Ua0tz98osu3SAD479ybshnekX0AiA16q35+0a4ab9hRBCCCFsbGw4e/ZcqevvPZ9BvznRJGbk36d4O1kwrV8F5seeICMylyPJ16ho51Ls/gbFyJentvDl6S3YW2i5nJFYYlCnPEiwRgghhBAAxKflsWBnAssjksjKLcg/UNPXmtFhbrSqZl8oyPLNmW0svrSPOk6+vFytDe09q2Lx7ygaD2sH0vJyOJMWa6pvfZcW6RNCCCHEo0OlUhW7qPDNDEaFGRvi+GFbgmnaU5saNnzayw97aw0feXdnWGAzQpx8ij1GfE46Lx34mR1x5wnReTOzcV8C7B6sQA1IsEYIIYR47MWl6pm3PZGf9yWRrS8I0tSqYM2YDu40D7IzBWnOpcUx/8Ie3g3pjLXGktFVW9HRO5iqDu58fGI9a6+fYHqDZwBo51mV7WGvPhDzvoUQQgjxcItL1TNu2TUOXcoCwFKjUK/1Rc5oLqC2eAHQYGuhvW2gJnzLDGKy0+gf0IhJtbo8sA+SJFgjhBBCPKZiUvTM257AL/uSyckrCNLUrWjDSx3caRJoawrSnEyJ5uszW1l97RgKCs3dA3nCpyYVbJ2pYOtMQk4G66JOYqlS84E+GwdLa1QqlQRqhBBCCPGf7Tidzls/Xyc5Mz8bpZ+LJVP7ejHh3FbOpsSyL+EybTyDbnscV60dnbxrUN+lIk/71b3Hrf5vJFgjhBBCPGauJ+uZuy2B3/YnozcUBGkaBNgwpoM7jSvbmcpOpEQz/dRm/oo6DkBbz6q8HNSaLGMeYw78zJf1n8ZCrcHVyo5ZjfpS38UPB0vr+94nIYQQQjx68gwKH/wexW8HUkxl4bXs+fBpX+ys1Hzv3Ie4nHQauFQs9hgpuVnMPLeDcdXbY6nW8FGd7vej6f+ZBGuEEEKIx8S1pFzmbE1gxcFk8gwF5U0q2zI6zJ0GlQrPFd8UfYq/oo7T0as6r1RrSx3nCiiKQpdt33Ek+TphXtV4skIdANp7VbtfXRFCCCHEIy4qOZdhP1zhcoIeyJ/21LzdNXIcErHV9gagop1LiQsJH0m+xov7lnElM4kgBw+eesBH09xMgjVCCCHEI+5KQi5ztsaz8lAKeQXJnWhWxY7RYW7U9S8I0hxNvsaMM9uZXLsb7tb2DK7clJbugVzMSMRJm19PpVLxZo2OXMlIpJN3jfvdHSGEEEI84tYdTeWtn66Re9PDpd4t7Pg5Zz+JqZk8X6UZ9Zz9it1fURQWX9rH+0fXADClTnd6/vtw6WEhwRohhBDiEXUpLodZWxJY808KhpuCNC2q2jEmzJ1afjamsiPJ15h+ajMbok8BEOZVjV4V6+Ngac2W2LN8cWoT/fwbMrVeTwBae9x+XrgQQgghRFnoDQqTVkSx4mBKoW0/7czkrf49qeimLTFQk5GXw5uH/+D3yH+oaOvMzMZ9qe3key+bfU9IsEYIIYR4xJyPzWH2lnj+/CfVlNYSoE11e0aHuVHDtyBIczz5OlNPbmRTzGkAuviE8EKVFjhYWpnq9PVvyJaYM7TzlGlOQgghhLg3riXmMmzuZa4m5pnKcl0voFhmYxVdgydq6+gR6IWtVl3icQyKwt+JVwn3CuaL+k/jpLUpsf6DSoI1QgghxCPibHQ2s7YksPZoKspNQZr2NewZFeZOde/CC/+eTotlU8xpuvqE8Eq1tlhrLHly+yyctbZsbv8yapUaLxtHVrZ+8T72RAghhBCPk78OpzDh1+vob5r2ZLRKI6vyHlDBuEb1GBnqbcpSWZRTqTFUd/TE0dKaFa1G4G5lX2L9B50Ea4QQQoiH3KmobGZujmfDsTRTmQroEOLAqPZuBHkVBGkOJl5h+qnNvF2zEzV0XvSoUJsgew9qOfsAYFSMuFnb42nlQFJuFq5WdreeTgghhBDirsjNM/Leb1GsOpxaaJs6xwHv+KY838yHF0IqF3uMbIOe946sZtnlgyxrPoQW7oF4WDvcy2bfFxKsEUIIIR5SJ65lMXNzPJtOpJvK1CoIr+XAyPbuBHoUTGXan3CZ6ac2sz3uHCpUtPW8QA2dF5+f3Miii3tZ3/YlfG2dUKvU/N5yhKTfFkIIIcQ9dTk+hxHzrxKZqDeV6XXXABWWKT6E1XRg8jOdcbDWFHuMi+kJvLh/GcdTomjlXoVgR6/70PL7Q4I1QgghxEPmWGQW322KZ9upgiCNRgWd6zgysp0bAe4FQZoTKVF8eOwvdsSdR42KJyvU4ZVqbQhy8AAgRZ9Fmj6H3fEX6FWxPoAEaoQQQghxT608lMy7/4si76ZpT3l2CWRW34IqT8srHkMZ1dK3xGlMf14/zmuHfiM9L5dx1dvxSrW2aFQlr2fzMJFgjRBCCPGQOHEti283xbP15E1BGjV0ravjxXZuVHTVmsoVRUGlUpGRl8uuuAs8VaEuPSvUZkXkEU6nxpqCNS9XbcvwwBZUsne97/0RQgghxOMlW2/kvd+us+aftELbNBku6JKD6F8rkFH1K5QYqLmakcSo/cvRWdqwtFk/WnlUuZfNLhcSrBFCCCEecCevZ/Pdpjg2nzAP0nSvlx+kqeBSEKTZE3+R6ac280KV5rT3qk4jV3/2dByPr60Tf0Qe4X+Rh7mcmUhX3xAAvGwc73t/hBBCCPH4uRCbzQsLrnI9qSDbU559HKo8KzTZjrQIsufTXgNwtis+THHjYZSfnTNfN+hFI1d/vG1096P5950Ea4QQQogH1JnobL7dGM/G4wVPnzRq6FZPx6j2bvg6FwRpIuIv8sWpTeyJv4hGpaaVRxVcrew5kRJFv4BGAHT1DSEyM5ln/evf974IIYQQ4vG16u9k/u/XKPKMBWV5jtFkVNuEOlvHeI/+jGnnjVpd/GiazTGn+fTEBpY1G4KLlR3dK9S+Dy0vPxKsEUIIIR4wZ6Oz+W5TPOtvyu6kUUHXejpGtnfD76aRNOfS4nj3yCp2xJ1Ho1LzbMX6vFStDXYaKxqt+xSNSk17r2p4WjuiUakZXbVVeXRJCCGEEI8hvUFh8h/R/Lo/udA2TZo7Vtmu9AyowZhQL9TFTHsyKEa+OLmJr89sxdHCmnPpcTR+DLJVSrBGCCGEeECcj83h+03xrD2aiqLkl6lV8EQdR0a1d8ffrfCaNFq1hn0Jl3nGrx5hXtXp4lPTNMf7+cDmOGltsNNYFXU6IYQQQoh7Ji5Vz4h5VzgTk2sqM1inoNbboDJoaehvz5QnRuLrVHxig9jsNMYc+Jnd8Reo7eTD94364m/ncj+aX+4kWCOEEEKUs4tx+UGaP4+YB2k61XZkTJh5kOZo8jW+OLmJtp5VGVS5KRXtXNgf/gYfHV/Hi/uXMa/JADp6BwPwfyGdyqM7QgghhHjM7b+QweiFV8nIVUxlet11MoO2YZHiyxivJxkb7oGFpvhpT5cyEnhq+2xic9IZVKkJ74Z0xlpjeT+a/0CQYI0QQghRTi7H5zJzczyrD6dg/PdeRgWE13JgTAd3Kt2Ugvt48nWmndrMuuiTAPjZOpNjyMNKY4GLlR1N3QLYGnuGHGNeEWcSQgghhLj3FEVh9pZ4vtkQj3LLNk2mE2qjJe0qezC2lRsWJaxPA/n3OvWc/ehWoRZPVqhz7xr9gFIpinLrNRRFSE1NRafTkZKSgqOjZM4QQghx564kFARpDP8utKcCwkIcGBPmThXPgiBNdFYq7x1dzZ/XjwPQ2bsm3XxrMfv8Thq7+PNerScAyDMayFOMj9UTJ1G+Hrd7o8etv0IIUVYZOUZeWRLJnnMZpjKjZRYqvTUqVNT0tea9Xs6EeDoVe4yk3Ex+unyQF6q0QKVSmaZ9PwrK+j0iI2uEEEKI+yQyMZdZW+L541BBkAYgrKYDL3UwD9LcuDmxs9CyO+4CHb2qM656e0KcfLiQHs+RpGtk5uXyjmJEo1JjodZggaYceiWEEEKIx935mGyGzb1KXNpNabkdo8issgNtdA0GV2zJm1080Fqoiz3G30lXGblvOZFZyQTrvGjtEfTIBGruhARrhBBCiHvsWlIus7Yk8MfBZLOUlW2D7XmpgzvVvAsW1ruQHs+Xp7bgbePIhJrh2Flo+b+andibcImaOm8AKtu7sbz5UBq5+qNRFX/TI4QQQghxr60+nMzbv0SZPYgCwKhBsdBTr7qe/wvzLDbwoigKCy5G8MHRv1CrVEyt+ySt3Kvc+4Y/4CRYI4QQQtwj15P1zNkSz/8OJpNnKChvXT0/SBPsUxCkuZyRyFent/Db1cMYFCPhXsEoioJBUfjqzFauZibxdMV6tHAPBKCZe+X73R0hhBBCCJM8g8L7K6JYcTDFVKaoDKiU/JG+1WwrMKbuCDoE+BUbqEnX5/D64RWsunYUfzsXZjfqS00nn/vS/gedBGuEEEKIuyw6Rc/sLfH8dsA8SNOyqh0vd3Snhq+NqSxNn80Hx/7i5yuHMChGQl0r0dClIsOrNEelUmGp0vBuSGdyjXmEulUqh94IIYQQQpiLT8tj6A+XOR9bkJY7zy6ezKAd2FxszFOVgnmvpze22pJHAKfos9gRe47O3jX5ov5TOFoWn8b7cSNjp4UQQoi7JDZVz0cro+n02Xl+2lsQqGkeZMdPowOYOaSiKVBzY31/G40l+xIu0cDFj5+aD6OGzptvzm5jzvldpuM+4VOTJyvUkSlP4pGzfft2unXrho+PDyqVit9//91su0qlKvL12Wefmerk5OTw0ksv4ebmhp2dHd27dycyMtLsOElJSQwcOBCdTodOp2PgwIEkJyffhx4KIcSjZ//5dDp9fs4sUANgsEtEscqgWr0opvT2KTFQczkjEQBfWyf+bDOK2Y37SqDmFjKyRgghhPiP4lL1/LAtgZ/3JZObV5BkMbSKLS939KC2X8FImtjsNL45s41UfRZfNegFwKxG/ajm6IFKpcLD2p4DiZdp6OJ/3/shxP2WkZFBnTp1GDJkCE8//XSh7VFRUWbv//rrL4YNG2ZWd+zYsaxatYrly5fj6urKa6+9RteuXTl48CAaTf5Q/H79+hEZGcnatWsBGDFiBAMHDmTVqlX3sHdCCPFoURSF7zfF8+2m+IIyFFTkT3GqrK/BM4EVGRZSp9hpT1l5ufzfkdX8ce0Iq1q9SLDOi4p2Lvel/Q8bCdYIIYQQdyg5I48ftifw4+4kcm4K0jQJtOXlDu7U9bc1lSXlZvL92R3Mv7CHLIOeOk6+nEyJ4oX9y3GzsuO3FsMBCHLwYHXrkY919gPx+OjcuTOdO3cudruXl5fZ+z/++IO2bdtSuXL+mk0pKSnMnTuXxYsXExYWBsCSJUvw8/Nj48aNhIeHc/LkSdauXUtERARNmjQBYM6cOYSGhnL69GmqVat2j3onhBCPjsxcI6MWXmX/hUxTmcE6hazAPdicb0ZYJR8+6uWDzqb4zJQX0uMZse9HTqXG0MYjCE9rh/vR9IeWBGuEEEKIMsrIMbJ4VyLztyeQnlOQ+qBRJVte7uhO/YCCII1BMfLN6a3MOreTtLwcqjl68nr1MMK9g8k1Gsgy6EnX55Csz8JZm7+fBGqEKCwmJoY1a9awcOFCU9nBgwfR6/V07NjRVObj40NISAi7d+8mPDycPXv2oNPpTIEagKZNm6LT6di9e3exwZqcnBxycnJM71NTU+9Br4QQ4sF3ITabQbOvkJhhMCvP9TyDwT6eoEbn+aZz4xLvX9ZFnWDswV9Jz8vl9eAwXqraGrVM7y6RBGuEEEKIUsrNM/Lz3mRmb40nIb3ghqVORRvGdfKgYSXbQvtoVGr2JlzC1cqep/zqcSQ5kqZulVCpVFhpLFjRcjg+Njq5YRHiNhYuXIiDgwNPPfWUqSw6OhqtVouzs7NZXU9PT6Kjo011PDw8Ch3Pw8PDVKcoU6ZMYdKkSXep9UII8XBacSCZif+LwqAU3lYhqREt6/kysVHrEgM1J1KiGbZ3KS5aW35sNpiWHpKWuzQkWCOEEELchsGosPLvFL7bGM/1ZL2pPMjTilc7udOqmr3pJiXXmMfyywfZFnuWHxr3R6VS8VWDXjhrbRl94Cf+Torkt6t/MyywGQAVbJ2LPKcQwty8efPo378/1ta3X4BSURSzPxyK+iPi1jq3mjBhAuPGjTO9T01Nxc/Pr4ytFkKIh1OeQeGdX6+x+nCaqcyozSDb729sLjWmib8Tn/Xxxc0h+LbHqqHz4v1aXXjCuwY+tk73sNWPFgnWCCGEEMVQFIWNx9P4ekMcF27KeFDBxZKXO7jTubYjanX+H3t5RgMrIv9h2qnNXM1MwlVry4KLEdR1rkA95/w/8MZXD6OHb206+9Qol/4I8bDasWMHp0+f5qeffjIr9/LyIjc3l6SkJLPRNbGxsTRr1sxUJyYmptAx4+Li8PT0LPacVlZWWFlZ3aUeCCHEwyMhPY+BMy9xOUFvVp4VsI8852vU8XLhhyeeQqMuPuB9MPEKM85s4/tGfbDWWPL8vw+pROlJsEYIIYQoQsS5DKavi+VYZLapzM1Bw6h27jzVyAlLTcENyp/XjzP1xAbOpcehs7ThrRodcbSw5u0jK2nuVpmfWgwDoKqjB1UdC0/HEEKUbO7cuTRo0IA6deqYlTdo0ABLS0s2bNhA7969gfwMUseOHWPq1KkAhIaGkpKSwr59+2jcuDEAe/fuJSUlxRTQEUIIkS/iXDqjFkaaJU64wSM6lOBK5/muRddiAzWKojD/QgQfHPsTC7WGY8nXaegqGS7vhARrhBBCiJscuZrFV+tiiThfkO3A0UbNsFauDGjugrVl4bVltsSc4XpWMs9VasKbwR3QaW3IMuj5M+o4/QMa3Xa6hRCPq/T0dM6dO2d6f/HiRQ4fPoyLiwsVK1YE8qcf/fLLL3zxxReF9tfpdAwbNozXXnsNV1dXXFxcGD9+PLVq1TJlhwoODqZTp04MHz6cWbNmAfmpu7t27SqZoIQQ4l+KovDV+ljmbE0sKNPkkuNxBquomtSuYMO0flXwca5X7DEy83J5/fAK/og8QoCdK3Ma9yNY51VsfVEyCdYIIYQQwLmYHL7ZEMfG4wVzs20sVQxo7sKw1q44WBekotwVd4GFFyP4pkFvrDQWvFS1NfsTLvNH5BEm1MjPSmOjsWR586H3vR9CPEwOHDhA27ZtTe9vrBEzaNAgFixYAMDy5ctRFIW+ffsWeYzp06djYWFB7969ycrKon379ixYsACNpuB3dunSpbz88sumrFHdu3dnxowZ96hXQgjxcMnKNfL83MscvlIwmlhBIaPqVgyOsTT0t2dRl05oLYp/8BSZmcSgPYs4nRZLuHcw0+s/g6Pl7dcYE8V7YFJPTJkyBZVKxdixY01liqLw/vvv4+Pjg42NDW3atOH48eNm++Xk5PDSSy/h5uaGnZ0d3bt3JzIy0qxOUlISAwcORKfTodPpGDhwIMnJyfehV0IIIR5015JyefuX6/T86oIpUGOpUdG3qRNrX6/C2HAPU6DmYOIV+uyax7O75rLu+gkOJF4BoKKdC5XsXfGwtudaVkq59UWIh02bNm1QFKXQ60agBvJHwWRmZqLT6Yo8hrW1Nd988w0JCQlkZmayatWqQgsBu7i4sGTJElJTU0lNTWXJkiU4OTndw54JIcTD4Wx0Nu0+OWsWqAFQocIpuh7BNv58E96ixEANgLPWFo1Kzds1w/mhcX8J1NwFD8TImv379zN79mxq165tVj516lSmTZvGggULqFq1KpMnT6ZDhw6cPn0aBwcHAMaOHcuqVatYvnw5rq6uvPbaa3Tt2pWDBw+anqj069ePyMhI1q5dC+R/6Q8cOJBVq1bd344KIYR4YMSn5TF7Szw/7Usi798s3GoVdKnryMsdPPBxtjTVPZESxdQTG9gYcxo1Klq5BxKTnYaNpqDOtPpP42hpjUZScAshhBDiIfDz3kQ+/CMG47/L0ygqA3mO0Vim+FLF04ov+zchwK1lsVO59UYD22PP0t6rOnYWVqxuMxKt+oEIMTwSyv1Kpqen079/f+bMmcPkyZNN5Yqi8OWXX/LOO+/w1FNPAbBw4UI8PT358ccfeeGFF0hJSWHu3LksXrzYNC95yZIl+Pn5sXHjRsLDwzl58iRr164lIiKCJk2aADBnzhxCQ0M5ffq0zFUWQojHTFq2gfnbE1i0K5Gs3ILF89oG2zM23IMqnoWzv2yIPsXGmNN09QnhteD2bIw+zUfH17L00j7qu+Q/wXfW2t63PgghhBBC3CmDUWH8skjWH0s3lSkoZFTfjMExhrb6Lszq0RRbbfEPoGKz0xi5fzl7Ey6xvPlQWrgHSqDmLiv3x3+jR4+mS5cupmDLDRcvXiQ6Oto0txjyUyi2bt2a3bt3A3Dw4EH0er1ZHR8fH0JCQkx19uzZg06nMwVqAJo2bYpOpzPVEUII8ejL1huZtz2B8KnnmbUlwRSoaVzZluWjApjxnJ8pUBOdlcq7R1aTkJMBQF2nCvxfzU7MbNyXIAcPBldqwvT6T/Np3SfLqztCCCGEEGWWkK4n/LNzZoEayJ/2ZJMUgIeFC//XMbDEQM3e+Et02jKDvQmXGFI5lMaS7emeKNfQ1/Llyzl06BD79+8vtC06OhoAT09Ps3JPT08uX75sqqPVanF2di5U58b+0dHReHgUTpPq4eFhqlOUnJwccnJyTO9TU1NL2SshhBAPEr1BYcWBZL7fHE9sap6pvIavNa918qBpFTtTWUpuFt+d3c7cC3vINuipaOtMK48q9N+zABetLQMrNcbOwgobCy29KtYvj+4IIYQQQtyRHafTeGnxNfSG/AdWCgpGqzQ0OY74uVgy7ZkOVPLqbDbN+2aKovDD+d1MPr4WrVrDjIa9ebJCnfvZhcdKuQVrrl69yiuvvML69euxti5+8aFb58eVJv3prXWKqn+740yZMoVJkyaVeB4hhBAPLqNR4a8jqczYGMeVBL2pvJK7llc6uhNW08H0PZCVl8v8ixF8e2Y7KfosKtu78W7NToR5VUelUtHLrx41dN6yHo0QQgghHjqKovDFX7HM33FTWm6VkazAneh1UYRlP83XT1fF0UZTwlHgUkYiU06sI8DOhdmN+1HN0bPE+uK/KbdgzcGDB4mNjaVBgwamMoPBwPbt25kxYwanT58G8kfGeHt7m+rExsaaRtt4eXmRm5tLUlKS2eia2NhYmjVrZqoTExNT6PxxcXGFRu3cbMKECab0kZA/subWzAJCCCEePIqisON0Bl+uj+V0VMEISS+dBS91cKdbPR0atXmwfm3UST4+vg4/W2dq6rzZE38RTxtHUzBneoNn7msfhBBCCCHuhmy9kcGzL3M08pZsT4oatUGLnaUFo9o4lBio0RsNWKo1VLJ3ZUHT56jnXAEHyfZ0z5XbI8L27dtz9OhRDh8+bHo1bNiQ/v37c/jwYSpXroyXlxcbNmww7ZObm8u2bdtMgZgGDRpgaWlpVicqKopjx46Z6oSGhpKSksK+fftMdfbu3UtKSoqpTlGsrKxwdHQ0ewkhhHiw/XMli8FzrjBy4VVToMbZTsNbXT34a3wgTzZwQqNWYVSMrIw8wrm0OAC6V6jF9PpPsy1sLC3dA7Gz0HIhPb48uyKEEEII8Z+cjc6izcdnzQI1ijp/SrirvYbF7Z9ma8eXaOwWUOwxVkYeoc2mL4nOyl8WpJVHFQnU3CflNrLGwcGBkJAQszI7OztcXV1N5WPHjuXjjz8mKCiIoKAgPv74Y2xtbenXrx8AOp2OYcOG8dprr+Hq6oqLiwvjx4+nVq1apgWLg4OD6dSpE8OHD2fWrFlAfururl27SiYoIYR4RFyIzeGr9XFsPJ5mKrOzUjOkpQvPtXDFzir/2YSiKGyLPccnJ9ZxLCWKjl7VcbOyp6bOm0GVmwIwLLAZAyo1luxOQgghhHho/bIvkQ9+vyktN0ay/Q6T5xxJs9SefN23Eh6ORa9NA/mjaSYfW8vcC7vxsLInJjsVLxsZwHA/PdC5td544w2ysrIYNWoUSUlJNGnShPXr1+Pg4GCqM336dCwsLOjduzdZWVm0b9+eBQsWoNEUDONaunQpL7/8silrVPfu3ZkxY8Z9748QQoi7KyZFz3eb4vnfgWTTzYhWo6JPU2deaOuKk13B19yhxKtMObGOPfEXsVJbMCKwOU3dKjF07xIq2DgxoFJjNCo1thZabNGWU4+EEEIIIe6cwajw+rJrrDuWZr5BpWBwiEVlk8HIduoSAzXRWamM3L+c/YmXaezqz/eN+uBpLYGa+02lKIpS3o14GKSmpqLT6UhJSZEpUUIIUc5SswzM257A4l2JZOvzv8ZUQNd6jrzc0QMfJ/MbkNOpMbTf/DUqoJFLAN807IWvrRMAc8/v5gmfmnjb6O5vJ4R4yD1u90aPW3+FEA+fhHQ9fb+9zLXkgsQKCkp+Wm5LFWO721OvipqaTj7FHuNqRhLdt88kLiedEYHNmVAzHEt1yQsPi9Ip6/fIAz2yRgghhLhZjt7IsogkZm9JICXLYCpvWc2O1zp5EORVMIf6WmYyKfosaui8qeboyfjq7VlwcS/7Ei+RnJtpCtYMCyx+/TIhhBBCiIfBnrPpjFoUSW5eQVruXI+z5DlGUyO5PV8P8KOKp9Vtj+Nrq6OFeyDh3sF09a11r5stSlCmYM3p06dZtmwZO3bs4NKlS2RmZuLu7k69evUIDw/n6aefxsrq9j8AQgghRFkYjAqr/k7hmw1xRKfkmcpr+VnzemdPGlQqWF8mKTeTr09vZeHFCILs3fmj9QtYa7SMrd4OlUrFubQ4HC1tyqMbQgghhBB33ZdrY5izLdG8UKMnx/coimUWb3RWlRioSdVns/jiPkYGtUCtUvNNw973uMWiNEoVrPn7779544032LFjB82aNaNx48Y8+eST2NjYkJiYyLFjx3jnnXd46aWXeOONNxg7dqwEbYQQQvxniqKw/XQ609fGcTamIA13gJuWcZ08aFfD3pReOysvl7kX9vDtmW2k5eVQ0daZa1kpLL98iMH/Lh78ctU2pvpCCCGEEA+zHL2RoT9c5vCV7ELbNEYtQ1170LKGJW28A4s9xqnUGIbvXcrFjAQq2bvyhE/Ne9lkUQalCtY8+eSTjB8/np9++gkXF5di6+3Zs4fp06fzxRdf8Pbbb9+1RgohhHj8/HMli2lrYzlwMdNU5u6gYXSYOz0bOGGhKQi6ZBv0tNv8NVczk/C3deGTuk/irLWh3+4F7E+8bArWSKBGCCGEEI+CC7HZDJh5mZQso6kszzEKg20S3mm1+KyvL00D7Uo8xv+uHubNw7+jNxqYVKsLnb1r3OtmizIoVbDm7NmzaLW3z4wRGhpKaGgoubm5/7lhQgghHk9FpeG2t1IzrLUrA5u7YKMtSMMdk52Gl40jVmoL6jr5UtnejflNB6BV53+9rWr9InWdKpRLP4QQQggh7oX/HUhi4v+iTZkwAYwW2WRU3QoaA5MaNKCpX/GBmlxjHpOO/snCi3vxtHZgZqO+NHL1v/cNF2VSqmCNVqvl2LFjhISElFjvk08+4a233ipVYEcIIYS4WWyqnm83xrPiYDKGfx8SaS1U9G3qzIg2hdNwf3R8LZczEtkR9irZxjw2x54hM0/PhfQEqjt6AlDP2a88uiKEEEIIcdcZjQpv/nydP/9JLbRNnWdNK00rWtawpm2FkgMvKbnZ/HX9OKFulfiuYR/cre3vVZPFf1DqBYbDw8PZtWsXAQEBRW7/9NNPmThxIm+99dbdapsQQojHQJFpuFXQra6Olzq6m6XhvpiewKcn1rP6+jFUwLMV65NjNOCsteWtGh2x01hRxd6tnHoihBBCCHFvJGXo6ffdZa4kFqTlNlinYtRm4JDlw8QnveleP7jEY8Rmp+Fh7YC7tT2/tRyBn60TFpKW+4FV6mBNy5Yt6dChA7t27cLDw8Ns22effca7777L0qVL73oDhRBCPJqKS8Pdqpodr3byoOpNabgBPj2xnu/P7iBPMVLZzpULGQnUdfHDSZuf2WlI5dD72n4hhBBCiPth7/kMRi64Sk5ewbwnozaD9Jp/oVbB9/VH0L6Srtj9jYqRb89s56szW/m1xfPUda5AJXvX+9F08R+UOlizZMkSunXrRseOHdm2bRs6Xf4Pw43FhBcvXkyvXr3uWUOFEEI8GgxGhdWH89NwRyWbp+Ee39mThjel4TYqRtSq/DVq7DRW1Hby5f9COpGZp2fk/mUYjMZCxxdCCCGEeFR8vSGWWZsTCpWrc+3wN1ShUaAtzSu6F7t/Sm4WYw/9yoboU1Rz9MTR0rrYuuLBolIURbl9tXxZWVl06NABlUrFhg0bmDlzJq+//joLFy6kX79+97Kd5S41NRWdTkdKSgqOjo7l3RwhhHjolJSG+9VO7rSv4WDK1pRnNLD88kFmntvJ/CYDWHp5Pxl5OUyt2xOVSoWiKKTl5cgNhxDl6HG7N3rc+iuEKF+5eUaen3uFg5eyTGWKJgejRS4WuQ681MGdoa2csdQUP43pREo0w/ct5XJGIj0r1OHTuk9iayHry5aXsn6PlHpkDYCNjQ1r1qyhdevWNGjQgDNnzjB//vxHPlAjhBDivzlxLYupa2LZb5aG24IxHdx4sn5BGm5FUVgXdZIpJ9ZxPj0edyt7zqXHsfTSfgyKkTeCO+JubY9KpZJAjRBCCCEeSZfjcug/8zJJmQXTxI3adDKCN6JGzZw6z9MhuORpTDHZqTy5fRZ6o4HJtbsxqFIT00Mx8XAodbBm5cqVpn+PHDmSV155hZ49e+Lo6Gi2rXv37ne3hUIIIR5acWl5fL0+lhUHU7gxjtPeWs3zrV0Z0KwgDTfA4aRI3j+6hgOJV9CqNIyt1oaRQa2ws7BiumKkps5HshUIIYQQ4pG26lAy7/waheGW+S8qvQ12KluCPGyoX/n2D6w8rR0ZV70djVz9aeBS8R61VtxLpQ7WPPnkk4XKfv31V3799VfTe5VKhcFgKFRPCCHE4yVHb2Tx7kRmb0kgIyd/XRkLNfQLdeaFtm5mabhvuJyRyN9JkfjZOnE1MxlfG2fsLKwA6Opb6762XwghhBDifjIaFd7+9Tqr/i5Iy62ojKAyoDJa0quhKyPDh+FmY1NsBqfY7DSmntzApFpdsLOw4sWglver+eIeKHWwxiiLOAohhLgNRVHYeDyNz/+MJTKpILVk6+r2vPGEBwHuVqaypNxMvjy1hT7+DQh0cKObbwh1nH25kB7PtFObqeJQ/GJ5QgghhBCPiuQMPf1nXuZSfMG9k9Eim8yg7WiMWqbW7MMzjZxLPMbBxCuM2PcjMdlpNHWtxDMV693rZot7rExr1gghhBDFORWVzSerY9h/oWBdmkAPLW928aR51YLpSzmGPBZciODrM1tI0WezNuoELT0C+bzeUwTYueJv60Jbj6oyr1oIIYQQj7z9FzJ4ccFVsvW3znsyorJNw9XOipa1il9EWFEUFl/ax8Qja9Co1XzToDc9/erc41aL+6FUwZo9e/YQGhpaqgNmZGRw6dIlatas+Z8aJoQQ4uGQkJ7H1+vj+O1AsmldGp2NmjEd3Ond2Nls8eDV148x5fg6rmQmUcHGiTeCO/Lh8b/YGnOWjLwc7CysJEgjhBBCiMfCd5vi+HZjvFmZgoIKFa0quTOkxWCqu7jipLUpcv9sg563/1nJz1cO4W/rwpwm/amh87ofTRf3QamCNc899xwBAQEMHz6cJ554Anv7wgs8njhxgiVLljB//nymTp0qwRohhHjE5eYpLN2dyMzN8aTftC5Nn6bOjGzvjpOt+VOgYynXGbl/OVq1hrdqdOT5wGZYayyp4uBOPecKkkpSCCGEEI+F3DwjI+ZdNcuSqagMZPsfRKW3Zlz1drzYzg2N+vYPsE6nxtDOsypfN+hdbFBHPJxKFaw5ceIEs2bN4r333qN///5UrVoVHx8frK2tSUpK4tSpU2RkZPDUU0+xYcMGQkJC7nW7hRBClBNFUdhyMp3P/ozhSkLB3OqWVe14o4snlT0K1qW5lJFAqj6b2k6+1HLyxd/OhcsZiXhYOWCtsQSguXvl+94HIYQQQojycCU+Py13YoZ5Yh6jTQq57uewsbDk2ZZdSgzUnE+LI9DBHWuNJUuaDUZnaY1apS62vng4qRRFUW5frcChQ4fYsWMHly5dIisrCzc3N+rVq0fbtm1xcXG5V+0sd6mpqeh0OlJSUnB0dCzv5gghRLk4E53Np6tjiDhf8CSoknv+ujQtqxWMukzKzeTr01uZf34PAQ6ubG73MmqVmk3Rp/hf5D+8EdwBf7tH9ztDiMfB43Zv9Lj1Vwhx963+O5m3f43CUETunureVnQNT6G5ty9VHT2K3F9RFL49u52pJzbwVYNesjbNQ6as3yNlXmC4fv361K9f/44aJ4QQ4uGUmJ7HjI1x/LIvGeO/IX5HGzWj27vzbFNnLP9dlybXmMfCC3v58vQWUvRZaNUa/G1dTE972ntVp71X9fLqhhBCCCHEfacoCu/+FsWKgylm5bnu51DlWfFMpRDee9ILa8viR8ek6bMZe+hX1kWdpLqjJ3WdK9zrZotyJtmghBBCFCs3T2FZRCLfb4onLTv/MZBGDc82dmJ0mDtOdgVfI3qjgU5bvuVMWiw+NjrGVW/Hx8fXkZCbgd5owFJdfCYDIYQQQohHUUqmngEzr3AhLtesPM8+lqzKEVirtIzv1LzEQM2Z1FiG71vK+fR4evjW5rN6PWWtv8eABGuEEEIUoigK206l89mfsVyKL7i5aFbFjje7elLFs2BdmuTcLJy0NlxMT8BWY8kbwR0YXqU5NhpLQt0qUd3RU+ZRCyGEEOKxc+hSBiPmXyUrt/DKIxU0PoR4NuWJgEBcrOyKPUaWQc+zu+aSmJvJ+yFPMCywmWTOfExIsEYIIYSZczE5fLomht1nM0xl/m5a3uziQatq9qYbhCsZiXxyYj0R8RfZ1v5VRh5YzunUGIYENsPm38WDa+i8y6UPQgghhBDlafaWeL5eH8fNYZo8+zhUeVpaVPBh6rM+uNgH3fY4NhpLJtfuhouVHaFule5dg8UDR4I1QgghAEjOyOPbTfH8tDfJtPCdg7Wake3d6NvUBa1FfpAmTZ/NN2e2MefcTvSKkQ5e1ckw5PJ2jXAOJF6mo6xJI4QQQojHVG6ewuiFV9h9LtOsPM8hlozqG3HR6Pii8xh02uL/FE/MyeDtf1byds1wKtq50MVXsi0/jv5TsCY7Oxtra+u71RYhhBDlQG9Q+CkiiW83xZGalR+lUaugVyMnXurojvNN69KsuPoPHxz7k7icdCxUajp4VWd+04EAeNk40t6rWrn0QQghhBCivEUm5jBg5mXi0gyFtun07vja+dDVvyoOlsWvN3M0+RrP7/2Ra1nJ1Hb2ZVRQq3vZZPEAK3Owxmg08tFHHzFz5kxiYmI4c+YMlStX5t133yUgIIBhw4bdi3YKIYS4B3afTWfK6hguxBasS9Mk0Ja3unpS1atwMD4hJx0FhbdrhPPFqU3kGg0YFCMaWZNGCCGEEI+xDcdSGb/8Gnk3xWmMlpmojBZUdXPgqwEV8HGpVmLChV+v/M2bh39HQeHzej3p49/wPrRcPKjKHKyZPHkyCxcuZOrUqQwfPtxUXqtWLaZPny7BGiGEeAhcTczlszUxbDqRbiqr6GrJ60940ja4YF2aSxkJfHZiI73967Mx+jTv1OzIs/4NcLC0ppNPDSrZucoid0IIIYR4bCmKwuSV0SyPSDYrN9gmkFFtC94aT5Z0HYq9VfF/ehsUI5OO/sm8C3vwsnZkTpN+1HP2u8ctFw+6MgdrFi1axOzZs2nfvj0vvviiqbx27dqcOnXqrjZOCCHE3ZWZa2TO1ngW7EgkNy9/yTtbrZoX27kysLkLWov8ETJp+my+PrOVued3k2s0sDv+AnE56TRw8ePJCnUAqGzvVm79EEIIIYQob2lZeQyec4VTUTmFtlkYbLC30lDT0waNxljicdSoSMjJoIlrADMb9cXd2v5eNVk8RMocrLl27RpVqlQpVG40GtHr9XelUUIIIe4uRVH460gqX/wVS3RKnqm8ez1HxnXywN0xP3uTQTGy/PJBPj2xnsTcTGrqvHm/Vhcy8nI4nBRJB1k8WAghhBCCY5FZDPvhCuk5BYEYRWUARY2rnQWf961OBe9AvG0cURczXfxUagxV7N2wUGv4vP5TWKjUJU6TEo+XMgdratasyY4dO/D39zcr/+WXX6hXr95da5gQQoi741RUNh+vjObgpSxTWU1fa97p7kWdijZmdbfGnOXNw7+jQkVzt8r82HyIaT2aMAnUCCGEEEKwdHcin6yOwXhTXm6jZSaZQdvxVvz4uXsPvJ0sSzzGsksHeOfISkZUacFbNTpioym5vnj8lDlYM3HiRAYOHMi1a9cwGo3873//4/Tp0yxatIjVq1ffizYKIYS4A8kZeXy9IY5f9iWbbiac7TSM6+TBk/V1qNUF69IYjEYCHdxp51mVN4LDmH56C7YWWmQ1GiGEEEKIfAajwhvLr7H2aFqhbUZtJop9ItYOKpwcij9GrjGPiUfWsPjSPnxtnOjiU/Metlg8zMocrOnWrRs//fQTH3/8MSqVivfee4/69euzatUqOnTocC/aKIQQogzyDAq/7Evi6w0Fqbgt1NA31JlR7d1xtMkfXpuqz+br01v54dwu3Kzt2dtxPBq1hpertaWbb20q2buWZzeEEEIIIR4YyZl59P/+Mpficwtts9DAxA4heAZ4Ud/Fr9hRMjHZqbywbxkHEq/Qwj2Q7xo+i4uV3b1uunhIlSlYk5eXx0cffcTQoUPZtm3bvWqTEEKIO7T/QgYfr4rhTHTBQndNA22Z0M2LKp5WQP66NMsuHeCzkxtJyM1Aq9YQnZ3KmuvH6V6hNoAEaoQQQggh/nXkahbDfrhMZm7BvCdFZSS74kFc9T7M6d6Muv62gHOxx1AUheF7f+RQ0lVeqNKCCTU6YiHr04gSlClYY2FhwWeffcagQYPuVXuEEELcgahkPV/8FctfR1JNZT5OlrzV1ZN2NQpScWfl5dJt20xOpcXgYWXPtHpPo9NaczT5uqxJI4QQQghxi2V7EvloVQyKYl6ep7tGrtdp9NprVKvQ+rbHUalUTK7TjYvpCfT49+GYECUp8zSosLAwtm7dyuDBg+9Bc4QQQpRFjt7I/B2JzNkaT7Y+/y7C2lLF8NauDG7lirVl/uLARsWIWqXmWEoUV7OSqOPky88thmFnkT/aJty7Rrn1QQghhBDiQWM0Krz58zX+/Kfw+jQAg4NrYxVkQRffmsVOe8o26Jl4dA1PVqhDqFslajv5UtvJ9142WzxCyhys6dy5MxMmTODYsWM0aNAAOzvzOXbdu3e/a40TQghRNEVR2HwinalrYohM0pvKO9VyYPwTnqYMBFkGPTPP7mB91ElWtn4Rd2t79EYDNhot1pJ1QAghhBCikJRMPf2+v8yleL1Zea7LJWxyXZjcuTrd6+sAr2KPcT0rhRH7fuRwUiRZeXpC3Srd41aLR02ZgzUjR44EYNq0aYW2qVQqDAbDf2+VEEKIYp2LyeGT1THsOZdhKgvytOKd7p40qpwfQFcUhT+vH2fi0TVEZ6cSaOdGVFYKAXaurG49imBHT9PUKCGEEEIIke94ZCaD51wxW58GQO98laygnbhauxBep0GJx4iIv8iL+5cRn5PBmKqteT047F42WTyiyhysMRqN96IdQgghbiM1y8B3m+L5cU8ihn8/inU2al7q4E6vxs5YaPKDL6dSY5h4ZDW74i+g/jf59ivV21LRzgWAGrrinwIJIYQQQjyulkck8tHKGIxK4W0tXYNIdYmkb6X6WGmK/zN6/oU9TDr6J1q1BbMa9aWLb8g9bLF4lJU5WCOEEOL+MhoVVhxM4ct1sSRm5I9eVKugV2MnXu7gjpNdwUe5UTHy8+VD7I6/SB//BjRwrsjBpPz0kEIIIYQQorD89Wmu8+c/qWblBusU1Hobhrfw5uWO7qhVQ247Mjldn4OfrTM/NOlPNUfPe9ls8Ygrc7Dmgw8+KHH7e++9V+pjff/993z//fdcunQJgJo1a/Lee+/RuXNnAAYPHszChQvN9mnSpAkRERGm9zk5OYwfP55ly5aRlZVF+/bt+e6776hQoYKpTlJSEi+//DIrV64E8tfV+eabb3Bycip1W4UQojwcuZrF5D+iOX4t21TWIMCGt7t7Ud3bGshPxf3z5UMEObgz8ega6jn7sbr1i9Rxzv8c7BvQsFzaLoQQQgjxoEvL0tP3+8tcjDNfnybPMZrMqlup5eDPKx0Goy4hSHM9KwU7jRad1oYxVVszpHIo9pZW97rp4hFX5mDNihUrzN7r9XouXryIhYUFgYGBZQrWVKhQgU8++YQqVaoAsHDhQnr06MHff/9NzZo1AejUqRPz58837aPVas2OMXbsWFatWsXy5ctxdXXltddeo2vXrhw8eBCNJj9vfb9+/YiMjGTt2rUAjBgxgoEDB7Jq1aqydl8IIe6L5EwDX62L5Zf9yaZUkZ6OFrzexZNOtRxMT3X2JVzivSOrOZYSxXMBjTmREk2WQc97tTqXY+uFEEIIIR58J65lMWj25ULr0wD427gRa2NDPU83DIqCuphYzd74S7yw/0fqOFVgQdOBqFQqCdSIu6LMwZq///67UFlqaiqDBw+mZ8+eZTpWt27dzN5/9NFHfP/990RERJiCNVZWVnh5Fb2+QkpKCnPnzmXx4sWEheUv2rRkyRL8/PzYuHEj4eHhnDx5krVr1xIREUGTJk0AmDNnDqGhoZw+fZpq1aqVqc1CCHEvKYrC74dS+OKvWJL+nfJkqVExuKULI9q6YavNT8V9PSuFSUf/ZM31Y1igZlRQK16u2oZuFWrTwMUPrVpmuQohhBBCFOeniEQ+XBljeigGoKj1YLSgXbADU3r7/D979x1XdfU/cPx174XLBhkCoggqKg4Utzhwr8K9SsWZoxyZ2rKhlWX5rWyYK8u9MldaWu6Nmoojt6KIskT2uHDv/fz+4NctuhcTE3G8n48Hj7qfcz7nvj+A3Pt533PehzxVRdxsHCyerygKS68d4d1Tm9GqrehTvq5s3iAeqAfybt7Z2Zn333+fsLAwwsPD72sMg8HAmjVryMzMJCQkxHR89+7deHp6UqpUKVq0aMGHH36Ip6cnAMeOHSMvL4/27dub+vv4+FCzZk0OHjxIhw4dOHToEC4uLqZEDUDjxo1xcXHh4MGDhSZrdDodOp3O9DgtLc1iPyGEeFAuxuXwwcY4jl/LNh1rVMmed7t641/6r09oTibH0Gv/ArIN+dN13w7qyAuVmgLItpBCCCGEEHehKAqvr77Fz/+sT2OTTlaV3TQpFchXHTujVqsAy4kanUHP26c2sfL67/jZu/Fd4wEESn0a8YA9sI9eU1JSSE1NLfJ5p0+fJiQkhJycHBwdHVm/fj3Vq1cHoFOnTvTu3Rs/Pz+ioqJ45513aN26NceOHcPGxoa4uDi0Wi2urq4FxvTy8iIuLg6AuLg4U3Ln7zw9PU19LJk+fTrvvfdeka9HCCGKKlNnZM6ORJYc+GuXJw8nDW+GedPhb0uecgx52KitqOFShhaelano6MHJ5Bialw4oweiFEEIIIR4PGTkG+n4TxbXbeWZt9g655DhkkOlwCz0GtHe5Vf7gzBZWXv+dFp4BzKrfF1etfXGGLZ5SRU7WfPXVVwUeK4pCbGwsS5cupWPHjkUOoGrVqkRGRpKSksLatWsZNGgQe/bsoXr16vTt29fUr2bNmtSvXx8/Pz9+/vlnevToUeiYiqIUmIJmaTraP/v805tvvsmECRNMj9PS0vD19S3q5QkhRKEURWHbH+l8sjmeuFQ9ABo19AtxZUzb0jja5tfdupaZxJuRG4nOTKZzuSDeqN6eBY36o/z/vF2ZciuEEEIIcXfnbmUzcJ7l+jRVvG34ckBDbillCXYt96/LycdWbUFpW0fGVGmBRqUurpDFU67IyZqZM2cWeKxWqyldujSDBg3izTffLHIAWq3WVGC4fv36HD16lC+//JJ58+aZ9S1Tpgx+fn5cunQJAG9vb3Jzc0lOTi4wuyYhIYEmTZqY+sTHx5uNlZiYiJdX4VPVbGxssLGRwlBCiOJx/XYuH22KY//FTNOxWr52TOn+1y5P2YY8vrm4hzmX9qEz6lEBS6IOM6ZyCxytbSRJI4QQQghxD348eof31sdj/Ht9GpWB7AqHaeRche+7N8Veq6Y8hS8nX3HtKAD9/BvgZevMy1VbFXfY4ilX5GRNVFRUccRhoihKgVoxf5eUlMSNGzcoU6YMAPXq1cPa2ppt27bRp08fAGJjYzlz5gwzZswAICQkhNTUVI4cOULDhg0BOHz4MKmpqaaEjhBCPCy6PCPf7Uni2z1J5Orz3zGUstcwsZMn3eq6oFar8mfcxJ3njciNJOjSqerkybTaXYjLTqORu5/sMCCEEEIIcQ8URWHymlv8dMK8/qjR7SZ5pa8SZZeERhMCWJ4hk2vUM/X0zyyJOkJFRw96la8jGzmIh6LIv2VDhw7lyy+/xMnJqcDxzMxMxo4dy/fff3/PY02ePJlOnTrh6+tLeno6q1atYvfu3WzdupWMjAymTp1Kz549KVOmDNeuXWPy5Ml4eHiYdp1ycXFh2LBhTJw4EXd3d9zc3Jg0aRJBQUGm3aGqVatGx44dGT58uGm2zogRIwgLC5OdoIQQD9X+ixlM2xjHjTt/rZPuUd+FiR09KeVQ8M/x5JP5iZo+vnX5pE43rNWahx2uEEIIIcRjK0tn4PnZ17ickGvW5uqg4bPuzThmtKNTmRrYaCzfFifmZDDy6AqOJF2nqUdF5jR4ThI14qEp8gK7xYsXk52dbXY8OzubJUuWFGms+Ph4wsPDqVq1Km3atOHw4cNs3bqVdu3aodFoOH36NF27dqVKlSoMGjSIKlWqcOjQoQKJopkzZ9KtWzf69OlD06ZNsbe3Z9OmTWg0f93YLF++nKCgINq3b0/79u2pVasWS5cuLeqlCyHEfYlLzeOV5TGMXHjDlKip4m3D8lF+fNDTh1IOVmQb8lhx7aipntaogOaUsrajpVdlSdQIIYQQQhTB5bgcWk2/bJaoyXW/in/5bH4YXYFGlRx4qXIoFRzdLY4RmRxDp93fcCTpOsMrNWV5k8GFbuMtRHG457RgWloaiqKgKArp6enY2tqa2gwGA7/88ovFXZfu5rvvviu0zc7Ojl9//fVfx7C1teXrr7/m66+/LrSPm5sby5YtK1JsQgjxX+UZFJYfvMM322+TlZu/zZODjZoxbT3oF+KGlSZ/ydOvsed4LXI9d3KzcNXa08mnBsMqNaGPXz2crW3/5VmEEEIIIcSfNh5L4e21sQXq0wDkuUaTHXCQVHt33J1r/es48TlppORl82W93vT0DS6eYIW4i3ueWVOqVCnc3NxQqVRUqVIFV1dX05eHhwdDhw5l9OjRxRmrEEI8No5dy6LPrCj+90uCKVHTsZYTmydUZGAzd6w0Kq5lJjEoYgkvHFnOndwsNCo1NVzya3KpVCpJ1Aghnnh79+6lc+fO+Pj4oFKp2LBhg1mfc+fO0aVLF1xcXHBycqJx48ZER0eb2nU6HWPHjsXDwwMHBwe6dOlCTExMgTGSk5MJDw/HxcUFFxcXwsPDSUlJKearE0I8TIqiMGXdLSb/aJ6oUavgtcZ1aOlZmddrtCt02VOe0UBcdn59mw5lqnOo3SRJ1IgSc88za3bt2oWiKLRu3Zq1a9fi5uZmatNqtfj5+eHj41MsQQohxOPiToaez7cmsP5YqumYn4eWd7p6ExLw19TZH6NP8NqJ9eQqBnqUC6asvQvBruXwtXe1NKwQQjyRMjMzqV27NkOGDKFnz55m7VeuXKFZs2YMGzaM9957DxcXF86dO1dghvf48ePZtGkTq1atwt3dnYkTJxIWFsaxY8dMy+L79etHTEwMW7duBfLrF4aHh7Np06aHc6FCiGKlyzPQb851zscW3KjGYJtKKY0jn/f1p0llR4YpgwrdTTNJl8mooyu5rcvgp9BROFnbUtrW8WGEL4RFKkVRzDeav4vr16/j6+uLWv107SeflpaGi4sLqampODs7l3Q4QohHjNGo8OPvKczcmkBadv5MGhsrFSNauTM01B2tlTp/KSkK626c5J1Tm/CydeLj4G409ih8m0ghhHhUPej3RiqVivXr19OtWzfTseeeew5ra+tCaw2mpqZSunRpli5dSt++fQG4desWvr6+/PLLL3To0IFz585RvXp1IiIiaNSoEQARERGEhIRw/vz5e95wQt4LCvFoupaYw3Ozr5OeYyxwXO+UQE7gLhp5+LOy+UA0qsLvX8+k3GLY4eXczE5hcIXGTAl6RmoGigeuqK8jRc64+Pn5oVarycrK4vz585w6darAlxBCPG3Ox+bQf+413lsfZ0rUhFZ14KdXKjKqdWm0VmqiMpIYGLGEby8fBCBdr6ONd6AkaoQQohBGo5Gff/6ZKlWq0KFDBzw9PWnUqFGBpVLHjh0jLy+P9u3bm475+PhQs2ZNDh7M/3t76NAhXFxcTIkagMaNG+Pi4mLqI4R4PP1yMpUuM6PMEjUAbfzLUNrejgrOpTDeZX7CTzGn6LZvPom6dD6t051ptTtLokY8Eoq871hiYiJDhgxhy5YtFtsNBsN/DkoIIR4HOXlGZu+4zaJ9SRj+/z2Ct4sVkzt707q6IyqVihxDHjPObuf7qwfRK0bK2ZViREBTKjl5UMfVt2QvQAghHmEJCQlkZGTw8ccfM23aND755BO2bt1Kjx492LVrFy1atCAuLg6tVoura8ElpF5eXsTFxQEQFxdncRMMT09PUx9LdDodOt1fSyrS0tIe0JUJIR6EaRtjWRmRUuCYotKjQsMrHTwZFurOndwxuGntC1369MutP3jp99V42jjybaP+1HMr/xAiF+LeFDlZM378eJKTk4mIiKBVq1asX7+e+Ph4pk2bxmeffVYcMQohxCMn4nImU9fHmrbi1qhhUDM3XmxTGntt/qTFvQmXeSNyA9FZyaiAb+r3oWu52gCSqBFCiH9hNOZnwbt27corr7wCQHBwMAcPHmTu3Lm0aNGi0HMVRSlwc2bpRu2fff5p+vTpvPfee/cbvhCimOjyjAycf50zMTkFjhu1meRU3cuzvlV5oXl1ANz/Zavt1l5VGODfgJertqKMnUuxxSzE/Shysmbnzp1s3LiRBg0aoFar8fPzo127djg7OzN9+nSeffbZ4ohTCCEeCSlZBj79Jb5AAeGaZW15r2cZAsv8VfAyx5DHK8d/JC0vh/pu5Sln70qIR8WSCFkIIR5LHh4eWFlZUb169QLHq1Wrxv79+wHw9vYmNzeX5OTkArNrEhISaNKkialPfHy82fiJiYl4eXkV+vxvvvkmEyZMMD1OS0vD11cS7UKUpBtJOvp+c43UbPNlT2W9DFx1SOFC3lWyDXnYaawtjnE14zZbbp1ldJVQbDXWfBzcrZijFuL+FDlZk5mZaZpK6ubmRmJiIlWqVCEoKIjjx48/8ACFEOJRoCgKW06l8fHmeJIy8pd72mlVjGtXmv5N3NCoVRgUI9vjLrD55mm6lavN7PrPUdbeBR87F9R3KWonhBDCnFarpUGDBly4cKHA8YsXL+Ln5wdAvXr1sLa2Ztu2bfTp0weA2NhYzpw5w4wZMwAICQkhNTWVI0eO0LBhQwAOHz5MamqqKaFjiY2NDTY2NsVxaUKI+7D9TBoTVt40LT3/u7Y1nPiodxUi0zwIdi1XaKJmZ/wFxhz9gQy9jrbeVanqXHjCVoiSVuRkTdWqVblw4QL+/v4EBwczb948/P39mTt3LmXKlCmOGIUQokTdSsnjgw2x7L2QaTrWrIoDU7qVwcc1/83AyeQY3jy5kdMpsSgoXE5P5JeWL911ir0QQjztMjIyuHz5sulxVFQUkZGRuLm5Ub58eV599VX69u1LaGgorVq1YuvWrWzatIndu3cD4OLiwrBhw5g4cSLu7u64ubkxadIkgoKCaNu2LZA/E6djx44MHz6cefPmAflbd4eFhd3zTlBCiJI14+c4Fu9PLnBMwYjO7zidKwTwebtA1GoVTUtXsni+oijMubyP6X/8hrO1LcubDJZEjXjk3VfNmtjYWACmTJlChw4dWL58OVqtlkWLFj3o+IQQosQYjAorDiXz5W8JZOfm7yLg6qDhzTAvnqntjEqlIi0vh3dPbWbtjUg0KhUjA5qiVVsxuGJjSdQIIcS/+P3332nVqpXp8Z/LjgYNGsSiRYvo3r07c+fOZfr06YwbN46qVauydu1amjVrZjpn5syZWFlZ0adPH7Kzs2nTpg2LFi1Co/lrN5fly5czbtw4065RXbp0YdasWQ/pKoUQ9ytPb2Twt9eJjM4xa7MuHUea93n2GGPQGethp9ZaHCPbkMerJ9azIeYkVZ08+a7xAPwd3Is7dCH+M5Wi3GUfs3vw5xbe5cuXx8PD40HF9cgp6p7oQojH24XYHKasi+X034rXdanjzOvPelHKIT/PvS32PKOOrkRn1FO7VFk+q9uTQPmURgjxlHja3hs9bdcrREmLTdbR55vr3Mk03224QmktX4eXY9Odg7T1DqS6S+ErPC6lJ/Ds7jk0L12JL+v1xtFaljeKklHU15EizazJy8ujatWqbN682VTszd7enrp1695ftEII8YjJyTMyd+dtFu5NQv//a6LLuVoztUcZQgIK7ijw54u9rcaaCYGtJVEjhBBCCPEA7DmXzrhlMab3Yn/Kc7lFo3IezO5VBSdbDeNKt7I8AJClz8XeSktlJ082tRhFZafSUkNQPFaKlKyxtrZGp9PJ1H4hxBPp8JX87bijkwpux/1Sm9LYadXkGPKYfPInglx8GFIphBCPCuxvOwFrjQYPG8cSjl4IIYQQ4vH35a/xzN99x+y43jmO7MBdXLV3RaUJBDTmJ/+/5deO8tm57awLHYG/g7vUpxGPpSLXrBk7diyffPIJCxYswMqqyKcLIcQjJzXbwGe/xLP297+2467uY8v7PctQzSd/O+69CZd55fha4nPS+Flzhn7+DbDRWFHG3qWkwhZCCCGEeGLoDUZe+C6ao1HZZm32WjXTOtdhYWoUbb2q4mBluT5NntHA1NM/szjqML72ruQY9MUdthDFpsjZlsOHD7Njxw5+++03goKCcHAouCxg3bp1Dyw4IYQoToqi8OvpdD7aFGfajtvWWsXYdqUZ0MQNK42K27oMpp7+hQ0xJ7FVW+Fn78bz/vVRywxDIYQQQogHIiE9j95fR3E7vWB9GqNVDuVdbfimvz8BXja0UwYXupQpSZfJiCMrOJx0jSYeFZnb4DncbBws9hXicVDkZE2pUqXo2bNnccQihBAPTWxKHh9sjGPP+QzTsSYBDkzp7k05t/xPayKTb9B937fkGQ209arKtNqdKWtXSpaCCiGEEEI8IAcvZfDS4hvk/aOOsME2FUPNXbh6eVPBMxCg0ETNbV0Gz+6ew83sFIZWDOGdmp2wVhe+TEqIx0GRkzULFy4sjjiEEOKhMBgVVkUk88WviWTl5letc7XX8HqYF2HB+dtx5xr1aNVWLL/2O3lGAy08K7OwcbgkaYQQQghh8s47b/Pbb78RExPDjh07CQwMNLX16tWTmzdv4uiYX9Oud+8+jBgxwtS+aNEiFi78Ho1Gg1qtZvPmn7G1tcVoNPLuu++wc+dOVCoVw4ePYPDgwRafv1GjhixevITAwEBycnJ48cVR2Nra8tVXX2NtbV2s1/6gzN6ewDc7kiy2DWzkxQaVBpVKIVufd9ddnNy1DoR6BlDPzZfn/OoXV7hCPFT3VXRGr9eze/durly5Qr9+/XBycuLWrVs4Ozub/iAJIcSj5nK8jnfW3uLUjb+24+4c7MzrYV64OlihM+j5/PwONt08zdZWY3izenu8bZ15qXJzSdQIIYQQooBnnw3jxRdfonv3bhbb33//A9q1a2d2/Ndft7J+/To2bdqMs7Mzt2/fNiVX1q5dy8WLl9i3bz9paWl07NiBZs2aEhBQudA40tPTGTJkMJUqBTB9+nTU6kd/xyOjUWHEwmgOXc4qcFxBwU6r4qNeZekQ5Ex45nDK2DljZWGWjFExsib6BD19g7FSa/hfne4PK3whHooiJ2uuX79Ox44diY6ORqfT0a5dO5ycnJgxYwY5OTnMnTu3OOIUQoj7pjcofL83idk7bpNnUAAo62rNlG7eNK2Sn2DeGXeBF39fRaY+l8qOpUnMSaeSU2kmVmtTkqELIYQQ4hHVuHHj+zpvzpw5TJw4CWdnZwA8PDxMbT/99BPh4eFoNBpcXV3p3LkzGzduZOLESRbHSkpKYvz4lwkNDWXy5LfuK56H7U6mnl5fRRGfVrD4r6LSowo8QtvAMnQIqgaAr4OrxTEy8nS8fGwNv8adIzUvmxEBzYo9biEetiKnXV9++WXq169PcnIydnZ2puPdu3dnx44dDzQ4IYT4ry7G5dBvzjW+/C2RPIOCWpW/HfeG8RVpWsWR1Nxs3ojcwMCIJWTpc7HXWPNV/d5Ucipd0qELIYQQ4jE2bdoHtGnTmlGjRnL9+nXT8UuXLnHq1Em6du1Cp04d+e67Baa2W7duUq5cOdPjcuV8uXnzZqHPMXLkCFq0aPHYJGqOXM2gzceXzRI1ADWr5pFdKpott09wR5dZ6BjRmXfoum8ev8ado1u52oRXaFScIQtRYoo8s2b//v0cOHAArbbgdml+fn53/UMihBAPU55BYcHu28zddRv9/xesq1hay4e9fKhVPj/RHHE7iojbUSy7dpQQjwqMqdyC2q7lKKW1u8vIQgghhBB39+WXX1G2bFkURWHRooUMGjSQ3bv3APklJa5fv866detJS0ujV6+e+PtXoE2b/Nm8BZdeK3d9njZt2rJ582YGDhxE2bJli+tyHohvd9/mi18TLbYNDXVnfIfS7Iy3o6qzV6G7OB1MvMrIoytJyc3mzeodZKm6eKIVeWaN0WjEYDCYHY+JicHJyemBBCWEEP/F+dgcnp8dxazt+YkatQqGtXDjx7EVqFXejptZKcy/fIBe+xdwKT2RuQ2e54emw2jhVVkSNUIIIYT4z/5MnKhUKoYMGUp0dDR37twxtXXt2s201KlVq1ZERp4AwMenLDdu3DCNExMTc9ckzIsvvkj//v3p3bsXN2/GFOMV3T+jUeGlxdEWEzWK5zX6dc5gYidPNGoV7cpUo7yDm8Vx8owGXo/cQK5Rz/eN+jO6SqgkasQTrcjJmnbt2vHFF1+YHqtUKjIyMpgyZQrPPPPMg4xNCCGKJFevMHt7In1nRXHulg6ASp5aVrzoz4SOXlhZwYLLB2i140sibl/Fx86FOq7leNanhrzYCyGEEOKB0Ov1JCb+lZj4+eef8fDwwM0tPwnRrVt3du/eBUBOTg4RERFUr14DgLCwMJYtW4rBYCA5OZmffvqJLl263vX5XnppNAMHDqRXr17ExDxaCZvULD0d/neZPefNlzW5eqWSVmE/i5N+ISEnvdAxFCV/dpG1WsP8hv34KXQU7cpUK7aYhXhUFHkZ1MyZM2nVqhXVq1cnJyeHfv36cenSJTw8PFi5cmVxxCiEEP/q3K0c3vrxFhdi85M0GjUMC3XnxTYeaK3UbI89z6QT67idm0l5e1cGVmhMk9IV0Krva1M8IYQQQjzlJk9+k19//Y3ExASee64vDg4OHDhwkNzcXAYODCc3NxeVSo2bmxsLFy4ynTd8+HBef/11WrZsgUqlIiwsjE6dOgHQq1cvTp6MpHnz/IK5L774IpUrF74T1J9GjXoRlUpNz549WLPmR8qXL18s11wUJ6OzGPJtNDq9+VKuRpXs+ez5ysy9lkpVZy88bS2v0Lijy2TM7z8wukooTUtXopqLd3GHLcQjQ6X8maosguzsbFauXMnx48cxGo3UrVuX/v37Fyg4/KRJS0vDxcWF1NRUU+V2IUTJy9UrzN91m29330ZvzD8W4GXDR73LUKOsHXlGAzPObmPO5X0ANCtdiYWNBmBnpb3LqEIIIf7N0/be6Gm7XiH+iyX7k5jxc4JZxR2jNpMu9R348JlArDR3n9V8Pi2eoRFLic5KZlyVlrxW3XwbdCEeJ0V9Hbmvj5Tt7OwYOnQoQ4cOvZ/ThRDigTh7M5u3fozlYlz+bBorNbzQ0p2RrUqjtVKhKApWKjUnU25S0cGd6i5lmFGnuyRqhBBCCPHUUxSlwDLwfz6+3zHHL49h+x8ZZm0ah3SUWtvZb2NDmr48bhrLRYQBfos9x9hjP6Az6PkkuBv9/Rv8p7iEeBzdV7LmwoULfP3115w7dw6VSkVgYCBjxowhMDDwQccnhBBmcvVG5uy8zXd7kjD8/2yaqt42fNjbh2o+tsRlpzLm0A9UcHTnf3V6MLfBczhb22Kl1pRs4EIIIYQQjwiVSoUhIRpD3HU03v5oPH3/03hp2Qb6zIrixp08szZvFys+71+daddPUcraHluNdaHjzLq4h0/ObsNVa8fixgNp7FHhP8UlxOOqyMmaH3/8keeff5769esTEhICQEREBEFBQaxYsYLevXs/8CCFEOJPZ2LyZ9Ncjv9rNs3IVh680NIDrZWKHXEXeC1yPfE56Ry7c4NXAtvgY+dSwlELIYQQQpQcRVHIzs42PTZmpJK+/EPyzh4yHbOuHoJT/7dQO+a/b7Kzs7vnmTbnb2UxYF402bkFFz4pKNStYMOX/fxwd7RiUZlw7DTWqFWF73OjUamp6uzJwkbh+Dq4FuUyhXiiFLlmTcWKFRkwYADvv/9+geNTpkxh6dKlXL169YEG+KiQdcpClCxdnpHZO26zcN9fs2kCy+TPpgksY8vFtHi+vrCH9TdP4mhlQ/dytXmhUhMqOZUu2cCFEOIJ9bS9N3rarlc8WbKysqhcOaBI51y6dBl7e/t/7bfuaDJT1sdh/MddpaLW497gKL6l1SwJCb/rDOfY7FTsNFpKae1QFIUcox67u8y+EeJxVOw1a+Li4hg4cKDZ8QEDBvC///2vqMMJIcS/OhWdzVtrb3E1IRcAKw282MqDYS09sNao+Pz8Dmae34kCtPGqyvTaXfCxL1WiMQshhBBCPMkURWHKuljW/p5q1malgVc6uzE75TZn0/TcyEqhgqO7xXGO3Ylm+OHlVHMpw7KQQahUKknUCMF9JGtatmzJvn37CAgomJndv38/zZs3f2CBCSGELs/IrO23WbQvyfRpTXUfWz7sXYYq3ramfpWdPFGA5qUDWNQ4/D8XxxNCCCGEeFKdPHmq0BkzWVlZ1K5d61/HyM41MGDedc7f0pm1uTtq+KJ/Oer629M4bRBOVjaULeRDtB+jT/Ba5HrUKjXP+9WT93BC/E2RkzVdunTh9ddf59ixYzRu3BjIr1mzZs0a3nvvPX766acCfYUQ4n6cvpHN5DW3uJqYP5vGWqPipTYeDA11x4Ced09tprJTacIrNKJz2SACHD2o5lKmhKMWQgghhHi02dvb39PypsJcv63judnXSMs2mrWVrnST1vUV6vpXASDQ2cviGAbFyEd//Mq8y/vxsXPh+0YDqFnK575jEuJJVOSaNWp14cWgCgysUmEwGO4rqEeRrFMW4uHIMyjM33Wbebtum2rT1Chry0e9fQjwsuFqxm2e2T2bDL2OMrbOHGw/CWvZ5UkIIR66p+290dN2veLJ8veaNXerRfNv/badSWPiypum92h/1yxIzXbHFeiMera2HH3X5MvHZ39j1sU91Hcrz7cN+1Pa1vE+r0yIx0ex16wxGi38yxRCiAcgKlHHGz/c4kxMDpC/3nlM29IMae6OSq0w//J+ZpzbTo4hD1etPd806CuJGiGEEEKIYqYoCp9tjWfh3mSL7aPbeDCqtQebbvUk16j/11kyL1Rqgt5o5NVqbbHRFPmWVIingvzLEEKUOEVRWHEomc+3JpCTlz/Zr7KXDR/3zd/p6UDiFab/8SuRKTfxc3Dj49pdaexRQRI1QgghhBDFLFdvZPj30fwelW3WZm2fzaD2VrzUKH/3za7lCq93czDxKjeykunrVw8PG0fertmx2GIW4klwX8maI0eOsHv3bhISEsxm2nz++ecPJDAhxNMhPjWPt9fGcvBSJgAqFQxu5sa49qWx1qg4lxpH3wPfY6/RMtC/Ie/U7ISdlbaEoxZCCCGEePLFp+bS95vrJKbrzdpKuxpIqfEbsxNy6JBamup3qR24/NpR3jr5E45WNnTyqYGztW2hfYUQ+YqcrPnoo494++23qVq1Kl5eXgUqdkv1biFEUWw5lcb7G2JNBep8SlnxUW8fGlR04GJaAm+c3MC0Wl0Y4N+AQGdvBlZoiFp1b3WzhBBCCCHE/TtyOYNXfrhDrsG8xGmwnx1f9i/H7GvRXMm4ja+9q8Ux9EYD75/ZwvdXD1He3pWFjcMlUSPEPSpysubLL7/k+++/Z/DgwcUQjhDiaZCabWDaxjh+OZlmOta1rguTO3uRbsyg3c6vuZSegFFROJJ0jY+Du5VcsEIIIYQQT5CsrKx7antpSQwqa7sC7QoKneppmd6tPForNW/9/1ImjYUP01Jzs3np99XsSbhEI3d/vm3YDzcbhwd0FUI8+Yr8EbVaraZp06YP5MnnzJlDrVq1cHZ2xtnZmZCQELZs2WJqVxSFqVOn4uPjg52dHS1btuSPP/4oMIZOp2Ps2LF4eHjg4OBAly5diImJKdAnOTmZ8PBwXFxccHFxITw8nJSUlAdyDUKIojl0OZPuX1w1JWpc7TV8OaAsH/X24VZuEl32zeVcWhxWag3rQ0cwuGLjEo5YCCGEEOLJUbt2LSpXDrD4Vbt24TVnVGoDFUKPcch5AxmGbDJWf0rq291IfqkR+puXC/RN+XwkmVN78tKGJfz6eySLdLYFEjXZe9aQ/F5vkt/vS/K051HydABkbp5P0qvtSf6wH8kf9iP9+7cLjefOW11Mz6vk6UibM5G0BZNRDOZLtoR4HBV5Zs0rr7zCN998wxdffPGfn7xcuXJ8/PHHBATkbw+3ePFiunbtyokTJ6hRowYzZszg888/Z9GiRVSpUoVp06bRrl07Lly4gJOTEwDjx49n06ZNrFq1Cnd3dyZOnEhYWBjHjh1Do8kvPtqvXz9iYmLYunUrACNGjCA8PJxNmzb952sQQtyb7FwjM7cmsPzQX7sItKjqwHs9fXB1UHErO5VOu78h16indqlyzG34XKFTaoUQQgghxMPjaKPm4+d8mHP7MNFpOm5kJVO9bmvs2oeT+unwAn3zjAYAPJ5/k9u+Fanu4lOgXIbu5B50R7bi8tpC1HaOGNPuwN92hLJt/AwOPcffc2zG7AzS5kzEytsfh+deR6WWJfPiyVDkZM2kSZN49tlnqVSpEtWrV8fa2rpA+7p16+55rM6dOxd4/OGHHzJnzhwiIiKoXr06X3zxBW+99RY9evQA8pM5Xl5erFixgpEjR5Kamsp3333H0qVLadu2LQDLli3D19eX7du306FDB86dO8fWrVuJiIigUaNGAHz77beEhIRw4cIFqlatWtRvgRCiiM7EZPPmD7e4mpgLgJ1WxevPetGzvgtLrx1hfsQBNrd4kfFVW9GkdEXquZUv4YiFEEIIIZ4cdnZ2XLp0udD2q4k59J99jTzD3w5a5deW8XPXMmtgOSp62hCc+zypedn4O7iDazmzcRZfjWBJ1GFWK/n1CGuVKmvWJ3vbUuzDRqC2cwRA7ex239dlzEghffF7aKs1xKH72PseR4hHUZGTNWPHjmXXrl20atUKd3f3B1ZU2GAwsGbNGjIzMwkJCSEqKoq4uDjat29v6mNjY0OLFi04ePAgI0eO5NixY+Tl5RXo4+PjQ82aNTl48CAdOnTg0KFDuLi4mBI1AI0bN8bFxYWDBw9KskaIYqQ3KMzffZt5O2+j//+N44LL2zG9jw8+rhpmX9rHN5f2kK7X8WvsWcZWbVmi8QohhBBCPIlUKhX29vYW2zafSOX1H+JBbcc/S89UrnYHjyrRlPfwB8BVa4+r1nwcvWJkysmfWBx1GD8HN/RGA5nrviJzwzdoylTAoetoNKXzkzuG2Cj00efI2jwf9HnYNHoGu9bPmcbSHf2N3HNHUDu4YPfMMLRV6xd6XenfvoFts244dBtTxO+IEI++IidrlixZwtq1a3n22WcfSACnT58mJCSEnJwcHB0dWb9+PdWrV+fgwYMAeHl5Fejv5eXF9evXAYiLi0Or1eLq6mrWJy4uztTH09PT7Hk9PT1NfSzR6XTodDrT47S0tEL7CiHMXUvU8eaaW5y6kQOAlRpGty3N0FA3IlNieGnfz0Qmx+Bv7857tcLoU75uCUcshBBCCPF0mbYxlpURKRbb6le04aL3IX6PS+bnWzXoWs5yPRsjCm+e3MiavBSaeFRkXsPnca6XhsbNG0VRyNmzhrTZE3Cd8sP/n2DAkBiDy8T5KNkZpH4+Eo2nL9qaTbFr3gP7TkNRaazIu3KStLmvUuqNxWjcLW8Lrq3ZDN3xHdiG9kLj5v0gviVCPDKKnKxxc3OjUqVKDyyAqlWrEhkZSUpKCmvXrmXQoEHs2bPH1P7PmTuKovzrbJ5/9rHU/9/GmT59Ou+99969XoYQ4v8pisLqwyl8+ks82Xn5Wz1W8tTySd+yuLrqaLnzC65nJgHwYuXmTAxsg63G+m5DCiGEEEKIB8hoVOg35xqnY3IstvcLKcVbXcpwNnUAB29fpUvZIIv9bmWlkJKTzvE7NwgPasP7tcKwVmvALX/2jUqlwq5lHzLXfokxIwW1YynUrl7Y1O+ASq1B5eCCtkYT8q79gbZmU9QuHqaxrSvVxsq3Kvrr5wpN1ti1G4Dmj4qkzhyFyytzJWEjnihFrr40depUpkyZctct34pCq9USEBBA/fr1mT59OrVr1+bLL7/E2zv/H9o/Z78kJCSYZtt4e3uTm5tLcnLyXfvEx8ebPW9iYqLZrJ2/e/PNN0lNTTV93bhx4z9dpxBPg4S0PEYtusEHG+NMiZqBTV1ZM6YC1XxsWR9zimuZSWhUauY2eJ63anSURI0QQgghxEOUmqWn+YcXLSZqVJpcuna6w1td8pMj1V28eaFSk0I/5Ha3cUSjUjG2Sgs+qt0Fa7UGxaDHmJZk6qM7vhO1sxtqx1IA2DToSN7ZQ0D+Lk55l45jVa4yAIbkv+7bDAnR6GMuYlX27hMF7NsPxDa0J6mfj8SQFHvv3wghHnFFnlnz1VdfceXKFby8vPD39zcrMHz8+PH/FJCiKOh0OipUqIC3tzfbtm2jTp06AOTm5rJnzx4++eQTAOrVq4e1tTXbtm2jT58+AMTGxnLmzBlmzJgBQEhICKmpqRw5coSGDRsCcPjwYVJTU2nSpEmhcdjY2GBjY/OfrkWIp8nOs+m8szaWlKz8ynTeLlZ81NsHH28d6YYsbKwdGVKxMQk56bxYuTmetk4lHLEQQgghxNPl3K0cnvsmylRL8O9stVCq2X6W3LlFwxhHupWrbXEMRVGISLpG0LYfyD21F/fsbFqtm0/yz8twe3896PNI++YVFH0uqNSoHV1wfvEz0/l2bZ4nY8V0kt/rAyrQ1m2LTXArALI2zkEffQ40GlBpcHzuNTRefv96XfbtwlGp1KR+PhKXV+ag8TAvbCzE40alKIpSlBP+bWnQlClT7nmsyZMn06lTJ3x9fUlPT2fVqlV8/PHHbN26lXbt2vHJJ58wffp0Fi5cSOXKlfnoo4/YvXt3ga27X3zxRTZv3syiRYtwc3Nj0qRJJCUlFdi6u1OnTty6dYt58+YB+Vt3+/n5FWnr7rS0NFxcXEhNTcXZ2fmezxPicffPJYP/fJyTZ2TGz/GsPpxiOta5jjOTO3uzNfEkr55YR0UHD3a1Hf8QoxZCCFHcnrb3Rk/b9Yonz9ojyby73nLNznJu1vwwugK77/zB/Mv7+b7xALxszX/P84wG3j21maXXjvBF3V70Kl+nuMMW4olR1NeRIs+sKUoy5t/Ex8cTHh5ObGwsLi4u1KpVy5SoAXjttdfIzs7mpZdeIjk5mUaNGvHbb7+ZEjUAM2fOxMrKij59+pCdnU2bNm1YtGiRKVEDsHz5csaNG2faNapLly7MmjXrgV2HEE8ylUqFISEaQ9x1NN7+aDx9TW2X4nOYuOImVxLyt+R2slUzpXsZOgY5sfZGJO+e3IRBUTCioDfqsVIX+U+OEEIIIYT4jyb/cJONJyxvmNIwUMV34ZVQq1V0ta9FWNmaaP65LRSQnJvFqCMrOXD7Ks1KV6KNt+yqK0RxKvLMGoCUlBR+/PFHrly5wquvvoqbmxvHjx/Hy8uLsmWfzCln8mmKeBoZM1JJXzyFvDMHTMesazbFadB7qB1dWHHoDh/+lL+2uI6fHZ/08eFQxh9svXWWrXFnKW3jyFs1OtBLdnoSQognztP23uhpu17xZDAYjPT8OopL8blmbQoKtZpf4bjhOGubv0BQqcLv465m3GbQoSVEZSYxqEIjpgY9m19IWAhxz4p9Zs2pU6do27YtLi4uXLt2jeHDh+Pm5sb69eu5fv06S5Ysua/AhRCPBmPaHVROrqhUKrNEDUDemQOkL56Ky+iZdK3jzJe/JjKwmRsjW3nwauRa1tw4AUCYT00+qt0FNxuHkrgMIYQQQoin2p2MPDp9eoUMnfln81Zq+GJAOfbpr3H4qoFrmXcKTdbkGvU8f2AhsdmpfFArjCEVQ4o7dCEE95GsmTBhAoMHD2bGjBkFliN16tSJfv36PdDghBAPX8bKj3EeOQNDQrRZouZPeWf2Y0i4gYOnLyte8qesuxorjYruvsHsSbhM7/J1eKN6+0J3DhBCCCGEEMXneFQmg76NxmhhDYWznZpVL/rjV9qGUKUjvcrXobqL5a2xAbRqKz6q3QW1SkUrryrFGLUQ4u+KnKw5evSoqVDv35UtW9Zsm20hxONH5ZA/Jc8Qd/2u/Qzx19B4+nJRf4V+23/m/VrP0qFMdQ61n4SNRmrTCCGEEEKUhMX7bjPjl0SLbb6+WTgHReLoXA6wQaNSW0zUGBQjn53bQa/ydajo6CH1aYQoAeaVo/6Fra0taWnmxakuXLhA6dKlH0hQQoiS49DjZQA03nffJlHj5Q/AuhsnSNSlk56nA5BEjRBCCCFECRm//EahiZrOwc741D3HwaSrzL60t9AxMvJ0DI1YxlcXd/P1hd3FFKkQ4t8U+a6qa9euvP/++/zwww9A/k4x0dHRvPHGG/Ts2fOBByiEeLjU9k4oioLGszzWNZtaXAplXbMZGk9f0vNyOJl8k7XNh1PH1dfCaEIIIYQQorjp9UY6f3GV6KQ8szYV8GZnL/o3cSM5twffXTnIy1VbWRwnJiuZwRFLOZ8WT2/fOnwc3K14AxdCFKrIM2s+/fRTEhMT8fT0JDs7mxYtWhAQEICTkxMffvhhccQohHjIcg35C5ydBr2Hdc1mBdqsazbDafBUIH9ngIPtJ0qiRgghhBCihCSk5tH4/YsWEzXWVgr9et6hb2MXAFy19kyq1tbiTk7H7kQTtmcOF9ISeLN6Bz6v21NmTAtRgor8r8/Z2Zn9+/ezc+dOjh8/jtFopG7durRt27Y44hNCPGTHr2Xx7rpbTOvlQ3B5F1xGz8SQcCO/Ro2XPxrP/MRMlj6X2q7lSjhaIYQQQoin18GLmYxYFI1ioZBwaScNwe3+YHbM7+TZpDIl6Jm7jrUm+jiZ+ly+bdiPjj7ViyliIcS9UimKpX/ahVuyZAl9+/bFxsamwPHc3FxWrVrFwIEDH2iAj4qi7okuxONGb1CYv+s2c3bexqiAnbWKGc+VpWU1R9R/29Up16jHWqWRnZ6EEOIp97S9N3rarlc8+ubuTOTrbbctttXzt2PBsPJczkzgxaMr+bp+H2pZ2JrbqBgxKgpWag25Rj3XMu5QxdmzuEMX4qlU1NeRIidrNBoNsbGxeHoW/EeclJSEp6cnBoOhaBE/JuQFWjzJbiXn8foPNzl+LRsArUbFyx3duFXqOFcyElGr1Pjau9LfvwGVnKSQuBBCiKfvvdHTdr3i0fbSomj2XMi02NYzxIb3u1Q0PTYoRjQq8+oX2fpcxh9fi4eNAx/W7lJssQoh8hX1daTINWsURbH4iXpMTAwuLi5FHU4IUcJ+PZ1Gj6+umhI1FUprWTXan8tOh5l9eR+/xp3HqCiMqdJCEjVCCCGEECUoT2+k3SeXLCZq1CoY0Dmb1eql/Bh9wnTcUqImPieNXvsX8POtM9zWZaI3PpkfuAvxOLvnmjV16tRBpVKhUqlo06YNVlZ/nWowGIiKiqJjx47FEqQQ4sHT5Rn53y8JrIxINh3r1aAUb4R5cTYjhkVREWhUasZUbsGkam1k2ZMQQgghRAmKS8nl2c+vkpNnvjDCXqti6Ug/zhsvkpmQyx+psfSijsVxzqTcYnDEUuJy0ni5SksmVmuD2kJCRwhRsu45WdOtWzcAIiMj6dChA46OjqY2rVaLv7+/bN0txGPi+u1cJq6M4dwtHQBOtmomdnXigOEAOp6lrqsvoyuH8pxffSo4updwtEIIIYQQT7cDFzMYufAGlupXlHW1Zs0Yf1zsrQikNn4OboXu1Lkj7gKjjq7EoBj5sl5vevoGF2vcQoj7d8/JmilTpgDg7+9P3759sbW1LbaghBDFZ+upNN5dF0umzghAzXK2fP58WV44+S2nU29hr7Hmo+CuvFmjQwlHKoQQQgghZu9I4JvtSRbbGlfWYhN0lOu5dtSyzy8gXFiiBqCsfSk8bZ34sm4v6rv7FUu8QogHo8hbdw8aNKg44hBCFDNdnpFPfo5n9eEU07GBTd0Y0NKO10+t4HTqLRw0WsIrNCq5IIUQQgghhMmohdHsu2i5kPDwlu7YV7rI+2dOcz3zDptbvGhx2XquUc+V9NtUc/Em0NmLPW3GY6XWFHfoQoj/qMjJGiHE4+f67VwmrIjhfOxfy56Gd4Zt2T+zbM8tkvOy6VO+Lu8HheFobVPC0QohhBBCPN3y9AY6fXaV2BS9WZtGDf97riwdgpwxKB4k5GQwtFKIxURNcm4Www+v4FxaLFtajqa8g5skaoR4TEiyRogn3C8nU5m6Ps607CmonC3/6+dDl4jPSdRlYKexZm6D5wkrW7OEIxVCCCGEELHJOp79PAqd3rxCjYONmgnPG2jgn59w0ajUvF3T8iYvVzNuM+jQEqIykxhWsQll7UsVZ9hCiAdMkjVCPKFy8ox8sjmeH46kmI4NaubGKx09sdao+LRODz76YysLG4VT3tGt5AIVQgghhBAA7D6fxpjFNy0WEi7vbs3w3tmMP7Ga1fHl+aHZMKwLmSVz6HYUww8vJy0vh2m1OjO4YuPiDVwI8cBJskaIJ9C1RB0TVt7kwp/LnuxUhLVP5rTxCEuuVWZYpSa08a5KG++qJRypEEIIIYQA+PK3BObvslxIuGU1R74eUJZUfQ4Bl0sTVrZmoYma82nx9DuwEBuNFYtDBtLKq0pxhi2EKCZFTtZMmDDB4nGVSoWtrS0BAQF07doVNzf5pF6IkvBzZP6yp6zc/GVPtXxtGdNFS79jyzAoChfS4xng3xAbjeRqhRBCCCEeBS8suM6hK1mW21q7MLaNF2q1GletPVtajr7r+7iqTp68WLk5ncsGUc3Fu7hCFkIUsyLfrZ04cYLjx49jMBioWrUqiqJw6dIlNBoNgYGBzJ49m4kTJ7J//36qV69eHDELISzIyTPy8eZ41vxt2dOQ5m40bZDN+OMrMCgKdV19WRIySBI1QgghhBCPgNw8Ax0+vUpCmnkhYSs1vNvXhW+T1nH7dHmm1eqMSqWy+D4u25DHd1cOMjKgGdZqDa9Vb/cwwhdCFKMi37H9OWtm4cKFODs7A5CWlsawYcNo1qwZw4cPp1+/frzyyiv8+uuvDzxgIYS5qEQdE1bc5GJc/rInZzto1Po6121P89WBU2g1VswI7sbzfvUt7hQghBBCCCEerpgkHZ2/iCLXQiFhJ1s1q17yJ0t7h6joJBQgy5CLg5X5rp2JORkMPbyME8k3cNXa09+/wUOIXghR3FSKoliqX1WosmXLsm3bNrNZM3/88Qft27fn5s2bHD9+nPbt23P79u0HGmxJSktLw8XFhdTUVFOSSohHweYTqUzdEEt2bv4/5drl7ejfKY+RkYuw12gp7+DKnAbPUdnJs4QjFUII8SR52t4bPW3XK4rXrnPpjF0SY7GQcEVPLatHV8Beqwbg2J1oqjp54Whtnqg5nxbP4ENLiMlOYUyVFrxWrS1qlbqYoxdC3I+ivo4UeWZNamoqCQkJZsmaxMRE0tLSAChVqhS5ublFHVoIUQS6PCMfbYrnx6MppmNDQ90JDEqkvGMpXqvWlmalA6jtWhaNvGgLIYQQQjwS7lZIuH1NJxo0jWVLfDo9fYMBqOdW3mLfXfEXefHoKnQGPZ/V6UFfv3rFFbIQogQU+Q6ua9euDB06lPXr1xMTE8PNmzdZv349w4YNo1u3bgAcOXKEKlWk6rgQxeVWch7h866bEjUuDtCww1kuum9n5O8rePvUZsZWaUldN19J1AghhHhk7d27l86dO+Pj44NKpWLDhg0F2gcPHoxKpSrw1bhxwS2IdTodY8eOxcPDAwcHB7p06UJMTEyBPsnJyYSHh+Pi4oKLiwvh4eGkpKQU89UJYW74d9cLTdSM71Ca4WFWvBa5gddOrCc2O7XQcfKMBt45tRmNSs3yJoMlUSPEE6jIM2vmzZvHK6+8wnPPPYden18Iy8rKikGDBjFz5kwAAgMDWbBgwYONVAgBwP6LGby26hap2QYgf7enak0uMf/acUiBxu7+fF2/j9SmEUII8cjLzMykdu3aDBkyhJ49e1rs07FjRxYuXGh6rNVqC7SPHz+eTZs2sWrVKtzd3Zk4cSJhYWEcO3YMjSZ/a+N+/foRExPD1q1bARgxYgTh4eFs2rSpmK5MiILy9AY6fnqVuFTLhYS/Ci9Hi0AnACbX6EB5ezfK2LkUOp61WsPCxgNQo6KSU+lii1sIUXKKXLPmTxkZGVy9ehVFUahUqRKOjo4POrZHiqxTFiXNaFSYvzuJWdsT+fNf7fONXQkMjmPyqQ1kGfIYXKER79UKk9k0Qgghit2Dfm+kUqlYv369aaY25M+sSUlJMZtx86fU1FRKly7N0qVL6du3LwC3bt3C19eXX375hQ4dOnDu3DmqV69OREQEjRo1AiAiIoKQkBDOnz9P1apV7yk+eS8o7ldcio5nPotCV0gh4XkjPLF1yKWqs9ddx8nI0/Hy8TUMqtCYUM+A4gpXCFFMivo6ct93dI6OjtSqVYvatWs/8YkaIUpaWraBMUtj+HpbfqJGa5tHrTanGdnBkT/SbuFoZcPqpkOZVruLJGqEEEI8UXbv3o2npydVqlRh+PDhJCQkmNqOHTtGXl4e7du3Nx3z8fGhZs2aHDx4EIBDhw7h4uJiStQANG7cGBcXF1MfS3Q6HWlpaQW+hCiqAxfTaTvjqsVETYXSWla/4s3YPxbR7+BCbmWlFDrOrawUeuybz6+x5/gt9lwxRiyEeFQUeRlUZmYmH3/8MTt27CAhIQGj0Vig/erVqw8sOCEEnI/NYfyyGG7cyQPA180ar8Yn2JH0B1NPK8ys15PRVULxsJGkqRBCiCdLp06d6N27N35+fkRFRfHOO+/QunVrjh07ho2NDXFxcWi1WlxdXQuc5+XlRVxcHABxcXF4eprviOjp6WnqY8n06dN57733HuwFiafKvF2JfPWb5d1x21R34ov+PigqqOToQUpuNnZWWot9T6XcZEjEUuJz0nm9WjvGVGlRnGELIR4RRU7WvPDCC+zZs4fw8HDKlCkjdTGEKEY/HU/lvQ2x5OTlfxrTItCRZs0TmXLmIn4ObrxTsxNatZUkaoQQQjyR/lzaBFCzZk3q16+Pn58fP//8Mz169Cj0PEVRCrxHtfR+9Z99/unNN99kwoQJpsdpaWn4+voW9RLEU2rskmh2nsu02PZSG3dGtfEwbbH9Tf2+qFUqbDXWZn233jrLmGM/oCgKcxo8R+eyQcUatxDi0VHkZM2WLVv4+eefadq0aXHEI4QAcvUKn/wcz6qI5PwD1jqqNb6CrRe8duo4XrZOfFqnB952smZeCCHE06NMmTL4+flx6dIlALy9vcnNzSU5ObnA7JqEhASaNGli6hMfH282VmJiIl5ehdcIsbGxwcbG5gFfgXjS6Q1GOs+8SnRSnlmbRgWfPu9DlO1p+uzfyPImg7HVWGNfyIwagOuZd3C00vJdowGFbuEthHgyFbm4haurK25ubsURixACiEvNY/D866ZETSl7DV5NDxKRe5wfbhwntHQAv7YaQ4hHhRKOVAghhHi4kpKSuHHjBmXKlAGgXr16WFtbs23bNlOf2NhYzpw5Y0rWhISEkJqaypEjR0x9Dh8+TGpqqqmPEA9CYnoeIe9ftJiosdeqWDuuAk2r2bLs2hF+vxPN73eiLY6jNxrIyNMBMCKgKTtbvyyJGiGeQkWeWfPBBx/w7rvvsnjxYuzt7YsjJiGeWoevZPLqqpskZeRvy13dx5YvBpRlyAkDZMPYyi14tXpb07RZIYQQ4nGWkZHB5cuXTY+joqKIjIzEzc0NNzc3pk6dSs+ePSlTpgzXrl1j8uTJeHh40L17dwBcXFwYNmwYEydOxN3dHTc3NyZNmkRQUBBt27YFoFq1anTs2JHhw4czb948IH/r7rCwsHveCUqIf/P71QyGLLiB0cI+uz6lrFg7rgLOdvm3XkubDOJaxh2ala5k1jcjT8eLv68i16BnaZNBaNVWuNk4FHf4QohHUJGTNZ999hlXrlzBy8sLf39/rK0Lrq08fvz4AwtOiKeFoigs3HeHmVsTMCpgtNJRo04cy7u0R2ulZm7D50nISaexzKYRQgjxBPn9999p1aqV6fGfNWIGDRrEnDlzOH36NEuWLCElJYUyZcrQqlUrVq9ejZOTk+mcmTNnYmVlRZ8+fcjOzqZNmzYsWrQIjUZj6rN8+XLGjRtn2jWqS5cuzJo16yFdpXjSLd53mxm/JFpsa1jRng/7lWLVzQiGV2qKSqXC38Edfwd3s763slMZdGgJ59Li6Fu+HiqkNqgQTzOVoigW8r+F+7eq+FOmTPlPAT2qironuhD3KiPHwFs/xrL9j3QArK1A1ehnEvXJvFCxCVNrPVvCEQohhBDmnrb3Rk/b9Yp78+rKGH45lW6xrX+IK6939qTdzq+5mJ7AzLo96V2+rsW+Z1JuMShiCfE56bxRvT2jK4fKRi5CPGGK+jpS5Jk1T2oyRoiScDlex/jlMUQl5gJQppQVfZ/N5JOr+S/6LlrbkgxPCCGEEEJYYDAqdP/yKlcScs3aVCqY2t2bXg3yi16/VaMjS6MO06lMDYtjRdyOYuChJRgUI7Pr96VLuVrFGrsQ4vFQ5GSNEOLB2P5HGm/8cIvsXAWjlY7KldOoFZTBe5cP4K51YGH9cJp7BpR0mEIIIYQQ4m+SM/Po+L+rZOiMZm1aKxULXyiPu4fOdKyNd1Vae1UpdKZMFSdPAp29eKdmJxq4+xVb3EKIx8s9JWvc3Ny4ePEiHh4euLq63nVK3p07dx5YcEI8iYxGhbk7b/PNjtv5B9R5qOpv5YSSwfHrCvXcyjOnwXP42LmUbKBCCCGEEKKA09FZ9J93HYN5ngZ3Rw1rx1Vg6c29zNqxh+VNhph27/zn/ZNBMXL8zg0auPvhZuPAxtCRsuxJCFHAPSVrZs6caSrkNnPmTPlDIsR9ytQZmLzmr/o09lo1M/r6c4S6/Bp7jnpu5fmwdme0apn0JoQQQgjxKPnxSDJT1sdZbKtR1pZlI/3QWv+1Y2eSLsNi3yx9LmN//4Ftcef5sfkLNHT3l/srIYSZIhcYflpJUTnxX924k8vYJTFcitehqPMo7ZnDMy1zCK9SG08bR9QqlWzJLYQQ4rHxtL03etquVxQ0dd0t1hxNtdjWpY4z0/uUNT1WFIUrGbcJcCpt1jc+J40hEUs5lXKL7uVq82mdHtho5EM6IZ4GRX0dKfKdoUajISEhwex4UlJSgS0S78X06dNp0KABTk5OeHp60q1bNy5cuFCgz+DBg1GpVAW+GjduXKCPTqdj7NixeHh44ODgQJcuXYiJiSnQJzk5mfDwcFxcXHBxcSE8PJyUlJQixSvE/Yq4nEnfWde4FK/DaJ2Nvu4WYir8zNdRv/K/s9uwUmskUSOEEEII8YgxGBX6fnO10ETNpE6evNzZicGHlnArO7+PSqWymKg5nxZPlz3zOJVyi/FVW/FVvd6SqBFCFKrId4eFTcTR6XRotdoijbVnzx5Gjx5NREQE27ZtQ6/X0759ezIzMwv069ixI7GxsaavX375pUD7+PHjWb9+PatWrWL//v1kZGQQFhaGwWAw9enXrx+RkZFs3bqVrVu3EhkZSXh4eJHiFaKoFEVh6YE7jFgYTWp2/u9jWAMtijYbnVFP+zLVmFa7cwlHKYQQQggh/ik9W0/Ljy5xJkZn1malhnmDyzEk1J3Pz+9ge/wFPv7jt0LHSsnNpue+b0nISWdm3Z5MqtZWlj4JIe7qnlO5X331FZCfKV6wYAGOjo6mNoPBwN69ewkMDCzSk2/durXA44ULF+Lp6cmxY8cIDQ01HbexscHb29viGKmpqXz33XcsXbqUtm3bArBs2TJ8fX3Zvn07HTp04Ny5c2zdupWIiAgaNWoEwLfffktISAgXLlygatWqRYpbiHuhyzPy/sY4NhxLRVEZsLbR82zrDH5I3Y7eYGBqzWcZVilEXqiFEEIIIR4xVxNz6PFlFHkG8zZHGzWrRvtTobQNAFOCnsHRyoYJgW0KHa+U1o43a7SngoMHTUtXLK6whRBPkHtO1sycORPInykwd+7cAkuetFot/v7+zJ079z8Fk5qaP3XQzc2twPHdu3fj6elJqVKlaNGiBR9++CGenp4AHDt2jLy8PNq3b2/q7+PjQ82aNTl48CAdOnTg0KFDuLi4mBI1AI0bN8bFxYWDBw9aTNbodDp0ur+y6Glpaf/p2sTTJSEtj5eXxXDqRg5G62zyAvdSrrQNcVonXLX2zG3wHPXcypd0mEIIIYQQ4h/2nk/npcUxWFpPUM7Nmh/HVOB4+lV8DBWw0VjhYGXDu0HPmPU1KkbmXz5AX796uGrtGeDfsPiDF0I8Me45WRMVFQVAq1atWLduHa6urg80EEVRmDBhAs2aNaNmzZqm4506daJ37974+fkRFRXFO++8Q+vWrTl27Bg2NjbExcWh1WrN4vHy8iIuLr9ae1xcnCm583eenp6mPv80ffp03nvvvQd4heJpcSo6m3HLYkhM1wNQpayGRHcDOlUOb1TvibuNA+42DiUcpRBCCCGE+Kfv9tzm862JFttCAuyZP6Q8K6N/5/XIDXQrV5uv6/W2OEs625DHK8d+ZPOtM9zKTuX9WmHFHboQ4glT5IpWu3btKo44GDNmDKdOnWL//v0Fjvft29f0/zVr1qR+/fr4+fnx888/06NHj0LHUxSlwB9OS39E/9nn7958800mTJhgepyWloavr+89X494Om08nsLU9XHo9EZQKTStm81Rh210KVOT16q1x9HapqRDFEIIIYQQFrzxw002nbA8m35AE1fe7JxflqGJR0W8bJ1o4Rlg8V4iSZfJ0MPLOHYnmjCfmrxZo0Oxxi2EeDLdU7Lm70mLf/P5558XOYixY8fy008/sXfvXsqVK3fXvmXKlMHPz49Lly4B4O3tTW5uLsnJyQVm1yQkJNCkSRNTn/j4eLOxEhMT8fLysvg8NjY22NjIjbW4N3qDwmdbElhy4A6KJpfsKgcpW1phmyEWrd6Khu7+kqgRQgghhHgEKYrCc7OjLBYSVgFTu3vTpb6T6VgFR3f2tZ2AvZX55ipXM24Tfmgx1zPv8GLl5rxZvb3s+CmEuC/3lKw5ceLEPQ1W1EKpiqIwduxY1q9fz+7du6lQocK/npOUlMSNGzcoU6YMAPXq1cPa2ppt27bRp08fAGJjYzlz5gwzZswAICQkhNTUVI4cOULDhvlrRQ8fPkxqaqopoSPE/UrJMjBp5U0OXc7fxczeOYtM11tc0xvxtXdlYeNwAp0tJwWFEEIIIUTJyck10OF/V7idYV5J2FqjYsEwX/x9FHrs+5Ye5YIZWikEwGKiBuCjP37lRmYyH9fuyoAKUqNGCHH/7ilZU1xLn0aPHs2KFSvYuHEjTk5OpvoxLi4u2NnZkZGRwdSpU+nZsydlypTh2rVrTJ48GQ8PD7p3727qO2zYMCZOnIi7uztubm5MmjSJoKAg0+5Q1apVo2PHjgwfPpx58+YBMGLECMLCwmQnKPGfXEnQMXrxDW7cyQOgspcNdvUuEpdkpJlHJeY1fB4XrV0JRymEEEIIIf4pNiWXZz+7ik5vXkrYxU7NmrEVKOuqZXf8JU4l30Rn0DOgQgO06sJvof5XpzsDKzQi1DOgOEMXQjwFilyz5k+XL1/mypUrhIaGYmdnd9f6L4WZM2cOAC1btixwfOHChQwePBiNRsPp06dZsmQJKSkplClThlatWrF69WqcnP6aijhz5kysrKzo06cP2dnZtGnThkWLFhXYsWr58uWMGzfOtGtUly5dmDVr1n1evRBw4GIGE1feJC3HgK7cSWp6eLCiexvOpmuon1COVwJbybRXIYQQQohH0O9XMxmyIBqjhS2fKpbW8sNof+xs8u8lWnpVZkGj/jRy9zdL1CiKwrdXDmCt1jCkYgiuWntJ1AghHgiVoiiWdqUrVFJSEn369GHXrl2oVCouXbpExYoVGTZsGKVKleKzzz4rrlhLVFpaGi4uLqSmpuLs7FzS4YgStvzgHT75OR6DEfIc48mqsQ07jTVHO7xOKZlJI4QQ4inwtL03etqu90m2+vAd3t9gXs8SILSqA98M9OXXuLO4aR1o5OFf6DgGxciUUz+zKCqCQGcvfmn50l1n3Qghnm5FfR0p8sf+r7zyCtbW1kRHR2Nvb2863rdvX7Zu3VrU4YR4rOgNCh9sjOOjTfmJGmtrAzUbxgBQxclTEjVCCCGEEI+wDzbEFpqoGdLcjTmDy3Mi5QYjjqxk6OFl3NFlWuybpc9l+OHlLIqKoIlHRdY2Gy6JGiHEA1Xkvyi//fYbv/76q9muTZUrV+b69esPLDAhHjVp2QYmrrzJwUuZ5LlG42SrxqHqOY5kxtOhTDW+qNurpEMUQgghhBCFGDz/OkejssyOq1TwQQ9vutfP31m2rqsvfcrXJdi1LG42Dmb9E3LSGRKxlJMpN+npG8z/6nSXRI0Q4oEr8l+VzMzMAjNq/nT79m3Z6lo8saKTchm9+AZXE3PRO8eSVWUv2ahQshUmBrbh5aotpT6NEEIIIcQjSK830vHTK8Sm6s3atBoV373gSw1fG5J0mbjbOKBSqfi0TvdC63GeT4vnTGosL1dtxaTANkWu2ymEEPeiyHeXoaGhLFmyxPRYpVJhNBr53//+R6tWrR5ocEI8Cn6PyuL52de4mpgLQNuyAVRyKI21Ss23DfvxSmBrSdQIIYQQQjyCktLzaPzBRYuJmlL2arZMqkhAWQ0DDi2i38GFpOflAFhMwOiN+dt7h3oGsKvNy7xara0kaoQQxabIM2v+97//0bJlS37//Xdyc3N57bXX+OOPP7hz5w4HDhwojhiFKDHrf09h6oZYdNapYGXF4JAyvNbRB4Wx3MhOwd/BvaRDFEIIIYQQFpyKzqL/3OsWd3wK8NSyerQ/tloNGXk60vNyyMjTkZybhZO1rVn/9TdO8vXF3axp9gLuNg5UdPR4CFcghHiaFTlZU716dU6dOsWcOXPQaDRkZmbSo0cPRo8eTZkyZYojRiEeOoNRYebWBBbuu4PeMZHMwB3YWmm45F4RVP3QqDSSqBFCCCGEeEStP5bC2z/GWmxrXc2Rr8LLmWbFOFrbsCRkECpUlLZ1LNBXURRmXdzDJ+e24W3rbFoqJYQQxe2+KmF5e3vz3nvvPehYhHgkZOqMvL76JrvOZQDgaKMhR2MkR9HjrnXAqCioZcarEEIIIcQjacbPcSzen2yxbURLd17u4Mnh29fYdPM0H9QKQ6VS4WnrZNZXbzQw+eRPrLj+O9WcvVkcMhAfO5fiDl8IIYD7TNbk5ORw6tQpEhISMBqNBdq6dOnyQAIToiTcSsljzJIbnI/LApUK9/IJxJfdCwaFD2t1ZlDFxiUdohBCCCGEKMSI76M5cMl8u221Cqb39iGsjgs5hjxe+n0V8TnpNPaoQFjZmmb9M/U6Rh5Zye6ES4SWDmBew+ctLo8SQojiUuRkzdatWxk4cCC3b982a1OpVBgMhgcSmBAP26nobMYsvUGiLoOsantwsdFyTRtLKY0dixqH06R0xZIOUQghhBBCWKA3GOk88yrRSXlmbTZWKhYN96NWeTsAbDXWzG3wPHsTLvOsTw2L41mrNeQZDfQtX4+Pg7tirdYUa/xCCPFPRU7WjBkzht69e/Puu+/i5eVVHDEJ8dBtO5PG66tvodMrKHY61E6pONo7UdXOj8/q9qS8g1tJhyiEEEIIISxIzdTT/n9XyNAZzdrcHDSsHVcBDycNx+5EU8+tPAAN3P1o4O5n1j8uOw0vWye0aisWhQzEVm0lOz4JIUpEkZM1CQkJTJgwQRI14omx9MAdPvk5HkUBlXU2fUNt6Bw0hMpOnrho7Uo6PCGEEEIIUYiLsdn0mnUNg3mehqreNqx8yR+tlYoJx9ey9kYk3zbqR4cy1S2OdSDxCi8cXs4rga0ZEdAMO411MUcvhBCFUxf1hF69erF79+5iCEWIh8toVPhkczzTN8eR7XMKve8prBptY1naRnzsXCRRI4QQQgjxCNt2OpUeX1lO1LSr6cTacRWwsVajUqmo5VoWF60dHjaO5p2BdTciGXBwMQA1XGSHWyFEySvyzJpZs2bRu3dv9u3bR1BQENbWBTPO48aNe2DBCVFccvKMvPHDLbadScfgeBtduVPoAF2emk/qdMPHvlRJhyiEEEIIIQrxzfZEZu8wr6EJMKqVO2Pbe6IoiunYkIohdC1bC7d/bLutKArfXNrLx2d/o4ydC0saD6Sai3exxi6EEPeiyMmaFStW8Ouvv2JnZ8fu3bsLrOFUqVSSrBGPvORMPWOWxhB5PRuAUl6pZAEOGi0LQwYS4lGhZAMUQgghhBCFGr88hm1n0s2Oq1UwvY8PYcEuXElPZNyxNXxdvw8VHT0AzBI1AB/+8StzL+8j0NmLJSGDZGtuIcQjo8jLoN5++23ef/99UlNTuXbtGlFRUaavq1evFkeMQjww0Um59J9znWOJtzDYJxEQkMFNjwgqOHrwS6vRkqgR4j9SqVRkZGRYbNPr9bz//vsEBgZSo0YNAgMDGTFiBCkpKUB+TbQhQ4ZQsWJFgoKCCAoK4qOPPgJg0aJF9OrV655i2Lx5M4GBgQQEBNCzZ89C49mwYQNHjhwp+kWSP4vU398flUrFmTNnCrS1bNmSihUrEhwcTHBwMDNnzjS1XblyhTZt2hAcHExgYCATJ07EaLQwfx/IyMhg/PjxBAQEEBQURO3atRkwYABRUVFA/vekVKlSBAcHU7NmTTp16kR0dPR9XQ/A6tWrqVOnDjVr1iQoKIivv/7a1GY0Gpk0aRI1a9YkMDCQYcOGkZuba3Gcli1bsnnz5iK33Yv/ev7dTJkyhWrVqtGoUSOztu+//56goCCsrKyYNWtWgTaj0cjYsWOpVKkSAQEBzJ49u0D7tGnTqFSpEpUqVeKdd94p0Pbdd99RuXJlKlWqxIgRI9Dr9UWKeerUqYX+HIR4EhkMRrp9ccViosbGSsXyF/0IC85Ptnx39SAnU24y+9Leu44Z6hlAS8/KrGs+QhI1QohHSpGTNbm5ufTt2xe1usinClGiTt3Ipv+ca1zNSiCj+q/oa+5hVt/KzKzbk42hI02fugghisewYcM4evQohw4d4o8//uDs2bO0a9eOO3fukJ2dTYsWLfDz8+PSpUucPn2aiIgIHBzMPwW9m4yMDIYNG8aGDRu4fPkyZcqU4cMPP7TY978ka3r16sX+/fvx8zPfSQTgq6++IjIyksjISF555RXT8UmTJtG1a1dT22+//cbWrVvNzlcUhWeeeYbs7GxOnz7N6dOnOXHiBG3btuXSpUumfm3btiUyMpIzZ84QGBhY4LmKqly5cmzZsoUzZ86wf/9+vvzySw4cOADkJxVOnTrF8ePHOXfuHABffvnlfT/Xo2jGjBns3buXw4cPm7XVq1ePH374gX79+pm1LVu2jLNnz3Lx4kWOHDnCjBkzOH/+PAB79+5l5cqVnDp1irNnz7JlyxZ+/fVXAKKionjnnXfYv38/ly9fJi4uju+++65IMb/33nuSrBFPjfRsPaEfXuJSvPnvvKuDhq2vVqKWr73p2NSgZ5lcowMf1e5i1j9Jl8nVjPwlVKGeASwNGYSztW3xBS+EEPehyBmXQYMGsXr16uKIRYhis/NsOkO+vc6dTAMYNDhqbOnpX4My9k70Ll8XV639vw8ihDCzbt06AgMDCQkJ4YMPPii03+XLl1mzZg0LFy7E1dUVALVaTe/evalYsSIrVqzAycmJqVOnotFoAHBwcODll18uUjxbtmyhfv36BAYGAvDSSy+xcuVKs36//PILP/30Ex9//DHBwcEsWLAAyL9hr1GjBkFBQfTv35/U1FSLzxMaGkq5cuWKFNuf/hwzOzubvLw8ypQxL2S5Y8cOoqKimDVrFnZ2+cXO1Wo1gwcPpn379hbHbdeuHRcuXCAuLo5WrVpRr149atSowbhx4wrUbShM06ZN8fbOr9Pg4uJCYGCgaRbPyZMnadu2LVqtFpVKxTPPPMPSpUsLHWv79u20bNmSypUr8+qrr1p8/vj4eLp3705QUBA1a9Zk/vz5prZz587RoUMHatWqRa1atZg7d67Z+T/++CPBwcFcuXKFS5cu0bRpU2rXrk1QUBBvv/22xbi2bt1K3bp1qVWrFi1atODs2bMANGnShJycHNq0aWNxOXft2rWpVq2axQ+qVq9ezahRo9BoNLi5udGnTx9WrVplahs8eDAODg7Y2NgwdOhQ0+/jjz/+SPfu3fHy8kKlUjFq1CiLv6uQPzunWrVqptla169fZ9SoUabYg4ODSUhIID09neHDh9OwYUNq1arFqFGjyMvLA/JnJY0fP97iz8XS+EI8Sq4l5tD8w0ukZJvPRKzspWXH6wF4Oluz+eZpMvU6ALRqK16qHIpWXbDqw7XMJLrunUe/AwtNfWVrbiHEo6jIyRqDwcCMGTNo0aIFY8eOZcKECQW+hHjUrDh0h3HLosk26jA6JaLU/Y0MMmjtXQUrtaakwxPisZWQkMDw4cPZuHEjhw4dwsbGptC+x48fp3Llynh4WJ7BduzYMUJCQv5zTNHR0QVmu/j7+3Pz5k2zpUbPPPMMXbp04Y033iAyMpIXXniBLVu2sHDhQg4cOMDp06dxcHBg8uTJ9xXHq6++SlBQEH379i2wRPiLL75gzZo1+Pj44OPjw8CBA6lTp47Z+cePH6du3bpmRfwLYzAYWLNmDfXq1aNUqVJs2rSJY8eOcerUKa5evcratWuLFP/Zs2c5dOgQrVu3BqBBgwZs3LiR9PR0cnNzWbVqFdeuXbvr+du2bePkyZPs2rWLNWvWmPUZN24cgYGBnD59mp07d/LBBx9w5MgR9Ho9Xbt2ZdiwYZw6dYpTp06ZLYH77LPP+Prrr9m5cyeVKlVi1qxZPPvss5w8eZLTp09bfD+SkJDAgAEDWLx4MadOnWLEiBH06dMHgIMHD5r++9VXXxXpe2Xpd+7P5Wj32/Z3ycnJfPrppxw/fpzIyEgOHjyIl5eXKYF18OBBIiMj8fT0ZOLEiYSGhnLkyBFOnjyJXq8vsGzL0s+lsPGFeFTsu5BO2OdR5BnM21pXd2T9yxWxsVazJOowo46u4sWjqwpNUJ9IvkHXPfOIzrzDi5Wb42BV+OuWEEKUtCIXGD59+rTpjeU/1+lLVlo8SoxGhZm/JvLd/jiyKu9HsUtDZZuJtVrDgnr96VCmekmHKMR/Mn1THBdidcU2ftUyNrzZufAdMSIiIqhbty5Vq1YFYMSIEbz++uvFFs+9ut/Xou3bt9O/f39KlSoFwIsvvshzzz1X5HGWLl2Kr69v/g4j33xDWFiYaQbHvHnzCA8P59VXXyUhIYHWrVvTuHFjU1KksOvYt28fY8eOJSMjg4EDB/Luu++aYg4ODgagbt26fPbZZxiNRl5//XX279+PoigkJCQQHBx8zzV/YmJi6Nq1K3PnzsXHxweAgQMHcv36dUJDQ3FwcKBt27bs3Lmz0DEGDRqEtbU11tbWDBgwgO3bt5sSI3/avn07J0+eBMDT05MePXqwY8cOHBwc0Ov1Bfr/Pck3depUfHx8+O2330wJwtDQUF599VUyMzNp0aIFbdu2NYvp8OHDBAcHExQUBED//v0ZPXo0sbGxFmc3FcXff1b/vEm837Y/OTs7U7lyZQYMGED79u159tlnC53VtWHDBiIiIvjss8+A/NlbWq3W1G7p59KzZ897Hl+Ih23RviT+90uCxbYRLd15uYOn6XE770C+vXyAPuXrWXwd2B53Pj+RA3zbqJ+8DxRCPPKKnKzZtWtXccQhxAOlyzPy1o+xbDmVhqIxYHS6jdFKh7vWgWVNBhFUqmxJhyjEf3YhVsfRqKwSe/67La1ZsmQJn3/+OQAvv/wyzZs359KlSyQlJeHu7m7Wv169egWWwdyv8uXLF0giXLt2jbJly95TnTVFUcze4N9P4sfX19d07pgxY5g0aZLpur/66ivTTBtPT086derEnj17zJI1derUYdasWeTl5WFtbU3z5s2JjIxk6tSppKWlmfq1bduWH3/8scC506ZNIykpicOHD2Nra8uECRPIycm5p9hv3bpF27Ztefvtt+ndu3eB78O7775rShKtWrWK6tXv/UansO/j/Xy/Q0JC+PXXX4mKijItd+vZsydNmjRh27ZtzJo1iy+++IJffvmlwHmWfr73+px3U758ea5du0aDBg0AuH79OuXLly/Q9qd7bfs7jUZDREQEBw8eZPfu3TRu3JiVK1fSvHlzs76KorBhwwYqVqx4T7GrVKoijS/Ew/TWj7fYcMx8KapaBdN7+xBWxwWdQY9WrUGlUlHGzoWdbV7G2sKs6YOJVxkasYxSWjsWNg6nnpv5vzUhhHjUSJVg8cRJzzEwcuENtpzKv6Ep72qHn5MTlRw92NJqtCRqxBOjahkbGlSwL7avqmXuPj08JCSEEydOcPHiRQBT3RfIn4nxZxHdIUOGmHZmGjZsmGn3J0VRWLJkCVeuXOH5558nJSWFDz74AIMhf657VlYWH3/8scXnDgwM5ObNm2bHO3bsyNGjR00FXmfPnl3o7BhnZ+cCNWnatWvHqlWrSE/P32Vk/vz5Fmdo3I1eryc+Pt70eO3atXh5eZkSVBUrVmTLli0AZGZmsnPnTmrWrGk2Ttu2bfH19eXll18ukGjJzMz81xiSk5Px9vbG1taW+Pj4AkuQjhw5Qps2bSyeFxsbS5s2bXj99dcZNGhQgbacnBzTz+327dt8/PHHvPbaa4XGsHTpUvR6PdnZ2axYscLi97Ft27amBF1iYiLr16+ndevWVK1aFa1WWyDu27dvm/6/Q4cOLFiwgLCwMCIjIwG4dOkSnp6eDBw4kBkzZhAREWH2fCEhIURGRpoKJK9atYpy5cqZ6vTcr969ezNv3jwMBgN37txh9erV9O3b19S2ePFiMjMz0el0fP/996bfx549e7J+/Xri4+NRFIW5c+da/F1NT08nPj6e5s2b884779CsWTNOnDgBgJOTU4Hf4S5duvDxxx+bdpVKTk7m8uXLpnZLP5e7jS9ESVAUhX5zoiwmarRWKpaO8iOsjgvJuVn0PfAdn5//K0FvKVED0MDdj37+9dkQOlISNUKIx0aRZ9YI8ShLTNczcmE0Z7Ivoy8fTyOaMWegL7maF7DVWEulf/FEudsSpYfB09OT+fPn07lzZ9zd3f91mc3333/PtGnTaNSoEVZWViiKQmhoKF26dMHe3p49e/bwxhtvEBAQgKOjIyqVyuLuO4mJiSQlJeHm5mbW5uTkxIIFC+jWrRt6vZ6goCAWL15sMZ7w8HAGDx7MmjVrGDNmDC+88AKnT58mJCQElUpFrVq1zLZh/tPo0aPZuHEjcXFxtG3bFkdHRy5fvoxOp+PZZ59Fp9OhVqvx8PDgp59+Mp23ePFixowZw2effUZeXh7dunWz+H1TqVRs2bKFt99+mxo1amBvb4+TkxOVKlX61zo648aNo3fv3gQHB1O2bNkCiZLr16+bChb/07vvvkt0dDRffvmlaaenl19+mSFDhpCamkqLFi3QaDQYDAbGjx9P586dC42hbt26tG3blps3bxZ6jV999RWjRo2iVq1aGI1G3nrrLRo2bAjAxo0bGTNmDO+//z4qlYrRo0czcuRI07mhoaGsXLmSnj17smzZMnbt2sXy5cvRarWmxMc/lS5dmqVLl9K/f38MBgOlSpXihx9+uOv38k/Lli3jjTfeIDk5mY0bN/Lxxx+zadMm6tSpQ3h4OEePHqVKlSpAfr2iatWqAflFffv06WNaevXcc8/RsWNHID9x995779G0aVOMRiOtW7dm2LBhZs+dmppKr169yMzMRKVSUblyZVMybeLEibRu3Ro7Ozt+++03vvjiC15//XWCg4NRq9VYW1vzySefEBAQUOjP5ebNm4WOL8TDlpNr4JnPrxKfar6NfSl7DT+OrUCZUvm1vK6kJ3Iq5SbJuVm8WLk59lbaAv1zjXo2xpyil28drNUaPg7u9jAuQQghHhiVci9bRAjS0tJwcXEhNTUVZ2fnkg5HWBCdlMuI76OJTs0gLXgDWOXxYqVQ3grqUNKhCSEeoHXr1nH27NlCd/wRhRs3bhx9+vShWbNmJR2KeMhatmzJpEmTCAsLe2BjPm3vjZ62633Y4lNzefbzq2Tnmt+aVCitZc0Yf+y0BWfO7E24TE2XMrjZOBQ4np6Xw4gjK9iXeIXZ9fvSpVytYo1dCCHuRVFfR2RmjXginLuVw8iF0SRlGDDa5mCrsSaHPOzvcScVIcTjo0ePHvTo0aOkw3gsFXWnIyGEeBhORWcxYO51DBY+Qm5a2YF5Q3xRqVT8nnSddL2OVl75M9lCPQPM+sdlpxF+aDHn0uIY4N+AZ3xqFHf4QghRLCRZIx57R69mMnrpdVKtE8BRhaHGXvJUucyo3Y1+/g1KOjwhhBCixO3evbukQxDCos2Rqby++pbFtgFNXE1Lfq9lJvHcwYWogF9bjaGio4dZ/wtp8YQfWsyt7FTeqN6e0ZVDZbdaIcRjS5I14rG282w6E1beIDlgOwbnBNQqFXZWVnzbINz0qYsQQgghhHj0fPlrAvN3J5kdVwFvdfHi+ZC/apP5O7gz0L8hVmoNFRzMdxXMMxoYErGUhJx0vqjbi17l6xRn6EIIUewkWSMeW+t+T2HKuliMigptehmsXNPRWqlY3mQwNUv5lHR4QgghhBCiEOOW3mDH2Qyz41ZqmD3Il6ZVHFEUhdS8HEpp8wujv1OzU6EzZazVGj6r25M8o8Hi8ighhHjcSLJGPHYUReG7vUl8vjV/e1ytjZ5ZrTtQr3JnNCoVDlZ3325YCCGEEEKUDIPBSO9Z17gQpzNrc9CqWTXaj4qethgUI1NO/cyehEtsCB2Ju42DxUTNkqjDNHT3J9DZixCPCg/jEoQQ4qGQZI14rBiNCp9uSeC7U2fJrnUE61xH3Lz01K9cFSfZllsIIYQQ4pGVpTPQ4X9XuJNpMGvzcrZi3biKlHLI3/Epz2jgXFocCbp0rmQk4v6PHZ8URWH62d+YfWkvzUtXYmXToQ/lGoQQ4mGRZI14bOQZFN5dG8tPJ1LRVT6P0S4NnV0aQe5BaNXyqyyEEEII8ai6lawj7PModHrzLZ9qlLVh+Sh/rK3UpmO2Gmu+bzSAmKxkavxjeXuuUc+rJ9az9kYkdV19md3guWKPXwghHjb1v3cRouRl5xp5eWkMP51IxWidhcYhE4DBFRrzTf0+2GgkWSPEo0ClUpGRYV6DAECv1/P+++8TGBhIjRo1CAwMZMSIEaSkpACQkJDAkCFDqFixIkFBQQQFBfHRRx8BsGjRInr16nVPMWzevJnAwEACAgLo2bNnofFs2LCBI0eOFP0igXHjxuHv749KpeLMmTMF2hISEujYsSOVK1emZs2a7N+/v9Bx4uPjGTp0KBUrVqR27drUqlWLF198kaSk/IKbU6dOxdPTk+DgYKpXr07fvn1JTk6+r5gBfv75Z+rXr4+NjQ2TJk0q0LZo0SJKlSpFcHAwwcHBtGrVytS2e/du7O3tTW3BwcFkZ2dbfI6WLVuyefPmIrfdi/96/t1MmTKFatWq0ahRI7O2wYMHU65cOdO1v/rqq6Y2o9HI2LFjqVSpEgEBAcyePbvAudOmTaNSpUpUqlSJd955p0gxpaSkMGPGjPu7ICEeIceiMunwv6sWEzUdg5xYPboC1lZqEnLSmXZmK3pj/swbF62dWaImI0/HkIilrL0RSTvvQFY3HYqr1v6hXIcQQjxMcocrHnnpOQZeXBzN4czTaGw8yau5G51VOq9Xa8eYKi1kS0bx1DEaFVKyzKeQF4dS9hrU6gfzb2zYsGHcuXOHQ4cO4erqitFoZO3atdy5cwcbGxtatGhB3759uXTpEhqNhszMTBYsWFCk58jIyGDYsGHs2bOHwMBAxowZw4cffsj06dPN+m7YsIH69evTsGHDIl9Lr169eO2112jWrJlZ2xtvvEHjxo3ZunUrR48epVevXly5cgUrq4IvuVlZWYSGhtK/f3/TNefm5vLll19y8+ZN3N3zdzsZOHAgn376KQaDgb59+zJt2jQ+++yzIscMULlyZb777jvWrFlDTk6OWXvbtm358ccfLZ5bvXp1fv/99/t63sfBjBkziI6OpnTp0hbb33jjDcaMGWN2fNmyZZw9e5aLFy+SmppK3bp1ad26NYGBgezdu5eVK1dy6tQprKysaNq0Kc2aNaNDhw73FNOfyZrXXnvtP12bECVp3e/JvLM2zmLbiJbuvNzBE8hf1vTi0VUcTrqGs7UN46q2snjOoqgI9iRcpp9ffT6q3QUrtabYYhdCiJIkyRrxSEvO1DNy4Q2OcRhdxdN45lSkrEcp+vm35Xn/+iUdnhAlIiXLQPMPLz2U59r3VmXcHAt/qVi3bh2TJ0/G1dWVZ555ptB+ly9fZs2aNURHR+Pq6gqAWq2md+/eAHz33Xc4OTkxdepU0zkODg68/PLLRYp3y5Yt1K9fn8DAQABeeuklnnnmGbNkzS+//MJPP/3E9u3bWbBgAWPGjOGFF15gxowZLF68GLVaTa1atZg9ezYuLi5mzxMaGlpoDD/88ANRUVEANGjQAC8vL/bv30/Lli0L9FuxYgWurq68++67pmNarbbArI2/02g0tG7dml9++YXTp0/z0ksvkZmZSU5ODuHh4bz55pv/+v2pUqUKAOvXr//Xvv/F9u3b+fTTT7l58ybdunVjxowZZon1+Ph4Ro0axeXLl1EUhXHjxjFixAgAzp07x/jx44mNjQXyf46jRo0qcP6PP/7ItGnTWLt2LUajkcGDB5ORkYHRaKRr165MmzbNLK6tW7cyefJk9Ho9rq6uzJkzh+rVq9OkSRNycnJo06YNLVu25Kuvvrrna129ejWjRo1Co9Hg5uZGnz59WLVqFVOnTmX16tUMHjwYB4f8WhtDhw5l5cqVZskao9HIuHHj2L59OzY2NlhZWXHgwAFGjRpFSkoKwcHBWFlZ8fvvvxMXF8e4ceO4du0aOTk5dOvWjffffx8Af39/nn/+eQ4cOMCtW7d46aWXmDBhQqHj29pKrTdRvD79JY6F+8xnA6pUMK1nGbrVK/W3Yyo+qNWZmed3MqRiSKFjvli5Ob72rnQpGyQf2AkhnmiSrBGPrMS0PIZ9F82VhFysHL2xLnODr1q1IsTTH41KVvAJUdISEhIYPnw4Bw8epGrVqnddrnH8+HEqV66Mh4eHxfZjx44RElL4m/N7FR0djZ+fn+mxv78/N2/exGg0olb/9XfjmWeeoUuXLtSvX980W2LLli0sXLiQQ4cOUapUKUaMGMHkyZP55ptv7vn5k5KSMBqNBWZn+Pv7Ex0dbdb3+PHjFpfcFCY7O5uNGzfSuHFj/P39TTfe2dnZNGnShHbt2lG//n9LYu/Zs4fg4GAcHBx45ZVXCiw9u3DhAnXr1kWj0TBkyBBeeumlQsc5e/Ys27ZtIy8vj9DQUNasWUOfPn0K9Bk3bhyBgYGsX7+ehIQE6tWrR3BwMHXr1jUlW/485/bt2wXO/eyzz/jpp5/YuXMnbm5uvPzyyzz77LNMnjwZgDt37pjFlJCQwIABA9i1axdBQUEsX76cPn36cObMGQ4ePIhKpeLgwYM4OjpavKbPP/+c+fPnU758eaZNm0ZwcDBg+XfuzxlI0dHRtGjRokCbpZlLJ0+eZMeOHZw9exa1Wk1qaiparZa5c+dSv359IiMjTX0HDRrEW2+9RWhoKHq9nrCwMNavX0/37t2B/CTY3r17uX37NvXq1aNp06ZotVqL4wtRnF5aHM2e85lmx601KhYM86V+hfwk5s2sFMralwKguos33zbqZ3bOieQbbIo5zTs1O6FRqelarlaxxi6EEI8CueMVj6RbyXn0n3+FKwm55LpdJ7v6Dt6u05JmXhUlUSPEIyIiIoK6detStWpVANOsiJJ2v5+0bt++nf79+1OqVCkAXnzxRbZv3/6fn19RzGs0WOq7evVqgoODqVChAgsXLjQdX7JkCXXq1KFJkyZUq1aNN954g+zsbF544QWCgoJo3Lgx169fL3BDfz/CwsJM4yxYsIBXXnmFiIgIAOrWrUtMTAzHjx9n/fr1zJ07lx9++KHQsQYNGoS1tTX29vYMGDDA4vdx+/btjB49GgBPT0969OjBjh07uHDhAnq9vkBy5+9JvqlTp7Jnzx5+++033NzcgPyZTgsWLOCtt97it99+M/0M/+7w4cMEBwcTFBQEQP/+/YmJiTHN3rmbDz/8kMuXL3Pq1CmGDRtGp06dCtRC+vvP8Z8/77u1/alixYrk5eUxdOhQFi9eTF5eXoHk4p8yMzPZuXMn48aNIzg4mPr163P58mXOnz9v6jNs2DAg/3vWvXt3duzYcc/jC/EgGAxGusy8YjFR42SrZtMrFUyJmp9iTtF8++f8cP14oePtjL9An/3fseTaES6lJxZb3EII8aiRV2rxyLmWqOP5Bec4X2YzmZX3kB2wj9J2DtRz9y3p0IQQf3O3JMSSJUtMxVgXLlxI3bp1uXTpkqlw7j/Vq1fPlBj4L8qXL8+1a9dMj69du0bZsmXv6cZUURSzREtREz9/1plJTPzrhuL69euUL1/erG+dOnU4fPiw6XHfvn2JjIykRYsWZGb+dZMzcOBATpw4wYkTJ/jiiy+ws7Nj8uTJeHl5ceLECU6ePEnLli0t1qApCg8PD+zt84t0VqtWjWeeeYYDBw4A4OzsbFoOVq5cOZ5//nn27dt3z2MX9n28n+93SEgI58+fNy01A+jZsycHDhygatWqzJo1i7CwMLPzLP187/U5//471L17d5ydnblw4QJg/jv395/33dr+zsXFhT/++IN+/fpx/vx5atWqxeXLl836GY1GVCoVR48eJTIyksjISC5fvnzXJXAqleqexxfiv0rP1hP60SWuJOSatfmUsmb7awH4utuYjukVI3lGIwm6dIvj/XD9OEMilmGjtmJ106FUcfYsttiFEOJRI8ka8Ui5EJvDwPnXiTUkYrRPRu92g4qO7mwMHUk1F++SDk+IR0Ipew373qr8UL5K2RdeuDEkJIQTJ05w8eJFgALFgAcOHGi6mRwyZIhpZ6Zhw4aZdn9SFIUlS5Zw5coVnn/+eVJSUvjggw8wGPKLJ2dlZfHxxx9bfO7AwEBu3rxpdrxjx44cPXrUNNNg9uzZPPec5S1dnZ2dSU1NNT1u164dq1atIj09/6Zh/vz5tG3bttDrL0zv3r1NS6eOHj1KXFycxULE/fr14/bt23z44Yema4b86/43ycnJlCtXDisrKy5cuMC2bdtMbevXr2fgwIFFjvvv38/4+Hh27txJnTp1AIiNjcVoNAKQnp7O5s2bTW2WLF26FL1eT3Z2NitWrLD4fWzbti3z588H8pNb69evp3Xr1lStWhWtVsuaNWtMff++DKpDhw4sWLCAsLAw02yiS5cu4enpycCBA5kxY4bFxF9ISAiRkZGcO3cOgFWrVlGuXDm8vf/9tSUmJsb0/xERESQlJREQEADk/7znzZuHwWDgzp07rF69mr59+5raFi9eTGZmJjqdju+//97i72NiYiKZmZm0b9+ejz76CH9/f86ePYuzszNZWVno9XoAnJycaN68eYF/F7du3SoQ35+zsu7cucOGDRto06ZNoeML8SBFJ+kI/fASKVlGs7Y6fnZsnVQRR7uCryk9fIPZ3nosY6q0KHBcURS+urCLCSfWUsbWmQ2hI6nnZp7oFEKIJ5nUrBGPjFM3shm5MJq0bCN63zhQQXVnb1Y2HYq7jUNJhyfEI0OtVt216O/D4unpyfz58+ncuTPu7u7/urX2999/z7Rp02jUqBFWVlYoikJoaChdunTB3t6ePXv28MYbbxAQEICjoyMqlYp+/cxrFyQmJpKUlGRaAvN3Tk5OLFiwgG7duqHX6wkKCmLx4sUW4wkPD2fw4MGsWbPGVGD49OnThISEoFKpTAWGLRk9ejQbN24kLi6Otm3b4ujoaJqp8MknnxAeHk7lypXRarUsXbrUbCcoyC+gvHfvXt58800CAgJwcXHBzs6OOnXq0K1bt7t+L99++23Cw8NZvnw5/v7+tG7d2tR2+fJlnJ2dLZ63e/duBgwYQFpaGoqisGrVKmbPnk2XLl345ptv2LhxI9bW1hiNRl555RXTuGvXrmXOnDlYWVmh1+vp3bs3Q4YMKTS+unXr0rZtW1OBYUu/G1999RWjRo2iVq1aGI1G3nrrLdPOXBs3bmTMmDG8//77qFQqRo8ezciRI03nhoaGsnLlSnr27MmyZcvYtWsXy5cvR6vVoigKc+fONXu+0qVLs3TpUvr374/BYKBUqVJ3Xcr1d4MHDyY+Ph6NRoOdnR1r1qwxzTQKDw/n6NGjpuLNr776KtWqVQPytxrv06ePaenVc889R8eOHc3Gv3HjBsOHDycvLw+j0UiTJk3o1KkT1tbW9O/fn6CgIBwcHPj9999Zvnw5EyZMMI3p6OjI3LlzKVeuHAB+fn40b96c2NhYxo0bR8OGDTl+/LjF8YV4UI5cyWTYd9EYLUy47FzHmY/7lAXAoBj56I9f6V6uNjX/f0vuqs5eZuck6jKYf/kA1Z29WRIyCG87y3/ThBDiSaZS7jaPvZhNnz6ddevWcf78eezs7GjSpAmffPKJqf4B5GfW33vvPebPn09ycjKNGjXim2++oUaNGqY+Op2OSZMmsXLlSrKzs2nTpg2zZ882vXGB/E8hx40bx08//QRAly5d+Prrry2ua7ckLS0NFxcXUlNTC30TLO7f0auZvLDmBDl6A1YZnnRsk8IN27N816g/TtayW4UQ4i/r1q3j7NmzvP322yUdyiOpZ8+efPbZZ/j7+5d0KOIh8/f3Z/PmzdSsWfOhPN/T9t7oabvee7X2aDLvrrO8NffYdh6Mav1XwfVV139n0on1+Du4s7vNy3fddvuPlFv4OrjhLO8DhRBPiKK+jpToMqg9e/YwevRoIiIi2LZtG3q9nvbt2xdYqz9jxgw+//xzZs2axdGjR/H29qZdu3amaeoA48ePZ/369axatYr9+/eTkZFBWFhYgWnl/fr1IzIykq1bt7J161YiIyMJDw9/qNcrLNt3IYNhK/4gKWAbmYE7eelZWz5rG8LqpkMlUSOEMNOjRw9J1NzF2rVrJVEjhHgoPtsSbzFRo1bBp8/7FEjUAPQuX5dw/4bMadDXLFGTkpvNwEOLOZNyC4AapXwkUSOEeKqV6Myaf0pMTMTT05M9e/YQGhqKoij4+Pgwfvx4Xn/9dSB/Fo2XlxeffPIJI0eOJDU11TS1+c814rdu3cLX15dffvmFDh06cO7cOapXr05ERIRpm9SIiAhTkcK/z+QpjHyaUjx+O5PGq6tukqvkkVFrE3a2Rg53nIirjX1JhyaEEEKIu3ja3hs9bdf7b8YtvcGOsxlmx601KhaNKE9w+fz3cnd0mahUKly1hb+3u5WVwoBDi7mYnsCkwDaMD2xdaF8hhHhcPVYza/7pz0KPf9YhiIqKIi4ujvbt25v62NjY0KJFCw4ePAjAsWPHyMvLK9DHx8eHmjVrmvocOnQIFxcXU6IGoHHjxri4uJj6/JNOpyMtLa3Al3iwNp1IZcKKG+SRS3bgThSbLLr41sBZK5+iCCGEEEI8ioxGIz2/umoxUeNkq2bzhIqmRM2t7FR67PuWIRFLydab7xAFcD4tni5753ExPYF3anSSRI0QQvy/kq9Q+f8URWHChAk0a9bMtNY6Li5/WqWXV8HCY15eXly/ft3UR6vV4urqatbnz/Pj4uLw9DTf6s/T09PU55+mT5/Oe++9998uShRq/bEUXtuzD13N86gAg30KIwOa8XaNjkXeKlcIIYQQQhS/nFwjHT+9TGK6waytjIsVG14uuOOTrfqvWw2d0YDdP845fPtafiLHkMfX9frQ3bd2cYUuhBCPnUcmWTNmzBhOnTrF/v37zdr+efOuKMq/3tD/s4+l/ncb580332TChAmmx2lpafj6+t71OcW9+fFoMlPW30JX4zxGuxRQwavV2jKuSktJ1AghhBBCPIJup+XS8bOrZOeaV1CoWdaW5S/6YaUpOGnfzcaBVU2H4mJti52V1uy83+LOYcDIkpCBNPcMKLbYhRDicfRILIMaO3YsP/30E7t27Sqwg5O3tzeA2eyXhIQE02wbb29vcnNzSU5Ovmuf+Ph4s+dNTEw0m7XzJxsbG5ydnQt8if/uh8PJTFkXB4oaj6utKW/rwftBYbxctZUkaoQQQgghHkEXY3No88kVi4madjWcWDXa35So2ZNwiQ//2MqfZTG97ZzNEjV/tr1VowNbW46RRI0QQlhQoskaRVEYM2YM69atY+fOnVSoUKFAe4UKFfD29mbbtm2mY7m5uezZs4cmTZoAUK9ePaytrQv0iY2N5cyZM6Y+ISEhpKamcuTIEVOfw4cPk5qaauojit+Kg0m8vfcwRo0OBxs13w+sxr6OLzO0UkhJhyaEEEKIErB37146d+6Mj48PKpWKDRs2FNp35MiRqFQqvvjiiwLHdTodY8eOxcPDAwcHB7p06UJMTEyBPsnJyYSHh+Pi4oKLiwvh4eGkpKQ8+At6Au09n06Pr6LQG83bBjd344sB5UwfuKXn5TD66GrmXNrHnoTLZv0VReHLC7sYe2wNRsWIWqWmgqN7cV+CEEI8lko0WTN69GiWLVvGihUrcHJyIi4ujri4OLKzs4H8pUvjx4/no48+Yv369Zw5c4bBgwdjb29Pv379AHBxcWHYsGFMnDiRHTt2cOLECQYMGEBQUBBt27YFoFq1anTs2JHhw4cTERFBREQEw4cPJyws7J52ghL/3bIDd3g7citZlfeRXmc9YWGxBPvZo1E9EpO7hBAPiEqlIiPDvOgkgF6v5/333ycwMJAaNWoQGBjIiBEjTDdMCQkJDBkyhIoVKxIUFERQUBAfffQRAIsWLaJXr173FMPmzZsJDAwkICCAnj17FhrPhg0bCiTxi8Lf35/AwECCg4MJDg5m9erVhfa9fPkyvXv3pkKFCtSpU4fatWvz6quvotPpABg8eDDlypUjODiYatWqMXLkSPLy8u4rrn+OFxwczKuvvmpq++abbwgKCiI4OJigoCC++uqrQse528/ybm334r+eX5jc3FzCwsKoVasWo0ePNmu/288tISGBjh07UrlyZWrWrFlgWXZWVhbPP/88AQEBVKlShXXr1hUprsjISH744Yf7v7AnWGZmJrVr12bWrFl37bdhwwYOHz6Mj4+PWdv48eNZv349q1atYv/+/WRkZBAWFobB8FddlX79+hEZGcnWrVvZunUrkZGRhIeHP/DredIsP3iHFxfH8M/5NCrg7a5evPpMwRnqTta2zGnwHG9Ub0+Lf8yWMShG3j61if+d286l9ATS83TFG7wQQjzulBIEWPxauHChqY/RaFSmTJmieHt7KzY2NkpoaKhy+vTpAuNkZ2crY8aMUdzc3BQ7OzslLCxMiY6OLtAnKSlJ6d+/v+Lk5KQ4OTkp/fv3V5KTk+851tTUVAVQUlNT/8slP5UW7butVH/jrBIwY7NSdt1kpfz6t5Sfb54p6bCEeGwZDEYlKT3voXwZDMYixQYo6enpFtsGDhyohIWFKXfu3Pn/6zAoP/zwg3LlyhUlKytLCQwMVKZMmaLo9XpFURQlIyND+eKLLxRFUZSFCxcqPXv2/NfnT09PVzw9PZVz584piqIoo0ePVt5445wiXHwAAGTwSURBVA2LfQcNGqR8/fXXRbq+P/n5+f1fe3ceV3P2/wH8de9tT0WlEi0iW9tVKWUp1ZCQfR/7Mo2lyW6YwfRlbDMYGYxh7NsgxjYhIySiKLspilKJtG+37j2/P/r5cN3bZqJ038/H4z4e7udzPp/POede957e93zeR+a7SJ6UlBRmaGjItm7dym3Ly8tjc+fOZenp6TL1KCwsZB07dmTr16//oHq9f773ZWVlcf/Ozs5mJiYmLDY2Vm7Zil7LivZVxX89vjzXrl1j7dq1K3d/Ra/buHHj2OLFixljjF2/fp2ZmpqykpISxhhjP/zwAxszZgxjjLEnT54wQ0ND7n1cFVV9/35uanpsBIAdPXpUZntycjJr2rQpu3v3LjMzM2Nr167l9mVlZTFlZWV24MABbtvz588Zn89nISEhjDHG7t+/zwCwa9eucWWuXr3KALCHDx9WuX6KNhZc9lcqazf/vszDZsF9duF+DldOIpGwB9lpFZ6rqLSE+V3fz5oeXcAGX97KckSFH7v6hBBS51T3e6RWEwwzJnvf6/t4PB6WLFmCJUuWlFtGTU0NQUFBCAoKKreMrq4u9uzZ8yHVJP/B9ksZ+OnvdIg1MlDcPApKPD5+dx6BL5q0re2qEfLZyioQo8uyuE9yrcsLLaHboPyviuDgYCxYsACNGjWCj49PueXi4+Nx6NAhPHv2jFu9j8/nY/DgwQCAbdu2QUtLS+qzXlNTE99880216vv333/D0dERbdq0AQBMmTIFPj4+WL58uVS506dP4/jx4wgNDcXWrVsxbdo0TJw4EatWrcLOnTvB5/Nha2uLjRs3QkdHp1p1eNevv/4Kd3d3TJgwQapdK1eulFteTU0NXbp0waNHj3D+/Hl89913KCoqQklJCWbNmoVx48Z9cF0ASLWloKAApaWlFeYL++mnn3Du3Dm8fPkSP/zwA4YPHy5TJioqCtOnT0d+fj7U1NSwdu1adOrUCQBw6tQpLFmyBCKRCDweD7/99hucnZ25YxljmD9/Ph4+fIj9+/fj/PnzWLhwIfh8PkpLS7Fs2TL07dtX5pryXqfnz59j5MiRSElJgVAoxMyZMzF69Ogq982ff/6JhIQEAECHDh1gaGiI8PBwuLu74+DBg9ixYweAslu0u3btir/++gtjx46VOsfLly8xcuRIpKamgsfjwcHBAStXrsSiRYuQk5MDoVCIjh07YvPmzbhx4wbmzZuHnJwcSCQSLFy4EAMHDkRiYiIcHR0xduxYXL58GXl5eQgKCoKHh4fc82/fvr3KbfwcSSQSjBo1CnPmzIGVlZXM/ujoaJSUlKB79+7cNmNjY1hbWyMiIgI9evTA1atXoaOjI/Xe69ixI3R0dBAREVHuLOvi4mJuBhxQttiEImCMYcrOJFx6lC+zT1WJh91+ZrBqqs6V/e72CexLjMIOl1FwM7CUOSa3pAgTI/fiyqsn6GVsjV8cBkFNoPzR20EIIZ+7OrMaFKl/fruQjhVxp8Bv0gCipvehrCTBto6j0M2wVW1XjRBSA9LT0zFp0iTuj51Vq1aVW/bmzZuwtLSEvr6+3P3R0dFwcfnv+auePXsGMzMz7rm5uTmeP38OiUQCPv/tbZc+Pj7w9fWFo6Mjpk2bBqAs0LN9+3ZcvXoVDRs2xOTJk7FgwQL8+uuvcq81cuRISCQSODs7Y/ny5WjcuLFMmZs3b+KLL76ocv0zMzNx5swZBAQEwN7eHuHh4RAIBHj9+jXs7e3h7e2NJk2aVHqeNWvWYMuWLTA1NcXSpUshFAq5fYcPH8bixYsRHx+PFStWwMbGptzz8Hg8XLlyBU+ePIGTkxM6d+4stTKiSCTCgAED8Pvvv6NHjx4IDw/HoEGDEB8fj+fPn2PChAm4dOkSWrVqhZKSEhQUFHDHFhUVYcKECTAwMMDRo0fB5/Px3XffYfPmzXB1dYVEIpH7x3FFr9PWrVsxe/ZsREVFldsmea9bRkYGJBKJ1Gtobm6OZ8+eAZD/vnqz71179uyBubk5zp49CwB4/fo1dHV1ERgYiJMnT+Lw4cMAgKysLHz11Vc4deoUmjRpglevXsHBwYELcmVkZMDGxgY//fQTrl27hn79+uHx48dyz1/frVy5EkpKSvD395e7Py0tDSoqKlwQ+A1DQ0NugYq0tDQYGBjIHGtgYCCziMW7li9fjh9++OE/1P7zUyqWYFBQAuJeiGT26ajzcTTAAobabwMtPB4PhmpaUBUoQYknkDkGAF6LCvAo9wVGN3fC/2z70C3whBBSRfRpST6Kzf+8ws+Rd1BiEA9R03tQVwZ2uY6mQA0h9ci1a9dgb2/P/So9efLkWq5RmQ9dWS40NBQjR45Ew4YNAQBff/01QkND5Za9dOkSYmNjcfPmTejp6WHMmDFVqs/atWshFAphamoqde4VK1agffv28PT0xMCBAzF27FhkZGRg8ODBsLa2hoeHB169eoV79+5V2o5ly5YhPj4et2/fxoQJE9CzZ0+p/DCDBg3CvXv38OjRI+zatQuPHj0q91wTJ04EAFhYWKBz5864fPmy1P5Hjx5BRUUFPXr0AAB07twZBgYGuH37Ns6dOwcfHx+0alX2ua+srCw1s8fb2xtCoRBBQUFcIM3T0xMBAQFYtWoVbt++zb0W76rO6/S+il63998378/+fXd/eTODO3bsiJCQEMyaNQvHjx+Hpqam3HIRERF48uQJevbsCaFQCC8vLzDGuNdCRUWFy6fSsWNHGBkZITY2tsrnry+io6Pxyy+/YMeOHdX+f80YkzpG3vHvl3nft99+i+zsbO6RlJRUrTp8bvKKxPBYES83UGOiq4zQeS2lAjVvTG/ljn88/NGpsYXU9lJJWc4gM01dhLhPwzJbXwrUEEJINdAnJqlxm86/RNC5l1DKbgLdFCf8JhyLG95z0blxi9quGiGkBlV0K+uuXbu4JK7bt2+Hvb094uLikJGRIbe8g4MDrl279p/rZGpqisTERO55YmIimjZtKjWrpjzy/nAr7w85U1NTAGUBiICAAJkgxhvt27dHZGQk93zGjBmIiYmBhYUFioqKuO3z58/HrVu3cPPmTSxatAg8Hg9+fn5wc3PDnTt3EBMTg1atWkkdU55329u/f39oa2vLDciYm5vD2dkZJ0+erPScb8gLaMjro6r8Ye3p6YmzZ88iNzeX27ZmzRps374dGhoaGDNmjNzZWtV5nd5X3uump1e2Gs3Lly+5sk+fPuXKv/++enffu1xcXBATEwNnZ2ccOXIEHTp0kEpy+24bbG1tERMTwz2ePXsGNze3cuvO4/GqfP764vLly0hPT4epqSmUlJSgpKSEp0+fYtasWTA3NwcAGBkZQSQSITMzU+rY9PR0GBoacmVevHghc/6XL19yZeRRVVWFtra21KO+Ss0Uwe3HOGTkyb6f7M3UcWqmBTRUy2bOZIoKMPn6PjwvyAJQ9t401mgodcy9rBS4nV+Hm6/LAlxG6tofHEgnhBCFVeNZc+opRUsq96E2//OCtVl0g7X68Txrvm81i0x6WdtVIqTeqSsJhl+8eMH09PTYo0ePGGOMrV69usLEsV9++SXr27cvl9xdIpGwnTt3svj4eJafn89atWrFAgMDuQTD+fn5bPny5Ywx2QStrVu3ZsnJyTLXyMnJYY0bN5ZKMDxv3jy59Zk+fTpbunQp9/z06dPM2tqa5eSUJc708/NjU6dOlTkuLy9PKkH9zz//zLp06SL3Gs+fP2eNGzeWSpwvFouZs7MzO3HiBGOs/ITA9vb2XLLVixcvMj6fzx0TFBRUbuLkpKQk7t9Xr15lenp6XGLh+/fvc/vS09NZy5Yt2dmzZ+WeBwALDAxkjDGWkJDA9PT0uOT9b17n4uJiZmJiws6fP88YY+zKlSvMyMiI5eXlsbi4OGZkZMS9P0QiEVePN8evWbOGOTs7c8l637xujDG2adMm1r9/f5l6VfQ6XbhwgTk4OMhtT2Wv25gxY6QSDJuYmHAJhhcvXiyVYNjAwIBlZGTIXOPJkyesuLiYMVY2blBVVWVZWVnsyJEjzMvLiyv3+vVrZmRkxPUbY4zdunWLFRcXs4SEBAaA7dq1izHGWGRkJDM0NGR5eXnlnr+2fOwEw69evWJ37tyRehgbG7N58+ZxiYHfJBg+ePAgd1xKSorcBMORkZFcmWvXrlGC4f9351k+s1kgm0i43fz7bN6BZCaRSH8PLIo9yZoeXcDGX9st93zh6Y9Z6xM/MIu/FrGQlHufogmEEPJZ+KwSDJP6ZduldKx4chSl1i/ABCVooKwC9Qa0LCMhNY3P51WY9PdTMTAwwJYtW9CnTx/o6elVurT2H3/8gaVLl8LZ2RlKSkpgjKFr167w9fWFhoYGLl68iPnz56Nly5Zo0KABeDweRowYIXOely9fIiMjA7q6ujL7tLS0sHXrVvTr1w+lpaWwsbHBzp075dZn1KhRGDt2LA4dOsQlGL5z5w5cXFzA4/G4xLXve/HiBQYOHAixWAzGGCwsLLBr1y651zA2Nsbly5exYMECLFmyBHp6elBVVYW7uztcXV0r7K8VK1ZgypQpWLFiBdq1ayeVHPXBgwdo3ry53OPGjh2LFy9eQCAQQF1dHYcOHeJuPwoKCsLFixehrKwMxhhmzJhRYU4dVVVVdOrUCS9fvkRQUJBUvhqg7HadI0eOwN/fn0swfOjQIWhqaqJly5bYtm0bhg8fjpKSEggEAvz2229wcnLijp8xYwYaNGgADw8PhISE4Ntvv8W///4LFRUVaGhoYNOmTTJ16tmzZ5Vep/dV9rqtXLkSo0aNgqWlJVRUVLB7924oKZX9P5szZw7Gjx+Pli1bgs/n49dff5X7/gsLC8OaNWsgEAggFouxevVq6OjowNPTEz/99BPs7Ozg4uKCzZs348SJE5gzZw5mzJiBkpISmJqa4tixYwDKZvrEx8fD2dkZeXl52LdvHzQ1Ncs9/+csLy8P8fHx3POEhATExMRAV1cXpqam3KynN5SVlWFkZMTdfqmjo4MJEyZg1qxZ0NPTg66uLmbPng0bGxt4eXkBANq2bQtvb29MmjQJv/32G4Cy2zZ79+5dbnJhRRF6LwcBe57LLM0NAH7d9DC9u2yun/ntvkApE2N2Wy+ZfSef34V/9J9Q5Sthj+tYuOjL/5wihBBSOR5jVViSiSAnJwc6OjrIzs6u19NgP9TuK6+x/FQK8tueg7jBK6gLVHCk60TYNmxa21UjhNQzwcHBuH//Pr777rvarkqtcXNzw8mTJ6GlpVXbVSE17M1qUK9evartqlSqJsZGYWFh6Natm8z2MWPGcCtwvcvc3BwBAQEICAjgthUVFWHOnDnYt28fCgsL4enpiY0bN0oFF1+/fg1/f38cP34cAODr64sNGzbIzYtUnvo2FtwZnoFVp9JltvMABA5sggGODbltT/Jeoal6Q6gKyv+hYFdCJBbGnkBjVU3scR2LdjqVJ0MnhBBFUt3vEQrWVFF9+4KuSfuuvsay4y9QqvUC+W3OQ11JCYe7TIBdo2a1XTVCCCHks6JowZrPSX1q79K/0rD/WqbMdiU+sHmsCVwsG3DbbmUm4cuInejU2AIbHYdCiS9/1adl90Lwd8p97HMdC1NN2ZlnhBCi6Kr7PVL78+jJZ21/ZAYWXQ+DCq81xE0fQENZGQc7j6NADSGEEPIBzM3NP4tADfk8McYwZWcSLj3Kl9mnrszD/qnNYWmoKrW9obIGVPgCNFBSlTlGzCQolUigKlDCgnY9MM3SDToq6h+t/oQQokgoWEM+WHBUFhbePA2R2UPwtLJwsNtIqOsUoJ2OUW1XjRBCCCGEvKOkVIIhGxLwr5yluXU1BTgaYAF9OfnQmjfQwyn3KTBS0wL/naW3i8QlmB51CACw2WkYBDw+BWoIIaQG0dLd5IP8dTMLi4JTIcjTB1+kgZ86ecLBVJsCNYQQQgghdUxekRhfrHosN1DTXF8F5+a2kArUHHgaha3xV7jnxuo6UoGanJIifBmxE3+n3oOKQAAxk3zcBhBCiAKimTWk2k7cysJ3h1NRovEKRRaRUFZi6GDaqLarRQghhBBC3pOaJYLv2icoEMmmqXRsro7tE83A5/O4bU/zX2N+zF+QMAZ3w1ZoqdVY6piXRXn48uoO3MtOxXgLFyyx8ZEK5BBCCKkZFKxRYIwxFBYWymzj8XjlPr8YJ0LA9eNgJkCJwRMoKzHscR0DY/XPe+lQQgghhJD65v7zIgzfmIBSORNffNtrY/kQ2VU7zTR18VP7AeDzeDKBmmf5rzEiYgcS8zMwt60XprdylxonEkIIqTkUBldghYWFsLRsKfVo1cqywuezgqNRbPAvREaPoCSQYLfraLg2tqjtphBCaklwcDAcHBwgFArRtm1beHp6QiIp+6vAx8cHjx8/rpV6vX79Gp07d4ZQKMSyZcuwaNEiHDx4EEDZUsFnz56t0nnGjh2LZcuWcc937NgBHo+H5ORkbpunpyd27dpVsw2opmPHjuH69esfdCyPx0NeXl6Vys6cORMHDhwAABw8eBDt27eHtbU1bGxsEBQUJFV227ZtsLS0RIsWLTB58mSUlpYCAPLy8tCjRw/o6+tDX19f6pj8/Hw4OzvDzs4OdnZ28Pb2RmJiIoCyHw+6dOmChISED2onIYrm4oNcDNkgP1DztYeeVKBGwiR4kvc2sfUg0/YYYCKUOY4HHkSSUiy384V/624UqCGEkI+IgjWkWlihNnilyhDwBNjlOhqdGreo7SoRQmpJWloa/Pz8EBwcjJiYGDx48ACrV6/mBu+nT59Gixa18xlx7tw56OjoICYmBgsXLkRgYCCGDh0KoHrBmm7duuHChQvc87CwMDg7OyMsLAwAIBKJcPXqVbi7u9d0E6rlvwRrqur58+f4+++/uX5s1qwZ/v77b9y9exfh4eH45ZdfcOVKWY6LhIQEfP/99wgPD0d8fDzS0tKwbds2AICysjLmzp2L0NBQmWuoq6sjNDQUsbGxiI2Nhbe3N2bOnAmgLKg0Y8YM/PDDDx+1nYTUB/uvvsaUXcl4/8YnHoD/DTTCtC8MuG2lEjGmRx9C77BNuJeVIvd8eSXFAAATzUYI8wzAqObOH6nmhBBC3qBgDQEAxMbeRlxcvNxHbOxtrpyWijJmmvfFdpeR6GLQshZrTAipbampqVBSUoKenh63zd7engvWmJub4+7duwAAd3d3zJkzB127doWJiQlWr16NAwcOwNXVFWZmZtxsDQAICQmBvb09bG1t4ebmhvv37wMoC5QIhUJMmTIFdnZ2sLKyQlRUlEy9QkNDMWfOHFy5cgVCoRChoaEYO3YsNmzYgJiYGGzevBm7du2CUChEYGBghW3s1q0bIiIiIBKVJeWMiIjAt99+ywVrIiMjYWxsDFNTU8yZMwcdOnSAUCiEm5sb4uLiAACJiYnQ19fHokWL4ODggJYtW+L06dPcNY4cOYI2bdqgffv2WLp0abkzXUpKSjB//nw4OTlBKBRi2LBhyMrKwunTp3H8+HGsWLECQqEQW7dulTl2zZo16NChA9q3bw8nJydERkZW2G55/vjjDwwaNIh7fTt16gQjo7Kk8jo6OmjTpg036+Xw4cPo378/DA0NwePx4Ofnh/379wMAVFVV4enpiYYNG8pcg8/nQ0tLC0DZTJqcnBzw+W+HKn369MHp06eRm5tb7foToihWn3qBpcdfyGxX4gO/TzDBAEfpPIMCHh8aAhUo8fmQyIR3gPNpj9Dx7GpEvkoEAGgoqXyUehNCCJFGOWsIAEBDQwMaGhqVlls7sik6tW1caTlCyKfhcf4Xudu3OX+J5g30kJCXgQmRe+SW+cfzGwBA2Is4BN49LXdfRezs7ODi4gJTU1O4ubnB1dUVI0aMQNOmsjkQAODZs2cICwtDWloaWrRogVmzZiEiIgLXr19Hv379MGzYMKSnp+PLL7/EhQsXYGNjg71792LIkCFc0OfevXvYunUrNm7ciM2bN2PhwoU4c+aM1HW8vLwQGBiIkydP4vDhwwCAPXvK+kAoFMLPzw95eXn46aefKm2jqakpmjRpgsjISJiamqJx48bw8vLC/PnzAQAXLlxAt27dAADz5s3D6tWrAQAHDhzAjBkzcPLkSQBARkYGHBwcEBgYiJCQEHzzzTfw8fFBeno6Jk+ejGvXrsHS0hLr1q0rty6rV69GgwYNuBk0//vf/7B48WL88ssv8PX1haOjI6ZNmyb32FGjRnEzVK5du4YJEyZwfVpVYWFhmD17ttx99+/fx9WrV7FlyxYAZa+1mZkZt9/c3BzPnj2r8rW8vLxw584dNG7cWGoWlLKyMqytrXHlyhV4e3tXq/6EKIKAPUk4d0822KuuzMP+qeawNFST2cfj8bBC2BcBrbuhqUZDqX1Hk2Ix4+ZhNFBShYpA8LGqTQghRA6aWUOqxcpEtbarQAipI/h8Po4cOYKIiAh4e3vjypUrsLKyQnx8vNzygwcPBp/Ph7GxMfT19dGvXz8AgIODA1JTU1FUVITIyEgIhULY2NgAAEaOHInk5GSkpqYCAFq3bg1HR0cAgIuLyyfJidOtWzeEhYXhwoULcHd3h6amJho1aoSkpCSEhYVxwZqzZ8/CxcUF1tbWCAwMRExMDHcOTU1N9O3bV6be165dg729PSwtLQEA48aNK7cex44dw549eyAUCiEUCrF//348efKkSm24desW3NzcYG1tDT8/P9y/f5+bLVRVycnJ3Eya97f37dsXmzdvhrGxMbf9/WT11REaGorU1FQMHToUS5culdpnZGQklTOI1F/ff/8dnJ2d0LSpMR4+fCi1b8aMAHh5eeKLL7zg49MTly9f5vYFBATAwcEBX3zhhS++8ML//vd2Bt2OHdvh6emBL77wgqenB7Ztk52J9oazsxN33aKiIkydOgWNGjVESUlJDbf0vxOLJRj6a4LcQE0jTQH+ntNCKlDzqjgP30QfQraobKEJAY8vE6j54/FVTI/+E43VtHC062S0b2TyUdtACCFEGs2sIdWiwqe3DCF1SWUzYJo30Ku0jLuhJdwNK59JU542bdqgTZs2+Oqrr+Dt7Y3jx49zszjepab29g8FgUDAPRf8/6+1paWlMivQvfFm2/vneJO09mPq1q0btm3bBlNTU4wYMQIA4ObmhpCQEFy7dg179uzBs2fP4O/vj+vXr8PCwgK3b9+Gh4cHd4736y0WiwHIrrhXEcYYNm7cKHXeqhCJRBg4cCDCwsLg4OCAnJwc6OjoQCQSQUWl6rczaGhoyKwgmJKSAi8vL3z33XcYPHgwt93U1JRLDAwAT58+hampabXqzefzMWnSJFhaWmLjxo3c9qKiIqirq1frXOTz1KtXb3z99RT0799PZt+SJT9AR6dsJcq7d+9i2LChuHPnLvf/adq0qRg3brzMcQMGDMTYsWVB0dzcXHh4dIOLiyvatWtXbj1yc3MxbtxYmJqaIjMzC8rKyjXQuppTJJKgz9onSMmSDSKZ6ikjeHpzqKtKz4pZdPskjj+/A3WBMlYI+8kc9/OD81j76B+0aKCPfa7jZAI5hBBCPj6aWUMIIeSDPH/+nEsoCwCZmZlISEj4T0mFXVxcuGTFQNntRM2aNZM7o+NDaWtrIzs7W2qbp6dnuQl6u3XrhmvXruHSpUvo1KkTgLIcPKtXr4apqSmMjY2RnZ0NFRUVGBkZgTGGDRs2VKkuHTt2RHR0NDcbaefOneWW9fX1xZo1a1BQUAAAKCgowL1798pt0xtFRUUoKSmBiUnZr+Lvr9pUVba2tlKzG1JTU+Hp6Yl58+ZhzJgxUmUHDhyIo0eP4sWLF2CMYfPmzRg2bFil13jx4gVev37NPT9w4ABsbW2lyjx48AB2dnYf1AbyeenYsaPUbK13vQnUAEBOTk6Vg57a2trcvwsLCyEWiys8NiMjA4MHD4K9vT2WLKl7ya0z8krhvjxObqCmvZk6Ts6wkAnUAMD/bPtgqKk9FliVfzuhbUNjBHeZTIEaQgipJRSsIYQQ8kFKS0sRGBiIVq1aQSgUokuXLhgzZgx3u8+HaNy4MXbv3o2RI0fCzs4OmzZtwp9//lmDtQb69++PqKgoLsGwWCxGbGwsmjVrJre8sbExTExMYGhoCE1NTQBlyXUTEhK4VaBsbGwwePBgWFlZwd3dvcqzSAwNDbF582b06tULrq6uyM/Ph7KystwcYvPnz4dQKISzszNsbW3RsWNH7larUaNGYd++fXITDGtrayMwMBBOTk7o2rUrVFXLv5114sSJOH78uNx9gwYNwt9//809X7RoEZ49e4ZffvmFuzVr+/btAAALCwv88MMP6NSpE1q0aAEDAwNMmDCBO9be3h4uLi7IzMxEs2bNMGrUKABlt1R5eXnB1tYWNjY2CAsL4/INAeBm61hbW1fQq0RR/PjjMri6umDSpIn47bctUkGXLVu2wMvLE6NHj5bJz3Ty5El06+YOZ2cn+Pl9jbZt25Z7ja++mgw3NzcsWLDwI7Xiwz1OL4bXinjkFsmuzd3TVgt7/MwhELwd6iflZ0LCysrqqWriZ/uB0FZ+O+tPJClFobgs6DOzjQeOdJkMPVXNj9wKQggh5eGx6t5IrqDeTBvPzs6W+lXmc1ZQUABLy7IVneLi4stNMFzVcoQQ8jm6efMmNm7cKHcVpU8hNzeXWwFp+/bt2LZtG8LDw2ulLhWRSCTo0KED/vrrr3IDWx/b/PnzYWlpKRX4IbXnU42NnJ2dsHPnLrRp00bu/kuXLmHFiuU4duwvqKioIDU1FYaGhuDz+fj777+xYMG3CA+/wgVb30hKSsKECeOxceMmtGwpu8Kls7MTOnZ0QVTUDfz55yFoaWnVmbHg9cf5mLDtGSRyRvET3HQx09tQaltUxlOMvroLg03tscTGR2Y2UX5pMSZf3wclngBbnUdCmU/JhAkhpKZV93uTZtYQAGUBmYoehBBSX9nb29daoAYA1q9fD6FQCGtra2zfvh2///57rdWlInw+H7/99ptULppPzdjYuMIkzEQxde3aFXl5edxtek2aNOGWfO/ZsycaNGggNxm5iYkJ2re3R2hoaLnn/vrrrzFy5EgMHjwIKSkpH6cB1XTyVhbGbZUN1PAAfN/PUCZQA5Tl/SplEhSIRWDvLc+dKSrAsCvbcTE9Hkbq2uBX8ZYyQgghHxdliyUAADs728oLEUIIqXELFy7EwoV17xYLed6sxFVb/P39a/X6pG4oLS3Fs2fPYGFhAaBstbOMjAzu9sOUlBQu1010dDQyMzNhbm4OAIiLi+NWX8vIyEB4eDh69fKp8HpTpkwFn8/HmDGjuYToteWPi6/wc8hLme0CHhA0uhnc2mjJPc5B1xR/u0+BRQN9qVk1KYXZGBmxHXG5LzG9lRvmtv2iyvl/CCGEfFwUrFFgdAccIYQQQuqqBQu+xZkzZ/HyZTqGDRsKTU1NXLkSAbFYjBkzApCbmws+XwANDXX89tsWNGzYEEDZst6vXr0Cn8+HmlrZvjfTzf/44w9cu3YVSkpKYAyYNGkSunZ1q7Qufn5fQyQSITExEcnJyRWuHvWx/Hg8DXuvZspsV1XiYY+fGdo1lV4lLTgpBmoCZfgYWwEAWmg1ltr/JO8Vhl/ZjueFWVhs7YNJLTt9vMoTQgipNspZU0X1MWfNxtB0bAhJBgAUNY1FsfEDCAp1sNt5LDqYNZJ7jLq6Ov3iQgghhJB6OTaqSG221393Es7fz5PZrqXGR/A3FjBuKL2c+KOcF/D6JwjKfD4ue82Uu6JTSmE2BodvxYzWHhhk2v5jVZ0QQsj/q+73CM2sUVB/Xs/Er+czwFNWR0mjZxCZPwa/uCF+6zgBbm1k73UmhBBCCCGflkQiwYjNT3EnqUhmn4G2Eo4HWEBLXfbWrNbahpjX7gs0UtGQCdRkigrQSEUDxuo6+MfjG6gK6M8BQgipi+jTWQGF3stB4NE0FDWNBb+oAQrNo8ArUcUyy5HoSYEaQgghhJBqYYyhsLCwWsdUNltZVCJBn7VPkJxZIrOvhYEKDk9rDhXlt2uFMMaQKSqA7v8vtz2tleztXSEp9xFw8zB+dxqBLgYtKVBDCCF1GH1CK5iohALM2vccJQ1eorjZHUCsBI3HrpjkbIbRDma1XT1CCCGEkM9OYWEhLC1ll/+uSFxcPDQ0NOTuyy4Qw+fneGQVSGT2dWiugT8mmnArXgGAhEmw5M5phKTex9Euk+Xe9nTo2U3MuhkMXVUN6KrIvy4hhJC6g5buViCPUovw9Y5nKJUA/BJ1qD4TQiO+E6YJ22OOW5varh4h5DMUHBwMBwcHCIVCtG3bFp6enpBIyv648PHxkbtc7qfw+vVrdO7cGUKhEMuWLcOiRYtw8OBBAEBYWBjOnj1brfM9fvwYfD4fS5cu/RjVxZIlSyASiap93I4dOzBo0KCPUCNCSG1JyRTBY0Wc3ECNj602dkw2kwrUAICYMSTkZyBLVIikAtkkxFsfR2DGzSNooq6D4C6TYdXQ+KPVnxBCSM2gmTUK4nmmCBO3PUO+SAKmJEJ+63/A+GJ8qfwlpn/RuPITEELIe9LS0uDn54cbN27AzKxsZt7Nmze5af2nT5+utbqdO3cOOjo6CA8Pl9kXFhaGvLw8dO/evcrn++OPP+Dm5oY//vgDCxcurPFE6z/88ANmz54NFRWVGj0vIeTTi429Xe6MmYKCAtjZ2ZZ77MOUQgz9NRGlsnEajOmsi7m95N+urswXYEuH4XiS90omELPm4XmsefgPWjZojH2dxsFYXafqjSGEEFJraGbNZ4wxhoKCgkofz1/mYNymR0gvSkWu1WnktwmFRD0HNkyI//U1odWdCCEfJDU1FUpKStDT0+O22dvbc58p5ubmuHv3LgDA3d0dc+bMQdeuXWFiYoLVq1fjwIEDcHV1hZmZGQ4cOMCdIyQkBPb29rC1tYWbmxvu378PoCzIIhQKMWXKFNjZ2cHKygpRUVEy9QoNDcWcOXNw5coVCIVChIaGYuzYsdiwYQNiYmKwefNm7Nq1C0KhEIGBgZW2UywWY+fOndiwYQMaNGiACxcucPuWLFmCESNGoE+fPmjXrh08PDzw+vVrueeJi4tDr1690KFDB9jZ2WHjxo0AAD8/PwCAq6srhEIh0tPTpY4rLS1Fjx494OjoCCsrK4wcORIFBQWV1psQUjs0NDQqfJQn4t9cDAqSH6iZ62MgE6gpFJdg7cN/UCwuBQCoK6nInTGjyleGbUNjHOkyiQI1hBDyGaFgzWfszf3RlT2chG1w79ceyNs+HBLldEg0M2GSb4Pggd5QElCghpDPmcXxRbA5vUxqm+f5X2BxfBFeFOVw2yZG7oXF8UW4+iqB2/bjvTOwOL4IexNvcNsOPI2CxfFFVbq2nZ0dXFxcYGpqiv79+2P16tV4/vx5ueWfPXuGsLAwREZGYtGiRbh79y4iIiJw6NAhzJw5EwCQnp6OL7/8Ejt37sTt27cxefJkDBkyhDvHvXv3MH78eMTGxmL69OlYuHChzHW8vLwQGBgILy8vxMTEwMvLi9snFArh5+eH0aNHIyYmBosWVd7WkJAQNG3aFFZWVpgwYQK2bdsmtT8yMhI7d+7E/fv3YWBggN9++03mHGKxGCNGjMDPP/+MGzdu4OrVq9i8eTNu3ryJzZs3AwAiIiIQExMDAwMDqWMFAgH27duHqKgo3L17F9ra2lyghxBSPwRHZWLS9mSw97bzeMDqocYY00VP5ph5t47h54fnEXhXdhZjqUSMgtKyWyuntuqK4C6Toff/iYcJIYR8HihYo4Aa5pvhdP+BUFOml58Q8uH4fD6OHDmCiIgIeHt748qVK7CyskJ8fLzc8oMHDwafz4exsTH09fXRr18/AICDgwNSU1NRVFSEyMhICIVC2NjYAABGjhyJ5ORkpKamAgBat24NR0dHAICLi8snyYmzbds2jB8/HgDw5Zdf4tSpU8jMfJsTomfPntDV1a2wTo8ePcK9e/cwbNgwCIVCuLq6Ijc3l5s1VBHGGNauXYv27dvD1tYWp06dQkxMTM00jhBS6zaGpuP7I2ky25X4wLYJpvARyp8NM6ONB5z1zPG1ZRep7UXiEnx1Yz8mRO7hZt2oCZRrvuKEEEI+KspZU09U9f5otcLGOO37JRpp0Jc2IfXBE1/Z23jOe34js22r80iZbQusemCBVQ+pbcPMHDHMzLFadWjTpg3atGmDr776Ct7e3jh+/Dg3U+Zdampq3L8FAgH3XCAQACi73YcxJvfWzDfb3j9HaWlptepaXenp6Th9+jRu3LiB5cuXAwBKSkqwb98+TJ06tcp1YoxBX1//g4Is+/btw8WLF3Hp0iVoaWlh/fr1uHTp0oc1iBBSp3x/JAXBUdky21WVeDg41RyWRmpS2wtKRdBQKstt1byBHg53nij1mZlXUowJkXtw5dUT9GtmBz7d6k4IIZ8tmlpRT1T1/ui9nUfCVJeWaySE/HfPnz/HlStXuOeZmZlISEhAixYtPvicLi4uiImJwYMHDwAABw4cQLNmzWBkZPSf6/uGtrY2srOl/zjy9PTE9evXZcru2rUL/fr1Q1JSEhITE5GYmIiDBw/K3ApVmdatW0NDQwO7du3itsXHx3P5bbS0tGTq9EZmZib09PSgpaWF3Nxc7Nixo1rXJoTUTVN3JskN1Gir83FqdguZQE1Sfia+uBCErY8juG3vBmoyRQUYFvEHrrx6gjHNnbHeYRCU+YKP1wBCCCEfFQVrFIytccPargIhpJ4oLS1FYGAgWrVqBaFQiC5dumDMmDHo27fvB5+zcePG2L17N0aOHAk7Ozts2rQJf/75Zw3WGujfvz+ioqK4BMNisRixsbFo1qyZTNk//vgDI0dKz0ry9vZGcnIybt68WeVrKikp4cSJE/jzzz9ha2sLKysrTJw4EYWFhQCAWbNmwcPDQ26C4dGjRyMvLw/t2rXDgAED0KVLF3mXQEpKCoRCYZXrRAipXZGP82W2Geko4ezclmiiIzsD+lHuCyQXZOFM6n2ImXQW4hdFORgUvhUxmcnwb+WOpbZ9wOfRMJ8QQj5nPMbY+7nMiBw5OTnQ0dFBdnY2tLW1a7s6AMpub7K0bAkAiIuLr/A2qKqUI4QQRXTz5k1s3LgRW7dure2qEPJZqYtjo4+pova+O9aq6q3pOsNPgqeszu1rZaSCP6c2h7JS+UGWy+nxcNQzg/p7OWjSi3Ix4PLvGGXuhK8sO39Q+wghhHxc1f3epJw1hBBCFJq9vT0FagghNeZNMKY6XFpo4PcJpjI5u25nPUeJRAwHXVMAQBeDllL73+SwMVDTwrlu06D+//lsCCGEfP5qdX7kpUuX0KdPHxgbG4PH4+HYsWNS+8eOHQsejyf16Nixo1SZ4uJiTJ8+Hfr6+tDU1ISvry+Sk5OlymRmZmLUqFHQ0dGBjo4ORo0ahaysrI/cOkIIIYQQQirm214bWyeayQRqEvMzMDR8G0ZF7ERifobMcTdfJ6HTuZ9xPu0hAFCghhBC6planVmTn58POzs7jBs3DgMHDpRbxtvbG9u3b+eeq6hIfxEFBATgxIkTOHDgAPT09DBr1iz07t0b0dHR3AojI0aMQHJyMkJCQgAAkydPxqhRo3DixImP1DJCCCGEEKIo1NXVERcXL7Nd/DIJ4hfPIDA0g6BxWV6s20kFmLIjCUVMFRPddDHD21DuOc00dNGnqQ0AwFSjkdS+8JePMf7aHkjAIOBREmFCCKmPajVY07NnT/Ts2bPCMqqqquWuApKdnY1t27Zh9+7d8PLyAgDs2bMHJiYmCA0NRY8ePfDgwQOEhITg2rVrcHZ2BgD8/vvvcHFxwaNHj9C6deuabVQtKSgo+KB9hJD6hxUXVqs8T1W98kKEEELKxePxpPLUSPKykbtzMUrulq2YVwpA2boTtMb8gI6t9TGjNx98HjDSVVfmXBImAZ/HB4/HwwphX/DAk5p1E5JyH1OiDkCNr4ydLqPRQc/so7ePEELIp1fnc9aEhYXBwMAADRs2hJubG5YtWwYDAwMAQHR0NEpKStC9e3euvLGxMaytrREREYEePXrg6tWr0NHR4QI1ANCxY0fo6OggIiKi3gRrPuT+aEJI/ZQR0FXqOU9VA8ptncHT1AbLz0HJg0iw4rdBXP1NNz51FQkhpN6R5LwGT6sReDyeVKDmjZK7V5C7cwl0pq7FcOeGUJKTSDgk5T42xl3Cbpcx0FFRl1nR6fCzW5h1KxiNVNSx12UsrBoaf9Q2EUIIqT11OljTs2dPDB48GGZmZkhISMD3338PDw8PREdHQ1VVFWlpaVBRUUGjRtJTQw0NDZGWlgYASEtL44I77zIwMODKyFNcXIzi4mLueU5OTg21quasP5teeSFCiOJSUYNm36lQde0Dvpomt1lSlI/iiBPI/+tXQFRUixUkhJD6I2//Cmh/tQri9GcygZo3Su6GQ5yeBCUDE5l9EiZB0L9hiM16jjOpDzDEzF6mTFZJIYzUtLG/0zhYNNCv8TYQQgipO+p0sGbo0KHcv62treHo6AgzMzOcOnUKAwYMKPc4xpjUdNH3E7bJK/O+5cuX44cffvjAmn98f8dmY9e1AugMP4nCprEQGT8AGNBftQ9W9XAo9zh1dbrdgZD6Tm/dpbJ/KKuCxy/7VVac/gzitKcQGJlDYGACdY9hUHMfApQUV3CmT2PHjh04efIkDh8+jMTERJw9exaTJ0/m9vv4+CAoKAgtWrSoketlZWVhy5YtmDt3bo2c71Nbt24dRowYIfeHiLouMTERjo6OePXqVW1XhZAax9MsW4ZVnPa0wnLiF4kQyAnW8Hl87HIZg9C0h1KBGsYYRBIxVAVKmNjCFUNN7aGlrFazlSeEEFLn1OpqUNXVpEkTmJmZIS4uDgBgZGQEkUiEzMxMqXLp6ekwNDTkyrx48ULmXC9fvuTKyPPtt98iOzubeyQlJdVgS/6bf1OLMPdgSlmwSUUVEt1c8FSVYS1xw4b+XaChoVHuo6IAFSGkfuCpqpc9+HxI8rKR/WsAMhcPRM6mmchcPADZvwZAkpcNHp9f5/LVJCYmYsuWLVLbTp8+XWOBGqAsWLNq1aoaO19NKy0trXD/unXrkJ7+YTMrxWLxBx1HCKmc5oBvAAACo4pzyAgMzaWeX3n5GIwxAICeqiaGmr390Y0xhqX3QjAiYjsKS0UAQIEaQghREJ9VsCYjIwNJSUlo0qQJAMDBwQHKyso4d+4cVyY1NRV3796Fq6srAMDFxQXZ2dm4fv06VyYyMhLZ2dlcGXlUVVWhra0t9agLcgrFGLE5EWLGwAQiFJlGQ6zzArpZbfD3sIqTNRNCFMebgX9FeRPeLfeheDweli9fDicnJ1hYWCA0NBTffvst2rdvDysrK9y7d48ru3v3bjg7O8Pe3h5ubm64e/euzPn8/Pxw//59CIVC+Pr6AgDMzc25su7u7pg3bx66dOmCFi1awM/Pjzv2+fPn8PT0hJWVFXr37o3evXtjw4YNcq+RlZUFoVAIR0dHAGW3zA4ZMgROTk6wtbXFokWLuPLm5uZYtGgRXF1dYWpqij179uCXX36Bk5MTWrRogbCwMABlgSZ9fX3Mnj0bzs7OsLKywj///MOd58yZM+jcuTMcHBzg7OyMS5fKZkCFhYVBKBTC398fLi4uOHr0KPbt2wdnZ2e0b98eQqEQp0+fBgAEBgYiJSUFgwYNglAoRExMDJYsWYLZs2dz19mwYQPGjh0LoGzWkre3N0aPHg1HR0dcv34dN27cgIeHBxwdHWFvb48jR47IfW3Hjh0LPz8/eHp6wszMDN988w0uXLiArl27wtzcHGvWrOHKRkVFwcXFBba2tnBycsKVK2/fc7/++itatmyJLl26YOvWrVLXKK9PCPkc8TW0wBiDwMAUytad5JZRtu4MgYEJ99m77XEEhl75A4F3/5YpK2ESfBv7F36LD4eYSVDCJB+1/oQQQuoYVotyc3PZrVu32K1btxgAtmbNGnbr1i329OlTlpuby2bNmsUiIiJYQkICu3DhAnNxcWFNmzZlOTk53Dn8/PxYs2bNWGhoKLt58ybz8PBgdnZ2rLS0lCvj7e3NbG1t2dWrV9nVq1eZjY0N6927d7Xqmp2dzQCw7OzsGmt/dYnFYtZ9VRxrN/8+s1j/J2t2MJA1PbqANd/9C3udX1xr9SKE1E2lL56yl36O5T5KXzz7z9cAwDZs2MAYY+zPP/9kGhoa7OTJk4wxxlauXMmGDx/OGGMsPDyc+fj4sKKiIsYYY5cuXWK2traMMca2b9/OBg4cyBhj7MKFC8zBwUHqGmZmZuzOnTuMMcbc3NzYwIEDWWlpKSsoKGDm5uYsIiKCMcbYgAED2P/+9z/GGGNPnz5lWlpaLCgoSKbOCQkJTE9PT2pb9+7d2cWLFxljjJWUlLAePXqw4OBg7vqzZ89mjDF2/fp1pq6uzn799VfGGGMHDx5kLi4u3HkBsB07djDGGLt69SozNDRkeXl57PHjx8zFxYX7DomLi2PGxsZMJBKxCxcuMB6Pxy5fvszV59WrV0wikXDnbdKkCROJRDL9wRhjixcvZrNmzeKeBwUFsTFjxnB9q6mpyf7991/GGGOZmZmsffv2LCUlhTHG2MuXL5mpqSlLTU2V6acxY8awTp06saKiIpafn88aN27Mxo0bx8RiMUtOTmaamposNzeXFRcXMxMTExYSEsIYY+zy5cvMyMiI5eXlsdjYWNakSROWlpbGGGPs66+/5vq+oj4hn4e6MDb6lKrTXnFuFsvaECD1mZu1IYCJ87KkykVlPGXtTv6PHU++LbW9RFzKpt04yJoeXcCGhm9j+SU0ziOEkM9ddb83azVnTVRUFLp168Y9nzlzJgBgzJgx2LRpE+7cuYNdu3YhKysLTZo0Qbdu3XDw4EFoaWlxx6xduxZKSkoYMmQICgsL4enpiR07dkAgEHBl9u7dC39/f27VKF9fX7m/ttZ1U3YlI/l1CRgkKNVOA1Mqhkp6Sxzo6YtGGiq1XT1CSB3zoXkTqutNfjF7e3vw+Xz06tULQNnsx+DgYADAX3/9hdjYWKmV+V6+fAmRSFTt6w0bNgwCgQDq6uoQCoV4/PgxXFxccOHCBaxfvx4AYGpqCk9PzyqdLz8/H//884/ULbN5eXl4+PCh3DYWFhZiyJAhXBufPHnClVNRUcGoUaMAlK08aGRkhNjYWMTExCA+Ph5du0qv1PXmFttWrVqhc+fO3PaEhASMHDkSycnJUFJSwqtXr/D06VO0bNmyyv30RufOnWFpaQkAiIiIwJMnT9Cz59uZmIwxPHr0CEZGRjLH9uvXD6qqqgCA1q1bw8fHB3w+H02bNkWjRo2QnJyMkpISqKiooEePHtz1DAwMcPv2bdy4cQO9evXibjuePHky/vzzTwBASEhIuX1iYWFR7XYSUpfwG+hAZ+paiNOTyj5rDc3lft466Joi4otZ0FF5e0tqsbgUU6IO4EzqA3Q3aoONHYZBTaD8KatPCCGkDqjVYI27u3uFU/DPnDlT6TnU1NQQFBSEoKCgcsvo6upiz549H1THuuLX0Je4/Ci/7AlfDI2H3SDRykCQb3s4mdSNW7QIIXVLdfMmfCg1tbL8CQKBgPvD/s3zN/lXGGMYP348AgMDa+x6718DkJ9QvjISiQQ8Hg83btyAsrL8P4jebeP7zyvLMcPj8cAYg7e3N3bt2iWz/9mzZ2jQoIHUtmHDhuGnn35Cv379AJR9jxUVyV+5S0lJSSoXzfvl3j03Ywy2trZVvt3o/b6W1/esnIT9b9pdnor6hJD6gDEGgYEJF6R58/9h2d0zcNAzQU9jKwCQCtQAQIFYhMe5r9C3mS3W2Q+CMl8AQgghiuezylmjqMIe5GLj+VdgPDEkKEV+6zAUtryCr+xbo7s1BWoIIbJYNfMmfGx9+vTBrl27uJkkEokEUVFRMuW0tbWRnZ39Qddwd3fHjh07AJTNzng3X8z71ygoKOCCLFpaWujSpQtWrFjBlUlJSUFycnK16yASibB3714AwPXr15GWlgZbW1t0794dISEhUnl63s2l9r7MzEyYm5sDAPbs2SOVSP/9PmrRogWioqIgkUhQUFBQbg4aAHB1dUVcXJxU38TExHzQDKc32rRpg+LiYu6cERERSE9Ph42NDbp164bTp09zCZG3bdvGHVfdPiHkc/N+EJPH4+Hyy8fY/Pgy5sYcQ26JdGBV/P85aRqpaCC4yySsdxhMgRpCCFFgdXrp7vqMMYbCwsJKy6VmieC//QkkEoZCyxiIdV6AqeXDrMgKM71lp6wTQgjw9o8ErTE/IHfnEpTcDef2KVt3htbYJVLlPrauXbvixx9/RN++fSEWi1FSUoJevXpxCX7fsLW1RevWrWFtbQ0LCwscP368ytf45ZdfMHr0aBw8eBCtWrVCp06doKOjI1NOV1cXI0eOhI2NDTQ1NREVFYW9e/di5syZsLGxAVA2G2Xz5s1o1qxZtdqpp6eH+Ph4ODs7Iy8vD/v27YOmpiYsLS2xZ88eTJw4EYWFhRCJRLC3t+cCO/La0r9/fzRt2hQuLi4wNTXl9vn7+2PcuHHQ0NDAjh07MHDgQBw+fBjt2rWDubk5hEJhud8vjRo1wokTJzBnzhzMmDEDJSUlMDU1xbFjx6rVznepqKjgyJEj8Pf3R35+PtTU1HDo0CFoamrC1tYWCxYsgKurK4yMjLhb5ABUu08IqQ+6GrTEIuuecNQ1k1rV6XVxPkZf24WvW3ZBr6bW0FXVRN7BnyC6fQmS16lo+N1+KDV9extk7q4fUPrsIcDjgSdQgka/aVBp4yR1LdG/0chZNwWaQ2ZB3b3s1k3RnXAUnNyC0pR4qLsPgebAgHLr+nqhL7SnrIFS05ZgJcXI3boAUFaF1rhA8AT0JwQhhHxsPPapflb9zOXk5EBHRwfZ2dk1sjJUQUEBLC2rl3uAt3I80IBBtVAP9wdPh6oS3b9MCJHFiv//D3VlVfD4ZRMo5eVNYBIJUFJc55bv/lCFhYVQVlaGkpISUlNT0aFDB5w/fx6tW7f+JNdPTEyEo6MjXr169UmuR0htq+mxUV33oe0tFpfiVXEemmo0lLs/rTAHIyK249/cdMxt6wX/1mX5HEviboKv3xTZP03igiZvSApywdcoy+FYmvQI2b9Mhe7qc1wAXlKUj5xfpoLXoBFUrFy4YI34xVOwkmIUR58HSourFKzh6xohZ9MsKBmZQ3PYPO57hRBCSPVU93uEwuKfESYoBb9EA2e8x1OghhBSroyA/0/YqqIGzb5ToerSWypvgqQwD8VXTyL/r18BURH0N92oxdrWnLi4OIwePRqMMZSUlGDx4sWfLFBDCCHyFIpLMPn6PjzKeYHgLpPQTKOR1P6k/EwMu/IHnha8xmJrH0xq+fbWVWVL+3LP+yZQA5R9puO9WZL5h9dC/YtREN25LLVdYFiWy6w4JgyoON1W2bnzspC78weotHWCZv/plR9ACCGkxlCwpg6Ijb0NDQ0NufsKCgpgZ2fLPf/JajhaNmr4iWpGCPmsiYqQf+hnFBzfBOW2zuBpaoPl56DkQSRYcUFt167G2draIiYmptaub25uTrNqCCFS+HibaFskEUvti899iWFX/sCLolysFPbDSPMO1Tp3/tEgFN88D1aQC62vVnGzakR3r4AV5kHV3lMmWFNdub/Ph1rnftDsN+0/nYcQQkj1UbCmDtDQ0Cg3WPOuYTo9MbSd5SeoESHkc6a3rmor/RBCCPm4VAVK+N15JDJFBTBWl86hFf36GV4V5yHIcTD6NbOr9rk1+0+HZv/pED2IREHwL1CevQ1MVIT8Y79Cx39DjdRfxbozim+eh1rXQRDoUq5EQgj5lChY8xn5n3v1fnEhhCimQnH1UpFVHiomhBDyodQFylB/J1DzZrn7oWYO6KjfHGaauv/p/CptnZF/cDXEz+PBSoohyX6FrJVjAQCS/CyI7oRDkpsJzT5fVb/uX3wJwT0LZK/1g86MzRSwIYSQT4iCNYQQUo8wxqqdvDw5+fknWxWKEEIU2ZWXj/Hrv5fwu/MIaCqpflCgholLIclIgcCgbJW4ksR7kORmgq/fFHxNbeitPsuVzd25BEpm7bgEwx9Co/togMdD9pqvygI2ek0++FyEEEKqjoI1hBBSj5S3ZHNlx1TlVkxCCCEfLjTtIb66vh8qfAES8jJg3dC4wvJ5+1eWLd2dk4Hs9VPBU9WAbuBRQCJB7s4fwArzAL4APFU1aE1aAb5m5SuLiP6NRt72RWBF+QBjKI46B81hc6Fq51bhcRpfjAKPx///gM0mCPSbVqvthBBCqo+W7q6ij7l0d1xcfIUJhqtSjhBCAOnPjKqizxZCyIegpbur7njybfhHH4K2shr2uo6FTUMKdhBCiKKp7vcI/xPUiRBCSC2Ijb2NuLh4uY/Y2Ns1co2//voLbdu2hVAoxJ07d2rknB+Lj48PHj9+/MmuN3bsWGzYUJbkc9GiRTh48GCNnTsrKwurVq2qsMzixYvRtm1bODs719h1f/vtN7Rp0wZCoRAZGRlS+95tb3WsW7cO6enp3PMlS5Zg9uzZ/7mu5ubmuHv37n8+DyH/1f7EKEyN+hN6qpo40mUSBWoIIYRUCd0GVQcUFJS/hG5F+wghpCJVXWnuv9i8eTMCAwMxePDgGj+3RCIBAPD5NfO7wunTp2vkPB8iMDBQ7vYPbeObYM3cuXPLLbNq1So8e/YMjRs3rta5K7Ju3Trs3r0bHTrUXML7devWwcvLCwYGBjV2TkLqCpGkFNufXIWJRkPs7zT+PycTJoQQojhoZk0dYGdnC0vLlnIfdna2tV09QgiRy9/fH5cvX8a8efPg6uoKALhx4wY8PDzg6OgIe3t7HDlyRO6x2dnZmDhxImxsbGBnZ4fx48cDKJtVMWrUKAwYMABCoRCpqanYvXs3bGxsYGtri169euH58+cAgGvXrsHBwQFCoRDW1tbYtGkTAGDr1q1o164dhEIhbGxsEBkZCUB6poW7uzvmzZuHLl26oEWLFvDz8+Pq9vz5c3h6esLKygq9e/dG7969qzRj5M1xtra26Nu3L169esXte3fWibw2njlzBp07d4aDgwOcnZ1x6dLb5de3b98OoVAIOzs7ODo6IjExEX5+fsjKyoJQKISjo6NMXVxdXVFUVARPT0/4+/sDAHbv3g1nZ2fY29vDzc2t3FknUVFRcHFxga2tLZycnHDlyhUAwKBBg/D48WOMGjUKgwYNkntsbGwsPD090aZNG4wdOxbFxcUAgBcvXqB///6wsbGBtbU1tmzZAqAsiJWSkoJBgwZBKBQiJiYGAJCSkoI+ffqgXbt28PDwwOvXr+Vez9zcHN9++y26du2Kli1bYs2aNVL7jxw5AldXVzRv3hxLly7ltq9ZswYdOnRA+/bt4eTkxL1HCgsLMXToULRr1w52dnbo3r07d0x5/Vfe+5AQAFDhK2Gv6zgc6TKJAjWEEEKqh5Eqyc7OZgBYdnZ2jZwvPz+fGRs3qdYjPz+/Rq5NCKm/3v1sqegzo6rlKuPm5sZOnDjBGGMsMzOTtW/fnqWkpDDGGHv58iUzNTVlqampMseNHTuWTZs2jYnFYsYYY+np6YwxxhYvXsyaNm3KXrx4wRhj7M6dO8zQ0JAlJyczxhhbunQp8/HxYYwx5uvry/bu3cud8/Xr14wxxrS1tdnz588ZY4yJRCKWm5vLGGPMzMyM3blzh6v3wIEDWWlpKSsoKGDm5uYsIiKCMcbYgAED2P/+9z/GGGNPnz5lWlpaLCgoqNK+GDBgAFuyZAljjLHHjx+zBg0acMeNGTOG+/f7bXz8+DFzcXHhvl/i4uKYsbExE4lE7MKFC6xFixZcn+bn57P8/HyWkJDA9PT0KqwPAK7t4eHhzMfHhxUVFTHGGLt06RKztbWVOaa4uJiZmJiwkJAQxhhjly9fZkZGRiwvL0+mD983ZswYZmNjw3Jzc1lpaSnr06cPW7lyJWOMsSFDhrD58+czxhh78eIFa9asGYuMjJR7zsWLFzMLCwuWkZHBGGNs6NCh7Mcff5R7TTMzMzZu3DjG2Nv327Vr17h9AQEBjLGy95e2tjb3PnrzfmOMsatXrzIrKyvGGGPBwcHsiy++4Pa9qUNF/Vfe+1AR1PTYqK5TtPYSQgipWdX9HqHboGqJuro64uLiZbaLXyZDnP4UAgMzCBo3kzmGEELqqoiICDx58gQ9e/bktjHG8OjRIxgZGUmVPXnyJKKjo7nbf969Vad3797cLTEXLlxA79690bRpWY6HKVOmYOnSpWCMoVu3bli6dCni4+Ph4eGBzp07AwA8PDwwevRo9OnTBz179kSrVq3k1nfYsGEQCARQV1eHUCjE48eP4eLiggsXLmD9+vUAAFNTU3h6elap/e8eZ2FhUeFx77YxJCQE8fHx6Nq1q1SZpKQknDp1CqNHj0aTJmVL5X7obW1//fUXYmNjpfLXvHz5EiKRCCoqKty2R48eQUVFBT169AAAdO7cGQYGBrh9+zZcXFwqvc7QoUPRoEEDAMD48eOxceNGzJ07F6GhoYiNjQUAGBgYYMCAATh//jycnJzknqdnz57Q1S2bheDi4lJhPqQJEyYAAPT19dG/f3+cP3+ea+fIkSMBlL2/LCwskJCQgKZNm+LWrVtYtmwZMjIyoKSkhPv370MkEsHOzg4PHz7ElClT4ObmBh8fn0r7r7z3ISGEEELIf0HBmlrC4/FkBt2MMfDMWgFmrd4+5/Fqo3qEEFJtjDHY2tpK3cLzId78sf/mnO9+Dr7774CAAPj6+uL8+fNYsGABrK2tsXHjRgQHByM6OhphYWHw8fHB0qVLMWzYMJnrqKmpcf8WCAQoLS2Ve52P4f02ent7Y9euXR/teowxjB8/vtzcOe+Wk9f2D+2P8l67ys5Z0WtTnWvKO49IJMLAgQMRFhYGBwcHbmUGkUgECwsL3L9/H//88w9CQ0Mxd+5cxMTEVNh/5b0PCSGEEEL+C8pZU4dUZyBLCCF1jaurK+Li4vDPP/9w22JiYiASiWTK+vr6YvXq1VyC3ZcvX8o9p6enJ06fPo20tDQAZQmNPT09wePx8OjRI1hYWGDSpElYsGABrl27htLSUjx+/BiOjo6YPXs2Bg0ahOvXr1erHe7u7tixYweAstkt77bn6NGjGD16tNzjPDw88McffwAAEhMTcf78+Spdr3v37ggJCZHKIfOmzn369MGuXbu49hcUFKCgoADa2tooKCiochDjzXmSkpIAlCU2joqKkinXpk0bFBcXc22OiIhAeno6bGxsqnSdQ4cOIT8/H2KxGNu3b4eXlxcAwMvLi8tT8/LlSxw9ehQeHh4AAG1tbWRnZ1fp/PJs374dAPD69WscO3as0plQRUVFKCkpgYmJCQAgKCiI25ecnAwejwdfX1/89NNPYIwhKSmpwv6T9z4khBBCCPmvaGYNIYTUU596pblGjRrhxIkTmDNnDmbMmIGSkhKYmpri2LFjMmXXrl2LGTNmwNraGioqKujQoQN+//13mXJWVlZYvnw5l+jVxMSE+6M/KCgIFy5cgIqKCgQCAX7++WeIxWKMGzcOmZmZUFJSQuPGjbk/5qvql19+wejRo3Hw4EG0atUKnTp1go6ODgAgPj4e2traFR536NAhtGrVigtUVMbS0hJ79uzBxIkTUVhYCJFIBHt7e+zduxddu3bFd999h+7du4PH40FFRQWHDx+GmZkZRo4cCRsbG2hqasoNvLyra9eu+PHHH9G3b1+IxWKUlJSgV69eMsmJVVRUcOTIEfj7+yM/Px9qamo4dOgQNDU1q9SWrl27ol+/fkhKSkLHjh0xffp0AMD69evh5+cHW1tbSCQSLFy4kLsFyt/fH+PGjYOGhgYXJKsOMzMzdOnSBampqfD39y/31qo3tLW1ERgYCCcnJ5iamsLX15fbd+fOHcyfPx+MMUgkEowaNQq2tmWJ/svrP3nvQ0IIIYSQ/4rHGGO1XYnPwZtp0tnZ2eUO1AkhpLYVFBTA0rJltY6Ji4v/6Et8f04KCwuhrKwMJSUlpKamokOHDjh//jxat26NgQMH4ueff4a5uXltV5OgbDWokydPwtrauraropBqYmx06dIlrF69GtHR0UhNTcXRo0fRr18/bv+SJUtw4MABJCUlQUVFBQ4ODli2bJlU/qDi4mLMnj0b+/fvR2FhITw9PbFx40Y0a/Y2919mZib8/f1x/PhxAGWz+4KCgtCwYcNP2l5CCCGKq7rfI3QbFCGEEPKOuLg4ODo6ws7ODp6enli8eDFat24NoGwpaArUEFJz8vPzYWdnxy1t/75WrVphw4YNuHPnDsLDw2Fubo7u3btL3ToZEBCAo0eP4sCBAwgPD0deXh569+4NsVjMlRkxYgRiYmIQEhKCkJAQxMTEYNSoUR+9fYQQQsiHopk1VUS/phBCPgeMMWRkZFTrGD09PcqRRQiptpoeG/F4PJmZNeVdMzQ0FJ6ensjOzkbjxo2xe/duDB06FACQkpICExMTnD59Gj169MCDBw/Qrl07XLt2jZuRc+3aNbi4uODhw4dcMPZTt5cQQohiqe73COWsIYSQeoTH40FfX7+2q0EIITVOJBJhy5Yt0NHRgZ2dHQAgOjoaJSUlXF4rADA2Noa1tTUiIiLQo0cPXL16FTo6OlK3TnXs2BE6OjqIiIiocrCGEEII+ZQoWEMIIYQQQuqskydPYtiwYSgoKECTJk1w7tw5LiidlpYGFRUVNGrUSOoYQ0NDbhW1tLQ0GBgYyJzXwMCAKyNPcXExiouLuec5OTk10RxCCCGkSihnDSGEEEIIqbO6deuGmJgYREREwNvbG0OGDEF6enqFxzDGpG7vlHer5/tl3rd8+XLo6OhwjzfLvRNCCCGfAgVrCCGEEEJInaWpqYmWLVuiY8eO2LZtG5SUlLBt2zYAgJGREUQiETIzM6WOSU9Ph6GhIVfmxYsXMud9+fIlV0aeb7/9FtnZ2dwjKSmpBltFCCGEVIyCNYQQQggh5LPBGONuT3JwcICysjLOnTvH7U9NTcXdu3fh6uoKAHBxcUF2djauX7/OlYmMjER2djZXRh5VVVVoa2tLPQghhJBPhXLWEEIIIYSQWpGXl4f4+HjueUJCAmJiYqCrqws9PT0sW7YMvr6+aNKkCTIyMrBx40YkJydj8ODBAAAdHR1MmDABs2bNgp6eHnR1dTF79mzY2NjAy8sLANC2bVt4e3tj0qRJ+O233wAAkydPRu/evSm5MCGEkDqLgjWEEEIIIaRWREVFoVu3btzzmTNnAgDGjBmDzZs34+HDh9i5cydevXoFPT09dOjQAZcvX4aVlRV3zNq1a6GkpIQhQ4agsLAQnp6e2LFjBwQCAVdm79698Pf351aN8vX1xYYNGz5RKwkhhJDq4zHGWG1X4nNQ3TXRCSGEEELqM0UbGylaewkhhNSs6n6P0MyaKnoT06JlGwkhhBBC3o6JFOV3PxoLEkII+S+q+71JwZoqys3NBQBatpEQQggh5B25ubnQ0dGp7Wp8dDQWJIQQUhOq+r1Jt0FVkUQiQUpKCrS0tMDj8T7adXJycmBiYoKkpCSFn2JLfVGG+qEM9UMZ6ocy1A9vUV+UoX4o8yn7gTGG3NxcGBsbg8+v/wuMfshYkN6X0qg/pFF/vEV9IY3646361BfV/d6kmTVVxOfz0axZs092PVoi8i3qizLUD2WoH8pQP5ShfniL+qIM9UOZT9UPijCj5o3/Mhak96U06g9p1B9vUV9Io/54q770RXW+N+v/zyCEEEIIIYQQQgghnxEK1hBCCCGEEEIIIYTUIRSsqWNUVVWxePFiqKqq1nZVah31RRnqhzLUD2WoH8pQP7xFfVGG+qEM9UPdQq+HNOoPadQfb1FfSKP+eEuR+4ISDBNCCCGEEEIIIYTUITSzhhBCCCGEEEIIIaQOoWANIYQQQgghhBBCSB1CwRpCCCGEEEIIIYSQOoSCNXXMxo0b0bx5c6ipqcHBwQGXL1+u7Sp9VMuXL0eHDh2gpaUFAwMD9OvXD48ePZIqwxjDkiVLYGxsDHV1dbi7u+PevXu1VONPY/ny5eDxeAgICOC2KUo/PH/+HF9++SX09PSgoaEBoVCI6Ohobr8i9ENpaSm+++47NG/eHOrq6rCwsEBgYCAkEglXpr72w6VLl9CnTx8YGxuDx+Ph2LFjUvur0u7i4mJMnz4d+vr60NTUhK+vL5KTkz9hK/67ivqhpKQE8+bNg42NDTQ1NWFsbIzRo0cjJSVF6hz1vR/e99VXX4HH42HdunVS2xWlHx48eABfX1/o6OhAS0sLHTt2xLNnz7j99aEfPkeKNq4rT1XGe4pK3phP0VQ29lMUVRn/1Wc1MQasbyhYU4ccPHgQAQEBWLhwIW7duoUuXbqgZ8+eUoOt+ubixYuYOnUqrl27hnPnzqG0tBTdu3dHfn4+V2bVqlVYs2YNNmzYgBs3bsDIyAhffPEFcnNza7HmH8+NGzewZcsW2NraSm1XhH7IzMxEp06doKysjL///hv379/Hzz//jIYNG3JlFKEfVq5cic2bN2PDhg148OABVq1ahdWrVyMoKIgrU1/7IT8/H3Z2dtiwYYPc/VVpd0BAAI4ePYoDBw4gPDwceXl56N27N8Ri8adqxn9WUT8UFBTg5s2b+P7773Hz5k0EBwfj33//ha+vr1S5+t4P7zp27BgiIyNhbGwss08R+uHx48fo3Lkz2rRpg7CwMMTGxuL777+HmpoaV6Y+9MPnRhHHdeWpynhPEZU35lMkVRn7KYqqjP/qs5oYA9Y7jNQZTk5OzM/PT2pbmzZt2Pz582upRp9eeno6A8AuXrzIGGNMIpEwIyMjtmLFCq5MUVER09HRYZs3b66tan40ubm5zNLSkp07d465ubmxb775hjGmOP0wb9481rlz53L3K0o/9OrVi40fP15q24ABA9iXX37JGFOcfgDAjh49yj2vSruzsrKYsrIyO3DgAFfm+fPnjM/ns5CQkE9W95r0fj/Ic/36dQaAPX36lDGmWP2QnJzMmjZtyu7evcvMzMzY2rVruX2K0g9Dhw7lPh/kqY/98DmgcV353h/vKaLyxnyKprKxnyKpbPynSD5kDFgf0cyaOkIkEiE6Ohrdu3eX2t69e3dERETUUq0+vezsbACArq4uACAhIQFpaWlS/aKqqgo3N7d62S9Tp05Fr1694OXlJbVdUfrh+PHjcHR0xODBg2FgYID27dvj999/5/YrSj907twZ58+fx7///gsAiI2NRXh4OHx8fAAoTj+8ryrtjo6ORklJiVQZY2NjWFtb1+u+yc7OBo/H436JVJR+kEgkGDVqFObMmQMrKyuZ/YrQDxKJBKdOnUKrVq3Qo0cPGBgYwNnZWWr6uCL0Q11D47qKvT/eU0TljfkUTWVjP0VS2fhPkSnq2JeCNXXEq1evIBaLYWhoKLXd0NAQaWlptVSrT4sxhpkzZ6Jz586wtrYGAK7titAvBw4cwM2bN7F8+XKZfYrSD0+ePMGmTZtgaWmJM2fOwM/PD/7+/ti1axcAxemHefPmYfjw4WjTpg2UlZXRvn17BAQEYPjw4QAUpx/eV5V2p6WlQUVFBY0aNSq3TH1TVFSE+fPnY8SIEdDW1gagOP2wcuVKKCkpwd/fX+5+ReiH9PR05OXlYcWKFfD29sbZs2fRv39/DBgwABcvXgSgGP1Q19C4rnzyxnuKpqIxn6KpbOynSCob/ykyRR37KtV2BYg0Ho8n9ZwxJrOtvpo2bRpu376N8PBwmX31vV+SkpLwzTff4OzZs1I5Bt5X3/tBIpHA0dERP/74IwCgffv2uHfvHjZt2oTRo0dz5ep7Pxw8eBB79uzBvn37YGVlhZiYGAQEBMDY2BhjxozhytX3fijPh7S7vvZNSUkJhg0bBolEgo0bN1Zavj71Q3R0NH755RfcvHmz2m2qT/3wJvFk3759MWPGDACAUChEREQENm/eDDc3t3KPrU/9UFcp6ud0RSoa7ymCqo75FEVVx36KoKrjP0WmaJ+pNLOmjtDX14dAIJCJDKanp8tEEOuj6dOn4/jx47hw4QKaNWvGbTcyMgKAet8v0dHRSE9Ph4ODA5SUlKCkpISLFy9i/fr1UFJS4tpa3/uhSZMmaNeundS2tm3bcskYFeX9MGfOHMyfPx/Dhg2DjY0NRo0ahRkzZnC/wClKP7yvKu02MjKCSCRCZmZmuWXqi5KSEgwZMgQJCQk4d+4cN6sGUIx+uHz5MtLT02Fqasp9bj59+hSzZs2Cubk5AMXoB319fSgpKVX62Vnf+6GuUfRxXXnKG+8pksrGfIqW9LuysZ8iqWz8p8gUdexLwZo6QkVFBQ4ODjh37pzU9nPnzsHV1bWWavXxMcYwbdo0BAcH459//kHz5s2l9jdv3hxGRkZS/SISiXDx4sV61S+enp64c+cOYmJiuIejoyNGjhyJmJgYWFhYKEQ/dOrUSWYpz3///RdmZmYAFOf9UFBQAD5f+uNZIBBwv6ArSj+8ryrtdnBwgLKyslSZ1NRU3L17t171zZtATVxcHEJDQ6Gnpye1XxH6YdSoUbh9+7bU56axsTHmzJmDM2fOAFCMflBRUUGHDh0q/OxUhH6oaxR1XFeeysZ7iqSyMZ9AIKjtKn5SlY39FEll4z9FpqhjX1oNqg45cOAAU1ZWZtu2bWP3799nAQEBTFNTkyUmJtZ21T6ar7/+muno6LCwsDCWmprKPQoKCrgyK1asYDo6Oiw4OJjduXOHDR8+nDVp0oTl5OTUYs0/vvdXBlCEfrh+/TpTUlJiy5YtY3FxcWzv3r1MQ0OD7dmzhyujCP0wZswY1rRpU3by5EmWkJDAgoODmb6+Pps7dy5Xpr72Q25uLrt16xa7desWA8DWrFnDbt26xa1yVJV2+/n5sWbNmrHQ0FB28+ZN5uHhwezs7FhpaWltNavaKuqHkpIS5uvry5o1a8ZiYmKkPjuLi4u5c9T3fpDn/dWgGFOMfggODmbKyspsy5YtLC4ujgUFBTGBQMAuX77MnaM+9MPnRhHHdeWpynhPkSnyalBVGfspiqqM/+qzmhgD1jcUrKljfv31V2ZmZsZUVFSYvb19vV/SEIDcx/bt27kyEomELV68mBkZGTFVVVXWtWtXdufOndqr9Cfy/he3ovTDiRMnmLW1NVNVVWVt2rRhW7ZskdqvCP2Qk5PDvvnmG2ZqasrU1NSYhYUFW7hwodQf4vW1Hy5cuCD3M2HMmDGMsaq1u7CwkE2bNo3p6uoydXV11rt3b/bs2bNaaM2Hq6gfEhISyv3svHDhAneO+t4P8sgL1ihKP2zbto21bNmSqampMTs7O3bs2DGpc9SHfvgcKdq4rjxVGe8pMkUO1jBW+dhPUVRl/Fef1cQYsL7hMcZYzc/XIYQQQgghhBBCCCEfgnLWEEIIIYQQQgghhNQhFKwhhBBCCCGEEEIIqUMoWEMIIYQQQgghhBBSh1CwhhBCCCGEEEIIIaQOoWANIYQQQgghhBBCSB1CwRpCCCGEEEIIIYSQOoSCNYQQQgghhBBCCCF1CAVrCCGEEEIIIYQQQuoQCtYQQoiC6dq1K/bt21cr1x40aBDWrFlTK9cmhBBCSN1GYxRC3qJgDSGEKJCTJ08iLS0Nw4YNk9p+69YtDB06FE2aNIGqqirMzMzQu3dvnDhxAowxAEBiYiJ4PB73aNSoEbp27YqLFy9W+fqLFi3CsmXLkJOTU6PtIoQQQsjnjcYohEijYA0hhFRAJBLVdhVk/Jc6rV+/HuPGjQOf//bj/6+//kLHjh2Rl5eHnTt34v79+zh06BD69euH7777DtnZ2VLnCA0NRWpqKi5evAhtbW34+PggISGhSte3tbWFubk59u7d+8FtIIQQQgiNUWiMQuo7CtYQQhSGu7s7pk2bhmnTpqFhw4bQ09PDd999x/0qAwDm5uZYunQpxo4dCx0dHUyaNAkAEBERga5du0JdXR0mJibw9/dHfn4+d9zGjRthaWkJNTU1GBoaYtCgQdy+w4cPw8bGBurq6tDT04OXlxd3rLu7OwICAqTq2a9fP4wdO/Y/1+l9r169QmhoKHx9fblt+fn5mDBhAnr16oVTp06he/fuaNGiBZycnDBx4kTExsZCR0dH6jx6enowMjKCra0tfvvtNxQUFODs2bPIyMjA8OHD0axZM2hoaMDGxgb79++XqYevr6/c7YQQQoiiojEKjVEIeR8FawghCmXnzp1QUlJCZGQk1q9fj7Vr12Lr1q1SZVavXg1ra2tER0fj+++/x507d9CjRw8MGDAAt2/fxsGDBxEeHo5p06YBAKKiouDv74/AwEA8evQIISEh6Nq1KwAgNTUVw4cPx/jx4/HgwQOEhYVhwIABUoOvqqhuneQJDw+HhoYG2rZty217M4CZO3duucfxeLxy92loaAAASkpKUFRUBAcHB5w8eRJ3797F5MmTMWrUKERGRkod4+TkhOvXr6O4uLiqzSeEEELqPRqj0BiFECmMEEIUhJubG2vbti2TSCTctnnz5rG2bdtyz83MzFi/fv2kjhs1ahSbPHmy1LbLly8zPp/PCgsL2ZEjR5i2tjbLycmRuWZ0dDQDwBITE8ut0zfffCO1rW/fvmzMmDH/qU7yrF27lllYWEhtW7FiBQPAXr9+zW27fv0609TU5B4nTpxgjDGWkJDAALBbt24xxhjLy8tjX331FRMIBOz27dtyr+nj48NmzZoltS02NrbCPiGEEEIUDY1RaIxCyPuUai9MRAghn17Hjh2lfoVxcXHBzz//DLFYDIFAAABwdHSUOiY6Ohrx8fFS9zAzxiCRSJCQkIAvvvgCZmZmsLCwgLe3N7y9vdG/f39oaGjAzs4Onp6esLGxQY8ePdC9e3cMGjQIjRo1qla9q1und3+ZeqOwsBBqamqVXsvW1hYxMTEAAEtLS5SWlkrtd3V1BZ/PR0FBAZo0aYIdO3bAxsYGYrEYK1aswMGDB/H8+XMUFxejuLgYmpqaUserq6sDAAoKCqrUdkIIIUQR0BiFxiiEvIuCNYQQ8p73v7glEgm++uor+Pv7y5Q1NTWFiooKbt68ibCwMJw9exaLFi3CkiVLcOPGDTRs2BDnzp1DREQEzp49i6CgICxcuBCRkZFo3rw5+Hy+zHTjkpKS/1wnefT19ZGZmSm1zdLSEgDw6NEjdOzYEQCgqqqKli1byj0HABw8eBDt2rXj7ql/4+eff8batWuxbt062NjYQFNTEwEBATLJBl+/fg0AaNy4cbnXIIQQQogsGqPQGIUoDspZQwhRKNeuXZN5bmlpyf1iJY+9vT3u3buHli1byjxUVFQAAEpKSvDy8sKqVatw+/ZtJCYm4p9//gFQdj91p06d8MMPP+DWrVtQUVHB0aNHAZQNBlJTU7lricVi3L17t9J2VKVO72vfvj3S0tKkBkPdu3eHrq4uVq5cWek13zAxMUGLFi2kBkEAcPnyZfTt2xdffvkl7OzsYGFhgbi4OJnj7969i2bNmkFfX7/K1ySEEELqOxqj0BiFkHdRsIYQolCSkpIwc+ZMPHr0CPv370dQUBC++eabCo+ZN28erl69iqlTpyImJgZxcXE4fvw4pk+fDgA4efIk1q9fj5iYGDx9+hS7du2CRCJB69atERkZiR9//BFRUVF49uwZgoOD8fLlS24KsIeHB06dOoVTp07h4cOHmDJlCrKysiptR2V1kqd9+/Zo3Lgxrly5wm1r0KABtm7dilOnTqFXr144c+YMnjx5gtu3b2PVqlUAUOEg8V0tW7bkfqF78OABvvrqK6SlpcmUu3z5Mrp3716lcxJCCCGKgsYoNEYh5F10GxQhRKGMHj0ahYWFcHJygkAgwPTp0zF58uQKj7G1tcXFixexcOFCdOnSBYwxtGjRAkOHDgUANGzYEMHBwViyZAmKiopgaWmJ/fv3w8rKCg8ePMClS5ewbt065OTkwMzMDD///DN69uwJABg/fjxiY2MxevRoKCkpYcaMGejWrVul7aisTvIIBAKMHz8ee/fuRe/evbnt/fv3R0REBFauXInRo0fj9evX0NHRgaOjIw4cOCBVtiLff/89EhIS0KNHD2hoaGDy5Mno168fsrOzuTJFRUU4evQozpw5U6VzEkIIIYqCxig0RiHkXTz2/o2IhBBST7m7u0MoFGLdunW1XZVa8+LFC1hZWSE6OhpmZmaf/Pq//vor/vrrL5w9e/aTX5sQQgipq2iMQmMUQt5Ht0ERQogCMTQ0xLZt2/Ds2bNaub6ysjKCgoJq5dqEEEIIqbtojEKINLoNihBCFEzfvn1r7dqVTecmhBBCiOKiMQohb9FtUIQQQgghhBBCCCF1CN0GRQghhBBCCCGEEFKHULCGEEIIIYQQQgghpA6hYA0hhBBCCCGEEEJIHULBGkIIIYQQQgghhJA6hII1hBBCCCGEEEIIIXUIBWsIIYQQQgghhBBC6hAK1hBCCCGEEEIIIYTUIRSsIYQQQgghhBBCCKlDKFhDCCGEEEIIIYQQUof8H5qI85xFQjGLAAAAAElFTkSuQmCC", + "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/input.yaml b/examples/example_13/input.yaml new file mode 100644 index 0000000..8c9742e --- /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 0000000..5fede24 --- /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 0000000..74fa202 --- /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 0000000000000000000000000000000000000000..a4d5809effc38b8ca6e9507ff627fb0b45da18de GIT binary patch literal 155305 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.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`. - The two runners are stepped sequentially in the same Python process (no MPI coupling, no - threads); with `queue.cores > 1` each cell's `lmp` gets the full core count in turn. + 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, diff --git a/calphy/dcci.py b/calphy/dcci.py index 18c4ac3..f5e91b4 100644 --- a/calphy/dcci.py +++ b/calphy/dcci.py @@ -42,6 +42,7 @@ import math import shutil import time +from concurrent.futures import ThreadPoolExecutor import numpy as np import yaml @@ -250,9 +251,43 @@ def __init__(self, calculation=None, simfolder=None, log_to_screen=False): ) 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): """ @@ -268,6 +303,7 @@ def _cell_calculation(self, phase): # 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"): @@ -307,19 +343,21 @@ 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``. """ - for phase in self.CELLS: + 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.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): + 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. + 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) @@ -337,7 +375,7 @@ def _open_cell(self, phase, lam, p_rs, conf, direction, iteration): 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, np.random.randint(1, 10000)) + % (self.t0, seed) ) lmp.command( @@ -403,7 +441,8 @@ def _read_block(self, phase, lmp, direction, iteration, k): def _check_phases(self, lmps, direction, iteration, tag): """Melt/freeze checks on both cells (raise MeltedError / SolidifiedError).""" - for phase in self.CELLS: + + def check(phase): job = self.jobs[phase] snapshot = "traj.dcci.%s_%d.%s.dat" % (direction, iteration, tag) job.dump_current_snapshot(lmps[phase], snapshot) @@ -412,6 +451,8 @@ def _check_phases(self, lmps, direction, iteration, tag): 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 @@ -460,10 +501,12 @@ def run_sweep(self, direction="forward", iteration=1): lam, self.t0 / lam) ) - lmps = { - phase: self._open_cell(phase, lam, p_rs_start, confs[phase], direction, iteration) - for phase in self.CELLS - } + 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) @@ -475,15 +518,16 @@ def run_sweep(self, direction="forward", iteration=1): 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 - for phase in self.CELLS: - lmps[phase].command( - lambda_ramp_command("lam", lam, lam_pred, k * self.n_block, self.n_block) - ) - lmps[phase].command( - "run %d start 0 stop %d" % (self.n_block, n_blocks * self.n_block) - ) + 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) @@ -537,7 +581,8 @@ def run_sweep(self, direction="forward", iteration=1): if self.calc.n_print_steps > 0: lmps[phase].command("undump d1") self._check_phases(lmps, direction, iteration, "end") - for phase in self.CELLS: + + def finish(phase): conf = os.path.join( self.jobs[phase].simfolder, "conf.dcci.%s_%d.data" % (direction, iteration) ) @@ -545,6 +590,8 @@ def run_sweep(self, direction="forward", iteration=1): 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( diff --git a/calphy/input.py b/calphy/input.py index bd0b53d..dfa6d0b 100644 --- a/calphy/input.py +++ b/calphy/input.py @@ -524,6 +524,18 @@ class DynamicClausiusClapeyron( ), ), ] + 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"): diff --git a/docs/source/inputfile.md b/docs/source/inputfile.md index 139f695..d6b3252 100644 --- a/docs/source/inputfile.md +++ b/docs/source/inputfile.md @@ -186,6 +186,8 @@ points at where it belongs. ``` ```{grid-item} [](hysteresis_tolerance) ``` +```{grid-item} [](parallel_cells) +``` ```` ### `composition_scaling` @@ -1959,6 +1961,7 @@ dcci: 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 @@ -1969,8 +1972,10 @@ 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)`. Each block -is a point `T = T0/λ`, `P = P_RS/λ` on the coexistence line. A backward sweep +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 @@ -2071,3 +2076,23 @@ the difference is the hysteresis of the integration and is reported in 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/tests/test_dcci_driver.py b/tests/test_dcci_driver.py index 70f2d42..5f66b71 100644 --- a/tests/test_dcci_driver.py +++ b/tests/test_dcci_driver.py @@ -75,9 +75,10 @@ def read_timeseries(self, name, usecols=None): @pytest.fixture -def driver(tmp_path, monkeypatch): +def driver(tmp_path, monkeypatch, request): monkeypatch.chdir(tmp_path) runners = {} + overrides = getattr(request, "param", {}) def fake_create_object(calc, directory): r = FakeRunner(directory) @@ -98,7 +99,10 @@ def fake_solid_fraction(path): monkeypatch.setattr(Liquid, "run_averaging", fake_averaging) monkeypatch.setattr(ph, "find_solid_fraction", fake_solid_fraction) - calc = Calculation(**BASE) + 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 @@ -267,3 +271,38 @@ def test_integrate_dcci_hysteresis_and_error(tmp_path): 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 index a658b68..abf4182 100644 --- a/tests/test_dcci_input.py +++ b/tests/test_dcci_input.py @@ -51,6 +51,7 @@ def test_dcci_block_defaults(build): 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): @@ -61,6 +62,22 @@ def test_dcci_block_overrides_and_hints(build): 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]) diff --git a/tests/test_dcci_lammps_e2e.py b/tests/test_dcci_lammps_e2e.py index 29a893e..fde772e 100644 --- a/tests/test_dcci_lammps_e2e.py +++ b/tests/test_dcci_lammps_e2e.py @@ -57,9 +57,17 @@ } -def test_dcci_cu_out_and_back(tmp_path): +@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(INPUT, fh, sort_keys=False) + yaml.safe_dump(inp, fh, sort_keys=False) env = dict(os.environ, PYTHONPATH=REPO) proc = subprocess.run( [sys.executable, "-c", From ad1aa227cd72dacf4f59e9d5cff1b83c7329e7fe Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 13:25:32 +0200 Subject: [PATCH 10/14] docs: list the dynamic Clausius-Clapeyron coexistence lines among calphy's methods --- README.md | 1 + docs/source/index.rst | 3 +++ 2 files changed, 4 insertions(+) diff --git a/README.md b/README.md index 831dcf3..674c931 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/docs/source/index.rst b/docs/source/index.rst index 15014de..c33b285 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 From acc7dc2af6d28c9040ccf33edf9202ef72e2abc0 Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 13:25:32 +0200 Subject: [PATCH 11/14] Bump version to 2.1.3 --- .bumpversion.cfg | 2 +- CITATION.cff | 2 +- calphy/__init__.py | 2 +- calphy/input.py | 2 +- pyproject.toml | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.bumpversion.cfg b/.bumpversion.cfg index f2191d4..46ad2c7 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 2.1.2 +current_version = 2.1.3 commit = True tag = True diff --git a/CITATION.cff b/CITATION.cff index e43b806..41a5582 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.1.2 +version: 2.1.3 diff --git a/calphy/__init__.py b/calphy/__init__.py index cc9c679..e08c4e7 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.1.2" +__version__ = "2.1.3" def addtest(a,b): return a+b diff --git a/calphy/input.py b/calphy/input.py index dfa6d0b..830a87b 100644 --- a/calphy/input.py +++ b/calphy/input.py @@ -53,7 +53,7 @@ from ase.io import read, write import shutil -__version__ = "2.1.2" +__version__ = "2.1.3" def _check_equal(val): diff --git a/pyproject.toml b/pyproject.toml index 2f1fef6..8b4dc5b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "calphy" -version = "2.1.2" +version = "2.1.3" description = "free energy calculation for python" readme = "README.md" license = "LicenseRef-ASL-1.0" From 3d12cacb673d31f2a0999c5268d6b6309056ca38 Mon Sep 17 00:00:00 2001 From: srmnitc Date: Tue, 6 Oct 2026 12:00:19 +0200 Subject: [PATCH 12/14] example_13: add the d-CCI run outputs the analysis notebook reads The three Cu01 runs (default, high and converged settings) from 1340 K at 0 bar: input_file.yaml, forward/backward sweeps, coexistence_line.dat and report.yaml. Force-added past the dcci-* and *.dat ignore rules so the notebook runs without repeating the simulations. --- .../coexistence_line.dat | 158 ++++++++++++++++++ .../dcci.backward_1.dat | 157 +++++++++++++++++ .../dcci.forward_1.dat | 157 +++++++++++++++++ .../input_file.yaml | 119 +++++++++++++ .../coexistence_line.dat | 32 ++++ .../dcci.backward_1.dat | 31 ++++ .../dcci.forward_1.dat | 31 ++++ .../input_file.yaml | 119 +++++++++++++ .../dcci-fcc-solid-1340-0-high/report.yaml | 20 +++ .../coexistence_line.dat | 56 +++++++ .../dcci-fcc-solid-1340-0/dcci.backward_1.dat | 55 ++++++ .../dcci-fcc-solid-1340-0/dcci.forward_1.dat | 55 ++++++ .../dcci-fcc-solid-1340-0/input_file.yaml | 119 +++++++++++++ .../dcci-fcc-solid-1340-0/report.yaml | 20 +++ .../coexistence_line.dat | 158 ++++++++++++++++++ .../dcci.backward_1.dat | 157 +++++++++++++++++ .../dcci.forward_1.dat | 157 +++++++++++++++++ .../input_file.yaml | 119 +++++++++++++ .../coexistence_line.dat | 32 ++++ .../dcci.backward_1.dat | 31 ++++ .../dcci.forward_1.dat | 31 ++++ .../input_file.yaml | 119 +++++++++++++ .../dcci-fcc-solid-1340-0-high/report.yaml | 20 +++ .../coexistence_line.dat | 56 +++++++ .../dcci-fcc-solid-1340-0/dcci.backward_1.dat | 55 ++++++ .../dcci-fcc-solid-1340-0/dcci.forward_1.dat | 55 ++++++ .../dcci-fcc-solid-1340-0/input_file.yaml | 119 +++++++++++++ .../dcci-fcc-solid-1340-0/report.yaml | 20 +++ 28 files changed, 2258 insertions(+) create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/coexistence_line.dat create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.backward_1.dat create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.forward_1.dat create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/coexistence_line.dat create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.backward_1.dat create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/dcci.forward_1.dat create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/report.yaml create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0/coexistence_line.dat create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0/dcci.backward_1.dat create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0/dcci.forward_1.dat create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml create mode 100644 docs/source/examples/example_13/dcci-fcc-solid-1340-0/report.yaml create mode 100644 examples/example_13/dcci-fcc-solid-1340-0-converged/coexistence_line.dat create mode 100644 examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.backward_1.dat create mode 100644 examples/example_13/dcci-fcc-solid-1340-0-converged/dcci.forward_1.dat create mode 100644 examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml create mode 100644 examples/example_13/dcci-fcc-solid-1340-0-high/coexistence_line.dat create mode 100644 examples/example_13/dcci-fcc-solid-1340-0-high/dcci.backward_1.dat create mode 100644 examples/example_13/dcci-fcc-solid-1340-0-high/dcci.forward_1.dat create mode 100644 examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml create mode 100644 examples/example_13/dcci-fcc-solid-1340-0-high/report.yaml create mode 100644 examples/example_13/dcci-fcc-solid-1340-0/coexistence_line.dat create mode 100644 examples/example_13/dcci-fcc-solid-1340-0/dcci.backward_1.dat create mode 100644 examples/example_13/dcci-fcc-solid-1340-0/dcci.forward_1.dat create mode 100644 examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml create mode 100644 examples/example_13/dcci-fcc-solid-1340-0/report.yaml 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 0000000..99097e8 --- /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 0000000..74be18a --- /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 0000000..16cb619 --- /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 0000000..80bae14 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml @@ -0,0 +1,119 @@ +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 + lambda_schedule: linear + 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 0000000..54b29c0 --- /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 0000000..c91cfba --- /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 0000000..76ceb01 --- /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 0000000..e6047a1 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml @@ -0,0 +1,119 @@ +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 + lambda_schedule: linear + 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 0000000..daf2ae5 --- /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 0000000..e2414fe --- /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 0000000..260b2e0 --- /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 0000000..204dc4b --- /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 0000000..35ce190 --- /dev/null +++ b/docs/source/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml @@ -0,0 +1,119 @@ +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 + lambda_schedule: linear + 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 0000000..75b75d9 --- /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/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 0000000..99097e8 --- /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 0000000..74be18a --- /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 0000000..16cb619 --- /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 0000000..80bae14 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml @@ -0,0 +1,119 @@ +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 + lambda_schedule: linear + 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 0000000..54b29c0 --- /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 0000000..c91cfba --- /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 0000000..76ceb01 --- /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 0000000..e6047a1 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml @@ -0,0 +1,119 @@ +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 + lambda_schedule: linear + 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 0000000..daf2ae5 --- /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 0000000..e2414fe --- /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 0000000..260b2e0 --- /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 0000000..204dc4b --- /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 0000000..35ce190 --- /dev/null +++ b/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml @@ -0,0 +1,119 @@ +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 + lambda_schedule: linear + 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 0000000..75b75d9 --- /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 From 6a0779d840ac9dcf6415c609b3db12cea7e5d829 Mon Sep 17 00:00:00 2001 From: srmnitc Date: Tue, 6 Oct 2026 12:18:06 +0200 Subject: [PATCH 13/14] example_13: drop lambda_schedule from the recorded run inputs The runs used the linear schedule, the only one left since 2.2.1, so the key carries no information and stops the files from loading. --- .../example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml | 1 - .../example_13/dcci-fcc-solid-1340-0-high/input_file.yaml | 1 - .../examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml | 1 - .../example_13/dcci-fcc-solid-1340-0-converged/input_file.yaml | 1 - examples/example_13/dcci-fcc-solid-1340-0-high/input_file.yaml | 1 - examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml | 1 - 6 files changed, 6 deletions(-) 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 index 80bae14..06f9462 100644 --- 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 @@ -21,7 +21,6 @@ calculations: folder_prefix: null inputfile: input.yaml kernel: 0 - lambda_schedule: linear 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 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 index e6047a1..95d1a6d 100644 --- 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 @@ -21,7 +21,6 @@ calculations: folder_prefix: null inputfile: input.yaml kernel: 0 - lambda_schedule: linear 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 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 index 35ce190..1fac61b 100644 --- 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 @@ -21,7 +21,6 @@ calculations: folder_prefix: null inputfile: input.yaml kernel: 0 - lambda_schedule: linear 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 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 index 80bae14..06f9462 100644 --- 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 @@ -21,7 +21,6 @@ calculations: folder_prefix: null inputfile: input.yaml kernel: 0 - lambda_schedule: linear 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 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 index e6047a1..95d1a6d 100644 --- 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 @@ -21,7 +21,6 @@ calculations: folder_prefix: null inputfile: input.yaml kernel: 0 - lambda_schedule: linear 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 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 index 35ce190..1fac61b 100644 --- a/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml +++ b/examples/example_13/dcci-fcc-solid-1340-0/input_file.yaml @@ -21,7 +21,6 @@ calculations: folder_prefix: null inputfile: input.yaml kernel: 0 - lambda_schedule: linear 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 From 356caa6adb50564e01d9cb9009eb930e7e266204 Mon Sep 17 00:00:00 2001 From: srmnitc Date: Tue, 6 Oct 2026 12:18:06 +0200 Subject: [PATCH 14/14] Bump version to 2.3.0 --- .bumpversion.cfg | 2 +- CITATION.cff | 2 +- calphy/__init__.py | 2 +- calphy/input.py | 2 +- pyproject.toml | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.bumpversion.cfg b/.bumpversion.cfg index 9c21bcd..a553437 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/CITATION.cff b/CITATION.cff index 8d00111..a7073fc 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/calphy/__init__.py b/calphy/__init__.py index dcf1b94..3446f84 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/input.py b/calphy/input.py index b45571c..1337fe7 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): diff --git a/pyproject.toml b/pyproject.toml index dd912ef..93735df 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"

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 K^oY5xTc0?^I? literal 0 HcmV?d00001 diff --git a/examples/example_13/melting_temperature_reference.yaml b/examples/example_13/melting_temperature_reference.yaml new file mode 100644 index 0000000..3311106 --- /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 0000000..ae501a9 --- /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 0000000..e552fd9 --- /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 From 370c546888a442e7144d345d67b99a7e4419aeba Mon Sep 17 00:00:00 2001 From: srmnitc Date: Thu, 10 Sep 2026 13:20:24 +0200 Subject: [PATCH 09/14] dcci: optional concurrent stepping of the two cells (dcci.parallel_cells) The cells exchange information only at block boundaries, through the driver, so between exchanges they are independent. With parallel_cells (off by default) the per-block sequence of each cell -- lambda ramp, run, sync -- and the equilibration, the phase checks and the session teardown run in two threads, each cell's LAMMPS with queue.cores/2, so the total allocation is unchanged and the sweep wall time halves. With a single core the cells fall back to running one after the other, with a warning. Velocity seeds are drawn in the main thread so the random stream is used from one place only. Fake-runner test: the concurrent run reproduces the sequential line exactly and the cells carry half the cores; the LAMMPS end-to-end test runs in both modes. --- DCCI_PLAN.md | 7 ++- calphy/dcci.py | 87 +++++++++++++++++++++++++++-------- calphy/input.py | 12 +++++ docs/source/inputfile.md | 29 +++++++++++- tests/test_dcci_driver.py | 43 ++++++++++++++++- tests/test_dcci_input.py | 17 +++++++ tests/test_dcci_lammps_e2e.py | 12 ++++- 7 files changed, 179 insertions(+), 28 deletions(-) diff --git a/DCCI_PLAN.md b/DCCI_PLAN.md index ffa940d..61c93ba 100644 --- a/DCCI_PLAN.md +++ b/DCCI_PLAN.md @@ -104,6 +104,7 @@ mode has no per-block cost and can use `n_block_steps` of 10-100. | `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`), @@ -139,8 +140,10 @@ coupled-sweep files and `report.yaml` at the top level. both, read the last `ave/time` row of each, `cce_step(...)`, append a row to `dcci.

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 K^oY5xTc0?^I? literal 0 HcmV?d00001 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 0000000..3311106 --- /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 0000000..ae501a9 --- /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 0000000..e552fd9 --- /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 125d746..8b879da 100644 --- a/docs/source/gettingstarted.md +++ b/docs/source/gettingstarted.md @@ -115,7 +115,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/inputfile.md b/docs/source/inputfile.md index a0d4f48..139f695 100644 --- a/docs/source/inputfile.md +++ b/docs/source/inputfile.md @@ -172,6 +172,22 @@ 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) +``` +```` + ### `composition_scaling` ````{grid} 1 2 3 4 @@ -325,7 +341,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 +356,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 +377,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 +404,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)= @@ -1918,3 +1938,136 @@ 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 +``` + +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)`. 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). diff --git a/docs/source/outputfiles.md b/docs/source/outputfiles.md index 5a8b627..91e46f4 100644 --- a/docs/source/outputfiles.md +++ b/docs/source/outputfiles.md @@ -167,6 +167,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 0000000..bef5405 --- /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": [ + "

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 K^oY5xTc0?^I? literal 0 HcmV?d00001 diff --git a/docs/source/examples.md b/docs/source/examples.md index 3ec8f60..0faa2ae 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 0000000..bef5405 --- /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": [ + "