From d9b96dfd931c05883c659063f4149690c80c9390 Mon Sep 17 00:00:00 2001 From: amartin Date: Sun, 27 Mar 2022 12:56:26 +1100 Subject: [PATCH 01/11] Updated Manifest --- Manifest.toml | 142 +++++++++++++++++++++++++++----------------------- 1 file changed, 77 insertions(+), 65 deletions(-) diff --git a/Manifest.toml b/Manifest.toml index e8585e6..734aa59 100644 --- a/Manifest.toml +++ b/Manifest.toml @@ -22,9 +22,9 @@ uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" [[ArrayInterface]] deps = ["Compat", "IfElse", "LinearAlgebra", "Requires", "SparseArrays", "Static"] -git-tree-sha1 = "745233d77146ad221629590b6d82fe7f1ddb478f" +git-tree-sha1 = "6e8fada11bb015ecf9263f64b156f98b546918c7" uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" -version = "4.0.3" +version = "5.0.5" [[ArrayLayouts]] deps = ["FillArrays", "LinearAlgebra", "SparseArrays"] @@ -69,9 +69,9 @@ version = "1.16.1+1" [[ChainRulesCore]] deps = ["Compat", "LinearAlgebra", "SparseArrays"] -git-tree-sha1 = "7dd38532a1115a215de51775f9891f0f3e1bac6a" +git-tree-sha1 = "9950387274246d08af38f6eef8cb5480862a435f" uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" -version = "1.12.1" +version = "1.14.0" [[ChangesOfVariables]] deps = ["ChainRulesCore", "LinearAlgebra", "Test"] @@ -116,9 +116,9 @@ version = "0.3.0" [[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 = "44c37b4636bc54afac5c574d2d02b625349d6582" +git-tree-sha1 = "96b0bc6c52df76506efc8a441c6cf1adcb1babc4" uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" -version = "3.41.0" +version = "3.42.0" [[CompilerSupportLibraries_jll]] deps = ["Artifacts", "Libdl"] @@ -216,10 +216,9 @@ uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5" version = "2.2.3+0" [[EllipsisNotation]] -deps = ["ArrayInterface"] -git-tree-sha1 = "d7ab55febfd0907b285fbf8dc0c73c0825d9d6aa" +git-tree-sha1 = "18ee049accec8763be17a933737c1dd0fdf8673a" uuid = "da5c29d0-fa7d-589e-88eb-ea29b0a81949" -version = "1.3.0" +version = "1.0.0" [[Expat_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -259,9 +258,9 @@ version = "0.12.8" [[FiniteDiff]] deps = ["ArrayInterface", "LinearAlgebra", "Requires", "SparseArrays", "StaticArrays"] -git-tree-sha1 = "ec299fdc8f49ae450807b0cb1d161c6b76fd2b60" +git-tree-sha1 = "56956d1e4c1221000b7781104c58c34019792951" uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" -version = "2.10.1" +version = "2.11.0" [[FixedPointNumbers]] deps = ["Statistics"] @@ -335,9 +334,9 @@ version = "3.24.31+0" [[GeometryBasics]] deps = ["EarCut_jll", "IterTools", "LinearAlgebra", "StaticArrays", "StructArrays", "Tables"] -git-tree-sha1 = "58bcdf5ebc057b085e58d95c138725628dd7453c" +git-tree-sha1 = "83ea630384a13fc4f002b77690bc0afeb4255ac9" uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326" -version = "0.4.1" +version = "0.4.2" [[Gettext_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "XML2_jll"] @@ -365,11 +364,11 @@ version = "1.3.14+0" [[Gridap]] deps = ["AbstractTrees", "BSON", "BlockArrays", "Combinatorics", "DocStringExtensions", "FastGaussQuadrature", "FileIO", "FillArrays", "ForwardDiff", "JLD2", "JSON", "LineSearches", "LinearAlgebra", "NLsolve", "NearestNeighbors", "QuadGK", "Random", "SparseArrays", "SparseMatricesCSR", "StaticArrays", "Test", "WriteVTK"] -git-tree-sha1 = "90c62a904ef0e25c08dbebc8a10f12a4964f957c" +git-tree-sha1 = "f20793bcb3a099ba3b5be7b6f9c64ea440e952ef" repo-rev = "exploring_hybridization" repo-url = "https://github.com/gridap/Gridap.jl" uuid = "56d4f2e9-7ea1-5844-9cf6-b9c51ca7ce8e" -version = "0.17.8" +version = "0.17.12" [[Grisu]] git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2" @@ -378,15 +377,15 @@ version = "1.0.2" [[Gtk]] deps = ["Cairo", "Cairo_jll", "Dates", "GTK3_jll", "Glib_jll", "Graphics", "JLLWrappers", "Libdl", "Librsvg_jll", "Pkg", "Reexport", "Serialization", "Test", "Xorg_xkeyboard_config_jll", "adwaita_icon_theme_jll", "gdk_pixbuf_jll", "hicolor_icon_theme_jll"] -git-tree-sha1 = "09afd81dd7d80ae0dc6f489fd21560725e45497e" +git-tree-sha1 = "eb7302ec0e1690787f396bc882a7c681d430bfdb" uuid = "4c0ca9eb-093a-5379-98c5-f87ac0bbbf44" -version = "1.2.0" +version = "1.2.1" [[GtkObservables]] deps = ["Cairo", "Colors", "Dates", "FixedPointNumbers", "Graphics", "Gtk", "IntervalSets", "LinearAlgebra", "Observables", "Reexport", "RoundingIntegers"] -git-tree-sha1 = "5f7627f03112307cb0a3e9268c2ffd535ba91de6" +git-tree-sha1 = "96dcca8d49566c6a0fddc98fb46f7b810de6ef63" uuid = "8710efd8-4ad6-11eb-33ea-2d5ceb25a41c" -version = "1.1.0" +version = "1.2.0" [[HTTP]] deps = ["Base64", "Dates", "IniFile", "Logging", "MbedTLS", "NetworkOptions", "Sockets", "URIs"] @@ -411,10 +410,9 @@ uuid = "9b13fd28-a010-5f03-acff-a1bbcff69959" version = "1.0.0" [[IniFile]] -deps = ["Test"] -git-tree-sha1 = "098e4d2c533924c921f9f9847274f2ad89e018b8" +git-tree-sha1 = "f550e6e32074c939295eb5ea6de31849ac2c9625" uuid = "83e8ac13-25f8-5344-8a64-a9f2b223428f" -version = "0.5.0" +version = "0.5.1" [[InteractiveUtils]] deps = ["Markdown"] @@ -422,15 +420,15 @@ uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" [[IntervalSets]] deps = ["Dates", "EllipsisNotation", "Statistics"] -git-tree-sha1 = "3cc368af3f110a767ac786560045dceddfc16758" +git-tree-sha1 = "bcf640979ee55b652f3b01650444eb7bbe3ea837" uuid = "8197267c-284f-5f27-9208-e0e47529a953" -version = "0.5.3" +version = "0.5.4" [[InverseFunctions]] deps = ["Test"] -git-tree-sha1 = "a7254c0acd8e62f1ac75ad24d5db43f5f19f3c65" +git-tree-sha1 = "91b5dcf362c5add98049e6c29ee756910b03051d" uuid = "3587e190-3f89-42d0-90ee-14403ec27112" -version = "0.1.2" +version = "0.1.3" [[InvertedIndices]] git-tree-sha1 = "bee5f1ef5bf65df56bdd2e40447590b272a5471f" @@ -454,9 +452,9 @@ version = "1.0.0" [[JLD2]] deps = ["FileIO", "MacroTools", "Mmap", "OrderedCollections", "Pkg", "Printf", "Reexport", "TranscodingStreams", "UUIDs"] -git-tree-sha1 = "28b114b3279cdbac9a61c57b3e6548a572142b34" +git-tree-sha1 = "81b9477b49402b47fbe7f7ae0b252077f53e4a08" uuid = "033835bb-8acc-5ee8-8aae-3f567f8a3819" -version = "0.4.21" +version = "0.4.22" [[JLLWrappers]] deps = ["Preferences"] @@ -482,6 +480,12 @@ git-tree-sha1 = "f6250b16881adf048549549fba48b1161acdac8c" uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" version = "3.100.1+0" +[[LERC_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "bf36f528eec6634efc60d7ec062008f171071434" +uuid = "88015f11-f218-50d7-93a8-a6af411a945d" +version = "3.0.0+1" + [[LZO_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6" @@ -495,9 +499,9 @@ version = "1.3.0" [[Latexify]] deps = ["Formatting", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "Printf", "Requires"] -git-tree-sha1 = "a6552bfeab40de157a297d84e03ade4b8177677f" +git-tree-sha1 = "4f00cc36fede3c04b8acf9b2e2763decfdcecfa6" uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" -version = "0.15.12" +version = "0.15.13" [[LeftChildRightSiblingTrees]] deps = ["AbstractTrees"] @@ -573,10 +577,10 @@ uuid = "925c91fb-5dd6-59dd-8e8c-345e74382d89" version = "2.52.4+0" [[Libtiff_jll]] -deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Pkg", "Zlib_jll", "Zstd_jll"] -git-tree-sha1 = "340e257aada13f95f98ee352d316c3bed37c8ab9" +deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "Pkg", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "c9551dd26e31ab17b86cbd00c2ede019c08758eb" uuid = "89763e89-9b03-5906-acba-b20f662cd828" -version = "4.3.0+0" +version = "4.3.0+1" [[Libuuid_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -597,14 +601,14 @@ uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" version = "7.1.1" [[LinearAlgebra]] -deps = ["Libdl"] +deps = ["Libdl", "libblastrampoline_jll"] uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" [[LogExpFunctions]] deps = ["ChainRulesCore", "ChangesOfVariables", "DocStringExtensions", "InverseFunctions", "IrrationalConstants", "LinearAlgebra"] -git-tree-sha1 = "e5718a00af0ab9756305a0392832c8952c7426c1" +git-tree-sha1 = "58f25e56b706f95125dcb796f39e1fb01d913a71" uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" -version = "0.3.6" +version = "0.3.10" [[Logging]] uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" @@ -671,9 +675,9 @@ version = "0.3.7" [[NearestNeighbors]] deps = ["Distances", "StaticArrays"] -git-tree-sha1 = "16baacfdc8758bc374882566c9187e785e85c2f0" +git-tree-sha1 = "ded92de95031d4a8c61dfb6ba9adb6f1d8016ddd" uuid = "b8a86587-4115-5ab1-83bc-aa920d37bbce" -version = "0.4.9" +version = "0.4.10" [[NetworkOptions]] uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" @@ -689,15 +693,19 @@ git-tree-sha1 = "887579a3eb005446d514ab7aeac5d1d027658b8f" uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051" version = "1.3.5+1" +[[OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" + [[OpenLibm_jll]] deps = ["Artifacts", "Libdl"] uuid = "05823500-19ac-5b8b-9628-191a04bc5112" [[OpenSSL_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "648107615c15d4e09f7eca16307bc821c1f718d8" +git-tree-sha1 = "ab05aa4cc89736e95915b01e7279e61b1bfe33b8" uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" -version = "1.1.13+0" +version = "1.1.14+0" [[OpenSpecFun_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] @@ -736,9 +744,9 @@ version = "0.12.3" [[Parsers]] deps = ["Dates"] -git-tree-sha1 = "13468f237353112a01b2d6b32f3d0f80219944aa" +git-tree-sha1 = "85b5da0fa43588c75bb1ff986493443f821c70b7" uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" -version = "2.2.2" +version = "2.2.3" [[Pixman_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -758,27 +766,27 @@ version = "2.0.1" [[PlotUtils]] deps = ["ColorSchemes", "Colors", "Dates", "Printf", "Random", "Reexport", "Statistics"] -git-tree-sha1 = "6f1b25e8ea06279b5689263cc538f51331d7ca17" +git-tree-sha1 = "bb16469fd5224100e422f0b027d26c5a25de1200" uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043" -version = "1.1.3" +version = "1.2.0" [[Plots]] -deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "GeometryBasics", "JSON", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "PlotThemes", "PlotUtils", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs", "UnicodeFun", "Unzip"] -git-tree-sha1 = "5c907bdee5966a9adb8a106807b7c387e51e4d6c" +deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "GeometryBasics", "JSON", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs", "UnicodeFun", "Unzip"] +git-tree-sha1 = "5f6e1309595e95db24342e56cd4dabd2159e0b79" uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" -version = "1.25.11" +version = "1.27.3" [[PooledArrays]] deps = ["DataAPI", "Future"] -git-tree-sha1 = "db3a23166af8aebf4db5ef87ac5b00d36eb771e2" +git-tree-sha1 = "28ef6c7ce353f0b35d0df0d5930e0d072c1f5b9b" uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720" -version = "1.4.0" +version = "1.4.1" [[Preferences]] deps = ["TOML"] -git-tree-sha1 = "2cf929d64681236a2e074ffafb8d568733d2e6af" +git-tree-sha1 = "d3538e7f8a790dc8903519090857ef8e1283eecd" uuid = "21216c6a-2e73-6563-6e65-726566657250" -version = "1.2.3" +version = "1.2.5" [[PrettyTables]] deps = ["Crayons", "Formatting", "Markdown", "Reexport", "Tables"] @@ -817,7 +825,7 @@ deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" [[Random]] -deps = ["Serialization"] +deps = ["SHA", "Serialization"] uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" [[RecipesBase]] @@ -827,9 +835,9 @@ version = "1.2.1" [[RecipesPipeline]] deps = ["Dates", "NaNMath", "PlotUtils", "RecipesBase"] -git-tree-sha1 = "37c1631cb3cc36a535105e6d5557864c82cd8c2b" +git-tree-sha1 = "dc1e451e15d90347a7decc4221842a022b011714" uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c" -version = "0.5.0" +version = "0.5.2" [[Reexport]] git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" @@ -896,21 +904,21 @@ version = "0.6.6" [[SpecialFunctions]] deps = ["ChainRulesCore", "IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] -git-tree-sha1 = "85e5b185ed647b8ee89aa25a7788a2b43aa8a74f" +git-tree-sha1 = "5ba658aeecaaf96923dce0da9e703bd1fe7666f9" uuid = "276daf66-3868-5448-9aa4-cd146d93841b" -version = "2.1.3" +version = "2.1.4" [[Static]] deps = ["IfElse"] -git-tree-sha1 = "00b725fffc9a7e9aac8850e4ed75b4c1acbe8cd2" +git-tree-sha1 = "87e9954dfa33fd145694e42337bdd3d5b07021a6" uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" -version = "0.5.5" +version = "0.6.0" [[StaticArrays]] deps = ["LinearAlgebra", "Random", "Statistics"] -git-tree-sha1 = "6354dfaf95d398a1a70e0b28238321d5d17b2530" +git-tree-sha1 = "4f6ec5d99a28e1a749559ef7dd518663c5eca3d5" uuid = "90137ffa-7385-5640-81b9-e52037218182" -version = "1.4.0" +version = "1.4.3" [[Statistics]] deps = ["LinearAlgebra", "SparseArrays"] @@ -949,10 +957,10 @@ uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" version = "1.0.1" [[Tables]] -deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "TableTraits", "Test"] -git-tree-sha1 = "bb1064c9a84c52e277f1096cf41434b675cd368b" +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "OrderedCollections", "TableTraits", "Test"] +git-tree-sha1 = "5ce79ce186cc678bbb5c5681ca3379d1ddae11a1" uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" -version = "1.6.1" +version = "1.7.0" [[Tar]] deps = ["ArgTools", "SHA"] @@ -1004,9 +1012,9 @@ version = "1.19.0+0" [[Wayland_protocols_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "66d72dc6fcc86352f01676e8f0f698562e60510f" +git-tree-sha1 = "4528479aa01ee1b3b4cd0e6faef0e04cf16466da" uuid = "2381bf8a-dfd0-557d-9999-79630e7b1b91" -version = "1.23.0+0" +version = "1.25.0+0" [[WriteVTK]] deps = ["Base64", "CodecZlib", "FillArrays", "LightXML", "TranscodingStreams"] @@ -1222,6 +1230,10 @@ git-tree-sha1 = "5982a94fcba20f02f42ace44b9894ee2b140fe47" uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" version = "0.15.1+0" +[[libblastrampoline_jll]] +deps = ["Artifacts", "Libdl", "OpenBLAS_jll"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" + [[libfdk_aac_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "daacc84a041563f965be61859a36e17c4e4fcd55" From 80b15e50f126f35c2d64657fdc1703aff12fe34c Mon Sep 17 00:00:00 2001 From: amartin Date: Sun, 27 Mar 2022 22:33:19 +1100 Subject: [PATCH 02/11] HDG for Darcy working + GridapDistributed + 1 part --- Manifest.toml | 96 ++++++------ Project.toml | 2 + src/Distributed/HybridAffineFEOperators.jl | 86 +++++++++++ src/Distributed/Skeleton.jl | 38 +++++ src/GridapHybrid.jl | 5 + src/HybridAffineFEOperators.jl | 8 +- src/Skeleton.jl | 148 +++++++++++-------- test/Distributed/DarcyHDGTests.jl | 102 +++++++++++++ test/Distributed/sequential/DarcyHDGTests.jl | 5 + 9 files changed, 375 insertions(+), 115 deletions(-) create mode 100644 src/Distributed/HybridAffineFEOperators.jl create mode 100644 src/Distributed/Skeleton.jl create mode 100644 test/Distributed/DarcyHDGTests.jl create mode 100644 test/Distributed/sequential/DarcyHDGTests.jl diff --git a/Manifest.toml b/Manifest.toml index 57c9c1d..845226a 100644 --- a/Manifest.toml +++ b/Manifest.toml @@ -373,6 +373,14 @@ repo-url = "https://github.com/gridap/Gridap.jl" uuid = "56d4f2e9-7ea1-5844-9cf6-b9c51ca7ce8e" version = "0.17.12" +[[deps.GridapDistributed]] +deps = ["FillArrays", "Gridap", "LinearAlgebra", "MPI", "PartitionedArrays", "SparseArrays", "SparseMatricesCSR", "WriteVTK"] +git-tree-sha1 = "3ff43a6b0a1347ff3a9e33d94b6d0c78ab9d7846" +repo-rev = "implement_support_spaces_on_lower_dim_trians" +repo-url = "https://github.com/gridap/GridapDistributed.jl" +uuid = "f9701e48-63b3-45aa-9a63-9bc6c271f355" +version = "0.2.5" + [[deps.Grisu]] git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2" uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe" @@ -412,11 +420,7 @@ git-tree-sha1 = "012e604e1c7458645cb8b436f8fba789a51b257f" uuid = "9b13fd28-a010-5f03-acff-a1bbcff69959" version = "1.0.0" -<<<<<<< HEAD -[[IniFile]] -======= [[deps.IniFile]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 git-tree-sha1 = "f550e6e32074c939295eb5ea6de31849ac2c9625" uuid = "83e8ac13-25f8-5344-8a64-a9f2b223428f" version = "0.5.1" @@ -452,6 +456,12 @@ git-tree-sha1 = "fa6287a4469f5e048d763df38279ee729fbd44e5" uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e" version = "1.4.0" +[[deps.IterativeSolvers]] +deps = ["LinearAlgebra", "Printf", "Random", "RecipesBase", "SparseArrays"] +git-tree-sha1 = "1169632f425f79429f245113b775a0e3d121457c" +uuid = "42fd0dbc-a981-5370-80f2-aaf504508153" +version = "0.9.2" + [[deps.IteratorInterfaceExtensions]] git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" uuid = "82899510-4779-5014-852e-03e436cf321d" @@ -487,21 +497,13 @@ git-tree-sha1 = "f6250b16881adf048549549fba48b1161acdac8c" uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" version = "3.100.1+0" -<<<<<<< HEAD -[[LERC_jll]] -======= [[deps.LERC_jll]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "bf36f528eec6634efc60d7ec062008f171071434" uuid = "88015f11-f218-50d7-93a8-a6af411a945d" version = "3.0.0+1" -<<<<<<< HEAD -[[LZO_jll]] -======= [[deps.LZO_jll]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6" uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac" @@ -518,6 +520,10 @@ git-tree-sha1 = "4f00cc36fede3c04b8acf9b2e2763decfdcecfa6" uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" version = "0.15.13" +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" + [[deps.LeftChildRightSiblingTrees]] deps = ["AbstractTrees"] git-tree-sha1 = "b864cb409e8e445688bc478ef87c0afe4f6d1f8d" @@ -591,11 +597,7 @@ git-tree-sha1 = "25d5e6b4eb3558613ace1c67d6a871420bfca527" uuid = "925c91fb-5dd6-59dd-8e8c-345e74382d89" version = "2.52.4+0" -<<<<<<< HEAD -[[Libtiff_jll]] -======= [[deps.Libtiff_jll]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "Pkg", "Zlib_jll", "Zstd_jll"] git-tree-sha1 = "c9551dd26e31ab17b86cbd00c2ede019c08758eb" uuid = "89763e89-9b03-5906-acba-b20f662cd828" @@ -619,11 +621,7 @@ git-tree-sha1 = "f27132e551e959b3667d8c93eae90973225032dd" uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" version = "7.1.1" -<<<<<<< HEAD -[[LinearAlgebra]] -======= [[deps.LinearAlgebra]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 deps = ["Libdl", "libblastrampoline_jll"] uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" @@ -636,6 +634,18 @@ version = "0.3.10" [[deps.Logging]] uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +[[deps.MPI]] +deps = ["Distributed", "DocStringExtensions", "Libdl", "MPICH_jll", "MicrosoftMPI_jll", "OpenMPI_jll", "Pkg", "Random", "Requires", "Serialization", "Sockets"] +git-tree-sha1 = "d56a80d8cf8b9dc3050116346b3d83432b1912c0" +uuid = "da04e1cc-30fd-572f-bb4f-1f8673147195" +version = "0.19.2" + +[[deps.MPICH_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "8eed51eb836c8f47781cdb493ffd5f56370c0496" +uuid = "7cb0a576-ebde-5e09-9194-50597f1243b4" +version = "4.0.1+0" + [[deps.MacroTools]] deps = ["Markdown", "Random"] git-tree-sha1 = "3d3e902b31198a27340d0bf00d6ac452866021cf" @@ -667,6 +677,12 @@ git-tree-sha1 = "81e123ea81d6081fe8b733dbe79e1291d55cfb0f" uuid = "85b6ec6f-f7df-4429-9514-a64bcd9ee824" version = "0.4.6" +[[deps.MicrosoftMPI_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "a16aa086d335ed7e0170c5265247db29172af2f9" +uuid = "9237b28f-5490-5468-be7b-bb81f5f5e6cf" +version = "10.1.3+2" + [[deps.Missings]] deps = ["DataAPI"] git-tree-sha1 = "bf210ce90b6c9eed32d25dbcae1ebc565df2687f" @@ -716,22 +732,20 @@ git-tree-sha1 = "887579a3eb005446d514ab7aeac5d1d027658b8f" uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051" version = "1.3.5+1" -<<<<<<< HEAD -[[OpenBLAS_jll]] -deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] -uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" - -[[OpenLibm_jll]] -======= [[deps.OpenBLAS_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" [[deps.OpenLibm_jll]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 deps = ["Artifacts", "Libdl"] uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +[[deps.OpenMPI_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg"] +git-tree-sha1 = "6340586e076b2abd41f5ba1a3b9c774ec6b30fde" +uuid = "fe0851c0-eecd-5654-98d4-656369965a5c" +version = "4.1.2+0" + [[deps.OpenSSL_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "ab05aa4cc89736e95915b01e7279e61b1bfe33b8" @@ -779,6 +793,12 @@ git-tree-sha1 = "85b5da0fa43588c75bb1ff986493443f821c70b7" uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" version = "2.2.3" +[[deps.PartitionedArrays]] +deps = ["Distances", "IterativeSolvers", "LinearAlgebra", "MPI", "Printf", "SparseArrays", "SparseMatricesCSR"] +git-tree-sha1 = "88ff2293fd57089a4036a3056ba058ae9806111b" +uuid = "5a9dfac6-5c52-46f7-8278-5e2210713be9" +version = "0.2.10" + [[deps.Pixman_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "b4f5d02549a10e20780a24fce72bea96b6329e29" @@ -801,11 +821,7 @@ git-tree-sha1 = "bb16469fd5224100e422f0b027d26c5a25de1200" uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043" version = "1.2.0" -<<<<<<< HEAD -[[Plots]] -======= [[deps.Plots]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "GeometryBasics", "JSON", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs", "UnicodeFun", "Unzip"] git-tree-sha1 = "5f6e1309595e95db24342e56cd4dabd2159e0b79" uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" @@ -859,11 +875,7 @@ version = "2.4.2" deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" -<<<<<<< HEAD -[[Random]] -======= [[deps.Random]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 deps = ["SHA", "Serialization"] uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" @@ -995,11 +1007,7 @@ git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" version = "1.0.1" -<<<<<<< HEAD -[[Tables]] -======= [[deps.Tables]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "OrderedCollections", "TableTraits", "Test"] git-tree-sha1 = "5ce79ce186cc678bbb5c5681ca3379d1ddae11a1" uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" @@ -1273,19 +1281,11 @@ git-tree-sha1 = "5982a94fcba20f02f42ace44b9894ee2b140fe47" uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" version = "0.15.1+0" -<<<<<<< HEAD -[[libblastrampoline_jll]] -deps = ["Artifacts", "Libdl", "OpenBLAS_jll"] -uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" - -[[libfdk_aac_jll]] -======= [[deps.libblastrampoline_jll]] deps = ["Artifacts", "Libdl", "OpenBLAS_jll"] uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" [[deps.libfdk_aac_jll]] ->>>>>>> 672dd42aafaab72d5b9b9df5b0eb8c9bf6bcde76 deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "daacc84a041563f965be61859a36e17c4e4fcd55" uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" diff --git a/Project.toml b/Project.toml index 3326394..91d5cef 100644 --- a/Project.toml +++ b/Project.toml @@ -8,7 +8,9 @@ DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" DrWatson = "634d3b9d-ee7a-5ddf-bec9-22491ea816e1" FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" Gridap = "56d4f2e9-7ea1-5844-9cf6-b9c51ca7ce8e" +GridapDistributed = "f9701e48-63b3-45aa-9a63-9bc6c271f355" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +PartitionedArrays = "5a9dfac6-5c52-46f7-8278-5e2210713be9" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" ProfileView = "c46f51b8-102a-5cf2-8d2c-8597cb0e0da7" StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" diff --git a/src/Distributed/HybridAffineFEOperators.jl b/src/Distributed/HybridAffineFEOperators.jl new file mode 100644 index 0000000..4912a7e --- /dev/null +++ b/src/Distributed/HybridAffineFEOperators.jl @@ -0,0 +1,86 @@ +function _merge_bulk_and_skeleton_contributions( + matcontribs::GridapDistributed.DistributedDomainContribution, + veccontribs::GridapDistributed.DistributedDomainContribution) + dmat,dvec=map_parts(matcontribs.contribs,veccontribs.contribs) do matseq, vecseq + _merge_bulk_and_skeleton_contributions(matseq,vecseq) + end + GridapDistributed.DistributedDomainContribution(dmat), + GridapDistributed.DistributedDomainContribution(dvec) +end + +function Gridap.FESpaces._pair_contribution_when_possible( + obiform::GridapDistributed.DistributedDomainContribution, + oliform::GridapDistributed.DistributedDomainContribution) + dmv,dm,dv=map_parts(obiform.contribs,oliform.contribs) do obiform, oliform + Gridap.FESpaces._pair_contribution_when_possible(obiform,oliform) + end + GridapDistributed.DistributedDomainContribution(dmv), + GridapDistributed.DistributedDomainContribution(dm), + GridapDistributed.DistributedDomainContribution(dv) +end + +function Gridap.FESpaces._collect_cell_matrix_and_vector( + trial :: GridapDistributed.DistributedFESpace, + test :: GridapDistributed.DistributedFESpace, + matvec :: GridapDistributed.DistributedDomainContribution, + mat :: GridapDistributed.DistributedDomainContribution, + vec :: GridapDistributed.DistributedDomainContribution) + map_parts(GridapDistributed.local_views(trial), + GridapDistributed.local_views(test), + matvec.contribs,mat.contribs,vec.contribs) do trial, test, matvec, mat, vec + Gridap.FESpaces._collect_cell_matrix_and_vector(trial,test,matvec,mat,vec) + end +end + + +function _collect_cell_matrix_and_vector(trial, test, matvec, mat, vec) + matvecdata = _collect_cell_matvec(trial,test,matvec) + matdata = collect_cell_matrix(trial,test,mat) + vecdata = collect_cell_vector(test,vec) + (matvecdata, matdata, vecdata) +end + +function _add_static_condensation( + matvec::GridapDistributed.DistributedDomainContribution, + bulk_fields, skeleton_fields) + dmv=map_parts(matvec.contribs) do matvec + _add_static_condensation(matvec,bulk_fields,skeleton_fields) + end + GridapDistributed.DistributedDomainContribution(dmv) +end + +function Gridap.FESpaces._attach_dirichlet( + matvec:: GridapDistributed.DistributedDomainContribution, + mat :: GridapDistributed.DistributedDomainContribution, + uhd) + dmv,dm=map_parts(matvec.contribs,mat.contribs,uhd.fields) do matvec, mat, uhd + Gridap.FESpaces._attach_dirichlet(matvec,mat, uhd) + end + GridapDistributed.DistributedDomainContribution(dmv), + GridapDistributed.DistributedDomainContribution(dm) +end + + +function _compute_hybridizable_from_skeleton_free_dof_values( + skeleton_fe_function :: GridapDistributed.DistributedCellField, + trial_hybridizable :: GridapDistributed.DistributedFESpace, + test_hybridizable :: GridapDistributed.DistributedFESpace, + trial_skeleton :: GridapDistributed.DistributedFESpace, + matvec :: GridapDistributed.DistributedDomainContribution, + bulk_fields, skeleton_fields) + + values=map_parts(GridapDistributed.local_views(skeleton_fe_function), + GridapDistributed.local_views(trial_hybridizable), + GridapDistributed.local_views(test_hybridizable), + GridapDistributed.local_views(trial_skeleton), + GridapDistributed.local_views(matvec)) do skel_fe, trial_hyb, test_hyb, trial_skel, matvec + _compute_hybridizable_from_skeleton_free_dof_values(skel_fe, + trial_hyb, + test_hyb, + trial_skel, + matvec, + bulk_fields, + skeleton_fields) + end + PVector(values,trial_hybridizable.gids) +end diff --git a/src/Distributed/Skeleton.jl b/src/Distributed/Skeleton.jl new file mode 100644 index 0000000..ea147b0 --- /dev/null +++ b/src/Distributed/Skeleton.jl @@ -0,0 +1,38 @@ + +function SkeletonTriangulation(model::GridapDistributed.DistributedDiscreteModel) + SkeletonTriangulation(no_ghost,model::GridapDistributed.DistributedDiscreteModel) +end + +function SkeletonTriangulation(portion::GridapDistributed.WithGhost, + model::GridapDistributed.DistributedDiscreteModel) + dtrians=map_parts(model.models) do model + Skeleton(model) + end + GridapDistributed.DistributedTriangulation(dtrians,model) +end + +function SkeletonTriangulation(portion::GridapDistributed.NoGhost, + model::GridapDistributed.DistributedDiscreteModel) + dtrians=map_parts(model.models, model.gids.partition) do model, partition + #cell_to_parent_cell= + # findall([partition.lid_to_part[cell]==partition.part + # for cell=1:length(partition.lid_to_part)]) + #modelp=DiscreteModelPortion(model, cell_to_parent_cell) + Skeleton(model) + end + GridapDistributed.DistributedTriangulation(dtrians,model) +end + +function get_cell_normal_vector(dskeleton::GridapDistributed.DistributedTriangulation) + fields=map_parts(dskeleton.trians) do skeleton + get_cell_normal_vector(skeleton) + end + GridapDistributed.DistributedCellField(fields) +end + +function get_cell_owner_normal_vector(dskeleton::GridapDistributed.DistributedTriangulation) + fields=map_parts(dskeleton.trians) do skeleton + get_cell_owner_normal_vector(skeleton) + end + GridapDistributed.DistributedCellField(fields) +end diff --git a/src/GridapHybrid.jl b/src/GridapHybrid.jl index 3f0166d..db00784 100644 --- a/src/GridapHybrid.jl +++ b/src/GridapHybrid.jl @@ -37,4 +37,9 @@ include("HybridLinearSolvers.jl") include("GridapAPIExtensions.jl") include("GridapTmpModifications.jl") +using GridapDistributed +using PartitionedArrays +include("Distributed/Skeleton.jl") +include("Distributed/HybridAffineFEOperators.jl") + end # module diff --git a/src/HybridAffineFEOperators.jl b/src/HybridAffineFEOperators.jl index 3edf305..8742d15 100644 --- a/src/HybridAffineFEOperators.jl +++ b/src/HybridAffineFEOperators.jl @@ -1,7 +1,7 @@ struct HybridAffineFEOperator{TB,TS} <: FEOperator weakform::Function - trial::MultiFieldFESpace - test::MultiFieldFESpace + trial + test bulk_fields::TB skeleton_fields::TS skeleton_op::AffineFEOperator @@ -9,8 +9,8 @@ end function HybridAffineFEOperator( weakform::Function, - trial::MultiFieldFESpace, - test::MultiFieldFESpace, + trial, + test, bulk_fields::TB, skeleton_fields::TS) where {TB <: Vector{<:Integer},TS <: Vector{<:Integer}} diff --git a/src/Skeleton.jl b/src/Skeleton.jl index 2ff3f60..53334c3 100644 --- a/src/Skeleton.jl +++ b/src/Skeleton.jl @@ -15,44 +15,45 @@ struct SkeletonGrid{Dc,Dp,P,A,B,C,D} <: Grid{Dc,Dp} cell_lface_nodes::B ftype_freffe::C cell_lface_ftype::D - function SkeletonGrid(grid::Grid) - D = num_cell_dims(grid) - Dp = num_point_dims(grid) - node_coord = get_node_coordinates(grid) - cell_ctype = get_cell_type(grid) - ctype_reffe = get_reffes(grid) - @notimplementedif length(ctype_reffe) != 1 - reffe = first(ctype_reffe) - freffes = get_reffaces(ReferenceFE{D-1},reffe) - @notimplementedif length(freffes) != 1 - ftype_freffe = [first(freffes),] - - #### - ctype_lface_ftype = map(reffe->get_face_type(reffe,D-1),ctype_reffe) - cell_lface_ftype = expand_cell_data(ctype_lface_ftype,cell_ctype) - ### - - cell_nodes = get_cell_node_ids(grid) - function f(reffe) - lface_to_lnodes=get_face_nodes(reffe,D-1) - ArrayBlock(lface_to_lnodes,[true for i=1:length(lface_to_lnodes)]) - end - ctype_lface_to_lnodes = map(f,ctype_reffe) - cell_lface_to_lnodes = expand_cell_data(ctype_lface_to_lnodes,cell_ctype) - m=lazy_map(Reindex,cell_nodes) - fi = testitem(cell_lface_to_lnodes) - mi = testitem(m) - T = return_type(mi, fi) - cell_lface_nodes=LazyArray(T,m,cell_lface_to_lnodes) - - A = typeof(node_coord) - B = typeof(cell_lface_nodes) - C = typeof(ftype_freffe) - E = typeof(cell_lface_ftype) - P = typeof(grid) - new{D-1,Dp,P,A,B,C,E}( - grid,node_coord,cell_lface_nodes,ftype_freffe,cell_lface_ftype) +end + +function SkeletonGrid(grid::Grid) + D = num_cell_dims(grid) + Dp = num_point_dims(grid) + node_coord = get_node_coordinates(grid) + cell_ctype = get_cell_type(grid) + ctype_reffe = get_reffes(grid) + @notimplementedif length(ctype_reffe) != 1 + reffe = first(ctype_reffe) + freffes = get_reffaces(ReferenceFE{D-1},reffe) + @notimplementedif length(freffes) != 1 + ftype_freffe = [first(freffes),] + + #### + ctype_lface_ftype = map(reffe->get_face_type(reffe,D-1),ctype_reffe) + cell_lface_ftype = expand_cell_data(ctype_lface_ftype,cell_ctype) + ### + + cell_nodes = get_cell_node_ids(grid) + function f(reffe) + lface_to_lnodes=get_face_nodes(reffe,D-1) + ArrayBlock(lface_to_lnodes,[true for i=1:length(lface_to_lnodes)]) end + ctype_lface_to_lnodes = map(f,ctype_reffe) + cell_lface_to_lnodes = expand_cell_data(ctype_lface_to_lnodes,cell_ctype) + m=lazy_map(Reindex,cell_nodes) + fi = testitem(cell_lface_to_lnodes) + mi = testitem(m) + T = return_type(mi, fi) + cell_lface_nodes=LazyArray(T,m,cell_lface_to_lnodes) + + A = typeof(node_coord) + B = typeof(cell_lface_nodes) + C = typeof(ftype_freffe) + E = typeof(cell_lface_ftype) + P = typeof(grid) + new{D-1,Dp,P,A,B,C,E}( + grid,node_coord,cell_lface_nodes,ftype_freffe,cell_lface_ftype) end Geometry.get_node_coordinates(a::SkeletonGrid) = a.node_coord @@ -115,32 +116,33 @@ struct SkeletonTriangulation{Dc,Dp,A,B,C} <: Triangulation{Dc,Dp} grid::B sign_flip::C glue::Gridap.Geometry.FaceToCellGlue - function SkeletonTriangulation(model::DiscreteModel) - A = typeof(model) - D = num_cell_dims(model) - mgrid = get_grid(model) - fgrid = Grid(ReferenceFE{D-1},model) - glue = Gridap.Geometry.FaceToCellGlue(get_grid_topology(model), - mgrid, - fgrid, - collect(1:num_facets(model)), - Fill(Int8(1),num_facets(model))) - sgrid = SkeletonGrid(mgrid) - B = typeof(sgrid) - - # Generate sign_flip - # TO-DO: here I am reusing the machinery for global RT FE spaces. - # Sure there is a way to decouple this from global RT FE spaces. - function _get_sign_flip(model) - basis,reffe_args,reffe_kwargs = ReferenceFE(raviart_thomas,Float64,0) - cell_reffe = ReferenceFE(model,basis,reffe_args...;reffe_kwargs...) - Gridap.FESpaces.get_sign_flip(model,cell_reffe) - end - sign_flip=_get_sign_flip(model) +end - C = typeof(sign_flip) - new{D-1,D,A,B,C}(model,sgrid,sign_flip,glue) +function SkeletonTriangulation(model::DiscreteModel) + A = typeof(model) + D = num_cell_dims(model) + mgrid = get_grid(model) + fgrid = Grid(ReferenceFE{D-1},model) + glue = Gridap.Geometry.FaceToCellGlue(get_grid_topology(model), + mgrid, + fgrid, + collect(1:num_facets(model)), + Fill(Int8(1),num_facets(model))) + sgrid = SkeletonGrid(mgrid) + B = typeof(sgrid) + + # Generate sign_flip + # TO-DO: here I am reusing the machinery for global RT FE spaces. + # Sure there is a way to decouple this from global RT FE spaces. + function _get_sign_flip(model) + basis,reffe_args,reffe_kwargs = ReferenceFE(raviart_thomas,Float64,0) + cell_reffe = ReferenceFE(model,basis,reffe_args...;reffe_kwargs...) + Gridap.FESpaces.get_sign_flip(model,cell_reffe) end + sign_flip=_get_sign_flip(model) + + C = typeof(sign_flip) + new{D-1,D,A,B,C}(model,sgrid,sign_flip,glue) end Skeleton(args...) = SkeletonTriangulation(args...) @@ -201,8 +203,28 @@ function Gridap.FESpaces.get_cell_fe_data( sface_to_data end -function Geometry.best_target(a::BodyFittedTriangulation{Dca}, - b::BodyFittedTriangulation{Dcb}) where {Dca,Dcb} +function Geometry.best_target(a::BodyFittedTriangulation{1}, + b::BodyFittedTriangulation{2}) where {Dca,Dcb} + _best_target(a,b) +end + +function Geometry.best_target(a::BodyFittedTriangulation{2}, + b::BodyFittedTriangulation{1}) where {Dca,Dcb} + _best_target(a,b) +end + +function Geometry.best_target(a::BodyFittedTriangulation{2}, + b::BodyFittedTriangulation{3}) where {Dca,Dcb} + _best_target(a,b) +end + +function Geometry.best_target(a::BodyFittedTriangulation{3}, + b::BodyFittedTriangulation{2}) where {Dca,Dcb} + _best_target(a,b) +end + +function _best_target(a::BodyFittedTriangulation{Dca}, + b::BodyFittedTriangulation{Dcb}) where {Dca,Dcb} @assert Dca==Dcb-1 || Dca-1==Dcb @assert get_background_model(a)===get_background_model(b) Skeleton(get_background_model(a)) diff --git a/test/Distributed/DarcyHDGTests.jl b/test/Distributed/DarcyHDGTests.jl new file mode 100644 index 0000000..c4edd1c --- /dev/null +++ b/test/Distributed/DarcyHDGTests.jl @@ -0,0 +1,102 @@ +module DarcyHDGTests + +using Test +using Gridap +using GridapDistributed +using PartitionedArrays +using Gridap +using FillArrays +using Gridap.Geometry +using GridapHybrid + +function main(parts) + partition = (0,1,0,1) + cells = (2,2) + model = CartesianDiscreteModel(parts,partition,cells) + order=1 + solve_darcy_lhdg(model,order) +end + +u(x) = VectorValue(1+x[1],1+x[2]) +Gridap.divergence(::typeof(u)) = (x) -> 2 +p(x) = -3.14 +∇p(x) = VectorValue(0,0) +Gridap.∇(::typeof(p)) = ∇p +f(x) = u(x) + ∇p(x) +# Normal component of u(x) on Neumann boundary +function g(x) + tol=1.0e-14 + if (abs(x[2])(a(u,v),l(v)), X, Y, [1,2], [3]) + xh=solve(op) + + uh,_=xh + e = u -uh + @test sqrt(sum(∫(e⋅e)dΩ)) < 1.0e-12 + end +end # module diff --git a/test/Distributed/sequential/DarcyHDGTests.jl b/test/Distributed/sequential/DarcyHDGTests.jl new file mode 100644 index 0000000..d71342c --- /dev/null +++ b/test/Distributed/sequential/DarcyHDGTests.jl @@ -0,0 +1,5 @@ +module DarcyHDGTestsSeq +using PartitionedArrays +include("../DarcyHDGTests.jl") +prun(DarcyHDGTests.main,sequential,(1,1)) +end # module From e3c5d2d7bc532b0bc7a47185d3b566f276f6eb25 Mon Sep 17 00:00:00 2001 From: amartin Date: Wed, 30 Mar 2022 16:45:53 +1100 Subject: [PATCH 03/11] Distributed/DarcyHDGTests.jl working with sequential backend --- src/Distributed/HybridAffineFEOperators.jl | 28 ++- src/Distributed/Skeleton.jl | 9 +- src/HybridAffineFEOperators.jl | 98 ++++++--- src/Skeleton.jl | 239 ++++++++++++++++----- src/SkeletonArrays.jl | 43 ++-- test/Distributed/DarcyHDGTests.jl | 17 +- 6 files changed, 303 insertions(+), 131 deletions(-) diff --git a/src/Distributed/HybridAffineFEOperators.jl b/src/Distributed/HybridAffineFEOperators.jl index 4912a7e..dfa3a14 100644 --- a/src/Distributed/HybridAffineFEOperators.jl +++ b/src/Distributed/HybridAffineFEOperators.jl @@ -32,14 +32,6 @@ function Gridap.FESpaces._collect_cell_matrix_and_vector( end end - -function _collect_cell_matrix_and_vector(trial, test, matvec, mat, vec) - matvecdata = _collect_cell_matvec(trial,test,matvec) - matdata = collect_cell_matrix(trial,test,mat) - vecdata = collect_cell_vector(test,vec) - (matvecdata, matdata, vecdata) -end - function _add_static_condensation( matvec::GridapDistributed.DistributedDomainContribution, bulk_fields, skeleton_fields) @@ -69,11 +61,7 @@ function _compute_hybridizable_from_skeleton_free_dof_values( matvec :: GridapDistributed.DistributedDomainContribution, bulk_fields, skeleton_fields) - values=map_parts(GridapDistributed.local_views(skeleton_fe_function), - GridapDistributed.local_views(trial_hybridizable), - GridapDistributed.local_views(test_hybridizable), - GridapDistributed.local_views(trial_skeleton), - GridapDistributed.local_views(matvec)) do skel_fe, trial_hyb, test_hyb, trial_skel, matvec + function f(skel_fe, trial_hyb, test_hyb, trial_skel, matvec) _compute_hybridizable_from_skeleton_free_dof_values(skel_fe, trial_hyb, test_hyb, @@ -81,6 +69,16 @@ function _compute_hybridizable_from_skeleton_free_dof_values( matvec, bulk_fields, skeleton_fields) - end - PVector(values,trial_hybridizable.gids) + end + # f(skeleton_fe_function.fields.parts[1], + # trial_hybridizable.part_fe_space.parts[1], + # test_hybridizable.part_fe_space.parts[1], + # trial_skeleton.spaces.parts[1], + # matvec.contribs.parts[1]) + values=map_parts(f,GridapDistributed.local_views(skeleton_fe_function), + GridapDistributed.local_views(trial_hybridizable), + GridapDistributed.local_views(test_hybridizable), + GridapDistributed.local_views(trial_skeleton), + GridapDistributed.local_views(matvec)) + PVector(values,trial_hybridizable.gids) end diff --git a/src/Distributed/Skeleton.jl b/src/Distributed/Skeleton.jl index ea147b0..6f7ab9d 100644 --- a/src/Distributed/Skeleton.jl +++ b/src/Distributed/Skeleton.jl @@ -14,11 +14,10 @@ end function SkeletonTriangulation(portion::GridapDistributed.NoGhost, model::GridapDistributed.DistributedDiscreteModel) dtrians=map_parts(model.models, model.gids.partition) do model, partition - #cell_to_parent_cell= - # findall([partition.lid_to_part[cell]==partition.part - # for cell=1:length(partition.lid_to_part)]) - #modelp=DiscreteModelPortion(model, cell_to_parent_cell) - Skeleton(model) + cell_to_parent_cell= + findall([partition.lid_to_part[cell]==partition.part + for cell=1:length(partition.lid_to_part)]) + Skeleton(model,cell_to_parent_cell) end GridapDistributed.DistributedTriangulation(dtrians,model) end diff --git a/src/HybridAffineFEOperators.jl b/src/HybridAffineFEOperators.jl index 8742d15..a779d65 100644 --- a/src/HybridAffineFEOperators.jl +++ b/src/HybridAffineFEOperators.jl @@ -121,25 +121,40 @@ function _compute_hybridizable_from_skeleton_free_dof_values(skeleton_fe_functio cell_wise_facets = _get_cell_wise_facets(model) cells_around_facets = _get_cells_around_facets(model) + if (isa(Γ.grid.parent,Gridap.Geometry.GridView)) + cell_to_parent_cell = Γ.grid.parent.cell_to_parent_cell + ifacet_to_facet, facet_to_icell = + _find_faces_touched_by_cells(cell_to_parent_cell, + cell_wise_facets, + cells_around_facets) + #cells_around_facets=lazy_map(Reindex(cells_around_facets),ifacet_to_facet) + end + nfields = length(bulk_fields) + length(skeleton_fields) m = Gridap.Fields.BlockMap(nfields, skeleton_fields) L = Gridap.FESpaces.get_fe_space(skeleton_fe_function) + L_cell_dof_ids = get_cell_dof_ids(L) + if (isa(Γ.grid.parent,Gridap.Geometry.GridView)) + L_cell_dof_ids=lazy_map(Reindex(L_cell_dof_ids),ifacet_to_facet) + end + lhₑ = lazy_map(m, convert_cell_wise_dofs_array_to_facet_dofs_array( cells_around_facets, cell_wise_facets, lhₖ, - get_cell_dof_ids(L))...) + L_cell_dof_ids)...) assem = SparseMatrixAssembler(trial_hybridizable, test_hybridizable) - lhₑ_dofs = get_cell_dof_ids(trial_hybridizable, get_triangulation(L)) + Ltrian=get_triangulation(L) + if (isa(Γ.grid.parent,Gridap.Geometry.GridView)) + Ltrian=view(Ltrian,ifacet_to_facet) + end + lhₑ_dofs = get_cell_dof_ids(trial_hybridizable, Ltrian) lhₑ_dofs = lazy_map(m, lhₑ_dofs.args[skeleton_fields]...) - Ω = trial_hybridizable[first(bulk_fields)] - Ω = get_triangulation(Ω) - m = Gridap.Fields.BlockMap(length(bulk_fields), bulk_fields) - uhph_dofs = get_cell_dof_ids(trial_hybridizable, Ω) + uhph_dofs = get_cell_dof_ids(trial_hybridizable, Γ) # This last step is needed as get_cell_dof_ids(...) returns as many blocks # as fields in trial, regardless of the FEspaces defined on Ω or not uhph_dofs = lazy_map(m, uhph_dofs.args[bulk_fields]...) @@ -188,9 +203,10 @@ function convert_cell_wise_dofs_array_to_facet_dofs_array( cells_around_facets, cell_wise_facets, cell_dofs::AbstractVector{<:AbstractVector{<:Real}}, - facet_dofs_ids::AbstractVector{<:AbstractVector{<:Integer}}) - glue = _generate_glue_among_facet_and_cell_wise_dofs_arrays( - cells_around_facets, cell_wise_facets, facet_dofs_ids) + facet_dofs_ids::AbstractVector{<:AbstractVector{<:Integer}}, + ifacet_to_facet::AbstractVector{<:Integer}=IdentityVector(length(facet_dofs_ids))) + glue = _generate_glue_among_facet_and_cell_wise_dofs_arrays( + cells_around_facets, cell_wise_facets, facet_dofs_ids, ifacet_to_facet) k = ExtractFacetDofsFromCellDofsMap(cell_dofs) [lazy_map(k, glue)] end @@ -198,30 +214,36 @@ end function _generate_glue_among_facet_and_cell_wise_dofs_arrays( cells_around_facets, cell_wise_facets, - facet_dof_ids::AbstractVector{<:AbstractVector{<:Integer}}) - - c1 = array_cache(cells_around_facets) - c2 = array_cache(cell_wise_facets) - c3 = array_cache(facet_dof_ids) - - result = Vector{NTuple{3,Int}}(undef, length(facet_dof_ids)) - current = 1 - ndofs = 0 - for facet_gid = 1:length(cells_around_facets) - cell_gid = Gridap.Arrays.getindex!(c1, cells_around_facets, facet_gid)[1] - current_cell_facets = Gridap.Arrays.getindex!(c2, cell_wise_facets, cell_gid) - pos = 1 - for facet_gid_in_cell in current_cell_facets - ndofs = length(Gridap.Arrays.getindex!(c3, facet_dof_ids, facet_gid_in_cell)) - if (facet_gid == facet_gid_in_cell) - break - else - pos = pos + ndofs - end - end - result[facet_gid] = (cell_gid, pos, ndofs) - end - result + facet_dof_ids::AbstractVector{<:AbstractVector{<:Integer}}, + ifacet_to_facet::AbstractVector{<:Integer}=IdentityVector(length(facet_dof_ids))) + + @check length(ifacet_to_facet) == length(facet_dof_ids) + + facet_to_ifacet=Dict([facet=>ifacet for (ifacet,facet) in enumerate(ifacet_to_facet)]) + + c1 = array_cache(cells_around_facets) + c2 = array_cache(cell_wise_facets) + c3 = array_cache(facet_dof_ids) + + result = Vector{NTuple{3,Int}}(undef, length(facet_dof_ids)) + current = 1 + ndofs = 0 + for (ifacet,facet_gid) in enumerate(ifacet_to_facet) + cell_gid = Gridap.Arrays.getindex!(c1, cells_around_facets, facet_gid)[1] + current_cell_facets = Gridap.Arrays.getindex!(c2, cell_wise_facets, cell_gid) + pos = 1 + for facet_gid_in_cell in current_cell_facets + ndofs = length(Gridap.Arrays.getindex!(c3, facet_dof_ids, facet_gid_in_cell)) + + if (facet_gid == facet_gid_in_cell) + break + else + pos = pos + ndofs + end + end + result[ifacet] = (cell_gid, pos, ndofs) + end + result end function convert_cell_wise_dofs_array_to_facet_dofs_array( @@ -362,10 +384,18 @@ function Gridap.FESpaces.get_cell_fe_data( tglue::SkeletonGlue) where Dc model = tglue.trian.model if Dc == num_cell_dims(model) - sface_to_data + if (isa(tglue.trian.grid.parent,Gridap.Geometry.GridView)) + cell_to_parent_cell=tglue.trian.grid.parent.cell_to_parent_cell + sface_to_data = lazy_map(Reindex(sface_to_data),cell_to_parent_cell) + end + sface_to_data else @assert Dc == num_cell_dims(model) - 1 cell_wise_facets = _get_cell_wise_facets(model) + if (isa(tglue.trian.grid.parent,Gridap.Geometry.GridView)) + cell_to_parent_cell=tglue.trian.grid.parent.cell_to_parent_cell + cell_wise_facets = lazy_map(Reindex(cell_wise_facets),cell_to_parent_cell) + end restrict_facet_dof_ids_to_cell_boundary(cell_wise_facets, sface_to_data) end end diff --git a/src/Skeleton.jl b/src/Skeleton.jl index 53334c3..69deb01 100644 --- a/src/Skeleton.jl +++ b/src/Skeleton.jl @@ -52,7 +52,7 @@ function SkeletonGrid(grid::Grid) C = typeof(ftype_freffe) E = typeof(cell_lface_ftype) P = typeof(grid) - new{D-1,Dp,P,A,B,C,E}( + SkeletonGrid{D-1,Dp,P,A,B,C,E}( grid,node_coord,cell_lface_nodes,ftype_freffe,cell_lface_ftype) end @@ -99,7 +99,7 @@ function Gridap.Arrays.return_type(k::Reindex,i::VectorBlock{<:Vector{<:Integer} TR=eltype(k.values) VectorBlock{Vector{TR}} end -# Default return_values fails because one(::VectorBlock{<:Vector{<:Integer}}) is NOT defined +# Default return_value fails because one(::VectorBlock{<:Vector{<:Integer}}) is NOT defined # This justifies why I had to define the following function function Gridap.Arrays.return_value(k::Reindex,i::VectorBlock{<:Vector{<:Integer}}) evaluate(k,i) @@ -118,6 +118,15 @@ struct SkeletonTriangulation{Dc,Dp,A,B,C} <: Triangulation{Dc,Dp} glue::Gridap.Geometry.FaceToCellGlue end +# Generate sign_flip +# TO-DO: here I am reusing the machinery for global RT FE spaces. +# Sure there is a way to decouple this from global RT FE spaces. +function _get_sign_flip(model) + basis,reffe_args,reffe_kwargs = ReferenceFE(raviart_thomas,Float64,0) + cell_reffe = ReferenceFE(model,basis,reffe_args...;reffe_kwargs...) + Gridap.FESpaces.get_sign_flip(model,cell_reffe) +end + function SkeletonTriangulation(model::DiscreteModel) A = typeof(model) D = num_cell_dims(model) @@ -131,18 +140,84 @@ function SkeletonTriangulation(model::DiscreteModel) sgrid = SkeletonGrid(mgrid) B = typeof(sgrid) - # Generate sign_flip - # TO-DO: here I am reusing the machinery for global RT FE spaces. - # Sure there is a way to decouple this from global RT FE spaces. - function _get_sign_flip(model) - basis,reffe_args,reffe_kwargs = ReferenceFE(raviart_thomas,Float64,0) - cell_reffe = ReferenceFE(model,basis,reffe_args...;reffe_kwargs...) - Gridap.FESpaces.get_sign_flip(model,cell_reffe) - end sign_flip=_get_sign_flip(model) C = typeof(sign_flip) - new{D-1,D,A,B,C}(model,sgrid,sign_flip,glue) + SkeletonTriangulation{D-1,D,A,B,C}(model,sgrid,sign_flip,glue) +end + +function _find_faces_touched_by_cells(cell_to_parent_cell, + cells_to_facets::Table, + facets_to_cells::Table) + + nfacets = 0 + touched=Dict{Int,Bool}() + cache=array_cache(cell_to_parent_cell) + for i in eachindex(cell_to_parent_cell) + cell = getindex!(cache,cell_to_parent_cell,i) + a = cells_to_facets.ptrs[cell] + b = cells_to_facets.ptrs[cell+1]-1 + for j=a:b + facet=cells_to_facets.data[j] + if !(facet in keys(touched)) + touched[facet]=true + nfacets+=1 + end + end + end + touched=Dict{Int,Bool}() + T = eltype(eltype(cells_to_facets)) + ifacet_to_facet = zeros(T,nfacets) + facet_to_icell = ones(T,length(facets_to_cells)) + nfacets = 0 + for i in eachindex(cell_to_parent_cell) + cell = getindex!(cache,cell_to_parent_cell,i) + a = cells_to_facets.ptrs[cell] + b = cells_to_facets.ptrs[cell+1]-1 + for j=a:b + facet=cells_to_facets.data[j] + if !(facet in keys(touched)) + touched[facet]=true + nfacets+=1 + ifacet_to_facet[nfacets]=facet + c = facets_to_cells.ptrs[facet] + d = facets_to_cells.ptrs[facet+1] + if ((d-c)==2) + if (facets_to_cells.data[d-1]==cell) + facet_to_icell[facet]=2 + end + end + end + end + end + ifacet_to_facet, facet_to_icell +end + +function SkeletonTriangulation(model::DiscreteModel{D}, + cell_to_parent_cell::AbstractVector{<:Integer}) where D + topo = get_grid_topology(model) + cells_to_facets = Table(get_faces(topo,D,D-1)) + facets_to_cells = Table(get_faces(topo,D-1,D)) + ifacet_to_facet, facet_to_icell = _find_faces_touched_by_cells(cell_to_parent_cell, + cells_to_facets, + facets_to_cells) + facet_grid = Grid(ReferenceFE{D-1},model) + cell_grid = get_grid(model) + ifacet_grid = view(facet_grid,ifacet_to_facet) + + glue = Gridap.Geometry.FaceToCellGlue(topo, + cell_grid, + ifacet_grid, + ifacet_to_facet, + facet_to_icell) + A = typeof(model) + cell_grid = view(cell_grid,cell_to_parent_cell) + sgrid = SkeletonGrid(cell_grid) + B = typeof(sgrid) + sign_flip=_get_sign_flip(model) + sign_flip=lazy_map(Reindex(sign_flip),cell_to_parent_cell) + C = typeof(sign_flip) + SkeletonTriangulation{D-1,D,A,B,C}(model,sgrid,sign_flip,glue) end Skeleton(args...) = SkeletonTriangulation(args...) @@ -232,15 +307,56 @@ end # TO-DO: dirty. I cannot check whether a===b, as a and b might be created from scratch # along the process +# TO-DO: fix current implementation of this function. It is nothing but a quick +# and dirty workaround. Possibly using TriangulationView and GridView. function Geometry.best_target(a::SkeletonTriangulation{Dc}, b::SkeletonTriangulation{Dc}) where {Dc} - a + agrid=a.grid.parent + bgrid=b.grid.parent + if (typeof(agrid)==typeof(bgrid)) + a + elseif (isa(agrid,Gridap.Geometry.GridView)) + a + elseif (isa(bgrid,Gridap.Geometry.GridView)) + b + else + @notimplemented + end + end +# TO-DO: fix current implementation of this function. It is nothing but a quick +# and dirty workaround. Possibly using TriangulationView and GridView. function CellData.change_domain_ref_ref(a::CellField, ttrian::SkeletonTriangulation, - sglue::SkeletonGlue,tglue::SkeletonGlue) - a + sglue::SkeletonGlue, + tglue::SkeletonGlue) + + sgrid=sglue.trian.grid.parent + tgrid=tglue.trian.grid.parent + @assert get_background_model(sglue.trian)===get_background_model(tglue.trian) + if (typeof(sgrid)==typeof(tgrid) && !isa(sgrid,Gridap.Geometry.GridView)) + a + else + if (!isa(sgrid,Gridap.Geometry.GridView) && + isa(tgrid,Gridap.Geometry.GridView)) + cell_to_parent_cell=tgrid.cell_to_parent_cell + a_field = Gridap.CellData.get_data(a) + a_field_view = lazy_map(Reindex(a_field),cell_to_parent_cell) + Gridap.CellData.similar_cell_field(a,a_field_view,ttrian,ReferenceDomain()) + elseif (isa(sgrid,Gridap.Geometry.GridView) && + !isa(tgrid,Gridap.Geometry.GridView)) + cell_to_parent_cell=sgrid.cell_to_parent_cell + a_field = Gridap.CellData.get_data(a) + a_field_view = lazy_map(Reindex(a_field),cell_to_parent_cell) + Gridap.CellData.similar_cell_field(a,a_field_view,ttrian,ReferenceDomain()) + else + scell_to_parent_cell=sgrid.cell_to_parent_cell + tcell_to_parent_cell=tgrid.cell_to_parent_cell + @notimplementedif !all(scell_to_parent_cell==tcell_to_parent_cell) + a + end + end end function Geometry.get_glue(trian::SkeletonTriangulation{D},::Val{D}) where D @@ -271,12 +387,17 @@ function Geometry.get_glue(trian::SkeletonTriangulation{d},::Val{D}) where {d,D} poly = get_polytope(reffe) num_faces(poly,d) end - # Avoid allocations here - tcell_lface_mface = lazy_map(cell_ctype,cell_cell) do ctype, cell + function f(ctype, cell) nlfaces = ctype_nlfaces[ctype] fill(cell,nlfaces) end - tcell_lface_mface_map = _setup_tcell_lface_mface_map(d,trian.model,trian.glue) + # Avoid allocations here + # TO-THINK. I am not 100% sure if tcell_lface_mface now + # holds the data it was planned to hold. + # It does not cause trouble as it turns out tcell_lface_mface + # is not currently being used. + tcell_lface_mface = lazy_map(f,cell_ctype,cell_cell) + tcell_lface_mface_map = _setup_tcell_lface_mface_map(d,trian.model,trian.grid.parent,trian.glue) SkeletonGlue(trian,tcell_lface_mface,tcell_lface_mface_map) end @@ -290,38 +411,42 @@ function CellData.change_domain_ref_ref( if isa(strian,Triangulation{D,D}) b=_restrict_to_skeleton_cell_field(ttrian.model, + ttrian.grid.parent, ttrian.glue, tglue.tcell_lface_mface_map, a) elseif isa(strian,Triangulation{D-1,D}) - b=_restrict_to_skeleton_facet_field(ttrian.model,ttrian.glue,a) + b=_restrict_to_skeleton_facet_field(ttrian.model,ttrian.grid.parent,ttrian.glue,a) end CellData.similar_cell_field(a,b,ttrian,ReferenceDomain()) end function _restrict_to_skeleton_cell_field(model, + cell_grid, glue, tface_to_mface_map, cell_fe_basis::Gridap.CellData.CellField) D = num_cell_dims(model) Gridap.Helpers.@check isa(get_triangulation(cell_fe_basis),Triangulation{D,D}) - cell_a_q = _transform_cell_to_cell_lface_array(glue, + cell_a_q = _transform_cell_to_cell_lface_array(glue,cell_grid, Gridap.CellData.get_data(cell_fe_basis); add_naive_innermost_block_level=true) lazy_map(Broadcasting(∘),cell_a_q,tface_to_mface_map) end function _transform_cell_to_cell_lface_array(glue, - cell_array::Fill; - add_naive_innermost_block_level=false) - d = Gridap.Arrays.CompressedArray([cell_array.value,],Fill(1,length(cell_array))) - _transform_cell_to_cell_lface_array(glue,d;add_naive_innermost_block_level=add_naive_innermost_block_level) + cell_grid, + cell_array::Fill; + add_naive_innermost_block_level=false) + d = Gridap.Arrays.CompressedArray([cell_array.value,],Fill(1,num_cells(cell_grid))) + _transform_cell_to_cell_lface_array(glue,cell_grid,d;add_naive_innermost_block_level=add_naive_innermost_block_level) end function _transform_cell_to_cell_lface_array(glue, - cell_array::Gridap.Arrays.CompressedArray; - add_naive_innermost_block_level=false) + cell_grid, + cell_array::Gridap.Arrays.CompressedArray; + add_naive_innermost_block_level=false) T=typeof(cell_array.values[1]) ctype_to_vector_block= Vector{Gridap.Fields.VectorBlock{T}}(undef,length(glue.ctype_to_lface_to_ftype)) @@ -338,13 +463,14 @@ function _transform_cell_to_cell_lface_array(glue, if add_naive_innermost_block_level ctype_to_vector_block=collect(lazy_map(AddNaiveInnerMostBlockLevelMap(),ctype_to_vector_block)) end - Gridap.Arrays.CompressedArray(ctype_to_vector_block,glue.cell_to_ctype) + Gridap.Arrays.CompressedArray(ctype_to_vector_block,get_cell_type(cell_grid)) end function _transform_cell_to_cell_lface_array(glue, + cell_grid, cell_array::AbstractVector; add_naive_innermost_block_level=false) - ctype_to_vector_block=SkeletonVectorFromCellVector(glue,cell_array) + ctype_to_vector_block=SkeletonVectorFromCellVector(glue,cell_grid,cell_array) if add_naive_innermost_block_level ctype_to_vector_block=collect(lazy_map(AddNaiveInnerMostBlockLevelMap(),ctype_to_vector_block)) end @@ -361,6 +487,7 @@ function _transform_cell_to_cell_lface_array( end function _restrict_to_skeleton_facet_field(model, + cell_grid, glue, facet_fe_function::Gridap.FESpaces.SingleFieldFEFunction) D = num_cell_dims(model) @@ -371,6 +498,7 @@ function _restrict_to_skeleton_facet_field(model, end function _restrict_to_skeleton_facet_field(model, + cell_grid, glue, facet_fe_basis::Gridap.CellData.CellField) @@ -379,11 +507,13 @@ function _restrict_to_skeleton_facet_field(model, _transform_face_to_cell_lface_expanded_array( glue, + cell_grid, Gridap.CellData.get_data(facet_fe_basis)) end function _transform_face_to_cell_lface_expanded_array( glue, + cell_grid, face_array::Gridap.Arrays.LazyArray{<:Fill{typeof(transpose)}}) Gridap.Helpers.@check typeof(face_array.args[1]) <: Gridap.Arrays.CompressedArray @@ -393,12 +523,13 @@ function _transform_face_to_cell_lface_expanded_array( v[i]=evaluate(transpose,face_array.args[1].values[i]) end face_array_compressed=Gridap.Arrays.CompressedArray(v,face_array.args[1].ptrs) - _transform_face_to_cell_lface_expanded_array(glue,face_array_compressed) + _transform_face_to_cell_lface_expanded_array(glue,cell_grid,face_array_compressed) end function _transform_face_to_cell_lface_expanded_array(glue, - face_array::Fill) + cell_grid, + face_array::Fill) T=typeof(face_array.value) ctype_to_vector_block= Vector{Gridap.Fields.VectorBlock{T}}(undef,length(glue.ctype_to_lface_to_ftype)) @@ -413,11 +544,12 @@ function _transform_face_to_cell_lface_expanded_array(glue, end ctype_to_vector_block[ctype]=Gridap.Fields.ArrayBlock(v,t) end - Gridap.Arrays.CompressedArray(ctype_to_vector_block,glue.cell_to_ctype) + Gridap.Arrays.CompressedArray(ctype_to_vector_block,get_cell_type(cell_grid)) end function _transform_face_to_cell_lface_expanded_array(glue, - face_array::Gridap.Arrays.CompressedArray) + cell_grid, + face_array::Gridap.Arrays.CompressedArray) ftype_to_block_layout=_get_block_layout(face_array.values) T=eltype(face_array.values[1]) if length(ftype_to_block_layout[1][1]) == 1 @@ -471,7 +603,7 @@ function _transform_face_to_cell_lface_expanded_array(glue, end ctype_to_vector_block[ctype]=Gridap.Fields.ArrayBlock(vf1,tf1) end - Gridap.Arrays.CompressedArray(ctype_to_vector_block,glue.cell_to_ctype) + Gridap.Arrays.CompressedArray(ctype_to_vector_block,get_cell_type(cell_grid)) end function _get_block_layout(fields_array::AbstractArray{<:AbstractArray{<:Gridap.Fields.Field}}) @@ -501,13 +633,12 @@ Returns a cell-wise array which, for each cell, and each facet within the cell, returns the unit outward normal to the boundary of the cell. """ function get_cell_normal_vector(s::SkeletonTriangulation) - cell_lface_normal=_get_cell_normal_vector(s.model, s.glue, _cell_lface_to_nref) + cell_lface_normal=_get_cell_normal_vector(s.model, s.grid.parent, s.glue, _cell_lface_to_nref) GenericCellField(cell_lface_normal,s,ReferenceDomain()) end function _cell_lface_to_nref(args...) - model,glue = args[1],first(args[2:end]) - cell_grid = get_grid(model) + model, cell_grid, glue = args[1],args[2],first(args[3:end]) ## Reference normal function f(r) p = Gridap.ReferenceFEs.get_polytope(r) @@ -518,7 +649,7 @@ function _cell_lface_to_nref(args...) lface_pindex_to_n end ctype_lface_pindex_to_nref = map(f, get_reffes(cell_grid)) - SkeletonCompressedVector(ctype_lface_pindex_to_nref,glue) + SkeletonCompressedVector(ctype_lface_pindex_to_nref,cell_grid,glue) end """ @@ -528,6 +659,7 @@ returns the unit outward normal to the boundary of the cell owner of the facet. function get_cell_owner_normal_vector(s::SkeletonTriangulation) cell_owner_lface_normal=_get_cell_normal_vector( s.model, + s.grid.parent, s.glue, _cell_lface_to_owner_nref, s.sign_flip) @@ -535,25 +667,28 @@ function get_cell_owner_normal_vector(s::SkeletonTriangulation) end function _cell_lface_to_owner_nref(args...) - model,glue,sign_flip = args - cell_lface_to_nref=_cell_lface_to_nref(model,glue) + model,cell_grid,glue,sign_flip = args + cell_lface_to_nref=_cell_lface_to_nref(model,cell_grid,glue) SkeletonOwnerNref(cell_lface_to_nref,sign_flip) end -function _get_cell_normal_vector(model,glue,cell_lface_to_nref::Function,sign_flip=nothing) - cell_grid = get_grid(model) +function _get_cell_normal_vector(model, + cell_grid, + glue, + cell_lface_to_nref::Function, + sign_flip=nothing) - cell_lface_to_nref = cell_lface_to_nref(model,glue,sign_flip) + cell_lface_to_nref = cell_lface_to_nref(model,cell_grid,glue,sign_flip) cell_lface_s_nref = lazy_map(Gridap.Fields.constant_field,cell_lface_to_nref) # Inverse of the Jacobian transpose cell_q_x = get_cell_map(cell_grid) cell_q_Jt = lazy_map(∇,cell_q_x) cell_q_invJt = lazy_map(Operation(Gridap.Fields.pinvJt),cell_q_Jt) - cell_lface_q_invJt = _transform_cell_to_cell_lface_array(glue, cell_q_invJt) + cell_lface_q_invJt = _transform_cell_to_cell_lface_array(glue, cell_grid, cell_q_invJt) # Change of domain - cell_lface_s_q = _setup_tcell_lface_mface_map(num_cell_dims(model)-1,model,glue) + cell_lface_s_q = _setup_tcell_lface_mface_map(num_cell_dims(model)-1,model,cell_grid,glue) cell_lface_s_invJt = lazy_map(∘,cell_lface_q_invJt,cell_lface_s_q) #face_s_n = @@ -563,16 +698,17 @@ function _get_cell_normal_vector(model,glue,cell_lface_to_nref::Function,sign_fl #Fields.MemoArray(face_s_n) end -function _setup_tcell_lface_mface_map(d,model,glue) - ctype_to_lface_to_pindex_to_qcoords=Gridap.Geometry._compute_face_to_q_vertex_coords_body(d,model,glue) - cell_lface_to_q_vertex_coords = SkeletonCompressedVector( - ctype_to_lface_to_pindex_to_qcoords.ctype_lface_pindex_to_value, - glue) +function _setup_tcell_lface_mface_map(d,model,cell_grid,glue) + ctype_to_lface_to_pindex_to_qcoords= + Gridap.Geometry._compute_face_to_q_vertex_coords_body(d,model,glue) + cell_lface_to_q_vertex_coords = + SkeletonCompressedVector(ctype_to_lface_to_pindex_to_qcoords.ctype_lface_pindex_to_value, + cell_grid, + glue) f(p) = Gridap.ReferenceFEs.get_shapefuns( Gridap.ReferenceFEs.LagrangianRefFE(Float64,Gridap.ReferenceFEs.get_polytope(p),1)) ################ TO-IMPROVE - cell_grid = get_grid(model) D = num_cell_dims(model) ctype_reffe = get_reffes(cell_grid) Gridap.Helpers.@notimplementedif length(ctype_reffe) != 1 @@ -584,13 +720,14 @@ function _setup_tcell_lface_mface_map(d,model,glue) ftype_to_shapefuns = map( f, ftrian_reffes) face_to_shapefuns = expand_cell_data(ftype_to_shapefuns,glue.face_to_ftype) - cell_to_lface_to_shapefuns = transform_face_to_cell_lface_array(glue,face_to_shapefuns) + cell_to_lface_to_shapefuns = transform_face_to_cell_lface_array(glue,cell_grid,face_to_shapefuns) lazy_map(Gridap.Fields.linear_combination, cell_lface_to_q_vertex_coords, cell_to_lface_to_shapefuns) end function transform_face_to_cell_lface_array(glue, + cell_grid, face_array::Gridap.Arrays.CompressedArray, f::Function=identity) T=typeof(f(face_array.values[1])) @@ -607,7 +744,7 @@ function transform_face_to_cell_lface_array(glue, end ctype_to_vector_block[ctype]=Gridap.Fields.ArrayBlock(v,t) end - Gridap.Arrays.CompressedArray(ctype_to_vector_block,glue.cell_to_ctype) + Gridap.Arrays.CompressedArray(ctype_to_vector_block,get_cell_type(cell_grid)) end function Gridap.ReferenceFEs.expand_cell_data( diff --git a/src/SkeletonArrays.jl b/src/SkeletonArrays.jl index bafbcf1..3366feb 100644 --- a/src/SkeletonArrays.jl +++ b/src/SkeletonArrays.jl @@ -1,9 +1,12 @@ -struct SkeletonCompressedVector{T,G<:Gridap.Geometry.FaceToCellGlue} <: AbstractVector{Gridap.Fields.VectorBlock{T}} +struct SkeletonCompressedVector{T, + R, + G<:Gridap.Geometry.FaceToCellGlue} <: AbstractVector{Gridap.Fields.VectorBlock{T}} ctype_lface_pindex_to_value::Vector{Vector{Vector{T}}} + cell_grid::R glue::G end -function _compressed_vector_from_glue(::Type{T}, glue) where T +function _compressed_vector_from_glue(::Type{T}, glue, cell_grid) where T ctype_to_vector_block= Vector{Gridap.Fields.VectorBlock{T}}(undef,length(glue.ctype_to_lface_to_ftype)) for ctype=1:length(glue.ctype_to_lface_to_ftype) @@ -13,11 +16,11 @@ function _compressed_vector_from_glue(::Type{T}, glue) where T t.=true ctype_to_vector_block[ctype]=Gridap.Fields.ArrayBlock(v,t) end - Gridap.Arrays.CompressedArray(ctype_to_vector_block, glue.cell_to_ctype) + Gridap.Arrays.CompressedArray(ctype_to_vector_block, get_cell_type(cell_grid)) end function Gridap.Arrays.array_cache(a::SkeletonCompressedVector{T}) where {T} - _compressed_vector_from_glue(T,a.glue) + _compressed_vector_from_glue(T,a.glue,a.cell_grid) end function Base.getindex(a::SkeletonCompressedVector,cell::Integer) @@ -27,7 +30,7 @@ end function Gridap.Arrays.getindex!(cache,a::SkeletonCompressedVector,cell::Integer) vb=cache[cell] - ctype=a.glue.cell_to_ctype[cell] + ctype=get_cell_type(a.cell_grid)[cell] for lface=1:length(vb) p = a.glue.cell_to_lface_to_pindex.ptrs[cell]-1 pindex = a.glue.cell_to_lface_to_pindex.data[p+lface] @@ -36,13 +39,13 @@ function Gridap.Arrays.getindex!(cache,a::SkeletonCompressedVector,cell::Integer vb end -Base.size(a::SkeletonCompressedVector) = (length(a.glue.cell_to_ctype),) +Base.size(a::SkeletonCompressedVector) = (num_cells(a.cell_grid),) Base.IndexStyle(::Type{<:SkeletonCompressedVector}) = IndexLinear() function Gridap.Arrays.lazy_map(k::Gridap.Fields.LinearCombinationMap, ::Type{T},b::SkeletonCompressedVector,c::Fill) where T - d = Gridap.Arrays.CompressedArray([c.value,],Fill(1,length(c))) + d = Gridap.Arrays.CompressedArray([c.value,],Fill(1,num_cells(b.cell_grid))) lazy_map(k,T,b,d) end @@ -50,7 +53,7 @@ function Gridap.Arrays.lazy_map(k::Gridap.Fields.LinearCombinationMap, ::Type{T}, b::SkeletonCompressedVector, c::Gridap.Arrays.CompressedArray{<:Gridap.Fields.VectorBlock}) where T - if c.ptrs === b.glue.cell_to_ctype || c.ptrs == b.glue.cell_to_ctype + if c.ptrs === get_cell_type(b.cell_grid) || c.ptrs == get_cell_type(b.cell_grid) ET=eltype(T) ctype_lface_pindex_to_r = Vector{Vector{Vector{ET}}}(undef,length(b.ctype_lface_pindex_to_value)) for (ctype, lface_pindex_to_value) in enumerate(b.ctype_lface_pindex_to_value) @@ -67,16 +70,12 @@ function Gridap.Arrays.lazy_map(k::Gridap.Fields.LinearCombinationMap, end ctype_lface_pindex_to_r[ctype] = lface_pindex_to_r end - SkeletonCompressedVector(ctype_lface_pindex_to_r,b.glue) + SkeletonCompressedVector(ctype_lface_pindex_to_r,b.cell_grid,b.glue) else Gridap.Helpers.@notimplemented end end - - - - function Gridap.Arrays.lazy_map( k::typeof(Gridap.Arrays.evaluate), ::Type{T}, @@ -99,7 +98,7 @@ function Gridap.Arrays.lazy_map( end ctype_lface_pindex_to_r[ctype] = lface_pindex_to_r end - SkeletonCompressedVector(ctype_lface_pindex_to_r,b.glue) + SkeletonCompressedVector(ctype_lface_pindex_to_r,b.cell_grid,b.glue) end function Gridap.Arrays.lazy_map( @@ -125,7 +124,7 @@ function Gridap.Arrays.lazy_map( end ctype_lface_pindex_to_r[ctype] = lface_pindex_to_r end - SkeletonCompressedVector(ctype_lface_pindex_to_r,b.glue) + SkeletonCompressedVector(ctype_lface_pindex_to_r,b.cell_grid,b.glue) end function Gridap.Arrays.lazy_map( @@ -150,7 +149,7 @@ function Gridap.Arrays.lazy_map( end ctype_lface_pindex_to_r[ctype] = lface_pindex_to_r end - SkeletonCompressedVector(ctype_lface_pindex_to_r,b.glue) + SkeletonCompressedVector(ctype_lface_pindex_to_r,b.cell_grid,b.glue) end @@ -280,24 +279,26 @@ function Gridap.Arrays.lazy_map( end -struct SkeletonVectorFromCellVector{T,G,V} <: AbstractVector{Gridap.Fields.VectorBlock{T}} +struct SkeletonVectorFromCellVector{T,G,R,V} <: AbstractVector{Gridap.Fields.VectorBlock{T}} glue::G + cell_grid::R cell_vector::V - function SkeletonVectorFromCellVector(glue,cell_vector) + function SkeletonVectorFromCellVector(glue,cell_grid,cell_vector) G=typeof(glue) + R=typeof(cell_grid) V=typeof(cell_vector) T=eltype(V) - new{T,G,V}(glue,cell_vector) + new{T,G,R,V}(glue,cell_grid,cell_vector) end end -Base.size(a::SkeletonVectorFromCellVector) = (length(a.glue.cell_to_ctype),) +Base.size(a::SkeletonVectorFromCellVector) = (num_cells(a.cell_grid),) Base.IndexStyle(::Type{<:SkeletonVectorFromCellVector}) = IndexLinear() function Gridap.Arrays.array_cache(a::SkeletonVectorFromCellVector{T}) where T cvc=array_cache(a.cell_vector) - vbc=_compressed_vector_from_glue(T,a.glue) + vbc=_compressed_vector_from_glue(T,a.glue,a.cell_grid) cvc,vbc end diff --git a/test/Distributed/DarcyHDGTests.jl b/test/Distributed/DarcyHDGTests.jl index c4edd1c..afe72c5 100644 --- a/test/Distributed/DarcyHDGTests.jl +++ b/test/Distributed/DarcyHDGTests.jl @@ -11,7 +11,7 @@ using GridapHybrid function main(parts) partition = (0,1,0,1) - cells = (2,2) + cells = (4,4) model = CartesianDiscreteModel(parts,partition,cells) order=1 solve_darcy_lhdg(model,order) @@ -74,11 +74,18 @@ function solve_darcy_lhdg(model,order) yh = get_fe_basis(Y) xh = get_trial_fe_basis(X) - (uh,ph,lh) = xh - (vh,qh,mh) = yh + # (uh,ph,lh) = xh + # (vh,qh,mh) = yh - ∫( vh⋅uh - (∇⋅vh)*ph - ∇(qh)⋅uh )dΩ - ∫((vh⋅n)*lh)d∂K + # ∫( vh⋅uh - (∇⋅vh)*ph - ∇(qh)⋅uh )dΩ + # (vh⋅n) + # (vh⋅n)*lh + # ∫((vh⋅n)*lh)d∂K + # ∫(qh*(uh⋅n))d∂K + # ∫(τ*qh*ph*(n⋅nₒ))d∂K + # ∫(mh*(uh⋅n))d∂K + # ∫(τ*mh*ph*(n⋅nₒ))d∂K + # ∫(τ*mh*lh*(n⋅nₒ))d∂K a((uh,ph,lh),(vh,qh,mh)) = ∫( vh⋅uh - (∇⋅vh)*ph - ∇(qh)⋅uh )dΩ + ∫((vh⋅n)*lh)d∂K + From 24f663728bd0f34410bb95dce4c0ea5488e7e0d5 Mon Sep 17 00:00:00 2001 From: amartin Date: Wed, 30 Mar 2022 17:27:11 +1100 Subject: [PATCH 04/11] Trying to fix failing tests --- src/GridapTmpModifications.jl | 7 +++++-- src/Skeleton.jl | 4 ++-- src/SkeletonArrays.jl | 18 ++++++++++-------- 3 files changed, 17 insertions(+), 12 deletions(-) diff --git a/src/GridapTmpModifications.jl b/src/GridapTmpModifications.jl index 837231a..8b2a3c8 100644 --- a/src/GridapTmpModifications.jl +++ b/src/GridapTmpModifications.jl @@ -302,11 +302,12 @@ function Gridap.Arrays.evaluate!(cache, end function _generate_cell_lface_dofs_from_cell_dofs(glue, + cell_grid, cell_wise_facets, cell_values_field, facets_dofs_ids) facet_sizes=lazy_map(x->length(x),facets_dofs_ids) - cell_wise_facet_sizes=SkeletonVectorFromFacetVector(glue,cell_wise_facets,facet_sizes) + cell_wise_facet_sizes=SkeletonVectorFromFacetVector(glue,cell_grid,cell_wise_facets,facet_sizes) m=SkeletonVectorFromNonBlockedSkeletonVector(cell_wise_facet_sizes) lazy_map(m,cell_values_field,collect(1:length(cell_values_field))) end @@ -335,13 +336,15 @@ function Gridap.FESpaces._change_argument( cell_lface_dof_values = _generate_cell_lface_dofs_from_cell_dofs( trian.glue, + trian.grid.parent, cell_wise_facets, cell_values_field, get_cell_dof_ids(Ui)) Ui_basis = get_fe_basis(Ui) - Ui_basis_data = get_data(Ui_basis) + Ui_basis_data = Gridap.CellData.get_data(Ui_basis) Ui_basis_cell_lface_data = SkeletonVectorFromFacetVector( trian.glue, + trian.grid.parent, cell_wise_facets, Ui_basis_data) cell_field = lazy_map(linear_combination, cell_lface_dof_values, Ui_basis_cell_lface_data) diff --git a/src/Skeleton.jl b/src/Skeleton.jl index 69deb01..db6066c 100644 --- a/src/Skeleton.jl +++ b/src/Skeleton.jl @@ -494,7 +494,7 @@ function _restrict_to_skeleton_facet_field(model, Gridap.Helpers.@check isa(get_triangulation(facet_fe_function),Triangulation{D-1,D}) facet_field_array=Gridap.CellData.get_data(facet_fe_function) cell_wise_facets_ids=_get_cell_wise_facets(model) - SkeletonVectorFromFacetVector(glue,cell_wise_facets_ids,facet_field_array) + SkeletonVectorFromFacetVector(glue,cell_grid,cell_wise_facets_ids,facet_field_array) end function _restrict_to_skeleton_facet_field(model, @@ -617,7 +617,7 @@ end function CellData.change_domain_phys_phys( a::CellField,ttrian::SkeletonTriangulation,sglue::FaceToFaceGlue,tglue::SkeletonGlue) - sface_to_field = get_data(a) + sface_to_field = Gridap.CellData.get_data(a) mface_to_sface = sglue.mface_to_tface tcell_lface_mface = tglue.tcell_lface_mface mface_to_field = extend(sface_to_field,mface_to_sface) diff --git a/src/SkeletonArrays.jl b/src/SkeletonArrays.jl index 3366feb..bc5bf8d 100644 --- a/src/SkeletonArrays.jl +++ b/src/SkeletonArrays.jl @@ -154,28 +154,30 @@ end -struct SkeletonVectorFromFacetVector{T,G,C,V} <: AbstractVector{Gridap.Fields.VectorBlock{T}} +struct SkeletonVectorFromFacetVector{T,G,F,C,V} <: AbstractVector{Gridap.Fields.VectorBlock{T}} glue::G + cell_grid::F cell_wise_facets_ids::C facet_vector::V - function SkeletonVectorFromFacetVector(glue,cell_wise_facets_ids,facet_vector) + function SkeletonVectorFromFacetVector(glue,cell_grid,cell_wise_facets_ids,facet_vector) G=typeof(glue) + F=typeof(cell_grid) C=typeof(cell_wise_facets_ids) V=typeof(facet_vector) T=eltype(V) - new{T,G,C,V}(glue,cell_wise_facets_ids,facet_vector) + new{T,G,F,C,V}(glue,cell_grid,cell_wise_facets_ids,facet_vector) end end -Base.size(a::SkeletonVectorFromFacetVector) = (length(a.glue.cell_to_ctype),) +Base.size(a::SkeletonVectorFromFacetVector) = (length(get_cell_type(a.cell_grid)),) Base.IndexStyle(::Type{<:SkeletonVectorFromFacetVector}) = IndexLinear() function Gridap.Arrays.array_cache(a::SkeletonVectorFromFacetVector{T}) where T fvc=array_cache(a.facet_vector) cwfc=array_cache(a.cell_wise_facets_ids) - vbc=_compressed_vector_from_glue(T,a.glue) - fvc=_compressed_vector_from_glue(typeof(fvc),a.glue) + vbc=_compressed_vector_from_glue(T,a.glue,a.cell_grid) + fvc=_compressed_vector_from_glue(typeof(fvc),a.glue,a.cell_grid) for ctype=1:length(a.glue.ctype_to_lface_to_ftype) num_facets=length(a.glue.ctype_to_lface_to_ftype[ctype]) for lface=1:num_facets @@ -239,7 +241,7 @@ function Gridap.Arrays.lazy_map( af=_cell_lfacet_vector_to_facet_vector(b.glue,a) bf=b.facet_vector bfx=lazy_map(evaluate,bf,af) - SkeletonVectorFromFacetVector(b.glue,b.cell_wise_facets_ids,bfx) + SkeletonVectorFromFacetVector(b.glue,b.cell_grid,b.cell_wise_facets_ids,bfx) end function _cell_lfacet_vector_to_facet_vector( @@ -275,7 +277,7 @@ function Gridap.Arrays.lazy_map( ::typeof(∇), b::SkeletonVectorFromFacetVector) ∇bf=lazy_map(∇,b.cell_vector) - SkeletonVectorFromFacetVector(b.glue,b.cell_wise_facets_ids,∇bf) + SkeletonVectorFromFacetVector(b.glue,b.cell_grid,b.cell_wise_facets_ids,∇bf) end From 83c6dcec8b0670fa8ea4a9bfbf998086b93cc580 Mon Sep 17 00:00:00 2001 From: amartin Date: Wed, 30 Mar 2022 21:43:58 +1100 Subject: [PATCH 05/11] Adding MPI package --- Project.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/Project.toml b/Project.toml index 91d5cef..5f8870b 100644 --- a/Project.toml +++ b/Project.toml @@ -10,6 +10,7 @@ FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" Gridap = "56d4f2e9-7ea1-5844-9cf6-b9c51ca7ce8e" GridapDistributed = "f9701e48-63b3-45aa-9a63-9bc6c271f355" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195" PartitionedArrays = "5a9dfac6-5c52-46f7-8278-5e2210713be9" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" ProfileView = "c46f51b8-102a-5cf2-8d2c-8597cb0e0da7" From 50dd4b5d60c9448637a2cdcd01ce57d9dcb3a8fa Mon Sep 17 00:00:00 2001 From: amartin Date: Thu, 31 Mar 2022 02:23:21 +1100 Subject: [PATCH 06/11] Debugged distributed HDG tests Add HDG tests to Github actions --- src/Distributed/HybridAffineFEOperators.jl | 3 ++- src/Distributed/Skeleton.jl | 19 +++++++++++++++---- src/HybridAffineFEOperators.jl | 10 ++++++++-- src/Skeleton.jl | 9 ++++----- test/Distributed/DarcyHDGTests.jl | 5 +---- test/Distributed/sequential/DarcyHDGTests.jl | 1 + test/runtests.jl | 1 + 7 files changed, 32 insertions(+), 16 deletions(-) diff --git a/src/Distributed/HybridAffineFEOperators.jl b/src/Distributed/HybridAffineFEOperators.jl index dfa3a14..4a7282f 100644 --- a/src/Distributed/HybridAffineFEOperators.jl +++ b/src/Distributed/HybridAffineFEOperators.jl @@ -46,7 +46,8 @@ function Gridap.FESpaces._attach_dirichlet( mat :: GridapDistributed.DistributedDomainContribution, uhd) dmv,dm=map_parts(matvec.contribs,mat.contribs,uhd.fields) do matvec, mat, uhd - Gridap.FESpaces._attach_dirichlet(matvec,mat, uhd) + m,v=Gridap.FESpaces._attach_dirichlet(matvec,mat, uhd) + m,v end GridapDistributed.DistributedDomainContribution(dmv), GridapDistributed.DistributedDomainContribution(dm) diff --git a/src/Distributed/Skeleton.jl b/src/Distributed/Skeleton.jl index 6f7ab9d..42a6723 100644 --- a/src/Distributed/Skeleton.jl +++ b/src/Distributed/Skeleton.jl @@ -3,21 +3,32 @@ function SkeletonTriangulation(model::GridapDistributed.DistributedDiscreteModel SkeletonTriangulation(no_ghost,model::GridapDistributed.DistributedDiscreteModel) end + +function _sign_flips(model::GridapDistributed.DistributedDiscreteModel) + cell_reffes = map_parts(model.models) do m + basis,reffe_args,reffe_kwargs = ReferenceFE(raviart_thomas,Float64,0) + reffe = ReferenceFE(m,basis,reffe_args...;reffe_kwargs...) + end + GridapDistributed._generate_sign_flips(model,cell_reffes) +end + function SkeletonTriangulation(portion::GridapDistributed.WithGhost, model::GridapDistributed.DistributedDiscreteModel) - dtrians=map_parts(model.models) do model - Skeleton(model) + dtrians=map_parts(model.models,_sign_flips(model)) do model, sign_flip + Skeleton(model,sign_flip) end GridapDistributed.DistributedTriangulation(dtrians,model) end function SkeletonTriangulation(portion::GridapDistributed.NoGhost, model::GridapDistributed.DistributedDiscreteModel) - dtrians=map_parts(model.models, model.gids.partition) do model, partition + dtrians=map_parts(model.models, + _sign_flips(model), + model.gids.partition) do model, sign_flip, partition cell_to_parent_cell= findall([partition.lid_to_part[cell]==partition.part for cell=1:length(partition.lid_to_part)]) - Skeleton(model,cell_to_parent_cell) + Skeleton(model,cell_to_parent_cell,sign_flip) end GridapDistributed.DistributedTriangulation(dtrians,model) end diff --git a/src/HybridAffineFEOperators.jl b/src/HybridAffineFEOperators.jl index a779d65..1143d81 100644 --- a/src/HybridAffineFEOperators.jl +++ b/src/HybridAffineFEOperators.jl @@ -27,6 +27,8 @@ function HybridAffineFEOperator( # Pair LHS and RHS terms associated to SkeletonTriangulation matvec, mat, vec = Gridap.FESpaces._pair_contribution_when_possible(obiform, oliform) + + # Add StaticCondensationMap to matvec terms matvec = _add_static_condensation(matvec, bulk_fields, skeleton_fields) @@ -127,7 +129,6 @@ function _compute_hybridizable_from_skeleton_free_dof_values(skeleton_fe_functio _find_faces_touched_by_cells(cell_to_parent_cell, cell_wise_facets, cells_around_facets) - #cells_around_facets=lazy_map(Reindex(cells_around_facets),ifacet_to_facet) end nfields = length(bulk_fields) + length(skeleton_fields) @@ -220,7 +221,7 @@ function _generate_glue_among_facet_and_cell_wise_dofs_arrays( @check length(ifacet_to_facet) == length(facet_dof_ids) facet_to_ifacet=Dict([facet=>ifacet for (ifacet,facet) in enumerate(ifacet_to_facet)]) - + c1 = array_cache(cells_around_facets) c2 = array_cache(cell_wise_facets) c3 = array_cache(facet_dof_ids) @@ -471,7 +472,12 @@ end function Gridap.FESpaces.get_cell_fe_data( fun::typeof(Gridap.FESpaces.get_cell_is_dirichlet),sface_to_data,sglue::FaceToFaceGlue,tglue::SkeletonGlue) model = tglue.trian.model + grid = tglue.trian.grid.parent cell_wise_facets = _get_cell_wise_facets(model) + if (isa(grid,Gridap.Geometry.GridView)) + cell_to_parent_cell = grid.cell_to_parent_cell + cell_wise_facets=lazy_map(Reindex(cell_wise_facets),cell_to_parent_cell) + end fdofscb = restrict_facet_dof_ids_to_cell_boundary(cell_wise_facets, sface_to_data) _generate_cell_is_dirichlet(fdofscb) end diff --git a/src/Skeleton.jl b/src/Skeleton.jl index db6066c..aec093a 100644 --- a/src/Skeleton.jl +++ b/src/Skeleton.jl @@ -127,7 +127,8 @@ function _get_sign_flip(model) Gridap.FESpaces.get_sign_flip(model,cell_reffe) end -function SkeletonTriangulation(model::DiscreteModel) +function SkeletonTriangulation(model::DiscreteModel, + sign_flip=_get_sign_flip(model)) A = typeof(model) D = num_cell_dims(model) mgrid = get_grid(model) @@ -140,8 +141,6 @@ function SkeletonTriangulation(model::DiscreteModel) sgrid = SkeletonGrid(mgrid) B = typeof(sgrid) - sign_flip=_get_sign_flip(model) - C = typeof(sign_flip) SkeletonTriangulation{D-1,D,A,B,C}(model,sgrid,sign_flip,glue) end @@ -194,7 +193,8 @@ function _find_faces_touched_by_cells(cell_to_parent_cell, end function SkeletonTriangulation(model::DiscreteModel{D}, - cell_to_parent_cell::AbstractVector{<:Integer}) where D + cell_to_parent_cell::AbstractVector{<:Integer}, + sign_flip=_get_sign_flip(model)) where D topo = get_grid_topology(model) cells_to_facets = Table(get_faces(topo,D,D-1)) facets_to_cells = Table(get_faces(topo,D-1,D)) @@ -214,7 +214,6 @@ function SkeletonTriangulation(model::DiscreteModel{D}, cell_grid = view(cell_grid,cell_to_parent_cell) sgrid = SkeletonGrid(cell_grid) B = typeof(sgrid) - sign_flip=_get_sign_flip(model) sign_flip=lazy_map(Reindex(sign_flip),cell_to_parent_cell) C = typeof(sign_flip) SkeletonTriangulation{D-1,D,A,B,C}(model,sgrid,sign_flip,glue) diff --git a/test/Distributed/DarcyHDGTests.jl b/test/Distributed/DarcyHDGTests.jl index afe72c5..8cdcc22 100644 --- a/test/Distributed/DarcyHDGTests.jl +++ b/test/Distributed/DarcyHDGTests.jl @@ -65,15 +65,12 @@ function solve_darcy_lhdg(model,order) # FE formulation params τ = 1.0 # HDG stab parameter - degree = 2*(order+1) + degree = 2*order+1 dΩ = Measure(Ω,degree) n = get_cell_normal_vector(∂K) nₒ = get_cell_owner_normal_vector(∂K) d∂K = Measure(∂K,degree) - yh = get_fe_basis(Y) - xh = get_trial_fe_basis(X) - # (uh,ph,lh) = xh # (vh,qh,mh) = yh diff --git a/test/Distributed/sequential/DarcyHDGTests.jl b/test/Distributed/sequential/DarcyHDGTests.jl index d71342c..b57aa49 100644 --- a/test/Distributed/sequential/DarcyHDGTests.jl +++ b/test/Distributed/sequential/DarcyHDGTests.jl @@ -2,4 +2,5 @@ module DarcyHDGTestsSeq using PartitionedArrays include("../DarcyHDGTests.jl") prun(DarcyHDGTests.main,sequential,(1,1)) +prun(DarcyHDGTests.main,sequential,(2,2)) end # module diff --git a/test/runtests.jl b/test/runtests.jl index aa32229..0650572 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -9,4 +9,5 @@ module Tests @testset "DarcyHDGTests" begin include("DarcyHDGTests.jl") end @testset "LinearElasticityHDGTests" begin include("LinearElasticityHDGTests.jl") end @testset "MultiFieldLagrangeMultipliersTests" begin include("MultiFieldLagrangeMultipliersTests.jl") end + @testset "Distributed/DarcyHDGTests" begin include("Distributed/sequential/DarcyHDGTests.jl") end end # module From 8f58ee099461b6450d1969d718b92b0bb3509878 Mon Sep 17 00:00:00 2001 From: amartin Date: Thu, 31 Mar 2022 03:28:11 +1100 Subject: [PATCH 07/11] missing solver in call to solve --- src/HybridAffineFEOperators.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/HybridAffineFEOperators.jl b/src/HybridAffineFEOperators.jl index 1143d81..64ba799 100644 --- a/src/HybridAffineFEOperators.jl +++ b/src/HybridAffineFEOperators.jl @@ -73,7 +73,7 @@ end function Gridap.FESpaces.solve!(uh, solver::LinearFESolver, op::HybridAffineFEOperator, cache) # Solve linear system defined on the skeleton - lh = solve(op.skeleton_op) + lh = solve(solver,op.skeleton_op) # Invoke weak form of the hybridizable system u = get_trial_fe_basis(op.trial) From f2d6f711f4484938668cabb19adc5ec7f0f594c7 Mon Sep 17 00:00:00 2001 From: amartin Date: Thu, 31 Mar 2022 15:54:36 +1100 Subject: [PATCH 08/11] Added 3D tests distributed --- test/Distributed/DarcyHDGTests.jl | 48 ++++++++++++++++---- test/Distributed/sequential/DarcyHDGTests.jl | 4 +- 2 files changed, 42 insertions(+), 10 deletions(-) diff --git a/test/Distributed/DarcyHDGTests.jl b/test/Distributed/DarcyHDGTests.jl index 8cdcc22..8581eba 100644 --- a/test/Distributed/DarcyHDGTests.jl +++ b/test/Distributed/DarcyHDGTests.jl @@ -10,21 +10,21 @@ using Gridap.Geometry using GridapHybrid function main(parts) - partition = (0,1,0,1) - cells = (4,4) + partition = (0,1,0,1,0,1) + cells = (2,2,2) model = CartesianDiscreteModel(parts,partition,cells) order=1 solve_darcy_lhdg(model,order) end -u(x) = VectorValue(1+x[1],1+x[2]) -Gridap.divergence(::typeof(u)) = (x) -> 2 +u2(x) = VectorValue(1+x[1],1+x[2]) +Gridap.divergence(::typeof(u2)) = (x) -> 2 p(x) = -3.14 -∇p(x) = VectorValue(0,0) +∇p2(x) = VectorValue(0,0,0) Gridap.∇(::typeof(p)) = ∇p -f(x) = u(x) + ∇p(x) +f2(x) = u2(x) + ∇p2(x) # Normal component of u(x) on Neumann boundary -function g(x) +function g2(x) tol=1.0e-14 if (abs(x[2]) 3 +∇p3(x) = VectorValue(0,0,0) +f3(x) = u3(x) + ∇p3(x) +function g3(x) # Normal component of u(x) on Neumann boundary + @assert false +end + +function ufg(D::Int) + if (D==2) + u2,f2,g2 + elseif (D==3) + u3,f3,g3 + end +end + +function dirichlet_tags(D::Int) + if (D==2) + collect(5:8) + elseif (D==3) + collect(21:26) + end +end + + + function solve_darcy_lhdg(model,order) # Geometry D = num_cell_dims(model) + + dtags=dirichlet_tags(D) + u,f,_ = ufg(D) + Ω = Triangulation(ReferenceFE{D},model) Γ = Triangulation(ReferenceFE{D-1},model) ∂K = GridapHybrid.Skeleton(model) @@ -53,7 +85,7 @@ function solve_darcy_lhdg(model,order) M = TestFESpace(Γ, reffeₗ; conformity=:L2, - dirichlet_tags=collect(5:8)) + dirichlet_tags=dtags) Y = MultiFieldFESpace([V,Q,M]) # Define trial FEspaces diff --git a/test/Distributed/sequential/DarcyHDGTests.jl b/test/Distributed/sequential/DarcyHDGTests.jl index b57aa49..d58bf73 100644 --- a/test/Distributed/sequential/DarcyHDGTests.jl +++ b/test/Distributed/sequential/DarcyHDGTests.jl @@ -1,6 +1,6 @@ module DarcyHDGTestsSeq using PartitionedArrays include("../DarcyHDGTests.jl") -prun(DarcyHDGTests.main,sequential,(1,1)) -prun(DarcyHDGTests.main,sequential,(2,2)) +prun(DarcyHDGTests.main,sequential,(1,1,1)) +prun(DarcyHDGTests.main,sequential,(2,2,2)) end # module From 72809a162b801e5045858f198f8456f235060407 Mon Sep 17 00:00:00 2001 From: amartin Date: Thu, 7 Apr 2022 11:23:45 +1000 Subject: [PATCH 09/11] Addint distributed tests --- test/Distributed/mpi/runtests.jl | 31 ++++++++++++++++++++++++ test/Distributed/mpi/runtests_body.jl | 35 +++++++++++++++++++++++++++ 2 files changed, 66 insertions(+) create mode 100644 test/Distributed/mpi/runtests.jl create mode 100644 test/Distributed/mpi/runtests_body.jl diff --git a/test/Distributed/mpi/runtests.jl b/test/Distributed/mpi/runtests.jl new file mode 100644 index 0000000..0ad0018 --- /dev/null +++ b/test/Distributed/mpi/runtests.jl @@ -0,0 +1,31 @@ +module MPITests + +using MPI +using Test + +#Sysimage +sysimage=nothing +if length(ARGS)==1 + @assert isfile(ARGS[1]) "$(ARGS[1]) must be a valid Julia sysimage file" + sysimage=ARGS[1] +end + +mpidir = @__DIR__ +testdir = joinpath(mpidir,"..") +repodir = joinpath(mpidir,"../../..") +function run_driver(procs,file,sysimage) + mpiexec() do cmd + if sysimage!=nothing + extra_args="-J$(sysimage)" + run(`$cmd -n $procs $(Base.julia_cmd()) $(extra_args) --project=$repodir $(joinpath(mpidir,file))`) + else + run(`$cmd -n $procs $(Base.julia_cmd()) --project=$repodir $(joinpath(mpidir,file))`) + end + @test true + end +end + +run_driver(1,"runtests_body.jl",sysimage) # Check that the degenerated case works +run_driver(4,"runtests_body.jl",sysimage) + +end # module diff --git a/test/Distributed/mpi/runtests_body.jl b/test/Distributed/mpi/runtests_body.jl new file mode 100644 index 0000000..1213f71 --- /dev/null +++ b/test/Distributed/mpi/runtests_body.jl @@ -0,0 +1,35 @@ +module NP4 +# All test running on 4 procs here + +using PartitionedArrays +const PArrays = PartitionedArrays +using MPI +using GridapPETSc + +include("../DarcyHDGTests.jl") + +if ! MPI.Initialized() + MPI.Init() +end + +function all_tests(parts) + display(parts) + t = PArrays.PTimer(parts,verbose=true) + PArrays.tic!(t) + options = "-ksp_type cg -pc_type gamg -ksp_monitor" + GridapPETSc.with(args=split(options)) do + DarcyHDGTests.main(parts) + end + PArrays.toc!(t,"DarcyHDGTests") + display(t) +end + +if MPI.Comm_size(MPI.COMM_WORLD) == 8 + prun(all_tests,mpi,(2,2,2)) +elseif MPI.Comm_size(MPI.COMM_WORLD) == 1 + prun(all_tests,mpi,(1,1,1)) +else + MPI.Abort(MPI.COMM_WORLD,0) +end + +end #module From 9b939bc6fb0bdd11523d49b9714b866340e8146b Mon Sep 17 00:00:00 2001 From: amartin Date: Wed, 8 Jun 2022 09:36:30 +1000 Subject: [PATCH 10/11] Adapted to the latest changes in GridapDistributed.jl --- Manifest.toml | 200 ++++++++++++++++++------------------ src/Distributed/Skeleton.jl | 3 +- 2 files changed, 100 insertions(+), 103 deletions(-) diff --git a/Manifest.toml b/Manifest.toml index 845226a..1554c26 100644 --- a/Manifest.toml +++ b/Manifest.toml @@ -23,11 +23,11 @@ version = "3.3.3" [[deps.ArgTools]] uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" -[[deps.ArrayInterface]] -deps = ["Compat", "IfElse", "LinearAlgebra", "Requires", "SparseArrays", "Static"] -git-tree-sha1 = "6e8fada11bb015ecf9263f64b156f98b546918c7" -uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" -version = "5.0.5" +[[deps.ArrayInterfaceCore]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "d0f59ebfe8d3ea2799fb3fb88742d69978e5843e" +uuid = "30b0a656-2188-435a-8636-2ec0e6a096e2" +version = "0.1.10" [[deps.ArrayLayouts]] deps = ["FillArrays", "LinearAlgebra", "SparseArrays"] @@ -72,15 +72,15 @@ version = "1.16.1+1" [[deps.ChainRulesCore]] deps = ["Compat", "LinearAlgebra", "SparseArrays"] -git-tree-sha1 = "9950387274246d08af38f6eef8cb5480862a435f" +git-tree-sha1 = "9489214b993cd42d17f44c36e359bf6a7c919abf" uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" -version = "1.14.0" +version = "1.15.0" [[deps.ChangesOfVariables]] deps = ["ChainRulesCore", "LinearAlgebra", "Test"] -git-tree-sha1 = "bf98fa45a0a4cee295de98d4c1462be26345b9a1" +git-tree-sha1 = "1e315e3f4b0b7ce40feded39c73049692126cf53" uuid = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" -version = "0.1.2" +version = "0.1.3" [[deps.CodecZlib]] deps = ["TranscodingStreams", "Zlib_jll"] @@ -89,16 +89,22 @@ uuid = "944b1d66-785c-5afd-91f1-9de20f533193" version = "0.7.0" [[deps.ColorSchemes]] -deps = ["ColorTypes", "Colors", "FixedPointNumbers", "Random"] -git-tree-sha1 = "12fc73e5e0af68ad3137b886e3f7c1eacfca2640" +deps = ["ColorTypes", "ColorVectorSpace", "Colors", "FixedPointNumbers", "Random"] +git-tree-sha1 = "7297381ccb5df764549818d9a7d57e45f1057d30" uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4" -version = "3.17.1" +version = "3.18.0" [[deps.ColorTypes]] deps = ["FixedPointNumbers", "Random"] -git-tree-sha1 = "024fe24d83e4a5bf5fc80501a314ce0d1aa35597" +git-tree-sha1 = "0f4e115f6f34bbe43c19751c90a38b2f380637b9" uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" -version = "0.11.0" +version = "0.11.3" + +[[deps.ColorVectorSpace]] +deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "SpecialFunctions", "Statistics", "TensorCore"] +git-tree-sha1 = "d08c20eef1f2cbc6e60fd3612ac4340b89fea322" +uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4" +version = "0.9.9" [[deps.Colors]] deps = ["ColorTypes", "FixedPointNumbers", "Reexport"] @@ -119,9 +125,9 @@ version = "0.3.0" [[deps.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 = "96b0bc6c52df76506efc8a441c6cf1adcb1babc4" +git-tree-sha1 = "9be8be1d8a6f44b96482c8af52238ea7987da3e3" uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" -version = "3.42.0" +version = "3.45.0" [[deps.CompilerSupportLibraries_jll]] deps = ["Artifacts", "Libdl"] @@ -139,21 +145,21 @@ uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" version = "4.1.1" [[deps.DataAPI]] -git-tree-sha1 = "cc70b17275652eb47bc9e5f81635981f13cea5c8" +git-tree-sha1 = "fb5f5316dd3fd4c5e7c30a24d50643b73e37cd40" uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" -version = "1.9.0" +version = "1.10.0" [[deps.DataFrames]] deps = ["Compat", "DataAPI", "Future", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrettyTables", "Printf", "REPL", "Reexport", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"] -git-tree-sha1 = "ae02104e835f219b8930c7664b8012c93475c340" +git-tree-sha1 = "daa21eb85147f72e41f6352a57fccea377e310a9" uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" -version = "1.3.2" +version = "1.3.4" [[deps.DataStructures]] deps = ["Compat", "InteractiveUtils", "OrderedCollections"] -git-tree-sha1 = "3daef5523dd2e769dad2365274f760ff5f282c7d" +git-tree-sha1 = "d1fff3a548102f48987a52a2e0d114fa97d730f0" uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" -version = "0.18.11" +version = "0.18.13" [[deps.DataValueInterfaces]] git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" @@ -182,9 +188,9 @@ version = "1.0.3" [[deps.DiffRules]] deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"] -git-tree-sha1 = "dd933c4ef7b4c270aacd4eb88fa64c147492acf0" +git-tree-sha1 = "28d605d9a0ac17118fe2c5e9ce0fbb76c3ceb120" uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" -version = "1.10.0" +version = "1.11.0" [[deps.Distances]] deps = ["LinearAlgebra", "SparseArrays", "Statistics", "StatsAPI"] @@ -218,16 +224,11 @@ git-tree-sha1 = "3f3a2501fa7236e9b911e0f7a588c657e822bb6d" uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5" version = "2.2.3+0" -[[deps.EllipsisNotation]] -git-tree-sha1 = "18ee049accec8763be17a933737c1dd0fdf8673a" -uuid = "da5c29d0-fa7d-589e-88eb-ea29b0a81949" -version = "1.0.0" - [[deps.Expat_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "ae13fcbc7ab8f16b0856729b050ef0c446aa3492" +git-tree-sha1 = "bad72f730e9e91c08d9427d5e8db95478a3c323d" uuid = "2e619515-83b5-522b-bb60-26c02a35a201" -version = "2.4.4+0" +version = "2.4.8+0" [[deps.FFMPEG]] deps = ["FFMPEG_jll"] @@ -249,9 +250,9 @@ version = "0.4.9" [[deps.FileIO]] deps = ["Pkg", "Requires", "UUIDs"] -git-tree-sha1 = "80ced645013a5dbdc52cf70329399c35ce007fae" +git-tree-sha1 = "9267e5f50b0e12fdfd5a2455534345c4cf2c7f7a" uuid = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" -version = "1.13.0" +version = "1.14.0" [[deps.FillArrays]] deps = ["LinearAlgebra", "Random", "SparseArrays", "Statistics"] @@ -260,10 +261,10 @@ uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" version = "0.12.8" [[deps.FiniteDiff]] -deps = ["ArrayInterface", "LinearAlgebra", "Requires", "SparseArrays", "StaticArrays"] -git-tree-sha1 = "56956d1e4c1221000b7781104c58c34019792951" +deps = ["ArrayInterfaceCore", "LinearAlgebra", "Requires", "SparseArrays", "StaticArrays"] +git-tree-sha1 = "a0700c21266b55bf62c22e75af5668aa7841b500" uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" -version = "2.11.0" +version = "2.12.1" [[deps.FixedPointNumbers]] deps = ["Statistics"] @@ -291,9 +292,9 @@ version = "0.4.2" [[deps.ForwardDiff]] deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions", "StaticArrays"] -git-tree-sha1 = "1bd6fc0c344fc0cbee1f42f8d2e7ec8253dda2d2" +git-tree-sha1 = "2f18915445b248731ec5db4e4a17e451020bf21e" uuid = "f6369f11-7733-5829-9624-2563aa707210" -version = "0.10.25" +version = "0.10.30" [[deps.FreeType2_jll]] deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"] @@ -319,15 +320,15 @@ version = "3.3.6+0" [[deps.GR]] deps = ["Base64", "DelimitedFiles", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Pkg", "Printf", "Random", "RelocatableFolders", "Serialization", "Sockets", "Test", "UUIDs"] -git-tree-sha1 = "9f836fb62492f4b0f0d3b06f55983f2704ed0883" +git-tree-sha1 = "c98aea696662d09e215ef7cda5296024a9646c75" uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71" -version = "0.64.0" +version = "0.64.4" [[deps.GR_jll]] deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Pkg", "Qt5Base_jll", "Zlib_jll", "libpng_jll"] -git-tree-sha1 = "a6c850d77ad5118ad3be4bd188919ce97fffac47" +git-tree-sha1 = "3a233eeeb2ca45842fe100e0413936834215abf5" uuid = "d2c73de3-f751-5644-a686-071e5b155ba9" -version = "0.64.0+0" +version = "0.64.4+0" [[deps.GTK3_jll]] deps = ["ATK_jll", "Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "FriBidi_jll", "Glib_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Libepoxy_jll", "Pango_jll", "Pkg", "Wayland_jll", "Xorg_libX11_jll", "Xorg_libXcomposite_jll", "Xorg_libXcursor_jll", "Xorg_libXdamage_jll", "Xorg_libXext_jll", "Xorg_libXfixes_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll", "Xorg_libXrender_jll", "at_spi2_atk_jll", "gdk_pixbuf_jll", "iso_codes_jll", "xkbcommon_jll"] @@ -355,9 +356,9 @@ version = "2.68.3+2" [[deps.Graphics]] deps = ["Colors", "LinearAlgebra", "NaNMath"] -git-tree-sha1 = "1c5a84319923bea76fa145d49e93aa4394c73fc2" +git-tree-sha1 = "d61890399bc535850c4bf08e4e0d3a7ad0f21cbd" uuid = "a2bd30eb-e257-5431-a919-1863eab51364" -version = "1.1.1" +version = "1.1.2" [[deps.Graphite2_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -375,11 +376,11 @@ version = "0.17.12" [[deps.GridapDistributed]] deps = ["FillArrays", "Gridap", "LinearAlgebra", "MPI", "PartitionedArrays", "SparseArrays", "SparseMatricesCSR", "WriteVTK"] -git-tree-sha1 = "3ff43a6b0a1347ff3a9e33d94b6d0c78ab9d7846" -repo-rev = "implement_support_spaces_on_lower_dim_trians" +git-tree-sha1 = "0b67924b214c9735db46071646e6ab1e1817eddd" +repo-rev = "master" repo-url = "https://github.com/gridap/GridapDistributed.jl" uuid = "f9701e48-63b3-45aa-9a63-9bc6c271f355" -version = "0.2.5" +version = "0.2.6" [[deps.Grisu]] git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2" @@ -394,9 +395,9 @@ version = "1.2.1" [[deps.GtkObservables]] deps = ["Cairo", "Colors", "Dates", "FixedPointNumbers", "Graphics", "Gtk", "IntervalSets", "LinearAlgebra", "Observables", "Reexport", "RoundingIntegers"] -git-tree-sha1 = "96dcca8d49566c6a0fddc98fb46f7b810de6ef63" +git-tree-sha1 = "cf87f031fee932b90023ea37207c7a1de8caee6f" uuid = "8710efd8-4ad6-11eb-33ea-2d5ceb25a41c" -version = "1.2.0" +version = "1.2.3" [[deps.HTTP]] deps = ["Base64", "Dates", "IniFile", "Logging", "MbedTLS", "NetworkOptions", "Sockets", "URIs"] @@ -410,11 +411,6 @@ git-tree-sha1 = "129acf094d168394e80ee1dc4bc06ec835e510a3" uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566" version = "2.8.1+1" -[[deps.IfElse]] -git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" -uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" -version = "0.1.1" - [[deps.IndirectArrays]] git-tree-sha1 = "012e604e1c7458645cb8b436f8fba789a51b257f" uuid = "9b13fd28-a010-5f03-acff-a1bbcff69959" @@ -430,16 +426,16 @@ deps = ["Markdown"] uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" [[deps.IntervalSets]] -deps = ["Dates", "EllipsisNotation", "Statistics"] -git-tree-sha1 = "bcf640979ee55b652f3b01650444eb7bbe3ea837" +deps = ["Dates", "Statistics"] +git-tree-sha1 = "ad841eddfb05f6d9be0bff1fa48dcae32f134a2d" uuid = "8197267c-284f-5f27-9208-e0e47529a953" -version = "0.5.4" +version = "0.6.2" [[deps.InverseFunctions]] deps = ["Test"] -git-tree-sha1 = "91b5dcf362c5add98049e6c29ee756910b03051d" +git-tree-sha1 = "c6cf981474e7094ce044168d329274d797843467" uuid = "3587e190-3f89-42d0-90ee-14403ec27112" -version = "0.1.3" +version = "0.1.6" [[deps.InvertedIndices]] git-tree-sha1 = "bee5f1ef5bf65df56bdd2e40447590b272a5471f" @@ -516,9 +512,9 @@ version = "1.3.0" [[deps.Latexify]] deps = ["Formatting", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "Printf", "Requires"] -git-tree-sha1 = "4f00cc36fede3c04b8acf9b2e2763decfdcecfa6" +git-tree-sha1 = "46a39b9c58749eefb5f2dc1178cb8fab5332b1ab" uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" -version = "0.15.13" +version = "0.15.15" [[deps.LazyArtifacts]] deps = ["Artifacts", "Pkg"] @@ -599,9 +595,9 @@ version = "2.52.4+0" [[deps.Libtiff_jll]] deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "Pkg", "Zlib_jll", "Zstd_jll"] -git-tree-sha1 = "c9551dd26e31ab17b86cbd00c2ede019c08758eb" +git-tree-sha1 = "3eb79b0ca5764d4799c06699573fd8f533259713" uuid = "89763e89-9b03-5906-acba-b20f662cd828" -version = "4.3.0+1" +version = "4.4.0+0" [[deps.Libuuid_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -627,9 +623,9 @@ uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" [[deps.LogExpFunctions]] deps = ["ChainRulesCore", "ChangesOfVariables", "DocStringExtensions", "InverseFunctions", "IrrationalConstants", "LinearAlgebra"] -git-tree-sha1 = "58f25e56b706f95125dcb796f39e1fb01d913a71" +git-tree-sha1 = "09e4b894ce6a976c354a69041a04748180d43637" uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" -version = "0.3.10" +version = "0.3.15" [[deps.Logging]] uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" @@ -642,9 +638,9 @@ version = "0.19.2" [[deps.MPICH_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "8eed51eb836c8f47781cdb493ffd5f56370c0496" +git-tree-sha1 = "9f781ffc4020c24ca05d83fa4eb4df0d34832b18" uuid = "7cb0a576-ebde-5e09-9194-50597f1243b4" -version = "4.0.1+0" +version = "4.0.2+1" [[deps.MacroTools]] deps = ["Markdown", "Random"] @@ -722,9 +718,9 @@ version = "0.4.10" uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" [[deps.Observables]] -git-tree-sha1 = "fe29afdef3d0c4a8286128d4e45cc50621b1e43d" +git-tree-sha1 = "dfd8d34871bc3ad08cd16026c1828e271d554db9" uuid = "510215fc-4207-5dde-b226-833fc4488ee2" -version = "0.4.0" +version = "0.5.1" [[deps.Ogg_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -742,9 +738,9 @@ uuid = "05823500-19ac-5b8b-9628-191a04bc5112" [[deps.OpenMPI_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg"] -git-tree-sha1 = "6340586e076b2abd41f5ba1a3b9c774ec6b30fde" +git-tree-sha1 = "19ec7d0311aa5fb5fe537dc6eeaec86942b64caf" uuid = "fe0851c0-eecd-5654-98d4-656369965a5c" -version = "4.1.2+0" +version = "4.1.3+0" [[deps.OpenSSL_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -789,9 +785,9 @@ version = "0.12.3" [[deps.Parsers]] deps = ["Dates"] -git-tree-sha1 = "85b5da0fa43588c75bb1ff986493443f821c70b7" +git-tree-sha1 = "1285416549ccfcdf0c50d4997a94331e88d68413" uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" -version = "2.2.3" +version = "2.3.1" [[deps.PartitionedArrays]] deps = ["Distances", "IterativeSolvers", "LinearAlgebra", "MPI", "Printf", "SparseArrays", "SparseMatricesCSR"] @@ -810,10 +806,10 @@ deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markd uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" [[deps.PlotThemes]] -deps = ["PlotUtils", "Requires", "Statistics"] -git-tree-sha1 = "a3a964ce9dc7898193536002a6dd892b1b5a6f1d" +deps = ["PlotUtils", "Statistics"] +git-tree-sha1 = "8162b2f8547bc23876edd0c5181b27702ae58dce" uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a" -version = "2.0.1" +version = "3.0.0" [[deps.PlotUtils]] deps = ["ColorSchemes", "Colors", "Dates", "Printf", "Random", "Reexport", "Statistics"] @@ -823,21 +819,21 @@ version = "1.2.0" [[deps.Plots]] deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "GeometryBasics", "JSON", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs", "UnicodeFun", "Unzip"] -git-tree-sha1 = "5f6e1309595e95db24342e56cd4dabd2159e0b79" +git-tree-sha1 = "9e42de869561d6bdf8602c57ec557d43538a92f0" uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" -version = "1.27.3" +version = "1.29.1" [[deps.PooledArrays]] deps = ["DataAPI", "Future"] -git-tree-sha1 = "28ef6c7ce353f0b35d0df0d5930e0d072c1f5b9b" +git-tree-sha1 = "a6062fe4063cdafe78f4a0a81cfffb89721b30e7" uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720" -version = "1.4.1" +version = "1.4.2" [[deps.Preferences]] deps = ["TOML"] -git-tree-sha1 = "d3538e7f8a790dc8903519090857ef8e1283eecd" +git-tree-sha1 = "47e5f437cc0e7ef2ce8406ce1e7e24d44915f88d" uuid = "21216c6a-2e73-6563-6e65-726566657250" -version = "1.2.5" +version = "1.3.0" [[deps.PrettyTables]] deps = ["Crayons", "Formatting", "Markdown", "Reexport", "Tables"] @@ -855,15 +851,15 @@ uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" [[deps.ProfileView]] deps = ["Cairo", "Colors", "FileIO", "FlameGraphs", "Graphics", "Gtk", "GtkObservables", "InteractiveUtils", "IntervalSets", "MethodAnalysis", "Preferences", "Profile", "UUIDs"] -git-tree-sha1 = "1638391c64d5ae2853b54823df3f98150dc202f3" +git-tree-sha1 = "17c95da7223ca01bccedde748ae4ccfebb494106" uuid = "c46f51b8-102a-5cf2-8d2c-8597cb0e0da7" -version = "1.5.0" +version = "1.5.1" [[deps.Qt5Base_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "xkbcommon_jll"] -git-tree-sha1 = "ad368663a5e20dbb8d6dc2fddeefe4dae0781ae8" +git-tree-sha1 = "c6c0f690d0cc7caddb74cef7aa847b824a16b256" uuid = "ea2cea3b-5b76-57ae-a6ef-0a8af62496e1" -version = "5.15.3+0" +version = "5.15.3+1" [[deps.QuadGK]] deps = ["DataStructures", "LinearAlgebra"] @@ -955,21 +951,15 @@ version = "0.6.6" [[deps.SpecialFunctions]] deps = ["ChainRulesCore", "IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] -git-tree-sha1 = "5ba658aeecaaf96923dce0da9e703bd1fe7666f9" +git-tree-sha1 = "a9e798cae4867e3a41cae2dd9eb60c047f1212db" uuid = "276daf66-3868-5448-9aa4-cd146d93841b" -version = "2.1.4" - -[[deps.Static]] -deps = ["IfElse"] -git-tree-sha1 = "87e9954dfa33fd145694e42337bdd3d5b07021a6" -uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" -version = "0.6.0" +version = "2.1.6" [[deps.StaticArrays]] deps = ["LinearAlgebra", "Random", "Statistics"] -git-tree-sha1 = "4f6ec5d99a28e1a749559ef7dd518663c5eca3d5" +git-tree-sha1 = "383a578bdf6e6721f480e749d503ebc8405a0b22" uuid = "90137ffa-7385-5640-81b9-e52037218182" -version = "1.4.3" +version = "1.4.6" [[deps.Statistics]] deps = ["LinearAlgebra", "SparseArrays"] @@ -977,9 +967,9 @@ uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" [[deps.StatsAPI]] deps = ["LinearAlgebra"] -git-tree-sha1 = "c3d8ba7f3fa0625b062b82853a7d5229cb728b6b" +git-tree-sha1 = "2c11d7290036fe7aac9038ff312d3b3a2a5bf89e" uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" -version = "1.2.1" +version = "1.4.0" [[deps.StatsBase]] deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] @@ -989,9 +979,9 @@ version = "0.33.16" [[deps.StructArrays]] deps = ["Adapt", "DataAPI", "StaticArrays", "Tables"] -git-tree-sha1 = "57617b34fa34f91d536eb265df67c2d4519b8b98" +git-tree-sha1 = "9abba8f8fb8458e9adf07c8a2377a070674a24f1" uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" -version = "0.6.5" +version = "0.6.8" [[deps.SuiteSparse]] deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"] @@ -1017,6 +1007,12 @@ version = "1.7.0" deps = ["ArgTools", "SHA"] uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +[[deps.TensorCore]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6" +uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50" +version = "0.1.1" + [[deps.Test]] deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" @@ -1075,9 +1071,9 @@ version = "1.14.2" [[deps.XML2_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "Zlib_jll"] -git-tree-sha1 = "1acf5bdf07aa0907e0a37d3718bb88d4b687b74a" +git-tree-sha1 = "58443b63fb7e465a8a7210828c91c08b92132dff" uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" -version = "2.9.12+0" +version = "2.9.14+0" [[deps.XSLT_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"] diff --git a/src/Distributed/Skeleton.jl b/src/Distributed/Skeleton.jl index 42a6723..e46b493 100644 --- a/src/Distributed/Skeleton.jl +++ b/src/Distributed/Skeleton.jl @@ -22,9 +22,10 @@ end function SkeletonTriangulation(portion::GridapDistributed.NoGhost, model::GridapDistributed.DistributedDiscreteModel) + cell_gids=get_cell_gids(model) dtrians=map_parts(model.models, _sign_flips(model), - model.gids.partition) do model, sign_flip, partition + cell_gids.partition) do model, sign_flip, partition cell_to_parent_cell= findall([partition.lid_to_part[cell]==partition.part for cell=1:length(partition.lid_to_part)]) From 7e2d9e94576cd628c89e65b2284dcac0d284cb80 Mon Sep 17 00:00:00 2001 From: amartin Date: Wed, 8 Jun 2022 10:01:09 +1000 Subject: [PATCH 11/11] Updating Manifest.toml to point to new release of GridapDistributed --- Manifest.toml | 2 -- Project.toml | 1 + 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/Manifest.toml b/Manifest.toml index 1554c26..b92f14d 100644 --- a/Manifest.toml +++ b/Manifest.toml @@ -377,8 +377,6 @@ version = "0.17.12" [[deps.GridapDistributed]] deps = ["FillArrays", "Gridap", "LinearAlgebra", "MPI", "PartitionedArrays", "SparseArrays", "SparseMatricesCSR", "WriteVTK"] git-tree-sha1 = "0b67924b214c9735db46071646e6ab1e1817eddd" -repo-rev = "master" -repo-url = "https://github.com/gridap/GridapDistributed.jl" uuid = "f9701e48-63b3-45aa-9a63-9bc6c271f355" version = "0.2.6" diff --git a/Project.toml b/Project.toml index 5f8870b..cd1d468 100644 --- a/Project.toml +++ b/Project.toml @@ -18,5 +18,6 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [compat] +GridapDistributed = "0.2.6" DrWatson = "1" Gridap = "0.17"