From 8a90da36b190ad1cc9c0779c96a47830d1504d1d Mon Sep 17 00:00:00 2001
From: Victor Vanthilt <73738005+VictorVanthilt@users.noreply.github.com>
Date: Tue, 21 Jan 2025 11:11:29 +0100
Subject: [PATCH] centralize `finalize!()` and add `finalize_two_by_two!()`
 (#5)

* centralize `finalize!()` and add `finalize_two_by_two!()`

* format

* fix finalize test
---
 src/TRGKit.jl           |  3 ++
 src/schemes/atrg.jl     | 10 -----
 src/schemes/btrg.jl     |  6 ---
 src/schemes/hotrg.jl    | 10 -----
 src/schemes/trg.jl      |  6 ---
 src/utility/finalize.jl | 58 ++++++++++++++++++++++++++++
 test/finalize.jl        | 83 +++++++++++++++++++++++++++++++++++++++++
 test/runtests.jl        |  1 +
 8 files changed, 145 insertions(+), 32 deletions(-)
 create mode 100644 src/utility/finalize.jl
 create mode 100644 test/finalize.jl

diff --git a/src/TRGKit.jl b/src/TRGKit.jl
index 3f207a0..6b3ae25 100644
--- a/src/TRGKit.jl
+++ b/src/TRGKit.jl
@@ -28,4 +28,7 @@ export gross_neveu_start
 # utility functions
 include("utility/cft.jl")
 export cft_data, central_charge
+
+include("utility/finalize.jl")
+export finalize!, finalize_two_by_two!
 end
diff --git a/src/schemes/atrg.jl b/src/schemes/atrg.jl
index 1b7548b..cbb3001 100644
--- a/src/schemes/atrg.jl
+++ b/src/schemes/atrg.jl
@@ -42,16 +42,6 @@ function step!(scheme::ATRG, trunc::TensorKit.TruncationScheme)
     return scheme
 end
 
-function finalize!(scheme::ATRG)
-    n = norm(@tensor scheme.T[1 2; 1 2])
-    scheme.T /= n
-
-    # turn the tensor by 90 degrees
-    scheme.T = permute(scheme.T, ((2, 3), (4, 1)))
-
-    return n
-end
-
 atrg_convcrit(steps::Int, data) = abs(log(data[end]) * 2.0^(-steps))
 
 function Base.show(io::IO, scheme::ATRG)
diff --git a/src/schemes/btrg.jl b/src/schemes/btrg.jl
index 745c13c..9a3a9fa 100644
--- a/src/schemes/btrg.jl
+++ b/src/schemes/btrg.jl
@@ -63,12 +63,6 @@ function step!(scheme::BTRG, trunc::TensorKit.TruncationScheme)
     return scheme
 end
 
-function finalize!(scheme::BTRG)
-    n = norm(@tensor scheme.T[1 2; 3 4] * scheme.S1[4; 2] * scheme.S2[3; 1])
-    scheme.T /= n
-    return n
-end
-
 # example convcrit function
 btrg_convcrit(steps::Int, data) = abs(log(data[end]) * 2.0^(-steps))
 
diff --git a/src/schemes/hotrg.jl b/src/schemes/hotrg.jl
index 733a03a..2112fb2 100644
--- a/src/schemes/hotrg.jl
+++ b/src/schemes/hotrg.jl
@@ -25,16 +25,6 @@ function step!(scheme::HOTRG, trunc::TensorKit.TruncationScheme)
     return scheme
 end
 
-function finalize!(scheme::HOTRG)
-    n = norm(@tensor scheme.T[1 2; 1 2])
-    scheme.T /= n
-
-    # turn the tensor by 90 degrees
-    scheme.T = permute(scheme.T, ((2, 3), (4, 1)))
-
-    return n
-end
-
 # example convcrit function
 hotrg_convcrit(steps::Int, data) = abs(log(data[end]) * 2.0^(-steps))
 
diff --git a/src/schemes/trg.jl b/src/schemes/trg.jl
index c36858f..120c8c1 100644
--- a/src/schemes/trg.jl
+++ b/src/schemes/trg.jl
@@ -31,12 +31,6 @@ function step!(scheme::TRG, trunc::TensorKit.TruncationScheme)
     return scheme
 end
 
-function finalize!(scheme::TRG)
-    n = norm(@tensor scheme.T[1 2; 1 2])
-    scheme.T /= n
-    return n
-end
-
 # example convcrit function
 trg_convcrit(steps::Int, data) = abs(log(data[end]) * 2.0^(-steps))
 
diff --git a/src/utility/finalize.jl b/src/utility/finalize.jl
new file mode 100644
index 0000000..f26674b
--- /dev/null
+++ b/src/utility/finalize.jl
@@ -0,0 +1,58 @@
+const simple_scheme = Union{TRG}
+const turning_scheme = Union{HOTRG,ATRG}
+
+# 1x1 unitcell finalize
+function finalize!(scheme::simple_scheme)
+    n = norm(@tensor scheme.T[1 2; 1 2])
+    scheme.T /= n
+    return n
+end
+
+function finalize!(scheme::turning_scheme)
+    n = norm(@tensor scheme.T[1 2; 1 2])
+    scheme.T /= n
+
+    # turn the tensor by 90 degrees
+    scheme.T = permute(scheme.T, ((2, 3), (4, 1)))
+    return n
+end
+
+function finalize!(scheme::BTRG)
+    n = norm(@tensor scheme.T[1 2; 3 4] * scheme.S1[4; 2] * scheme.S2[3; 1])
+    scheme.T /= n
+    return n
+end
+
+# 2x2 unitcell finalize
+function finalize_two_by_two!(scheme::simple_scheme)
+    n = norm(@tensor scheme.T[2 5; 1 7] * scheme.T[1 6; 2 8] * scheme.T[3 8; 4 6] *
+                     scheme.T[4 7; 3 5])
+    scheme.T /= (n^(1 / 4))
+    return n
+end
+
+function finalize_two_by_two!(scheme::turning_scheme)
+    n = norm(@tensor scheme.T[2 5; 1 7] * scheme.T[1 6; 2 8] * scheme.T[3 8; 4 6] *
+                     scheme.T[4 7; 3 5])
+    scheme.T /= (n^(1 / 4))
+
+    # turn the tensor by 90 degrees
+    scheme.T = permute(scheme.T, ((2, 3), (4, 1)))
+    return n
+end
+
+function finalize_two_by_two!(scheme::BTRG)
+    n′ = @tensor begin
+        scheme.T[3 7; 1 11] *
+        scheme.S2[1; 2] *
+        scheme.T[2 9; 3 12] *
+        scheme.S1[10; 9] *
+        scheme.T[5 12; 6 10] *
+        scheme.S2[4; 5] *
+        scheme.T[6 11; 4 8] *
+        scheme.S1[8; 7]
+    end
+    n = norm(n′)
+    scheme.T /= (n^(1 / 4))
+    return n
+end
diff --git a/test/finalize.jl b/test/finalize.jl
new file mode 100644
index 0000000..b5278ff
--- /dev/null
+++ b/test/finalize.jl
@@ -0,0 +1,83 @@
+println("---------------------")
+println(" two by two finalize ")
+println("---------------------")
+
+# Onsager solution
+function onsager_integrand(θ, T)
+    k = 1 / sinh(2 / T)^(2)
+    integrand = 1 / (2π) * log(cosh(2 / T)^2 + 1 / k * sqrt(1 + k^2 - 2k * cos(2 * θ)))
+    return integrand
+end
+
+function onsager_free_energy(β)
+    return -(quadgk(θ -> onsager_integrand(θ, 1 / β), 0, π)[1] + log(2) / 2) / β
+end
+
+criterion_f(steps::Int, data) = abs(log(data[end]) * 2.0^(1 - steps))
+
+T = classical_ising_symmetric(Ising_βc)
+fs_onsager = onsager_free_energy(Ising_βc)
+
+# TRG
+@testset "TRG - Ising Model" begin
+    scheme = TRG(T; finalize=finalize_two_by_two!)
+    data = run!(scheme, truncdim(24), maxiter(25))
+
+    lnz = 0
+    for (i, d) in enumerate(data)
+        lnz += log(d) * 2.0^(-(i + 1))
+    end
+
+    fs = lnz * -1 / Ising_βc
+
+    relerror = abs((fs - fs_onsager) / fs_onsager)
+    @test relerror < 2e-6
+end
+
+# BTRG
+@testset "BTRG - Ising Model" begin
+    scheme = BTRG(T, -0.5; finalize=finalize_two_by_two!)
+    data = run!(scheme, truncdim(24), maxiter(25))
+
+    lnz = 0
+    for (i, d) in enumerate(data)
+        lnz += log(d) * 2.0^(-(i + 1))
+    end
+
+    fs = lnz * -1 / Ising_βc
+
+    relerror = abs((fs - fs_onsager) / fs_onsager)
+    @test relerror < 6e-8
+end
+
+# HOTRG
+@testset "HOTRG - Ising Model" begin
+    scheme = HOTRG(T; finalize=finalize_two_by_two!)
+    data = run!(scheme, truncdim(16), maxiter(25))
+
+    lnz = 0
+    for (i, d) in enumerate(data)
+        lnz += log(d) * 2.0^(-(i + 1))
+    end
+
+    fs = lnz * -1 / Ising_βc
+
+    relerror = abs((fs - fs_onsager) / fs_onsager)
+    @test relerror < 6e-7
+end
+
+# ATRG
+@testset "ATRG - Ising Model" begin
+    scheme = ATRG(T; finalize=finalize_two_by_two!)
+    data = run!(scheme, truncdim(24), maxiter(25))
+
+    lnz = 0
+    for (i, d) in enumerate(data)
+        lnz += log(d) * 2.0^(-(i + 1))
+    end
+
+    fs = lnz * -1 / Ising_βc
+
+    relerror = abs((fs - fs_onsager) / fs_onsager)
+    @test relerror < 3e-6
+end
diff --git a/test/runtests.jl b/test/runtests.jl
index e1438d1..1386b8f 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -6,3 +6,4 @@ using QuadGK
 
 include("spaces.jl") # do they give spacemismatches?
 include("ising.jl") # do they give the correct results (with the expected accuracy)?
+include("finalize.jl") # do they give the correct results (with the expected accuracy)?