From 9dd9801258f703bf599a007058dd1d07635ee852 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Fri, 12 Jan 2024 13:55:02 +0100 Subject: [PATCH 01/27] Tests for the AtomsBase interface. --- test/atomsbase_interface.jl | 48 +++++++++++++++++++++++++++++++++++++ test/testcases.jl | 14 +++++++++++ 2 files changed, 62 insertions(+) create mode 100644 test/atomsbase_interface.jl create mode 100644 test/testcases.jl diff --git a/test/atomsbase_interface.jl b/test/atomsbase_interface.jl new file mode 100644 index 0000000..c22a7bd --- /dev/null +++ b/test/atomsbase_interface.jl @@ -0,0 +1,48 @@ +#= Test Geometry Optimization on an aluminium supercell. +=# +@testitem "AtomsBase interface: check positions+cell updating" setup=[TestCases] begin + using AtomsBase + using Unitful + using UnitfulAtomic + using GeometryOptimization + using Random + using ComponentArrays + + silicon_supercell = TestCases.silicon_supercell + + Random.seed!(1234) + orig_positions = position(silicon_supercell) + orig_lattice = bounding_box(silicon_supercell) + σ = 0.1u"angstrom" + new_positions = orig_positions + [σ * rand(Float64, size(v)) for v in orig_positions] + new_lattice = orig_lattice + [σ * rand(Float64, size(v)) for v in orig_lattice] + new_general_pos = ComponentVector(atoms = new_positions, bounding_box = new_lattice) + new_system = update_positions(silicon_supercell, new_general_pos) + + @test position(new_system) == new_positions + @test bounding_box(new_system) == new_lattice +end + +@testitem "AtomsBase interface: check positions+cell updating (with mask)" setup=[TestCases] begin + using AtomsBase + using Unitful + using UnitfulAtomic + using GeometryOptimization + using Random + using ComponentArrays + + silicon_supercell = TestCases.silicon_supercell + + Random.seed!(1234) + orig_positions = position(silicon_supercell) + orig_lattice = bounding_box(silicon_supercell) + σ = 0.1u"angstrom" + new_positions = orig_positions + [σ * rand(Float64, size(v)) for v in orig_positions] + new_not_clamped_positions = reduce(vcat, new_positions) + new_lattice = orig_lattice + [σ * rand(Float64, size(v)) for v in orig_lattice] + new_general_pos = ComponentVector(atoms = new_not_clamped_positions, bounding_box = new_lattice) + new_system = update_not_clamped_positions(silicon_supercell, new_general_pos) + + @test position(new_system) == new_positions + @test bounding_box(new_system) == new_lattice +end diff --git a/test/testcases.jl b/test/testcases.jl new file mode 100644 index 0000000..d207dd3 --- /dev/null +++ b/test/testcases.jl @@ -0,0 +1,14 @@ +@testsetup module TestCases + using AtomsBase + using ASEconvert + using Unitful + using UnitfulAtomic + + a = 5.431u"angstrom" + lattice = a / 2 * [[0, 1, 1.], [1, 0, 1.], [1, 1 ,0.]] + atoms = [:Si => ones(3)/8, :Si => -ones(3)/8] + silicon = periodic_system(atoms, lattice; fractional=true) + rep = 3 + supercell_ase = convert_ase(silicon) * pytuple((rep, 1, 1)) + silicon_supercell = pyconvert(AbstractSystem, supercell_ase) +end From c2b81f094a5ff9da63f11e7b558e304a452f8fc3 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Mon, 15 Jan 2024 15:36:15 +0100 Subject: [PATCH 02/27] Added state updating procedure. --- src/optimization.jl | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/src/optimization.jl b/src/optimization.jl index 87f79af..aef8560 100644 --- a/src/optimization.jl +++ b/src/optimization.jl @@ -2,22 +2,33 @@ # Note that by default all particles in the system are assumed optimizable. # IMPORTANT: Note that we always work in cartesian coordinates. =# - +using DFTK export minimize_energy! +function update_state(original_system, new_system, state) + if bounding_box(original_system) != bounding_box(new_system) + return DFTK.DFTKState() + else + return state + end +end + """ -By default we work in cartesian coordinaes. +By default we work in cartesian coordinates. Note that internally, when optimizing the cartesian positions, atomic units are used. """ -function Optimization.OptimizationFunction(system, calculator; kwargs...) +function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwargs...) mask = not_clamped_mask(system) # mask is assumed not to change during optim. - f = function(x::AbstractVector{<:Real}, p) + # TODO: Note that this function will dispatch appropriately when called with + # a Component vector. + f = function(x, p) new_system = update_not_clamped_positions(system, x * u"bohr") - energy = AtomsCalculators.potential_energy(new_system, calculator; kwargs...) - austrip(energy) + state = update_state(system, new_system, calculator.state) + energy = AtomsCalculators.potential_energy(new_system, calculator; state, kwargs...) + austrip(energy) + pressure * calculator.state.scfres.basis.model.unit_cell_volume end g! = function(G::AbstractVector{<:Real}, x::AbstractVector{<:Real}, p) @@ -34,10 +45,10 @@ function Optimization.OptimizationFunction(system, calculator; kwargs...) OptimizationFunction(f; grad=g!) end -function minimize_energy!(system, calculator; solver=Optim.LBFGS(), kwargs...) +function minimize_energy!(system, calculator; pressure=0.0, solver=Optim.LBFGS(), kwargs...) # Use current system parameters as starting positions. x0 = austrip.(not_clamped_positions(system)) # Optim modifies x0 in-place, so need a mutable type. - f_opt = OptimizationFunction(system, calculator) + f_opt = OptimizationFunction(system, calculator; pressure) problem = OptimizationProblem(f_opt, x0, nothing) # Last argument needed in Optimization.jl. solve(problem, solver; kwargs...) end From f699d363e863c8beecce37b41fe731ab88d10a01 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Tue, 16 Jan 2024 07:21:08 +0100 Subject: [PATCH 03/27] Implemented lattice optimization. --- examples/Al_supercell.jl | 2 +- src/atomsbase_interface.jl | 5 +++-- src/optimization.jl | 26 +++++++++++++++++++++++--- test/atomsbase_interface.jl | 3 ++- test/dummy_calculator.jl | 5 ++++- 5 files changed, 33 insertions(+), 8 deletions(-) diff --git a/examples/Al_supercell.jl b/examples/Al_supercell.jl index aea2658..9d8295e 100644 --- a/examples/Al_supercell.jl +++ b/examples/Al_supercell.jl @@ -40,7 +40,7 @@ al_supercell = build_al_supercell(1) model_kwargs = (; functionals = [:lda_x, :lda_c_pw], temperature = 1e-4) basis_kwargs = (; kgrid = [6, 6, 6], Ecut = 30.0) scf_kwargs = (; tol = 1e-6) -calculator = DFTKCalculator(al_supercell; model_kwargs, basis_kwargs, scf_kwargs, verbose=true) +calculator = DFTKCalculator(; model_kwargs, basis_kwargs, scf_kwargs, verbose=true) energy_true = AtomsCalculators.potential_energy(al_supercell, calculator) diff --git a/src/atomsbase_interface.jl b/src/atomsbase_interface.jl index 83b5e25..1a52430 100644 --- a/src/atomsbase_interface.jl +++ b/src/atomsbase_interface.jl @@ -57,9 +57,10 @@ function update_not_clamped_positions(system, positions::ComponentVector) atoms_positions = collect(positions.atoms) new_positions[mask] = reinterpret(reshape, SVector{3, eltype(atoms_positions)}, reshape(atoms_positions, 3, :)) + bounding_box = reinterpret(reshape, SVector{3, eltype(positions.bounding_box)}, + reshape(positions.bounding_box, 3, 3)) update_positions(system, - ComponentVector(atoms=new_positions, - bounding_box=collect.(positions.bounding_box)) + ComponentVector(atoms=new_positions, bounding_box=bounding_box) ) end diff --git a/src/optimization.jl b/src/optimization.jl index aef8560..6d13d16 100644 --- a/src/optimization.jl +++ b/src/optimization.jl @@ -28,10 +28,10 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa new_system = update_not_clamped_positions(system, x * u"bohr") state = update_state(system, new_system, calculator.state) energy = AtomsCalculators.potential_energy(new_system, calculator; state, kwargs...) - austrip(energy) + pressure * calculator.state.scfres.basis.model.unit_cell_volume + austrip(energy) end - g! = function(G::AbstractVector{<:Real}, x::AbstractVector{<:Real}, p) + function g!(G, x, p) new_system = update_not_clamped_positions(system, x * u"bohr") energy = AtomsCalculators.potential_energy(new_system, calculator; kwargs...) @@ -42,12 +42,32 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa # NOTE: minus sign since forces are opposite to gradient. G .= - austrip.(forces_concat) end + function g!(G::ComponentVector, x::ComponentVector, p) + new_system = update_not_clamped_positions(system, x * u"bohr") + energy = AtomsCalculators.potential_energy(new_system, calculator) + + forces = AtomsCalculators.forces(new_system, calculator; kwargs...) + # Translate the forces vectors on each particle to a single gradient for the optimization parameter. + forces_concat = collect(Iterators.flatten(forces[mask])) + + # NOTE: minus sign since forces are opposite to gradient. + g.atoms .= - austrip.(forces_concat) + virial = AtomsCalculators.virial(new_system, calculator) + G.bounding_box .= - collect(Iterators.flatten(virial)) + end OptimizationFunction(f; grad=g!) end function minimize_energy!(system, calculator; pressure=0.0, solver=Optim.LBFGS(), kwargs...) # Use current system parameters as starting positions. - x0 = austrip.(not_clamped_positions(system)) # Optim modifies x0 in-place, so need a mutable type. + if procedure == "relax" + x0 = austrip.(not_clamped_positions(system)) + elseif procedure == "vc_relax" + x0 = ComponentVector(atoms = austrip.(reduce(vcat, position(al_supercell))), + bounding_box = austrip.(reduce(vcat, bounding_box(al_supercell)))) + else + print("error") + end f_opt = OptimizationFunction(system, calculator; pressure) problem = OptimizationProblem(f_opt, x0, nothing) # Last argument needed in Optimization.jl. solve(problem, solver; kwargs...) diff --git a/test/atomsbase_interface.jl b/test/atomsbase_interface.jl index c22a7bd..64f990b 100644 --- a/test/atomsbase_interface.jl +++ b/test/atomsbase_interface.jl @@ -40,7 +40,8 @@ end new_positions = orig_positions + [σ * rand(Float64, size(v)) for v in orig_positions] new_not_clamped_positions = reduce(vcat, new_positions) new_lattice = orig_lattice + [σ * rand(Float64, size(v)) for v in orig_lattice] - new_general_pos = ComponentVector(atoms = new_not_clamped_positions, bounding_box = new_lattice) + new_general_pos = ComponentVector(atoms = new_not_clamped_positions, + bounding_box = reduce(vcat, new_lattice)) new_system = update_not_clamped_positions(silicon_supercell, new_general_pos) @test position(new_system) == new_positions diff --git a/test/dummy_calculator.jl b/test/dummy_calculator.jl index ba29c0e..0d1ec8a 100644 --- a/test/dummy_calculator.jl +++ b/test/dummy_calculator.jl @@ -4,7 +4,10 @@ using Unitful using UnitfulAtomic - struct DummyCalculator end + struct DummyCalculator + state + end + DummyCalculator() = DummyCalculator(nothing) AtomsCalculators.@generate_interface function AtomsCalculators.potential_energy( system, calculator::DummyCalculator; kwargs...) From 36ad6c1444e9fe07dc20bf8938a595ec46736787 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Tue, 16 Jan 2024 07:54:13 +0100 Subject: [PATCH 04/27] Unit cell optimization works. --- examples/Al_variable_cell.jl | 50 ++++++++++++++++++++++++++++++++++++ src/optimization.jl | 15 ++++++----- 2 files changed, 59 insertions(+), 6 deletions(-) create mode 100644 examples/Al_variable_cell.jl diff --git a/examples/Al_variable_cell.jl b/examples/Al_variable_cell.jl new file mode 100644 index 0000000..cc78880 --- /dev/null +++ b/examples/Al_variable_cell.jl @@ -0,0 +1,50 @@ +using LinearAlgebra +using DFTK +using ASEconvert +using LazyArtifacts +using AtomsBase +using AtomsCalculators +using Unitful +using UnitfulAtomic +using Random +using OptimizationOptimJL +using ComponentArrays + +using GeometryOptimization + + +function build_al_supercell(rep=1) + pseudodojo_psp = artifact"pd_nc_sr_lda_standard_0.4.1_upf/Al.upf" + a = 7.65339 # true lattice constant. + lattice = a * Matrix(I, 3, 3) + Al = ElementPsp(:Al; psp=load_psp(pseudodojo_psp)) + atoms = [Al, Al, Al, Al] + positions = [[0.0, 0.0, 0.0], [0.0, 0.5, 0.5], [0.5, 0.0, 0.5], [0.5, 0.5, 0.0]] + unit_cell = periodic_system(lattice, atoms, positions) + + # Make supercell in ASE: + # We convert our lattice to the conventions used in ASE, make the supercell + # and then convert back ... + supercell_ase = convert_ase(unit_cell) * pytuple((rep, 1, 1)) + supercell = pyconvert(AbstractSystem, supercell_ase) + + # Unfortunately right now the conversion to ASE drops the pseudopotential information, + # so we need to reattach it: + supercell = attach_psp(supercell; Al=pseudodojo_psp) + return supercell +end; + +al_supercell = build_al_supercell(1) + +# Create a simple calculator for the model. +model_kwargs = (; functionals = [:lda_x, :lda_c_pw], temperature = 1e-2) +basis_kwargs = (; kgrid = [2, 2, 2], Ecut = 10.0) +scf_kwargs = (; tol = 1e-3) +calculator = DFTKCalculator(; model_kwargs, basis_kwargs, scf_kwargs, verbose=true) + +# Create starting vector. +x0 = ComponentVector(atoms = austrip.(reduce(vcat, position(al_supercell))), + bounding_box = austrip.(reduce(vcat, bounding_box(al_supercell)))) + +optim_options = (f_tol=1e-6, iterations=6, show_trace=true) +results = minimize_energy!(al_supercell, calculator; procedure="vc_relax", optim_options...) diff --git a/src/optimization.jl b/src/optimization.jl index 6d13d16..8ce1c44 100644 --- a/src/optimization.jl +++ b/src/optimization.jl @@ -33,6 +33,7 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa function g!(G, x, p) new_system = update_not_clamped_positions(system, x * u"bohr") + # TODO: Determine if here we need a call to update_state. energy = AtomsCalculators.potential_energy(new_system, calculator; kwargs...) forces = AtomsCalculators.forces(new_system, calculator; kwargs...) @@ -44,27 +45,29 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa end function g!(G::ComponentVector, x::ComponentVector, p) new_system = update_not_clamped_positions(system, x * u"bohr") - energy = AtomsCalculators.potential_energy(new_system, calculator) + state = update_state(system, new_system, calculator.state) + energy = AtomsCalculators.potential_energy(new_system, calculator; state, kwargs...) - forces = AtomsCalculators.forces(new_system, calculator; kwargs...) + forces = AtomsCalculators.forces(new_system, calculator; state, kwargs...) # Translate the forces vectors on each particle to a single gradient for the optimization parameter. forces_concat = collect(Iterators.flatten(forces[mask])) # NOTE: minus sign since forces are opposite to gradient. - g.atoms .= - austrip.(forces_concat) + G.atoms .= - austrip.(forces_concat) virial = AtomsCalculators.virial(new_system, calculator) G.bounding_box .= - collect(Iterators.flatten(virial)) end OptimizationFunction(f; grad=g!) end -function minimize_energy!(system, calculator; pressure=0.0, solver=Optim.LBFGS(), kwargs...) +function minimize_energy!(system, calculator; pressure=0.0, procedure="relax", + solver=Optim.LBFGS(), kwargs...) # Use current system parameters as starting positions. if procedure == "relax" x0 = austrip.(not_clamped_positions(system)) elseif procedure == "vc_relax" - x0 = ComponentVector(atoms = austrip.(reduce(vcat, position(al_supercell))), - bounding_box = austrip.(reduce(vcat, bounding_box(al_supercell)))) + x0 = ComponentVector(atoms = austrip.(reduce(vcat, position(system))), + bounding_box = austrip.(reduce(vcat, bounding_box(system)))) else print("error") end From b72bf35232623adcebd094d124971612d58974e9 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Wed, 24 Jan 2024 15:13:00 +0100 Subject: [PATCH 05/27] Apply strain to system. --- src/strain.jl | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 src/strain.jl diff --git a/src/strain.jl b/src/strain.jl new file mode 100644 index 0000000..de004ef --- /dev/null +++ b/src/strain.jl @@ -0,0 +1,20 @@ +export apply_voigt_strain + +function voigt_to_full(v) + [v[1] .5*v[6] .5*v[5]; + .5*v[6] v[2] .5*v[4]; + .5*v[5] .5*v[4] v[3]] +end + +function full_to_voigt(A) + [A[1, 1], A[2, 2], A[3, 3], 2. * A[2, 3], 2. * A[1, 3], 2. * A[1, 2]] +end + +function apply_voigt_strain(system, strain) + deformation = I + voigt_to_full(strain) + new_lattice = eachrow(hcat(bounding_box(system)...) * deformation) + # Also deform coordinates, since internally do not work in fractional coordinates. + new_positions = [transpose(pos) * deformation for pos in position(system)] + new_generalized_positions = ComponentVector(atoms=new_positions , bounding_box=new_lattice) + update_positions(system, new_generalized_positions) +end From dacdeaf8b8f355e7a256cbc135579833fc09b46f Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Fri, 26 Jan 2024 09:04:35 +0100 Subject: [PATCH 06/27] Fixed transpose in strain. Added test for strain. --- src/GeometryOptimization.jl | 2 ++ src/strain.jl | 3 ++- test/strain.jl | 33 +++++++++++++++++++++++++++++++++ test/testcases.jl | 7 +++++++ 4 files changed, 44 insertions(+), 1 deletion(-) create mode 100644 test/strain.jl diff --git a/src/GeometryOptimization.jl b/src/GeometryOptimization.jl index d4b730b..a7ba427 100644 --- a/src/GeometryOptimization.jl +++ b/src/GeometryOptimization.jl @@ -1,5 +1,6 @@ module GeometryOptimization +using LinearAlgebra using StaticArrays using ComponentArrays using Optimization @@ -10,6 +11,7 @@ using Unitful using UnitfulAtomic include("atomsbase_interface.jl") +include("strain.jl") include("optimization.jl") end diff --git a/src/strain.jl b/src/strain.jl index de004ef..62fafdc 100644 --- a/src/strain.jl +++ b/src/strain.jl @@ -12,7 +12,8 @@ end function apply_voigt_strain(system, strain) deformation = I + voigt_to_full(strain) - new_lattice = eachrow(hcat(bounding_box(system)...) * deformation) + new_lattice = eachrow( + reduce(hcat, bounding_box(system))' * deformation) # Also deform coordinates, since internally do not work in fractional coordinates. new_positions = [transpose(pos) * deformation for pos in position(system)] new_generalized_positions = ComponentVector(atoms=new_positions , bounding_box=new_lattice) diff --git a/test/strain.jl b/test/strain.jl new file mode 100644 index 0000000..4978f7a --- /dev/null +++ b/test/strain.jl @@ -0,0 +1,33 @@ +#= Test Geometry Optimization on an aluminium supercell. +=# +@testitem "Stain interface: test cell deformation under strain" setup=[TestCases] begin + using AtomsBase + using Unitful + using UnitfulAtomic + using GeometryOptimization + using Random + using ComponentArrays + + silicon = TestCases.silicon + + # Test elongation along first vector. + strain = Vector([1., 0, 0, 0, 0, 0.]) + new_silicon = apply_voigt_strain(silicon, strain) + @test [v[1] for v in bounding_box(new_silicon)] ≈ 2. * [v[1] for v in bounding_box(silicon)] rtol=1e-3 +end + +@testitem "Stain interface: test atoms positions deformation under strain" setup=[TestCases] begin + using AtomsBase + using Unitful + using UnitfulAtomic + using GeometryOptimization + using Random + using ComponentArrays + + silicon = TestCases.silicon + + # Test elongation along first vector. + strain = Vector([1., 0, 0, 0, 0, 0.]) + new_silicon = apply_voigt_strain(silicon, strain) + @test [v[1] for v in position(new_silicon)] ≈ 2. * [v[1] for v in position(silicon)] rtol=1e-3 +end diff --git a/test/testcases.jl b/test/testcases.jl index d207dd3..af8fee4 100644 --- a/test/testcases.jl +++ b/test/testcases.jl @@ -11,4 +11,11 @@ rep = 3 supercell_ase = convert_ase(silicon) * pytuple((rep, 1, 1)) silicon_supercell = pyconvert(AbstractSystem, supercell_ase) + + a = 335.9u"pm" + lattice = a * [[1., 0, 0], [0 , 1, 0.], [0, 0 ,1.]] + atoms = [:Po => zeros(3)] + polonium = periodic_system(atoms, lattice; fractional=true) + supercell_ase = convert_ase(polonium) * pytuple((rep, 1, 1)) + polonium_supercell = pyconvert(AbstractSystem, supercell_ase) end From 572598d85388211b41888e284ff43402a323fdc0 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Fri, 26 Jan 2024 16:02:59 +0100 Subject: [PATCH 07/27] Strain from deformation and corresponding tests. --- src/strain.jl | 33 ++++++++++++++++++++++++++++----- test/strain.jl | 22 ++++++++++++++++++++-- 2 files changed, 48 insertions(+), 7 deletions(-) diff --git a/src/strain.jl b/src/strain.jl index 62fafdc..2c085ae 100644 --- a/src/strain.jl +++ b/src/strain.jl @@ -1,4 +1,4 @@ -export apply_voigt_strain +export apply_voigt_strain, compute_voigt_strain function voigt_to_full(v) [v[1] .5*v[6] .5*v[5]; @@ -10,12 +10,35 @@ function full_to_voigt(A) [A[1, 1], A[2, 2], A[3, 3], 2. * A[2, 3], 2. * A[1, 3], 2. * A[1, 2]] end +""" +Transform a bounding box in list of vectors form in matrix form +(box vectors in the rows). +""" +function bbox_to_matrix(bbox) + reduce(hcat, bbox) +end + +@doc raw""" +Deform system by applying given strain. Unit cell vectors as well as atomic +positions are scaled. For a matrix of strains E, the matrix L of unit cell vectors +is scaled accodring to L' = (I + E) L. +Input strains should be given as a vector (Voigt notation). +""" function apply_voigt_strain(system, strain) - deformation = I + voigt_to_full(strain) - new_lattice = eachrow( - reduce(hcat, bounding_box(system))' * deformation) + deformation_tensor = I + voigt_to_full(strain) + new_lattice = eachcol( + deformation_tensor * bbox_to_matrix(bounding_box(system))) # Also deform coordinates, since internally do not work in fractional coordinates. - new_positions = [transpose(pos) * deformation for pos in position(system)] + new_positions = [deformation_tensor * pos for pos in position(system)] new_generalized_positions = ComponentVector(atoms=new_positions , bounding_box=new_lattice) update_positions(system, new_generalized_positions) end + +@doc raw""" +Compute the strain (in Voigt notation) needed to deform the unit cell `bouding_box` into +`deformed_bounding_box`. +""" +function compute_voigt_strain(bbox, deformed_bbox) + strain_full = (bbox_to_matrix(deformed_bbox .- bbox)) / bbox_to_matrix(bbox) + full_to_voigt(strain_full) +end diff --git a/test/strain.jl b/test/strain.jl index 4978f7a..ed67c08 100644 --- a/test/strain.jl +++ b/test/strain.jl @@ -1,6 +1,6 @@ #= Test Geometry Optimization on an aluminium supercell. =# -@testitem "Stain interface: test cell deformation under strain" setup=[TestCases] begin +@testitem "Stain interface: cell deformation under strain" setup=[TestCases] begin using AtomsBase using Unitful using UnitfulAtomic @@ -16,7 +16,7 @@ @test [v[1] for v in bounding_box(new_silicon)] ≈ 2. * [v[1] for v in bounding_box(silicon)] rtol=1e-3 end -@testitem "Stain interface: test atoms positions deformation under strain" setup=[TestCases] begin +@testitem "Stain interface: atoms positions deformation under strain" setup=[TestCases] begin using AtomsBase using Unitful using UnitfulAtomic @@ -31,3 +31,21 @@ end new_silicon = apply_voigt_strain(silicon, strain) @test [v[1] for v in position(new_silicon)] ≈ 2. * [v[1] for v in position(silicon)] rtol=1e-3 end + +@testitem "Stain interface: strain from deformation" setup=[TestCases] begin + bbox = [[1., 0, 0], + [0., 2., 0], + [0., 0, 3]] + bbox_pert = [[1., 0, 0], + [0., 4., 0], + [0., 0, 3]] + strain = compute_voigt_strain(bbox, bbox_pert) + @test strain ≈ [0., 1., 0, 0, 0, 0] rtol=1e-6 + + # Test with y-z rotation. + bbox_pert = [[6,0,0], + [0,2,1], + [0,1.5,3]] + strain = compute_voigt_strain(bbox, bbox_pert) + @test strain ≈ [5., 0, 0, 1., 0, 0] rtol=1e-6 +end From 4e41c6098ba9a0018f6185c0b62e83129849efd7 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Mon, 29 Jan 2024 13:40:54 +0100 Subject: [PATCH 08/27] Correct parametrization of strain in lattice optimization. --- src/atomsbase_interface.jl | 30 +++++++++++++++--------------- src/optimization.jl | 9 +++------ src/strain.jl | 2 +- 3 files changed, 19 insertions(+), 22 deletions(-) diff --git a/src/atomsbase_interface.jl b/src/atomsbase_interface.jl index 1a52430..d3a109f 100644 --- a/src/atomsbase_interface.jl +++ b/src/atomsbase_interface.jl @@ -9,27 +9,31 @@ export update_positions, update_not_clamped_positions, clamp_atoms @doc raw""" Creates a new system based on ``system`` but with atoms positions updated -to the ones provided. +to the ones provided. Can also update lattice vectors if `bounding_box` is provided. """ -function update_positions(system, positions::AbstractVector{<:AbstractVector{<:Unitful.Length}}) +function update_positions(system, positions::AbstractVector{<:AbstractVector{<:Unitful.Length}}; + bounding_box=bounding_box(system)) particles = [Atom(atom; position) for (atom, position) in zip(system, positions)] - AbstractSystem(system; particles) + AbstractSystem(system; particles, bounding_box) end @doc raw""" -Creates a new system based on ``system`` but with atoms positions and lattice -vectors updated to the ones provided. +Creates a new system based on ``system`` but with atoms positions +updated to the ones provided and lattice vectors deformed according +to the provided strain. New generalized coordinates should be provided in a ComponentArray with -component `atoms` and `bounding_box`, containing new atomic positions -and lattice vectors respectively. +component `atoms` and `strain`. """ function update_positions(system, positions::ComponentVector) - # Collect are needed with ComponentArrays to get concrete types. + # TODO: Do we want to apply the strain to the atoms too? particles = [Atom(atom; position) for (atom, position) in zip(system, collect.(positions.atoms))] - AbstractSystem(system; particles, bounding_box=collect.(positions.bounding_box)) + + deformation_tensor = I + voigt_to_full(austrip.(positions.strain)) + bbox = eachcol(deformation_tensor * bbox_to_matrix(bounding_box(system))) + AbstractSystem(system; particles, bounding_box=bbox) end @doc raw""" @@ -48,7 +52,7 @@ end Creates a new system based on ``system`` where the non clamped positions and lattice vectors are updated to the ones provided. Note that the `atoms`component of `positions` should be a vector of -coordinates. +coordinates and that the `strain` component should be a 6-vector. """ function update_not_clamped_positions(system, positions::ComponentVector) @@ -57,11 +61,7 @@ function update_not_clamped_positions(system, positions::ComponentVector) atoms_positions = collect(positions.atoms) new_positions[mask] = reinterpret(reshape, SVector{3, eltype(atoms_positions)}, reshape(atoms_positions, 3, :)) - bounding_box = reinterpret(reshape, SVector{3, eltype(positions.bounding_box)}, - reshape(positions.bounding_box, 3, 3)) - update_positions(system, - ComponentVector(atoms=new_positions, bounding_box=bounding_box) - ) + update_positions(system, ComponentVector(; atoms=new_positions, positions.strain)) end @doc raw""" diff --git a/src/optimization.jl b/src/optimization.jl index 8ce1c44..466cbde 100644 --- a/src/optimization.jl +++ b/src/optimization.jl @@ -46,8 +46,6 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa function g!(G::ComponentVector, x::ComponentVector, p) new_system = update_not_clamped_positions(system, x * u"bohr") state = update_state(system, new_system, calculator.state) - energy = AtomsCalculators.potential_energy(new_system, calculator; state, kwargs...) - forces = AtomsCalculators.forces(new_system, calculator; state, kwargs...) # Translate the forces vectors on each particle to a single gradient for the optimization parameter. forces_concat = collect(Iterators.flatten(forces[mask])) @@ -55,7 +53,7 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa # NOTE: minus sign since forces are opposite to gradient. G.atoms .= - austrip.(forces_concat) virial = AtomsCalculators.virial(new_system, calculator) - G.bounding_box .= - collect(Iterators.flatten(virial)) + G.strain .= - full_to_voigt(virial) end OptimizationFunction(f; grad=g!) end @@ -66,10 +64,9 @@ function minimize_energy!(system, calculator; pressure=0.0, procedure="relax", if procedure == "relax" x0 = austrip.(not_clamped_positions(system)) elseif procedure == "vc_relax" - x0 = ComponentVector(atoms = austrip.(reduce(vcat, position(system))), - bounding_box = austrip.(reduce(vcat, bounding_box(system)))) + x0 = ComponentVector(atoms = austrip.(reduce(vcat, position(system))), strain = zeros(6)) else - print("error") + print("Error: unknown optimization procedure. Please use one of [`relax`, `vc_relax`].") end f_opt = OptimizationFunction(system, calculator; pressure) problem = OptimizationProblem(f_opt, x0, nothing) # Last argument needed in Optimization.jl. diff --git a/src/strain.jl b/src/strain.jl index 2c085ae..ef0cfb2 100644 --- a/src/strain.jl +++ b/src/strain.jl @@ -12,7 +12,7 @@ end """ Transform a bounding box in list of vectors form in matrix form -(box vectors in the rows). +(box vectors in the columns). """ function bbox_to_matrix(bbox) reduce(hcat, bbox) From 4517e6bc38d9aa317fa31391ff31dd714db4dae7 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Mon, 29 Jan 2024 13:41:12 +0100 Subject: [PATCH 09/27] Verification example on silicium. --- examples/Si_verification.jl | 44 +++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 examples/Si_verification.jl diff --git a/examples/Si_verification.jl b/examples/Si_verification.jl new file mode 100644 index 0000000..5dabce7 --- /dev/null +++ b/examples/Si_verification.jl @@ -0,0 +1,44 @@ +# Verify correctness of lattice optimization on silicon. +using DFTK +using AtomsBase +using AtomsCalculators +using ComponentArrays +using LazyArtifacts +using Random +using Unitful +using UnitfulAtomic +using OptimizationOptimJL +using GeometryOptimization + + +lattice = [0.0 5.131570667152971 5.131570667152971; + 5.131570667152971 0.0 5.131570667152971; + 5.131570667152971 5.131570667152971 0.0] +hgh_lda_family = artifact"hgh_lda_hgh" +psp_hgh = joinpath(hgh_lda_family, "si-q4.hgh") + +positions = [ones(3)/8, -ones(3)/8] +atoms = fill(ElementPsp(:Si; psp=load_psp(psp_hgh)), 2) +system = periodic_system(lattice, atoms, positions) + +# Create a simple calculator for the model. +model_kwargs = (; functionals = [:lda_x, :lda_c_pw], temperature = 1e-5) +basis_kwargs = (; kgrid = [5, 5, 5], Ecut = 30.0) +scf_kwargs = (; tol = 1e-6) +calculator = DFTKCalculator(; model_kwargs, basis_kwargs, scf_kwargs, verbose=true) + +# Perturb unit cell. +Random.seed!(1234) +σ = 0.2u"bohr" +bounding_box_pert = [v + σ * rand(Float64, size(v)) for v in bounding_box(system)] +system_pert = update_positions(system, position(system); bounding_box=bounding_box_pert) + + +using LineSearches +linesearch = BackTracking(c_1= 1e-4, ρ_hi= 0.5, ρ_lo= 0.1, iterations=4, + order=3, maxstep=Inf) +solver = OptimizationOptimJL.LBFGS(; linesearch) +optim_options = (; solver, f_tol=1e-4, g_tol=1e-4, iterations=3, + show_trace=true, store_trace = true, allow_f_increases=true) + +results = minimize_energy!(system_pert, calculator; procedure="vc_relax", optim_options...) From e113328888eec693a7b505fed0a8fef717745cba Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Thu, 1 Feb 2024 11:49:43 +0100 Subject: [PATCH 10/27] Now translating forces and stresses back to original cell during optimization. --- src/optimization.jl | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/optimization.jl b/src/optimization.jl index 466cbde..a5d4494 100644 --- a/src/optimization.jl +++ b/src/optimization.jl @@ -44,16 +44,18 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa G .= - austrip.(forces_concat) end function g!(G::ComponentVector, x::ComponentVector, p) + deformation_tensor = I + voigt_to_full(austrip.(x.strain)) new_system = update_not_clamped_positions(system, x * u"bohr") + state = update_state(system, new_system, calculator.state) forces = AtomsCalculators.forces(new_system, calculator; state, kwargs...) # Translate the forces vectors on each particle to a single gradient for the optimization parameter. - forces_concat = collect(Iterators.flatten(forces[mask])) + forces_concat = collect(Iterators.flatten([deformation_tensor * f for f in forces[mask]])) # NOTE: minus sign since forces are opposite to gradient. G.atoms .= - austrip.(forces_concat) virial = AtomsCalculators.virial(new_system, calculator) - G.strain .= - full_to_voigt(virial) + G.strain .= - full_to_voigt(virial / deformation_tensor) end OptimizationFunction(f; grad=g!) end From 442f5055cab8578c076ea90243fe9c7950e02558 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Thu, 1 Feb 2024 11:50:10 +0100 Subject: [PATCH 11/27] Set position with strain now also applies it to the atoms. --- src/atomsbase_interface.jl | 4 ++-- src/strain.jl | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/atomsbase_interface.jl b/src/atomsbase_interface.jl index d3a109f..efd9ba7 100644 --- a/src/atomsbase_interface.jl +++ b/src/atomsbase_interface.jl @@ -27,11 +27,11 @@ component `atoms` and `strain`. """ function update_positions(system, positions::ComponentVector) + deformation_tensor = I + voigt_to_full(austrip.(positions.strain)) # TODO: Do we want to apply the strain to the atoms too? - particles = [Atom(atom; position) for (atom, position) + particles = [Atom(atom; position = deformation_tensor * position) for (atom, position) in zip(system, collect.(positions.atoms))] - deformation_tensor = I + voigt_to_full(austrip.(positions.strain)) bbox = eachcol(deformation_tensor * bbox_to_matrix(bounding_box(system))) AbstractSystem(system; particles, bounding_box=bbox) end diff --git a/src/strain.jl b/src/strain.jl index ef0cfb2..969a5a1 100644 --- a/src/strain.jl +++ b/src/strain.jl @@ -18,6 +18,7 @@ function bbox_to_matrix(bbox) reduce(hcat, bbox) end +# TODO: deprecate. @doc raw""" Deform system by applying given strain. Unit cell vectors as well as atomic positions are scaled. For a matrix of strains E, the matrix L of unit cell vectors From 3c3a84402969b58ed6c9f2bc2e035956b981cd82 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Thu, 1 Feb 2024 13:13:20 +0100 Subject: [PATCH 12/27] Updated Project.toml --- Project.toml | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/Project.toml b/Project.toml index 11547d8..7fb1feb 100644 --- a/Project.toml +++ b/Project.toml @@ -4,17 +4,29 @@ authors = ["JuliaMolSim community"] version = "0.0.1" [deps] +ASEconvert = "3da9722f-58c2-4165-81be-b4d7253e8fd2" AtomsBase = "a963bdd2-2df7-4f54-a1ee-49d51e6be12a" AtomsCalculators = "a3e0e189-c65a-42c1-833c-339540406eb1" +AtomsIO = "1692102d-eeb4-4df9-807b-c9517f998d44" +AtomsIOPython = "9e4c859b-2281-48ef-8059-f50fe53c37b0" +ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66" +DFTK = "acf6eb54-70d9-11e9-0013-234b7a5f5337" +LineSearches = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" Optimization = "7f7a1694-90dd-40f0-9382-eb1efda571ba" OptimizationOptimJL = "36348300-93cb-4f02-beb5-3c3902f8871e" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" UnitfulAtomic = "a7773ee8-282e-5fa2-be4e-bd808c38a91a" [compat] +ASEconvert = "0.1" AtomsBase = "0.3" AtomsCalculators = "0.1" +DFTK = "0.6" +EmpiricalPotentials = "0.0.1" Optimization = "3.20" OptimizationOptimJL = "0.1" StaticArrays = "1.8" @@ -22,16 +34,13 @@ TestItemRunner = "0.2" Unitful = "1.19" UnitfulAtomic = "1.0" julia = "1.9" -DFTK = "0.6" -ASEconvert = "0.1" -EmpiricalPotentials = "0.0.1" [extras] -Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" -TestItemRunner = "f8b46487-2199-4994-9208-9a1283c18c0a" -DFTK = "acf6eb54-70d9-11e9-0013-234b7a5f5337" ASEconvert = "3da9722f-58c2-4165-81be-b4d7253e8fd2" +DFTK = "acf6eb54-70d9-11e9-0013-234b7a5f5337" EmpiricalPotentials = "38527215-9240-4c91-a638-d4250620c9e2" +Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" +TestItemRunner = "f8b46487-2199-4994-9208-9a1283c18c0a" [targets] examples = ["DFTK", "ASEconvert", "EmpiricalPotentials"] From 24b2771105e23906824d2b8ec172cd6814f4726d Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Mon, 19 Feb 2024 14:39:44 +0100 Subject: [PATCH 13/27] Modified examples. --- examples/Al_strain.jl | 84 ++++++++++++++++++++++++++++++++++++ examples/Al_variable_cell.jl | 4 -- examples/Si_verification.jl | 5 +-- 3 files changed, 86 insertions(+), 7 deletions(-) create mode 100644 examples/Al_strain.jl diff --git a/examples/Al_strain.jl b/examples/Al_strain.jl new file mode 100644 index 0000000..c0d305b --- /dev/null +++ b/examples/Al_strain.jl @@ -0,0 +1,84 @@ +using DFTK: occupation +#= Test Geometry Optimization on an aluminium supercell. +=# +using LinearAlgebra +using DFTK +using ASEconvert +using LazyArtifacts +using AtomsCalculators +using Unitful +using UnitfulAtomic +using Random +using OptimizationOptimJL + +using GeometryOptimization + + +function build_al_supercell(rep=1) + pseudodojo_psp = artifact"pd_nc_sr_lda_standard_0.4.1_upf/Al.upf" + a = 7.65339 # true lattice constant. + lattice = a * Matrix(I, 3, 3) + Al = ElementPsp(:Al; psp=load_psp(pseudodojo_psp)) + atoms = [Al, Al, Al, Al] + positions = [[0.0, 0.0, 0.0], [0.0, 0.5, 0.5], [0.5, 0.0, 0.5], [0.5, 0.5, 0.0]] + unit_cell = periodic_system(lattice, atoms, positions) + + # Make supercell in ASE: + # We convert our lattice to the conventions used in ASE, make the supercell + # and then convert back ... + supercell_ase = convert_ase(unit_cell) * pytuple((rep, 1, 1)) + supercell = pyconvert(AbstractSystem, supercell_ase) + + # Unfortunately right now the conversion to ASE drops the pseudopotential information, + # so we need to reattach it: + supercell = attach_psp(supercell; Al=pseudodojo_psp) + return supercell +end; + +al_supercell = build_al_supercell(1) + +# Create a simple calculator for the model. +model_kwargs = (; functionals = [:lda_x, :lda_c_pw], temperature = 1e-4) +basis_kwargs = (; kgrid = [6, 6, 6], Ecut = 30.0) +scf_kwargs = (; tol = 1e-6) +calculator = DFTKCalculator(; model_kwargs, basis_kwargs, scf_kwargs, verbose=true) + +energy_true = AtomsCalculators.potential_energy(al_supercell, calculator) + +# Starting position is a random perturbation of the equilibrium one. +Random.seed!(1234) +x0 = vcat(position(al_supercell)...) +σ = 0.5u"angstrom"; x0_pert = x0 + σ * rand(Float64, size(x0)) +al_supercell = update_not_clamped_positions(al_supercell, x0_pert) +energy_pert = AtomsCalculators.potential_energy(al_supercell, calculator) + +println("Initial guess distance (norm) from true parameters $(norm(x0 - x0_pert)).") +println("Initial regret $(energy_pert - energy_true).") + +optim_options = (f_tol=1e-6, iterations=6, show_trace=true) + +results = minimize_energy!(al_supercell, calculator; optim_options...) +println(results) + +""" Returns the index of the highest occupied band. + `atol` specifies the (fractional) occupations below which + a band is considered unoccupied. +""" +function valence_band_index(occupations; atol=1e-36) + filter = x -> isapprox(x, 0.; atol) + maximum(maximum.(findall.(!filter, occupations))) +end + +function band_gaps(scfres) + vi = valence_band_index(occupations; atol) + # If the system is metallic, by convenction band gap is zero. + if DFTK.is_metal(scfres.eigenvalues, scfres.εF; tol=1e-4) + return (; εMax_valence=0.0u"hartree", εMin_conduction=0.0u"hartree", + direct_bandgap=0.0u"hartree", valence_band_index=vi) + else + εMax_valence = maximum([εk[vi] for εk in scfres.eigenvalues]) * u"hartree" + εMin_conduction = minimum([εk[vi + 1] for εk in scfres.eigenvalues]) * u"hartree" + direct_bandgap = minimum([εk[vi + 1] - εk[vi] for εk in scfres.eigenvalues]) * u"hartree" + return (; εMax_valence, εMin_conduction, direct_bandgap, valence_band_index=vi) + end +end diff --git a/examples/Al_variable_cell.jl b/examples/Al_variable_cell.jl index cc78880..1877990 100644 --- a/examples/Al_variable_cell.jl +++ b/examples/Al_variable_cell.jl @@ -42,9 +42,5 @@ basis_kwargs = (; kgrid = [2, 2, 2], Ecut = 10.0) scf_kwargs = (; tol = 1e-3) calculator = DFTKCalculator(; model_kwargs, basis_kwargs, scf_kwargs, verbose=true) -# Create starting vector. -x0 = ComponentVector(atoms = austrip.(reduce(vcat, position(al_supercell))), - bounding_box = austrip.(reduce(vcat, bounding_box(al_supercell)))) - optim_options = (f_tol=1e-6, iterations=6, show_trace=true) results = minimize_energy!(al_supercell, calculator; procedure="vc_relax", optim_options...) diff --git a/examples/Si_verification.jl b/examples/Si_verification.jl index 5dabce7..4acd976 100644 --- a/examples/Si_verification.jl +++ b/examples/Si_verification.jl @@ -35,10 +35,9 @@ system_pert = update_positions(system, position(system); bounding_box=bounding_b using LineSearches -linesearch = BackTracking(c_1= 1e-4, ρ_hi= 0.5, ρ_lo= 0.1, iterations=4, - order=3, maxstep=Inf) +linesearch = BackTracking(c_1= 1e-4, ρ_hi= 0.8, ρ_lo= 0.1, order=2, maxstep=Inf) solver = OptimizationOptimJL.LBFGS(; linesearch) -optim_options = (; solver, f_tol=1e-4, g_tol=1e-4, iterations=3, +optim_options = (; solver, f_tol=1e-10, g_tol=1e-5, iterations=30, show_trace=true, store_trace = true, allow_f_increases=true) results = minimize_energy!(system_pert, calculator; procedure="vc_relax", optim_options...) From a724e008dcbc02d84a16e21a914395d5c1495c25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?C=C3=A9dric=20Travelletti?= <33686811+CedricTravelletti@users.noreply.github.com> Date: Mon, 19 Feb 2024 14:47:42 +0100 Subject: [PATCH 14/27] Bumped version --- Project.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Project.toml b/Project.toml index ec66b45..65191ac 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "GeometryOptimization" uuid = "673bf261-a53d-43b9-876f-d3c1fc8329c2" authors = ["JuliaMolSim community"] -version = "0.0.1" +version = "0.0.2" [deps] ASEconvert = "3da9722f-58c2-4165-81be-b4d7253e8fd2" @@ -43,4 +43,4 @@ TestItemRunner = "f8b46487-2199-4994-9208-9a1283c18c0a" [targets] examples = ["DFTK", "ASEconvert", "EmpiricalPotentials"] -test = ["Test", "TestItemRunner"] \ No newline at end of file +test = ["Test", "TestItemRunner"] From 1a3d9c3f37552153d03d2f3f1c2628fd18fda76f Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Sat, 9 Mar 2024 17:28:13 +0100 Subject: [PATCH 15/27] Fixed cell updating and tests. --- src/GeometryOptimization.jl | 4 +++ src/atomsbase_interface.jl | 15 ++++---- src/strain.jl | 18 ---------- test/atomsbase_interface.jl | 69 ++++++++++++++++++++++++++++++++----- test/strain.jl | 51 --------------------------- 5 files changed, 72 insertions(+), 85 deletions(-) delete mode 100644 test/strain.jl diff --git a/src/GeometryOptimization.jl b/src/GeometryOptimization.jl index 464e5be..0e1ab3f 100644 --- a/src/GeometryOptimization.jl +++ b/src/GeometryOptimization.jl @@ -8,9 +8,13 @@ using AtomsBase using AtomsCalculators using Unitful using UnitfulAtomic +using ComponentArrays +export update_positions, update_not_clamped_positions, clamp_atoms include("atomsbase_interface.jl") +export compute_voigt_strain, voigt_to_full include("strain.jl") +export minimize_energy! include("optimization.jl") end diff --git a/src/atomsbase_interface.jl b/src/atomsbase_interface.jl index cf45c99..4316f29 100644 --- a/src/atomsbase_interface.jl +++ b/src/atomsbase_interface.jl @@ -3,8 +3,9 @@ # utility functions for manipulating systems. # # IMPORTANT: Note that we always work in cartesian coordinates. +# BUG: Unitful does not play well with arrays in Julia 1.10. This is why +# collect statements are needed to restor array type (otherwise we get Vector{Any}). # -export update_positions, update_not_clamped_positions, clamp_atoms @doc raw""" @@ -12,8 +13,8 @@ Creates a new system based on ``system`` but with atoms positions updated to the ones provided. Can also update lattice vectors if `bounding_box` is provided. """ -function update_positions(system, positions::AbstractVector{<:AbstractVector{<:Unitful.Length}}; - bounding_box=bounding_box(system)) +function update_positions(system, positions::AbstractVector{<:AbstractVector{<:Unitful.Length}}, + bounding_box=bounding_box(system)) particles = [Atom(atom; position) for (atom, position) in zip(system, positions)] AbstractSystem(system; particles, bounding_box) end @@ -27,10 +28,10 @@ component `atoms` and `strain`. """ function update_positions(system, positions::ComponentVector) - deformation_tensor = I + voigt_to_full(austrip.(positions.strain)) + deformation_tensor = I + voigt_to_full(positions.strain) # TODO: Do we want to apply the strain to the atoms too? - particles = [Atom(atom; position = deformation_tensor * position) for (atom, position) - in zip(system, collect.(positions.atoms))] + particles = [Atom(atom; position = collect((x for x in deformation_tensor * position))) for (atom, position) + in zip(system, positions.atoms)] bbox = eachcol(deformation_tensor * bbox_to_matrix(bounding_box(system))) AbstractSystem(system; particles, bounding_box=bbox) @@ -59,7 +60,7 @@ coordinates and that the `strain` component should be a 6-vector. function update_not_clamped_positions(system, positions::ComponentVector) mask = not_clamped_mask(system) new_positions = deepcopy(position(system)) - atoms_positions = collect(positions.atoms) + atoms_positions = collect((x for x in positions.atoms)) new_positions[mask] = reinterpret(reshape, SVector{3, eltype(atoms_positions)}, reshape(atoms_positions, 3, :)) update_positions(system, ComponentVector(; atoms=new_positions, positions.strain)) diff --git a/src/strain.jl b/src/strain.jl index 969a5a1..345ddb6 100644 --- a/src/strain.jl +++ b/src/strain.jl @@ -1,4 +1,3 @@ -export apply_voigt_strain, compute_voigt_strain function voigt_to_full(v) [v[1] .5*v[6] .5*v[5]; @@ -17,23 +16,6 @@ Transform a bounding box in list of vectors form in matrix form function bbox_to_matrix(bbox) reduce(hcat, bbox) end - -# TODO: deprecate. -@doc raw""" -Deform system by applying given strain. Unit cell vectors as well as atomic -positions are scaled. For a matrix of strains E, the matrix L of unit cell vectors -is scaled accodring to L' = (I + E) L. -Input strains should be given as a vector (Voigt notation). -""" -function apply_voigt_strain(system, strain) - deformation_tensor = I + voigt_to_full(strain) - new_lattice = eachcol( - deformation_tensor * bbox_to_matrix(bounding_box(system))) - # Also deform coordinates, since internally do not work in fractional coordinates. - new_positions = [deformation_tensor * pos for pos in position(system)] - new_generalized_positions = ComponentVector(atoms=new_positions , bounding_box=new_lattice) - update_positions(system, new_generalized_positions) -end @doc raw""" Compute the strain (in Voigt notation) needed to deform the unit cell `bouding_box` into diff --git a/test/atomsbase_interface.jl b/test/atomsbase_interface.jl index 64f990b..1185e9c 100644 --- a/test/atomsbase_interface.jl +++ b/test/atomsbase_interface.jl @@ -6,7 +6,6 @@ using UnitfulAtomic using GeometryOptimization using Random - using ComponentArrays silicon_supercell = TestCases.silicon_supercell @@ -16,34 +15,86 @@ σ = 0.1u"angstrom" new_positions = orig_positions + [σ * rand(Float64, size(v)) for v in orig_positions] new_lattice = orig_lattice + [σ * rand(Float64, size(v)) for v in orig_lattice] - new_general_pos = ComponentVector(atoms = new_positions, bounding_box = new_lattice) - new_system = update_positions(silicon_supercell, new_general_pos) + new_system = update_positions(silicon_supercell, new_positions, new_lattice) @test position(new_system) == new_positions @test bounding_box(new_system) == new_lattice end +@testitem "AtomsBase interface: cell deformation under strain" setup=[TestCases] begin + using AtomsBase + using Unitful + using UnitfulAtomic + using GeometryOptimization + using ComponentArrays + + silicon = TestCases.silicon + + # Test elongation along first component. + strain = Vector([1., 0, 0, 0, 0, 0.]) + new_general_pos = ComponentVector(;atoms = position(silicon), strain) + new_system = update_positions(silicon, new_general_pos) + + @test [v[1] for v in bounding_box(new_system)] ≈ 2. * [v[1] for v in bounding_box(silicon)] rtol=1e-3 +end + +@testitem "Stain interface: atoms positions deformation under strain" setup=[TestCases] begin + using AtomsBase + using Unitful + using UnitfulAtomic + using GeometryOptimization + using ComponentArrays + + silicon = TestCases.silicon + + # Test elongation along first component. + strain = Vector([1., 0, 0, 0, 0, 0.]) + new_general_pos = ComponentVector(atoms = collect.(position(silicon)); strain) + new_system = update_positions(silicon, new_general_pos) + @test [v[1] for v in position(new_system)] ≈ 2. * [v[1] for v in position(silicon)] rtol=1e-3 +end + @testitem "AtomsBase interface: check positions+cell updating (with mask)" setup=[TestCases] begin using AtomsBase using Unitful using UnitfulAtomic using GeometryOptimization using Random + using LinearAlgebra using ComponentArrays silicon_supercell = TestCases.silicon_supercell Random.seed!(1234) orig_positions = position(silicon_supercell) - orig_lattice = bounding_box(silicon_supercell) σ = 0.1u"angstrom" new_positions = orig_positions + [σ * rand(Float64, size(v)) for v in orig_positions] new_not_clamped_positions = reduce(vcat, new_positions) - new_lattice = orig_lattice + [σ * rand(Float64, size(v)) for v in orig_lattice] - new_general_pos = ComponentVector(atoms = new_not_clamped_positions, - bounding_box = reduce(vcat, new_lattice)) + + # Test elongation along first component. + strain = Vector([1., 0, 0, 0, 0, 0.]) + new_general_pos = ComponentVector(;atoms = new_not_clamped_positions, strain) new_system = update_not_clamped_positions(silicon_supercell, new_general_pos) - @test position(new_system) == new_positions - @test bounding_box(new_system) == new_lattice + new_positions_strained = [(I + voigt_to_full(strain)) * x for x in position(silicon_supercell)] + @test [v[1] for v in position(new_system)] ≈ 2. * [v[1] for v in new_positions] rtol=1e-3 + @test [v[1] for v in bounding_box(new_system)] ≈ 2. * [v[1] for v in bounding_box(silicon_supercell)] rtol=1e-3 +end + +@testitem "Stain interface: strain from deformation" setup=[TestCases] begin + bbox = [[1., 0, 0], + [0., 2., 0], + [0., 0, 3]] + bbox_pert = [[1., 0, 0], + [0., 4., 0], + [0., 0, 3]] + strain = compute_voigt_strain(bbox, bbox_pert) + @test strain ≈ [0., 1., 0, 0, 0, 0] rtol=1e-6 + + # Test with y-z rotation. + bbox_pert = [[6,0,0], + [0,2,1], + [0,1.5,3]] + strain = compute_voigt_strain(bbox, bbox_pert) + @test strain ≈ [5., 0, 0, 1., 0, 0] rtol=1e-6 end diff --git a/test/strain.jl b/test/strain.jl deleted file mode 100644 index ed67c08..0000000 --- a/test/strain.jl +++ /dev/null @@ -1,51 +0,0 @@ -#= Test Geometry Optimization on an aluminium supercell. -=# -@testitem "Stain interface: cell deformation under strain" setup=[TestCases] begin - using AtomsBase - using Unitful - using UnitfulAtomic - using GeometryOptimization - using Random - using ComponentArrays - - silicon = TestCases.silicon - - # Test elongation along first vector. - strain = Vector([1., 0, 0, 0, 0, 0.]) - new_silicon = apply_voigt_strain(silicon, strain) - @test [v[1] for v in bounding_box(new_silicon)] ≈ 2. * [v[1] for v in bounding_box(silicon)] rtol=1e-3 -end - -@testitem "Stain interface: atoms positions deformation under strain" setup=[TestCases] begin - using AtomsBase - using Unitful - using UnitfulAtomic - using GeometryOptimization - using Random - using ComponentArrays - - silicon = TestCases.silicon - - # Test elongation along first vector. - strain = Vector([1., 0, 0, 0, 0, 0.]) - new_silicon = apply_voigt_strain(silicon, strain) - @test [v[1] for v in position(new_silicon)] ≈ 2. * [v[1] for v in position(silicon)] rtol=1e-3 -end - -@testitem "Stain interface: strain from deformation" setup=[TestCases] begin - bbox = [[1., 0, 0], - [0., 2., 0], - [0., 0, 3]] - bbox_pert = [[1., 0, 0], - [0., 4., 0], - [0., 0, 3]] - strain = compute_voigt_strain(bbox, bbox_pert) - @test strain ≈ [0., 1., 0, 0, 0, 0] rtol=1e-6 - - # Test with y-z rotation. - bbox_pert = [[6,0,0], - [0,2,1], - [0,1.5,3]] - strain = compute_voigt_strain(bbox, bbox_pert) - @test strain ≈ [5., 0, 0, 1., 0, 0] rtol=1e-6 -end From 2079a6e1af2c400c463b448865f68fe14e60425f Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Sat, 9 Mar 2024 17:35:08 +0100 Subject: [PATCH 16/27] Fixed formatting. --- src/strain.jl | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/strain.jl b/src/strain.jl index 345ddb6..ed95f2a 100644 --- a/src/strain.jl +++ b/src/strain.jl @@ -1,12 +1,12 @@ function voigt_to_full(v) - [v[1] .5*v[6] .5*v[5]; - .5*v[6] v[2] .5*v[4]; - .5*v[5] .5*v[4] v[3]] + [v[1] .5*v[6] .5*v[5]; + .5*v[6] v[2] .5*v[4]; + .5*v[5] .5*v[4] v[3]] end function full_to_voigt(A) - [A[1, 1], A[2, 2], A[3, 3], 2. * A[2, 3], 2. * A[1, 3], 2. * A[1, 2]] + [A[1, 1], A[2, 2], A[3, 3], 2. * A[2, 3], 2. * A[1, 3], 2. * A[1, 2]] end """ @@ -14,7 +14,7 @@ Transform a bounding box in list of vectors form in matrix form (box vectors in the columns). """ function bbox_to_matrix(bbox) - reduce(hcat, bbox) + reduce(hcat, bbox) end @doc raw""" @@ -22,6 +22,6 @@ Compute the strain (in Voigt notation) needed to deform the unit cell `bouding_b `deformed_bounding_box`. """ function compute_voigt_strain(bbox, deformed_bbox) - strain_full = (bbox_to_matrix(deformed_bbox .- bbox)) / bbox_to_matrix(bbox) - full_to_voigt(strain_full) + strain_full = (bbox_to_matrix(deformed_bbox .- bbox)) / bbox_to_matrix(bbox) + full_to_voigt(strain_full) end From 0947b2baa8076d2b8cf7c96a80480cf6821af6f3 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Sat, 9 Mar 2024 17:38:06 +0100 Subject: [PATCH 17/27] Added matrix_to_bbox. --- src/GeometryOptimization.jl | 2 +- src/strain.jl | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/GeometryOptimization.jl b/src/GeometryOptimization.jl index 0e1ab3f..143c3fa 100644 --- a/src/GeometryOptimization.jl +++ b/src/GeometryOptimization.jl @@ -12,7 +12,7 @@ using ComponentArrays export update_positions, update_not_clamped_positions, clamp_atoms include("atomsbase_interface.jl") -export compute_voigt_strain, voigt_to_full +export compute_voigt_strain, voigt_to_full, bbox_to_matrix, matrix_to_bbox include("strain.jl") export minimize_energy! include("optimization.jl") diff --git a/src/strain.jl b/src/strain.jl index ed95f2a..ca58bb7 100644 --- a/src/strain.jl +++ b/src/strain.jl @@ -17,6 +17,10 @@ function bbox_to_matrix(bbox) reduce(hcat, bbox) end +function matrix_to_bbox(matrix) + eachcol(matrix) +end + @doc raw""" Compute the strain (in Voigt notation) needed to deform the unit cell `bouding_box` into `deformed_bounding_box`. From 551ee5aeff67777851b8a989005c2f17285d035d Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Sat, 9 Mar 2024 17:43:16 +0100 Subject: [PATCH 18/27] Removed DFTK-dependent updating of the calculator. --- src/optimization.jl | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/src/optimization.jl b/src/optimization.jl index a5d4494..fd28128 100644 --- a/src/optimization.jl +++ b/src/optimization.jl @@ -2,17 +2,6 @@ # Note that by default all particles in the system are assumed optimizable. # IMPORTANT: Note that we always work in cartesian coordinates. =# -using DFTK -export minimize_energy! - - -function update_state(original_system, new_system, state) - if bounding_box(original_system) != bounding_box(new_system) - return DFTK.DFTKState() - else - return state - end -end """ By default we work in cartesian coordinates. @@ -22,8 +11,6 @@ are used. function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwargs...) mask = not_clamped_mask(system) # mask is assumed not to change during optim. - # TODO: Note that this function will dispatch appropriately when called with - # a Component vector. f = function(x, p) new_system = update_not_clamped_positions(system, x * u"bohr") state = update_state(system, new_system, calculator.state) From 205b1490dc7399b0036d48e88d25502358580522 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Sat, 9 Mar 2024 18:00:10 +0100 Subject: [PATCH 19/27] Adapted to new calculator state handling. --- examples/Al_strain.jl | 1 - src/atomsbase_interface.jl | 2 +- src/optimization.jl | 4 ++-- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/examples/Al_strain.jl b/examples/Al_strain.jl index c0d305b..8ed4207 100644 --- a/examples/Al_strain.jl +++ b/examples/Al_strain.jl @@ -1,4 +1,3 @@ -using DFTK: occupation #= Test Geometry Optimization on an aluminium supercell. =# using LinearAlgebra diff --git a/src/atomsbase_interface.jl b/src/atomsbase_interface.jl index 4316f29..e068384 100644 --- a/src/atomsbase_interface.jl +++ b/src/atomsbase_interface.jl @@ -33,7 +33,7 @@ function update_positions(system, positions::ComponentVector) particles = [Atom(atom; position = collect((x for x in deformation_tensor * position))) for (atom, position) in zip(system, positions.atoms)] - bbox = eachcol(deformation_tensor * bbox_to_matrix(bounding_box(system))) + bbox = matrix_to_bbox(deformation_tensor * bbox_to_matrix(bounding_box(system))) AbstractSystem(system; particles, bounding_box=bbox) end diff --git a/src/optimization.jl b/src/optimization.jl index fd28128..6f10d17 100644 --- a/src/optimization.jl +++ b/src/optimization.jl @@ -13,7 +13,7 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa f = function(x, p) new_system = update_not_clamped_positions(system, x * u"bohr") - state = update_state(system, new_system, calculator.state) + state = update_state(nothing, calculator_state(calculator), system, new_system) energy = AtomsCalculators.potential_energy(new_system, calculator; state, kwargs...) austrip(energy) end @@ -34,7 +34,7 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa deformation_tensor = I + voigt_to_full(austrip.(x.strain)) new_system = update_not_clamped_positions(system, x * u"bohr") - state = update_state(system, new_system, calculator.state) + state = update_state(nothing, calculator_state(calculator), system, new_system) forces = AtomsCalculators.forces(new_system, calculator; state, kwargs...) # Translate the forces vectors on each particle to a single gradient for the optimization parameter. forces_concat = collect(Iterators.flatten([deformation_tensor * f for f in forces[mask]])) From a0312d365402dc1fde4d84254a766e8fa9f6f67e Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Mon, 11 Mar 2024 14:27:06 +0100 Subject: [PATCH 20/27] Updated Project.toml --- Project.toml | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/Project.toml b/Project.toml index 65191ac..1558c5d 100644 --- a/Project.toml +++ b/Project.toml @@ -4,11 +4,8 @@ authors = ["JuliaMolSim community"] version = "0.0.2" [deps] -ASEconvert = "3da9722f-58c2-4165-81be-b4d7253e8fd2" AtomsBase = "a963bdd2-2df7-4f54-a1ee-49d51e6be12a" AtomsCalculators = "a3e0e189-c65a-42c1-833c-339540406eb1" -AtomsIO = "1692102d-eeb4-4df9-807b-c9517f998d44" -AtomsIOPython = "9e4c859b-2281-48ef-8059-f50fe53c37b0" ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66" LineSearches = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" @@ -35,6 +32,8 @@ UnitfulAtomic = "1.0" julia = "1.9" [extras] +AtomsIO = "1692102d-eeb4-4df9-807b-c9517f998d44" +AtomsIOPython = "9e4c859b-2281-48ef-8059-f50fe53c37b0" ASEconvert = "3da9722f-58c2-4165-81be-b4d7253e8fd2" DFTK = "acf6eb54-70d9-11e9-0013-234b7a5f5337" EmpiricalPotentials = "38527215-9240-4c91-a638-d4250620c9e2" @@ -42,5 +41,5 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" TestItemRunner = "f8b46487-2199-4994-9208-9a1283c18c0a" [targets] -examples = ["DFTK", "ASEconvert", "EmpiricalPotentials"] +examples = ["DFTK", "ASEconvert", "EmpiricalPotentials", "AtomsIO", "AtomsIOPython"] test = ["Test", "TestItemRunner"] From 06679ee3382ad3688a9901bf3795fea399631c76 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Mon, 18 Mar 2024 10:45:06 +0100 Subject: [PATCH 21/27] Adding Manifest to repo for now, to ensure tests use correct revisions across packages. --- Manifest.toml | 2114 +++++++++++++++++++++++++++++++++++++++++++++++++ Project.toml | 3 +- 2 files changed, 2116 insertions(+), 1 deletion(-) create mode 100644 Manifest.toml diff --git a/Manifest.toml b/Manifest.toml new file mode 100644 index 0000000..18a8a08 --- /dev/null +++ b/Manifest.toml @@ -0,0 +1,2114 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.10.0" +manifest_format = "2.0" +project_hash = "e3f0ed0f05d10cce184e2706c320fafdad20fe87" + +[[deps.ADTypes]] +git-tree-sha1 = "41c37aa88889c171f1300ceac1313c06e891d245" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "0.2.6" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" +weakdeps = ["ChainRulesCore", "Test"] + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + +[[deps.AbstractTrees]] +git-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177" +uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" +version = "0.4.5" + +[[deps.Accessors]] +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "LinearAlgebra", "MacroTools", "Test"] +git-tree-sha1 = "cb96992f1bec110ad211b7e410e57ddf7944c16f" +uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +version = "0.1.35" + + [deps.Accessors.extensions] + AccessorsAxisKeysExt = "AxisKeys" + AccessorsIntervalSetsExt = "IntervalSets" + AccessorsStaticArraysExt = "StaticArrays" + AccessorsStructArraysExt = "StructArrays" + + [deps.Accessors.weakdeps] + AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5" + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + Requires = "ae029012-a4dd-5104-9daa-d747884805df" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + +[[deps.Adapt]] +deps = ["LinearAlgebra", "Requires"] +git-tree-sha1 = "cde29ddf7e5726c9fb511f340244ea3481267608" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "3.7.2" +weakdeps = ["StaticArrays"] + + [deps.Adapt.extensions] + AdaptStaticArraysExt = "StaticArrays" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.1" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra", "Requires", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "c5aeb516a84459e0318a02507d2261edad97eb75" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.7.1" + + [deps.ArrayInterface.extensions] + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" + +[[deps.AtomsBase]] +deps = ["LinearAlgebra", "PeriodicTable", "Printf", "Requires", "StaticArrays", "Unitful", "UnitfulAtomic"] +git-tree-sha1 = "995c2b6b17840cd87b722ce9c6cdd72f47bab545" +uuid = "a963bdd2-2df7-4f54-a1ee-49d51e6be12a" +version = "0.3.5" + +[[deps.AtomsCalculators]] +deps = ["AtomsBase", "StaticArrays", "Test", "Unitful"] +git-tree-sha1 = "0448c56b9aec90a8089207605e52e0a1cd29d02b" +repo-rev = "state" +repo-url = "https://github.com/CedricTravelletti/AtomsCalculators.jl" +uuid = "a3e0e189-c65a-42c1-833c-339540406eb1" +version = "0.1.1" + +[[deps.AxisAlgorithms]] +deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"] +git-tree-sha1 = "01b8ccb13d68535d73d2b0c23e39bd23155fb712" +uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950" +version = "1.1.0" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[deps.BenchmarkTools]] +deps = ["JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"] +git-tree-sha1 = "f1f03a9fa24271160ed7e73051fba3c1a759b53f" +uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +version = "1.4.0" + +[[deps.BitFlags]] +git-tree-sha1 = "2dc09997850d68179b69dafb58ae806167a32b1b" +uuid = "d1d4a3ce-64b1-5f1a-9ba4-7e7e69966f35" +version = "0.1.8" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "0c5f81f47bbbcf4aea7b2959135713459170798b" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.5" + +[[deps.Bravais]] +deps = ["LinearAlgebra", "StaticArrays"] +git-tree-sha1 = "b40f38f758a15e4fe9599d47bc73ffc2c96932ab" +uuid = "ada6cbde-b013-4edf-aa94-f6abe8bd6e6b" +version = "0.1.9" + +[[deps.Brillouin]] +deps = ["Bravais", "DirectQhull", "DocStringExtensions", "LinearAlgebra", "PrecompileTools", "Reexport", "Requires", "StaticArrays"] +git-tree-sha1 = "f0cdbec5f47651bd48410636c79191820bd09ea5" +uuid = "23470ee3-d0df-4052-8b1a-8cbd6363e7f0" +version = "0.5.15" + + [deps.Brillouin.extensions] + BrillouinMakieExt = "Makie" + BrillouinPlotlyJSExt = "PlotlyJS" + BrillouinSpglibExt = "Spglib" + + [deps.Brillouin.weakdeps] + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + PlotlyJS = "f0f68f2c-4968-5e81-91da-67840de0976a" + Spglib = "f761d5c5-86db-4880-b97f-9680a7cccfb5" + +[[deps.Bzip2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "9e2a6b69137e6969bab0152632dcb3bc108c8bdd" +uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" +version = "1.0.8+1" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Static"] +git-tree-sha1 = "601f7e7b3d36f18790e2caf83a882d88e9b71ff1" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.4" + +[[deps.CUDA_Driver_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg"] +git-tree-sha1 = "d01bfc999768f0a31ed36f5d22a76161fc63079c" +uuid = "4ee394cb-3365-5eb0-8335-949819d2adfc" +version = "0.7.0+1" + +[[deps.CUDA_Runtime_jll]] +deps = ["Artifacts", "CUDA_Driver_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"] +git-tree-sha1 = "8e25c009d2bf16c2c31a70a6e9e8939f7325cc84" +uuid = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" +version = "0.11.1+0" + +[[deps.Cairo_jll]] +deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "4b859a208b2397a7a623a03449e4636bdb17bcf2" +uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a" +version = "1.16.1+1" + +[[deps.ChainRulesCore]] +deps = ["Compat", "LinearAlgebra"] +git-tree-sha1 = "892b245fdec1c511906671b6a5e1bafa38a727c1" +uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +version = "1.22.0" +weakdeps = ["SparseArrays"] + + [deps.ChainRulesCore.extensions] + ChainRulesCoreSparseArraysExt = "SparseArrays" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "70232f82ffaab9dc52585e0dd043b5e0c6b714f1" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.12" + +[[deps.CodecBzip2]] +deps = ["Bzip2_jll", "Libdl", "TranscodingStreams"] +git-tree-sha1 = "9b1ca1aa6ce3f71b3d1840c538a8210a043625eb" +uuid = "523fee87-0ab8-5b00-afb7-3ecf72e48cfd" +version = "0.8.2" + +[[deps.CodecZlib]] +deps = ["TranscodingStreams", "Zlib_jll"] +git-tree-sha1 = "59939d8a997469ee05c4b4944560a820f9ba0d73" +uuid = "944b1d66-785c-5afd-91f1-9de20f533193" +version = "0.7.4" + +[[deps.ColorSchemes]] +deps = ["ColorTypes", "ColorVectorSpace", "Colors", "FixedPointNumbers", "PrecompileTools", "Random"] +git-tree-sha1 = "67c1f244b991cad9b0aa4b7540fb758c2488b129" +uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4" +version = "3.24.0" + +[[deps.ColorTypes]] +deps = ["FixedPointNumbers", "Random"] +git-tree-sha1 = "eb7f0f8307f71fac7c606984ea5fb2817275d6e4" +uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" +version = "0.11.4" + +[[deps.ColorVectorSpace]] +deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "Requires", "Statistics", "TensorCore"] +git-tree-sha1 = "a1f44953f2382ebb937d60dafbe2deea4bd23249" +uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4" +version = "0.10.0" +weakdeps = ["SpecialFunctions"] + + [deps.ColorVectorSpace.extensions] + SpecialFunctionsExt = "SpecialFunctions" + +[[deps.Colors]] +deps = ["ColorTypes", "FixedPointNumbers", "Reexport"] +git-tree-sha1 = "fc08e5930ee9a4e03f84bfb5211cb54e7769758a" +uuid = "5ae59095-9a9b-59fe-a467-6f913c188581" +version = "0.12.10" + +[[deps.CommonSolve]] +git-tree-sha1 = "0eee5eb66b1cf62cd6ad1b460238e60e4b09400c" +uuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2" +version = "0.2.4" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools", "Test"] +git-tree-sha1 = "7b8a93dba8af7e3b42fecabf646260105ac373f7" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.0" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "d2c021fbdde94f6cdaa799639adfeeaa17fd67f5" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.13.0" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.0.5+1" + +[[deps.ComponentArrays]] +deps = ["ArrayInterface", "ChainRulesCore", "ForwardDiff", "Functors", "LinearAlgebra", "PackageExtensionCompat", "StaticArrayInterface", "StaticArraysCore"] +git-tree-sha1 = "0bcacba787140924e954304216dcc09f968176ca" +uuid = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66" +version = "0.15.7" + + [deps.ComponentArrays.extensions] + ComponentArraysAdaptExt = "Adapt" + ComponentArraysConstructionBaseExt = "ConstructionBase" + ComponentArraysGPUArraysExt = "GPUArrays" + ComponentArraysRecursiveArrayToolsExt = "RecursiveArrayTools" + ComponentArraysReverseDiffExt = "ReverseDiff" + ComponentArraysSciMLBaseExt = "SciMLBase" + ComponentArraysTrackerExt = "Tracker" + ComponentArraysZygoteExt = "Zygote" + + [deps.ComponentArrays.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9" + GPUArrays = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" + RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.CompositionsBase]] +git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" +uuid = "a33af91c-f02d-484b-be07-31d278c5ca2b" +version = "0.1.2" +weakdeps = ["InverseFunctions"] + + [deps.CompositionsBase.extensions] + CompositionsBaseInverseFunctionsExt = "InverseFunctions" + +[[deps.ConcurrentUtilities]] +deps = ["Serialization", "Sockets"] +git-tree-sha1 = "9c4708e3ed2b799e6124b5673a712dda0b596a9b" +uuid = "f0e56b4a-5159-44fe-b623-3e5288b988bb" +version = "2.3.1" + +[[deps.CondaPkg]] +deps = ["JSON3", "Markdown", "MicroMamba", "Pidfile", "Pkg", "Preferences", "TOML"] +git-tree-sha1 = "e81c4263c7ef4eca4d645ef612814d72e9255b41" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.22" + +[[deps.ConsoleProgressMonitor]] +deps = ["Logging", "ProgressMeter"] +git-tree-sha1 = "3ab7b2136722890b9af903859afcf457fa3059e8" +uuid = "88cd18e8-d9cc-4ea6-8889-5259c0d15c8b" +version = "0.1.2" + +[[deps.ConstructionBase]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "c53fc348ca4d40d7b371e71fd52251839080cbc9" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.5.4" + + [deps.ConstructionBase.extensions] + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseStaticArraysExt = "StaticArrays" + + [deps.ConstructionBase.weakdeps] + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.Contour]] +git-tree-sha1 = "d05d9e7b7aedff4e5b51a029dced05cfb6125781" +uuid = "d38c429a-6771-53c6-b99e-75d170b6e991" +version = "0.6.2" + +[[deps.CpuId]] +deps = ["Markdown"] +git-tree-sha1 = "fcbb72b032692610bfbdb15018ac16a36cf2e406" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.1" + +[[deps.CrystallographyCore]] +deps = ["LinearAlgebra", "StaticArrays", "StructEquality"] +git-tree-sha1 = "521a8ed44455592672d887632eef056c1ba4678c" +uuid = "80545937-1184-4bc9-b283-396e91386b5c" +version = "0.3.3" + +[[deps.DFTK]] +deps = ["AbstractFFTs", "Artifacts", "AtomsBase", "AtomsCalculators", "Brillouin", "ChainRulesCore", "Dates", "DftFunctionals", "DocStringExtensions", "FFTW", "ForwardDiff", "GPUArraysCore", "Interpolations", "IterTools", "IterativeSolvers", "LazyArtifacts", "Libxc", "LineSearches", "LinearAlgebra", "LinearMaps", "LoopVectorization", "MPI", "Markdown", "Optim", "PeriodicTable", "PkgVersion", "Polynomials", "PrecompileTools", "Preferences", "Primes", "Printf", "PseudoPotentialIO", "Random", "Roots", "SparseArrays", "SpecialFunctions", "Spglib", "StaticArrays", "Statistics", "TimerOutputs", "Unitful", "UnitfulAtomic"] +git-tree-sha1 = "10bc44f1e451e1c52f59c441de50b78fe0cb383c" +repo-rev = "AtomsCalculators" +repo-url = "https://github.com/CedricTravelletti/DFTK.jl" +uuid = "acf6eb54-70d9-11e9-0013-234b7a5f5337" +version = "0.6.18" + + [deps.DFTK.extensions] + DFTKCUDAExt = "CUDA" + DFTKGenericLinearAlgebraExt = "GenericLinearAlgebra" + DFTKIntervalArithmeticExt = "IntervalArithmetic" + DFTKJLD2Ext = "JLD2" + DFTKJSON3Ext = "JSON3" + DFTKPlotsExt = "Plots" + DFTKWannier90Ext = "wannier90_jll" + DFTKWannierExt = "Wannier" + DFTKWriteVTKExt = "WriteVTK" + + [deps.DFTK.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + GenericLinearAlgebra = "14197337-ba66-59df-a3e3-ca00e7dcff7a" + IntervalArithmetic = "d1acc4aa-44c8-5952-acd4-ba5d80a2a253" + JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" + JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" + Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" + Wannier = "2b19380a-1f7e-4d7d-b1b8-8aa60b3321c9" + WriteVTK = "64499a7a-5c06-52f2-abe2-ccb03c286192" + wannier90_jll = "c5400fa0-8d08-52c2-913f-1e3f656c1ce9" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataStructures]] +deps = ["Compat", "InteractiveUtils", "OrderedCollections"] +git-tree-sha1 = "ac67408d9ddf207de5cfa9a97e114352430f01ed" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.18.16" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" + +[[deps.DelimitedFiles]] +deps = ["Mmap"] +git-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae" +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" +version = "1.9.1" + +[[deps.DftFunctionals]] +deps = ["ComponentArrays", "DiffResults", "ForwardDiff"] +git-tree-sha1 = "0ae7d5b8d65091e4b59f5859c85be4427c57de11" +uuid = "6bd331d2-b28d-4fd3-880e-1a1c7f37947f" +version = "0.2.4" + +[[deps.DiffResults]] +deps = ["StaticArraysCore"] +git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.1.0" + +[[deps.DiffRules]] +deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "23163d55f885173722d1e4cf0f6110cdbaf7e272" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.15.1" + +[[deps.DirectQhull]] +deps = ["Qhull_jll"] +git-tree-sha1 = "49951cee00be263d4dc187f38aa96333d74f4d1c" +uuid = "c3f9d41a-afcb-471e-bc58-0b8d83bd86f4" +version = "0.2.1" + +[[deps.Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" + +[[deps.DocStringExtensions]] +deps = ["LibGit2"] +git-tree-sha1 = "2fb1e02f2b635d0845df5d7c167fec4dd739b00d" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.3" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.6.0" + +[[deps.EnumX]] +git-tree-sha1 = "bdb1942cd4c45e3c678fd11569d5cccd80976237" +uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" +version = "1.0.4" + +[[deps.EpollShim_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8e9441ee83492030ace98f9789a654a6d0b1f643" +uuid = "2702e6a9-849d-5ed8-8c21-79e8b8f9ee43" +version = "0.0.20230411+0" + +[[deps.ExceptionUnwrapping]] +deps = ["Test"] +git-tree-sha1 = "dcb08a0d93ec0b1cdc4af184b26b591e9695423a" +uuid = "460bff9d-24e4-43bc-9d9f-a8973cb893f4" +version = "0.1.10" + +[[deps.Expat_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "4558ab818dcceaab612d1bb8c19cee87eda2b83c" +uuid = "2e619515-83b5-522b-bb60-26c02a35a201" +version = "2.5.0+0" + +[[deps.ExprTools]] +git-tree-sha1 = "27415f162e6028e81c72b82ef756bf321213b6ec" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.10" + +[[deps.EzXML]] +deps = ["Printf", "XML2_jll"] +git-tree-sha1 = "380053d61bb9064d6aa4a9777413b40429c79901" +uuid = "8f5d6c58-4d21-5cfd-889c-e3ad7ee6a615" +version = "1.2.0" + +[[deps.FFMPEG]] +deps = ["FFMPEG_jll"] +git-tree-sha1 = "b57e3acbe22f8484b4b5ff66a7499717fe1a9cc8" +uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" +version = "0.4.1" + +[[deps.FFMPEG_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] +git-tree-sha1 = "466d45dc38e15794ec7d5d63ec03d776a9aff36e" +uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5" +version = "4.4.4+1" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "4820348781ae578893311153d69049a93d05f39d" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.8.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "c6033cc3892d0ef5bb9cd29b7f2f0331ea5184ea" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.10+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" + +[[deps.FillArrays]] +deps = ["LinearAlgebra", "Random"] +git-tree-sha1 = "5b93957f6dcd33fc343044af3d48c215be2562f1" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.9.3" + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStatisticsExt = "Statistics" + + [deps.FillArrays.weakdeps] + PDMats = "90014a1f-27ba-587c-ab20-58faa44d9150" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[deps.FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Requires", "Setfield", "SparseArrays"] +git-tree-sha1 = "73d1214fec245096717847c62d389a5d2ac86504" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.22.0" + + [deps.FiniteDiff.extensions] + FiniteDiffBandedMatricesExt = "BandedMatrices" + FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices" + FiniteDiffStaticArraysExt = "StaticArrays" + + [deps.FiniteDiff.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.FixedPointNumbers]] +deps = ["Statistics"] +git-tree-sha1 = "335bfdceacc84c5cdf16aadc768aa5ddfc5383cc" +uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" +version = "0.8.4" + +[[deps.Fontconfig_jll]] +deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Pkg", "Zlib_jll"] +git-tree-sha1 = "21efd19106a55620a188615da6d3d06cd7f6ee03" +uuid = "a3f928ae-7b40-5064-980b-68af3947d34b" +version = "2.13.93+0" + +[[deps.Formatting]] +deps = ["Printf"] +git-tree-sha1 = "8339d61043228fdd3eb658d86c926cb282ae72a8" +uuid = "59287772-0a20-5a39-b81b-1366585eb4c0" +version = "0.4.2" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "cf0fe81336da9fb90944683b8c41984b08793dad" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "0.10.36" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + +[[deps.FreeType2_jll]] +deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "d8db6a5a2fe1381c1ea4ef2cab7c69c2de7f9ea0" +uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7" +version = "2.13.1+0" + +[[deps.FriBidi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "aa31987c2ba8704e23c6c8ba8a4f769d5d7e4f91" +uuid = "559328eb-81f9-559d-9380-de523a88c83c" +version = "1.0.10+0" + +[[deps.FunctionWrappers]] +git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.1.3" + +[[deps.FunctionWrappersWrappers]] +deps = ["FunctionWrappers"] +git-tree-sha1 = "b104d487b34566608f8b4e1c39fb0b10aa279ff8" +uuid = "77dc65aa-8811-40c2-897b-53d922fa7daf" +version = "0.1.3" + +[[deps.Functors]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "166c544477f97bbadc7179ede1c1868e0e9b426b" +uuid = "d9f16b24-f501-4c13-a1f2-28368ffc5196" +version = "0.4.7" + +[[deps.Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" + +[[deps.GLFW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll"] +git-tree-sha1 = "ff38ba61beff76b8f4acad8ab0c97ef73bb670cb" +uuid = "0656b61e-2033-5cc2-a64a-77c0f6c09b89" +version = "3.3.9+0" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "2d6ca471a6c7b536127afccfa7564b5b39227fe0" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.1.5" + +[[deps.GR]] +deps = ["Artifacts", "Base64", "DelimitedFiles", "Downloads", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Pkg", "Preferences", "Printf", "Random", "Serialization", "Sockets", "TOML", "Tar", "Test", "UUIDs", "p7zip_jll"] +git-tree-sha1 = "27442171f28c952804dede8ff72828a96f2bfc1f" +uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71" +version = "0.72.10" + +[[deps.GR_jll]] +deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "FreeType2_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Qt6Base_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "025d171a2847f616becc0f84c8dc62fe18f0f6dd" +uuid = "d2c73de3-f751-5644-a686-071e5b155ba9" +version = "0.72.10+0" + +[[deps.Gettext_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "XML2_jll"] +git-tree-sha1 = "9b02998aba7bf074d14de89f9d37ca24a1a0b046" +uuid = "78b55507-aeef-58d4-861c-77aaff3498b1" +version = "0.21.0+0" + +[[deps.Glib_jll]] +deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Zlib_jll"] +git-tree-sha1 = "e94c92c7bf4819685eb80186d51c43e71d4afa17" +uuid = "7746bdde-850d-59dc-9ae8-88ece973131d" +version = "2.76.5+0" + +[[deps.Graphite2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "344bf40dcab1073aca04aa0df4fb092f920e4011" +uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472" +version = "1.3.14+0" + +[[deps.Grisu]] +git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2" +uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe" +version = "1.0.2" + +[[deps.HTTP]] +deps = ["Base64", "CodecZlib", "ConcurrentUtilities", "Dates", "ExceptionUnwrapping", "Logging", "LoggingExtras", "MbedTLS", "NetworkOptions", "OpenSSL", "Random", "SimpleBufferStream", "Sockets", "URIs", "UUIDs"] +git-tree-sha1 = "ac7b73d562b8f4287c3b67b4c66a5395a19c1ae8" +uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3" +version = "1.10.2" + +[[deps.HarfBuzz_jll]] +deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg"] +git-tree-sha1 = "129acf094d168394e80ee1dc4bc06ec835e510a3" +uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566" +version = "2.8.1+1" + +[[deps.HostCPUFeatures]] +deps = ["BitTwiddlingConvenienceFunctions", "IfElse", "Libdl", "Static"] +git-tree-sha1 = "eb8fed28f4994600e29beef49744639d985a04b2" +uuid = "3e5b6fbb-0976-4d2c-9146-d79de83f2fb0" +version = "0.1.16" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "ca0f6bf568b4bfc807e7537f081c81e35ceca114" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.10.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.IntegerMathUtils]] +git-tree-sha1 = "b8ffb903da9f7b8cf695a8bead8e01814aa24b30" +uuid = "18e54dd8-cb9d-406c-a71d-865a43cbb235" +version = "0.1.2" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "5fdf2fe6724d8caabf43b557b84ce53f3b7e2f6b" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2024.0.2+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[deps.Interpolations]] +deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"] +git-tree-sha1 = "88a101217d7cb38a7b481ccd50d21876e1d1b0e0" +uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" +version = "0.15.1" +weakdeps = ["Unitful"] + + [deps.Interpolations.extensions] + InterpolationsUnitfulExt = "Unitful" + +[[deps.InverseFunctions]] +deps = ["Test"] +git-tree-sha1 = "68772f49f54b479fa88ace904f6127f0a3bb2e46" +uuid = "3587e190-3f89-42d0-90ee-14403ec27112" +version = "0.1.12" + +[[deps.IrrationalConstants]] +git-tree-sha1 = "630b497eafcc20001bba38a4651b327dcfc491d2" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.2.2" + +[[deps.IterTools]] +git-tree-sha1 = "42d5f897009e7ff2cf88db414a389e5ed1bdd023" +uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e" +version = "1.10.0" + +[[deps.IterativeSolvers]] +deps = ["LinearAlgebra", "Printf", "Random", "RecipesBase", "SparseArrays"] +git-tree-sha1 = "59545b0a2b27208b0650df0a46b8e3019f85055b" +uuid = "42fd0dbc-a981-5370-80f2-aaf504508153" +version = "0.9.4" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLFzf]] +deps = ["Pipe", "REPL", "Random", "fzf_jll"] +git-tree-sha1 = "a53ebe394b71470c7f97c2e7e170d51df21b17af" +uuid = "1019f520-868f-41f5-a6de-eb00f4b6a39c" +version = "0.1.7" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7e5d6779a1e09a36db2a7b6cff50942a0a7d0fca" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.5.0" + +[[deps.JSON]] +deps = ["Dates", "Mmap", "Parsers", "Unicode"] +git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "0.21.4" + +[[deps.JSON3]] +deps = ["Dates", "Mmap", "Parsers", "PrecompileTools", "StructTypes", "UUIDs"] +git-tree-sha1 = "eb3edce0ed4fa32f75a0a11217433c31d56bd48b" +uuid = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" +version = "1.14.0" + + [deps.JSON3.extensions] + JSON3ArrowExt = ["ArrowTypes"] + + [deps.JSON3.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + +[[deps.JpegTurbo_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "60b1194df0a3298f460063de985eae7b01bc011a" +uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8" +version = "3.0.1+0" + +[[deps.LAME_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "f6250b16881adf048549549fba48b1161acdac8c" +uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" +version = "3.100.1+0" + +[[deps.LERC_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "bf36f528eec6634efc60d7ec062008f171071434" +uuid = "88015f11-f218-50d7-93a8-a6af411a945d" +version = "3.0.0+1" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d986ce2d884d49126836ea94ed5bfb0f12679713" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "15.0.7+0" + +[[deps.LZO_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6" +uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac" +version = "2.10.1+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "50901ebc375ed41dbf8058da26f9de442febbbec" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.3.1" + +[[deps.Latexify]] +deps = ["Formatting", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "OrderedCollections", "Printf", "Requires"] +git-tree-sha1 = "f428ae552340899a935973270b8d98e5a31c49fe" +uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" +version = "0.16.1" + + [deps.Latexify.extensions] + DataFramesExt = "DataFrames" + SymEngineExt = "SymEngine" + + [deps.Latexify.weakdeps] + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + SymEngine = "123dc426-2d89-5057-bbad-38513e3affd8" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "62edfee3211981241b57ff1cedf4d74d79519277" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.15" + +[[deps.Lazy]] +deps = ["MacroTools"] +git-tree-sha1 = "1370f8202dac30758f3c345f9909b97f53d87d3f" +uuid = "50d2b5c4-7a5e-59d5-8109-a42b560f39c0" +version = "0.15.1" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" + +[[deps.LeftChildRightSiblingTrees]] +deps = ["AbstractTrees"] +git-tree-sha1 = "fb6803dafae4a5d62ea5cab204b1e657d9737e7f" +uuid = "1d6d02ad-be62-4b6b-8a6d-2f90e265016e" +version = "0.2.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "0.6.4" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.4.0+0" + +[[deps.LibGit2]] +deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.6.4+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.0+1" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[deps.Libffi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "0b4a5d71f3e5200a7dff793393e09dfc2d874290" +uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490" +version = "3.2.2+1" + +[[deps.Libgcrypt_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgpg_error_jll", "Pkg"] +git-tree-sha1 = "64613c82a59c120435c067c2b809fc61cf5166ae" +uuid = "d4300ac3-e22c-5743-9152-c294e39db1e4" +version = "1.8.7+0" + +[[deps.Libglvnd_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll", "Xorg_libXext_jll"] +git-tree-sha1 = "6f73d1dd803986947b2c750138528a999a6c7733" +uuid = "7e76a0d4-f3c7-5321-8279-8d96eeed0f29" +version = "1.6.0+0" + +[[deps.Libgpg_error_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "c333716e46366857753e273ce6a69ee0945a6db9" +uuid = "7add5ba3-2f88-524e-9cd5-f83b8a55f7b8" +version = "1.42.0+0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "f9557a255370125b405568f9767d6d195822a175" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.17.0+0" + +[[deps.Libmount_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "9c30530bf0effd46e15e0fdcf2b8636e78cbbd73" +uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9" +version = "2.35.0+0" + +[[deps.Libtiff_jll]] +deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "XZ_jll", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "2da088d113af58221c52828a80378e16be7d037a" +uuid = "89763e89-9b03-5906-acba-b20f662cd828" +version = "4.5.1+1" + +[[deps.Libuuid_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "7f3efec06033682db852f8b3bc3c1d2b0a0ab066" +uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700" +version = "2.36.0+0" + +[[deps.Libxc]] +deps = ["Libxc_GPU_jll", "Libxc_jll", "Requires"] +git-tree-sha1 = "a8af8c180bbd455aed17a950f2efa86f8b1d10bf" +uuid = "66e17ffc-8502-11e9-23b5-c9248d0eb96d" +version = "0.3.18" + + [deps.Libxc.extensions] + LibxcCudaExt = "CUDA" + + [deps.Libxc.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + +[[deps.Libxc_GPU_jll]] +deps = ["Artifacts", "CUDA_Runtime_jll", "CompilerSupportLibraries_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg", "TOML"] +git-tree-sha1 = "ee321f68686361802f2ddb978dae441a024e61ea" +uuid = "25af9330-9b41-55d4-a324-1a83c0a0a1ac" +version = "6.1.0+2" + +[[deps.Libxc_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "c5516f2b1655a103225e69477e3df009347580df" +uuid = "a56a6d9d-ad03-58af-ab61-878bf78270d6" +version = "6.1.0+0" + +[[deps.LineSearches]] +deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf"] +git-tree-sha1 = "7bbea35cec17305fc70a0e5b4641477dc0789d9d" +uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +version = "7.2.0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[deps.LinearMaps]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "9948d6f8208acfebc3e8cf4681362b2124339e7e" +uuid = "7a12625a-238d-50fd-b39a-03d52299707e" +version = "3.11.2" +weakdeps = ["ChainRulesCore", "SparseArrays", "Statistics"] + + [deps.LinearMaps.extensions] + LinearMapsChainRulesCoreExt = "ChainRulesCore" + LinearMapsSparseArraysExt = "SparseArrays" + LinearMapsStatisticsExt = "Statistics" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "18144f3e9cbe9b15b070288eef858f71b291ce37" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "0.3.27" + + [deps.LogExpFunctions.extensions] + LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" + LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" + LogExpFunctionsInverseFunctionsExt = "InverseFunctions" + + [deps.LogExpFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ChangesOfVariables = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[deps.LoggingExtras]] +deps = ["Dates", "Logging"] +git-tree-sha1 = "c1dd6d7978c12545b4179fb6153b9250c96b0075" +uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" +version = "1.0.3" + +[[deps.LoopVectorization]] +deps = ["ArrayInterface", "CPUSummary", "CloseOpenIntervals", "DocStringExtensions", "HostCPUFeatures", "IfElse", "LayoutPointers", "LinearAlgebra", "OffsetArrays", "PolyesterWeave", "PrecompileTools", "SIMDTypes", "SLEEFPirates", "Static", "StaticArrayInterface", "ThreadingUtilities", "UnPack", "VectorizationBase"] +git-tree-sha1 = "0f5648fbae0d015e3abe5867bca2b362f67a5894" +uuid = "bdcacae8-1622-11e9-2a5c-532679323890" +version = "0.12.166" +weakdeps = ["ChainRulesCore", "ForwardDiff", "SpecialFunctions"] + + [deps.LoopVectorization.extensions] + ForwardDiffExt = ["ChainRulesCore", "ForwardDiff"] + SpecialFunctionsExt = "SpecialFunctions" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "72dc3cf284559eb8f53aa593fe62cb33f83ed0c0" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2024.0.0+0" + +[[deps.MPI]] +deps = ["Distributed", "DocStringExtensions", "Libdl", "MPICH_jll", "MPIPreferences", "MPItrampoline_jll", "MicrosoftMPI_jll", "OpenMPI_jll", "PkgVersion", "PrecompileTools", "Requires", "Serialization", "Sockets"] +git-tree-sha1 = "b4d8707e42b693720b54f0b3434abee6dd4d947a" +uuid = "da04e1cc-30fd-572f-bb4f-1f8673147195" +version = "0.20.16" + + [deps.MPI.extensions] + AMDGPUExt = "AMDGPU" + CUDAExt = "CUDA" + + [deps.MPI.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + +[[deps.MPICH_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Hwloc_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "MPIPreferences", "TOML"] +git-tree-sha1 = "656036b9ed6f942d35e536e249600bc31d0f9df8" +uuid = "7cb0a576-ebde-5e09-9194-50597f1243b4" +version = "4.2.0+0" + +[[deps.MPIPreferences]] +deps = ["Libdl", "Preferences"] +git-tree-sha1 = "8f6af051b9e8ec597fa09d8885ed79fd582f33c9" +uuid = "3da0fdf6-3ccc-4f1b-acd9-58baa6c99267" +version = "0.1.10" + +[[deps.MPItrampoline_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Hwloc_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "MPIPreferences", "TOML"] +git-tree-sha1 = "77c3bd69fdb024d75af38713e883d0f249ce19c2" +uuid = "f1f71cc9-e9ae-5b93-9b94-4fe0e1ad3748" +version = "5.3.2+0" + +[[deps.MacroTools]] +deps = ["Markdown", "Random"] +git-tree-sha1 = "2fa9ee3e63fd3a4f7a9a4f4744a52f4856de82df" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.13" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[deps.MathOptInterface]] +deps = ["BenchmarkTools", "CodecBzip2", "CodecZlib", "DataStructures", "ForwardDiff", "JSON", "LinearAlgebra", "MutableArithmetics", "NaNMath", "OrderedCollections", "PrecompileTools", "Printf", "SparseArrays", "SpecialFunctions", "Test", "Unicode"] +git-tree-sha1 = "569a003f93d7c64068d3afaab908d21f67a22cd5" +uuid = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" +version = "1.25.3" + +[[deps.MbedTLS]] +deps = ["Dates", "MbedTLS_jll", "MozillaCACerts_jll", "NetworkOptions", "Random", "Sockets"] +git-tree-sha1 = "c067a280ddc25f196b5e7df3877c6b226d390aaf" +uuid = "739be429-bea8-5141-9913-cc70e7f3736d" +version = "1.1.9" + +[[deps.MbedTLS_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.2+1" + +[[deps.Measures]] +git-tree-sha1 = "c13304c81eec1ed3af7fc20e75fb6b26092a1102" +uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e" +version = "0.3.2" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "011cab361eae7bcd7d278f0a7a00ff9c69000c51" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.14" + +[[deps.MicrosoftMPI_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "f12a29c4400ba812841c6ace3f4efbb6dbb3ba01" +uuid = "9237b28f-5490-5468-be7b-bb81f5f5e6cf" +version = "10.1.4+2" + +[[deps.Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "f66bdc5de519e8f8ae43bdc598782d35a25b1272" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "1.1.0" + +[[deps.Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2023.1.10" + +[[deps.MutableArithmetics]] +deps = ["LinearAlgebra", "SparseArrays", "Test"] +git-tree-sha1 = "302fd161eb1c439e4115b51ae456da4e9984f130" +uuid = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" +version = "1.4.1" + +[[deps.NLSolversBase]] +deps = ["DiffResults", "Distributed", "FiniteDiff", "ForwardDiff"] +git-tree-sha1 = "a0b464d183da839699f4c79e7606d9d186ec172c" +uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" +version = "7.8.3" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "0877504529a3e5c3343c6f8b4c0381e57e4387e4" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.0.2" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.2.0" + +[[deps.OffsetArrays]] +git-tree-sha1 = "6a731f2b5c03157418a20c12195eb4b74c8f8621" +uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" +version = "1.13.0" +weakdeps = ["Adapt"] + + [deps.OffsetArrays.extensions] + OffsetArraysAdaptExt = "Adapt" + +[[deps.Ogg_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "887579a3eb005446d514ab7aeac5d1d027658b8f" +uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051" +version = "1.3.5+1" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.23+2" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.1+2" + +[[deps.OpenMPI_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Hwloc_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "MPIPreferences", "PMIx_jll", "TOML", "Zlib_jll", "libevent_jll", "prrte_jll"] +git-tree-sha1 = "f46caf663e069027a06942d00dced37f1eb3d8ad" +uuid = "fe0851c0-eecd-5654-98d4-656369965a5c" +version = "5.0.2+0" + +[[deps.OpenSSL]] +deps = ["BitFlags", "Dates", "MozillaCACerts_jll", "OpenSSL_jll", "Sockets"] +git-tree-sha1 = "51901a49222b09e3743c65b8847687ae5fc78eb2" +uuid = "4d8831e6-92b7-49fb-bdf8-b643e874388c" +version = "1.4.1" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "60e3045590bd104a16fefb12836c00c0ef8c7f8c" +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.0.13+0" + +[[deps.OpenSpecFun_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.5+0" + +[[deps.Optim]] +deps = ["Compat", "FillArrays", "ForwardDiff", "LineSearches", "LinearAlgebra", "MathOptInterface", "NLSolversBase", "NaNMath", "Parameters", "PositiveFactorizations", "Printf", "SparseArrays", "StatsBase"] +git-tree-sha1 = "d024bfb56144d947d4fafcd9cb5cafbe3410b133" +uuid = "429524aa-4258-5aef-a3af-852621145aeb" +version = "1.9.2" + +[[deps.Optimization]] +deps = ["ADTypes", "ArrayInterface", "ConsoleProgressMonitor", "DocStringExtensions", "LinearAlgebra", "Logging", "LoggingExtras", "Pkg", "Printf", "ProgressLogging", "Reexport", "Requires", "SciMLBase", "SparseArrays", "SymbolicIndexingInterface", "TerminalLoggers"] +git-tree-sha1 = "a9c6823c7166c8e583f815396fffd004e9d81073" +uuid = "7f7a1694-90dd-40f0-9382-eb1efda571ba" +version = "3.20.0" + + [deps.Optimization.extensions] + OptimizationEnzymeExt = "Enzyme" + OptimizationFiniteDiffExt = "FiniteDiff" + OptimizationForwardDiffExt = "ForwardDiff" + OptimizationMTKExt = "ModelingToolkit" + OptimizationReverseDiffExt = "ReverseDiff" + OptimizationSparseDiffExt = ["SparseDiffTools", "Symbolics", "ReverseDiff"] + OptimizationTrackerExt = "Tracker" + OptimizationZygoteExt = "Zygote" + + [deps.Optimization.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseDiffTools = "47a9eef4-7e08-11e9-0b38-333d64bd3804" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.OptimizationOptimJL]] +deps = ["Optim", "Optimization", "Reexport", "SparseArrays"] +git-tree-sha1 = "bea24fb320d58cb639e3cbc63f8eedde6c667bd3" +uuid = "36348300-93cb-4f02-beb5-3c3902f8871e" +version = "0.1.14" + +[[deps.Opus_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "51a08fb14ec28da2ec7a927c4337e4332c2a4720" +uuid = "91d4177d-7536-5919-b921-800302f37372" +version = "1.3.2+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "dfdf5519f235516220579f949664f1bf44e741c5" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.6.3" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.42.0+1" + +[[deps.PMIx_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "Zlib_jll", "libevent_jll"] +git-tree-sha1 = "8b3b19351fa24791f94d7ae85faf845ca1362541" +uuid = "32165bc3-0280-59bc-8c0b-c33b6203efab" +version = "4.2.7+0" + +[[deps.PackageExtensionCompat]] +git-tree-sha1 = "fb28e33b8a95c4cee25ce296c817d89cc2e53518" +uuid = "65ce6f38-6b18-4e1d-a461-8949797d7930" +version = "1.0.2" +weakdeps = ["Requires", "TOML"] + +[[deps.Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.3" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "8489905bcdbcfac64d1daa51ca07c0d8f0283821" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.8.1" + +[[deps.PeriodicTable]] +deps = ["Base64", "Unitful"] +git-tree-sha1 = "238aa6298007565529f911b734e18addd56985e1" +uuid = "7b2266bf-644c-5ea3-82d8-af4bbd25a884" +version = "1.2.1" + +[[deps.Pidfile]] +deps = ["FileWatching", "Test"] +git-tree-sha1 = "2d8aaf8ee10df53d0dfb9b8ee44ae7c04ced2b03" +uuid = "fa939f87-e72e-5be4-a000-7fc836dbe307" +version = "1.3.0" + +[[deps.Pipe]] +git-tree-sha1 = "6842804e7867b115ca9de748a0cf6b364523c16d" +uuid = "b98c9c47-44ae-5843-9183-064241ee97a0" +version = "1.3.0" + +[[deps.Pixman_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "64779bc4c9784fee475689a1752ef4d5747c5e87" +uuid = "30392449-352a-5448-841d-b1acce4e97dc" +version = "0.42.2+0" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.10.0" + +[[deps.PkgVersion]] +deps = ["Pkg"] +git-tree-sha1 = "f9501cc0430a26bc3d156ae1b5b0c1b47af4d6da" +uuid = "eebad327-c553-4316-9ea0-9fa01ccd7688" +version = "0.3.3" + +[[deps.PlotThemes]] +deps = ["PlotUtils", "Statistics"] +git-tree-sha1 = "1f03a2d339f42dca4a4da149c7e15e9b896ad899" +uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a" +version = "3.1.0" + +[[deps.PlotUtils]] +deps = ["ColorSchemes", "Colors", "Dates", "PrecompileTools", "Printf", "Random", "Reexport", "Statistics"] +git-tree-sha1 = "862942baf5663da528f66d24996eb6da85218e76" +uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043" +version = "1.4.0" + +[[deps.Plots]] +deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "JLFzf", "JSON", "LaTeXStrings", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "PrecompileTools", "Preferences", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "RelocatableFolders", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs", "UnicodeFun", "UnitfulLatexify", "Unzip"] +git-tree-sha1 = "ccee59c6e48e6f2edf8a5b64dc817b6729f99eb5" +uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +version = "1.39.0" + + [deps.Plots.extensions] + FileIOExt = "FileIO" + GeometryBasicsExt = "GeometryBasics" + IJuliaExt = "IJulia" + ImageInTerminalExt = "ImageInTerminal" + UnitfulExt = "Unitful" + + [deps.Plots.weakdeps] + FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" + GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326" + IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" + ImageInTerminal = "d8c32880-2388-543b-8c61-d9f865259254" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "240d7170f5ffdb285f9427b92333c3463bf65bf6" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.1" + +[[deps.Polynomials]] +deps = ["LinearAlgebra", "RecipesBase", "Setfield", "SparseArrays"] +git-tree-sha1 = "a9c7a523d5ed375be3983db190f6a5874ae9286d" +uuid = "f27b6e38-b328-58d1-80ce-0feddd5e7a45" +version = "4.0.6" + + [deps.Polynomials.extensions] + PolynomialsChainRulesCoreExt = "ChainRulesCore" + PolynomialsFFTWExt = "FFTW" + PolynomialsMakieCoreExt = "MakieCore" + PolynomialsMutableArithmeticsExt = "MutableArithmetics" + + [deps.Polynomials.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" + MakieCore = "20f20a25-4f0e-4fdf-b5d1-57303727442b" + MutableArithmetics = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" + +[[deps.PositiveFactorizations]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "17275485f373e6673f7e7f97051f703ed5b15b20" +uuid = "85a6dd25-e78a-55b7-8502-1745935b8125" +version = "0.2.4" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "03b4c25b43cb84cee5c90aa9b5ea0a78fd848d2f" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.2.0" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "00805cd429dcb4870060ff49ef443486c262e38e" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.4.1" + +[[deps.Primes]] +deps = ["IntegerMathUtils"] +git-tree-sha1 = "1d05623b5952aed1307bf8b43bec8b8d1ef94b6e" +uuid = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae" +version = "0.5.5" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[deps.Profile]] +deps = ["Printf"] +uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" + +[[deps.ProgressLogging]] +deps = ["Logging", "SHA", "UUIDs"] +git-tree-sha1 = "80d919dee55b9c50e8d9e2da5eeafff3fe58b539" +uuid = "33c8b6b6-d38a-422a-b730-caa89a2f386c" +version = "0.1.4" + +[[deps.ProgressMeter]] +deps = ["Distributed", "Printf"] +git-tree-sha1 = "00099623ffee15972c16111bcf84c58a0051257c" +uuid = "92933f4c-e287-5a05-a399-4b506db050ca" +version = "1.9.0" + +[[deps.PseudoPotentialIO]] +deps = ["EzXML", "LinearAlgebra"] +git-tree-sha1 = "88cf9598d70015889c99920ff3dacca0eb26ae90" +uuid = "cb339c56-07fa-4cb2-923a-142469552264" +version = "0.1.1" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Pkg", "REPL", "Requires", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "4999b3e4e9bdeba0b61ede19cc45a2128db21cdc" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.15" + +[[deps.Qhull_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be2449911f4d6cfddacdf7efc895eceda3eee5c1" +uuid = "784f63db-0788-585a-bace-daefebcd302b" +version = "8.0.1003+0" + +[[deps.Qt6Base_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Vulkan_Loader_jll", "Xorg_libSM_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_cursor_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "libinput_jll", "xkbcommon_jll"] +git-tree-sha1 = "37b7bb7aabf9a085e0044307e1717436117f2b3b" +uuid = "c0090381-4147-56d7-9ebc-da0b1113ec56" +version = "6.5.3+1" + +[[deps.REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[deps.Ratios]] +deps = ["Requires"] +git-tree-sha1 = "1342a47bf3260ee108163042310d26f2be5ec90b" +uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439" +version = "0.4.5" +weakdeps = ["FixedPointNumbers"] + + [deps.Ratios.extensions] + RatiosFixedPointNumbersExt = "FixedPointNumbers" + +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + +[[deps.RecipesPipeline]] +deps = ["Dates", "NaNMath", "PlotUtils", "PrecompileTools", "RecipesBase"] +git-tree-sha1 = "45cf9fd0ca5839d06ef333c8201714e888486342" +uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c" +version = "0.6.12" + +[[deps.RecursiveArrayTools]] +deps = ["Adapt", "ArrayInterface", "DocStringExtensions", "GPUArraysCore", "IteratorInterfaceExtensions", "LinearAlgebra", "RecipesBase", "SparseArrays", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables"] +git-tree-sha1 = "09c906ce9fa905d40e0706cdb62422422091c22f" +uuid = "731186ca-8d62-57ce-b412-fbd966d074cd" +version = "3.8.1" + + [deps.RecursiveArrayTools.extensions] + RecursiveArrayToolsFastBroadcastExt = "FastBroadcast" + RecursiveArrayToolsForwardDiffExt = "ForwardDiff" + RecursiveArrayToolsMeasurementsExt = "Measurements" + RecursiveArrayToolsMonteCarloMeasurementsExt = "MonteCarloMeasurements" + RecursiveArrayToolsReverseDiffExt = ["ReverseDiff", "Zygote"] + RecursiveArrayToolsTrackerExt = "Tracker" + RecursiveArrayToolsZygoteExt = "Zygote" + + [deps.RecursiveArrayTools.weakdeps] + FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.RelocatableFolders]] +deps = ["SHA", "Scratch"] +git-tree-sha1 = "ffdaf70d81cf6ff22c2b6e733c900c3321cab864" +uuid = "05181044-ff0b-4ac5-8273-598c1e38db00" +version = "1.0.1" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "838a3a4188e2ded87a4f9f184b4b0d78a1e91cb7" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.0" + +[[deps.Roots]] +deps = ["Accessors", "ChainRulesCore", "CommonSolve", "Printf"] +git-tree-sha1 = "754acd3031a9f2eaf6632ba4850b1c01fe4460c1" +uuid = "f2b01f46-fcfa-551c-844a-d8ac1e96c665" +version = "2.1.2" + + [deps.Roots.extensions] + RootsForwardDiffExt = "ForwardDiff" + RootsIntervalRootFindingExt = "IntervalRootFinding" + RootsSymPyExt = "SymPy" + RootsSymPyPythonCallExt = "SymPyPythonCall" + + [deps.Roots.weakdeps] + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + IntervalRootFinding = "d2bf35a9-74e0-55ec-b149-d360ff49b807" + SymPy = "24249f21-da20-56a4-8eb1-6a02cf4ae2e6" + SymPyPythonCall = "bc8888f7-b21e-4b7c-a06a-5d9c9496438c" + +[[deps.RuntimeGeneratedFunctions]] +deps = ["ExprTools", "SHA", "Serialization"] +git-tree-sha1 = "6aacc5eefe8415f47b3e34214c1d79d2674a0ba2" +uuid = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47" +version = "0.5.12" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEFPirates]] +deps = ["IfElse", "Static", "VectorizationBase"] +git-tree-sha1 = "3aac6d68c5e57449f5b9b865c9ba50ac2970c4cf" +uuid = "476501e8-09a2-5ece-8869-fb82de89a1fa" +version = "0.6.42" + +[[deps.SciMLBase]] +deps = ["ADTypes", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FillArrays", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "PrecompileTools", "Preferences", "Printf", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLOperators", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables", "TruncatedStacktraces"] +git-tree-sha1 = "33e40003f4ef424e8a8700e0a3a189c6ece2af27" +uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462" +version = "2.26.1" + + [deps.SciMLBase.extensions] + SciMLBaseChainRulesCoreExt = "ChainRulesCore" + SciMLBaseMakieExt = "Makie" + SciMLBasePartialFunctionsExt = "PartialFunctions" + SciMLBasePyCallExt = "PyCall" + SciMLBasePythonCallExt = "PythonCall" + SciMLBaseRCallExt = "RCall" + SciMLBaseZygoteExt = "Zygote" + + [deps.SciMLBase.weakdeps] + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" + RCall = "6f49c342-dc21-5d91-9882-a32aef131414" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.SciMLOperators]] +deps = ["ArrayInterface", "DocStringExtensions", "Lazy", "LinearAlgebra", "Setfield", "SparseArrays", "StaticArraysCore", "Tricks"] +git-tree-sha1 = "51ae235ff058a64815e0a2c34b1db7578a06813d" +uuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" +version = "0.3.7" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "3bac05bc7e74a75fd9cba4295cde4045d9fe2386" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.2.1" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.Setfield]] +deps = ["ConstructionBase", "Future", "MacroTools", "StaticArraysCore"] +git-tree-sha1 = "e2cc6d8c88613c05e1defb55170bf5ff211fbeac" +uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" +version = "1.1.1" + +[[deps.SharedArrays]] +deps = ["Distributed", "Mmap", "Random", "Serialization"] +uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" + +[[deps.Showoff]] +deps = ["Dates", "Grisu"] +git-tree-sha1 = "91eddf657aca81df9ae6ceb20b959ae5653ad1de" +uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f" +version = "1.0.3" + +[[deps.SimpleBufferStream]] +git-tree-sha1 = "874e8867b33a00e784c8a7e4b60afe9e037b74e1" +uuid = "777ac1f9-54b0-4bf8-805c-2214025038e7" +version = "1.1.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[deps.SortingAlgorithms]] +deps = ["DataStructures"] +git-tree-sha1 = "66e0a8e672a0bdfca2c3f5937efb8538b9ddc085" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "1.2.1" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.10.0" + +[[deps.SpecialFunctions]] +deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] +git-tree-sha1 = "e2cfc4012a19088254b3950b85c3c1d8882d864d" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.3.1" +weakdeps = ["ChainRulesCore"] + + [deps.SpecialFunctions.extensions] + SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + +[[deps.Spglib]] +deps = ["CrystallographyCore", "StaticArrays", "StructEquality", "spglib_jll"] +git-tree-sha1 = "3ba34ed365df96e26e78c192de4448ad1ec4998e" +uuid = "f761d5c5-86db-4880-b97f-9680a7cccfb5" +version = "0.9.4" + +[[deps.Static]] +deps = ["IfElse"] +git-tree-sha1 = "d2fdac9ff3906e27f7a618d47b676941baa6c80c" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "0.8.10" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "Requires", "SparseArrays", "Static", "SuiteSparse"] +git-tree-sha1 = "5d66818a39bb04bf328e92bc933ec5b4ee88e436" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.5.0" +weakdeps = ["OffsetArrays", "StaticArrays"] + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "fba11dbe2562eecdfcac49a05246af09ee64d055" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.8.1" +weakdeps = ["ChainRulesCore", "Statistics"] + + [deps.StaticArrays.extensions] + StaticArraysChainRulesCoreExt = "ChainRulesCore" + StaticArraysStatisticsExt = "Statistics" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "36b3d696ce6366023a0ea192b4cd442268995a0d" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.2" + +[[deps.Statistics]] +deps = ["LinearAlgebra", "SparseArrays"] +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.10.0" + +[[deps.StatsAPI]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1ff449ad350c9c4cbc756624d6f8a8c3ef56d3ed" +uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" +version = "1.7.0" + +[[deps.StatsBase]] +deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] +git-tree-sha1 = "1d77abd07f617c4868c33d4f5b9e1dbb2643c9cf" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.34.2" + +[[deps.StructEquality]] +deps = ["Compat"] +git-tree-sha1 = "192a9f1de3cfef80ab1a4ba7b150bb0e11ceedcf" +uuid = "6ec83bb0-ed9f-11e9-3b4c-2b04cb4e219c" +version = "2.1.0" + +[[deps.StructTypes]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "ca4bccb03acf9faaf4137a9abc1881ed1841aa70" +uuid = "856f2bd8-1eba-4b0a-8007-ebc267875bd4" +version = "1.10.0" + +[[deps.SuiteSparse]] +deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"] +uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.2.1+1" + +[[deps.SymbolicIndexingInterface]] +git-tree-sha1 = "dc7186d456f9ff2bef0cb754a59758920f0b2382" +uuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5" +version = "0.3.6" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "cb76cf677714c095e535e3501ac7954732aeea2d" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.11.1" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.TensorCore]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6" +uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50" +version = "0.1.1" + +[[deps.TerminalLoggers]] +deps = ["LeftChildRightSiblingTrees", "Logging", "Markdown", "Printf", "ProgressLogging", "UUIDs"] +git-tree-sha1 = "f133fab380933d042f6796eda4e130272ba520ca" +uuid = "5d786b92-1e48-4d6f-9151-6b4477ca9bed" +version = "0.1.7" + +[[deps.Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "eda08f7e9818eb53661b3deb74e3159460dfbc27" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.2" + +[[deps.TimerOutputs]] +deps = ["ExprTools", "Printf"] +git-tree-sha1 = "f548a9e9c490030e545f72074a41edfd0e5bcdd7" +uuid = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f" +version = "0.5.23" + +[[deps.TranscodingStreams]] +git-tree-sha1 = "54194d92959d8ebaa8e26227dbe3cdefcdcd594f" +uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" +version = "0.10.3" +weakdeps = ["Random", "Test"] + + [deps.TranscodingStreams.extensions] + TestExt = ["Test", "Random"] + +[[deps.Tricks]] +git-tree-sha1 = "eae1bb484cd63b36999ee58be2de6c178105112f" +uuid = "410a4b4d-49e4-4fbc-ab6d-cb71b17b3775" +version = "0.1.8" + +[[deps.TruncatedStacktraces]] +deps = ["InteractiveUtils", "MacroTools", "Preferences"] +git-tree-sha1 = "ea3e54c2bdde39062abf5a9758a23735558705e1" +uuid = "781d530d-4396-4725-bb49-402e4bee1e77" +version = "1.4.0" + +[[deps.URIs]] +git-tree-sha1 = "67db6cc7b3821e19ebe75791a9dd19c9b1188f2b" +uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4" +version = "1.5.1" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[[deps.UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" + +[[deps.UnicodeFun]] +deps = ["REPL"] +git-tree-sha1 = "53915e50200959667e78a92a418594b428dffddf" +uuid = "1cfade01-22cf-5700-b092-accc4b62d6e1" +version = "0.4.1" + +[[deps.Unitful]] +deps = ["Dates", "LinearAlgebra", "Random"] +git-tree-sha1 = "3c793be6df9dd77a0cf49d80984ef9ff996948fa" +uuid = "1986cc42-f94f-5a68-af5c-568840ba703d" +version = "1.19.0" +weakdeps = ["ConstructionBase", "InverseFunctions"] + + [deps.Unitful.extensions] + ConstructionBaseUnitfulExt = "ConstructionBase" + InverseFunctionsUnitfulExt = "InverseFunctions" + +[[deps.UnitfulAtomic]] +deps = ["Unitful"] +git-tree-sha1 = "903be579194534af1c4b4778d1ace676ca042238" +uuid = "a7773ee8-282e-5fa2-be4e-bd808c38a91a" +version = "1.0.0" + +[[deps.UnitfulLatexify]] +deps = ["LaTeXStrings", "Latexify", "Unitful"] +git-tree-sha1 = "e2d817cc500e960fdbafcf988ac8436ba3208bfd" +uuid = "45397f5d-5981-4c77-b2b3-fc36d6e9b728" +version = "1.6.3" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.Unzip]] +git-tree-sha1 = "ca0969166a028236229f63514992fc073799bb78" +uuid = "41fe7b60-77ed-43a1-b4f0-825fd5a5650d" +version = "0.2.0" + +[[deps.VectorizationBase]] +deps = ["ArrayInterface", "CPUSummary", "HostCPUFeatures", "IfElse", "LayoutPointers", "Libdl", "LinearAlgebra", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "7209df901e6ed7489fe9b7aa3e46fb788e15db85" +uuid = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f" +version = "0.21.65" + +[[deps.Vulkan_Loader_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Wayland_jll", "Xorg_libX11_jll", "Xorg_libXrandr_jll", "xkbcommon_jll"] +git-tree-sha1 = "2f0486047a07670caad3a81a075d2e518acc5c59" +uuid = "a44049a8-05dd-5a78-86c9-5fde0876e88c" +version = "1.3.243+0" + +[[deps.Wayland_jll]] +deps = ["Artifacts", "EpollShim_jll", "Expat_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg", "XML2_jll"] +git-tree-sha1 = "7558e29847e99bc3f04d6569e82d0f5c54460703" +uuid = "a2964d1f-97da-50d4-b82a-358c7fce9d89" +version = "1.21.0+1" + +[[deps.Wayland_protocols_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "93f43ab61b16ddfb2fd3bb13b3ce241cafb0e6c9" +uuid = "2381bf8a-dfd0-557d-9999-79630e7b1b91" +version = "1.31.0+0" + +[[deps.WoodburyMatrices]] +deps = ["LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "c1a7aa6219628fcd757dede0ca95e245c5cd9511" +uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6" +version = "1.0.0" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "801cbe47eae69adc50f36c3caec4758d2650741b" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.12.2+0" + +[[deps.XSLT_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"] +git-tree-sha1 = "91844873c4085240b95e795f692c4cec4d805f8a" +uuid = "aed1982a-8fda-507f-9586-7b0439959a61" +version = "1.1.34+0" + +[[deps.XZ_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "ac88fb95ae6447c8dda6a5503f3bafd496ae8632" +uuid = "ffd25f8a-64ca-5728-b0f7-c24cf3aae800" +version = "5.4.6+0" + +[[deps.Xorg_libICE_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "e5becd4411063bdcac16be8b66fc2f9f6f1e8fe5" +uuid = "f67eecfb-183a-506d-b269-f58e52b52d7c" +version = "1.0.10+1" + +[[deps.Xorg_libSM_jll]] +deps = ["Libdl", "Pkg", "Xorg_libICE_jll"] +git-tree-sha1 = "4a9d9e4c180e1e8119b5ffc224a7b59d3a7f7e18" +uuid = "c834827a-8449-5923-a945-d239c165b7dd" +version = "1.2.3+0" + +[[deps.Xorg_libX11_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xtrans_jll"] +git-tree-sha1 = "afead5aba5aa507ad5a3bf01f58f82c8d1403495" +uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc" +version = "1.8.6+0" + +[[deps.Xorg_libXau_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6035850dcc70518ca32f012e46015b9beeda49d8" +uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec" +version = "1.0.11+0" + +[[deps.Xorg_libXcursor_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "12e0eb3bc634fa2080c1c37fccf56f7c22989afd" +uuid = "935fb764-8cf2-53bf-bb30-45bb1f8bf724" +version = "1.2.0+4" + +[[deps.Xorg_libXdmcp_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "34d526d318358a859d7de23da945578e8e8727b7" +uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05" +version = "1.1.4+0" + +[[deps.Xorg_libXext_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"] +git-tree-sha1 = "b7c0aa8c376b31e4852b360222848637f481f8c3" +uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3" +version = "1.3.4+4" + +[[deps.Xorg_libXfixes_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"] +git-tree-sha1 = "0e0dc7431e7a0587559f9294aeec269471c991a4" +uuid = "d091e8ba-531a-589c-9de9-94069b037ed8" +version = "5.0.3+4" + +[[deps.Xorg_libXi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXfixes_jll"] +git-tree-sha1 = "89b52bc2160aadc84d707093930ef0bffa641246" +uuid = "a51aa0fd-4e3c-5386-b890-e753decda492" +version = "1.7.10+4" + +[[deps.Xorg_libXinerama_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll"] +git-tree-sha1 = "26be8b1c342929259317d8b9f7b53bf2bb73b123" +uuid = "d1454406-59df-5ea1-beac-c340f2130bc3" +version = "1.1.4+4" + +[[deps.Xorg_libXrandr_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "34cea83cb726fb58f325887bf0612c6b3fb17631" +uuid = "ec84b674-ba8e-5d96-8ba1-2a689ba10484" +version = "1.5.2+4" + +[[deps.Xorg_libXrender_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"] +git-tree-sha1 = "19560f30fd49f4d4efbe7002a1037f8c43d43b96" +uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa" +version = "0.9.10+4" + +[[deps.Xorg_libpthread_stubs_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8fdda4c692503d44d04a0603d9ac0982054635f9" +uuid = "14d82f49-176c-5ed1-bb49-ad3f5cbd8c74" +version = "0.1.1+0" + +[[deps.Xorg_libxcb_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"] +git-tree-sha1 = "b4bfde5d5b652e22b9c790ad00af08b6d042b97d" +uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b" +version = "1.15.0+0" + +[[deps.Xorg_libxkbfile_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "730eeca102434283c50ccf7d1ecdadf521a765a4" +uuid = "cc61e674-0454-545c-8b26-ed2c68acab7a" +version = "1.1.2+0" + +[[deps.Xorg_xcb_util_cursor_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_jll", "Xorg_xcb_util_renderutil_jll"] +git-tree-sha1 = "04341cb870f29dcd5e39055f895c39d016e18ccd" +uuid = "e920d4aa-a673-5f3a-b3d7-f755a4d47c43" +version = "0.1.4+0" + +[[deps.Xorg_xcb_util_image_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"] +git-tree-sha1 = "0fab0a40349ba1cba2c1da699243396ff8e94b97" +uuid = "12413925-8142-5f55-bb0e-6d7ca50bb09b" +version = "0.4.0+1" + +[[deps.Xorg_xcb_util_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll"] +git-tree-sha1 = "e7fd7b2881fa2eaa72717420894d3938177862d1" +uuid = "2def613f-5ad1-5310-b15b-b15d46f528f5" +version = "0.4.0+1" + +[[deps.Xorg_xcb_util_keysyms_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"] +git-tree-sha1 = "d1151e2c45a544f32441a567d1690e701ec89b00" +uuid = "975044d2-76e6-5fbe-bf08-97ce7c6574c7" +version = "0.4.0+1" + +[[deps.Xorg_xcb_util_renderutil_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"] +git-tree-sha1 = "dfd7a8f38d4613b6a575253b3174dd991ca6183e" +uuid = "0d47668e-0667-5a69-a72c-f761630bfb7e" +version = "0.3.9+1" + +[[deps.Xorg_xcb_util_wm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"] +git-tree-sha1 = "e78d10aab01a4a154142c5006ed44fd9e8e31b67" +uuid = "c22f9ab0-d5fe-5066-847c-f4bb1cd4e361" +version = "0.4.1+1" + +[[deps.Xorg_xkbcomp_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxkbfile_jll"] +git-tree-sha1 = "330f955bc41bb8f5270a369c473fc4a5a4e4d3cb" +uuid = "35661453-b289-5fab-8a00-3d9160c6a3a4" +version = "1.4.6+0" + +[[deps.Xorg_xkeyboard_config_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xkbcomp_jll"] +git-tree-sha1 = "691634e5453ad362044e2ad653e79f3ee3bb98c3" +uuid = "33bec58e-1273-512f-9401-5d533626f822" +version = "2.39.0+0" + +[[deps.Xorg_xtrans_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e92a1a012a10506618f10b7047e478403a046c77" +uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10" +version = "1.5.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.13+1" + +[[deps.Zstd_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "49ce682769cd5de6c72dcf1b94ed7790cd08974c" +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.5+0" + +[[deps.eudev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "gperf_jll"] +git-tree-sha1 = "431b678a28ebb559d224c0b6b6d01afce87c51ba" +uuid = "35ca27e7-8b34-5b7f-bca9-bdc33f59eb06" +version = "3.2.9+0" + +[[deps.fzf_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a68c9655fbe6dfcab3d972808f1aafec151ce3f8" +uuid = "214eeab7-80f7-51ab-84ad-2988db7cef09" +version = "0.43.0+0" + +[[deps.gperf_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "3516a5630f741c9eecb3720b1ec9d8edc3ecc033" +uuid = "1a1c6b14-54f6-533d-8383-74cd7377aa70" +version = "3.1.1+0" + +[[deps.libaom_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "3a2ea60308f0996d26f1e5354e10c24e9ef905d4" +uuid = "a4ae2306-e953-59d6-aa16-d00cac43593b" +version = "3.4.0+0" + +[[deps.libass_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"] +git-tree-sha1 = "5982a94fcba20f02f42ace44b9894ee2b140fe47" +uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" +version = "0.15.1+0" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.8.0+1" + +[[deps.libevdev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "141fe65dc3efabb0b1d5ba74e91f6ad26f84cc22" +uuid = "2db6ffa8-e38f-5e21-84af-90c45d0032cc" +version = "1.11.0+0" + +[[deps.libevent_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "OpenSSL_jll"] +git-tree-sha1 = "f04ec6d9a186115fb38f858f05c0c4e1b7fc9dcb" +uuid = "1080aeaf-3a6a-583e-a51c-c537b09f60ec" +version = "2.1.13+1" + +[[deps.libfdk_aac_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "daacc84a041563f965be61859a36e17c4e4fcd55" +uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" +version = "2.0.2+0" + +[[deps.libinput_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "eudev_jll", "libevdev_jll", "mtdev_jll"] +git-tree-sha1 = "ad50e5b90f222cfe78aa3d5183a20a12de1322ce" +uuid = "36db933b-70db-51c0-b978-0f229ee0e533" +version = "1.18.0+0" + +[[deps.libpng_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "873b4f805771d3e4bafe63af759a26ea8ca84d14" +uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f" +version = "1.6.42+0" + +[[deps.libvorbis_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll", "Pkg"] +git-tree-sha1 = "b910cb81ef3fe6e78bf6acee440bda86fd6ae00c" +uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a" +version = "1.3.7+1" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "66d07957bcf7e4930d933195aed484078dd8cbb5" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "1.4.9+0" + +[[deps.mtdev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "814e154bdb7be91d78b6802843f76b6ece642f11" +uuid = "009596ad-96f7-51b1-9f1b-5ce2d5e8a71e" +version = "1.1.6+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.52.0+1" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.4.0+2" + +[[deps.prrte_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "PMIx_jll", "libevent_jll"] +git-tree-sha1 = "5adb2d7a18a30280feb66cad6f1a1dfdca2dc7b0" +uuid = "eb928a42-fffd-568d-ab9c-3f5d54fc65b9" +version = "3.0.2+0" + +[[deps.spglib_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "bc328924cf4975fe49e6416f7e1622e8ceda55e8" +uuid = "ac4a9f1e-bdb2-5204-990c-47c8b2f70d4e" +version = "2.1.0+0" + +[[deps.x264_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "4fea590b89e6ec504593146bf8b988b2c00922b2" +uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a" +version = "2021.5.5+0" + +[[deps.x265_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "ee567a171cce03570d77ad3a43e90218e38937a9" +uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76" +version = "3.5.0+0" + +[[deps.xkbcommon_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Wayland_jll", "Wayland_protocols_jll", "Xorg_libxcb_jll", "Xorg_xkeyboard_config_jll"] +git-tree-sha1 = "9c304562909ab2bab0262639bd4f444d7bc2be37" +uuid = "d8fb68d0-12a3-5cfd-a85a-d49703b185fd" +version = "1.4.1+1" diff --git a/Project.toml b/Project.toml index 1558c5d..4cb372a 100644 --- a/Project.toml +++ b/Project.toml @@ -7,6 +7,7 @@ version = "0.0.2" AtomsBase = "a963bdd2-2df7-4f54-a1ee-49d51e6be12a" AtomsCalculators = "a3e0e189-c65a-42c1-833c-339540406eb1" ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66" +DFTK = "acf6eb54-70d9-11e9-0013-234b7a5f5337" LineSearches = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" Optimization = "7f7a1694-90dd-40f0-9382-eb1efda571ba" @@ -32,9 +33,9 @@ UnitfulAtomic = "1.0" julia = "1.9" [extras] +ASEconvert = "3da9722f-58c2-4165-81be-b4d7253e8fd2" AtomsIO = "1692102d-eeb4-4df9-807b-c9517f998d44" AtomsIOPython = "9e4c859b-2281-48ef-8059-f50fe53c37b0" -ASEconvert = "3da9722f-58c2-4165-81be-b4d7253e8fd2" DFTK = "acf6eb54-70d9-11e9-0013-234b7a5f5337" EmpiricalPotentials = "38527215-9240-4c91-a638-d4250620c9e2" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" From e3a8b02672864ef567f3351954adaaffa84adaf4 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Tue, 19 Mar 2024 17:04:36 +0100 Subject: [PATCH 22/27] Modified examples --- examples/H2.jl | 8 +++++--- examples/H2_LJ.jl | 9 ++++++--- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/examples/H2.jl b/examples/H2.jl index 4e97f41..e0af1b4 100644 --- a/examples/H2.jl +++ b/examples/H2.jl @@ -22,11 +22,13 @@ system = clamp_atoms(system, [1]) model_kwargs = (; functionals = [:lda_x, :lda_c_pw]) basis_kwargs = (; kgrid = [1, 1, 1], Ecut = 10.0) scf_kwargs = (; tol = 1e-7) -calculator = DFTKCalculator(system; model_kwargs, basis_kwargs, scf_kwargs) +calculator = DFTKCalculator(; model_kwargs, basis_kwargs, scf_kwargs, verbose=true) solver = OptimizationOptimJL.LBFGS() -optim_options = (f_tol=1e-32, iterations=20, show_trace=true) +# optim_options = (f_tol=1e-32, iterations=20, show_trace=true) +optim_options = (; solver, f_tol=1e-10, g_tol=1e-5, iterations=30, + show_trace=true, store_trace = true, allow_f_increases=true) -results = minimize_energy!(system, calculator; solver=solver, optim_options...) +results = minimize_energy!(system, calculator; solver, procedure="relax", optim_options...) println(results) @printf "Bond length: %3f bohrs.\n" norm(results.minimizer[1:end]) diff --git a/examples/H2_LJ.jl b/examples/H2_LJ.jl index 594f05d..7ba65fe 100644 --- a/examples/H2_LJ.jl +++ b/examples/H2_LJ.jl @@ -17,7 +17,10 @@ system = periodic_system(atoms, bounding_box) lj = LennardJones(-1.17u"hartree", 0.743u"angstrom", 1, 1, 0.6u"nm") solver = OptimizationOptimJL.LBFGS() -optim_options = (f_tol=1e-6, iterations=100, show_trace=false) +jk +optim_options = (; solver, f_tol=1e-10, g_tol=1e-5, iterations=30, + show_trace=true, store_trace = true, allow_f_increases=true) -results = minimize_energy!(system, lj; solver=solver, optim_options...) -println("Bond length: $(norm(results.minimizer[1:3] - results.minimizer[4:end])).") +results = minimize_energy!(system, calculator; solver, procedure="relax", optim_options...) +println(results) +@printf "Bond length: %3f bohrs.\n" norm(results.minimizer[1:end]) From b2d33fed5a74c1e40f4abfaccbd4c3964783d8cd Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Tue, 19 Mar 2024 18:34:40 +0100 Subject: [PATCH 23/27] Updated examples. --- examples/H2_LJ.jl | 6 ++---- examples/TiAl_EmpiricalPotentials.jl | 3 ++- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/examples/H2_LJ.jl b/examples/H2_LJ.jl index 7ba65fe..d87eda5 100644 --- a/examples/H2_LJ.jl +++ b/examples/H2_LJ.jl @@ -1,5 +1,4 @@ -#= Test Geometry Optimization on an aluminium supercell. -=# +using Printf using LinearAlgebra using EmpiricalPotentials using Unitful @@ -14,10 +13,9 @@ bounding_box = 10.0u"angstrom" .* [[1, 0, 0.], [0., 1, 0], [0., 0, 1]] atoms = [:H => [0, 0, 0.0]u"bohr", :H => [0, 0, 1.9]u"bohr"] system = periodic_system(atoms, bounding_box) -lj = LennardJones(-1.17u"hartree", 0.743u"angstrom", 1, 1, 0.6u"nm") +calculator = LennardJones(-1.17u"hartree", 0.743u"angstrom", 1, 1, 0.6u"nm") solver = OptimizationOptimJL.LBFGS() -jk optim_options = (; solver, f_tol=1e-10, g_tol=1e-5, iterations=30, show_trace=true, store_trace = true, allow_f_increases=true) diff --git a/examples/TiAl_EmpiricalPotentials.jl b/examples/TiAl_EmpiricalPotentials.jl index 0aa3a85..43ae4a2 100644 --- a/examples/TiAl_EmpiricalPotentials.jl +++ b/examples/TiAl_EmpiricalPotentials.jl @@ -20,7 +20,8 @@ end system = AbstractSystem(data; particles) solver = OptimizationOptimJL.LBFGS() -optim_options = (f_tol=1e-8, g_tol=1e-8, iterations=10, show_trace=true) +optim_options = (; solver, f_tol=1e-10, g_tol=1e-5, iterations=30, + show_trace=true, store_trace = true, allow_f_increases=true) results = minimize_energy!(system, lj; solver, optim_options...) println(results) From fa82d3c032ab9460a785d86e4f40cbbcd7ea22f6 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Mon, 25 Mar 2024 13:23:26 +0100 Subject: [PATCH 24/27] Switched to natural units for the inside of the optimization loop. --- examples/Si_verification.jl | 2 +- src/atomsbase_interface.jl | 37 ++++++++++++++++++++++--------------- src/optimization.jl | 8 ++++---- 3 files changed, 27 insertions(+), 20 deletions(-) diff --git a/examples/Si_verification.jl b/examples/Si_verification.jl index 4acd976..70af0c8 100644 --- a/examples/Si_verification.jl +++ b/examples/Si_verification.jl @@ -31,7 +31,7 @@ calculator = DFTKCalculator(; model_kwargs, basis_kwargs, scf_kwargs, verbose=tr Random.seed!(1234) σ = 0.2u"bohr" bounding_box_pert = [v + σ * rand(Float64, size(v)) for v in bounding_box(system)] -system_pert = update_positions(system, position(system); bounding_box=bounding_box_pert) +system_pert = update_positions(system, position(system), bounding_box_pert) using LineSearches diff --git a/src/atomsbase_interface.jl b/src/atomsbase_interface.jl index e068384..b26df97 100644 --- a/src/atomsbase_interface.jl +++ b/src/atomsbase_interface.jl @@ -19,6 +19,13 @@ function update_positions(system, positions::AbstractVector{<:AbstractVector{<:U AbstractSystem(system; particles, bounding_box) end +# Method for natural units. +function update_positions(system, positions::AbstractVector{<:AbstractVector{<:Real}}, + bounding_box=bounding_box(system)) + particles = [Atom(atom; position=position * u"bohr") for (atom, position) in zip(system, positions)] + AbstractSystem(system; particles, bounding_box) +end + @doc raw""" Creates a new system based on ``system`` but with atoms positions updated to the ones provided and lattice vectors deformed according @@ -30,23 +37,27 @@ component `atoms` and `strain`. function update_positions(system, positions::ComponentVector) deformation_tensor = I + voigt_to_full(positions.strain) # TODO: Do we want to apply the strain to the atoms too? - particles = [Atom(atom; position = collect((x for x in deformation_tensor * position))) for (atom, position) - in zip(system, positions.atoms)] - + strained_positions = [collect((x for x in deformation_tensor * position)) + for position in positions.atoms] bbox = matrix_to_bbox(deformation_tensor * bbox_to_matrix(bounding_box(system))) - AbstractSystem(system; particles, bounding_box=bbox) + update_positions(system, strained_positions, bbox) +end + +function set_masked_positions(system, positions_flat) + mask = not_clamped_mask(system) + new_positions = [austrip.(x) for x in deepcopy(position(system))] + positions_flat = austrip.(positions_flat) + new_positions[mask] = reinterpret(reshape, SVector{3, eltype(positions_flat)}, + reshape(positions_flat, 3, :)) + return new_positions end @doc raw""" -======= Creates a new system based on ``system`` where the non clamped positions are updated to the ones provided (in the order in which they appear in the system). """ -function update_not_clamped_positions(system, positions::AbstractVector{<:Unitful.Length}) - mask = not_clamped_mask(system) - new_positions = deepcopy(position(system)) - new_positions[mask] = reinterpret(reshape, SVector{3, eltype(positions)}, - reshape(positions, 3, :)) +function update_not_clamped_positions(system, positions::AbstractVector) + new_positions = set_masked_positions(system, positions) update_positions(system, new_positions) end @@ -58,11 +69,7 @@ coordinates and that the `strain` component should be a 6-vector. """ function update_not_clamped_positions(system, positions::ComponentVector) - mask = not_clamped_mask(system) - new_positions = deepcopy(position(system)) - atoms_positions = collect((x for x in positions.atoms)) - new_positions[mask] = reinterpret(reshape, SVector{3, eltype(atoms_positions)}, - reshape(atoms_positions, 3, :)) + new_positions = set_masked_positions(system, positions.atoms) update_positions(system, ComponentVector(; atoms=new_positions, positions.strain)) end diff --git a/src/optimization.jl b/src/optimization.jl index 6f10d17..ee4cc1a 100644 --- a/src/optimization.jl +++ b/src/optimization.jl @@ -12,14 +12,14 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa mask = not_clamped_mask(system) # mask is assumed not to change during optim. f = function(x, p) - new_system = update_not_clamped_positions(system, x * u"bohr") + new_system = update_not_clamped_positions(system, x) state = update_state(nothing, calculator_state(calculator), system, new_system) energy = AtomsCalculators.potential_energy(new_system, calculator; state, kwargs...) austrip(energy) end function g!(G, x, p) - new_system = update_not_clamped_positions(system, x * u"bohr") + new_system = update_not_clamped_positions(system, x) # TODO: Determine if here we need a call to update_state. energy = AtomsCalculators.potential_energy(new_system, calculator; kwargs...) @@ -32,7 +32,7 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa end function g!(G::ComponentVector, x::ComponentVector, p) deformation_tensor = I + voigt_to_full(austrip.(x.strain)) - new_system = update_not_clamped_positions(system, x * u"bohr") + new_system = update_not_clamped_positions(system, x) state = update_state(nothing, calculator_state(calculator), system, new_system) forces = AtomsCalculators.forces(new_system, calculator; state, kwargs...) @@ -41,7 +41,7 @@ function Optimization.OptimizationFunction(system, calculator; pressure=0.0, kwa # NOTE: minus sign since forces are opposite to gradient. G.atoms .= - austrip.(forces_concat) - virial = AtomsCalculators.virial(new_system, calculator) + virial = austrip.(AtomsCalculators.virial(new_system, calculator)) G.strain .= - full_to_voigt(virial / deformation_tensor) end OptimizationFunction(f; grad=g!) From 39c54d4fa3efc7eee14da06bb38ec37ddf0b89f5 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Tue, 26 Mar 2024 11:45:12 +0100 Subject: [PATCH 25/27] Changed Manifest to track correct revision. --- Manifest.toml | 12 +++++++++--- Project.toml | 5 +++-- 2 files changed, 12 insertions(+), 5 deletions(-) diff --git a/Manifest.toml b/Manifest.toml index 18a8a08..dfe3f67 100644 --- a/Manifest.toml +++ b/Manifest.toml @@ -2,13 +2,19 @@ julia_version = "1.10.0" manifest_format = "2.0" -project_hash = "e3f0ed0f05d10cce184e2706c320fafdad20fe87" +project_hash = "4d33414bf9793afb1fd7fbb60fd6c8b915896018" [[deps.ADTypes]] git-tree-sha1 = "41c37aa88889c171f1300ceac1313c06e891d245" uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" version = "0.2.6" +[[deps.ASEconvert]] +deps = ["AtomsBase", "AtomsCalculators", "CondaPkg", "PeriodicTable", "PythonCall", "Unitful", "UnitfulAtomic"] +git-tree-sha1 = "859d94df6922a66e304e8b4e0c82510f0b6eea11" +uuid = "3da9722f-58c2-4165-81be-b4d7253e8fd2" +version = "0.1.6" + [[deps.AbstractFFTs]] deps = ["LinearAlgebra"] git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" @@ -91,7 +97,7 @@ version = "0.3.5" [[deps.AtomsCalculators]] deps = ["AtomsBase", "StaticArrays", "Test", "Unitful"] -git-tree-sha1 = "0448c56b9aec90a8089207605e52e0a1cd29d02b" +git-tree-sha1 = "b790ed8afef77ff523ad1c09a7eb73bb065687c3" repo-rev = "state" repo-url = "https://github.com/CedricTravelletti/AtomsCalculators.jl" uuid = "a3e0e189-c65a-42c1-833c-339540406eb1" @@ -343,7 +349,7 @@ version = "0.3.3" [[deps.DFTK]] deps = ["AbstractFFTs", "Artifacts", "AtomsBase", "AtomsCalculators", "Brillouin", "ChainRulesCore", "Dates", "DftFunctionals", "DocStringExtensions", "FFTW", "ForwardDiff", "GPUArraysCore", "Interpolations", "IterTools", "IterativeSolvers", "LazyArtifacts", "Libxc", "LineSearches", "LinearAlgebra", "LinearMaps", "LoopVectorization", "MPI", "Markdown", "Optim", "PeriodicTable", "PkgVersion", "Polynomials", "PrecompileTools", "Preferences", "Primes", "Printf", "PseudoPotentialIO", "Random", "Roots", "SparseArrays", "SpecialFunctions", "Spglib", "StaticArrays", "Statistics", "TimerOutputs", "Unitful", "UnitfulAtomic"] -git-tree-sha1 = "10bc44f1e451e1c52f59c441de50b78fe0cb383c" +git-tree-sha1 = "a7b33533c28b97be08975b30d04d8b152909f432" repo-rev = "AtomsCalculators" repo-url = "https://github.com/CedricTravelletti/DFTK.jl" uuid = "acf6eb54-70d9-11e9-0013-234b7a5f5337" diff --git a/Project.toml b/Project.toml index 4cb372a..1d796f5 100644 --- a/Project.toml +++ b/Project.toml @@ -4,6 +4,7 @@ authors = ["JuliaMolSim community"] version = "0.0.2" [deps] +ASEconvert = "3da9722f-58c2-4165-81be-b4d7253e8fd2" AtomsBase = "a963bdd2-2df7-4f54-a1ee-49d51e6be12a" AtomsCalculators = "a3e0e189-c65a-42c1-833c-339540406eb1" ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66" @@ -21,8 +22,8 @@ UnitfulAtomic = "a7773ee8-282e-5fa2-be4e-bd808c38a91a" [compat] ASEconvert = "0.1" AtomsBase = "0.3" -AtomsCalculators = "0.1" -DFTK = "0.6" +AtomsCalculators = "0.1.1" +DFTK = "0.6.18" EmpiricalPotentials = "0.1.0" Optimization = "3.20" OptimizationOptimJL = "0.1" From 6697e229b0c9bb734cc5599d8b2b13aa5f390581 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Tue, 3 Sep 2024 10:08:40 +0200 Subject: [PATCH 26/27] Bugfix and looser compat to allow working with CovarianceFunctions.jl --- Project.toml | 8 ++++---- src/strain.jl | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Project.toml b/Project.toml index 1d796f5..ef05166 100644 --- a/Project.toml +++ b/Project.toml @@ -22,16 +22,16 @@ UnitfulAtomic = "a7773ee8-282e-5fa2-be4e-bd808c38a91a" [compat] ASEconvert = "0.1" AtomsBase = "0.3" -AtomsCalculators = "0.1.1" -DFTK = "0.6.18" +AtomsCalculators = "0.1.1 - 0.2" +DFTK = "0.6.14 - 0.6.18" EmpiricalPotentials = "0.1.0" -Optimization = "3.20" +Optimization = "3.5 - 3.27" OptimizationOptimJL = "0.1" StaticArrays = "1.8" TestItemRunner = "0.2" Unitful = "1.19" UnitfulAtomic = "1.0" -julia = "1.9" +julia = "1.8.5 - 1.9" [extras] ASEconvert = "3da9722f-58c2-4165-81be-b4d7253e8fd2" diff --git a/src/strain.jl b/src/strain.jl index ca58bb7..49a5e32 100644 --- a/src/strain.jl +++ b/src/strain.jl @@ -18,7 +18,7 @@ function bbox_to_matrix(bbox) end function matrix_to_bbox(matrix) - eachcol(matrix) + collect.(eachcol(matrix)) end @doc raw""" From 33702776c9481a967406d92ac5178942a4f19150 Mon Sep 17 00:00:00 2001 From: CedricTravelletti Date: Wed, 4 Sep 2024 13:40:58 +0200 Subject: [PATCH 27/27] Modififed Project.toml --- Project.toml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Project.toml b/Project.toml index ef05166..8beb41c 100644 --- a/Project.toml +++ b/Project.toml @@ -23,10 +23,8 @@ UnitfulAtomic = "a7773ee8-282e-5fa2-be4e-bd808c38a91a" ASEconvert = "0.1" AtomsBase = "0.3" AtomsCalculators = "0.1.1 - 0.2" -DFTK = "0.6.14 - 0.6.18" +DFTK = "0.6.14 - 0.6.20" EmpiricalPotentials = "0.1.0" -Optimization = "3.5 - 3.27" -OptimizationOptimJL = "0.1" StaticArrays = "1.8" TestItemRunner = "0.2" Unitful = "1.19"