From 5bb4f28c8bee8bb21e492fe0331ac405248d11cc Mon Sep 17 00:00:00 2001 From: Alberto Ramos Date: Tue, 13 Jul 2021 22:12:55 +0200 Subject: [PATCH] First commit with layout for Latttice GPU code --- Manifest.toml | 295 +++++++++++++++++++++++++++++++++++++++++ Project.toml | 7 + src/Groups/GroupSU2.jl | 146 ++++++++++++++++++++ src/Groups/GroupSU3.jl | 48 +++++++ src/Groups/Groups.jl | 28 ++++ src/LatticeGPU.jl | 24 ++++ src/Space/Space.jl | 133 +++++++++++++++++++ src/YM/YM.jl | 25 ++++ src/YM/YMact.jl | 41 ++++++ 9 files changed, 747 insertions(+) create mode 100644 Manifest.toml create mode 100644 Project.toml create mode 100644 src/Groups/GroupSU2.jl create mode 100644 src/Groups/GroupSU3.jl create mode 100644 src/Groups/Groups.jl create mode 100644 src/LatticeGPU.jl create mode 100644 src/Space/Space.jl create mode 100644 src/YM/YM.jl create mode 100644 src/YM/YMact.jl diff --git a/Manifest.toml b/Manifest.toml new file mode 100644 index 0000000..e4309c0 --- /dev/null +++ b/Manifest.toml @@ -0,0 +1,295 @@ +# This file is machine-generated - editing it directly is not advised + +[[AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "485ee0867925449198280d4af84bdb46a2a404d0" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.0.1" + +[[Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "84918055d15b3114ede17ac6a7182f68870c16f7" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "3.3.1" + +[[ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" + +[[Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" + +[[BFloat16s]] +deps = ["LinearAlgebra", "Test"] +git-tree-sha1 = "4af69e205efc343068dc8722b8dfec1ade89254a" +uuid = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" +version = "0.1.0" + +[[Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[CEnum]] +git-tree-sha1 = "215a9aa4a1f23fbd05b92769fdd62559488d70e9" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.4.1" + +[[CUDA]] +deps = ["AbstractFFTs", "Adapt", "BFloat16s", "CEnum", "CompilerSupportLibraries_jll", "DataStructures", "ExprTools", "GPUArrays", "GPUCompiler", "LLVM", "LazyArtifacts", "Libdl", "LinearAlgebra", "Logging", "Printf", "Random", "Random123", "RandomNumbers", "Reexport", "Requires", "SparseArrays", "SpecialFunctions", "TimerOutputs"] +git-tree-sha1 = "8ef71bf6d6602cf227196b43650924bf9ef7babc" +uuid = "052768ef-5323-5732-b1bb-66c8b64840ba" +version = "3.3.3" + +[[ChainRulesCore]] +deps = ["Compat", "LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "dcc25ff085cf548bc8befad5ce048391a7c07d40" +uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +version = "0.10.11" + +[[Compat]] +deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "SHA", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Statistics", "Test", "UUIDs", "Unicode"] +git-tree-sha1 = "dc7dedc2c2aa9faf59a55c622760a25cbefbe941" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "3.31.0" + +[[CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" + +[[DataStructures]] +deps = ["Compat", "InteractiveUtils", "OrderedCollections"] +git-tree-sha1 = "4437b64df1e0adccc3e5d1adbc3ac741095e4677" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.18.9" + +[[Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" + +[[DelimitedFiles]] +deps = ["Mmap"] +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" + +[[Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" + +[[DocStringExtensions]] +deps = ["LibGit2"] +git-tree-sha1 = "a32185f5428d3986f47c2ab78b1f216d5e6cc96f" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.8.5" + +[[Downloads]] +deps = ["ArgTools", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" + +[[ExprTools]] +git-tree-sha1 = "b7e3d17636b348f005f11040025ae8c6f645fe92" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.6" + +[[GPUArrays]] +deps = ["AbstractFFTs", "Adapt", "LinearAlgebra", "Printf", "Random", "Serialization", "Statistics"] +git-tree-sha1 = "ececbf05f8904c92814bdbd0aafd5540b0bf2e9a" +uuid = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" +version = "7.0.1" + +[[GPUCompiler]] +deps = ["DataStructures", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "TimerOutputs", "UUIDs"] +git-tree-sha1 = "e8a09182a4440489e2e3dedff5ad3f6bbe555396" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "0.12.5" + +[[InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[JLLWrappers]] +deps = ["Preferences"] +git-tree-sha1 = "642a199af8b68253517b80bd3bfd17eb4e84df6e" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.3.0" + +[[LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "Printf", "Unicode"] +git-tree-sha1 = "1b7ba36ea7aa6fa2278118951bad114fbb8359f2" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "4.1.0" + +[[LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "b36c0677a0549c7d1dc8719899a4133abbfacf7d" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.6+0" + +[[LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" + +[[LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" + +[[LibCURL_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" + +[[LibGit2]] +deps = ["Base64", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" + +[[LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" + +[[Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[LinearAlgebra]] +deps = ["Libdl"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[LogExpFunctions]] +deps = ["DocStringExtensions", "LinearAlgebra"] +git-tree-sha1 = "7bd5f6565d80b6bf753738d2bc40a5dfea072070" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "0.2.5" + +[[Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[MbedTLS_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" + +[[Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" + +[[MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" + +[[NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" + +[[OpenSpecFun_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.5+0" + +[[OrderedCollections]] +git-tree-sha1 = "85f8e6578bf1f9ee0d11e7bb1b1456435479d47c" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.4.1" + +[[Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" + +[[Preferences]] +deps = ["TOML"] +git-tree-sha1 = "00cfd92944ca9c760982747e9a1d0d5d86ab1e5a" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.2.2" + +[[Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[Random]] +deps = ["Serialization"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[Random123]] +deps = ["Libdl", "Random", "RandomNumbers"] +git-tree-sha1 = "0e8b146557ad1c6deb1367655e052276690e71a3" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.4.2" + +[[RandomNumbers]] +deps = ["Random", "Requires"] +git-tree-sha1 = "441e6fc35597524ada7f85e13df1f4e10137d16f" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.4.0" + +[[Reexport]] +git-tree-sha1 = "5f6c21241f0f655da3952fd60aa18477cf96c220" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.1.0" + +[[Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "4036a3bd08ac7e968e27c203d45f5fff15020621" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.1.3" + +[[SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" + +[[Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[SharedArrays]] +deps = ["Distributed", "Mmap", "Random", "Serialization"] +uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" + +[[Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[SparseArrays]] +deps = ["LinearAlgebra", "Random"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[SpecialFunctions]] +deps = ["ChainRulesCore", "LogExpFunctions", "OpenSpecFun_jll"] +git-tree-sha1 = "a50550fa3164a8c46747e62063b4d774ac1bcf49" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "1.5.1" + +[[Statistics]] +deps = ["LinearAlgebra", "SparseArrays"] +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" + +[[Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" + +[[Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[TimerOutputs]] +deps = ["ExprTools", "Printf"] +git-tree-sha1 = "209a8326c4f955e2442c07b56029e88bb48299c7" +uuid = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f" +version = "0.5.12" + +[[UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[[Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" + +[[Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" + +[[nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" + +[[p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" diff --git a/Project.toml b/Project.toml new file mode 100644 index 0000000..b4db941 --- /dev/null +++ b/Project.toml @@ -0,0 +1,7 @@ +name = "LatticeGPU" +uuid = "958c3683-801a-4582-9cfa-2d6e2ae1763b" +authors = ["Alberto Ramos "] +version = "0.1.0" + +[deps] +CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" diff --git a/src/Groups/GroupSU2.jl b/src/Groups/GroupSU2.jl new file mode 100644 index 0000000..79514ce --- /dev/null +++ b/src/Groups/GroupSU2.jl @@ -0,0 +1,146 @@ +### +### "THE BEER-WARE LICENSE": +### Alberto Ramos wrote this file. As long as you retain this +### notice you can do whatever you want with this stuff. If we meet some +### day, and you think this stuff is worth it, you can buy me a beer in +### return. +### +### file: GroupSU2.jl +### created: Sun Jul 11 17:23:12 2021 +### + +# +# SU(2) group elements represented trough Cayley-Dickson +# construction +# https://en.wikipedia.org/wiki/Cayley%E2%80%93Dickson_construction + +import Base.:*, Base.:+, Base.:-,Base.:/,Base.:\ +struct SU2 <: Group + t1::ComplexF64 + t2::ComplexF64 +end +SU2() = SU2(1.0, 0.0) +inverse(b::SU2) = SU2(conj(b.t1), -b.t2) +dag(a::SU2) = inverse(a) +norm(a::SU2) = sqrt(abs2(a.t1) + abs2(a.t2)) +tr(g::SU2) = 2.0*real(a.t1) + +""" + function normalize(a::SU2) + +Return a normalized element of `SU(2)` +""" +function normalize(a::SU2) + dr = sqrt(abs2(a.t1) + abs2(a.t2)) + if (dr == 0.0) + return SU2(0.0) + end + return SU2(a.t1/dr,a.t2/dr) +end + +Base.:+(a::SU2,b::SU2) = SU2(a.t1+b.t1,a.t2+b.t2) +Base.:-(a::SU2,b::SU2) = SU2(a.t1-b.t1,a.t2-b.t2) +Base.:*(a::SU2,b::SU2) = SU2(a.t1*b.t1-a.t2*conj(b.t2),a.t1*b.t2+a.t2*conj(b.t1)) +Base.:/(a::SU2,b::SU2) = SU2(a.t1*conj(b.t1)+a.t2*conj(b.t2),-a.t1*b.t2+a.t2*b.t1) +Base.:\(a::SU2,b::SU2) = SU2(conj(a.t1)*b.t1+a.t2*conj(b.t2),conj(a.t1)*b.t2-a.t2*conj(b.t1)) +Base.:+(a::SU2) = SU2(a.t1,a.t2) +Base.:-(a::SU2) = SU2(-a.t1,-a.t2) + +struct SU2alg <: Algebra + t1::Float64 + t2::Float64 + t3::Float64 +end +SU2alg(x::Real) = SU2alg(x,0.0,0.0) +SU2alg(v::Vector) = SU2alg(v[1],v[2],v[3]) +projalg(g::SU2) = SU2alg(imag(g.t1), real(g.t2), imag(g.t2)) +dot(a::SU2alg, b::SU2alg) = a.t1*b.t1 + a.t2*b.t2 + a.t3*b.t3 +Base.:+(a::SU2alg) = SU2alg(a.t1,a.t2,a.t3) +Base.:-(a::SU2alg) = SU2alg(-a.t1,-a.t2,-a.t3) +Base.:+(a::SU2alg,b::SU2alg) = SU2alg(a.t1+b.t1,a.t2+b.t2,a.t3+b.t3) +Base.:-(a::SU2alg,b::SU2alg) = SU2alg(a.t1-b.t1,a.t2-b.t2,a.t3-b.t3) + +Base.:*(a::SU2alg,b::Real) = SU2alg(a.t1*b,a.t2*b,a.t3*b) +Base.:*(b::Real,a::SU2alg) = SU2alg(a.t1*b,a.t2*b,a.t3*b) +Base.:/(a::SU2alg,b::Real) = SU2alg(a.t1/b,a.t2/b,a.t3/b) + + +""" + function Base.exp(a::SU2alg, t::Number=1) + +Computes `exp(a)` +""" +function Base.exp(a::SU2alg) + + rm = sqrt( a.t1^2+a.t2^2+a.t3^2 )/2.0 + if (abs(rm) < 0.05) + rms = rm^2/2.0 + ca = 1.0 - rms *(1.0 - (rms/6.0 )*(1.0 - rms/15.0)) + sa = 0.5 - rms/6.0*(1.0 - (rms/10.0)*(1.0 - rms/21.0)) + else + ca = cos(rm) + sa = sin(rm)/(2.0*rm) + end + + return SU2(complex(ca,sa*a.t1),complex(sa*a.t2,sa*a.t3)) +end + +function Base.exp(a::SU2alg, t::Number) + + rm = t*sqrt( a.t1^2+a.t2^2+a.t3^2 )/2.0 + if (abs(rm) < 0.05) + rms = rm^2/2.0 + ca = 1.0 - rms *(1.0 - (rms/6.0 )*(1.0 - rms/15.0)) + sa = t*(0.5 - rms/6.0*(1.0 - (rms/10.0)*(1.0 - rms/21.0))) + else + ca = cos(rm) + sa = t*sin(rm)/(2.0*rm) + end + + return SU2(complex(ca,sa*a.t1),complex(sa*a.t2,sa*a.t3)) +end + + +""" + function expm(g::SU2, a::SU2alg) + +Computes `exp(a)*g` + +""" +function expm(g::SU2, a::SU2alg) + + rm = sqrt( a.t1^2+a.t2^2+a.t3^2 )/2.0 + if (abs(rm) < 0.05) + rms = rm^2/2.0 + ca = 1.0 - rms *(1.0 - (rms/6.0 )*(1.0 - rms/15.0)) + sa = 0.5 - rms/6.0*(1.0 - (rms/10.0)*(1.0 - rms/21.0)) + else + ca = cos(rm) + sa = sin(rm)/(2.0*rm) + end + + return SU2(complex(ca,sa*a.t1)*g.t1-complex(sa*a.t2,sa*a.t3)*conj(g.t2), + complex(ca,sa*a.t1)*g.t2+complex(sa*a.t2,sa*a.t3)*conj(g.t1)) +end + +""" + function expm(g::SU2, a::SU2alg, t::Float64) + +Computes `exp(t*a)*g` + +""" +function expm(g::SU2, a::SU2alg, t::Float64) + + rm = t*sqrt( a.t1^2+a.t2^2+a.t3^2 )/2.0 + if (abs(rm) < 0.05) + rms = rm^2/2.0 + ca = 1.0 - rms *(1.0 - (rms/6.0 )*(1.0 - rms/15.0)) + sa = t*(0.5 - rms/6.0*(1.0 - (rms/10.0)*(1.0 - rms/21.0))) + else + ca = cos(rm) + sa = t*sin(rm)/(2.0*rm) + end + + return SU2(complex(ca,sa*a.t1)*g.t1-complex(sa*a.t2,sa*a.t3)*conj(g.t2), + complex(ca,sa*a.t1)*g.t2+complex(sa*a.t2,sa*a.t3)*conj(g.t1)) +end diff --git a/src/Groups/GroupSU3.jl b/src/Groups/GroupSU3.jl new file mode 100644 index 0000000..e4ca91d --- /dev/null +++ b/src/Groups/GroupSU3.jl @@ -0,0 +1,48 @@ +### +### "THE BEER-WARE LICENSE": +### Alberto Ramos wrote this file. As long as you retain this +### notice you can do whatever you want with this stuff. If we meet some +### day, and you think this stuff is worth it, you can buy me a beer in +### return. +### +### file: GroupSU3.jl +### created: Sun Jul 11 17:23:02 2021 +### + +# +# Use memory efficient representation: Only store +# first two rows +# +# a.u31 = a.u12*conj(a.u23) - a.u13*conj(a.u22) +# a.u32 = a.u13*conj(a.u21) - a.u11*conj(a.u23) +# a.u33 = a.u11*conj(a.u22) - a.u12*conj(a.u21) +# + +import Base.:*, Base.:+, Base.:-,Base.:/,Base.:\ +struct SU3 <: Group + u11::ComplexF64 + u12::ComplexF64 + u13::ComplexF64 + u21::ComplexF64 + u22::ComplexF64 + u23::ComplexF64 +end +SU3() = SU3(1,0,0,0,1,0) +inverse(a::SU3) = SU3(conj(a.u11),conj(a.u21),conj(a.u12*conj(a.u23) - a.u13*conj(a.u22)), + conj(a.u12),conj(a.u22),conj(a.u13*conj(a.u21) - a.u11*conj(a.u23))) +dag(a::SU3) = inverse(a) +tr(g::SU3) = a.u11+a.u22+a.u11*conj(a.u22)-a.u12*conj(a.u21) +function Base.:*(a::SU3,b::SU3) + + bu31 = (b.u12*conj(a.u23) - b.u13*conj(b.u22)) + bu32 = (b.u13*conj(b.u21) - b.u11*conj(b.u23)) + bu33 = (b.u11*conj(b.u22) - b.u12*conj(b.u21)) + + return SU3(a.u11*b.u11 + a.u12*b.u21 + a.u13*bu31, + a.u11*b.u12 + a.u12*b.u22 + a.u13*bu32, + a.u11*b.u13 + a.u12*b.u23 + a.u13*bu33, + a.u21*b.u11 + a.u22*b.u21 + a.u23*bu31, + a.u21*b.u12 + a.u22*b.u22 + a.u23*bu32, + a.u21*b.u13 + a.u22*b.u23 + a.u23*bu33) +end + diff --git a/src/Groups/Groups.jl b/src/Groups/Groups.jl new file mode 100644 index 0000000..4719691 --- /dev/null +++ b/src/Groups/Groups.jl @@ -0,0 +1,28 @@ +### +### "THE BEER-WARE LICENSE": +### Alberto Ramos wrote this file. As long as you retain this +### notice you can do whatever you want with this stuff. If we meet some +### day, and you think this stuff is worth it, you can buy me a beer in +### return. +### +### file: Groups.jl +### created: Sun Jul 11 18:02:16 2021 +### + + +module Groups + +abstract type Group end +abstract type Algebra end + +include("GroupSU2.jl") + +export SU2, SU2alg, dag, normalize, inverse, tr, projalg, norm +export dot, expm, exp + +include("GroupSU3.jl") + + + + +end # module diff --git a/src/LatticeGPU.jl b/src/LatticeGPU.jl new file mode 100644 index 0000000..fe9991f --- /dev/null +++ b/src/LatticeGPU.jl @@ -0,0 +1,24 @@ +module LatticeGPU + +using CUDA + +include("Groups/Groups.jl") + +using .Groups +export Group, Algebra +export SU2, SU2alg, dag, normalize, inverse, tr, projalg, norm +export dot, expm, exp + +include("Space/Space.jl") + +using .Space +export SpaceParm, KernelParm +export map2latt, up, dw, shift + + +include("YM/YM.jl") + +using .YM + + +end # module diff --git a/src/Space/Space.jl b/src/Space/Space.jl new file mode 100644 index 0000000..32d7ad5 --- /dev/null +++ b/src/Space/Space.jl @@ -0,0 +1,133 @@ +### +### "THE BEER-WARE LICENSE": +### Alberto Ramos wrote this file. As long as you retain this +### notice you can do whatever you want with this stuff. If we meet some +### day, and you think this stuff is worth it, you can buy me a beer in +### return. +### +### file: Space.jl +### created: Mon Jul 12 16:44:35 2021 +### + + +module Space + +struct SpaceParm{N,M} + ndim::Int64 + iL::NTuple{N,Int64} + npls::Int64 + plidx::NTuple{M, Tuple{Int64, Int64}} + + function SpaceParm{N}(x, bt, c=(0.0,0.0)) where {N} + M = convert(Int64, round(N*(N-1)/2)) + N == length(x) || throw(ArgumentError("Tuple of incorrect length for dimension $N")) + + pls = Vector{Tuple{Int64, Int64}}() + for i in 1:N + for j in i+1:N + push!(pls, (i,j)) + end + end + return new{N,M}(N, bt, c, x, M, tuple(pls...)) + end +end +export SpaceParm + +struct KernelParm + threads::Tuple{Int64,Int64,Int64} + blocks::Tuple{Int64,Int64,Int64} +end +export KernelParm + +@inline shift(p::CartesianIndex{4}, sh::CartesianIndex{4}, lp::SpaceParm{4}) = CartesianIndex(mod1(p[1]+sh[1], lp.iL[1]), + mod1(p[2]+sh[2], lp.iL[2]), + mod1(p[3]+sh[3], lp.iL[3]), + mod1(p[4]+sh[4], lp.iL[4])) +@inline shift(p::CartesianIndex{3}, sh::CartesianIndex{3}, lp::SpaceParm{3}) = CartesianIndex(mod1(p[1]+sh[1], lp.iL[1]), + mod1(p[2]+sh[2], lp.iL[2]), + mod1(p[3]+sh[3], lp.iL[3])) +@inline shift(p::CartesianIndex{2}, sh::CartesianIndex{2}, lp::SpaceParm{2}) = CartesianIndex(mod1(p[1]+sh[1], lp.iL[1]), + mod1(p[2]+sh[2], lp.iL[2])) +@inline function dw(p::CartesianIndex{4}, id, lp::SpaceParm{4}) + + if (id == 1) + s = CartesianIndex(mod1(p[1]-1, lp.iL[1]), p[2], p[3], p[4]) + elseif (id == 2) + s = CartesianIndex(p[1], mod1(p[2]-1, lp.iL[2]), p[3], p[4]) + elseif (id == 3) + s = CartesianIndex(p[1], p[2], mod1(p[3]-1, lp.iL[3]), p[4]) + elseif (id == 4) + s = CartesianIndex(p[1], p[2], p[3], mod1(p[4]-1, lp.iL[4])) + end + + return s +end + +@inline function dw(p::CartesianIndex{3}, id, lp::SpaceParm{3}) + + if (id == 1) + s = CartesianIndex(mod1(p[1]-1, lp.iL[1]), p[2], p[3]) + elseif (id == 2) + s = CartesianIndex(p[1], mod1(p[2]-1, lp.iL[2]), p[3]) + elseif (id == 3) + s = CartesianIndex(p[1], p[2], mod1(p[3]-1, lp.iL[3])) + end + + return s +end + +@inline function dw(p::CartesianIndex{2}, id, lp::SpaceParm{2}) + + if (id == 1) + s = CartesianIndex(mod1(p[1]-1, lp.iL[1]), p[2]) + elseif (id == 2) + s = CartesianIndex(p[1], mod1(p[2]-1, lp.iL[2])) + end + + return s +end + +@inline function up(p::CartesianIndex{4}, id, lp::SpaceParm{4}) + + if (id == 1) + s = CartesianIndex(mod1(p[1]+1, lp.iL[1]), p[2], p[3], p[4]) + elseif (id == 2) + s = CartesianIndex(p[1], mod1(p[2]+1, lp.iL[2]), p[3], p[4]) + elseif (id == 3) + s = CartesianIndex(p[1], p[2], mod1(p[3]+1, lp.iL[3]), p[4]) + elseif (id == 4) + s = CartesianIndex(p[1], p[2], p[3], mod1(p[4]+1, lp.iL[4])) + end + + return s +end + +@inline function up(p::CartesianIndex{3}, id, lp::SpaceParm{3}) + + if (id == 1) + s = CartesianIndex(mod1(p[1]+1, lp.iL[1]), p[2], p[3]) + elseif (id == 2) + s = CartesianIndex(p[1], mod1(p[2]+1, lp.iL[2]), p[3]) + elseif (id == 3) + s = CartesianIndex(p[1], p[2], mod1(p[3]+1, lp.iL[3])) + end + + return s +end + +@inline function up(p::CartesianIndex{2}, id, lp::SpaceParm{2}) + + if (id == 1) + s = CartesianIndex(mod1(p[1]+1, lp.iL[1]), p[2]) + elseif (id == 2) + s = CartesianIndex(p[1], mod1(p[2]+1, lp.iL[2])) + end + + return s +end + +@inline map2latt(th::NTuple{3,Int64},bl::NTuple{3,Int64}) = CartesianIndex(th[1],bl[1],bl[2],bl[2]) + +export map2latt, up, dw, shift + +end diff --git a/src/YM/YM.jl b/src/YM/YM.jl new file mode 100644 index 0000000..7b8d4a3 --- /dev/null +++ b/src/YM/YM.jl @@ -0,0 +1,25 @@ +### +### "THE BEER-WARE LICENSE": +### Alberto Ramos wrote this file. As long as you retain this +### notice you can do whatever you want with this stuff. If we meet some +### day, and you think this stuff is worth it, you can buy me a beer in +### return. +### +### file: YM.jl +### created: Mon Jul 12 16:23:51 2021 +### + + +module YM + +struct GaugeParm + beta::Float64 + cG::Tuple{Float64,Float64} +end +export GaugeParm + +include("YMact.jl") +export krnl_plaq! + + +end diff --git a/src/YM/YMact.jl b/src/YM/YMact.jl new file mode 100644 index 0000000..3110379 --- /dev/null +++ b/src/YM/YMact.jl @@ -0,0 +1,41 @@ +### +### "THE BEER-WARE LICENSE": +### Alberto Ramos wrote this file. As long as you retain this +### notice you can do whatever you want with this stuff. If we meet some +### day, and you think this stuff is worth it, you can buy me a beer in +### return. +### +### file: YMact.jl +### created: Mon Jul 12 18:31:19 2021 +### + +function krnl_plaq!(plx, U, ipl, lp::SpaceParm) + + id1, id2 = lp.plidx(ipl) + X = map2latt((CUDA.threadIdx().x,CUDA.threadIdx().y,CUDA.threadIdx().z), + (CUDA.blockIdx().x,CUDA.blockIdx().y,CUDA.blockIdx().z)) + Xu1 = up(X, id1) + Xu2 = up(X, id2) + + plx[X] = tr(U[X, id1]*U[Xu1, id2] / (U[X, id2]*U[Xu2, id1])) + + return nothing +end + +function krnl_plaq!(plx, U, lp::SpaceParm) + + X = map2latt((CUDA.threadIdx().x,CUDA.threadIdx().y,CUDA.threadIdx().z), + (CUDA.blockIdx().x,CUDA.blockIdx().y,CUDA.blockIdx().z)) + + plx[X] = 0.0 + for ipl in 1:lp.npls + id1, id2 = lp.plidx(ipl) + Xu1 = up(X, id1) + Xu2 = up(X, id2) + + plx[X] += tr(U[X, id1]*U[Xu1, id2] / (U[X, id2]*U[Xu2, id1])) + end + plx[X] = plx[X]/lp.npls + + return nothing +end