reformat

euro-hpc-pl · Jul 20, 2024 · a61d821 · a61d821
1 parent d76c8ea
commit a61d821
Show file tree

Hide file tree

Showing 31 changed files with 146 additions and 111 deletions.
diff --git a/examples/pegasus.jl b/examples/pegasus.jl
@@ -25,8 +25,8 @@ function bench(instance::String, β::Real, bond_dim::Integer, num_states::Intege
         cluster_assignment_rule = pegasus_lattice((m, n, t)),
     )
 
-    params = MpsParameters{Float64}(;bd=bond_dim, ϵ=1E-8, sw=4, ts=1E-16)
-    search_params = SearchParameters(; max_states=num_states, cut_off_prob=δp)
+    params = MpsParameters{Float64}(; bd = bond_dim, ϵ = 1E-8, sw = 4, ts = 1E-16)
+    search_params = SearchParameters(; max_states = num_states, cut_off_prob = δp)
     Strategy = Zipper
     Sparsity = Sparse
     Layout = GaugesEnergy

diff --git a/src/search.jl b/src/search.jl
@@ -415,7 +415,10 @@ function merge_branches_blur(
     update_droplets = NoDroplets(),
 ) where {T}
     function _merge_blur(psol::Solution)
-        psol = merge_branches(ctr; merge_type=merge_type, update_droplets=update_droplets)(psol)
+        psol =
+            merge_branches(ctr; merge_type = merge_type, update_droplets = update_droplets)(
+                psol,
+            )
         node = get(ctr.nodes_search_order, length(psol.states[1]) + 1, ctr.node_outside)
         boundaries = boundary_states(ctr, psol.states, node)
         sorted_indices = sortperm(psol.probabilities, rev = true)

diff --git a/test/chimera_overlap_python.jl b/test/chimera_overlap_python.jl
@@ -24,8 +24,8 @@ cl_h = clustered_hamiltonian(
     cluster_assignment_rule = super_square_lattice((m, n, t)),
 )
 
-params = MpsParameters{Float64}(;bd=bond_dim, ϵ=1E-8, sw=4)
-search_params = SearchParameters(; max_states=num_states, cut_off_prob=δp)
+params = MpsParameters{Float64}(; bd = bond_dim, ϵ = 1E-8, sw = 4)
+search_params = SearchParameters(; max_states = num_states, cut_off_prob = δp)
 
 Strategy = SVDTruncate
 Gauge = NoUpdate
@@ -45,7 +45,7 @@ Gauge = NoUpdate
         params;
         onGPU = onGPU,
         βs = [β / 8, β / 4, β / 2, β],
-        graduate_truncation=:graduate_truncate,
+        graduate_truncation = :graduate_truncate,
     )
     @testset "Compare the results with Python" begin
         overlap_python = [0.2637787707674837, 0.2501621729619047, 0.2951954406837012]
@@ -76,7 +76,7 @@ end
         params;
         onGPU = onGPU,
         βs = [β / 8, β / 4, β / 2, β],
-        graduate_truncation=:graduate_truncate,
+        graduate_truncation = :graduate_truncate,
     )
     for i = 1:n-1
         psi_top = mps_top(ctr, i, 4)

diff --git a/test/experimental/gauges.jl b/test/experimental/gauges.jl
@@ -85,8 +85,8 @@ search_params = SearchParameters(num_states, δp)
                         net,
                         params;
                         onGPU = onGPU,
-                        βs=[β / 8, β / 4, β / 2, β],
-                        graduate_truncation=:graduate_truncate,
+                        βs = [β / 8, β / 4, β / 2, β],
+                        graduate_truncation = :graduate_truncate,
                     )
 
                     @testset "Overlaps calculated differently are the same." begin

diff --git a/test/experimental/gauges_cuda.jl b/test/experimental/gauges_cuda.jl
@@ -44,8 +44,8 @@ end
             net,
             params;
             onGPU = onGPU,
-            βs=[β / 6, β / 3, β / 2, β],
-            graduate_truncation=:graduate_truncate,
+            βs = [β / 6, β / 3, β / 2, β],
+            graduate_truncation = :graduate_truncate,
         )
         update_gauges!(ctr, m, INDβ, Val(:up))
         sol, s = low_energy_spectrum(ctr, search_params)

diff --git a/test/experimental/mpo_size.jl b/test/experimental/mpo_size.jl
@@ -89,8 +89,8 @@ for cl_states in cluster_states
         net,
         params;
         onGPU = onGPU,
-        βs=[β],
-        graduate_truncation=:graduate_truncate,
+        βs = [β],
+        graduate_truncation = :graduate_truncate,
     )
     Ws = SpinGlassEngine.mpo(ctr, ctr.layers.main, i, indβ)
     # println(" Ws -> ", which_device(Ws), " ", format_bytes.(measure_memory(Ws)))

diff --git a/test/experimental/sampling.jl b/test/experimental/sampling.jl
@@ -40,8 +40,8 @@ ctr = MpsContractor{Strategy,Gauge,Float64}(
     net,
     params;
     onGPU = onGPU,
-    βs=[β / 8.0, β / 4.0, β / 2.0, β],
-    graduate_truncation=:graduate_truncate,
+    βs = [β / 8.0, β / 4.0, β / 2.0, β],
+    graduate_truncation = :graduate_truncate,
 )
 sol = gibbs_sampling(ctr, search_params)
 

diff --git a/test/experimental/search_chimera_gauge.jl b/test/experimental/search_chimera_gauge.jl
@@ -38,8 +38,8 @@
                     net,
                     params;
                     onGPU = onGPU,
-                    βs=[β / 6, β / 3, β / 2, β],
-                    graduate_truncation=:graduate_truncate,
+                    βs = [β / 6, β / 3, β / 2, β],
+                    graduate_truncation = :graduate_truncate,
                 )
                 update_gauges!(ctr, m, INDβ, Val(:up))
                 sol, s = low_energy_spectrum(ctr, search_params)

diff --git a/test/experimental/squarestar_double_node_pegasus.jl b/test/experimental/squarestar_double_node_pegasus.jl
@@ -314,13 +314,17 @@ for tran ∈ all_lattice_transformations #[LatticeTransformation((1, 2, 3, 4), f
         net,
         params;
         onGPU = onGPU,
-        βs=[β / 6, β / 3, β / 2, β],
-        graduate_truncation=:graduate_truncate,
+        βs = [β / 6, β / 3, β / 2, β],
+        graduate_truncation = :graduate_truncate,
     )
     sol, s = low_energy_spectrum(
         ctr,
         search_params,
-        merge_branches(ctr; merge_type=:nofit, update_droplets=SingleLayerDroplets(eng, hamming_dist, :hamming)),
+        merge_branches(
+            ctr;
+            merge_type = :nofit,
+            update_droplets = SingleLayerDroplets(eng, hamming_dist, :hamming),
+        ),
     )
     println(sol.energies)
     # println(sol.states)

diff --git a/test/experimental/squarestar_double_node_zephyr.jl b/test/experimental/squarestar_double_node_zephyr.jl
@@ -34,7 +34,7 @@ cl_h = clustered_hamiltonian(
     iter = iter,
 )
 
-params = MpsParameters{Float64}(; bd=bond_dim, ϵ=1E-8, sw=10, ts=1E-16)
+params = MpsParameters{Float64}(; bd = bond_dim, ϵ = 1E-8, sw = 10, ts = 1E-16)
 search_params = SearchParameters(num_states, δp)
 
 # Solve using PEPS search
@@ -50,8 +50,8 @@ ctr = MpsContractor{Strategy,Gauge,Float64}(
     net,
     params;
     onGPU = onGPU,
-    βs=[β / 6, β / 3, β / 2, β],
-    graduate_truncation=:graduate_truncate,
+    βs = [β / 6, β / 3, β / 2, β],
+    graduate_truncation = :graduate_truncate,
 )
 
 # for i in 1//2 : 1//2 : m

diff --git a/test/experimental/truncate.jl b/test/experimental/truncate.jl
@@ -83,8 +83,8 @@ for cs ∈ cl_states
             net,
             params;
             onGPU = onGPU,
-            βs=[β / 6, β / 3, β / 2, β],
-            graduate_truncation=:graduate_truncate,
+            βs = [β / 6, β / 3, β / 2, β],
+            graduate_truncation = :graduate_truncate,
         )
         sol, schmidts = low_energy_spectrum(ctr, search_params, merge_branches(ctr))
         println("sol ", sol)

diff --git a/test/experimental/truncate_small.jl b/test/experimental/truncate_small.jl
@@ -86,8 +86,8 @@ function run_test(instance, m, n, t)
                 net,
                 params;
                 onGPU = onGPU,
-                βs=βs,
-                graduate_truncation=:graduate_truncate,
+                βs = βs,
+                graduate_truncation = :graduate_truncate,
             )
 
             sol, schmidts = low_energy_spectrum(ctr, search_params, merge_branches(ctr)) #, merge_branches(ctr))

diff --git a/test/experimental/zipper.jl b/test/experimental/zipper.jl
@@ -55,8 +55,8 @@ ctr = MpsContractor{Strategy,Gauge,Float64}(
     net,
     params;
     onGPU = onGPU,
-    βs=[β],
-    graduate_truncation=:graduate_truncate,
+    βs = [β],
+    graduate_truncation = :graduate_truncate,
 )
 Ws = SpinGlassEngine.mpo(ctr, ctr.layers.main, i, indβ)
 println(" Ws -> ", which_device(Ws), " ", format_bytes.(measure_memory(Ws)))
@@ -66,8 +66,8 @@ ctr = MpsContractor{Strategy,Gauge,Float64}(
     net,
     params;
     onGPU = onGPU,
-    βs=[β],
-    graduate_truncation=:graduate_truncate,
+    βs = [β],
+    graduate_truncation = :graduate_truncate,
 )
 Wd = SpinGlassEngine.mpo(ctr, ctr.layers.main, i, indβ)
 println(" Wd -> ", which_device(Wd), " ", format_bytes.(measure_memory(Wd)))

diff --git a/test/mwe.jl b/test/mwe.jl
@@ -33,7 +33,16 @@ for T in [Float64, Float32]
     println("=========")
     println("type ", T)
     energies = Vector{T}[]
-    params = MpsParameters{T}(;bond_dim, T(VAR_TOL), MAX_SWEEPS, T(TOL_SVD), ITERS_SVD, ITERS_VAR, DTEMP_MULT, METHOD)
+    params = MpsParameters{T}(;
+        bond_dim,
+        T(VAR_TOL),
+        MAX_SWEEPS,
+        T(TOL_SVD),
+        ITERS_SVD,
+        ITERS_VAR,
+        DTEMP_MULT,
+        METHOD,
+    )
     search_params = SearchParameters(mstates, δp)
 
     net = PEPSNetwork{SquareCrossDoubleNode{Layout},Sparsity,T}(m, n, cl_h, transform)
@@ -42,10 +51,10 @@ for T in [Float64, Float32]
         params;
         onGPU = onGPU,
         βs = [β / 8, β / 4, β / 2, β],
-        graduate_truncation=:graduate_truncate,
+        graduate_truncation = :graduate_truncate,
     )
     sol, s = low_energy_spectrum(ctr, search_params)
     @test eltype(sol.energies) == T
     println(sol.energies[1])
     clear_memoize_cache()
-end
+end
diff --git a/test/random_markov_field.jl b/test/random_markov_field.jl
@@ -7,8 +7,8 @@
     num_states = 64
     cl_h = clustered_hamiltonian(instance_dir)
     Nx, Ny = get_prop(cl_h, :Nx), get_prop(cl_h, :Ny)
-    params = MpsParameters{Float64}(;bd=bond_dim, ϵ=1E-8, sw=4)
-    search_params = SearchParameters(; max_states=num_states, cut_off_prob=δp)
+    params = MpsParameters{Float64}(; bd = bond_dim, ϵ = 1E-8, sw = 4)
+    search_params = SearchParameters(; max_states = num_states, cut_off_prob = δp)
     Gauge = NoUpdate
     graduate_truncation = :graduate_truncate
     energies = Vector{Float64}[]
@@ -22,8 +22,8 @@
         params;
         onGPU = onGPU,
         βs = [β / 8, β / 4, β / 2, β],
-        graduate_truncation=:graduate_truncate,
-        mode=:RMF
+        graduate_truncation = :graduate_truncate,
+        mode = :RMF,
     )
     sol_peps, s = low_energy_spectrum(ctr, search_params, merge_branches(ctr))
 end
diff --git a/test/search_chimera_droplets.jl b/test/search_chimera_droplets.jl
@@ -24,8 +24,8 @@ function bench(instance::String)
         spectrum = my_brute_force,
         cluster_assignment_rule = super_square_lattice((m, n, t)),
     )
-    params = MpsParameters{Float64}(;bd=bond_dim, ϵ=1E-8, sw=4, ts=1E-16)
-    search_params = SearchParameters(; max_states=num_states, cut_off_prob=δp)
+    params = MpsParameters{Float64}(; bd = bond_dim, ϵ = 1E-8, sw = 4, ts = 1E-16)
+    search_params = SearchParameters(; max_states = num_states, cut_off_prob = δp)
 
     energies = Vector{Float64}[]
     for Strategy ∈ (Zipper,), Sparsity ∈ (Dense,)
@@ -41,13 +41,17 @@ function bench(instance::String)
                     net,
                     params;
                     onGPU = onGPU,
-                    βs= all_betas,
-                    graduate_truncation=:graduate_truncate,
+                    βs = all_betas,
+                    graduate_truncation = :graduate_truncate,
                 )
                 sol1, s = low_energy_spectrum(
                     ctr,
                     search_params,
-                    merge_branches(ctr; merge_type=:nofit, update_droplets=SingleLayerDroplets(1.0, 1000, :hamming)),
+                    merge_branches(
+                        ctr;
+                        merge_type = :nofit,
+                        update_droplets = SingleLayerDroplets(1.0, 1000, :hamming),
+                    ),
                 )
 
                 sol2 = unpack_droplets(sol1, β)

diff --git a/test/search_chimera_full.jl b/test/search_chimera_full.jl
@@ -23,8 +23,8 @@ function bench(instance::String)
         spectrum = full_spectrum,
         cluster_assignment_rule = super_square_lattice((m, n, t)),
     )
-    params = MpsParameters{Float64}(;bd=bond_dim, ϵ=1E-8, sw=4, ts=1E-16)
-    search_params = SearchParameters(; max_states=num_states, cut_off_prob=δp)
+    params = MpsParameters{Float64}(; bd = bond_dim, ϵ = 1E-8, sw = 4, ts = 1E-16)
+    search_params = SearchParameters(; max_states = num_states, cut_off_prob = δp)
 
     energies = Vector{Float64}[]
     for Strategy ∈ (SVDTruncate, Zipper), Sparsity ∈ (Dense, Sparse)
@@ -42,10 +42,13 @@ function bench(instance::String)
                     params;
                     onGPU = onGPU,
                     βs = all_betas,
-                    graduate_truncation=:graduate_truncate,
+                    graduate_truncation = :graduate_truncate,
+                )
+                sol, s = low_energy_spectrum(
+                    ctr,
+                    search_params,
+                    merge_branches(ctr; merge_type = :nofit),
                 )
-                sol, s =
-                    low_energy_spectrum(ctr, search_params, merge_branches(ctr; merge_type=:nofit))
 
                 @test sol.energies[begin] ≈ ground_energy
 

diff --git a/test/search_chimera_pathological.jl b/test/search_chimera_pathological.jl
@@ -114,8 +114,8 @@ transform = $transform
         spectrum = full_spectrum,
         cluster_assignment_rule = super_square_lattice((m, n, t)),
     )
-    params = MpsParameters{Float64}(;bd=bond_dim, ϵ=1E-8, sw=4)
-    search_params = SearchParameters(; max_states=num_states, cut_off_prob=0.0)
+    params = MpsParameters{Float64}(; bd = bond_dim, ϵ = 1E-8, sw = 4)
+    search_params = SearchParameters(; max_states = num_states, cut_off_prob = 0.0)
     Gauge = NoUpdate
 
     energies = Vector{Float64}[]
@@ -126,8 +126,8 @@ transform = $transform
         net,
         params;
         onGPU = onGPU,
-        βs=[β / 8.0, β / 4.0, β / 2.0, β],
-        graduate_truncation=:graduate_truncate,
+        βs = [β / 8.0, β / 4.0, β / 2.0, β],
+        graduate_truncation = :graduate_truncate,
     )
     sol, s = low_energy_spectrum(ctr, search_params)
 

diff --git a/test/search_chimera_pathological_Z2.jl b/test/search_chimera_pathological_Z2.jl
@@ -103,8 +103,8 @@
         spectrum = full_spectrum,
         cluster_assignment_rule = super_square_lattice((m, n, t)),
     )
-    params = MpsParameters{Float64}(;bd=bond_dim, ϵ=1E-8, sw=4)
-    search_params = SearchParameters(; max_states=num_states, cut_off_prob=0.0)
+    params = MpsParameters{Float64}(; bd = bond_dim, ϵ = 1E-8, sw = 4)
+    search_params = SearchParameters(; max_states = num_states, cut_off_prob = 0.0)
     Gauge = NoUpdate
 
     energies = Vector{Float64}[]
@@ -123,13 +123,17 @@
                     net,
                     params;
                     onGPU = onGPU,
-                    βs=[β / 8.0, β / 4.0, β / 2.0, β],
-                    graduate_truncation=:graduate_truncate,
+                    βs = [β / 8.0, β / 4.0, β / 2.0, β],
+                    graduate_truncation = :graduate_truncate,
                 )
                 sol1, s = low_energy_spectrum(
                     ctr,
                     search_params,
-                    merge_branches(ctr; merge_type=:nofit, update_droplets=SingleLayerDroplets(10.0, 0, :hamming)),
+                    merge_branches(
+                        ctr;
+                        merge_type = :nofit,
+                        update_droplets = SingleLayerDroplets(10.0, 0, :hamming),
+                    ),
                     :Z2,
                 )
                 sol2 = unpack_droplets(sol1, β)

diff --git a/test/search_chimera_pathological_droplets.jl b/test/search_chimera_pathological_droplets.jl
@@ -104,8 +104,8 @@
         spectrum = full_spectrum,
         cluster_assignment_rule = super_square_lattice((m, n, t)),
     )
-    params = MpsParameters{Float64}(;bd=bond_dim, ϵ=1E-8, sw=4)
-    search_params = SearchParameters(; max_states=num_states, cut_off_prob=0.0)
+    params = MpsParameters{Float64}(; bd = bond_dim, ϵ = 1E-8, sw = 4)
+    search_params = SearchParameters(; max_states = num_states, cut_off_prob = 0.0)
     Gauge = NoUpdate
 
     energies = Vector{Float64}[]
@@ -126,8 +126,8 @@
                     net,
                     params;
                     onGPU = onGPU,
-                    βs=[β / 8.0, β / 4.0, β / 2.0, β],
-                    graduate_truncation=:graduate_truncate,
+                    βs = [β / 8.0, β / 4.0, β / 2.0, β],
+                    graduate_truncation = :graduate_truncate,
                 )
                 sol1, s = low_energy_spectrum(
                     ctr,