From 056c52318ec8d6f1a8eb9ad776d5b0ae20cc8ad0 Mon Sep 17 00:00:00 2001 From: Michael Kraus Date: Thu, 17 Dec 2020 20:41:40 +0100 Subject: [PATCH] Update for GeometricIntegrators v0.7. --- Manifest.toml | 723 ++++++++++++++++++++++ Project.toml | 2 +- src/poincare_invariant_1st.jl | 24 +- src/poincare_invariant_1st_canonical.jl | 17 +- src/poincare_invariant_2nd_approxfun.jl | 39 +- src/poincare_invariant_2nd_opq.jl | 14 +- src/poincare_invariant_2nd_trapezoidal.jl | 16 +- test/poincare_invariant_2nd_module.jl | 27 +- 8 files changed, 772 insertions(+), 90 deletions(-) create mode 100644 Manifest.toml diff --git a/Manifest.toml b/Manifest.toml new file mode 100644 index 0000000..13e7e05 --- /dev/null +++ b/Manifest.toml @@ -0,0 +1,723 @@ +# This file is machine-generated - editing it directly is not advised + +[[AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "051c95d6836228d120f5f4b984dd5aba1624f716" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "0.5.0" + +[[Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "42c42f2221906892ceb765dbcb1a51deeffd86d7" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "2.3.0" + +[[ApproxFun]] +deps = ["AbstractFFTs", "ApproxFunBase", "ApproxFunFourier", "ApproxFunOrthogonalPolynomials", "ApproxFunSingularities", "Calculus", "DomainSets", "DualNumbers", "FFTW", "FastTransforms", "LinearAlgebra", "RecipesBase", "Reexport"] +git-tree-sha1 = "a39b494a491b5590ff5e9cbda13c33b4ff781ccc" +uuid = "28f2ccd6-bb30-5033-b560-165f7b14dc2f" +version = "0.12.3" + +[[ApproxFunBase]] +deps = ["AbstractFFTs", "BandedMatrices", "BlockArrays", "BlockBandedMatrices", "Calculus", "DSP", "DomainSets", "DualNumbers", "FFTW", "FastGaussQuadrature", "FillArrays", "InfiniteArrays", "IntervalSets", "LazyArrays", "LinearAlgebra", "LowRankApprox", "SparseArrays", "SpecialFunctions", "StaticArrays", "Statistics", "Test", "ToeplitzMatrices"] +git-tree-sha1 = "76e0610192ad89b26ef5933fd7b25fb7a9fac312" +uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05" +version = "0.3.10" + +[[ApproxFunFourier]] +deps = ["AbstractFFTs", "ApproxFunBase", "DomainSets", "FFTW", "FastTransforms", "InfiniteArrays", "IntervalSets", "LinearAlgebra", "Reexport"] +git-tree-sha1 = "cdfb0cd01d8cc2cb13fe881c9f3c6cc93e22581e" +uuid = "59844689-9c9d-51bf-9583-5b794ec66d30" +version = "0.2.6" + +[[ApproxFunOrthogonalPolynomials]] +deps = ["AbstractFFTs", "ApproxFunBase", "BandedMatrices", "BlockArrays", "BlockBandedMatrices", "DomainSets", "FFTW", "FastGaussQuadrature", "FastTransforms", "FillArrays", "IntervalSets", "LinearAlgebra", "Reexport", "SpecialFunctions", "Statistics"] +git-tree-sha1 = "fd96f4d35bdc92127d6268fb4d9fda957287e325" +uuid = "b70543e2-c0d9-56b8-a290-0d4d6d4de211" +version = "0.3.8" + +[[ApproxFunSingularities]] +deps = ["ApproxFunBase", "ApproxFunOrthogonalPolynomials", "DomainSets", "IntervalSets", "LinearAlgebra", "Reexport", "Statistics"] +git-tree-sha1 = "f81dc4a9f09547b280183ebbdc79d2d91ff94c02" +uuid = "f8fcb915-6b99-5be2-b79a-d6dbef8e6e7e" +version = "0.2.0" + +[[Aqua]] +deps = ["Pkg", "Test"] +git-tree-sha1 = "b28b1f08e814090ef35eec6ab974264b3a93c862" +uuid = "4c88cf16-eb10-579e-8560-4a9242c79595" +version = "0.5.0" + +[[ArrayInterface]] +deps = ["LinearAlgebra", "Requires", "SparseArrays"] +git-tree-sha1 = "b7898df8dff4098db4a9494d2451c5c2edd4cb2c" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "2.14.5" + +[[ArrayLayouts]] +deps = ["Compat", "FillArrays", "LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "a577e27915fdcb3f6b96118b56655b38e3b466f2" +uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a" +version = "0.4.12" + +[[Artifacts]] +deps = ["Pkg"] +git-tree-sha1 = "c30985d8821e0cd73870b17b0ed0ce6dc44cb744" +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.3.0" + +[[BandedMatrices]] +deps = ["ArrayLayouts", "Compat", "FillArrays", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "8c83ee44dc9835263760ad4e77ed4eed4b3490c1" +uuid = "aae01518-5342-5314-be14-df237901396f" +version = "0.15.25" + +[[Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[BinaryProvider]] +deps = ["Libdl", "Logging", "SHA"] +git-tree-sha1 = "ecdec412a9abc8db54c0efc5548c64dfce072058" +uuid = "b99e7846-7c00-51b0-8f62-c81ae34c0232" +version = "0.5.10" + +[[BlockArrays]] +deps = ["ArrayLayouts", "Compat", "FillArrays", "LinearAlgebra"] +git-tree-sha1 = "824b1094a47d7da81f9ff77cb56c3341f2f92097" +uuid = "8e7c35d0-a365-5155-bbbb-fb81a777f24e" +version = "0.12.14" + +[[BlockBandedMatrices]] +deps = ["ArrayLayouts", "BandedMatrices", "BlockArrays", "Distributed", "FillArrays", "LinearAlgebra", "MatrixFactorizations", "Pkg", "SharedArrays", "SparseArrays", "Statistics"] +git-tree-sha1 = "50374b927844af8c21d31db10b833af39493eaca" +uuid = "ffab5731-97b5-5995-9138-79e8c1846df0" +version = "0.9.5" + +[[Blosc]] +deps = ["Blosc_jll"] +git-tree-sha1 = "84cf7d0f8fd46ca6f1b3e0305b4b4a37afe50fd6" +uuid = "a74b3585-a348-5f62-a45c-50e91977d574" +version = "0.7.0" + +[[Blosc_jll]] +deps = ["Libdl", "Lz4_jll", "Pkg", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "aa9ef39b54a168c3df1b2911e7797e4feee50fbe" +uuid = "0b7ba130-8d10-5ba8-a3d6-c5182647fed9" +version = "1.14.3+1" + +[[Calculus]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "f641eb0a4f00c343bbc32346e1217b86f3ce9dad" +uuid = "49dc2e85-a5d0-5ad3-a950-438e2897f1b9" +version = "0.5.1" + +[[CommonSubexpressions]] +deps = ["MacroTools", "Test"] +git-tree-sha1 = "7b8a93dba8af7e3b42fecabf646260105ac373f7" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.0" + +[[CompactBasisFunctions]] +deps = ["ContinuumArrays", "FastTransforms", "LinearAlgebra", "OffsetArrays", "QuadratureRules", "StaticArrays"] +git-tree-sha1 = "bca76931ee7889c755e3542c8ae1c2db2450fc84" +uuid = "a09551c4-f815-4143-809e-dd1986753ba7" +version = "0.2.1" + +[[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 = "919c7f3151e79ff196add81d7f4e45d91bbf420b" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "3.25.0" + +[[CompilerSupportLibraries_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "8e695f735fca77e9708e795eda62afdb869cbb70" +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "0.3.4+0" + +[[ContinuumArrays]] +deps = ["ArrayLayouts", "BandedMatrices", "FillArrays", "InfiniteArrays", "IntervalSets", "LazyArrays", "LinearAlgebra", "QuasiArrays"] +git-tree-sha1 = "3b3d622279a3f1fea36dabc3f9e1c6793647a88e" +uuid = "7ae1f121-cc2c-504b-ac30-9b923412ae5c" +version = "0.3.5" + +[[DSP]] +deps = ["FFTW", "IterTools", "LinearAlgebra", "Polynomials", "Random", "Reexport", "SpecialFunctions", "Statistics"] +git-tree-sha1 = "c80041f11f39c545b4d62e88f91cc417b0609765" +uuid = "717857b8-e6f2-59f4-9121-6e50c889abd2" +version = "0.6.9" + +[[DataAPI]] +git-tree-sha1 = "ad84f52c0b8f05aa20839484dbaf01690b41ff84" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.4.0" + +[[DataStructures]] +deps = ["Compat", "InteractiveUtils", "OrderedCollections"] +git-tree-sha1 = "fb0aa371da91c1ff9dc7fbed6122d3e411420b9c" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.18.8" + +[[Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" + +[[DecFP]] +deps = ["DecFP_jll", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "ea62e5dfc21d89107ebedd962cc615b0ccd2124a" +uuid = "55939f99-70c6-5e9b-8bb0-5071ed7d61fd" +version = "1.1.0" + +[[DecFP_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "ebc359a7d11bb63e3a3b87c36d07a88947640eb9" +uuid = "47200ebd-12ce-5be5-abb7-8e082af23329" +version = "2.0.2+0" + +[[DelimitedFiles]] +deps = ["Mmap"] +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" + +[[DiffResults]] +deps = ["StaticArrays"] +git-tree-sha1 = "c18e98cba888c6c25d1c3b048e4b3380ca956805" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.0.3" + +[[DiffRules]] +deps = ["NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "214c3fcac57755cfda163d91c58893a8723f93e9" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.0.2" + +[[Distances]] +deps = ["LinearAlgebra", "Statistics"] +git-tree-sha1 = "e8b13ba5f166e11df2de6fc283e5db7864245df0" +uuid = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7" +version = "0.10.0" + +[[Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" + +[[DocStringExtensions]] +deps = ["LibGit2", "Markdown", "Pkg", "Test"] +git-tree-sha1 = "50ddf44c53698f5e784bbebb3f4b21c5807401b1" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.8.3" + +[[Documenter]] +deps = ["Base64", "Dates", "DocStringExtensions", "IOCapture", "InteractiveUtils", "JSON", "LibGit2", "Logging", "Markdown", "REPL", "Test", "Unicode"] +git-tree-sha1 = "b7715ae18be02110a8cf9cc8ed2ccdb1e3e3aba2" +uuid = "e30172f5-a6a5-5a46-863b-614d45cd2de4" +version = "0.26.1" + +[[DomainSets]] +deps = ["IntervalSets", "LinearAlgebra", "StaticArrays", "Statistics", "Test"] +git-tree-sha1 = "7ba497e98b4d58d0b673c800957a2884a3b5d798" +uuid = "5b8099bc-c8ec-5219-889f-1d9e522a28bf" +version = "0.4.1" + +[[DoubleFloats]] +deps = ["GenericSVD", "GenericSchur", "LinearAlgebra", "Polynomials", "Printf", "Quadmath", "Random", "Requires", "SpecialFunctions"] +git-tree-sha1 = "3351fb3839b6967604f9abca62fd3c1f85875906" +uuid = "497a8b3b-efae-58df-a0af-a86822472b78" +version = "1.1.15" + +[[DualNumbers]] +deps = ["Calculus", "NaNMath", "SpecialFunctions"] +git-tree-sha1 = "a484a8051536b92b0ef36ff3d2cca68ab6d374b2" +uuid = "fa6b7ba4-c1ee-5f82-b5fc-ecf0adba8f74" +version = "0.6.3" + +[[EllipsisNotation]] +git-tree-sha1 = "65dad386e877850e6fce4fc77f60fe75a468ce9d" +uuid = "da5c29d0-fa7d-589e-88eb-ea29b0a81949" +version = "0.4.0" + +[[ExprTools]] +git-tree-sha1 = "10407a39b87f29d47ebaca8edbc75d7c302ff93e" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.3" + +[[EzXML]] +deps = ["Printf", "XML2_jll"] +git-tree-sha1 = "0fa3b52a04a4e210aeb1626def9c90df3ae65268" +uuid = "8f5d6c58-4d21-5cfd-889c-e3ad7ee6a615" +version = "1.1.0" + +[[FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "IntelOpenMP_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Reexport"] +git-tree-sha1 = "8b7c16b56936047ca41bf25effa137ae0b381ae8" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.2.4" + +[[FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "f10c3009373a2d5c4349b8a2932d8accb892892d" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.9+6" + +[[FastGaussQuadrature]] +deps = ["LinearAlgebra", "SpecialFunctions"] +git-tree-sha1 = "3a4939db42fbed6d52c81190ca39afc5017c9841" +uuid = "442a2c76-b920-505d-bb47-c5924d526838" +version = "0.4.4" + +[[FastTransforms]] +deps = ["AbstractFFTs", "ArrayLayouts", "BinaryProvider", "DSP", "FFTW", "FastGaussQuadrature", "FastTransforms_jll", "FillArrays", "Libdl", "LinearAlgebra", "Reexport", "SpecialFunctions", "Test", "ToeplitzMatrices"] +git-tree-sha1 = "4ad358e013a441afcad34250d65de7caa3dc9c0a" +uuid = "057dd010-8810-581a-b7be-e3fc3b93f78c" +version = "0.11.1" + +[[FastTransforms_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "FFTW_jll", "JLLWrappers", "Libdl", "MPFR_jll", "OpenBLAS_jll", "Pkg"] +git-tree-sha1 = "a3307d3b79e0e97a8d0eb6ac1939aea90c243ce2" +uuid = "34b6f7d7-08f9-5794-9e10-3819e4c7e49a" +version = "0.4.1+0" + +[[FillArrays]] +deps = ["LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "c1cf9e87a5c45f0c05dc31ae95757f706e70865a" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "0.10.1" + +[[FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Requires", "SparseArrays", "StaticArrays"] +git-tree-sha1 = "7f7216e0eb46c20ee8ddab5c8f9a262ed72587b6" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.7.2" + +[[ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "NaNMath", "Random", "SpecialFunctions", "StaticArrays"] +git-tree-sha1 = "8de2519a83c6c1c2442c2f481dd9a8364855daf4" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "0.10.14" + +[[GMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "15abc5f976569a1c9d651aff02f7222ef305eb2a" +uuid = "781609d7-10c4-51f6-84f2-b8444358ff6d" +version = "6.1.2+6" + +[[GenericLinearAlgebra]] +deps = ["LinearAlgebra", "Printf", "Random"] +git-tree-sha1 = "29a74c7ff32df6eb40c3cb4a5252db14fd33b9f2" +uuid = "14197337-ba66-59df-a3e3-ca00e7dcff7a" +version = "0.2.4" + +[[GenericSVD]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "62909c3eda8a25b5673a367d1ad2392ebb265211" +uuid = "01680d73-4ee2-5a08-a1aa-533608c188bb" +version = "0.3.0" + +[[GenericSchur]] +deps = ["LinearAlgebra", "Printf"] +git-tree-sha1 = "43b4dc5648028be2c6e96201aa3653903bd1af21" +uuid = "c145ed77-6b09-5dd9-b285-bf645a82121e" +version = "0.4.0" + +[[GeometricIntegrators]] +deps = ["Aqua", "CompactBasisFunctions", "DecFP", "DelimitedFiles", "Documenter", "ForwardDiff", "GenericLinearAlgebra", "HDF5", "LinearAlgebra", "NLsolve", "OffsetArrays", "Parameters", "Polynomials", "Printf", "ProgressMeter", "QuadratureRules", "Random", "Reexport", "SharedArrays", "SimpleSolvers"] +git-tree-sha1 = "bcfacbc2362b0604d59dca015ce03a0e1d71c514" +repo-rev = "master" +repo-url = "https://github.com/JuliaGNI/GeometricIntegrators.jl.git" +uuid = "dcce2d33-59f6-5b8d-9047-0defad88ae06" +version = "0.7.0" + +[[HDF5]] +deps = ["Blosc", "Compat", "HDF5_jll", "Libdl", "Mmap", "Random", "Requires"] +git-tree-sha1 = "8be8b31df938483ba2ab27f38a8bc91a9e43ae92" +uuid = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f" +version = "0.14.3" + +[[HDF5_jll]] +deps = ["Artifacts", "JLLWrappers", "LibCURL_jll", "Libdl", "OpenSSL_jll", "Pkg", "Zlib_jll"] +git-tree-sha1 = "fd83fa0bde42e01952757f01149dd968c06c4dba" +uuid = "0234f1f7-429e-5d53-9886-15a909be8d59" +version = "1.12.0+1" + +[[IOCapture]] +deps = ["Logging"] +git-tree-sha1 = "377252859f740c217b936cebcd918a44f9b53b59" +uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89" +version = "0.1.1" + +[[InfiniteArrays]] +deps = ["DSP", "FillArrays", "LazyArrays", "LinearAlgebra", "Statistics"] +git-tree-sha1 = "eccce647e5ed82e1c3d39868ae3868904bf214d4" +uuid = "4858937d-0d70-526a-a4dd-2d5cb5dd786c" +version = "0.8.3" + +[[IntelOpenMP_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "fb8e1c7a5594ba56f9011310790e03b5384998d6" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2018.0.3+0" + +[[InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[IntervalSets]] +deps = ["Dates", "EllipsisNotation", "Statistics"] +git-tree-sha1 = "3b1cef135bc532b3c3401b309e1b8a2a2ba26af5" +uuid = "8197267c-284f-5f27-9208-e0e47529a953" +version = "0.5.1" + +[[Intervals]] +deps = ["Dates", "Printf", "RecipesBase", "Serialization", "TimeZones"] +git-tree-sha1 = "323a38ed1952d30586d0fe03412cde9399d3618b" +uuid = "d8418881-c3e1-53bb-8760-2df7ec849ed5" +version = "1.5.0" + +[[IterTools]] +git-tree-sha1 = "05110a2ab1fc5f932622ffea2a003221f4782c18" +uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e" +version = "1.3.0" + +[[JLLWrappers]] +git-tree-sha1 = "c70593677bbf2c3ccab4f7500d0f4dacfff7b75c" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.1.3" + +[[JSON]] +deps = ["Dates", "Mmap", "Parsers", "Unicode"] +git-tree-sha1 = "81690084b6198a2e1da36fcfda16eeca9f9f24e4" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "0.21.1" + +[[LazyArrays]] +deps = ["ArrayLayouts", "FillArrays", "LinearAlgebra", "MacroTools", "MatrixFactorizations", "SparseArrays", "StaticArrays"] +git-tree-sha1 = "62b5b31a3c89d7c673b9f2eb1119084ad3420dc7" +uuid = "5078a376-72f3-5289-bfd5-ec5146d43c02" +version = "0.19.4" + +[[LibCURL_jll]] +deps = ["LibSSH2_jll", "Libdl", "MbedTLS_jll", "Pkg", "Zlib_jll", "nghttp2_jll"] +git-tree-sha1 = "897d962c20031e6012bba7b3dcb7a667170dad17" +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "7.70.0+2" + +[[LibGit2]] +deps = ["Printf"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" + +[[LibSSH2_jll]] +deps = ["Libdl", "MbedTLS_jll", "Pkg"] +git-tree-sha1 = "717705533148132e5466f2924b9a3657b16158e8" +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.9.0+3" + +[[Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "8e924324b2e9275a51407a4e06deb3455b1e359f" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.16.0+7" + +[[LineSearches]] +deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf"] +git-tree-sha1 = "d6e6b2ed397a402a22e474a3f1859c8c1db82c8c" +uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +version = "7.1.0" + +[[LinearAlgebra]] +deps = ["Libdl"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[LowRankApprox]] +deps = ["FFTW", "FillArrays", "LinearAlgebra", "Nullables", "Random", "SparseArrays", "Test"] +git-tree-sha1 = "8cac2a8fea8e28ba7da2fa91b3eac68de2cbf3ff" +uuid = "898213cb-b102-5a47-900c-97e73b919f73" +version = "0.4.2" + +[[Lz4_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "51b1db0732bbdcfabb60e36095cc3ed9c0016932" +uuid = "5ced341a-0733-55b8-9ab6-a4889d929147" +version = "1.9.2+2" + +[[MKL_jll]] +deps = ["IntelOpenMP_jll", "Libdl", "Pkg"] +git-tree-sha1 = "eb540ede3aabb8284cb482aa41d00d6ca850b1f8" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2020.2.254+0" + +[[MPFR_jll]] +deps = ["GMP_jll", "Libdl", "Pkg"] +git-tree-sha1 = "301ce96952df90bbaa2c66112b7c1f15ced2b55b" +uuid = "3a97d323-0669-5f0c-9066-3539efd106a3" +version = "4.1.0+1" + +[[MacroTools]] +deps = ["Markdown", "Random"] +git-tree-sha1 = "6a8a2a625ab0dea913aba95c11370589e0239ff0" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.6" + +[[Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[MatrixFactorizations]] +deps = ["ArrayLayouts", "LinearAlgebra", "Random"] +git-tree-sha1 = "292e5f9f0761f3511edfb5420b4feadd9ba165b0" +uuid = "a3b82374-2e81-5b9e-98ce-41277c0e4c87" +version = "0.6.1" + +[[MbedTLS_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "0eef589dd1c26a3ac9d753fe1a8bcad63f956fa6" +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.16.8+1" + +[[Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "ed61674a0864832495ffe0a7e889c0da76b0f4c8" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "0.4.4" + +[[Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" + +[[Mocking]] +deps = ["ExprTools"] +git-tree-sha1 = "916b850daad0d46b8c71f65f719c49957e9513ed" +uuid = "78c3b35d-d492-501b-9361-3d52fe80e533" +version = "0.7.1" + +[[NLSolversBase]] +deps = ["DiffResults", "Distributed", "FiniteDiff", "ForwardDiff"] +git-tree-sha1 = "39d6bc45e99c96e6995cbddac02877f9b61a1dd1" +uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" +version = "7.7.1" + +[[NLsolve]] +deps = ["Distances", "LineSearches", "LinearAlgebra", "NLSolversBase", "Printf", "Reexport"] +git-tree-sha1 = "e7fcfb6107b412241bff2a7901b80136fe1f0b71" +uuid = "2774e3e8-f4cf-5e23-947b-6d7e65073b56" +version = "4.5.0" + +[[NaNMath]] +git-tree-sha1 = "bfe47e760d60b82b66b61d2d44128b62e3a369fb" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "0.3.5" + +[[Nullables]] +git-tree-sha1 = "8f87854cc8f3685a60689d8edecaa29d2251979b" +uuid = "4d1e1d77-625e-5b40-9113-a560ec7a8ecd" +version = "1.0.0" + +[[OffsetArrays]] +deps = ["Adapt"] +git-tree-sha1 = "45d5e495ab559357aee8cb1dfb8c12b0787d4545" +uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" +version = "1.4.1" + +[[OpenBLAS_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl", "Pkg"] +git-tree-sha1 = "0c922fd9634e358622e333fc58de61f05a048492" +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.9+5" + +[[OpenSSL_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "71bbbc616a1d710879f5a1021bcba65ffba6ce58" +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "1.1.1+6" + +[[OpenSpecFun_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "9db77584158d0ab52307f8c04f8e7c08ca76b5b3" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.3+4" + +[[OrderedCollections]] +git-tree-sha1 = "cf59cfed2e2c12e8a2ff0a4f1e9b2cd8650da6db" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.3.2" + +[[Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "38b2e970043613c187bd56a995fe2e551821eb4a" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.1" + +[[Parsers]] +deps = ["Dates"] +git-tree-sha1 = "50c9a9ed8c714945e01cd53a21007ed3865ed714" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "1.0.15" + +[[Pkg]] +deps = ["Dates", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "UUIDs"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" + +[[Polynomials]] +deps = ["Intervals", "LinearAlgebra", "OffsetArrays", "RecipesBase"] +git-tree-sha1 = "1c6c5b0c3713738d6b987903c529d80622c37e07" +uuid = "f27b6e38-b328-58d1-80ce-0feddd5e7a45" +version = "1.2.0" + +[[Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[ProgressMeter]] +deps = ["Distributed", "Printf"] +git-tree-sha1 = "45640774ee2efa24e52686dbdf895e88102e68fc" +uuid = "92933f4c-e287-5a05-a399-4b506db050ca" +version = "1.4.1" + +[[Quadmath]] +deps = ["Printf", "Random", "Requires"] +git-tree-sha1 = "cd993c45147a8432bf24358f14bf2cfd4aeb14df" +uuid = "be4d8f0f-7fa4-5f49-b795-2f01399ab2dd" +version = "0.5.4" + +[[QuadratureRules]] +deps = ["FastGaussQuadrature", "GenericLinearAlgebra", "Polynomials"] +git-tree-sha1 = "bf68e1589b1b771c1ca58bf42212c27c7668e491" +uuid = "a08977f5-a20d-4b99-b11f-f5ea535e0575" +version = "0.1.2" + +[[QuasiArrays]] +deps = ["ArrayLayouts", "LazyArrays", "LinearAlgebra"] +git-tree-sha1 = "2aa6247222bb374483b0a8c471869af1f82a25a5" +uuid = "c4ea9172-b204-11e9-377d-29865faadc5c" +version = "0.3.6" + +[[REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[Random]] +deps = ["Serialization"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[RecipesBase]] +git-tree-sha1 = "b3fb709f3c97bfc6e948be68beeecb55a0b340ae" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.1.1" + +[[Reexport]] +deps = ["Pkg"] +git-tree-sha1 = "7b1d07f411bc8ddb7977ec7f377b97b158514fe0" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "0.2.0" + +[[Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "cfbac6c1ed70c002ec6361e7fd334f02820d6419" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.1.2" + +[[SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" + +[[Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[SharedArrays]] +deps = ["Distributed", "Mmap", "Random", "Serialization"] +uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" + +[[SimpleSolvers]] +deps = ["ForwardDiff", "LineSearches", "LinearAlgebra", "NLsolve", "Printf"] +git-tree-sha1 = "3719b913d4f4525a8dc579d3f612cc90d74ec843" +uuid = "36b790f5-6434-4fbe-b711-1f64a1e2f6a2" +version = "0.1.1" + +[[Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[SortingAlgorithms]] +deps = ["DataStructures", "Random", "Test"] +git-tree-sha1 = "03f5898c9959f8115e30bc7226ada7d0df554ddd" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "0.3.1" + +[[SparseArrays]] +deps = ["LinearAlgebra", "Random"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[SpecialFunctions]] +deps = ["OpenSpecFun_jll"] +git-tree-sha1 = "d8d8b8a9f4119829410ecd706da4cc8594a1e020" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "0.10.3" + +[[StaticArrays]] +deps = ["LinearAlgebra", "Random", "Statistics"] +git-tree-sha1 = "da4cf579416c81994afd6322365d00916c79b8ae" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "0.12.5" + +[[Statistics]] +deps = ["LinearAlgebra", "SparseArrays"] +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[StatsBase]] +deps = ["DataAPI", "DataStructures", "LinearAlgebra", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics"] +git-tree-sha1 = "7bab7d4eb46b225b35179632852b595a3162cb61" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.33.2" + +[[Test]] +deps = ["Distributed", "InteractiveUtils", "Logging", "Random"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[TimeZones]] +deps = ["Dates", "EzXML", "Mocking", "Pkg", "Printf", "RecipesBase", "Serialization", "Unicode"] +git-tree-sha1 = "4ba8a9579a243400db412b50300cd61d7447e583" +uuid = "f269a46b-ccf7-5d73-abea-4c690281aa53" +version = "1.5.3" + +[[ToeplitzMatrices]] +deps = ["AbstractFFTs", "FFTW", "LinearAlgebra", "StatsBase"] +git-tree-sha1 = "e318629aa5ff8894f63a198b22788253d67fe3b1" +uuid = "c751599d-da0a-543b-9d20-d0a503d91d24" +version = "0.6.2" + +[[UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[[UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + +[[Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" + +[[XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "Zlib_jll"] +git-tree-sha1 = "be0db24f70aae7e2b89f2f3092e93b8606d659a6" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.9.10+3" + +[[Zlib_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "320228915c8debb12cb434c59057290f0834dbf6" +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.11+18" + +[[Zstd_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "6f1abcb0c44f184690912aa4b0ba861dd64f11b9" +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.4.5+2" + +[[nghttp2_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "8e2c44ab4d49ad9518f359ed8b62f83ba8beede4" +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.40.0+2" diff --git a/Project.toml b/Project.toml index ef26b57..f8591f0 100644 --- a/Project.toml +++ b/Project.toml @@ -20,7 +20,7 @@ ApproxFun = "0.10, 0.11, 0.12" Documenter = "0.23, 0.24, 0.25, 0.26" DoubleFloats = "1" FFTW = "1" -GeometricIntegrators = "0.5, 0.6" +GeometricIntegrators = "0.7" HDF5 = "0.10, 0.12, 0.13, 0.14" OffsetArrays = "1" ProgressMeter = "1" diff --git a/src/poincare_invariant_1st.jl b/src/poincare_invariant_1st.jl index ec170af..716c0e5 100644 --- a/src/poincare_invariant_1st.jl +++ b/src/poincare_invariant_1st.jl @@ -27,11 +27,7 @@ function PoincareInvariant1st(f_equ::Function, f_loop::Function, Θ::ΘT, Δt::T end # compute initial conditions - q₀ = zeros(DT, (d, nloop)) - - for i in 1:nloop - q₀[:,i] .= f_loop(i/nloop) - end + q₀ = [f_loop(i/nloop) for i in 1:nloop] # initialise euation equ = f_equ(q₀) @@ -48,10 +44,10 @@ end function evaluate_poincare_invariant(pinv::PoincareInvariant1st, sol::Solution) - p = zero(sol.q) - g = zero(sol.q) - v = zeros(size(sol.q,1), size(sol.q,3)) - γ = zeros(size(sol.q,1), size(sol.q,3)) + p = zeros(size(sol.q[begin],1), size(sol.q,1), size(sol.q,2)) + g = zeros(size(sol.q[begin],1), size(sol.q,1), size(sol.q,2)) + v = zeros(size(sol.q[begin],1), size(sol.q,2)) + γ = zeros(size(sol.q[begin],1), size(sol.q,2)) compute_one_form(sol.t, sol.q, p, pinv.Θ) @@ -59,16 +55,16 @@ function evaluate_poincare_invariant(pinv::PoincareInvariant1st, sol::Solution) compute_correction(sol.t, sol.q, sol.λ, g, pinv.equ.g) end - for i in axes(sol.q,2) - compute_velocity(sol.q[:,i,:], v) - pinv.I[i] = compute_loop_integral(p[:,i,:], v) + for i in axes(sol.q,1) + compute_velocity(hcat(sol.q[i,:]...), v) + pinv.I[i] = compute_loop_integral(hcat(sol.p[i,:]...), v) if isdefined(sol, :p) - pinv.J[i] = compute_loop_integral(sol.d[:,i,:], v) + pinv.J[i] = compute_loop_integral(hcat(sol.d[i,:]...), v) end if isdefined(sol, :λ) - compute_velocity(sol.λ[:,i,:], γ) + compute_velocity(hcat(sol.λ[i,:]...), γ) pinv.L[i] = compute_loop_integral(p[:,i,:] .- pinv.Δt .* g[:,i,:], v .- pinv.Δt .* γ) end end diff --git a/src/poincare_invariant_1st_canonical.jl b/src/poincare_invariant_1st_canonical.jl index ea274b5..43ceb7e 100644 --- a/src/poincare_invariant_1st_canonical.jl +++ b/src/poincare_invariant_1st_canonical.jl @@ -24,13 +24,8 @@ function PoincareInvariant1stCanonical(f_equ::Function, f_loop_q::Function, f_lo end # compute initial conditions - q₀ = zeros(DT, (d, nloop)) - p₀ = zeros(DT, (d, nloop)) - - for i in 1:nloop - q₀[:,i] .= f_loop_q(i/nloop) - p₀[:,i] .= f_loop_p(i/nloop) - end + q₀ = [f_loop_q(i/nloop) for i in 1:nloop] + p₀ = [f_loop_p(i/nloop) for i in 1:nloop] # initialise euation equ = f_equ(q₀, p₀) @@ -45,11 +40,11 @@ end function evaluate_poincare_invariant(pinv::PoincareInvariant1stCanonical, sol::SolutionPODE) - v = zeros(size(sol.q,1), size(sol.q,3)) + v = zeros(size(sol.q[begin],1), size(sol.q,2)) - for i in axes(sol.q,2) - compute_velocity(sol.q[:,i,:], v) - pinv.I[i] = compute_loop_integral(sol.p[:,i,:], v) + for i in axes(sol.q,1) + compute_velocity(hcat(sol.q[i,:]...), v) + pinv.I[i] = compute_loop_integral(hcat(sol.p[i,:]...), v) end pinv.I diff --git a/src/poincare_invariant_2nd_approxfun.jl b/src/poincare_invariant_2nd_approxfun.jl index cd41e2e..dcbebdd 100644 --- a/src/poincare_invariant_2nd_approxfun.jl +++ b/src/poincare_invariant_2nd_approxfun.jl @@ -28,11 +28,7 @@ function PoincareInvariant2ndApproxFun(f_equ::Function, f_surface::Function, ω: c = ApproxFun.points(ApproxFun.Chebyshev(0..1)^2, nx*ny) # compute initial conditions - q₀ = zeros(DT, (nd, length(c))) - - for i in eachindex(c) - q₀[:,i] .= f_surface(c[i][1], c[i][2]) - end + q₀ = [f_surface(c[i][1], c[i][2]) for i in eachindex(c)] # initialise euation equ = f_equ(q₀) @@ -53,7 +49,7 @@ function PoincareInvariant2ndApproxFun(f_equ::Function, f_surface::Function, ω: Dx = ApproxFun.Derivative(SC, [1,0]) Dy = ApproxFun.Derivative(SC, [0,1]) - fqc = Fun(SC, ApproxFun.transform(SC, q₀[1,:])) + fqc = Fun(SC, ApproxFun.transform(SC, hcat(q₀...)[1,:])) fqu = Fun(Dx * fqc, SU) nc = ApproxFun.ncoefficients(fqu) nv = length(ApproxFun.values(fqu)) @@ -98,18 +94,18 @@ function evaluate_poincare_invariant(pinv::PoincareInvariant2ndApproxFun{DT}, so # local λ = permutedims(sol.λ, [3,1,2]) # end - verbosity ≤ 1 ? prog = Progress(size(sol.q,2), 5) : nothing + verbosity ≤ 1 ? prog = Progress(size(sol.q,1), 5) : nothing - for i in axes(sol.q,2) + for i in axes(sol.q,1) verbosity > 1 ? println(" it = ", i) : nothing - pinv.I[i] = compute_noncanonical_invariant(pinv, sol.t[i], sol.q[:,i,:]) + pinv.I[i] = compute_noncanonical_invariant(pinv, sol.t[i], hcat(sol.q[i,:]...)) pinv.ΔI[i] = abs(pinv.I[0]) < sqrt(eps()) ? pinv.I[i] : (pinv.I[i] .- pinv.I[0]) ./ pinv.I[0] verbosity > 1 ? println(" I_q = ", pinv.I[i], ", ε_q = ", pinv.ΔI[i]) : nothing end if isdefined(sol, :p) - for i in axes(sol.q,2) - pinv.J[i] = compute_canonical_invariant(pinv, sol.q[:,i,:], sol.p[:,i,:]) + for i in axes(sol.q,1) + pinv.J[i] = compute_canonical_invariant(pinv, hcat(sol.q[i,:]...), hcat(sol.p[i,:]...)) pinv.ΔJ[i] = abs(pinv.J[0]) < sqrt(eps()) ? pinv.J[i] : (pinv.J[i] .- pinv.J[0]) ./ pinv.J[0] verbosity > 1 ? println(" I_p = ", pinv.J[i], ", ε_p = ", pinv.ΔJ[i]) : nothing end @@ -124,8 +120,8 @@ function evaluate_poincare_invariant_correction(pinv::PoincareInvariant2ndApprox local verbosity = get_config(:verbosity) if isdefined(sol, :λ) - for i in axes(sol.q,2) - pinv.K[i] = compute_noncanonical_correction(pinv, sol.t[i], sol.q[:,i,:], sol.λ[:,i,:]) + for i in axes(sol.q,1) + pinv.K[i] = compute_noncanonical_correction(pinv, sol.t[i], hcat(sol.q[i,:]...), hcat(sol.λ[i,:]...)) pinv.L[i] = pinv.I[i] - pinv.Δt^2 * pinv.K[i] verbosity > 1 ? println(" I_λ = ", pinv.L[i], ", ε_λ = ", (pinv.L[i]-pinv.L[0])/pinv.L[0]) : nothing verbosity > 1 ? println(" K_λ = ", pinv.K[i]) : nothing @@ -185,13 +181,8 @@ function PoincareInvariant2ndApproxFunCanonical(f_equ::Function, f_surface_q::Fu c = ApproxFun.points(ApproxFun.Chebyshev(0..1)^2, nx*ny) # compute initial conditions - q₀ = zeros(DT, (nd, length(c))) - p₀ = zeros(DT, (nd, length(c))) - - for i in eachindex(c) - q₀[:,i] .= f_surface_q(c[i][1], c[i][2]) - p₀[:,i] .= f_surface_p(c[i][1], c[i][2]) - end + q₀ = [f_surface_q(c[i][1], c[i][2]) for i in eachindex(c)] + p₀ = [f_surface_p(c[i][1], c[i][2]) for i in eachindex(c)] # initialise euation equ = f_equ(q₀, p₀) @@ -208,7 +199,7 @@ function PoincareInvariant2ndApproxFunCanonical(f_equ::Function, f_surface_q::Fu Dx = ApproxFun.Derivative(SC, [1,0]) Dy = ApproxFun.Derivative(SC, [0,1]) - fq = Fun(Dx * Fun(SC, ApproxFun.transform(SC, q₀[1,:])), SU) + fq = Fun(Dx * Fun(SC, ApproxFun.transform(SC, hcat(q₀...)[1,:])), SU) nc = ApproxFun.ncoefficients(fq) nv = length(ApproxFun.values(fq)) @@ -220,11 +211,11 @@ end function evaluate_poincare_invariant(pinv::PoincareInvariant2ndApproxFunCanonical{DT}, sol::Solution) where {DT} local verbosity = get_config(:verbosity) - verbosity ≤ 1 ? prog = Progress(size(sol.q,2), 5) : nothing + verbosity ≤ 1 ? prog = Progress(size(sol.q,1), 5) : nothing - for i in axes(sol.q,2) + for i in axes(sol.q,1) verbosity > 1 ? println(" it = ", i) : nothing - pinv.I[i] = compute_canonical_invariant(pinv, sol.q[:,i,:], sol.p[:,i,:]) + pinv.I[i] = compute_canonical_invariant(pinv, hcat(sol.q[i,:]...), hcat(sol.p[i,:]...)) verbosity > 1 ? println(" I_p = ", pinv.I[i], ", ε_p = ", (pinv.I[i]-pinv.I[0])/pinv.I[0]) : nothing verbosity ≤ 1 ? next!(prog) : nothing diff --git a/src/poincare_invariant_2nd_opq.jl b/src/poincare_invariant_2nd_opq.jl index e47217e..31e3506 100644 --- a/src/poincare_invariant_2nd_opq.jl +++ b/src/poincare_invariant_2nd_opq.jl @@ -47,15 +47,9 @@ function PoincareInvariant2ndOPQ(f_equ::Function, f_surface::Function, ω::ΩT, xGrid = OPQ.grid(OPQ.ChebyshevT()[:,1:nx]) yGrid = OPQ.grid(OPQ.ChebyshevT()[:,1:ny]) - q₀ = zeros(DT, (d, nx, ny)) + q₀ = reshape([f_surface((xGrid[i] + 1) / 2, (yGrid[j] + 1) / 2) for i in 1:nx, j in 1:ny], nx*ny) - for j in 1:ny - for i in 1:nx - q₀[:,i,j] = f_surface((xGrid[i] + 1) / 2, (yGrid[j] + 1) / 2) - end - end - - equ = f_equ(reshape(q₀, (d, nx*ny))) + equ = f_equ(q₀) # compute initial conditions @@ -452,12 +446,12 @@ function evaluate_poincare_invariant(pinv::PoincareInvariant2ndOPQ{DT}, sol::Sol for i in axes(sol.q,2) verbosity > 1 ? println(" it = ", i) : nothing - @views pinv.I[i] = surface_integral(pinv, sol.t[i], sol.q[:,i,:]) + @views pinv.I[i] = surface_integral(pinv, sol.t[i], hcat(sol.q[i,:]...)) pinv.ΔI[i] = abs(pinv.I[0]) < sqrt(eps()) ? pinv.I[i] : (pinv.I[i] .- pinv.I[0]) ./ pinv.I[0] verbosity > 1 ? println(" I_q = ", pinv.I[i], ", ε_q = ", pinv.ΔI[i]) : nothing # if hasproperty(sol, :p) - # pinv.J[i] = surface_integral_canonical(pinv, sol.q[:,i,:], sol.p[:,i,:]) + # pinv.J[i] = surface_integral_canonical(pinv, hcat(sol.q[i,:]...), hcat(sol.p[i,:]...)) # pinv.ΔJ[i] = abs(pinv.J[0]) < sqrt(eps()) ? pinv.J[i] : (pinv.J[i] .- pinv.J[0]) ./ pinv.J[0] # verbosity > 1 ? println(" I_p = ", pinv.J[i], ", ε_p = ", pinv.ΔJ[i]) : nothing # end diff --git a/src/poincare_invariant_2nd_trapezoidal.jl b/src/poincare_invariant_2nd_trapezoidal.jl index 01a56f2..300bf40 100644 --- a/src/poincare_invariant_2nd_trapezoidal.jl +++ b/src/poincare_invariant_2nd_trapezoidal.jl @@ -30,15 +30,9 @@ function PoincareInvariant2ndTrapezoidal(f_equ::Function, f_surface::Function, end # compute initial conditions - q₀ = zeros(DT, (d, nx, ny)) + q₀ = reshape([f_surface(i/nx, j/ny) for i in 1:nx, j in 1:ny], nx*ny) - for j in 1:ny - for i in 1:nx - q₀[:,i,j] = f_surface(i/nx, j/ny) - end - end - - equ = f_equ(reshape(q₀, (d, nx*ny))) + equ = f_equ(q₀) # create arrays for results nt = div(ntime, nsave) @@ -211,14 +205,14 @@ end function evaluate_poincare_invariant(pinv::PoincareInvariant2ndTrapezoidal{DT}, sol::Solution) where {DT} local verbosity = get_config(:verbosity) - for i in axes(sol.q,2) + for i in axes(sol.q,1) verbosity > 1 ? println(" it = ", i) : nothing - @views pinv.I[i] = surface_integral(sol.t[i], sol.q[:,i,:], pinv.ω, pinv.nx, pinv.ny) + @views pinv.I[i] = surface_integral(sol.t[i], hcat(sol.q[i,:]...), pinv.ω, pinv.nx, pinv.ny) pinv.ΔI[i] = abs(pinv.I[0]) < sqrt(eps()) ? pinv.I[i] : (pinv.I[i] .- pinv.I[0]) ./ pinv.I[0] verbosity > 1 ? println(" I_q = ", pinv.I[i], ", ε_q = ", pinv.ΔI[i]) : nothing if hasproperty(sol, :p) - @views pinv.J[i] = surface_integral_canonical(sol.q[:,i,:], sol.p[:,i,:], pinv.nx, pinv.ny) + @views pinv.J[i] = surface_integral_canonical(hcat(sol.q[i,:]...), hcat(sol.p[i,:]...), pinv.nx, pinv.ny) pinv.ΔJ[i] = abs(pinv.J[0]) < sqrt(eps()) ? pinv.J[i] : (pinv.J[i] .- pinv.J[0]) ./ pinv.J[0] verbosity > 1 ? println(" I_p = ", pinv.J[i], ", ε_p = ", pinv.ΔJ[i]) : nothing end diff --git a/test/poincare_invariant_2nd_module.jl b/test/poincare_invariant_2nd_module.jl index 0621726..d1bc191 100644 --- a/test/poincare_invariant_2nd_module.jl +++ b/test/poincare_invariant_2nd_module.jl @@ -28,6 +28,12 @@ module PoincareInvariant2ndTest nothing end + function gcϑ(t, q) + ϑ = zero(q) + gcϑ(t, q, ϑ) + return ϑ + end + function gcω(t, q, Ω) Ω[1,1] = 0 Ω[1,2] =-B(t,q) @@ -62,10 +68,7 @@ module PoincareInvariant2ndTest end function gc_surface_p(s,t) - q = gc_surface_q(s,t) - p = zero(q) - gcϑ(zero(eltype(q)), q, p) - p + gcϑ(0, gc_surface_q(s,t)) end function gc_dummy(t, a, b, c) @@ -77,21 +80,7 @@ module PoincareInvariant2ndTest end function gc_dummy_iode(q₀) - p₀ = zero(q₀) - - if ndims(q₀) == 1 - gcϑ(zero(eltype(q₀)), q₀, p₀) - else - tq = zeros(eltype(q₀), size(q₀,1)) - tp = zeros(eltype(p₀), size(p₀,1)) - - for i in axes(q₀,2) - tq .= q₀[:,i] - gcϑ(zero(eltype(q₀)), tq, tp) - p₀[:,i] .= tp - end - end - + p₀ = [gcϑ(0,q) for q in q₀] IODE(gc_dummy, gc_dummy, gc_dummy, q₀, p₀; v̄=gc_dummy) end